---input---
;;;; TYPEP und Verwandtes
;;;; Michael Stoll, 21. 10. 1988
;;;; Bruno Haible, 10.6.1989
;;;; Sam Steingold 2000-2005

;;; Datenstrukturen für TYPEP:
;;; - Ein Type-Specifier-Symbol hat auf seiner Propertyliste unter dem
;;;   Indikator SYS::TYPE-SYMBOL eine Funktion von einem Argument, die
;;;   testet, ob ein Objekt vom richtigen Typ ist.
;;; - Ein Symbol, das eine Type-Specifier-Liste beginnen kann, hat auf seiner
;;;   Propertyliste unter dem Indikator SYS::TYPE-LIST eine Funktion von
;;;   einem Argument für das zu testende Objekt und zusätzlichen Argumenten
;;;   für die Listenelemente.
;;; - Ein Symbol, das als Typmacro definiert wurde, hat auf seiner Property-
;;;   liste unter dem Indikator SYSTEM::DEFTYPE-EXPANDER den zugehörigen
;;;   Expander: eine Funktion, die den zu expandierenden Type-Specifier (eine
;;;   mindestens einelementige Liste) als Argument bekommt.

(in-package "EXT")
(export '(type-expand))
(in-package "SYSTEM")

; vorläufig, solange bis clos.lisp geladen wird:
(eval-when (eval)
  (predefun clos::built-in-class-p (object) (declare (ignore object)) nil))
(unless (fboundp 'clos::class-name)
  (defun clos::class-name (c) (declare (ignore c)) nil)
)

(defun typespec-error (fun type)
  (error-of-type 'error
    (TEXT "~S: invalid type specification ~S")
    fun type
) )

;; ============================================================================

;; return the CLOS class named by TYPESPEC or NIL
(defun clos-class (typespec)
  (let ((cc (get typespec 'CLOS::CLOSCLASS)))
    (when (and cc (clos::defined-class-p cc) (eq (clos:class-name cc) typespec))
      cc)))

;;; TYPEP, CLTL S. 72, S. 42-51
(defun typep (x y &optional env &aux f) ; x = Objekt, y = Typ
  (declare (ignore env))
  (setq y (expand-deftype y))
  (cond
    ((symbolp y)
       (cond ((setq f (get y 'TYPE-SYMBOL)) (funcall f x))
             ((setq f (get y 'TYPE-LIST)) (funcall f x))
             ((setq f (get y 'DEFSTRUCT-DESCRIPTION)) (ds-typep x y f))
             ((setq f (clos-class y))
              ; It's not worth handling structure classes specially here.
              (clos::typep-class x f))
             (t (typespec-error 'typep y))
    )  )
    ((and (consp y) (symbolp (first y)))
       (cond
         ((and (eq (first y) 'SATISFIES) (eql (length y) 2))
            (unless (symbolp (second y))
              (error-of-type 'error
                (TEXT "~S: argument to SATISFIES must be a symbol: ~S")
                'typep (second y)
            ) )
            (if (funcall (symbol-function (second y)) x) t nil)
         )
         ((eq (first y) 'MEMBER)
            (if (member x (rest y)) t nil)
         )
         ((and (eq (first y) 'EQL) (eql (length y) 2))
            (eql x (second y))
         )
         ((and (eq (first y) 'NOT) (eql (length y) 2))
            (not (typep x (second y)))
         )
         ((eq (first y) 'AND)
            (dolist (type (rest y) t)
              (unless (typep x type) (return nil))
         )  )
         ((eq (first y) 'OR)
            (dolist (type (rest y) nil)
              (when (typep x type) (return t))
         )  )
         ((setq f (get (first y) 'TYPE-LIST)) (apply f x (rest y)))
         (t (typespec-error 'typep y))
    )  )
    ((clos::defined-class-p y) (clos::typep-class x y))
    ((clos::eql-specializer-p y) (eql x (clos::eql-specializer-singleton y)))
    ((encodingp y) (charset-typep x y))
    (t (typespec-error 'typep y))
) )

;; ----------------------------------------------------------------------------

;; UPGRADED-ARRAY-ELEMENT-TYPE is a lattice homomorphism, see
;; ANSI CL 15.1.2.1.
(defun upgraded-array-element-type (type &optional environment)
  (declare (ignore environment))
  ;; see array.d
  (case type
    ((BIT) 'BIT)
    ((CHARACTER) 'CHARACTER)
    ((T) 'T)
    ((NIL) 'NIL)
    (t (if (subtypep type 'NIL)
         'NIL
         (multiple-value-bind (low high) (sys::subtype-integer type)
           ; Es gilt (or (null low) (subtypep type `(INTEGER ,low ,high)))
           (if (and (integerp low) (not (minusp low)) (integerp high))
             (let ((l (integer-length high)))
               ; Es gilt (subtypep type `(UNSIGNED-BYTE ,l))
               (cond ((<= l 1) 'BIT)
                     ((<= l 2) '(UNSIGNED-BYTE 2))
                     ((<= l 4) '(UNSIGNED-BYTE 4))
                     ((<= l 8) '(UNSIGNED-BYTE 8))
                     ((<= l 16) '(UNSIGNED-BYTE 16))
                     ((<= l 32) '(UNSIGNED-BYTE 32))
                     (t 'T)))
             (if (subtypep type 'CHARACTER)
               'CHARACTER
               'T)))))))

;; ----------------------------------------------------------------------------

;; UPGRADED-COMPLEX-PART-TYPE is a lattice homomorphism, see
;; HyperSpec/Body/fun_complex.html and HyperSpec/Body/syscla_complex.html,
;; and an idempotent. Therefore
;;   (subtypep (upgraded-complex-part-type T1) (upgraded-complex-part-type T2))
;; is equivalent to
;;   (subtypep T1 (upgraded-complex-part-type T2))
;; (Proof: Let U T be an abbreviation for (upgraded-complex-part-type T).
;;  If U T1 <= U T2, then T1 <= U T1 <= U T2.
;;  If T1 <= U T2, then by homomorphism U T1 <= U U T2 = U T2.)
;;
;; For _any_ CL implementation, you could define
;;   (defun upgraded-complex-part-type (type) 'REAL)
;; Likewise for _any_ CL implementation, you could define
;;   (defun upgraded-complex-part-type (type) type)
;; or - again for _any_ CL implementation:
;;   (defun upgraded-complex-part-type (type)
;;     (cond ((subtypep type 'NIL) 'NIL)
;;           ((subtypep type 'SHORT-FLOAT) 'SHORT-FLOAT)
;;           ((subtypep type 'SINGLE-FLOAT) 'SINGLE-FLOAT)
;;           ((subtypep type 'DOUBLE-FLOAT) 'DOUBLE-FLOAT)
;;           ((subtypep type 'LONG-FLOAT) 'LONG-FLOAT)
;;           ((subtypep type 'RATIONAL) 'RATIONAL)
;;           ((subtypep type 'REAL) 'REAL)
;;           (t (error ...))))
;; The reason is that a complex number is immutable: no setters for the
;; realpart and imagpart exist.
;;
;; We choose the second implementation because it allows the most precise
;; type inference.
(defun upgraded-complex-part-type (type &optional environment)
  (declare (ignore environment))
  (if (subtypep type 'REAL)
    type
    (error-of-type 'error
      (TEXT "~S: type ~S is not a subtype of ~S")
      'upgraded-complex-part-type type 'real)))

;; ----------------------------------------------------------------------------

;; Macros for defining the various built-in "atomic type specifier"s and
;; "compound type specifier"s. The following macros add information for both
;; the TYPEP function above and the c-TYPEP in the compiler.

; Alist symbol -> funname, used by the compiler.
(defparameter c-typep-alist1 '())
; Alist symbol -> lambdabody, used by the compiler.
(defparameter c-typep-alist2 '())
; Alist symbol -> expander function, used by the compiler.
(defparameter c-typep-alist3 '())

; (def-atomic-type symbol function-name)
; defines an atomic type. The function-name designates a function taking one
; argument and returning a generalized boolean value. It can be either a
; symbol or a lambda expression.
(defmacro def-atomic-type (symbol funname)
  (let ((lambdap (and (consp funname) (eq (car funname) 'LAMBDA))))
    `(PROGN
       (SETF (GET ',symbol 'TYPE-SYMBOL)
             ,(if lambdap
                `(FUNCTION ,(concat-pnames "TYPE-SYMBOL-" symbol) ,funname)
                `(FUNCTION ,funname)
              )
       )
       ,(if lambdap
          `(SETQ C-TYPEP-ALIST2
                 (NCONC C-TYPEP-ALIST2 (LIST (CONS ',symbol ',(cdr funname))))
           )
          `(SETQ C-TYPEP-ALIST1
                 (NCONC C-TYPEP-ALIST1 (LIST (CONS ',symbol ',funname)))
           )
        )
       ',symbol
     )
) )

; (def-compound-type symbol lambda-list (x) check-form typep-form c-typep-form)
; defines a compound type. The lambda-list is of the form (&optional ...)
; where the arguments come from the CDR of the type specifier.
; For typep-form, x is an object.
; For c-typep-form, x is a multiply evaluatable form (actually a gensym).
; check-form is a form performing error checking, may call `error'.
; typep-form should return a generalized boolean value.
; c-typep-form should produce a form returning a generalized boolean value.
(defmacro def-compound-type (symbol lambdalist (var) check-form typep-form c-typep-form)
  `(PROGN
     (SETF (GET ',symbol 'TYPE-LIST)
           (FUNCTION ,(concat-pnames "TYPE-LIST-" symbol)
             (LAMBDA (,var ,@lambdalist)
               ,@(if check-form
                   `((MACROLET ((ERROR (&REST ERROR-ARGS)
                                  (LIST* 'ERROR-OF-TYPE ''ERROR ERROR-ARGS)
                               ))
                       ,check-form
                    ))
                 )
               ,typep-form
     )     ) )
     (SETQ C-TYPEP-ALIST3
           (NCONC C-TYPEP-ALIST3
                  (LIST (CONS ',symbol
                              #'(LAMBDA (,var ,@lambdalist &REST ILLEGAL-ARGS)
                                  (DECLARE (IGNORE ILLEGAL-ARGS))
                                  ,@(if check-form
                                      `((MACROLET ((ERROR (&REST ERROR-ARGS)
                                                     (LIST 'PROGN
                                                           (LIST* 'C-WARN ERROR-ARGS)
                                                           '(THROW 'C-TYPEP NIL)
                                                  )) )
                                          ,check-form
                                       ))
                                    )
                                  ,c-typep-form
                                )
     )     )      )     )
     ',symbol
   )
)

; CLtL1 p. 43
(def-atomic-type ARRAY arrayp)
(def-atomic-type ATOM atom)
(def-atomic-type BASE-CHAR
  #+BASE-CHAR=CHARACTER
  characterp
  #-BASE-CHAR=CHARACTER
  (lambda (x) (and (characterp x) (base-char-p x)))
)
(def-atomic-type BASE-STRING
  (lambda (x)
    (and (stringp x)
         (eq (array-element-type x)
             #+BASE-CHAR=CHARACTER 'CHARACTER #-BASE-CHAR=CHARACTER 'BASE-CHAR
) ) )    )
(def-atomic-type BIGNUM
  (lambda (x) (and (integerp x) (not (fixnump x))))
)
(def-atomic-type BIT
  (lambda (x) (or (eql x 0) (eql x 1)))
)
(def-atomic-type BIT-VECTOR bit-vector-p)
(def-atomic-type BOOLEAN
  (lambda (x) (or (eq x 'nil) (eq x 't)))
)
(def-atomic-type CHARACTER characterp)
(def-atomic-type COMPILED-FUNCTION compiled-function-p)
(def-atomic-type COMPLEX complexp)
(def-atomic-type CONS consp)
(def-atomic-type DOUBLE-FLOAT double-float-p)
(def-atomic-type ENCODING encodingp)
(def-atomic-type EXTENDED-CHAR
  #+BASE-CHAR=CHARACTER
  (lambda (x) (declare (ignore x)) nil)
  #-BASE-CHAR=CHARACTER
  (lambda (x) (and (characterp x) (not (base-char-p x))))
)
(def-atomic-type FIXNUM fixnump)
(def-atomic-type FLOAT floatp)
(def-atomic-type FUNCTION functionp)
(def-atomic-type HASH-TABLE hash-table-p)
(def-atomic-type INTEGER integerp)
(def-atomic-type KEYWORD keywordp)
(def-atomic-type LIST listp)
#+LOGICAL-PATHNAMES
(def-atomic-type LOGICAL-PATHNAME logical-pathname-p)
(def-atomic-type LONG-FLOAT long-float-p)
(def-atomic-type NIL
  (lambda (x) (declare (ignore x)) nil)
)
(def-atomic-type NULL null)
(def-atomic-type NUMBER numberp)
(def-atomic-type PACKAGE packagep)
(def-atomic-type PATHNAME pathnamep)
(def-atomic-type RANDOM-STATE random-state-p)
(def-atomic-type RATIO
  (lambda (x) (and (rationalp x) (not (integerp x))))
)
(def-atomic-type RATIONAL rationalp)
(def-atomic-type READTABLE readtablep)
(def-atomic-type REAL realp)
(def-atomic-type SEQUENCE sequencep)
(def-atomic-type SHORT-FLOAT short-float-p)
(def-atomic-type SIMPLE-ARRAY simple-array-p)
(def-atomic-type SIMPLE-BASE-STRING
  (lambda (x)
    (and (simple-string-p x)
         (eq (array-element-type x)
             #+BASE-CHAR=CHARACTER 'CHARACTER #-BASE-CHAR=CHARACTER 'BASE-CHAR
) ) )    )
(def-atomic-type SIMPLE-BIT-VECTOR simple-bit-vector-p)
(def-atomic-type SIMPLE-STRING simple-string-p)
(def-atomic-type SIMPLE-VECTOR simple-vector-p)
(def-atomic-type SINGLE-FLOAT single-float-p)
(defun %standard-char-p (x) (and (characterp x) (standard-char-p x))) ; ABI
(def-atomic-type STANDARD-CHAR %standard-char-p)
(def-atomic-type CLOS:STANDARD-OBJECT clos::std-instance-p)
(def-atomic-type STREAM streamp)
(def-atomic-type FILE-STREAM file-stream-p)
(def-atomic-type SYNONYM-STREAM synonym-stream-p)
(def-atomic-type BROADCAST-STREAM broadcast-stream-p)
(def-atomic-type CONCATENATED-STREAM concatenated-stream-p)
(def-atomic-type TWO-WAY-STREAM two-way-stream-p)
(def-atomic-type ECHO-STREAM echo-stream-p)
(def-atomic-type STRING-STREAM string-stream-p)
(def-atomic-type STRING stringp)
(def-atomic-type STRING-CHAR characterp)
(def-atomic-type CLOS:STRUCTURE-OBJECT clos::structure-object-p)
(def-atomic-type SYMBOL symbolp)
(def-atomic-type T (lambda (x) (declare (ignore x)) t))
;; foreign1.lisp is loaded after this file,
;; so these symbols are not external yet
#+ffi
(def-atomic-type ffi::foreign-function
  (lambda (x) (eq 'ffi::foreign-function (type-of x))))
#+ffi
(def-atomic-type ffi::foreign-variable
  (lambda (x) (eq 'ffi::foreign-variable (type-of x))))
#+ffi
(def-atomic-type ffi::foreign-address
  (lambda (x) (eq 'ffi::foreign-address (type-of x))))
;; see lispbibl.d (#define FOREIGN) and predtype.d (TYPE-OF):
#+(or unix ffi affi win32)
(def-atomic-type foreign-pointer
  (lambda (x) (eq 'foreign-pointer (type-of x))))
(def-atomic-type VECTOR vectorp)
(def-atomic-type PLIST
    (lambda (x) (multiple-value-bind (length tail) (list-length-dotted x)
                  (and (null tail) (evenp length)))))

(defmacro ensure-dim (type dim)
  ;; make sure DIM is a valid dimension
  `(unless (or (eq ,dim '*) (typep ,dim `(INTEGER 0 (,ARRAY-DIMENSION-LIMIT))))
     (error (TEXT "~S: dimension ~S is invalid") ',type ,dim)))

(defmacro ensure-rank (type rank)
  ;; make sure RANK is a valid rank
  `(unless (typep ,rank `(INTEGER 0 (,ARRAY-RANK-LIMIT)))
     (error (TEXT "~S: rank ~S is invalid") ',type ,rank)))

; CLtL1 p. 46-50
(defun c-typep-array (tester el-type dims x)
  `(AND (,tester ,x)
        ,@(if (eq el-type '*)
            '()
            `((EQUAL (ARRAY-ELEMENT-TYPE ,x) ',(upgraded-array-element-type el-type)))
          )
        ,@(if (eq dims '*)
            '()
            (if (numberp dims)
              `((EQL ,dims (ARRAY-RANK ,x)))
              `((EQL ,(length dims) (ARRAY-RANK ,x))
                ,@(let ((i 0))
                    (mapcap #'(lambda (dim)
                                (prog1
                                  (if (eq dim '*)
                                    '()
                                    `((EQL ',dim (ARRAY-DIMENSION ,x ,i)))
                                  )
                                  (incf i)
                              ) )
                            dims
                  ) )
               )
          ) )
   )
)
(defun c-typep-vector (tester size x)
  `(AND (,tester ,x)
        ,@(if (eq size '*)
            '()
            `((EQL ',size (ARRAY-DIMENSION ,x 0)))
          )
   )
)
(defun typep-number-test (x low high test type)
  (and (funcall test x)
       (cond ((eq low '*))
             ((funcall test low) (<= low x))
             ((and (consp low) (null (rest low)) (funcall test (first low)))
                (< (first low) x)
             )
             (t (error-of-type 'error
                  #1=(TEXT "~S: argument to ~S must be *, ~S or a list of ~S: ~S")
                  'typep type type type low
       )     )  )
       (cond ((eq high '*))
             ((funcall test high) (>= high x))
             ((and (consp high) (null (rest high)) (funcall test (first high)))
                (> (first high) x)
             )
             (t (error-of-type 'error
                  #1# 'typep type type type high
) )    )     )  )
(defun c-typep-number (caller tester low high x)
  `(AND (,tester ,x)
        ,@(cond ((eq low '*) '())
                ((funcall tester low) `((<= ,low ,x)))
                ((and (consp low) (null (rest low)) (funcall tester (first low)))
                 `((< ,(first low) ,x))
                )
                (t (c-warn #1=(TEXT "~S: argument to ~S must be *, ~S or a list of ~S: ~S")
                           'typep caller caller caller low
                   )
                   (throw 'c-TYPEP nil)
          )     )
        ,@(cond ((eq high '*) '())
                ((funcall tester high) `((>= ,high ,x)))
                ((and (consp high) (null (rest high)) (funcall tester (first high)))
                 `((> ,(first high) ,x))
                )
                (t (c-warn #1# 'typep caller caller caller high)
                   (throw 'c-TYPEP nil)
          )     )
   )
)
(def-compound-type ARRAY (&optional (el-type '*) (dims '*)) (x)
  (unless (eq dims '*)
    (if (numberp dims)
      (ensure-rank ARRAY dims)
      (dolist (dim dims) (ensure-dim ARRAY dim))))
  (and (arrayp x)
       (or (eq el-type '*)
           (equal (array-element-type x) (upgraded-array-element-type el-type))
       )
       (or (eq dims '*)
           (if (numberp dims)
             (eql dims (array-rank x))
             (and (eql (length dims) (array-rank x))
                  (every #'(lambda (a b) (or (eq a '*) (eql a b)))
                         dims (array-dimensions x)
  )    )   ) )    )
  (c-typep-array 'ARRAYP el-type dims x)
)
(def-compound-type SIMPLE-ARRAY (&optional (el-type '*) (dims '*)) (x)
  (unless (eq dims '*)
    (if (numberp dims)
      (ensure-rank SIMPLE-ARRAY dims)
      (dolist (dim dims) (ensure-dim SIMPLE-ARRAY dim))))
  (and (simple-array-p x)
       (or (eq el-type '*)
           (equal (array-element-type x) (upgraded-array-element-type el-type))
       )
       (or (eq dims '*)
           (if (numberp dims)
             (eql dims (array-rank x))
             (and (eql (length dims) (array-rank x))
                  (every #'(lambda (a b) (or (eq a '*) (eql a b)))
                         dims (array-dimensions x)
  )    )   ) )    )
  (c-typep-array 'SIMPLE-ARRAY-P el-type dims x)
)
(def-compound-type VECTOR (&optional (el-type '*) (size '*)) (x)
  (ensure-dim VECTOR size)
  (and (vectorp x)
       (or (eq el-type '*)
           (equal (array-element-type x) (upgraded-array-element-type el-type))
       )
       (or (eq size '*) (eql (array-dimension x 0) size))
  )
  `(AND (VECTORP ,x)
        ,@(if (eq el-type '*)
            '()
            `((EQUAL (ARRAY-ELEMENT-TYPE ,x) ',(upgraded-array-element-type el-type)))
          )
        ,@(if (eq size '*)
            '()
            `((EQL (ARRAY-DIMENSION ,x 0) ',size))
          )
   )
)
(def-compound-type SIMPLE-VECTOR (&optional (size '*)) (x)
  (ensure-dim SIMLPE-VECTOR size)
  (and (simple-vector-p x)
       (or (eq size '*) (eql size (array-dimension x 0)))
  )
  (c-typep-vector 'SIMPLE-VECTOR-P size x)
)
(def-compound-type COMPLEX (&optional (rtype '*) (itype rtype)) (x)
  nil
  (and (complexp x)
       (or (eq rtype '*)
           (typep (realpart x) (upgraded-complex-part-type rtype)))
       (or (eq itype '*)
           (typep (imagpart x) (upgraded-complex-part-type itype))))
  `(AND (COMPLEXP ,x)
        ,@(if (eq rtype '*)
            '()
            `((TYPEP (REALPART ,x) ',(upgraded-complex-part-type rtype))))
        ,@(if (eq itype '*)
            '()
            `((TYPEP (IMAGPART ,x) ',(upgraded-complex-part-type itype))))))
(def-compound-type INTEGER (&optional (low '*) (high '*)) (x)
  nil
  (typep-number-test x low high #'integerp 'INTEGER)
  (c-typep-number 'INTEGER 'INTEGERP low high x)
)
(def-compound-type MOD (n) (x)
  (unless (integerp n)
    (error (TEXT "~S: argument to MOD must be an integer: ~S")
           'typep n
  ) )
  (and (integerp x) (<= 0 x) (< x n))
  `(AND (INTEGERP ,x) (NOT (MINUSP ,x)) (< ,x ,n))
)
(def-compound-type SIGNED-BYTE (&optional (n '*)) (x)
  (unless (or (eq n '*) (integerp n))
    (error (TEXT "~S: argument to SIGNED-BYTE must be an integer or * : ~S")
           'typep n
  ) )
  (and (integerp x) (or (eq n '*) (< (integer-length x) n)))
  `(AND (INTEGERP ,x)
        ,@(if (eq n '*) '() `((< (INTEGER-LENGTH ,x) ,n)))
   )
)
(def-compound-type UNSIGNED-BYTE (&optional (n '*)) (x)
  (unless (or (eq n '*) (integerp n))
    (error (TEXT "~S: argument to UNSIGNED-BYTE must be an integer or * : ~S")
           'typep n
  ) )
  (and (integerp x)
       (not (minusp x))
       (or (eq n '*) (<= (integer-length x) n))
  )
  `(AND (INTEGERP ,x) (NOT (MINUSP ,x))
        ,@(if (eq n '*) '() `((<= (INTEGER-LENGTH ,x) ,n)))
   )
)
(def-compound-type REAL (&optional (low '*) (high '*)) (x)
  nil
  (typep-number-test x low high #'realp 'REAL)
  (c-typep-number 'REAL 'REALP low high x)
)
(def-compound-type RATIONAL (&optional (low '*) (high '*)) (x)
  nil
  (typep-number-test x low high #'rationalp 'RATIONAL)
  (c-typep-number 'RATIONAL 'RATIONALP low high x)
)
(def-compound-type FLOAT (&optional (low '*) (high '*)) (x)
  nil
  (typep-number-test x low high #'floatp 'FLOAT)
  (c-typep-number 'FLOAT 'FLOATP low high x)
)
(def-compound-type SHORT-FLOAT (&optional (low '*) (high '*)) (x)
  nil
  (typep-number-test x low high #'short-float-p 'SHORT-FLOAT)
  (c-typep-number 'SHORT-FLOAT 'SHORT-FLOAT-P low high x)
)
(def-compound-type SINGLE-FLOAT (&optional (low '*) (high '*)) (x)
  nil
  (typep-number-test x low high #'single-float-p 'SINGLE-FLOAT)
  (c-typep-number 'SINGLE-FLOAT 'SINGLE-FLOAT-P low high x)
)
(def-compound-type DOUBLE-FLOAT (&optional (low '*) (high '*)) (x)
  nil
  (typep-number-test x low high #'double-float-p 'DOUBLE-FLOAT)
  (c-typep-number 'DOUBLE-FLOAT 'DOUBLE-FLOAT-P low high x)
)
(def-compound-type LONG-FLOAT (&optional (low '*) (high '*)) (x)
  nil
  (typep-number-test x low high #'long-float-p 'LONG-FLOAT)
  (c-typep-number 'LONG-FLOAT 'LONG-FLOAT-P low high x)
)
(def-compound-type STRING (&optional (size '*)) (x)
  (ensure-dim STRING size)
  (and (stringp x)
       (or (eq size '*) (eql size (array-dimension x 0)))
  )
  (c-typep-vector 'STRINGP size x)
)
(def-compound-type SIMPLE-STRING (&optional (size '*)) (x)
  (ensure-dim SIMPLE-STRING size)
  (and (simple-string-p x)
       (or (eq size '*) (eql size (array-dimension x 0)))
  )
  (c-typep-vector 'SIMPLE-STRING-P size x)
)
(def-compound-type BASE-STRING (&optional (size '*)) (x)
  (ensure-dim BASE-STRING size)
  (and (stringp x)
       (or (eq size '*) (eql size (array-dimension x 0)))
  )
  (c-typep-vector 'STRINGP size x)
)
(def-compound-type SIMPLE-BASE-STRING (&optional (size '*)) (x)
  (ensure-dim SIMPLE-BASE-STRING size)
  (and (simple-string-p x)
       (or (eq size '*) (eql size (array-dimension x 0)))
  )
  (c-typep-vector 'SIMPLE-STRING-P size x)
)
(def-compound-type BIT-VECTOR (&optional (size '*)) (x)
  (ensure-dim BIT-VECTOR size)
  (and (bit-vector-p x)
       (or (eq size '*) (eql size (array-dimension x 0)))
  )
  (c-typep-vector 'BIT-VECTOR-P size x)
)
(def-compound-type SIMPLE-BIT-VECTOR (&optional (size '*)) (x)
  (ensure-dim SIMPLE-BIT-VECTOR size)
  (and (simple-bit-vector-p x)
       (or (eq size '*) (eql size (array-dimension x 0)))
  )
  (c-typep-vector 'SIMPLE-BIT-VECTOR-P size x)
)
(def-compound-type CONS (&optional (car-type '*) (cdr-type '*)) (x)
  nil
  (and (consp x)
       (or (eq car-type '*) (typep (car x) car-type))
       (or (eq cdr-type '*) (typep (cdr x) cdr-type))
  )
  `(AND (CONSP ,x)
        ,@(if (eq car-type '*) '() `((TYPEP (CAR ,x) ',car-type)))
        ,@(if (eq cdr-type '*) '() `((TYPEP (CDR ,x) ',cdr-type)))
   )
)

(fmakunbound 'def-compound-type)

;; ----------------------------------------------------------------------------

; Typtest ohne Gefahr einer Fehlermeldung. Für SIGNAL und HANDLER-BIND.
(defun safe-typep (x y &optional env)
  (let ((*error-handler*
          #'(lambda (&rest error-args)
              (declare (ignore error-args))
              (return-from safe-typep (values nil nil))
       ))   )
    (values (typep x y env) t)
) )

; Umwandlung eines "type for declaration" in einen "type for discrimination".
(defun type-for-discrimination (y &optional (notp nil) &aux f)
  (cond ((symbolp y)
           (cond ((get y 'TYPE-SYMBOL) y)
                 ((get y 'TYPE-LIST) y)
                 ((setq f (get y 'DEFTYPE-EXPANDER))
                  (let* ((z (funcall f (list y)))
                         (zx (type-for-discrimination z notp)))
                    (if (eql zx z) y zx)
                 ))
                 (t y)
        )  )
        ((and (consp y) (symbolp (first y)))
           (case (first y)
             ((SATISFIES MEMBER EQL) y)
             (NOT
              (let* ((z (second y))
                     (zx (type-for-discrimination z (not notp))))
                (if (eql zx z) y `(NOT ,zx))
             ))
             ((AND OR COMPLEX VALUES)
              (let* ((z (rest y))
                     (zx (mapcar #'(lambda (x) (type-for-discrimination x notp)) z)))
                (if (every #'eql z zx) y (cons (first y) zx))
             ))
             (FUNCTION
              ;; (FUNCTION arg-types res-type) is somewhere between
              ;; NIL and FUNCTION, but undecidable.
              (if notp 'NIL 'FUNCTION)
             )
             (t (cond ((get (first y) 'TYPE-LIST) y)
                      ((setq f (get (first y) 'DEFTYPE-EXPANDER))
                       (let* ((z (funcall f y))
                              (zx (type-for-discrimination z notp)))
                         (if (eql zx z) y zx)
                      ))
                      (t y)
        )  ) )  )
        (t y)
) )

; Testet eine Liste von Werten auf Erfüllen eines Type-Specifiers. Für THE.
(defun %the (values type) ; ABI
  (macrolet ((near-typep (objform typform)
               ;; near-typep ist wie typep, nur dass das Objekt auch ein
               ;; Read-Label sein darf. Das tritt z.B. auf bei
               ;; (read-from-string "#1=#S(FOO :X #1#)")
               ;; im Konstruktor MAKE-FOO. Die Implementation ist aber
               ;; nicht gezwungen, bei fehlerhaftem THE zwingend einen
               ;; Fehler zu melden, darum ist ein lascherer Typcheck hier
               ;; erlaubt.
               (let ((g (gensym)))
                 `(let ((,g ,objform))
                    (or (typep ,g ,typform) (eq (type-of ,g) 'READ-LABEL))))))
    (if (and (consp type) (eq (car type) 'VALUES))
      ;; The VALUES type specifier is ill-defined in ANSI CL.
      ;;
      ;; There are two possibilities to define a VALUES type specifier in a
      ;; sane way:
      ;; - (EXACT-VALUES type1 ... [&optional ...]) describes the exact shape
      ;;   of the values list, as received by MULTIPLE-VALUE-LIST.
      ;;   For example, (EXACT-VALUES SYMBOL) is matched by (values 'a) but not
      ;;   by (values 'a 'b) or (values).
      ;; - (ASSIGNABLE-VALUES type1 ... [&optional ...]) describes the values
      ;;   as received by a set of variables through MULTIPLE-VALUE-BIND or
      ;;   MULTIPLE-VALUE-SETQ. For example, (ASSIGNABLE-VALUES SYMBOL) is
      ;;   defined by whether
      ;;     (MULTIPLE-VALUE-BIND (var1) values (DECLARE (TYPE SYMBOL var1)) ...)
      ;;   is valid or not; therefore (ASSIGNABLE-VALUES SYMBOL) is matched by
      ;;   (values 'a) and (values 'a 'b) and (values).
      ;;   Note that &OPTIONAL is actually redundant here:
      ;;     (ASSIGNABLE-VALUES type1 ... &optional otype1 ...)
      ;;   is equivalent to
      ;;     (ASSIGNABLE-VALUES type1 ... (OR NULL otype1) ...)
      ;; HyperSpec/Body/typspe_values.html indicates that VALUES means
      ;; EXACT-VALUES; however, HyperSpec/Body/speope_the.html indicates that
      ;; VALUES means ASSIGNABLE-VALUES.
      ;;
      ;; SBCL interprets the VALUES type specifier to mean EXACT-VALUES when
      ;; it contains &OPTIONAL or &REST, but ASSIGNABLE-VALUES when it has
      ;; only a tuple of type specifiers. This is utter nonsense, in particular
      ;; because it makes (VALUES type1 ... typek &OPTIONAL)
      ;; different from   (VALUES type1 ... typek).
      ;;
      ;; Here we use the ASSIGNABLE-VALUES interpretation.
      ;; In SUBTYPEP we just punt and don't assume any interpretation.
      (let ((vals values) (types (cdr type)))
        ;; required:
        (loop
          (when (or (atom types) (atom vals)) (return-from %the t))
          (when (memq (car types) lambda-list-keywords) (return))
          (unless (near-typep (pop vals) (pop types))
            (return-from %the nil)))
        ;; &optional:
        (when (and (consp types) (eq (car types) '&optional))
          (setq types (cdr types))
          (loop
            (when (or (atom types) (atom vals)) (return-from %the t))
            (when (memq (car types) lambda-list-keywords) (return))
            (unless (near-typep (pop vals) (pop types))
              (return-from %the nil))))
        ;; &rest &key:
        (case (car types)
          (&rest
           (setq types (cdr types))
           (when (atom types) (typespec-error 'the type))
           (unless (near-typep (pop vals) (pop types))
             (return-from %the nil)))
          (&key)
          (t (typespec-error 'the type)))
        (if (eq (car types) '&key)
          (progn
            (setq types (cdr types))
            (when (oddp (length vals)) (return-from %the nil))
            (let ((keywords nil))
              (loop
                (when (or (atom types) (atom vals)) (return-from %the t))
                (when (memq (car types) lambda-list-keywords) (return))
                (let ((item (pop types)))
                  (unless (and (listp item) (eql (length item) 2)
                               (symbolp (first item)))
                    (typespec-error 'the type))
                  (let ((kw (symbol-to-keyword (first item))))
                    (unless (near-typep (getf vals kw) (second item))
                      (return-from %the nil))
                    (push kw keywords))))
              (if (and (consp types) (eq (car types) '&allow-other-keys))
                (setq types (cdr types))
                (unless (getf vals ':allow-other-keys)
                  (do ((L vals (cddr L)))
                      ((atom L))
                    (unless (memq (car L) keywords)
                      (return-from %the nil)))))))
          (when (consp types) (typespec-error 'the type)))
        t)
      (near-typep (if (consp values) (car values) nil) type))))

;;; ===========================================================================

;; SUBTYPEP
(load "subtypep")


;; Returns the number of bytes that are needed to represent #\Null in a
;; given encoding.
(defun encoding-zeroes (encoding)
  #+UNICODE
  ;; this should use min_bytes_per_char for cache, not the hash table
  (let ((name (ext:encoding-charset encoding))
        (table #.(make-hash-table :key-type '(or string symbol) :value-type 'fixnum
                                  :test 'stablehash-equal :warn-if-needs-rehash-after-gc t
                                  :initial-contents '(("UTF-7" . 1))))
        (tester #.(make-string 2 :initial-element (code-char 0))))
    (or (gethash name table)
        (setf (gethash name table)
              (- (length (ext:convert-string-to-bytes tester encoding))
                 (length (ext:convert-string-to-bytes tester encoding
                                                      :end 1))))))
  #-UNICODE 1)

;; Determines two values low,high such that
;;   (subtypep type `(INTEGER ,low ,high))
;; holds and low is as large as possible and high is as small as possible.
;; low = * means -infinity, high = * means infinity.
;; When (subtypep type 'INTEGER) is false, the values NIL,NIL are returned.
;; We need this function only for MAKE-ARRAY, UPGRADED-ARRAY-ELEMENT-TYPE and
;; OPEN and can therefore w.l.o.g. replace
;;   type  with  `(OR ,type (MEMBER 0))
#| ;; The original implementation calls canonicalize-type and then applies
   ;; a particular SUBTYPE variant:
 (defun subtype-integer (type)
  (macrolet ((yes () '(return-from subtype-integer (values low high)))
             (no () '(return-from subtype-integer nil))
             (unknown () '(return-from subtype-integer nil)))
    (setq type (canonicalize-type type))
    (if (consp type)
      (case (first type)
        (MEMBER ; (MEMBER &rest objects)
          ;; All elements must be of type INTEGER.
          (let ((low 0) (high 0)) ; wlog!
            (dolist (x (rest type) (yes))
              (unless (typep x 'INTEGER) (return (no)))
              (setq low (min low x) high (max high x)))))
        (OR ; (OR type*)
          ;; Every type must be subtype of INTEGER.
          (let ((low 0) (high 0)) ; wlog!
            (dolist (type1 (rest type) (yes))
              (multiple-value-bind (low1 high1) (subtype-integer type1)
                (unless low1 (return (no)))
                (setq low (if (or (eq low '*) (eq low1 '*)) '* (min low low1))
                      high (if (or (eq high '*) (eq high1 '*))
                               '* (max high high1)))))))
        (AND ; (AND type*)
          ;; If one of the types is subtype of INTEGER, then yes,
          ;; otherwise unknown.
          (let ((low nil) (high nil))
            (dolist (type1 (rest type))
              (multiple-value-bind (low1 high1) (subtype-integer type1)
                (when low1
                  (if low
                    (setq low (if (eq low '*) low1 (if (eq low1 '*) low (max low low1)))
                          high (if (eq high '*) high1 (if (eq high1 '*) high (min high high1))))
                    (setq low low1 high high1)))))
            (if low
              (progn
                (when (and (numberp low) (numberp high) (not (<= low high)))
                  (setq low 0 high 0) ; type equivalent to NIL)
                (yes))
              (unknown)))))
      (setq type (list type)))
    (if (eq (first type) 'INTEGER)
      (let ((low (if (rest type) (second type) '*))
            (high (if (cddr type) (third type) '*)))
        (when (consp low)
          (setq low (first low))
          (when (numberp low) (incf low)))
        (when (consp high)
          (setq high (first high))
          (when (numberp high) (decf high)))
        (when (and (numberp low) (numberp high) (not (<= low high))) ; type leer?
          (setq low 0 high 0))
        (yes))
      (if (and (eq (first type) 'INTERVALS) (eq (second type) 'INTEGER))
        (let ((low (third type))
              (high (car (last type))))
          (when (consp low)
            (setq low (first low))
            (when (numberp low) (incf low)))
          (when (consp high)
            (setq high (first high))
            (when (numberp high) (decf high)))
          (yes))
        (unknown)))))
|# ;; This implementation inlines the (tail-recursive) canonicalize-type
   ;; function. Its advantage is that it doesn't cons as much.
   ;; (For example, (subtype-integer '(UNSIGNED-BYTE 8)) doesn't cons.)
(defun subtype-integer (type)
  (macrolet ((yes () '(return-from subtype-integer (values low high)))
             (no () '(return-from subtype-integer nil))
             (unknown () '(return-from subtype-integer nil)))
    (setq type (expand-deftype type))
    (cond ((symbolp type)
           (case type
             (BIT (let ((low 0) (high 1)) (yes)))
             (FIXNUM
              (let ((low '#,most-negative-fixnum)
                    (high '#,most-positive-fixnum))
                (yes)))
             ((INTEGER BIGNUM SIGNED-BYTE)
              (let ((low '*) (high '*)) (yes)))
             (UNSIGNED-BYTE
              (let ((low 0) (high '*)) (yes)))
             ((NIL)
              (let ((low 0) (high 0)) (yes))) ; wlog!
             (t (no))))
          ((and (consp type) (symbolp (first type)))
           (unless (and (list-length type) (null (cdr (last type))))
             (typespec-error 'subtypep type))
           (case (first type)
             (MEMBER ; (MEMBER &rest objects)
              ;; All elements must be of type INTEGER.
              (let ((low 0) (high 0)) ; wlog!
                (dolist (x (rest type) (yes))
                  (unless (typep x 'INTEGER) (return (no)))
                  (setq low (min low x) high (max high x)))))
             (EQL ; (EQL object)
              (let ((x (second type)))
                (if (typep x 'INTEGER)
                  (let ((low (min 0 x)) (high (max 0 x))) (yes))
                  (no))))
             (OR ; (OR type*)
              ;; Every type must be subtype of INTEGER.
              (let ((low 0) (high 0)) ; wlog!
                (dolist (type1 (rest type) (yes))
                  (multiple-value-bind (low1 high1) (subtype-integer type1)
                    (unless low1 (return (no)))
                    (setq low (if (or (eq low '*) (eq low1 '*))
                                  '* (min low low1))
                          high (if (or (eq high '*) (eq high1 '*))
                                   '* (max high high1)))))))
             (AND ; (AND type*)
              ;; If one of the types is subtype of INTEGER, then yes,
              ;; otherwise unknown.
              (let ((low nil) (high nil))
                (dolist (type1 (rest type))
                  (multiple-value-bind (low1 high1) (subtype-integer type1)
                    (when low1
                      (if low
                        (setq low (if (eq low '*) low1
                                      (if (eq low1 '*) low
                                          (max low low1)))
                              high (if (eq high '*) high1
                                       (if (eq high1 '*) high
                                           (min high high1))))
                        (setq low low1
                              high high1)))))
                (if low
                  (progn
                    (when (and (numberp low) (numberp high)
                               (not (<= low high)))
                      (setq low 0 high 0)) ; type equivalent to NIL
                    (yes))
                  (unknown))))
             (INTEGER
              (let ((low (if (rest type) (second type) '*))
                    (high (if (cddr type) (third type) '*)))
                (when (consp low)
                  (setq low (first low))
                  (when (numberp low) (incf low)))
                (when (consp high)
                  (setq high (first high))
                  (when (numberp high) (decf high)))
                (when (and (numberp low) (numberp high) (not (<= low high)))
                  (setq low 0 high 0)) ; type equivalent to NIL
                (yes)))
             (INTERVALS
              (if (eq (second type) 'INTEGER)
                (let ((low (third type))
                      (high (car (last type))))
                  (when (consp low)
                    (setq low (first low))
                    (when (numberp low) (incf low)))
                  (when (consp high)
                    (setq high (first high))
                    (when (numberp high) (decf high)))
                  (yes))
                (unknown)))
             (MOD ; (MOD n)
              (let ((n (second type)))
                (unless (and (integerp n) (>= n 0))
                  (typespec-error 'subtypep type))
                (if (eql n 0)
                  (no)
                  (let ((low 0) (high (1- n)))
                    (yes)))))
             (SIGNED-BYTE ; (SIGNED-BYTE &optional s)
              (let ((s (if (cdr type) (second type) '*)))
                (if (eq s '*)
                  (let ((low '*) (high '*)) (yes))
                  (progn
                    (unless (and (integerp s) (plusp s))
                      (typespec-error 'subtypep type))
                    (let ((n (ash 1 (1- s)))) ; (ash 1 *) == (expt 2 *)
                      (let ((low (- n)) (high (1- n)))
                        (yes)))))))
             (UNSIGNED-BYTE ; (UNSIGNED-BYTE &optional s)
              (let ((s (if (cdr type) (second type) '*)))
                (if (eq s '*)
                    (let ((low 0) (high '*)) (yes))
                    (progn
                      (unless (and (integerp s) (>= s 0))
                        (typespec-error 'subtypep type))
                      (let ((n (ash 1 s))) ; (ash 1 *) == (expt 2 *)
                        (let ((low 0) (high (1- n)))
                          (yes)))))))
             (t (no))))
          ((clos::defined-class-p type)
           (if (and (clos::built-in-class-p type)
                    (eq (get (clos:class-name type) 'CLOS::CLOSCLASS) type))
             (return-from subtype-integer
               (subtype-integer (clos:class-name type)))
             (no)))
          ((clos::eql-specializer-p type)
           (let ((x (clos::eql-specializer-singleton type)))
             (if (typep x 'INTEGER)
               (let ((low (min 0 x)) (high (max 0 x))) (yes))
               (no))))
          ((encodingp type) (no))
          (t (typespec-error 'subtypep type)))))

#| TODO: Fix subtype-integer such that this works.
Henry Baker:
 (defun type-null (x)
  (values (and (eq 'bit (upgraded-array-element-type `(or bit ,x)))
               (not (typep 0 x))
               (not (typep 1 x)))
          t))
 (type-null '(and symbol number))
 (type-null '(and integer symbol))
 (type-null '(and integer character))
|#

;; Determines a sequence kind (an atom, as defined in defseq.lisp: one of
;;   LIST - stands for LIST
;;   VECTOR - stands for (VECTOR T)
;;   STRING - stands for (VECTOR CHARACTER)
;;   1, 2, 4, 8, 16, 32 - stands for (VECTOR (UNSIGNED-BYTE n))
;;   0 - stands for (VECTOR NIL))
;; that indicates the sequence type meant by the given type. Other possible
;; return values are
;;   SEQUENCE - denoting a type whose intersection with (OR LIST VECTOR) is not
;;              subtype of LIST or VECTOR, or
;;   NIL - indicating a type whose intersection with (OR LIST VECTOR) is empty.
;; When the type is (OR (VECTOR eltype1) ... (VECTOR eltypeN)), the chosen
;; element type is the smallest element type that contains all of eltype1 ...
;; eltypeN.
;;
;; User-defined sequence types are not supported here.
;;
;; This implementation inlines the (tail-recursive) canonicalize-type
;; function. Its advantage is that it doesn't cons as much. Also it employs
;; some heuristics and does not have the full power of SUBTYPEP.
(defun subtype-sequence (type)
  (setq type (expand-deftype type))
  (cond ((symbolp type)
         (case type
           ((LIST CONS NULL) 'LIST)
           ((NIL) 'NIL)
           ((BIT-VECTOR SIMPLE-BIT-VECTOR) '1)
           ((STRING SIMPLE-STRING BASE-STRING SIMPLE-BASE-STRING) 'STRING)
           ((VECTOR SIMPLE-VECTOR ARRAY SIMPLE-ARRAY) 'VECTOR)
           ((SEQUENCE) 'SEQUENCE)
           (t 'NIL)))
        ((and (consp type) (symbolp (first type)))
         (unless (and (list-length type) (null (cdr (last type))))
           (typespec-error 'subtypep type))
         (case (first type)
           (MEMBER ; (MEMBER &rest objects)
            (let ((kind 'NIL))
              (dolist (x (rest type))
                (setq kind (sequence-type-union kind (type-of-sequence x))))
              kind))
           (EQL ; (EQL object)
            (unless (eql (length type) 2)
              (typespec-error 'subtypep type))
            (type-of-sequence (second type)))
           (OR ; (OR type*)
            (let ((kind 'NIL))
              (dolist (x (rest type))
                (setq kind (sequence-type-union kind (subtype-sequence x))))
              kind))
           (AND ; (AND type*)
            (let ((kind 'SEQUENCE))
              (dolist (x (rest type))
                (setq kind (sequence-type-intersection kind (subtype-sequence x))))
              kind))
           ((SIMPLE-BIT-VECTOR BIT-VECTOR) ; (SIMPLE-BIT-VECTOR &optional size)
            (when (cddr type)
              (typespec-error 'subtypep type))
            '1)
           ((SIMPLE-STRING STRING SIMPLE-BASE-STRING BASE-STRING) ; (SIMPLE-STRING &optional size)
            (when (cddr type)
              (typespec-error 'subtypep type))
            'STRING)
           (SIMPLE-VECTOR ; (SIMPLE-VECTOR &optional size)
            (when (cddr type)
              (typespec-error 'subtypep type))
            'VECTOR)
           ((VECTOR ARRAY SIMPLE-ARRAY) ; (VECTOR &optional el-type size), (ARRAY &optional el-type dimensions)
            (when (cdddr type)
              (typespec-error 'subtypep type))
            (let ((el-type (if (cdr type) (second type) '*)))
              (if (eq el-type '*)
                'VECTOR
                (let ((eltype (upgraded-array-element-type el-type)))
                  (cond ((eq eltype 'T) 'VECTOR)
                        ((eq eltype 'CHARACTER) 'STRING)
                        ((eq eltype 'BIT) '1)
                        ((and (consp eltype) (eq (first eltype) 'UNSIGNED-BYTE)) (second eltype))
                        ((eq eltype 'NIL) '0)
                        (t (error (TEXT "~S is not up-to-date with ~S for element type ~S")
                                  'subtypep-sequence 'upgraded-array-element-type eltype)))))))
           ((CONS) ; (CONS &optional cartype cdrtype)
            (when (cdddr type)
              (typespec-error 'subtypep type))
            'LIST)
           (t 'NIL)))
        ((clos::defined-class-p type)
         (if (and (clos::built-in-class-p type)
                  (eq (get (clos:class-name type) 'CLOS::CLOSCLASS) type))
           (subtype-sequence (clos:class-name type))
           'NIL))
        ((clos::eql-specializer-p type)
         (type-of-sequence (clos::eql-specializer-singleton type)))
        (t 'NIL)))
(defun type-of-sequence (x)
  (cond ((listp x) 'LIST)
        ((vectorp x)
         (let ((eltype (array-element-type x)))
           (cond ((eq eltype 'T) 'VECTOR)
                 ((eq eltype 'CHARACTER) 'STRING)
                 ((eq eltype 'BIT) '1)
                 ((and (consp eltype) (eq (first eltype) 'UNSIGNED-BYTE)) (second eltype))
                 ((eq eltype 'NIL) '0)
                 (t (error (TEXT "~S is not up-to-date with ~S for element type ~S")
                           'type-of-sequence 'array-element-type eltype)))))
        (t 'NIL)))
(defun sequence-type-union (t1 t2)
  (cond ; Simple general rules.
        ((eql t1 t2) t1)
        ((eq t1 'NIL) t2)
        ((eq t2 'NIL) t1)
        ; Now the union of two different types.
        ((or (eq t1 'SEQUENCE) (eq t2 'SEQUENCE)) 'SEQUENCE)
        ((or (eq t1 'LIST) (eq t2 'LIST))
         ; union of LIST and a vector type
         'SEQUENCE)
        ((or (eq t1 'VECTOR) (eq t2 'VECTOR)) 'VECTOR)
        ((eql t1 0) t2)
        ((eql t2 0) t1)
        ((or (eq t1 'STRING) (eq t2 'STRING))
         ; union of STRING and an integer-vector type
         'VECTOR)
        (t (max t1 t2))))
(defun sequence-type-intersection (t1 t2)
  (cond ; Simple general rules.
        ((eql t1 t2) t1)
        ((or (eq t1 'NIL) (eq t2 'NIL)) 'NIL)
        ; Now the intersection of two different types.
        ((eq t1 'SEQUENCE) t2)
        ((eq t2 'SEQUENCE) t1)
        ((or (eq t1 'LIST) (eq t2 'LIST))
         ; intersection of LIST and a vector type
         'NIL)
        ((eq t1 'VECTOR) t2)
        ((eq t2 'VECTOR) t1)
        ((or (eql t1 0) (eql t2 0)) '0)
        ((or (eq t1 'STRING) (eq t2 'STRING))
         ; intersection of STRING and an integer-vector type
         '0)
        (t (min t1 t2))))

;; ============================================================================

(defun type-expand (typespec &optional once-p)
  (multiple-value-bind (expanded user-defined-p)
      (expand-deftype typespec once-p)
    (if user-defined-p (values expanded user-defined-p)
      (cond ((symbolp typespec)
             (cond ((or (get typespec 'TYPE-SYMBOL) (get typespec 'TYPE-LIST))
                    (values typespec nil))
                   ((or (get typespec 'DEFSTRUCT-DESCRIPTION)
                        (clos-class typespec))
                    (values typespec nil))
                   (t (typespec-error 'type-expand typespec))))
            ((and (consp typespec) (symbolp (first typespec)))
             (case (first typespec)
               ((SATISFIES MEMBER EQL NOT AND OR) (values typespec nil))
               (t (cond ((get (first typespec) 'TYPE-LIST)
                         (values typespec nil))
                        (t (typespec-error 'type-expand typespec))))))
            ((clos::defined-class-p typespec) (values typespec nil))
            (t (typespec-error 'type-expand typespec))))))

;; ============================================================================

(unless (clos::funcallable-instance-p #'clos::class-name)
  (fmakunbound 'clos::class-name))


(keywordp :junk)
  T

(keywordp ::junk)
  T

(symbol-name ::junk)
  "JUNK"

(symbol-name :#junk)
  "#JUNK"

(symbol-name :#.junk)
  "#.JUNK"

---tokens---
';;;; TYPEP und Verwandtes' Comment.Single
'\n'          Text

';;;; Michael Stoll, 21. 10. 1988' Comment.Single
'\n'          Text

';;;; Bruno Haible, 10.6.1989' Comment.Single
'\n'          Text

';;;; Sam Steingold 2000-2005' Comment.Single
'\n\n'        Text

';;; Datenstrukturen für TYPEP:' Comment.Single
'\n'          Text

';;; - Ein Type-Specifier-Symbol hat auf seiner Propertyliste unter dem' Comment.Single
'\n'          Text

';;;   Indikator SYS::TYPE-SYMBOL eine Funktion von einem Argument, die' Comment.Single
'\n'          Text

';;;   testet, ob ein Objekt vom richtigen Typ ist.' Comment.Single
'\n'          Text

';;; - Ein Symbol, das eine Type-Specifier-Liste beginnen kann, hat auf seiner' Comment.Single
'\n'          Text

';;;   Propertyliste unter dem Indikator SYS::TYPE-LIST eine Funktion von' Comment.Single
'\n'          Text

';;;   einem Argument für das zu testende Objekt und zusätzlichen Argumenten' Comment.Single
'\n'          Text

';;;   für die Listenelemente.' Comment.Single
'\n'          Text

';;; - Ein Symbol, das als Typmacro definiert wurde, hat auf seiner Property-' Comment.Single
'\n'          Text

';;;   liste unter dem Indikator SYSTEM::DEFTYPE-EXPANDER den zugehörigen' Comment.Single
'\n'          Text

';;;   Expander: eine Funktion, die den zu expandierenden Type-Specifier (eine' Comment.Single
'\n'          Text

';;;   mindestens einelementige Liste) als Argument bekommt.' Comment.Single
'\n\n'        Text

'('           Punctuation
'in-package'  Name.Builtin
' '           Text
'"EXT"'       Literal.String
')'           Punctuation
'\n'          Text

'('           Punctuation
'export'      Name.Builtin
' '           Text
"'"           Operator
'('           Punctuation
'type-expand' Name.Variable
')'           Punctuation
')'           Punctuation
'\n'          Text

'('           Punctuation
'in-package'  Name.Builtin
' '           Text
'"SYSTEM"'    Literal.String
')'           Punctuation
'\n\n'        Text

'; vorläufig, solange bis clos.lisp geladen wird:' Comment.Single
'\n'          Text

'('           Punctuation
'eval-when'   Keyword
' '           Text
'('           Punctuation
'eval'        Name.Builtin
')'           Punctuation
'\n  '        Text
'('           Punctuation
'predefun'    Name.Variable
' '           Text
'clos::built-in-class-p' Name.Variable
' '           Text
'('           Punctuation
'object'      Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'declare'     Keyword
' '           Text
'('           Punctuation
'ignore'      Keyword
' '           Text
'object'      Name.Variable
')'           Punctuation
')'           Punctuation
' '           Text
'nil'         Name.Constant
')'           Punctuation
')'           Punctuation
'\n'          Text

'('           Punctuation
'unless'      Name.Builtin
' '           Text
'('           Punctuation
'fboundp'     Name.Builtin
' '           Text
"'clos::class-name" Literal.String.Symbol
')'           Punctuation
'\n  '        Text
'('           Punctuation
'defun'       Name.Builtin
' '           Text
'clos::class-name' Name.Variable
' '           Text
'('           Punctuation
'c'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'declare'     Keyword
' '           Text
'('           Punctuation
'ignore'      Keyword
' '           Text
'c'           Name.Variable
')'           Punctuation
')'           Punctuation
' '           Text
'nil'         Name.Constant
')'           Punctuation
'\n'          Text

')'           Punctuation
'\n\n'        Text

'('           Punctuation
'defun'       Name.Builtin
' '           Text
'typespec-error' Name.Variable
' '           Text
'('           Punctuation
'fun'         Name.Variable
' '           Text
'type'        Keyword
')'           Punctuation
'\n  '        Text
'('           Punctuation
'error-of-type' Name.Variable
' '           Text
"'error"      Literal.String.Symbol
'\n    '      Text
'('           Punctuation
'TEXT'        Name.Variable
' '           Text
'"~S: invalid type specification ~S"' Literal.String
')'           Punctuation
'\n    '      Text
'fun'         Name.Variable
' '           Text
'type'        Keyword
'\n'          Text

')'           Punctuation
' '           Text
')'           Punctuation
'\n\n'        Text

';; ============================================================================' Comment.Single
'\n\n'        Text

';; return the CLOS class named by TYPESPEC or NIL' Comment.Single
'\n'          Text

'('           Punctuation
'defun'       Name.Builtin
' '           Text
'clos-class'  Name.Variable
' '           Text
'('           Punctuation
'typespec'    Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'let'         Keyword
' '           Text
'('           Punctuation
'('           Punctuation
'cc'          Name.Variable
' '           Text
'('           Punctuation
'get'         Name.Builtin
' '           Text
'typespec'    Name.Variable
' '           Text
"'CLOS::CLOSCLASS" Literal.String.Symbol
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n    '      Text
'('           Punctuation
'when'        Name.Builtin
' '           Text
'('           Punctuation
'and'         Name.Builtin
' '           Text
'cc'          Name.Variable
' '           Text
'('           Punctuation
'clos::defined-class-p' Name.Variable
' '           Text
'cc'          Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'('           Punctuation
'clos:class-name' Name.Variable
' '           Text
'cc'          Name.Variable
')'           Punctuation
' '           Text
'typespec'    Name.Variable
')'           Punctuation
')'           Punctuation
'\n      '    Text
'cc'          Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

';;; TYPEP, CLTL S. 72, S. 42-51' Comment.Single
'\n'          Text

'('           Punctuation
'defun'       Name.Builtin
' '           Text
'typep'       Name.Builtin
' '           Text
'('           Punctuation
'x'           Name.Variable
' '           Text
'y'           Name.Variable
' '           Text
'&optional'   Keyword
' '           Text
'env'         Name.Variable
' '           Text
'&aux'        Keyword
' '           Text
'f'           Name.Variable
')'           Punctuation
' '           Text
'; x = Objekt, y = Typ' Comment.Single
'\n  '        Text
'('           Punctuation
'declare'     Keyword
' '           Text
'('           Punctuation
'ignore'      Keyword
' '           Text
'env'         Name.Variable
')'           Punctuation
')'           Punctuation
'\n  '        Text
'('           Punctuation
'setq'        Keyword
' '           Text
'y'           Name.Variable
' '           Text
'('           Punctuation
'expand-deftype' Name.Variable
' '           Text
'y'           Name.Variable
')'           Punctuation
')'           Punctuation
'\n  '        Text
'('           Punctuation
'cond'        Name.Builtin
'\n    '      Text
'('           Punctuation
'('           Punctuation
'symbolp'     Name.Builtin
' '           Text
'y'           Name.Variable
')'           Punctuation
'\n       '   Text
'('           Punctuation
'cond'        Name.Builtin
' '           Text
'('           Punctuation
'('           Punctuation
'setq'        Keyword
' '           Text
'f'           Name.Variable
' '           Text
'('           Punctuation
'get'         Name.Builtin
' '           Text
'y'           Name.Variable
' '           Text
"'TYPE-SYMBOL" Literal.String.Symbol
')'           Punctuation
')'           Punctuation
' '           Text
'('           Punctuation
'funcall'     Name.Builtin
' '           Text
'f'           Name.Variable
' '           Text
'x'           Name.Variable
')'           Punctuation
')'           Punctuation
'\n             ' Text
'('           Punctuation
'('           Punctuation
'setq'        Keyword
' '           Text
'f'           Name.Variable
' '           Text
'('           Punctuation
'get'         Name.Builtin
' '           Text
'y'           Name.Variable
' '           Text
"'TYPE-LIST"  Literal.String.Symbol
')'           Punctuation
')'           Punctuation
' '           Text
'('           Punctuation
'funcall'     Name.Builtin
' '           Text
'f'           Name.Variable
' '           Text
'x'           Name.Variable
')'           Punctuation
')'           Punctuation
'\n             ' Text
'('           Punctuation
'('           Punctuation
'setq'        Keyword
' '           Text
'f'           Name.Variable
' '           Text
'('           Punctuation
'get'         Name.Builtin
' '           Text
'y'           Name.Variable
' '           Text
"'DEFSTRUCT-DESCRIPTION" Literal.String.Symbol
')'           Punctuation
')'           Punctuation
' '           Text
'('           Punctuation
'ds-typep'    Name.Variable
' '           Text
'x'           Name.Variable
' '           Text
'y'           Name.Variable
' '           Text
'f'           Name.Variable
')'           Punctuation
')'           Punctuation
'\n             ' Text
'('           Punctuation
'('           Punctuation
'setq'        Keyword
' '           Text
'f'           Name.Variable
' '           Text
'('           Punctuation
'clos-class'  Name.Variable
' '           Text
'y'           Name.Variable
')'           Punctuation
')'           Punctuation
'\n              ' Text
"; It's not worth handling structure classes specially here." Comment.Single
'\n              ' Text
'('           Punctuation
'clos::typep-class' Name.Variable
' '           Text
'x'           Name.Variable
' '           Text
'f'           Name.Variable
')'           Punctuation
')'           Punctuation
'\n             ' Text
'('           Punctuation
't'           Name.Constant
' '           Text
'('           Punctuation
'typespec-error' Name.Variable
' '           Text
"'typep"      Literal.String.Symbol
' '           Text
'y'           Name.Variable
')'           Punctuation
')'           Punctuation
'\n    '      Text
')'           Punctuation
'  '          Text
')'           Punctuation
'\n    '      Text
'('           Punctuation
'('           Punctuation
'and'         Name.Builtin
' '           Text
'('           Punctuation
'consp'       Name.Builtin
' '           Text
'y'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'symbolp'     Name.Builtin
' '           Text
'('           Punctuation
'first'       Name.Builtin
' '           Text
'y'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n       '   Text
'('           Punctuation
'cond'        Name.Builtin
'\n         ' Text
'('           Punctuation
'('           Punctuation
'and'         Name.Builtin
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'('           Punctuation
'first'       Name.Builtin
' '           Text
'y'           Name.Variable
')'           Punctuation
' '           Text
"'SATISFIES"  Literal.String.Symbol
')'           Punctuation
' '           Text
'('           Punctuation
'eql'         Name.Builtin
' '           Text
'('           Punctuation
'length'      Name.Builtin
' '           Text
'y'           Name.Variable
')'           Punctuation
' '           Text
'2'           Literal.Number.Integer
')'           Punctuation
')'           Punctuation
'\n            ' Text
'('           Punctuation
'unless'      Name.Builtin
' '           Text
'('           Punctuation
'symbolp'     Name.Builtin
' '           Text
'('           Punctuation
'second'      Name.Builtin
' '           Text
'y'           Name.Variable
')'           Punctuation
')'           Punctuation
'\n              ' Text
'('           Punctuation
'error-of-type' Name.Variable
' '           Text
"'error"      Literal.String.Symbol
'\n                ' Text
'('           Punctuation
'TEXT'        Name.Variable
' '           Text
'"~S: argument to SATISFIES must be a symbol: ~S"' Literal.String
')'           Punctuation
'\n                ' Text
"'typep"      Literal.String.Symbol
' '           Text
'('           Punctuation
'second'      Name.Builtin
' '           Text
'y'           Name.Variable
')'           Punctuation
'\n            ' Text
')'           Punctuation
' '           Text
')'           Punctuation
'\n            ' Text
'('           Punctuation
'if'          Keyword
' '           Text
'('           Punctuation
'funcall'     Name.Builtin
' '           Text
'('           Punctuation
'symbol-function' Name.Builtin
' '           Text
'('           Punctuation
'second'      Name.Builtin
' '           Text
'y'           Name.Variable
')'           Punctuation
')'           Punctuation
' '           Text
'x'           Name.Variable
')'           Punctuation
' '           Text
't'           Name.Constant
' '           Text
'nil'         Name.Constant
')'           Punctuation
'\n         ' Text
')'           Punctuation
'\n         ' Text
'('           Punctuation
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'('           Punctuation
'first'       Name.Builtin
' '           Text
'y'           Name.Variable
')'           Punctuation
' '           Text
"'MEMBER"     Literal.String.Symbol
')'           Punctuation
'\n            ' Text
'('           Punctuation
'if'          Keyword
' '           Text
'('           Punctuation
'member'      Name.Builtin
' '           Text
'x'           Name.Variable
' '           Text
'('           Punctuation
'rest'        Name.Builtin
' '           Text
'y'           Name.Variable
')'           Punctuation
')'           Punctuation
' '           Text
't'           Name.Constant
' '           Text
'nil'         Name.Constant
')'           Punctuation
'\n         ' Text
')'           Punctuation
'\n         ' Text
'('           Punctuation
'('           Punctuation
'and'         Name.Builtin
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'('           Punctuation
'first'       Name.Builtin
' '           Text
'y'           Name.Variable
')'           Punctuation
' '           Text
"'EQL"        Literal.String.Symbol
')'           Punctuation
' '           Text
'('           Punctuation
'eql'         Name.Builtin
' '           Text
'('           Punctuation
'length'      Name.Builtin
' '           Text
'y'           Name.Variable
')'           Punctuation
' '           Text
'2'           Literal.Number.Integer
')'           Punctuation
')'           Punctuation
'\n            ' Text
'('           Punctuation
'eql'         Name.Builtin
' '           Text
'x'           Name.Variable
' '           Text
'('           Punctuation
'second'      Name.Builtin
' '           Text
'y'           Name.Variable
')'           Punctuation
')'           Punctuation
'\n         ' Text
')'           Punctuation
'\n         ' Text
'('           Punctuation
'('           Punctuation
'and'         Name.Builtin
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'('           Punctuation
'first'       Name.Builtin
' '           Text
'y'           Name.Variable
')'           Punctuation
' '           Text
"'NOT"        Literal.String.Symbol
')'           Punctuation
' '           Text
'('           Punctuation
'eql'         Name.Builtin
' '           Text
'('           Punctuation
'length'      Name.Builtin
' '           Text
'y'           Name.Variable
')'           Punctuation
' '           Text
'2'           Literal.Number.Integer
')'           Punctuation
')'           Punctuation
'\n            ' Text
'('           Punctuation
'not'         Name.Builtin
' '           Text
'('           Punctuation
'typep'       Name.Builtin
' '           Text
'x'           Name.Variable
' '           Text
'('           Punctuation
'second'      Name.Builtin
' '           Text
'y'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n         ' Text
')'           Punctuation
'\n         ' Text
'('           Punctuation
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'('           Punctuation
'first'       Name.Builtin
' '           Text
'y'           Name.Variable
')'           Punctuation
' '           Text
"'AND"        Literal.String.Symbol
')'           Punctuation
'\n            ' Text
'('           Punctuation
'dolist'      Name.Builtin
' '           Text
'('           Punctuation
'type'        Keyword
' '           Text
'('           Punctuation
'rest'        Name.Builtin
' '           Text
'y'           Name.Variable
')'           Punctuation
' '           Text
't'           Name.Constant
')'           Punctuation
'\n              ' Text
'('           Punctuation
'unless'      Name.Builtin
' '           Text
'('           Punctuation
'typep'       Name.Builtin
' '           Text
'x'           Name.Variable
' '           Text
'type'        Keyword
')'           Punctuation
' '           Text
'('           Punctuation
'return'      Name.Builtin
' '           Text
'nil'         Name.Constant
')'           Punctuation
')'           Punctuation
'\n         ' Text
')'           Punctuation
'  '          Text
')'           Punctuation
'\n         ' Text
'('           Punctuation
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'('           Punctuation
'first'       Name.Builtin
' '           Text
'y'           Name.Variable
')'           Punctuation
' '           Text
"'OR"         Literal.String.Symbol
')'           Punctuation
'\n            ' Text
'('           Punctuation
'dolist'      Name.Builtin
' '           Text
'('           Punctuation
'type'        Keyword
' '           Text
'('           Punctuation
'rest'        Name.Builtin
' '           Text
'y'           Name.Variable
')'           Punctuation
' '           Text
'nil'         Name.Constant
')'           Punctuation
'\n              ' Text
'('           Punctuation
'when'        Name.Builtin
' '           Text
'('           Punctuation
'typep'       Name.Builtin
' '           Text
'x'           Name.Variable
' '           Text
'type'        Keyword
')'           Punctuation
' '           Text
'('           Punctuation
'return'      Name.Builtin
' '           Text
't'           Name.Constant
')'           Punctuation
')'           Punctuation
'\n         ' Text
')'           Punctuation
'  '          Text
')'           Punctuation
'\n         ' Text
'('           Punctuation
'('           Punctuation
'setq'        Keyword
' '           Text
'f'           Name.Variable
' '           Text
'('           Punctuation
'get'         Name.Builtin
' '           Text
'('           Punctuation
'first'       Name.Builtin
' '           Text
'y'           Name.Variable
')'           Punctuation
' '           Text
"'TYPE-LIST"  Literal.String.Symbol
')'           Punctuation
')'           Punctuation
' '           Text
'('           Punctuation
'apply'       Name.Builtin
' '           Text
'f'           Name.Variable
' '           Text
'x'           Name.Variable
' '           Text
'('           Punctuation
'rest'        Name.Builtin
' '           Text
'y'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n         ' Text
'('           Punctuation
't'           Name.Constant
' '           Text
'('           Punctuation
'typespec-error' Name.Variable
' '           Text
"'typep"      Literal.String.Symbol
' '           Text
'y'           Name.Variable
')'           Punctuation
')'           Punctuation
'\n    '      Text
')'           Punctuation
'  '          Text
')'           Punctuation
'\n    '      Text
'('           Punctuation
'('           Punctuation
'clos::defined-class-p' Name.Variable
' '           Text
'y'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'clos::typep-class' Name.Variable
' '           Text
'x'           Name.Variable
' '           Text
'y'           Name.Variable
')'           Punctuation
')'           Punctuation
'\n    '      Text
'('           Punctuation
'('           Punctuation
'clos::eql-specializer-p' Name.Variable
' '           Text
'y'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'eql'         Name.Builtin
' '           Text
'x'           Name.Variable
' '           Text
'('           Punctuation
'clos::eql-specializer-singleton' Name.Variable
' '           Text
'y'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n    '      Text
'('           Punctuation
'('           Punctuation
'encodingp'   Name.Variable
' '           Text
'y'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'charset-typep' Name.Variable
' '           Text
'x'           Name.Variable
' '           Text
'y'           Name.Variable
')'           Punctuation
')'           Punctuation
'\n    '      Text
'('           Punctuation
't'           Name.Constant
' '           Text
'('           Punctuation
'typespec-error' Name.Variable
' '           Text
"'typep"      Literal.String.Symbol
' '           Text
'y'           Name.Variable
')'           Punctuation
')'           Punctuation
'\n'          Text

')'           Punctuation
' '           Text
')'           Punctuation
'\n\n'        Text

';; ----------------------------------------------------------------------------' Comment.Single
'\n\n'        Text

';; UPGRADED-ARRAY-ELEMENT-TYPE is a lattice homomorphism, see' Comment.Single
'\n'          Text

';; ANSI CL 15.1.2.1.' Comment.Single
'\n'          Text

'('           Punctuation
'defun'       Name.Builtin
' '           Text
'upgraded-array-element-type' Name.Builtin
' '           Text
'('           Punctuation
'type'        Keyword
' '           Text
'&optional'   Keyword
' '           Text
'environment' Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'declare'     Keyword
' '           Text
'('           Punctuation
'ignore'      Keyword
' '           Text
'environment' Name.Variable
')'           Punctuation
')'           Punctuation
'\n  '        Text
';; see array.d' Comment.Single
'\n  '        Text
'('           Punctuation
'case'        Name.Builtin
' '           Text
'type'        Keyword
'\n    '      Text
'('           Punctuation
'('           Punctuation
'BIT'         Name.Variable
')'           Punctuation
' '           Text
"'BIT"        Literal.String.Symbol
')'           Punctuation
'\n    '      Text
'('           Punctuation
'('           Punctuation
'CHARACTER'   Name.Variable
')'           Punctuation
' '           Text
"'CHARACTER"  Literal.String.Symbol
')'           Punctuation
'\n    '      Text
'('           Punctuation
'('           Punctuation
'T'           Name.Constant
')'           Punctuation
' '           Text
"'T"          Literal.String.Symbol
')'           Punctuation
'\n    '      Text
'('           Punctuation
'('           Punctuation
'NIL'         Name.Constant
')'           Punctuation
' '           Text
"'NIL"        Literal.String.Symbol
')'           Punctuation
'\n    '      Text
'('           Punctuation
't'           Name.Constant
' '           Text
'('           Punctuation
'if'          Keyword
' '           Text
'('           Punctuation
'subtypep'    Name.Builtin
' '           Text
'type'        Keyword
' '           Text
"'NIL"        Literal.String.Symbol
')'           Punctuation
'\n         ' Text
"'NIL"        Literal.String.Symbol
'\n         ' Text
'('           Punctuation
'multiple-value-bind' Name.Builtin
' '           Text
'('           Punctuation
'low'         Name.Variable
' '           Text
'high'        Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'sys::subtype-integer' Name.Variable
' '           Text
'type'        Keyword
')'           Punctuation
'\n           ' Text
'; Es gilt (or (null low) (subtypep type `(INTEGER ,low ,high)))' Comment.Single
'\n           ' Text
'('           Punctuation
'if'          Keyword
' '           Text
'('           Punctuation
'and'         Name.Builtin
' '           Text
'('           Punctuation
'integerp'    Name.Builtin
' '           Text
'low'         Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'not'         Name.Builtin
' '           Text
'('           Punctuation
'minusp'      Name.Builtin
' '           Text
'low'         Name.Variable
')'           Punctuation
')'           Punctuation
' '           Text
'('           Punctuation
'integerp'    Name.Builtin
' '           Text
'high'        Name.Variable
')'           Punctuation
')'           Punctuation
'\n             ' Text
'('           Punctuation
'let'         Keyword
' '           Text
'('           Punctuation
'('           Punctuation
'l'           Name.Variable
' '           Text
'('           Punctuation
'integer-length' Name.Builtin
' '           Text
'high'        Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n               ' Text
'; Es gilt (subtypep type `(UNSIGNED-BYTE ,l))' Comment.Single
'\n               ' Text
'('           Punctuation
'cond'        Name.Builtin
' '           Text
'('           Punctuation
'('           Punctuation
'<='          Name.Builtin
' '           Text
'l'           Name.Variable
' '           Text
'1'           Literal.Number.Integer
')'           Punctuation
' '           Text
"'BIT"        Literal.String.Symbol
')'           Punctuation
'\n                     ' Text
'('           Punctuation
'('           Punctuation
'<='          Name.Builtin
' '           Text
'l'           Name.Variable
' '           Text
'2'           Literal.Number.Integer
')'           Punctuation
' '           Text
"'"           Operator
'('           Punctuation
'UNSIGNED-BYTE' Name.Variable
' '           Text
'2'           Literal.Number.Integer
')'           Punctuation
')'           Punctuation
'\n                     ' Text
'('           Punctuation
'('           Punctuation
'<='          Name.Builtin
' '           Text
'l'           Name.Variable
' '           Text
'4'           Literal.Number.Integer
')'           Punctuation
' '           Text
"'"           Operator
'('           Punctuation
'UNSIGNED-BYTE' Name.Variable
' '           Text
'4'           Literal.Number.Integer
')'           Punctuation
')'           Punctuation
'\n                     ' Text
'('           Punctuation
'('           Punctuation
'<='          Name.Builtin
' '           Text
'l'           Name.Variable
' '           Text
'8'           Literal.Number.Integer
')'           Punctuation
' '           Text
"'"           Operator
'('           Punctuation
'UNSIGNED-BYTE' Name.Variable
' '           Text
'8'           Literal.Number.Integer
')'           Punctuation
')'           Punctuation
'\n                     ' Text
'('           Punctuation
'('           Punctuation
'<='          Name.Builtin
' '           Text
'l'           Name.Variable
' '           Text
'16'          Literal.Number.Integer
')'           Punctuation
' '           Text
"'"           Operator
'('           Punctuation
'UNSIGNED-BYTE' Name.Variable
' '           Text
'16'          Literal.Number.Integer
')'           Punctuation
')'           Punctuation
'\n                     ' Text
'('           Punctuation
'('           Punctuation
'<='          Name.Builtin
' '           Text
'l'           Name.Variable
' '           Text
'32'          Literal.Number.Integer
')'           Punctuation
' '           Text
"'"           Operator
'('           Punctuation
'UNSIGNED-BYTE' Name.Variable
' '           Text
'32'          Literal.Number.Integer
')'           Punctuation
')'           Punctuation
'\n                     ' Text
'('           Punctuation
't'           Name.Constant
' '           Text
"'T"          Literal.String.Symbol
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n             ' Text
'('           Punctuation
'if'          Keyword
' '           Text
'('           Punctuation
'subtypep'    Name.Builtin
' '           Text
'type'        Keyword
' '           Text
"'CHARACTER"  Literal.String.Symbol
')'           Punctuation
'\n               ' Text
"'CHARACTER"  Literal.String.Symbol
'\n               ' Text
"'T"          Literal.String.Symbol
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

';; ----------------------------------------------------------------------------' Comment.Single
'\n\n'        Text

';; UPGRADED-COMPLEX-PART-TYPE is a lattice homomorphism, see' Comment.Single
'\n'          Text

';; HyperSpec/Body/fun_complex.html and HyperSpec/Body/syscla_complex.html,' Comment.Single
'\n'          Text

';; and an idempotent. Therefore' Comment.Single
'\n'          Text

';;   (subtypep (upgraded-complex-part-type T1) (upgraded-complex-part-type T2))' Comment.Single
'\n'          Text

';; is equivalent to' Comment.Single
'\n'          Text

';;   (subtypep T1 (upgraded-complex-part-type T2))' Comment.Single
'\n'          Text

';; (Proof: Let U T be an abbreviation for (upgraded-complex-part-type T).' Comment.Single
'\n'          Text

';;  If U T1 <= U T2, then T1 <= U T1 <= U T2.' Comment.Single
'\n'          Text

';;  If T1 <= U T2, then by homomorphism U T1 <= U U T2 = U T2.)' Comment.Single
'\n'          Text

';;'          Comment.Single
'\n'          Text

';; For _any_ CL implementation, you could define' Comment.Single
'\n'          Text

";;   (defun upgraded-complex-part-type (type) 'REAL)" Comment.Single
'\n'          Text

';; Likewise for _any_ CL implementation, you could define' Comment.Single
'\n'          Text

';;   (defun upgraded-complex-part-type (type) type)' Comment.Single
'\n'          Text

';; or - again for _any_ CL implementation:' Comment.Single
'\n'          Text

';;   (defun upgraded-complex-part-type (type)' Comment.Single
'\n'          Text

";;     (cond ((subtypep type 'NIL) 'NIL)" Comment.Single
'\n'          Text

";;           ((subtypep type 'SHORT-FLOAT) 'SHORT-FLOAT)" Comment.Single
'\n'          Text

";;           ((subtypep type 'SINGLE-FLOAT) 'SINGLE-FLOAT)" Comment.Single
'\n'          Text

";;           ((subtypep type 'DOUBLE-FLOAT) 'DOUBLE-FLOAT)" Comment.Single
'\n'          Text

";;           ((subtypep type 'LONG-FLOAT) 'LONG-FLOAT)" Comment.Single
'\n'          Text

";;           ((subtypep type 'RATIONAL) 'RATIONAL)" Comment.Single
'\n'          Text

";;           ((subtypep type 'REAL) 'REAL)" Comment.Single
'\n'          Text

';;           (t (error ...))))' Comment.Single
'\n'          Text

';; The reason is that a complex number is immutable: no setters for the' Comment.Single
'\n'          Text

';; realpart and imagpart exist.' Comment.Single
'\n'          Text

';;'          Comment.Single
'\n'          Text

';; We choose the second implementation because it allows the most precise' Comment.Single
'\n'          Text

';; type inference.' Comment.Single
'\n'          Text

'('           Punctuation
'defun'       Name.Builtin
' '           Text
'upgraded-complex-part-type' Name.Builtin
' '           Text
'('           Punctuation
'type'        Keyword
' '           Text
'&optional'   Keyword
' '           Text
'environment' Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'declare'     Keyword
' '           Text
'('           Punctuation
'ignore'      Keyword
' '           Text
'environment' Name.Variable
')'           Punctuation
')'           Punctuation
'\n  '        Text
'('           Punctuation
'if'          Keyword
' '           Text
'('           Punctuation
'subtypep'    Name.Builtin
' '           Text
'type'        Keyword
' '           Text
"'REAL"       Literal.String.Symbol
')'           Punctuation
'\n    '      Text
'type'        Keyword
'\n    '      Text
'('           Punctuation
'error-of-type' Name.Variable
' '           Text
"'error"      Literal.String.Symbol
'\n      '    Text
'('           Punctuation
'TEXT'        Name.Variable
' '           Text
'"~S: type ~S is not a subtype of ~S"' Literal.String
')'           Punctuation
'\n      '    Text
"'upgraded-complex-part-type" Literal.String.Symbol
' '           Text
'type'        Keyword
' '           Text
"'real"       Literal.String.Symbol
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

';; ----------------------------------------------------------------------------' Comment.Single
'\n\n'        Text

';; Macros for defining the various built-in "atomic type specifier"s and' Comment.Single
'\n'          Text

';; "compound type specifier"s. The following macros add information for both' Comment.Single
'\n'          Text

';; the TYPEP function above and the c-TYPEP in the compiler.' Comment.Single
'\n\n'        Text

'; Alist symbol -> funname, used by the compiler.' Comment.Single
'\n'          Text

'('           Punctuation
'defparameter' Name.Builtin
' '           Text
'c-typep-alist1' Name.Variable
' '           Text
"'"           Operator
'('           Punctuation
')'           Punctuation
')'           Punctuation
'\n'          Text

'; Alist symbol -> lambdabody, used by the compiler.' Comment.Single
'\n'          Text

'('           Punctuation
'defparameter' Name.Builtin
' '           Text
'c-typep-alist2' Name.Variable
' '           Text
"'"           Operator
'('           Punctuation
')'           Punctuation
')'           Punctuation
'\n'          Text

'; Alist symbol -> expander function, used by the compiler.' Comment.Single
'\n'          Text

'('           Punctuation
'defparameter' Name.Builtin
' '           Text
'c-typep-alist3' Name.Variable
' '           Text
"'"           Operator
'('           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'; (def-atomic-type symbol function-name)' Comment.Single
'\n'          Text

'; defines an atomic type. The function-name designates a function taking one' Comment.Single
'\n'          Text

'; argument and returning a generalized boolean value. It can be either a' Comment.Single
'\n'          Text

'; symbol or a lambda expression.' Comment.Single
'\n'          Text

'('           Punctuation
'defmacro'    Name.Builtin
' '           Text
'def-atomic-type' Name.Variable
' '           Text
'('           Punctuation
'symbol'      Name.Class
' '           Text
'funname'     Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'let'         Keyword
' '           Text
'('           Punctuation
'('           Punctuation
'lambdap'     Name.Variable
' '           Text
'('           Punctuation
'and'         Name.Builtin
' '           Text
'('           Punctuation
'consp'       Name.Builtin
' '           Text
'funname'     Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'('           Punctuation
'car'         Name.Builtin
' '           Text
'funname'     Name.Variable
')'           Punctuation
' '           Text
"'LAMBDA"     Literal.String.Symbol
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n    '      Text
'`'           Operator
'('           Punctuation
'PROGN'       Name.Variable
'\n       '   Text
'('           Punctuation
'SETF'        Name.Variable
' '           Text
'('           Punctuation
'GET'         Name.Variable
' '           Text
"',symbol"    Literal.String.Symbol
' '           Text
"'TYPE-SYMBOL" Literal.String.Symbol
')'           Punctuation
'\n             ' Text
','           Operator
'('           Punctuation
'if'          Keyword
' '           Text
'lambdap'     Name.Variable
'\n                ' Text
'`'           Operator
'('           Punctuation
'FUNCTION'    Name.Variable
' '           Text
','           Operator
'('           Punctuation
'concat-pnames' Name.Variable
' '           Text
'"TYPE-SYMBOL-"' Literal.String
' '           Text
'symbol'      Name.Class
')'           Punctuation
' '           Text
','           Operator
'funname'     Name.Variable
')'           Punctuation
'\n                ' Text
'`'           Operator
'('           Punctuation
'FUNCTION'    Name.Variable
' '           Text
','           Operator
'funname'     Name.Variable
')'           Punctuation
'\n              ' Text
')'           Punctuation
'\n       '   Text
')'           Punctuation
'\n       '   Text
','           Operator
'('           Punctuation
'if'          Keyword
' '           Text
'lambdap'     Name.Variable
'\n          ' Text
'`'           Operator
'('           Punctuation
'SETQ'        Name.Variable
' '           Text
'C-TYPEP-ALIST2' Name.Variable
'\n                 ' Text
'('           Punctuation
'NCONC'       Name.Variable
' '           Text
'C-TYPEP-ALIST2' Name.Variable
' '           Text
'('           Punctuation
'LIST'        Name.Variable
' '           Text
'('           Punctuation
'CONS'        Name.Variable
' '           Text
"',symbol"    Literal.String.Symbol
' '           Text
"',"          Literal.String.Symbol
'('           Punctuation
'cdr'         Name.Builtin
' '           Text
'funname'     Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n           ' Text
')'           Punctuation
'\n          ' Text
'`'           Operator
'('           Punctuation
'SETQ'        Name.Variable
' '           Text
'C-TYPEP-ALIST1' Name.Variable
'\n                 ' Text
'('           Punctuation
'NCONC'       Name.Variable
' '           Text
'C-TYPEP-ALIST1' Name.Variable
' '           Text
'('           Punctuation
'LIST'        Name.Variable
' '           Text
'('           Punctuation
'CONS'        Name.Variable
' '           Text
"',symbol"    Literal.String.Symbol
' '           Text
"',funname"   Literal.String.Symbol
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n           ' Text
')'           Punctuation
'\n        '  Text
')'           Punctuation
'\n       '   Text
"',symbol"    Literal.String.Symbol
'\n     '     Text
')'           Punctuation
'\n'          Text

')'           Punctuation
' '           Text
')'           Punctuation
'\n\n'        Text

'; (def-compound-type symbol lambda-list (x) check-form typep-form c-typep-form)' Comment.Single
'\n'          Text

'; defines a compound type. The lambda-list is of the form (&optional ...)' Comment.Single
'\n'          Text

'; where the arguments come from the CDR of the type specifier.' Comment.Single
'\n'          Text

'; For typep-form, x is an object.' Comment.Single
'\n'          Text

'; For c-typep-form, x is a multiply evaluatable form (actually a gensym).' Comment.Single
'\n'          Text

"; check-form is a form performing error checking, may call `error'." Comment.Single
'\n'          Text

'; typep-form should return a generalized boolean value.' Comment.Single
'\n'          Text

'; c-typep-form should produce a form returning a generalized boolean value.' Comment.Single
'\n'          Text

'('           Punctuation
'defmacro'    Name.Builtin
' '           Text
'def-compound-type' Name.Variable
' '           Text
'('           Punctuation
'symbol'      Name.Class
' '           Text
'lambdalist'  Name.Variable
' '           Text
'('           Punctuation
'var'         Name.Variable
')'           Punctuation
' '           Text
'check-form'  Name.Variable
' '           Text
'typep-form'  Name.Variable
' '           Text
'c-typep-form' Name.Variable
')'           Punctuation
'\n  '        Text
'`'           Operator
'('           Punctuation
'PROGN'       Name.Variable
'\n     '     Text
'('           Punctuation
'SETF'        Name.Variable
' '           Text
'('           Punctuation
'GET'         Name.Variable
' '           Text
"',symbol"    Literal.String.Symbol
' '           Text
"'TYPE-LIST"  Literal.String.Symbol
')'           Punctuation
'\n           ' Text
'('           Punctuation
'FUNCTION'    Name.Variable
' '           Text
','           Operator
'('           Punctuation
'concat-pnames' Name.Variable
' '           Text
'"TYPE-LIST-"' Literal.String
' '           Text
'symbol'      Name.Class
')'           Punctuation
'\n             ' Text
'('           Punctuation
'LAMBDA'      Name.Variable
' '           Text
'('           Punctuation
','           Operator
'var'         Name.Variable
' '           Text
',@'          Operator
'lambdalist'  Name.Variable
')'           Punctuation
'\n               ' Text
',@'          Operator
'('           Punctuation
'if'          Keyword
' '           Text
'check-form'  Name.Variable
'\n                   ' Text
'`'           Operator
'('           Punctuation
'('           Punctuation
'MACROLET'    Name.Variable
' '           Text
'('           Punctuation
'('           Punctuation
'ERROR'       Name.Variable
' '           Text
'('           Punctuation
'&REST'       Name.Variable
' '           Text
'ERROR-ARGS'  Name.Variable
')'           Punctuation
'\n                                  ' Text
'('           Punctuation
'LIST*'       Name.Variable
' '           Text
"'ERROR-OF-TYPE" Literal.String.Symbol
' '           Text
"'"           Operator
"'ERROR"      Literal.String.Symbol
' '           Text
'ERROR-ARGS'  Name.Variable
')'           Punctuation
'\n                               ' Text
')'           Punctuation
')'           Punctuation
'\n                       ' Text
','           Operator
'check-form'  Name.Variable
'\n                    ' Text
')'           Punctuation
')'           Punctuation
'\n                 ' Text
')'           Punctuation
'\n               ' Text
','           Operator
'typep-form'  Name.Variable
'\n     '     Text
')'           Punctuation
'     '       Text
')'           Punctuation
' '           Text
')'           Punctuation
'\n     '     Text
'('           Punctuation
'SETQ'        Name.Variable
' '           Text
'C-TYPEP-ALIST3' Name.Variable
'\n           ' Text
'('           Punctuation
'NCONC'       Name.Variable
' '           Text
'C-TYPEP-ALIST3' Name.Variable
'\n                  ' Text
'('           Punctuation
'LIST'        Name.Variable
' '           Text
'('           Punctuation
'CONS'        Name.Variable
' '           Text
"',symbol"    Literal.String.Symbol
'\n                              ' Text
"#'"          Name.Function
'('           Punctuation
'LAMBDA'      Name.Variable
' '           Text
'('           Punctuation
','           Operator
'var'         Name.Variable
' '           Text
',@'          Operator
'lambdalist'  Name.Variable
' '           Text
'&REST'       Name.Variable
' '           Text
'ILLEGAL-ARGS' Name.Variable
')'           Punctuation
'\n                                  ' Text
'('           Punctuation
'DECLARE'     Name.Variable
' '           Text
'('           Punctuation
'IGNORE'      Name.Variable
' '           Text
'ILLEGAL-ARGS' Name.Variable
')'           Punctuation
')'           Punctuation
'\n                                  ' Text
',@'          Operator
'('           Punctuation
'if'          Keyword
' '           Text
'check-form'  Name.Variable
'\n                                      ' Text
'`'           Operator
'('           Punctuation
'('           Punctuation
'MACROLET'    Name.Variable
' '           Text
'('           Punctuation
'('           Punctuation
'ERROR'       Name.Variable
' '           Text
'('           Punctuation
'&REST'       Name.Variable
' '           Text
'ERROR-ARGS'  Name.Variable
')'           Punctuation
'\n                                                     ' Text
'('           Punctuation
'LIST'        Name.Variable
' '           Text
"'PROGN"      Literal.String.Symbol
'\n                                                           ' Text
'('           Punctuation
'LIST*'       Name.Variable
' '           Text
"'C-WARN"     Literal.String.Symbol
' '           Text
'ERROR-ARGS'  Name.Variable
')'           Punctuation
'\n                                                           ' Text
"'"           Operator
'('           Punctuation
'THROW'       Name.Variable
' '           Text
"'C-TYPEP"    Literal.String.Symbol
' '           Text
'NIL'         Name.Constant
')'           Punctuation
'\n                                                  ' Text
')'           Punctuation
')'           Punctuation
' '           Text
')'           Punctuation
'\n                                          ' Text
','           Operator
'check-form'  Name.Variable
'\n                                       ' Text
')'           Punctuation
')'           Punctuation
'\n                                    ' Text
')'           Punctuation
'\n                                  ' Text
','           Operator
'c-typep-form' Name.Variable
'\n                                ' Text
')'           Punctuation
'\n     '     Text
')'           Punctuation
'     '       Text
')'           Punctuation
'      '      Text
')'           Punctuation
'     '       Text
')'           Punctuation
'\n     '     Text
"',symbol"    Literal.String.Symbol
'\n   '       Text
')'           Punctuation
'\n'          Text

')'           Punctuation
'\n\n'        Text

'; CLtL1 p. 43' Comment.Single
'\n'          Text

'('           Punctuation
'def-atomic-type' Name.Variable
' '           Text
'ARRAY'       Name.Variable
' '           Text
'arrayp'      Name.Builtin
')'           Punctuation
'\n'          Text

'('           Punctuation
'def-atomic-type' Name.Variable
' '           Text
'ATOM'        Name.Variable
' '           Text
'atom'        Name.Builtin
')'           Punctuation
'\n'          Text

'('           Punctuation
'def-atomic-type' Name.Variable
' '           Text
'BASE-CHAR'   Name.Variable
'\n  '        Text
'#+'          Operator
'BASE-CHAR=CHARACTER' Name.Variable
'\n  '        Text
'characterp'  Name.Builtin
'\n  '        Text
'#-'          Operator
'BASE-CHAR=CHARACTER' Name.Variable
'\n  '        Text
'('           Punctuation
'lambda'      Keyword
' '           Text
'('           Punctuation
'x'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'and'         Name.Builtin
' '           Text
'('           Punctuation
'characterp'  Name.Builtin
' '           Text
'x'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'base-char-p' Name.Variable
' '           Text
'x'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n'          Text

')'           Punctuation
'\n'          Text

'('           Punctuation
'def-atomic-type' Name.Variable
' '           Text
'BASE-STRING' Name.Variable
'\n  '        Text
'('           Punctuation
'lambda'      Keyword
' '           Text
'('           Punctuation
'x'           Name.Variable
')'           Punctuation
'\n    '      Text
'('           Punctuation
'and'         Name.Builtin
' '           Text
'('           Punctuation
'stringp'     Name.Builtin
' '           Text
'x'           Name.Variable
')'           Punctuation
'\n         ' Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'('           Punctuation
'array-element-type' Name.Builtin
' '           Text
'x'           Name.Variable
')'           Punctuation
'\n             ' Text
'#+'          Operator
'BASE-CHAR=CHARACTER' Name.Variable
' '           Text
"'CHARACTER"  Literal.String.Symbol
' '           Text
'#-'          Operator
'BASE-CHAR=CHARACTER' Name.Variable
' '           Text
"'BASE-CHAR"  Literal.String.Symbol
'\n'          Text

')'           Punctuation
' '           Text
')'           Punctuation
' '           Text
')'           Punctuation
'    '        Text
')'           Punctuation
'\n'          Text

'('           Punctuation
'def-atomic-type' Name.Variable
' '           Text
'BIGNUM'      Name.Variable
'\n  '        Text
'('           Punctuation
'lambda'      Keyword
' '           Text
'('           Punctuation
'x'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'and'         Name.Builtin
' '           Text
'('           Punctuation
'integerp'    Name.Builtin
' '           Text
'x'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'not'         Name.Builtin
' '           Text
'('           Punctuation
'fixnump'     Name.Variable
' '           Text
'x'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n'          Text

')'           Punctuation
'\n'          Text

'('           Punctuation
'def-atomic-type' Name.Variable
' '           Text
'BIT'         Name.Variable
'\n  '        Text
'('           Punctuation
'lambda'      Keyword
' '           Text
'('           Punctuation
'x'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'or'          Name.Builtin
' '           Text
'('           Punctuation
'eql'         Name.Builtin
' '           Text
'x'           Name.Variable
' '           Text
'0'           Literal.Number.Integer
')'           Punctuation
' '           Text
'('           Punctuation
'eql'         Name.Builtin
' '           Text
'x'           Name.Variable
' '           Text
'1'           Literal.Number.Integer
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n'          Text

')'           Punctuation
'\n'          Text

'('           Punctuation
'def-atomic-type' Name.Variable
' '           Text
'BIT-VECTOR'  Name.Variable
' '           Text
'bit-vector-p' Name.Builtin
')'           Punctuation
'\n'          Text

'('           Punctuation
'def-atomic-type' Name.Variable
' '           Text
'BOOLEAN'     Name.Variable
'\n  '        Text
'('           Punctuation
'lambda'      Keyword
' '           Text
'('           Punctuation
'x'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'or'          Name.Builtin
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'x'           Name.Variable
' '           Text
"'nil"        Literal.String.Symbol
')'           Punctuation
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'x'           Name.Variable
' '           Text
"'t"          Literal.String.Symbol
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n'          Text

')'           Punctuation
'\n'          Text

'('           Punctuation
'def-atomic-type' Name.Variable
' '           Text
'CHARACTER'   Name.Variable
' '           Text
'characterp'  Name.Builtin
')'           Punctuation
'\n'          Text

'('           Punctuation
'def-atomic-type' Name.Variable
' '           Text
'COMPILED-FUNCTION' Name.Variable
' '           Text
'compiled-function-p' Name.Builtin
')'           Punctuation
'\n'          Text

'('           Punctuation
'def-atomic-type' Name.Variable
' '           Text
'COMPLEX'     Name.Variable
' '           Text
'complexp'    Name.Builtin
')'           Punctuation
'\n'          Text

'('           Punctuation
'def-atomic-type' Name.Variable
' '           Text
'CONS'        Name.Variable
' '           Text
'consp'       Name.Builtin
')'           Punctuation
'\n'          Text

'('           Punctuation
'def-atomic-type' Name.Variable
' '           Text
'DOUBLE-FLOAT' Name.Variable
' '           Text
'double-float-p' Name.Variable
')'           Punctuation
'\n'          Text

'('           Punctuation
'def-atomic-type' Name.Variable
' '           Text
'ENCODING'    Name.Variable
' '           Text
'encodingp'   Name.Variable
')'           Punctuation
'\n'          Text

'('           Punctuation
'def-atomic-type' Name.Variable
' '           Text
'EXTENDED-CHAR' Name.Variable
'\n  '        Text
'#+'          Operator
'BASE-CHAR=CHARACTER' Name.Variable
'\n  '        Text
'('           Punctuation
'lambda'      Keyword
' '           Text
'('           Punctuation
'x'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'declare'     Keyword
' '           Text
'('           Punctuation
'ignore'      Keyword
' '           Text
'x'           Name.Variable
')'           Punctuation
')'           Punctuation
' '           Text
'nil'         Name.Constant
')'           Punctuation
'\n  '        Text
'#-'          Operator
'BASE-CHAR=CHARACTER' Name.Variable
'\n  '        Text
'('           Punctuation
'lambda'      Keyword
' '           Text
'('           Punctuation
'x'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'and'         Name.Builtin
' '           Text
'('           Punctuation
'characterp'  Name.Builtin
' '           Text
'x'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'not'         Name.Builtin
' '           Text
'('           Punctuation
'base-char-p' Name.Variable
' '           Text
'x'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n'          Text

')'           Punctuation
'\n'          Text

'('           Punctuation
'def-atomic-type' Name.Variable
' '           Text
'FIXNUM'      Name.Variable
' '           Text
'fixnump'     Name.Variable
')'           Punctuation
'\n'          Text

'('           Punctuation
'def-atomic-type' Name.Variable
' '           Text
'FLOAT'       Name.Variable
' '           Text
'floatp'      Name.Builtin
')'           Punctuation
'\n'          Text

'('           Punctuation
'def-atomic-type' Name.Variable
' '           Text
'FUNCTION'    Name.Variable
' '           Text
'functionp'   Name.Builtin
')'           Punctuation
'\n'          Text

'('           Punctuation
'def-atomic-type' Name.Variable
' '           Text
'HASH-TABLE'  Name.Variable
' '           Text
'hash-table-p' Name.Builtin
')'           Punctuation
'\n'          Text

'('           Punctuation
'def-atomic-type' Name.Variable
' '           Text
'INTEGER'     Name.Variable
' '           Text
'integerp'    Name.Builtin
')'           Punctuation
'\n'          Text

'('           Punctuation
'def-atomic-type' Name.Variable
' '           Text
'KEYWORD'     Name.Variable
' '           Text
'keywordp'    Name.Builtin
')'           Punctuation
'\n'          Text

'('           Punctuation
'def-atomic-type' Name.Variable
' '           Text
'LIST'        Name.Variable
' '           Text
'listp'       Name.Builtin
')'           Punctuation
'\n'          Text

'#+'          Operator
'LOGICAL-PATHNAMES' Name.Variable
'\n'          Text

'('           Punctuation
'def-atomic-type' Name.Variable
' '           Text
'LOGICAL-PATHNAME' Name.Variable
' '           Text
'logical-pathname-p' Name.Variable
')'           Punctuation
'\n'          Text

'('           Punctuation
'def-atomic-type' Name.Variable
' '           Text
'LONG-FLOAT'  Name.Variable
' '           Text
'long-float-p' Name.Variable
')'           Punctuation
'\n'          Text

'('           Punctuation
'def-atomic-type' Name.Variable
' '           Text
'NIL'         Name.Constant
'\n  '        Text
'('           Punctuation
'lambda'      Keyword
' '           Text
'('           Punctuation
'x'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'declare'     Keyword
' '           Text
'('           Punctuation
'ignore'      Keyword
' '           Text
'x'           Name.Variable
')'           Punctuation
')'           Punctuation
' '           Text
'nil'         Name.Constant
')'           Punctuation
'\n'          Text

')'           Punctuation
'\n'          Text

'('           Punctuation
'def-atomic-type' Name.Variable
' '           Text
'NULL'        Name.Variable
' '           Text
'null'        Name.Builtin
')'           Punctuation
'\n'          Text

'('           Punctuation
'def-atomic-type' Name.Variable
' '           Text
'NUMBER'      Name.Variable
' '           Text
'numberp'     Name.Builtin
')'           Punctuation
'\n'          Text

'('           Punctuation
'def-atomic-type' Name.Variable
' '           Text
'PACKAGE'     Name.Variable
' '           Text
'packagep'    Name.Builtin
')'           Punctuation
'\n'          Text

'('           Punctuation
'def-atomic-type' Name.Variable
' '           Text
'PATHNAME'    Name.Variable
' '           Text
'pathnamep'   Name.Builtin
')'           Punctuation
'\n'          Text

'('           Punctuation
'def-atomic-type' Name.Variable
' '           Text
'RANDOM-STATE' Name.Variable
' '           Text
'random-state-p' Name.Builtin
')'           Punctuation
'\n'          Text

'('           Punctuation
'def-atomic-type' Name.Variable
' '           Text
'RATIO'       Name.Variable
'\n  '        Text
'('           Punctuation
'lambda'      Keyword
' '           Text
'('           Punctuation
'x'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'and'         Name.Builtin
' '           Text
'('           Punctuation
'rationalp'   Name.Builtin
' '           Text
'x'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'not'         Name.Builtin
' '           Text
'('           Punctuation
'integerp'    Name.Builtin
' '           Text
'x'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n'          Text

')'           Punctuation
'\n'          Text

'('           Punctuation
'def-atomic-type' Name.Variable
' '           Text
'RATIONAL'    Name.Variable
' '           Text
'rationalp'   Name.Builtin
')'           Punctuation
'\n'          Text

'('           Punctuation
'def-atomic-type' Name.Variable
' '           Text
'READTABLE'   Name.Variable
' '           Text
'readtablep'  Name.Builtin
')'           Punctuation
'\n'          Text

'('           Punctuation
'def-atomic-type' Name.Variable
' '           Text
'REAL'        Name.Variable
' '           Text
'realp'       Name.Builtin
')'           Punctuation
'\n'          Text

'('           Punctuation
'def-atomic-type' Name.Variable
' '           Text
'SEQUENCE'    Name.Variable
' '           Text
'sequencep'   Name.Variable
')'           Punctuation
'\n'          Text

'('           Punctuation
'def-atomic-type' Name.Variable
' '           Text
'SHORT-FLOAT' Name.Variable
' '           Text
'short-float-p' Name.Variable
')'           Punctuation
'\n'          Text

'('           Punctuation
'def-atomic-type' Name.Variable
' '           Text
'SIMPLE-ARRAY' Name.Variable
' '           Text
'simple-array-p' Name.Variable
')'           Punctuation
'\n'          Text

'('           Punctuation
'def-atomic-type' Name.Variable
' '           Text
'SIMPLE-BASE-STRING' Name.Variable
'\n  '        Text
'('           Punctuation
'lambda'      Keyword
' '           Text
'('           Punctuation
'x'           Name.Variable
')'           Punctuation
'\n    '      Text
'('           Punctuation
'and'         Name.Builtin
' '           Text
'('           Punctuation
'simple-string-p' Name.Builtin
' '           Text
'x'           Name.Variable
')'           Punctuation
'\n         ' Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'('           Punctuation
'array-element-type' Name.Builtin
' '           Text
'x'           Name.Variable
')'           Punctuation
'\n             ' Text
'#+'          Operator
'BASE-CHAR=CHARACTER' Name.Variable
' '           Text
"'CHARACTER"  Literal.String.Symbol
' '           Text
'#-'          Operator
'BASE-CHAR=CHARACTER' Name.Variable
' '           Text
"'BASE-CHAR"  Literal.String.Symbol
'\n'          Text

')'           Punctuation
' '           Text
')'           Punctuation
' '           Text
')'           Punctuation
'    '        Text
')'           Punctuation
'\n'          Text

'('           Punctuation
'def-atomic-type' Name.Variable
' '           Text
'SIMPLE-BIT-VECTOR' Name.Variable
' '           Text
'simple-bit-vector-p' Name.Builtin
')'           Punctuation
'\n'          Text

'('           Punctuation
'def-atomic-type' Name.Variable
' '           Text
'SIMPLE-STRING' Name.Variable
' '           Text
'simple-string-p' Name.Builtin
')'           Punctuation
'\n'          Text

'('           Punctuation
'def-atomic-type' Name.Variable
' '           Text
'SIMPLE-VECTOR' Name.Variable
' '           Text
'simple-vector-p' Name.Builtin
')'           Punctuation
'\n'          Text

'('           Punctuation
'def-atomic-type' Name.Variable
' '           Text
'SINGLE-FLOAT' Name.Variable
' '           Text
'single-float-p' Name.Variable
')'           Punctuation
'\n'          Text

'('           Punctuation
'defun'       Name.Builtin
' '           Text
'%standard-char-p' Name.Variable
' '           Text
'('           Punctuation
'x'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'and'         Name.Builtin
' '           Text
'('           Punctuation
'characterp'  Name.Builtin
' '           Text
'x'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'standard-char-p' Name.Builtin
' '           Text
'x'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
' '           Text
'; ABI'       Comment.Single
'\n'          Text

'('           Punctuation
'def-atomic-type' Name.Variable
' '           Text
'STANDARD-CHAR' Name.Variable
' '           Text
'%standard-char-p' Name.Variable
')'           Punctuation
'\n'          Text

'('           Punctuation
'def-atomic-type' Name.Variable
' '           Text
'CLOS:STANDARD-OBJECT' Name.Variable
' '           Text
'clos::std-instance-p' Name.Variable
')'           Punctuation
'\n'          Text

'('           Punctuation
'def-atomic-type' Name.Variable
' '           Text
'STREAM'      Name.Variable
' '           Text
'streamp'     Name.Builtin
')'           Punctuation
'\n'          Text

'('           Punctuation
'def-atomic-type' Name.Variable
' '           Text
'FILE-STREAM' Name.Variable
' '           Text
'file-stream-p' Name.Variable
')'           Punctuation
'\n'          Text

'('           Punctuation
'def-atomic-type' Name.Variable
' '           Text
'SYNONYM-STREAM' Name.Variable
' '           Text
'synonym-stream-p' Name.Variable
')'           Punctuation
'\n'          Text

'('           Punctuation
'def-atomic-type' Name.Variable
' '           Text
'BROADCAST-STREAM' Name.Variable
' '           Text
'broadcast-stream-p' Name.Variable
')'           Punctuation
'\n'          Text

'('           Punctuation
'def-atomic-type' Name.Variable
' '           Text
'CONCATENATED-STREAM' Name.Variable
' '           Text
'concatenated-stream-p' Name.Variable
')'           Punctuation
'\n'          Text

'('           Punctuation
'def-atomic-type' Name.Variable
' '           Text
'TWO-WAY-STREAM' Name.Variable
' '           Text
'two-way-stream-p' Name.Variable
')'           Punctuation
'\n'          Text

'('           Punctuation
'def-atomic-type' Name.Variable
' '           Text
'ECHO-STREAM' Name.Variable
' '           Text
'echo-stream-p' Name.Variable
')'           Punctuation
'\n'          Text

'('           Punctuation
'def-atomic-type' Name.Variable
' '           Text
'STRING-STREAM' Name.Variable
' '           Text
'string-stream-p' Name.Variable
')'           Punctuation
'\n'          Text

'('           Punctuation
'def-atomic-type' Name.Variable
' '           Text
'STRING'      Name.Variable
' '           Text
'stringp'     Name.Builtin
')'           Punctuation
'\n'          Text

'('           Punctuation
'def-atomic-type' Name.Variable
' '           Text
'STRING-CHAR' Name.Variable
' '           Text
'characterp'  Name.Builtin
')'           Punctuation
'\n'          Text

'('           Punctuation
'def-atomic-type' Name.Variable
' '           Text
'CLOS:STRUCTURE-OBJECT' Name.Variable
' '           Text
'clos::structure-object-p' Name.Variable
')'           Punctuation
'\n'          Text

'('           Punctuation
'def-atomic-type' Name.Variable
' '           Text
'SYMBOL'      Name.Variable
' '           Text
'symbolp'     Name.Builtin
')'           Punctuation
'\n'          Text

'('           Punctuation
'def-atomic-type' Name.Variable
' '           Text
'T'           Name.Constant
' '           Text
'('           Punctuation
'lambda'      Keyword
' '           Text
'('           Punctuation
'x'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'declare'     Keyword
' '           Text
'('           Punctuation
'ignore'      Keyword
' '           Text
'x'           Name.Variable
')'           Punctuation
')'           Punctuation
' '           Text
't'           Name.Constant
')'           Punctuation
')'           Punctuation
'\n'          Text

';; foreign1.lisp is loaded after this file,' Comment.Single
'\n'          Text

';; so these symbols are not external yet' Comment.Single
'\n'          Text

'#+'          Operator
'ffi'         Name.Variable
'\n'          Text

'('           Punctuation
'def-atomic-type' Name.Variable
' '           Text
'ffi::foreign-function' Name.Variable
'\n  '        Text
'('           Punctuation
'lambda'      Keyword
' '           Text
'('           Punctuation
'x'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
"'ffi::foreign-function" Literal.String.Symbol
' '           Text
'('           Punctuation
'type-of'     Name.Builtin
' '           Text
'x'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n'          Text

'#+'          Operator
'ffi'         Name.Variable
'\n'          Text

'('           Punctuation
'def-atomic-type' Name.Variable
' '           Text
'ffi::foreign-variable' Name.Variable
'\n  '        Text
'('           Punctuation
'lambda'      Keyword
' '           Text
'('           Punctuation
'x'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
"'ffi::foreign-variable" Literal.String.Symbol
' '           Text
'('           Punctuation
'type-of'     Name.Builtin
' '           Text
'x'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n'          Text

'#+'          Operator
'ffi'         Name.Variable
'\n'          Text

'('           Punctuation
'def-atomic-type' Name.Variable
' '           Text
'ffi::foreign-address' Name.Variable
'\n  '        Text
'('           Punctuation
'lambda'      Keyword
' '           Text
'('           Punctuation
'x'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
"'ffi::foreign-address" Literal.String.Symbol
' '           Text
'('           Punctuation
'type-of'     Name.Builtin
' '           Text
'x'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n'          Text

';; see lispbibl.d (#define FOREIGN) and predtype.d (TYPE-OF):' Comment.Single
'\n'          Text

'#+'          Operator
'('           Punctuation
'or'          Name.Builtin
' '           Text
'unix'        Name.Variable
' '           Text
'ffi'         Name.Variable
' '           Text
'affi'        Name.Variable
' '           Text
'win32'       Name.Variable
')'           Punctuation
'\n'          Text

'('           Punctuation
'def-atomic-type' Name.Variable
' '           Text
'foreign-pointer' Name.Variable
'\n  '        Text
'('           Punctuation
'lambda'      Keyword
' '           Text
'('           Punctuation
'x'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
"'foreign-pointer" Literal.String.Symbol
' '           Text
'('           Punctuation
'type-of'     Name.Builtin
' '           Text
'x'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n'          Text

'('           Punctuation
'def-atomic-type' Name.Variable
' '           Text
'VECTOR'      Name.Variable
' '           Text
'vectorp'     Name.Builtin
')'           Punctuation
'\n'          Text

'('           Punctuation
'def-atomic-type' Name.Variable
' '           Text
'PLIST'       Name.Variable
'\n    '      Text
'('           Punctuation
'lambda'      Keyword
' '           Text
'('           Punctuation
'x'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'multiple-value-bind' Name.Builtin
' '           Text
'('           Punctuation
'length'      Name.Builtin
' '           Text
'tail'        Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'list-length-dotted' Name.Variable
' '           Text
'x'           Name.Variable
')'           Punctuation
'\n                  ' Text
'('           Punctuation
'and'         Name.Builtin
' '           Text
'('           Punctuation
'null'        Name.Builtin
' '           Text
'tail'        Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'evenp'       Name.Builtin
' '           Text
'length'      Name.Builtin
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'defmacro'    Name.Builtin
' '           Text
'ensure-dim'  Name.Variable
' '           Text
'('           Punctuation
'type'        Keyword
' '           Text
'dim'         Name.Variable
')'           Punctuation
'\n  '        Text
';; make sure DIM is a valid dimension' Comment.Single
'\n  '        Text
'`'           Operator
'('           Punctuation
'unless'      Name.Builtin
' '           Text
'('           Punctuation
'or'          Name.Builtin
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
','           Operator
'dim'         Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
' '           Text
'('           Punctuation
'typep'       Name.Builtin
' '           Text
','           Operator
'dim'         Name.Variable
' '           Text
'`'           Operator
'('           Punctuation
'INTEGER'     Name.Variable
' '           Text
'0'           Literal.Number.Integer
' '           Text
'('           Punctuation
','           Operator
'ARRAY-DIMENSION-LIMIT' Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n     '     Text
'('           Punctuation
'error'       Name.Builtin
' '           Text
'('           Punctuation
'TEXT'        Name.Variable
' '           Text
'"~S: dimension ~S is invalid"' Literal.String
')'           Punctuation
' '           Text
"',type"      Literal.String.Symbol
' '           Text
','           Operator
'dim'         Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'defmacro'    Name.Builtin
' '           Text
'ensure-rank' Name.Variable
' '           Text
'('           Punctuation
'type'        Keyword
' '           Text
'rank'        Name.Variable
')'           Punctuation
'\n  '        Text
';; make sure RANK is a valid rank' Comment.Single
'\n  '        Text
'`'           Operator
'('           Punctuation
'unless'      Name.Builtin
' '           Text
'('           Punctuation
'typep'       Name.Builtin
' '           Text
','           Operator
'rank'        Name.Variable
' '           Text
'`'           Operator
'('           Punctuation
'INTEGER'     Name.Variable
' '           Text
'0'           Literal.Number.Integer
' '           Text
'('           Punctuation
','           Operator
'ARRAY-RANK-LIMIT' Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n     '     Text
'('           Punctuation
'error'       Name.Builtin
' '           Text
'('           Punctuation
'TEXT'        Name.Variable
' '           Text
'"~S: rank ~S is invalid"' Literal.String
')'           Punctuation
' '           Text
"',type"      Literal.String.Symbol
' '           Text
','           Operator
'rank'        Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'; CLtL1 p. 46-50' Comment.Single
'\n'          Text

'('           Punctuation
'defun'       Name.Builtin
' '           Text
'c-typep-array' Name.Variable
' '           Text
'('           Punctuation
'tester'      Name.Variable
' '           Text
'el-type'     Name.Variable
' '           Text
'dims'        Name.Variable
' '           Text
'x'           Name.Variable
')'           Punctuation
'\n  '        Text
'`'           Operator
'('           Punctuation
'AND'         Name.Variable
' '           Text
'('           Punctuation
','           Operator
'tester'      Name.Variable
' '           Text
','           Operator
'x'           Name.Variable
')'           Punctuation
'\n        '  Text
',@'          Operator
'('           Punctuation
'if'          Keyword
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'el-type'     Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
'\n            ' Text
"'"           Operator
'('           Punctuation
')'           Punctuation
'\n            ' Text
'`'           Operator
'('           Punctuation
'('           Punctuation
'EQUAL'       Name.Variable
' '           Text
'('           Punctuation
'ARRAY-ELEMENT-TYPE' Name.Variable
' '           Text
','           Operator
'x'           Name.Variable
')'           Punctuation
' '           Text
"',"          Literal.String.Symbol
'('           Punctuation
'upgraded-array-element-type' Name.Builtin
' '           Text
'el-type'     Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n          ' Text
')'           Punctuation
'\n        '  Text
',@'          Operator
'('           Punctuation
'if'          Keyword
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'dims'        Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
'\n            ' Text
"'"           Operator
'('           Punctuation
')'           Punctuation
'\n            ' Text
'('           Punctuation
'if'          Keyword
' '           Text
'('           Punctuation
'numberp'     Name.Builtin
' '           Text
'dims'        Name.Variable
')'           Punctuation
'\n              ' Text
'`'           Operator
'('           Punctuation
'('           Punctuation
'EQL'         Name.Variable
' '           Text
','           Operator
'dims'        Name.Variable
' '           Text
'('           Punctuation
'ARRAY-RANK'  Name.Variable
' '           Text
','           Operator
'x'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n              ' Text
'`'           Operator
'('           Punctuation
'('           Punctuation
'EQL'         Name.Variable
' '           Text
','           Operator
'('           Punctuation
'length'      Name.Builtin
' '           Text
'dims'        Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'ARRAY-RANK'  Name.Variable
' '           Text
','           Operator
'x'           Name.Variable
')'           Punctuation
')'           Punctuation
'\n                ' Text
',@'          Operator
'('           Punctuation
'let'         Keyword
' '           Text
'('           Punctuation
'('           Punctuation
'i'           Name.Variable
' '           Text
'0'           Literal.Number.Integer
')'           Punctuation
')'           Punctuation
'\n                    ' Text
'('           Punctuation
'mapcap'      Name.Variable
' '           Text
"#'"          Name.Function
'('           Punctuation
'lambda'      Keyword
' '           Text
'('           Punctuation
'dim'         Name.Variable
')'           Punctuation
'\n                                ' Text
'('           Punctuation
'prog1'       Name.Builtin
'\n                                  ' Text
'('           Punctuation
'if'          Keyword
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'dim'         Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
'\n                                    ' Text
"'"           Operator
'('           Punctuation
')'           Punctuation
'\n                                    ' Text
'`'           Operator
'('           Punctuation
'('           Punctuation
'EQL'         Name.Variable
' '           Text
"',dim"       Literal.String.Symbol
' '           Text
'('           Punctuation
'ARRAY-DIMENSION' Name.Variable
' '           Text
','           Operator
'x'           Name.Variable
' '           Text
','           Operator
'i'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n                                  ' Text
')'           Punctuation
'\n                                  ' Text
'('           Punctuation
'incf'        Name.Builtin
' '           Text
'i'           Name.Variable
')'           Punctuation
'\n                              ' Text
')'           Punctuation
' '           Text
')'           Punctuation
'\n                            ' Text
'dims'        Name.Variable
'\n                  ' Text
')'           Punctuation
' '           Text
')'           Punctuation
'\n               ' Text
')'           Punctuation
'\n          ' Text
')'           Punctuation
' '           Text
')'           Punctuation
'\n   '       Text
')'           Punctuation
'\n'          Text

')'           Punctuation
'\n'          Text

'('           Punctuation
'defun'       Name.Builtin
' '           Text
'c-typep-vector' Name.Variable
' '           Text
'('           Punctuation
'tester'      Name.Variable
' '           Text
'size'        Name.Variable
' '           Text
'x'           Name.Variable
')'           Punctuation
'\n  '        Text
'`'           Operator
'('           Punctuation
'AND'         Name.Variable
' '           Text
'('           Punctuation
','           Operator
'tester'      Name.Variable
' '           Text
','           Operator
'x'           Name.Variable
')'           Punctuation
'\n        '  Text
',@'          Operator
'('           Punctuation
'if'          Keyword
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'size'        Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
'\n            ' Text
"'"           Operator
'('           Punctuation
')'           Punctuation
'\n            ' Text
'`'           Operator
'('           Punctuation
'('           Punctuation
'EQL'         Name.Variable
' '           Text
"',size"      Literal.String.Symbol
' '           Text
'('           Punctuation
'ARRAY-DIMENSION' Name.Variable
' '           Text
','           Operator
'x'           Name.Variable
' '           Text
'0'           Literal.Number.Integer
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n          ' Text
')'           Punctuation
'\n   '       Text
')'           Punctuation
'\n'          Text

')'           Punctuation
'\n'          Text

'('           Punctuation
'defun'       Name.Builtin
' '           Text
'typep-number-test' Name.Variable
' '           Text
'('           Punctuation
'x'           Name.Variable
' '           Text
'low'         Name.Variable
' '           Text
'high'        Name.Variable
' '           Text
'test'        Name.Variable
' '           Text
'type'        Keyword
')'           Punctuation
'\n  '        Text
'('           Punctuation
'and'         Name.Builtin
' '           Text
'('           Punctuation
'funcall'     Name.Builtin
' '           Text
'test'        Name.Variable
' '           Text
'x'           Name.Variable
')'           Punctuation
'\n       '   Text
'('           Punctuation
'cond'        Name.Builtin
' '           Text
'('           Punctuation
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'low'         Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
')'           Punctuation
'\n             ' Text
'('           Punctuation
'('           Punctuation
'funcall'     Name.Builtin
' '           Text
'test'        Name.Variable
' '           Text
'low'         Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'<='          Name.Builtin
' '           Text
'low'         Name.Variable
' '           Text
'x'           Name.Variable
')'           Punctuation
')'           Punctuation
'\n             ' Text
'('           Punctuation
'('           Punctuation
'and'         Name.Builtin
' '           Text
'('           Punctuation
'consp'       Name.Builtin
' '           Text
'low'         Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'null'        Name.Builtin
' '           Text
'('           Punctuation
'rest'        Name.Builtin
' '           Text
'low'         Name.Variable
')'           Punctuation
')'           Punctuation
' '           Text
'('           Punctuation
'funcall'     Name.Builtin
' '           Text
'test'        Name.Variable
' '           Text
'('           Punctuation
'first'       Name.Builtin
' '           Text
'low'         Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n                ' Text
'('           Punctuation
'<'           Name.Builtin
' '           Text
'('           Punctuation
'first'       Name.Builtin
' '           Text
'low'         Name.Variable
')'           Punctuation
' '           Text
'x'           Name.Variable
')'           Punctuation
'\n             ' Text
')'           Punctuation
'\n             ' Text
'('           Punctuation
't'           Name.Constant
' '           Text
'('           Punctuation
'error-of-type' Name.Variable
' '           Text
"'error"      Literal.String.Symbol
'\n                  ' Text
'#1='         Operator
'('           Punctuation
'TEXT'        Name.Variable
' '           Text
'"~S: argument to ~S must be *, ~S or a list of ~S: ~S"' Literal.String
')'           Punctuation
'\n                  ' Text
"'typep"      Literal.String.Symbol
' '           Text
'type'        Keyword
' '           Text
'type'        Keyword
' '           Text
'type'        Keyword
' '           Text
'low'         Name.Variable
'\n       '   Text
')'           Punctuation
'     '       Text
')'           Punctuation
'  '          Text
')'           Punctuation
'\n       '   Text
'('           Punctuation
'cond'        Name.Builtin
' '           Text
'('           Punctuation
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'high'        Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
')'           Punctuation
'\n             ' Text
'('           Punctuation
'('           Punctuation
'funcall'     Name.Builtin
' '           Text
'test'        Name.Variable
' '           Text
'high'        Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'>='          Name.Builtin
' '           Text
'high'        Name.Variable
' '           Text
'x'           Name.Variable
')'           Punctuation
')'           Punctuation
'\n             ' Text
'('           Punctuation
'('           Punctuation
'and'         Name.Builtin
' '           Text
'('           Punctuation
'consp'       Name.Builtin
' '           Text
'high'        Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'null'        Name.Builtin
' '           Text
'('           Punctuation
'rest'        Name.Builtin
' '           Text
'high'        Name.Variable
')'           Punctuation
')'           Punctuation
' '           Text
'('           Punctuation
'funcall'     Name.Builtin
' '           Text
'test'        Name.Variable
' '           Text
'('           Punctuation
'first'       Name.Builtin
' '           Text
'high'        Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n                ' Text
'('           Punctuation
'>'           Name.Builtin
' '           Text
'('           Punctuation
'first'       Name.Builtin
' '           Text
'high'        Name.Variable
')'           Punctuation
' '           Text
'x'           Name.Variable
')'           Punctuation
'\n             ' Text
')'           Punctuation
'\n             ' Text
'('           Punctuation
't'           Name.Constant
' '           Text
'('           Punctuation
'error-of-type' Name.Variable
' '           Text
"'error"      Literal.String.Symbol
'\n                  ' Text
'#1#'         Operator
' '           Text
"'typep"      Literal.String.Symbol
' '           Text
'type'        Keyword
' '           Text
'type'        Keyword
' '           Text
'type'        Keyword
' '           Text
'high'        Name.Variable
'\n'          Text

')'           Punctuation
' '           Text
')'           Punctuation
'    '        Text
')'           Punctuation
'     '       Text
')'           Punctuation
'  '          Text
')'           Punctuation
'\n'          Text

'('           Punctuation
'defun'       Name.Builtin
' '           Text
'c-typep-number' Name.Variable
' '           Text
'('           Punctuation
'caller'      Name.Variable
' '           Text
'tester'      Name.Variable
' '           Text
'low'         Name.Variable
' '           Text
'high'        Name.Variable
' '           Text
'x'           Name.Variable
')'           Punctuation
'\n  '        Text
'`'           Operator
'('           Punctuation
'AND'         Name.Variable
' '           Text
'('           Punctuation
','           Operator
'tester'      Name.Variable
' '           Text
','           Operator
'x'           Name.Variable
')'           Punctuation
'\n        '  Text
',@'          Operator
'('           Punctuation
'cond'        Name.Builtin
' '           Text
'('           Punctuation
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'low'         Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
' '           Text
"'"           Operator
'('           Punctuation
')'           Punctuation
')'           Punctuation
'\n                ' Text
'('           Punctuation
'('           Punctuation
'funcall'     Name.Builtin
' '           Text
'tester'      Name.Variable
' '           Text
'low'         Name.Variable
')'           Punctuation
' '           Text
'`'           Operator
'('           Punctuation
'('           Punctuation
'<='          Name.Builtin
' '           Text
','           Operator
'low'         Name.Variable
' '           Text
','           Operator
'x'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n                ' Text
'('           Punctuation
'('           Punctuation
'and'         Name.Builtin
' '           Text
'('           Punctuation
'consp'       Name.Builtin
' '           Text
'low'         Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'null'        Name.Builtin
' '           Text
'('           Punctuation
'rest'        Name.Builtin
' '           Text
'low'         Name.Variable
')'           Punctuation
')'           Punctuation
' '           Text
'('           Punctuation
'funcall'     Name.Builtin
' '           Text
'tester'      Name.Variable
' '           Text
'('           Punctuation
'first'       Name.Builtin
' '           Text
'low'         Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n                 ' Text
'`'           Operator
'('           Punctuation
'('           Punctuation
'<'           Name.Builtin
' '           Text
','           Operator
'('           Punctuation
'first'       Name.Builtin
' '           Text
'low'         Name.Variable
')'           Punctuation
' '           Text
','           Operator
'x'           Name.Variable
')'           Punctuation
')'           Punctuation
'\n                ' Text
')'           Punctuation
'\n                ' Text
'('           Punctuation
't'           Name.Constant
' '           Text
'('           Punctuation
'c-warn'      Name.Variable
' '           Text
'#1='         Operator
'('           Punctuation
'TEXT'        Name.Variable
' '           Text
'"~S: argument to ~S must be *, ~S or a list of ~S: ~S"' Literal.String
')'           Punctuation
'\n                           ' Text
"'typep"      Literal.String.Symbol
' '           Text
'caller'      Name.Variable
' '           Text
'caller'      Name.Variable
' '           Text
'caller'      Name.Variable
' '           Text
'low'         Name.Variable
'\n                   ' Text
')'           Punctuation
'\n                   ' Text
'('           Punctuation
'throw'       Keyword
' '           Text
"'c-TYPEP"    Literal.String.Symbol
' '           Text
'nil'         Name.Constant
')'           Punctuation
'\n          ' Text
')'           Punctuation
'     '       Text
')'           Punctuation
'\n        '  Text
',@'          Operator
'('           Punctuation
'cond'        Name.Builtin
' '           Text
'('           Punctuation
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'high'        Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
' '           Text
"'"           Operator
'('           Punctuation
')'           Punctuation
')'           Punctuation
'\n                ' Text
'('           Punctuation
'('           Punctuation
'funcall'     Name.Builtin
' '           Text
'tester'      Name.Variable
' '           Text
'high'        Name.Variable
')'           Punctuation
' '           Text
'`'           Operator
'('           Punctuation
'('           Punctuation
'>='          Name.Builtin
' '           Text
','           Operator
'high'        Name.Variable
' '           Text
','           Operator
'x'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n                ' Text
'('           Punctuation
'('           Punctuation
'and'         Name.Builtin
' '           Text
'('           Punctuation
'consp'       Name.Builtin
' '           Text
'high'        Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'null'        Name.Builtin
' '           Text
'('           Punctuation
'rest'        Name.Builtin
' '           Text
'high'        Name.Variable
')'           Punctuation
')'           Punctuation
' '           Text
'('           Punctuation
'funcall'     Name.Builtin
' '           Text
'tester'      Name.Variable
' '           Text
'('           Punctuation
'first'       Name.Builtin
' '           Text
'high'        Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n                 ' Text
'`'           Operator
'('           Punctuation
'('           Punctuation
'>'           Name.Builtin
' '           Text
','           Operator
'('           Punctuation
'first'       Name.Builtin
' '           Text
'high'        Name.Variable
')'           Punctuation
' '           Text
','           Operator
'x'           Name.Variable
')'           Punctuation
')'           Punctuation
'\n                ' Text
')'           Punctuation
'\n                ' Text
'('           Punctuation
't'           Name.Constant
' '           Text
'('           Punctuation
'c-warn'      Name.Variable
' '           Text
'#1#'         Operator
' '           Text
"'typep"      Literal.String.Symbol
' '           Text
'caller'      Name.Variable
' '           Text
'caller'      Name.Variable
' '           Text
'caller'      Name.Variable
' '           Text
'high'        Name.Variable
')'           Punctuation
'\n                   ' Text
'('           Punctuation
'throw'       Keyword
' '           Text
"'c-TYPEP"    Literal.String.Symbol
' '           Text
'nil'         Name.Constant
')'           Punctuation
'\n          ' Text
')'           Punctuation
'     '       Text
')'           Punctuation
'\n   '       Text
')'           Punctuation
'\n'          Text

')'           Punctuation
'\n'          Text

'('           Punctuation
'def-compound-type' Name.Variable
' '           Text
'ARRAY'       Name.Variable
' '           Text
'('           Punctuation
'&optional'   Keyword
' '           Text
'('           Punctuation
'el-type'     Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
' '           Text
'('           Punctuation
'dims'        Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
')'           Punctuation
' '           Text
'('           Punctuation
'x'           Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'unless'      Name.Builtin
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'dims'        Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
'\n    '      Text
'('           Punctuation
'if'          Keyword
' '           Text
'('           Punctuation
'numberp'     Name.Builtin
' '           Text
'dims'        Name.Variable
')'           Punctuation
'\n      '    Text
'('           Punctuation
'ensure-rank' Name.Variable
' '           Text
'ARRAY'       Name.Variable
' '           Text
'dims'        Name.Variable
')'           Punctuation
'\n      '    Text
'('           Punctuation
'dolist'      Name.Builtin
' '           Text
'('           Punctuation
'dim'         Name.Variable
' '           Text
'dims'        Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'ensure-dim'  Name.Variable
' '           Text
'ARRAY'       Name.Variable
' '           Text
'dim'         Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n  '        Text
'('           Punctuation
'and'         Name.Builtin
' '           Text
'('           Punctuation
'arrayp'      Name.Builtin
' '           Text
'x'           Name.Variable
')'           Punctuation
'\n       '   Text
'('           Punctuation
'or'          Name.Builtin
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'el-type'     Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
'\n           ' Text
'('           Punctuation
'equal'       Name.Builtin
' '           Text
'('           Punctuation
'array-element-type' Name.Builtin
' '           Text
'x'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'upgraded-array-element-type' Name.Builtin
' '           Text
'el-type'     Name.Variable
')'           Punctuation
')'           Punctuation
'\n       '   Text
')'           Punctuation
'\n       '   Text
'('           Punctuation
'or'          Name.Builtin
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'dims'        Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
'\n           ' Text
'('           Punctuation
'if'          Keyword
' '           Text
'('           Punctuation
'numberp'     Name.Builtin
' '           Text
'dims'        Name.Variable
')'           Punctuation
'\n             ' Text
'('           Punctuation
'eql'         Name.Builtin
' '           Text
'dims'        Name.Variable
' '           Text
'('           Punctuation
'array-rank'  Name.Builtin
' '           Text
'x'           Name.Variable
')'           Punctuation
')'           Punctuation
'\n             ' Text
'('           Punctuation
'and'         Name.Builtin
' '           Text
'('           Punctuation
'eql'         Name.Builtin
' '           Text
'('           Punctuation
'length'      Name.Builtin
' '           Text
'dims'        Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'array-rank'  Name.Builtin
' '           Text
'x'           Name.Variable
')'           Punctuation
')'           Punctuation
'\n                  ' Text
'('           Punctuation
'every'       Name.Builtin
' '           Text
"#'"          Name.Function
'('           Punctuation
'lambda'      Keyword
' '           Text
'('           Punctuation
'a'           Name.Variable
' '           Text
'b'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'or'          Name.Builtin
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'a'           Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
' '           Text
'('           Punctuation
'eql'         Name.Builtin
' '           Text
'a'           Name.Variable
' '           Text
'b'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n                         ' Text
'dims'        Name.Variable
' '           Text
'('           Punctuation
'array-dimensions' Name.Builtin
' '           Text
'x'           Name.Variable
')'           Punctuation
'\n  '        Text
')'           Punctuation
'    '        Text
')'           Punctuation
'   '         Text
')'           Punctuation
' '           Text
')'           Punctuation
'    '        Text
')'           Punctuation
'\n  '        Text
'('           Punctuation
'c-typep-array' Name.Variable
' '           Text
"'ARRAYP"     Literal.String.Symbol
' '           Text
'el-type'     Name.Variable
' '           Text
'dims'        Name.Variable
' '           Text
'x'           Name.Variable
')'           Punctuation
'\n'          Text

')'           Punctuation
'\n'          Text

'('           Punctuation
'def-compound-type' Name.Variable
' '           Text
'SIMPLE-ARRAY' Name.Variable
' '           Text
'('           Punctuation
'&optional'   Keyword
' '           Text
'('           Punctuation
'el-type'     Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
' '           Text
'('           Punctuation
'dims'        Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
')'           Punctuation
' '           Text
'('           Punctuation
'x'           Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'unless'      Name.Builtin
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'dims'        Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
'\n    '      Text
'('           Punctuation
'if'          Keyword
' '           Text
'('           Punctuation
'numberp'     Name.Builtin
' '           Text
'dims'        Name.Variable
')'           Punctuation
'\n      '    Text
'('           Punctuation
'ensure-rank' Name.Variable
' '           Text
'SIMPLE-ARRAY' Name.Variable
' '           Text
'dims'        Name.Variable
')'           Punctuation
'\n      '    Text
'('           Punctuation
'dolist'      Name.Builtin
' '           Text
'('           Punctuation
'dim'         Name.Variable
' '           Text
'dims'        Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'ensure-dim'  Name.Variable
' '           Text
'SIMPLE-ARRAY' Name.Variable
' '           Text
'dim'         Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n  '        Text
'('           Punctuation
'and'         Name.Builtin
' '           Text
'('           Punctuation
'simple-array-p' Name.Variable
' '           Text
'x'           Name.Variable
')'           Punctuation
'\n       '   Text
'('           Punctuation
'or'          Name.Builtin
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'el-type'     Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
'\n           ' Text
'('           Punctuation
'equal'       Name.Builtin
' '           Text
'('           Punctuation
'array-element-type' Name.Builtin
' '           Text
'x'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'upgraded-array-element-type' Name.Builtin
' '           Text
'el-type'     Name.Variable
')'           Punctuation
')'           Punctuation
'\n       '   Text
')'           Punctuation
'\n       '   Text
'('           Punctuation
'or'          Name.Builtin
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'dims'        Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
'\n           ' Text
'('           Punctuation
'if'          Keyword
' '           Text
'('           Punctuation
'numberp'     Name.Builtin
' '           Text
'dims'        Name.Variable
')'           Punctuation
'\n             ' Text
'('           Punctuation
'eql'         Name.Builtin
' '           Text
'dims'        Name.Variable
' '           Text
'('           Punctuation
'array-rank'  Name.Builtin
' '           Text
'x'           Name.Variable
')'           Punctuation
')'           Punctuation
'\n             ' Text
'('           Punctuation
'and'         Name.Builtin
' '           Text
'('           Punctuation
'eql'         Name.Builtin
' '           Text
'('           Punctuation
'length'      Name.Builtin
' '           Text
'dims'        Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'array-rank'  Name.Builtin
' '           Text
'x'           Name.Variable
')'           Punctuation
')'           Punctuation
'\n                  ' Text
'('           Punctuation
'every'       Name.Builtin
' '           Text
"#'"          Name.Function
'('           Punctuation
'lambda'      Keyword
' '           Text
'('           Punctuation
'a'           Name.Variable
' '           Text
'b'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'or'          Name.Builtin
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'a'           Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
' '           Text
'('           Punctuation
'eql'         Name.Builtin
' '           Text
'a'           Name.Variable
' '           Text
'b'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n                         ' Text
'dims'        Name.Variable
' '           Text
'('           Punctuation
'array-dimensions' Name.Builtin
' '           Text
'x'           Name.Variable
')'           Punctuation
'\n  '        Text
')'           Punctuation
'    '        Text
')'           Punctuation
'   '         Text
')'           Punctuation
' '           Text
')'           Punctuation
'    '        Text
')'           Punctuation
'\n  '        Text
'('           Punctuation
'c-typep-array' Name.Variable
' '           Text
"'SIMPLE-ARRAY-P" Literal.String.Symbol
' '           Text
'el-type'     Name.Variable
' '           Text
'dims'        Name.Variable
' '           Text
'x'           Name.Variable
')'           Punctuation
'\n'          Text

')'           Punctuation
'\n'          Text

'('           Punctuation
'def-compound-type' Name.Variable
' '           Text
'VECTOR'      Name.Variable
' '           Text
'('           Punctuation
'&optional'   Keyword
' '           Text
'('           Punctuation
'el-type'     Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
' '           Text
'('           Punctuation
'size'        Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
')'           Punctuation
' '           Text
'('           Punctuation
'x'           Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'ensure-dim'  Name.Variable
' '           Text
'VECTOR'      Name.Variable
' '           Text
'size'        Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'and'         Name.Builtin
' '           Text
'('           Punctuation
'vectorp'     Name.Builtin
' '           Text
'x'           Name.Variable
')'           Punctuation
'\n       '   Text
'('           Punctuation
'or'          Name.Builtin
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'el-type'     Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
'\n           ' Text
'('           Punctuation
'equal'       Name.Builtin
' '           Text
'('           Punctuation
'array-element-type' Name.Builtin
' '           Text
'x'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'upgraded-array-element-type' Name.Builtin
' '           Text
'el-type'     Name.Variable
')'           Punctuation
')'           Punctuation
'\n       '   Text
')'           Punctuation
'\n       '   Text
'('           Punctuation
'or'          Name.Builtin
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'size'        Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
' '           Text
'('           Punctuation
'eql'         Name.Builtin
' '           Text
'('           Punctuation
'array-dimension' Name.Builtin
' '           Text
'x'           Name.Variable
' '           Text
'0'           Literal.Number.Integer
')'           Punctuation
' '           Text
'size'        Name.Variable
')'           Punctuation
')'           Punctuation
'\n  '        Text
')'           Punctuation
'\n  '        Text
'`'           Operator
'('           Punctuation
'AND'         Name.Variable
' '           Text
'('           Punctuation
'VECTORP'     Name.Variable
' '           Text
','           Operator
'x'           Name.Variable
')'           Punctuation
'\n        '  Text
',@'          Operator
'('           Punctuation
'if'          Keyword
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'el-type'     Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
'\n            ' Text
"'"           Operator
'('           Punctuation
')'           Punctuation
'\n            ' Text
'`'           Operator
'('           Punctuation
'('           Punctuation
'EQUAL'       Name.Variable
' '           Text
'('           Punctuation
'ARRAY-ELEMENT-TYPE' Name.Variable
' '           Text
','           Operator
'x'           Name.Variable
')'           Punctuation
' '           Text
"',"          Literal.String.Symbol
'('           Punctuation
'upgraded-array-element-type' Name.Builtin
' '           Text
'el-type'     Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n          ' Text
')'           Punctuation
'\n        '  Text
',@'          Operator
'('           Punctuation
'if'          Keyword
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'size'        Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
'\n            ' Text
"'"           Operator
'('           Punctuation
')'           Punctuation
'\n            ' Text
'`'           Operator
'('           Punctuation
'('           Punctuation
'EQL'         Name.Variable
' '           Text
'('           Punctuation
'ARRAY-DIMENSION' Name.Variable
' '           Text
','           Operator
'x'           Name.Variable
' '           Text
'0'           Literal.Number.Integer
')'           Punctuation
' '           Text
"',size"      Literal.String.Symbol
')'           Punctuation
')'           Punctuation
'\n          ' Text
')'           Punctuation
'\n   '       Text
')'           Punctuation
'\n'          Text

')'           Punctuation
'\n'          Text

'('           Punctuation
'def-compound-type' Name.Variable
' '           Text
'SIMPLE-VECTOR' Name.Variable
' '           Text
'('           Punctuation
'&optional'   Keyword
' '           Text
'('           Punctuation
'size'        Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
')'           Punctuation
' '           Text
'('           Punctuation
'x'           Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'ensure-dim'  Name.Variable
' '           Text
'SIMLPE-VECTOR' Name.Variable
' '           Text
'size'        Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'and'         Name.Builtin
' '           Text
'('           Punctuation
'simple-vector-p' Name.Builtin
' '           Text
'x'           Name.Variable
')'           Punctuation
'\n       '   Text
'('           Punctuation
'or'          Name.Builtin
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'size'        Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
' '           Text
'('           Punctuation
'eql'         Name.Builtin
' '           Text
'size'        Name.Variable
' '           Text
'('           Punctuation
'array-dimension' Name.Builtin
' '           Text
'x'           Name.Variable
' '           Text
'0'           Literal.Number.Integer
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n  '        Text
')'           Punctuation
'\n  '        Text
'('           Punctuation
'c-typep-vector' Name.Variable
' '           Text
"'SIMPLE-VECTOR-P" Literal.String.Symbol
' '           Text
'size'        Name.Variable
' '           Text
'x'           Name.Variable
')'           Punctuation
'\n'          Text

')'           Punctuation
'\n'          Text

'('           Punctuation
'def-compound-type' Name.Variable
' '           Text
'COMPLEX'     Name.Variable
' '           Text
'('           Punctuation
'&optional'   Keyword
' '           Text
'('           Punctuation
'rtype'       Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
' '           Text
'('           Punctuation
'itype'       Name.Variable
' '           Text
'rtype'       Name.Variable
')'           Punctuation
')'           Punctuation
' '           Text
'('           Punctuation
'x'           Name.Variable
')'           Punctuation
'\n  '        Text
'nil'         Name.Constant
'\n  '        Text
'('           Punctuation
'and'         Name.Builtin
' '           Text
'('           Punctuation
'complexp'    Name.Builtin
' '           Text
'x'           Name.Variable
')'           Punctuation
'\n       '   Text
'('           Punctuation
'or'          Name.Builtin
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'rtype'       Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
'\n           ' Text
'('           Punctuation
'typep'       Name.Builtin
' '           Text
'('           Punctuation
'realpart'    Name.Builtin
' '           Text
'x'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'upgraded-complex-part-type' Name.Builtin
' '           Text
'rtype'       Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n       '   Text
'('           Punctuation
'or'          Name.Builtin
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'itype'       Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
'\n           ' Text
'('           Punctuation
'typep'       Name.Builtin
' '           Text
'('           Punctuation
'imagpart'    Name.Builtin
' '           Text
'x'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'upgraded-complex-part-type' Name.Builtin
' '           Text
'itype'       Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n  '        Text
'`'           Operator
'('           Punctuation
'AND'         Name.Variable
' '           Text
'('           Punctuation
'COMPLEXP'    Name.Variable
' '           Text
','           Operator
'x'           Name.Variable
')'           Punctuation
'\n        '  Text
',@'          Operator
'('           Punctuation
'if'          Keyword
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'rtype'       Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
'\n            ' Text
"'"           Operator
'('           Punctuation
')'           Punctuation
'\n            ' Text
'`'           Operator
'('           Punctuation
'('           Punctuation
'TYPEP'       Name.Variable
' '           Text
'('           Punctuation
'REALPART'    Name.Variable
' '           Text
','           Operator
'x'           Name.Variable
')'           Punctuation
' '           Text
"',"          Literal.String.Symbol
'('           Punctuation
'upgraded-complex-part-type' Name.Builtin
' '           Text
'rtype'       Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n        '  Text
',@'          Operator
'('           Punctuation
'if'          Keyword
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'itype'       Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
'\n            ' Text
"'"           Operator
'('           Punctuation
')'           Punctuation
'\n            ' Text
'`'           Operator
'('           Punctuation
'('           Punctuation
'TYPEP'       Name.Variable
' '           Text
'('           Punctuation
'IMAGPART'    Name.Variable
' '           Text
','           Operator
'x'           Name.Variable
')'           Punctuation
' '           Text
"',"          Literal.String.Symbol
'('           Punctuation
'upgraded-complex-part-type' Name.Builtin
' '           Text
'itype'       Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n'          Text

'('           Punctuation
'def-compound-type' Name.Variable
' '           Text
'INTEGER'     Name.Variable
' '           Text
'('           Punctuation
'&optional'   Keyword
' '           Text
'('           Punctuation
'low'         Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
' '           Text
'('           Punctuation
'high'        Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
')'           Punctuation
' '           Text
'('           Punctuation
'x'           Name.Variable
')'           Punctuation
'\n  '        Text
'nil'         Name.Constant
'\n  '        Text
'('           Punctuation
'typep-number-test' Name.Variable
' '           Text
'x'           Name.Variable
' '           Text
'low'         Name.Variable
' '           Text
'high'        Name.Variable
' '           Text
"#'"          Name.Function
'integerp'    Name.Builtin
' '           Text
"'INTEGER"    Literal.String.Symbol
')'           Punctuation
'\n  '        Text
'('           Punctuation
'c-typep-number' Name.Variable
' '           Text
"'INTEGER"    Literal.String.Symbol
' '           Text
"'INTEGERP"   Literal.String.Symbol
' '           Text
'low'         Name.Variable
' '           Text
'high'        Name.Variable
' '           Text
'x'           Name.Variable
')'           Punctuation
'\n'          Text

')'           Punctuation
'\n'          Text

'('           Punctuation
'def-compound-type' Name.Variable
' '           Text
'MOD'         Name.Variable
' '           Text
'('           Punctuation
'n'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'x'           Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'unless'      Name.Builtin
' '           Text
'('           Punctuation
'integerp'    Name.Builtin
' '           Text
'n'           Name.Variable
')'           Punctuation
'\n    '      Text
'('           Punctuation
'error'       Name.Builtin
' '           Text
'('           Punctuation
'TEXT'        Name.Variable
' '           Text
'"~S: argument to MOD must be an integer: ~S"' Literal.String
')'           Punctuation
'\n           ' Text
"'typep"      Literal.String.Symbol
' '           Text
'n'           Name.Variable
'\n  '        Text
')'           Punctuation
' '           Text
')'           Punctuation
'\n  '        Text
'('           Punctuation
'and'         Name.Builtin
' '           Text
'('           Punctuation
'integerp'    Name.Builtin
' '           Text
'x'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'<='          Name.Builtin
' '           Text
'0'           Literal.Number.Integer
' '           Text
'x'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'<'           Name.Builtin
' '           Text
'x'           Name.Variable
' '           Text
'n'           Name.Variable
')'           Punctuation
')'           Punctuation
'\n  '        Text
'`'           Operator
'('           Punctuation
'AND'         Name.Variable
' '           Text
'('           Punctuation
'INTEGERP'    Name.Variable
' '           Text
','           Operator
'x'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'NOT'         Name.Variable
' '           Text
'('           Punctuation
'MINUSP'      Name.Variable
' '           Text
','           Operator
'x'           Name.Variable
')'           Punctuation
')'           Punctuation
' '           Text
'('           Punctuation
'<'           Name.Builtin
' '           Text
','           Operator
'x'           Name.Variable
' '           Text
','           Operator
'n'           Name.Variable
')'           Punctuation
')'           Punctuation
'\n'          Text

')'           Punctuation
'\n'          Text

'('           Punctuation
'def-compound-type' Name.Variable
' '           Text
'SIGNED-BYTE' Name.Variable
' '           Text
'('           Punctuation
'&optional'   Keyword
' '           Text
'('           Punctuation
'n'           Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
')'           Punctuation
' '           Text
'('           Punctuation
'x'           Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'unless'      Name.Builtin
' '           Text
'('           Punctuation
'or'          Name.Builtin
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'n'           Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
' '           Text
'('           Punctuation
'integerp'    Name.Builtin
' '           Text
'n'           Name.Variable
')'           Punctuation
')'           Punctuation
'\n    '      Text
'('           Punctuation
'error'       Name.Builtin
' '           Text
'('           Punctuation
'TEXT'        Name.Variable
' '           Text
'"~S: argument to SIGNED-BYTE must be an integer or * : ~S"' Literal.String
')'           Punctuation
'\n           ' Text
"'typep"      Literal.String.Symbol
' '           Text
'n'           Name.Variable
'\n  '        Text
')'           Punctuation
' '           Text
')'           Punctuation
'\n  '        Text
'('           Punctuation
'and'         Name.Builtin
' '           Text
'('           Punctuation
'integerp'    Name.Builtin
' '           Text
'x'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'or'          Name.Builtin
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'n'           Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
' '           Text
'('           Punctuation
'<'           Name.Builtin
' '           Text
'('           Punctuation
'integer-length' Name.Builtin
' '           Text
'x'           Name.Variable
')'           Punctuation
' '           Text
'n'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n  '        Text
'`'           Operator
'('           Punctuation
'AND'         Name.Variable
' '           Text
'('           Punctuation
'INTEGERP'    Name.Variable
' '           Text
','           Operator
'x'           Name.Variable
')'           Punctuation
'\n        '  Text
',@'          Operator
'('           Punctuation
'if'          Keyword
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'n'           Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
' '           Text
"'"           Operator
'('           Punctuation
')'           Punctuation
' '           Text
'`'           Operator
'('           Punctuation
'('           Punctuation
'<'           Name.Builtin
' '           Text
'('           Punctuation
'INTEGER-LENGTH' Name.Variable
' '           Text
','           Operator
'x'           Name.Variable
')'           Punctuation
' '           Text
','           Operator
'n'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n   '       Text
')'           Punctuation
'\n'          Text

')'           Punctuation
'\n'          Text

'('           Punctuation
'def-compound-type' Name.Variable
' '           Text
'UNSIGNED-BYTE' Name.Variable
' '           Text
'('           Punctuation
'&optional'   Keyword
' '           Text
'('           Punctuation
'n'           Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
')'           Punctuation
' '           Text
'('           Punctuation
'x'           Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'unless'      Name.Builtin
' '           Text
'('           Punctuation
'or'          Name.Builtin
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'n'           Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
' '           Text
'('           Punctuation
'integerp'    Name.Builtin
' '           Text
'n'           Name.Variable
')'           Punctuation
')'           Punctuation
'\n    '      Text
'('           Punctuation
'error'       Name.Builtin
' '           Text
'('           Punctuation
'TEXT'        Name.Variable
' '           Text
'"~S: argument to UNSIGNED-BYTE must be an integer or * : ~S"' Literal.String
')'           Punctuation
'\n           ' Text
"'typep"      Literal.String.Symbol
' '           Text
'n'           Name.Variable
'\n  '        Text
')'           Punctuation
' '           Text
')'           Punctuation
'\n  '        Text
'('           Punctuation
'and'         Name.Builtin
' '           Text
'('           Punctuation
'integerp'    Name.Builtin
' '           Text
'x'           Name.Variable
')'           Punctuation
'\n       '   Text
'('           Punctuation
'not'         Name.Builtin
' '           Text
'('           Punctuation
'minusp'      Name.Builtin
' '           Text
'x'           Name.Variable
')'           Punctuation
')'           Punctuation
'\n       '   Text
'('           Punctuation
'or'          Name.Builtin
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'n'           Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
' '           Text
'('           Punctuation
'<='          Name.Builtin
' '           Text
'('           Punctuation
'integer-length' Name.Builtin
' '           Text
'x'           Name.Variable
')'           Punctuation
' '           Text
'n'           Name.Variable
')'           Punctuation
')'           Punctuation
'\n  '        Text
')'           Punctuation
'\n  '        Text
'`'           Operator
'('           Punctuation
'AND'         Name.Variable
' '           Text
'('           Punctuation
'INTEGERP'    Name.Variable
' '           Text
','           Operator
'x'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'NOT'         Name.Variable
' '           Text
'('           Punctuation
'MINUSP'      Name.Variable
' '           Text
','           Operator
'x'           Name.Variable
')'           Punctuation
')'           Punctuation
'\n        '  Text
',@'          Operator
'('           Punctuation
'if'          Keyword
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'n'           Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
' '           Text
"'"           Operator
'('           Punctuation
')'           Punctuation
' '           Text
'`'           Operator
'('           Punctuation
'('           Punctuation
'<='          Name.Builtin
' '           Text
'('           Punctuation
'INTEGER-LENGTH' Name.Variable
' '           Text
','           Operator
'x'           Name.Variable
')'           Punctuation
' '           Text
','           Operator
'n'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n   '       Text
')'           Punctuation
'\n'          Text

')'           Punctuation
'\n'          Text

'('           Punctuation
'def-compound-type' Name.Variable
' '           Text
'REAL'        Name.Variable
' '           Text
'('           Punctuation
'&optional'   Keyword
' '           Text
'('           Punctuation
'low'         Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
' '           Text
'('           Punctuation
'high'        Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
')'           Punctuation
' '           Text
'('           Punctuation
'x'           Name.Variable
')'           Punctuation
'\n  '        Text
'nil'         Name.Constant
'\n  '        Text
'('           Punctuation
'typep-number-test' Name.Variable
' '           Text
'x'           Name.Variable
' '           Text
'low'         Name.Variable
' '           Text
'high'        Name.Variable
' '           Text
"#'"          Name.Function
'realp'       Name.Builtin
' '           Text
"'REAL"       Literal.String.Symbol
')'           Punctuation
'\n  '        Text
'('           Punctuation
'c-typep-number' Name.Variable
' '           Text
"'REAL"       Literal.String.Symbol
' '           Text
"'REALP"      Literal.String.Symbol
' '           Text
'low'         Name.Variable
' '           Text
'high'        Name.Variable
' '           Text
'x'           Name.Variable
')'           Punctuation
'\n'          Text

')'           Punctuation
'\n'          Text

'('           Punctuation
'def-compound-type' Name.Variable
' '           Text
'RATIONAL'    Name.Variable
' '           Text
'('           Punctuation
'&optional'   Keyword
' '           Text
'('           Punctuation
'low'         Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
' '           Text
'('           Punctuation
'high'        Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
')'           Punctuation
' '           Text
'('           Punctuation
'x'           Name.Variable
')'           Punctuation
'\n  '        Text
'nil'         Name.Constant
'\n  '        Text
'('           Punctuation
'typep-number-test' Name.Variable
' '           Text
'x'           Name.Variable
' '           Text
'low'         Name.Variable
' '           Text
'high'        Name.Variable
' '           Text
"#'"          Name.Function
'rationalp'   Name.Builtin
' '           Text
"'RATIONAL"   Literal.String.Symbol
')'           Punctuation
'\n  '        Text
'('           Punctuation
'c-typep-number' Name.Variable
' '           Text
"'RATIONAL"   Literal.String.Symbol
' '           Text
"'RATIONALP"  Literal.String.Symbol
' '           Text
'low'         Name.Variable
' '           Text
'high'        Name.Variable
' '           Text
'x'           Name.Variable
')'           Punctuation
'\n'          Text

')'           Punctuation
'\n'          Text

'('           Punctuation
'def-compound-type' Name.Variable
' '           Text
'FLOAT'       Name.Variable
' '           Text
'('           Punctuation
'&optional'   Keyword
' '           Text
'('           Punctuation
'low'         Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
' '           Text
'('           Punctuation
'high'        Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
')'           Punctuation
' '           Text
'('           Punctuation
'x'           Name.Variable
')'           Punctuation
'\n  '        Text
'nil'         Name.Constant
'\n  '        Text
'('           Punctuation
'typep-number-test' Name.Variable
' '           Text
'x'           Name.Variable
' '           Text
'low'         Name.Variable
' '           Text
'high'        Name.Variable
' '           Text
"#'"          Name.Function
'floatp'      Name.Builtin
' '           Text
"'FLOAT"      Literal.String.Symbol
')'           Punctuation
'\n  '        Text
'('           Punctuation
'c-typep-number' Name.Variable
' '           Text
"'FLOAT"      Literal.String.Symbol
' '           Text
"'FLOATP"     Literal.String.Symbol
' '           Text
'low'         Name.Variable
' '           Text
'high'        Name.Variable
' '           Text
'x'           Name.Variable
')'           Punctuation
'\n'          Text

')'           Punctuation
'\n'          Text

'('           Punctuation
'def-compound-type' Name.Variable
' '           Text
'SHORT-FLOAT' Name.Variable
' '           Text
'('           Punctuation
'&optional'   Keyword
' '           Text
'('           Punctuation
'low'         Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
' '           Text
'('           Punctuation
'high'        Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
')'           Punctuation
' '           Text
'('           Punctuation
'x'           Name.Variable
')'           Punctuation
'\n  '        Text
'nil'         Name.Constant
'\n  '        Text
'('           Punctuation
'typep-number-test' Name.Variable
' '           Text
'x'           Name.Variable
' '           Text
'low'         Name.Variable
' '           Text
'high'        Name.Variable
' '           Text
"#'"          Name.Function
'short-float-p' Name.Variable
' '           Text
"'SHORT-FLOAT" Literal.String.Symbol
')'           Punctuation
'\n  '        Text
'('           Punctuation
'c-typep-number' Name.Variable
' '           Text
"'SHORT-FLOAT" Literal.String.Symbol
' '           Text
"'SHORT-FLOAT-P" Literal.String.Symbol
' '           Text
'low'         Name.Variable
' '           Text
'high'        Name.Variable
' '           Text
'x'           Name.Variable
')'           Punctuation
'\n'          Text

')'           Punctuation
'\n'          Text

'('           Punctuation
'def-compound-type' Name.Variable
' '           Text
'SINGLE-FLOAT' Name.Variable
' '           Text
'('           Punctuation
'&optional'   Keyword
' '           Text
'('           Punctuation
'low'         Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
' '           Text
'('           Punctuation
'high'        Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
')'           Punctuation
' '           Text
'('           Punctuation
'x'           Name.Variable
')'           Punctuation
'\n  '        Text
'nil'         Name.Constant
'\n  '        Text
'('           Punctuation
'typep-number-test' Name.Variable
' '           Text
'x'           Name.Variable
' '           Text
'low'         Name.Variable
' '           Text
'high'        Name.Variable
' '           Text
"#'"          Name.Function
'single-float-p' Name.Variable
' '           Text
"'SINGLE-FLOAT" Literal.String.Symbol
')'           Punctuation
'\n  '        Text
'('           Punctuation
'c-typep-number' Name.Variable
' '           Text
"'SINGLE-FLOAT" Literal.String.Symbol
' '           Text
"'SINGLE-FLOAT-P" Literal.String.Symbol
' '           Text
'low'         Name.Variable
' '           Text
'high'        Name.Variable
' '           Text
'x'           Name.Variable
')'           Punctuation
'\n'          Text

')'           Punctuation
'\n'          Text

'('           Punctuation
'def-compound-type' Name.Variable
' '           Text
'DOUBLE-FLOAT' Name.Variable
' '           Text
'('           Punctuation
'&optional'   Keyword
' '           Text
'('           Punctuation
'low'         Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
' '           Text
'('           Punctuation
'high'        Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
')'           Punctuation
' '           Text
'('           Punctuation
'x'           Name.Variable
')'           Punctuation
'\n  '        Text
'nil'         Name.Constant
'\n  '        Text
'('           Punctuation
'typep-number-test' Name.Variable
' '           Text
'x'           Name.Variable
' '           Text
'low'         Name.Variable
' '           Text
'high'        Name.Variable
' '           Text
"#'"          Name.Function
'double-float-p' Name.Variable
' '           Text
"'DOUBLE-FLOAT" Literal.String.Symbol
')'           Punctuation
'\n  '        Text
'('           Punctuation
'c-typep-number' Name.Variable
' '           Text
"'DOUBLE-FLOAT" Literal.String.Symbol
' '           Text
"'DOUBLE-FLOAT-P" Literal.String.Symbol
' '           Text
'low'         Name.Variable
' '           Text
'high'        Name.Variable
' '           Text
'x'           Name.Variable
')'           Punctuation
'\n'          Text

')'           Punctuation
'\n'          Text

'('           Punctuation
'def-compound-type' Name.Variable
' '           Text
'LONG-FLOAT'  Name.Variable
' '           Text
'('           Punctuation
'&optional'   Keyword
' '           Text
'('           Punctuation
'low'         Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
' '           Text
'('           Punctuation
'high'        Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
')'           Punctuation
' '           Text
'('           Punctuation
'x'           Name.Variable
')'           Punctuation
'\n  '        Text
'nil'         Name.Constant
'\n  '        Text
'('           Punctuation
'typep-number-test' Name.Variable
' '           Text
'x'           Name.Variable
' '           Text
'low'         Name.Variable
' '           Text
'high'        Name.Variable
' '           Text
"#'"          Name.Function
'long-float-p' Name.Variable
' '           Text
"'LONG-FLOAT" Literal.String.Symbol
')'           Punctuation
'\n  '        Text
'('           Punctuation
'c-typep-number' Name.Variable
' '           Text
"'LONG-FLOAT" Literal.String.Symbol
' '           Text
"'LONG-FLOAT-P" Literal.String.Symbol
' '           Text
'low'         Name.Variable
' '           Text
'high'        Name.Variable
' '           Text
'x'           Name.Variable
')'           Punctuation
'\n'          Text

')'           Punctuation
'\n'          Text

'('           Punctuation
'def-compound-type' Name.Variable
' '           Text
'STRING'      Name.Variable
' '           Text
'('           Punctuation
'&optional'   Keyword
' '           Text
'('           Punctuation
'size'        Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
')'           Punctuation
' '           Text
'('           Punctuation
'x'           Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'ensure-dim'  Name.Variable
' '           Text
'STRING'      Name.Variable
' '           Text
'size'        Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'and'         Name.Builtin
' '           Text
'('           Punctuation
'stringp'     Name.Builtin
' '           Text
'x'           Name.Variable
')'           Punctuation
'\n       '   Text
'('           Punctuation
'or'          Name.Builtin
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'size'        Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
' '           Text
'('           Punctuation
'eql'         Name.Builtin
' '           Text
'size'        Name.Variable
' '           Text
'('           Punctuation
'array-dimension' Name.Builtin
' '           Text
'x'           Name.Variable
' '           Text
'0'           Literal.Number.Integer
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n  '        Text
')'           Punctuation
'\n  '        Text
'('           Punctuation
'c-typep-vector' Name.Variable
' '           Text
"'STRINGP"    Literal.String.Symbol
' '           Text
'size'        Name.Variable
' '           Text
'x'           Name.Variable
')'           Punctuation
'\n'          Text

')'           Punctuation
'\n'          Text

'('           Punctuation
'def-compound-type' Name.Variable
' '           Text
'SIMPLE-STRING' Name.Variable
' '           Text
'('           Punctuation
'&optional'   Keyword
' '           Text
'('           Punctuation
'size'        Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
')'           Punctuation
' '           Text
'('           Punctuation
'x'           Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'ensure-dim'  Name.Variable
' '           Text
'SIMPLE-STRING' Name.Variable
' '           Text
'size'        Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'and'         Name.Builtin
' '           Text
'('           Punctuation
'simple-string-p' Name.Builtin
' '           Text
'x'           Name.Variable
')'           Punctuation
'\n       '   Text
'('           Punctuation
'or'          Name.Builtin
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'size'        Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
' '           Text
'('           Punctuation
'eql'         Name.Builtin
' '           Text
'size'        Name.Variable
' '           Text
'('           Punctuation
'array-dimension' Name.Builtin
' '           Text
'x'           Name.Variable
' '           Text
'0'           Literal.Number.Integer
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n  '        Text
')'           Punctuation
'\n  '        Text
'('           Punctuation
'c-typep-vector' Name.Variable
' '           Text
"'SIMPLE-STRING-P" Literal.String.Symbol
' '           Text
'size'        Name.Variable
' '           Text
'x'           Name.Variable
')'           Punctuation
'\n'          Text

')'           Punctuation
'\n'          Text

'('           Punctuation
'def-compound-type' Name.Variable
' '           Text
'BASE-STRING' Name.Variable
' '           Text
'('           Punctuation
'&optional'   Keyword
' '           Text
'('           Punctuation
'size'        Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
')'           Punctuation
' '           Text
'('           Punctuation
'x'           Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'ensure-dim'  Name.Variable
' '           Text
'BASE-STRING' Name.Variable
' '           Text
'size'        Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'and'         Name.Builtin
' '           Text
'('           Punctuation
'stringp'     Name.Builtin
' '           Text
'x'           Name.Variable
')'           Punctuation
'\n       '   Text
'('           Punctuation
'or'          Name.Builtin
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'size'        Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
' '           Text
'('           Punctuation
'eql'         Name.Builtin
' '           Text
'size'        Name.Variable
' '           Text
'('           Punctuation
'array-dimension' Name.Builtin
' '           Text
'x'           Name.Variable
' '           Text
'0'           Literal.Number.Integer
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n  '        Text
')'           Punctuation
'\n  '        Text
'('           Punctuation
'c-typep-vector' Name.Variable
' '           Text
"'STRINGP"    Literal.String.Symbol
' '           Text
'size'        Name.Variable
' '           Text
'x'           Name.Variable
')'           Punctuation
'\n'          Text

')'           Punctuation
'\n'          Text

'('           Punctuation
'def-compound-type' Name.Variable
' '           Text
'SIMPLE-BASE-STRING' Name.Variable
' '           Text
'('           Punctuation
'&optional'   Keyword
' '           Text
'('           Punctuation
'size'        Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
')'           Punctuation
' '           Text
'('           Punctuation
'x'           Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'ensure-dim'  Name.Variable
' '           Text
'SIMPLE-BASE-STRING' Name.Variable
' '           Text
'size'        Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'and'         Name.Builtin
' '           Text
'('           Punctuation
'simple-string-p' Name.Builtin
' '           Text
'x'           Name.Variable
')'           Punctuation
'\n       '   Text
'('           Punctuation
'or'          Name.Builtin
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'size'        Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
' '           Text
'('           Punctuation
'eql'         Name.Builtin
' '           Text
'size'        Name.Variable
' '           Text
'('           Punctuation
'array-dimension' Name.Builtin
' '           Text
'x'           Name.Variable
' '           Text
'0'           Literal.Number.Integer
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n  '        Text
')'           Punctuation
'\n  '        Text
'('           Punctuation
'c-typep-vector' Name.Variable
' '           Text
"'SIMPLE-STRING-P" Literal.String.Symbol
' '           Text
'size'        Name.Variable
' '           Text
'x'           Name.Variable
')'           Punctuation
'\n'          Text

')'           Punctuation
'\n'          Text

'('           Punctuation
'def-compound-type' Name.Variable
' '           Text
'BIT-VECTOR'  Name.Variable
' '           Text
'('           Punctuation
'&optional'   Keyword
' '           Text
'('           Punctuation
'size'        Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
')'           Punctuation
' '           Text
'('           Punctuation
'x'           Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'ensure-dim'  Name.Variable
' '           Text
'BIT-VECTOR'  Name.Variable
' '           Text
'size'        Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'and'         Name.Builtin
' '           Text
'('           Punctuation
'bit-vector-p' Name.Builtin
' '           Text
'x'           Name.Variable
')'           Punctuation
'\n       '   Text
'('           Punctuation
'or'          Name.Builtin
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'size'        Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
' '           Text
'('           Punctuation
'eql'         Name.Builtin
' '           Text
'size'        Name.Variable
' '           Text
'('           Punctuation
'array-dimension' Name.Builtin
' '           Text
'x'           Name.Variable
' '           Text
'0'           Literal.Number.Integer
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n  '        Text
')'           Punctuation
'\n  '        Text
'('           Punctuation
'c-typep-vector' Name.Variable
' '           Text
"'BIT-VECTOR-P" Literal.String.Symbol
' '           Text
'size'        Name.Variable
' '           Text
'x'           Name.Variable
')'           Punctuation
'\n'          Text

')'           Punctuation
'\n'          Text

'('           Punctuation
'def-compound-type' Name.Variable
' '           Text
'SIMPLE-BIT-VECTOR' Name.Variable
' '           Text
'('           Punctuation
'&optional'   Keyword
' '           Text
'('           Punctuation
'size'        Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
')'           Punctuation
' '           Text
'('           Punctuation
'x'           Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'ensure-dim'  Name.Variable
' '           Text
'SIMPLE-BIT-VECTOR' Name.Variable
' '           Text
'size'        Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'and'         Name.Builtin
' '           Text
'('           Punctuation
'simple-bit-vector-p' Name.Builtin
' '           Text
'x'           Name.Variable
')'           Punctuation
'\n       '   Text
'('           Punctuation
'or'          Name.Builtin
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'size'        Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
' '           Text
'('           Punctuation
'eql'         Name.Builtin
' '           Text
'size'        Name.Variable
' '           Text
'('           Punctuation
'array-dimension' Name.Builtin
' '           Text
'x'           Name.Variable
' '           Text
'0'           Literal.Number.Integer
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n  '        Text
')'           Punctuation
'\n  '        Text
'('           Punctuation
'c-typep-vector' Name.Variable
' '           Text
"'SIMPLE-BIT-VECTOR-P" Literal.String.Symbol
' '           Text
'size'        Name.Variable
' '           Text
'x'           Name.Variable
')'           Punctuation
'\n'          Text

')'           Punctuation
'\n'          Text

'('           Punctuation
'def-compound-type' Name.Variable
' '           Text
'CONS'        Name.Variable
' '           Text
'('           Punctuation
'&optional'   Keyword
' '           Text
'('           Punctuation
'car-type'    Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
' '           Text
'('           Punctuation
'cdr-type'    Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
')'           Punctuation
' '           Text
'('           Punctuation
'x'           Name.Variable
')'           Punctuation
'\n  '        Text
'nil'         Name.Constant
'\n  '        Text
'('           Punctuation
'and'         Name.Builtin
' '           Text
'('           Punctuation
'consp'       Name.Builtin
' '           Text
'x'           Name.Variable
')'           Punctuation
'\n       '   Text
'('           Punctuation
'or'          Name.Builtin
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'car-type'    Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
' '           Text
'('           Punctuation
'typep'       Name.Builtin
' '           Text
'('           Punctuation
'car'         Name.Builtin
' '           Text
'x'           Name.Variable
')'           Punctuation
' '           Text
'car-type'    Name.Variable
')'           Punctuation
')'           Punctuation
'\n       '   Text
'('           Punctuation
'or'          Name.Builtin
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'cdr-type'    Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
' '           Text
'('           Punctuation
'typep'       Name.Builtin
' '           Text
'('           Punctuation
'cdr'         Name.Builtin
' '           Text
'x'           Name.Variable
')'           Punctuation
' '           Text
'cdr-type'    Name.Variable
')'           Punctuation
')'           Punctuation
'\n  '        Text
')'           Punctuation
'\n  '        Text
'`'           Operator
'('           Punctuation
'AND'         Name.Variable
' '           Text
'('           Punctuation
'CONSP'       Name.Variable
' '           Text
','           Operator
'x'           Name.Variable
')'           Punctuation
'\n        '  Text
',@'          Operator
'('           Punctuation
'if'          Keyword
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'car-type'    Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
' '           Text
"'"           Operator
'('           Punctuation
')'           Punctuation
' '           Text
'`'           Operator
'('           Punctuation
'('           Punctuation
'TYPEP'       Name.Variable
' '           Text
'('           Punctuation
'CAR'         Name.Variable
' '           Text
','           Operator
'x'           Name.Variable
')'           Punctuation
' '           Text
"',car-type"  Literal.String.Symbol
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n        '  Text
',@'          Operator
'('           Punctuation
'if'          Keyword
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'cdr-type'    Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
' '           Text
"'"           Operator
'('           Punctuation
')'           Punctuation
' '           Text
'`'           Operator
'('           Punctuation
'('           Punctuation
'TYPEP'       Name.Variable
' '           Text
'('           Punctuation
'CDR'         Name.Variable
' '           Text
','           Operator
'x'           Name.Variable
')'           Punctuation
' '           Text
"',cdr-type"  Literal.String.Symbol
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n   '       Text
')'           Punctuation
'\n'          Text

')'           Punctuation
'\n\n'        Text

'('           Punctuation
'fmakunbound' Name.Builtin
' '           Text
"'def-compound-type" Literal.String.Symbol
')'           Punctuation
'\n\n'        Text

';; ----------------------------------------------------------------------------' Comment.Single
'\n\n'        Text

'; Typtest ohne Gefahr einer Fehlermeldung. Für SIGNAL und HANDLER-BIND.' Comment.Single
'\n'          Text

'('           Punctuation
'defun'       Name.Builtin
' '           Text
'safe-typep'  Name.Variable
' '           Text
'('           Punctuation
'x'           Name.Variable
' '           Text
'y'           Name.Variable
' '           Text
'&optional'   Keyword
' '           Text
'env'         Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'let'         Keyword
' '           Text
'('           Punctuation
'('           Punctuation
'*error-handler*' Name.Variable.Global
'\n          ' Text
"#'"          Name.Function
'('           Punctuation
'lambda'      Keyword
' '           Text
'('           Punctuation
'&rest'       Keyword
' '           Text
'error-args'  Name.Variable
')'           Punctuation
'\n              ' Text
'('           Punctuation
'declare'     Keyword
' '           Text
'('           Punctuation
'ignore'      Keyword
' '           Text
'error-args'  Name.Variable
')'           Punctuation
')'           Punctuation
'\n              ' Text
'('           Punctuation
'return-from' Keyword
' '           Text
'safe-typep'  Name.Variable
' '           Text
'('           Punctuation
'values'      Name.Builtin
' '           Text
'nil'         Name.Constant
' '           Text
'nil'         Name.Constant
')'           Punctuation
')'           Punctuation
'\n       '   Text
')'           Punctuation
')'           Punctuation
'   '         Text
')'           Punctuation
'\n    '      Text
'('           Punctuation
'values'      Name.Builtin
' '           Text
'('           Punctuation
'typep'       Name.Builtin
' '           Text
'x'           Name.Variable
' '           Text
'y'           Name.Variable
' '           Text
'env'         Name.Variable
')'           Punctuation
' '           Text
't'           Name.Constant
')'           Punctuation
'\n'          Text

')'           Punctuation
' '           Text
')'           Punctuation
'\n\n'        Text

'; Umwandlung eines "type for declaration" in einen "type for discrimination".' Comment.Single
'\n'          Text

'('           Punctuation
'defun'       Name.Builtin
' '           Text
'type-for-discrimination' Name.Variable
' '           Text
'('           Punctuation
'y'           Name.Variable
' '           Text
'&optional'   Keyword
' '           Text
'('           Punctuation
'notp'        Name.Variable
' '           Text
'nil'         Name.Constant
')'           Punctuation
' '           Text
'&aux'        Keyword
' '           Text
'f'           Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'cond'        Name.Builtin
' '           Text
'('           Punctuation
'('           Punctuation
'symbolp'     Name.Builtin
' '           Text
'y'           Name.Variable
')'           Punctuation
'\n           ' Text
'('           Punctuation
'cond'        Name.Builtin
' '           Text
'('           Punctuation
'('           Punctuation
'get'         Name.Builtin
' '           Text
'y'           Name.Variable
' '           Text
"'TYPE-SYMBOL" Literal.String.Symbol
')'           Punctuation
' '           Text
'y'           Name.Variable
')'           Punctuation
'\n                 ' Text
'('           Punctuation
'('           Punctuation
'get'         Name.Builtin
' '           Text
'y'           Name.Variable
' '           Text
"'TYPE-LIST"  Literal.String.Symbol
')'           Punctuation
' '           Text
'y'           Name.Variable
')'           Punctuation
'\n                 ' Text
'('           Punctuation
'('           Punctuation
'setq'        Keyword
' '           Text
'f'           Name.Variable
' '           Text
'('           Punctuation
'get'         Name.Builtin
' '           Text
'y'           Name.Variable
' '           Text
"'DEFTYPE-EXPANDER" Literal.String.Symbol
')'           Punctuation
')'           Punctuation
'\n                  ' Text
'('           Punctuation
'let*'        Keyword
' '           Text
'('           Punctuation
'('           Punctuation
'z'           Name.Variable
' '           Text
'('           Punctuation
'funcall'     Name.Builtin
' '           Text
'f'           Name.Variable
' '           Text
'('           Punctuation
'list'        Name.Builtin
' '           Text
'y'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n                         ' Text
'('           Punctuation
'zx'          Name.Variable
' '           Text
'('           Punctuation
'type-for-discrimination' Name.Variable
' '           Text
'z'           Name.Variable
' '           Text
'notp'        Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n                    ' Text
'('           Punctuation
'if'          Keyword
' '           Text
'('           Punctuation
'eql'         Name.Builtin
' '           Text
'zx'          Name.Variable
' '           Text
'z'           Name.Variable
')'           Punctuation
' '           Text
'y'           Name.Variable
' '           Text
'zx'          Name.Variable
')'           Punctuation
'\n                 ' Text
')'           Punctuation
')'           Punctuation
'\n                 ' Text
'('           Punctuation
't'           Name.Constant
' '           Text
'y'           Name.Variable
')'           Punctuation
'\n        '  Text
')'           Punctuation
'  '          Text
')'           Punctuation
'\n        '  Text
'('           Punctuation
'('           Punctuation
'and'         Name.Builtin
' '           Text
'('           Punctuation
'consp'       Name.Builtin
' '           Text
'y'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'symbolp'     Name.Builtin
' '           Text
'('           Punctuation
'first'       Name.Builtin
' '           Text
'y'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n           ' Text
'('           Punctuation
'case'        Name.Builtin
' '           Text
'('           Punctuation
'first'       Name.Builtin
' '           Text
'y'           Name.Variable
')'           Punctuation
'\n             ' Text
'('           Punctuation
'('           Punctuation
'SATISFIES'   Name.Variable
' '           Text
'MEMBER'      Name.Variable
' '           Text
'EQL'         Name.Variable
')'           Punctuation
' '           Text
'y'           Name.Variable
')'           Punctuation
'\n             ' Text
'('           Punctuation
'NOT'         Name.Variable
'\n              ' Text
'('           Punctuation
'let*'        Keyword
' '           Text
'('           Punctuation
'('           Punctuation
'z'           Name.Variable
' '           Text
'('           Punctuation
'second'      Name.Builtin
' '           Text
'y'           Name.Variable
')'           Punctuation
')'           Punctuation
'\n                     ' Text
'('           Punctuation
'zx'          Name.Variable
' '           Text
'('           Punctuation
'type-for-discrimination' Name.Variable
' '           Text
'z'           Name.Variable
' '           Text
'('           Punctuation
'not'         Name.Builtin
' '           Text
'notp'        Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n                ' Text
'('           Punctuation
'if'          Keyword
' '           Text
'('           Punctuation
'eql'         Name.Builtin
' '           Text
'zx'          Name.Variable
' '           Text
'z'           Name.Variable
')'           Punctuation
' '           Text
'y'           Name.Variable
' '           Text
'`'           Operator
'('           Punctuation
'NOT'         Name.Variable
' '           Text
','           Operator
'zx'          Name.Variable
')'           Punctuation
')'           Punctuation
'\n             ' Text
')'           Punctuation
')'           Punctuation
'\n             ' Text
'('           Punctuation
'('           Punctuation
'AND'         Name.Variable
' '           Text
'OR'          Name.Variable
' '           Text
'COMPLEX'     Name.Variable
' '           Text
'VALUES'      Name.Variable
')'           Punctuation
'\n              ' Text
'('           Punctuation
'let*'        Keyword
' '           Text
'('           Punctuation
'('           Punctuation
'z'           Name.Variable
' '           Text
'('           Punctuation
'rest'        Name.Builtin
' '           Text
'y'           Name.Variable
')'           Punctuation
')'           Punctuation
'\n                     ' Text
'('           Punctuation
'zx'          Name.Variable
' '           Text
'('           Punctuation
'mapcar'      Name.Builtin
' '           Text
"#'"          Name.Function
'('           Punctuation
'lambda'      Keyword
' '           Text
'('           Punctuation
'x'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'type-for-discrimination' Name.Variable
' '           Text
'x'           Name.Variable
' '           Text
'notp'        Name.Variable
')'           Punctuation
')'           Punctuation
' '           Text
'z'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n                ' Text
'('           Punctuation
'if'          Keyword
' '           Text
'('           Punctuation
'every'       Name.Builtin
' '           Text
"#'"          Name.Function
'eql'         Name.Builtin
' '           Text
'z'           Name.Variable
' '           Text
'zx'          Name.Variable
')'           Punctuation
' '           Text
'y'           Name.Variable
' '           Text
'('           Punctuation
'cons'        Name.Builtin
' '           Text
'('           Punctuation
'first'       Name.Builtin
' '           Text
'y'           Name.Variable
')'           Punctuation
' '           Text
'zx'          Name.Variable
')'           Punctuation
')'           Punctuation
'\n             ' Text
')'           Punctuation
')'           Punctuation
'\n             ' Text
'('           Punctuation
'FUNCTION'    Name.Variable
'\n              ' Text
';; (FUNCTION arg-types res-type) is somewhere between' Comment.Single
'\n              ' Text
';; NIL and FUNCTION, but undecidable.' Comment.Single
'\n              ' Text
'('           Punctuation
'if'          Keyword
' '           Text
'notp'        Name.Variable
' '           Text
"'NIL"        Literal.String.Symbol
' '           Text
"'FUNCTION"   Literal.String.Symbol
')'           Punctuation
'\n             ' Text
')'           Punctuation
'\n             ' Text
'('           Punctuation
't'           Name.Constant
' '           Text
'('           Punctuation
'cond'        Name.Builtin
' '           Text
'('           Punctuation
'('           Punctuation
'get'         Name.Builtin
' '           Text
'('           Punctuation
'first'       Name.Builtin
' '           Text
'y'           Name.Variable
')'           Punctuation
' '           Text
"'TYPE-LIST"  Literal.String.Symbol
')'           Punctuation
' '           Text
'y'           Name.Variable
')'           Punctuation
'\n                      ' Text
'('           Punctuation
'('           Punctuation
'setq'        Keyword
' '           Text
'f'           Name.Variable
' '           Text
'('           Punctuation
'get'         Name.Builtin
' '           Text
'('           Punctuation
'first'       Name.Builtin
' '           Text
'y'           Name.Variable
')'           Punctuation
' '           Text
"'DEFTYPE-EXPANDER" Literal.String.Symbol
')'           Punctuation
')'           Punctuation
'\n                       ' Text
'('           Punctuation
'let*'        Keyword
' '           Text
'('           Punctuation
'('           Punctuation
'z'           Name.Variable
' '           Text
'('           Punctuation
'funcall'     Name.Builtin
' '           Text
'f'           Name.Variable
' '           Text
'y'           Name.Variable
')'           Punctuation
')'           Punctuation
'\n                              ' Text
'('           Punctuation
'zx'          Name.Variable
' '           Text
'('           Punctuation
'type-for-discrimination' Name.Variable
' '           Text
'z'           Name.Variable
' '           Text
'notp'        Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n                         ' Text
'('           Punctuation
'if'          Keyword
' '           Text
'('           Punctuation
'eql'         Name.Builtin
' '           Text
'zx'          Name.Variable
' '           Text
'z'           Name.Variable
')'           Punctuation
' '           Text
'y'           Name.Variable
' '           Text
'zx'          Name.Variable
')'           Punctuation
'\n                      ' Text
')'           Punctuation
')'           Punctuation
'\n                      ' Text
'('           Punctuation
't'           Name.Constant
' '           Text
'y'           Name.Variable
')'           Punctuation
'\n        '  Text
')'           Punctuation
'  '          Text
')'           Punctuation
' '           Text
')'           Punctuation
'  '          Text
')'           Punctuation
'\n        '  Text
'('           Punctuation
't'           Name.Constant
' '           Text
'y'           Name.Variable
')'           Punctuation
'\n'          Text

')'           Punctuation
' '           Text
')'           Punctuation
'\n\n'        Text

'; Testet eine Liste von Werten auf Erfüllen eines Type-Specifiers. Für THE.' Comment.Single
'\n'          Text

'('           Punctuation
'defun'       Name.Builtin
' '           Text
'%the'        Name.Variable
' '           Text
'('           Punctuation
'values'      Name.Builtin
' '           Text
'type'        Keyword
')'           Punctuation
' '           Text
'; ABI'       Comment.Single
'\n  '        Text
'('           Punctuation
'macrolet'    Keyword
' '           Text
'('           Punctuation
'('           Punctuation
'near-typep'  Name.Variable
' '           Text
'('           Punctuation
'objform'     Name.Variable
' '           Text
'typform'     Name.Variable
')'           Punctuation
'\n               ' Text
';; near-typep ist wie typep, nur dass das Objekt auch ein' Comment.Single
'\n               ' Text
';; Read-Label sein darf. Das tritt z.B. auf bei' Comment.Single
'\n               ' Text
';; (read-from-string "#1=#S(FOO :X #1#)")' Comment.Single
'\n               ' Text
';; im Konstruktor MAKE-FOO. Die Implementation ist aber' Comment.Single
'\n               ' Text
';; nicht gezwungen, bei fehlerhaftem THE zwingend einen' Comment.Single
'\n               ' Text
';; Fehler zu melden, darum ist ein lascherer Typcheck hier' Comment.Single
'\n               ' Text
';; erlaubt.' Comment.Single
'\n               ' Text
'('           Punctuation
'let'         Keyword
' '           Text
'('           Punctuation
'('           Punctuation
'g'           Name.Variable
' '           Text
'('           Punctuation
'gensym'      Name.Builtin
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n                 ' Text
'`'           Operator
'('           Punctuation
'let'         Keyword
' '           Text
'('           Punctuation
'('           Punctuation
','           Operator
'g'           Name.Variable
' '           Text
','           Operator
'objform'     Name.Variable
')'           Punctuation
')'           Punctuation
'\n                    ' Text
'('           Punctuation
'or'          Name.Builtin
' '           Text
'('           Punctuation
'typep'       Name.Builtin
' '           Text
','           Operator
'g'           Name.Variable
' '           Text
','           Operator
'typform'     Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'('           Punctuation
'type-of'     Name.Builtin
' '           Text
','           Operator
'g'           Name.Variable
')'           Punctuation
' '           Text
"'READ-LABEL" Literal.String.Symbol
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n    '      Text
'('           Punctuation
'if'          Keyword
' '           Text
'('           Punctuation
'and'         Name.Builtin
' '           Text
'('           Punctuation
'consp'       Name.Builtin
' '           Text
'type'        Keyword
')'           Punctuation
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'('           Punctuation
'car'         Name.Builtin
' '           Text
'type'        Keyword
')'           Punctuation
' '           Text
"'VALUES"     Literal.String.Symbol
')'           Punctuation
')'           Punctuation
'\n      '    Text
';; The VALUES type specifier is ill-defined in ANSI CL.' Comment.Single
'\n      '    Text
';;'          Comment.Single
'\n      '    Text
';; There are two possibilities to define a VALUES type specifier in a' Comment.Single
'\n      '    Text
';; sane way:' Comment.Single
'\n      '    Text
';; - (EXACT-VALUES type1 ... [&optional ...]) describes the exact shape' Comment.Single
'\n      '    Text
';;   of the values list, as received by MULTIPLE-VALUE-LIST.' Comment.Single
'\n      '    Text
";;   For example, (EXACT-VALUES SYMBOL) is matched by (values 'a) but not" Comment.Single
'\n      '    Text
";;   by (values 'a 'b) or (values)." Comment.Single
'\n      '    Text
';; - (ASSIGNABLE-VALUES type1 ... [&optional ...]) describes the values' Comment.Single
'\n      '    Text
';;   as received by a set of variables through MULTIPLE-VALUE-BIND or' Comment.Single
'\n      '    Text
';;   MULTIPLE-VALUE-SETQ. For example, (ASSIGNABLE-VALUES SYMBOL) is' Comment.Single
'\n      '    Text
';;   defined by whether' Comment.Single
'\n      '    Text
';;     (MULTIPLE-VALUE-BIND (var1) values (DECLARE (TYPE SYMBOL var1)) ...)' Comment.Single
'\n      '    Text
';;   is valid or not; therefore (ASSIGNABLE-VALUES SYMBOL) is matched by' Comment.Single
'\n      '    Text
";;   (values 'a) and (values 'a 'b) and (values)." Comment.Single
'\n      '    Text
';;   Note that &OPTIONAL is actually redundant here:' Comment.Single
'\n      '    Text
';;     (ASSIGNABLE-VALUES type1 ... &optional otype1 ...)' Comment.Single
'\n      '    Text
';;   is equivalent to' Comment.Single
'\n      '    Text
';;     (ASSIGNABLE-VALUES type1 ... (OR NULL otype1) ...)' Comment.Single
'\n      '    Text
';; HyperSpec/Body/typspe_values.html indicates that VALUES means' Comment.Single
'\n      '    Text
';; EXACT-VALUES; however, HyperSpec/Body/speope_the.html indicates that' Comment.Single
'\n      '    Text
';; VALUES means ASSIGNABLE-VALUES.' Comment.Single
'\n      '    Text
';;'          Comment.Single
'\n      '    Text
';; SBCL interprets the VALUES type specifier to mean EXACT-VALUES when' Comment.Single
'\n      '    Text
';; it contains &OPTIONAL or &REST, but ASSIGNABLE-VALUES when it has' Comment.Single
'\n      '    Text
';; only a tuple of type specifiers. This is utter nonsense, in particular' Comment.Single
'\n      '    Text
';; because it makes (VALUES type1 ... typek &OPTIONAL)' Comment.Single
'\n      '    Text
';; different from   (VALUES type1 ... typek).' Comment.Single
'\n      '    Text
';;'          Comment.Single
'\n      '    Text
';; Here we use the ASSIGNABLE-VALUES interpretation.' Comment.Single
'\n      '    Text
";; In SUBTYPEP we just punt and don't assume any interpretation." Comment.Single
'\n      '    Text
'('           Punctuation
'let'         Keyword
' '           Text
'('           Punctuation
'('           Punctuation
'vals'        Name.Variable
' '           Text
'values'      Name.Builtin
')'           Punctuation
' '           Text
'('           Punctuation
'types'       Name.Variable
' '           Text
'('           Punctuation
'cdr'         Name.Builtin
' '           Text
'type'        Keyword
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n        '  Text
';; required:' Comment.Single
'\n        '  Text
'('           Punctuation
'loop'        Name.Builtin
'\n          ' Text
'('           Punctuation
'when'        Name.Builtin
' '           Text
'('           Punctuation
'or'          Name.Builtin
' '           Text
'('           Punctuation
'atom'        Name.Builtin
' '           Text
'types'       Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'atom'        Name.Builtin
' '           Text
'vals'        Name.Variable
')'           Punctuation
')'           Punctuation
' '           Text
'('           Punctuation
'return-from' Keyword
' '           Text
'%the'        Name.Variable
' '           Text
't'           Name.Constant
')'           Punctuation
')'           Punctuation
'\n          ' Text
'('           Punctuation
'when'        Name.Builtin
' '           Text
'('           Punctuation
'memq'        Name.Variable
' '           Text
'('           Punctuation
'car'         Name.Builtin
' '           Text
'types'       Name.Variable
')'           Punctuation
' '           Text
'lambda-list-keywords' Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'return'      Name.Builtin
')'           Punctuation
')'           Punctuation
'\n          ' Text
'('           Punctuation
'unless'      Name.Builtin
' '           Text
'('           Punctuation
'near-typep'  Name.Variable
' '           Text
'('           Punctuation
'pop'         Name.Builtin
' '           Text
'vals'        Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'pop'         Name.Builtin
' '           Text
'types'       Name.Variable
')'           Punctuation
')'           Punctuation
'\n            ' Text
'('           Punctuation
'return-from' Keyword
' '           Text
'%the'        Name.Variable
' '           Text
'nil'         Name.Constant
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n        '  Text
';; &optional:' Comment.Single
'\n        '  Text
'('           Punctuation
'when'        Name.Builtin
' '           Text
'('           Punctuation
'and'         Name.Builtin
' '           Text
'('           Punctuation
'consp'       Name.Builtin
' '           Text
'types'       Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'('           Punctuation
'car'         Name.Builtin
' '           Text
'types'       Name.Variable
')'           Punctuation
' '           Text
"'&optional"  Literal.String.Symbol
')'           Punctuation
')'           Punctuation
'\n          ' Text
'('           Punctuation
'setq'        Keyword
' '           Text
'types'       Name.Variable
' '           Text
'('           Punctuation
'cdr'         Name.Builtin
' '           Text
'types'       Name.Variable
')'           Punctuation
')'           Punctuation
'\n          ' Text
'('           Punctuation
'loop'        Name.Builtin
'\n            ' Text
'('           Punctuation
'when'        Name.Builtin
' '           Text
'('           Punctuation
'or'          Name.Builtin
' '           Text
'('           Punctuation
'atom'        Name.Builtin
' '           Text
'types'       Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'atom'        Name.Builtin
' '           Text
'vals'        Name.Variable
')'           Punctuation
')'           Punctuation
' '           Text
'('           Punctuation
'return-from' Keyword
' '           Text
'%the'        Name.Variable
' '           Text
't'           Name.Constant
')'           Punctuation
')'           Punctuation
'\n            ' Text
'('           Punctuation
'when'        Name.Builtin
' '           Text
'('           Punctuation
'memq'        Name.Variable
' '           Text
'('           Punctuation
'car'         Name.Builtin
' '           Text
'types'       Name.Variable
')'           Punctuation
' '           Text
'lambda-list-keywords' Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'return'      Name.Builtin
')'           Punctuation
')'           Punctuation
'\n            ' Text
'('           Punctuation
'unless'      Name.Builtin
' '           Text
'('           Punctuation
'near-typep'  Name.Variable
' '           Text
'('           Punctuation
'pop'         Name.Builtin
' '           Text
'vals'        Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'pop'         Name.Builtin
' '           Text
'types'       Name.Variable
')'           Punctuation
')'           Punctuation
'\n              ' Text
'('           Punctuation
'return-from' Keyword
' '           Text
'%the'        Name.Variable
' '           Text
'nil'         Name.Constant
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n        '  Text
';; &rest &key:' Comment.Single
'\n        '  Text
'('           Punctuation
'case'        Name.Builtin
' '           Text
'('           Punctuation
'car'         Name.Builtin
' '           Text
'types'       Name.Variable
')'           Punctuation
'\n          ' Text
'('           Punctuation
'&rest'       Keyword
'\n           ' Text
'('           Punctuation
'setq'        Keyword
' '           Text
'types'       Name.Variable
' '           Text
'('           Punctuation
'cdr'         Name.Builtin
' '           Text
'types'       Name.Variable
')'           Punctuation
')'           Punctuation
'\n           ' Text
'('           Punctuation
'when'        Name.Builtin
' '           Text
'('           Punctuation
'atom'        Name.Builtin
' '           Text
'types'       Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'typespec-error' Name.Variable
' '           Text
"'the"        Literal.String.Symbol
' '           Text
'type'        Keyword
')'           Punctuation
')'           Punctuation
'\n           ' Text
'('           Punctuation
'unless'      Name.Builtin
' '           Text
'('           Punctuation
'near-typep'  Name.Variable
' '           Text
'('           Punctuation
'pop'         Name.Builtin
' '           Text
'vals'        Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'pop'         Name.Builtin
' '           Text
'types'       Name.Variable
')'           Punctuation
')'           Punctuation
'\n             ' Text
'('           Punctuation
'return-from' Keyword
' '           Text
'%the'        Name.Variable
' '           Text
'nil'         Name.Constant
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n          ' Text
'('           Punctuation
'&key'        Keyword
')'           Punctuation
'\n          ' Text
'('           Punctuation
't'           Name.Constant
' '           Text
'('           Punctuation
'typespec-error' Name.Variable
' '           Text
"'the"        Literal.String.Symbol
' '           Text
'type'        Keyword
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n        '  Text
'('           Punctuation
'if'          Keyword
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'('           Punctuation
'car'         Name.Builtin
' '           Text
'types'       Name.Variable
')'           Punctuation
' '           Text
"'&key"       Literal.String.Symbol
')'           Punctuation
'\n          ' Text
'('           Punctuation
'progn'       Keyword
'\n            ' Text
'('           Punctuation
'setq'        Keyword
' '           Text
'types'       Name.Variable
' '           Text
'('           Punctuation
'cdr'         Name.Builtin
' '           Text
'types'       Name.Variable
')'           Punctuation
')'           Punctuation
'\n            ' Text
'('           Punctuation
'when'        Name.Builtin
' '           Text
'('           Punctuation
'oddp'        Name.Builtin
' '           Text
'('           Punctuation
'length'      Name.Builtin
' '           Text
'vals'        Name.Variable
')'           Punctuation
')'           Punctuation
' '           Text
'('           Punctuation
'return-from' Keyword
' '           Text
'%the'        Name.Variable
' '           Text
'nil'         Name.Constant
')'           Punctuation
')'           Punctuation
'\n            ' Text
'('           Punctuation
'let'         Keyword
' '           Text
'('           Punctuation
'('           Punctuation
'keywords'    Name.Variable
' '           Text
'nil'         Name.Constant
')'           Punctuation
')'           Punctuation
'\n              ' Text
'('           Punctuation
'loop'        Name.Builtin
'\n                ' Text
'('           Punctuation
'when'        Name.Builtin
' '           Text
'('           Punctuation
'or'          Name.Builtin
' '           Text
'('           Punctuation
'atom'        Name.Builtin
' '           Text
'types'       Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'atom'        Name.Builtin
' '           Text
'vals'        Name.Variable
')'           Punctuation
')'           Punctuation
' '           Text
'('           Punctuation
'return-from' Keyword
' '           Text
'%the'        Name.Variable
' '           Text
't'           Name.Constant
')'           Punctuation
')'           Punctuation
'\n                ' Text
'('           Punctuation
'when'        Name.Builtin
' '           Text
'('           Punctuation
'memq'        Name.Variable
' '           Text
'('           Punctuation
'car'         Name.Builtin
' '           Text
'types'       Name.Variable
')'           Punctuation
' '           Text
'lambda-list-keywords' Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'return'      Name.Builtin
')'           Punctuation
')'           Punctuation
'\n                ' Text
'('           Punctuation
'let'         Keyword
' '           Text
'('           Punctuation
'('           Punctuation
'item'        Name.Variable
' '           Text
'('           Punctuation
'pop'         Name.Builtin
' '           Text
'types'       Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n                  ' Text
'('           Punctuation
'unless'      Name.Builtin
' '           Text
'('           Punctuation
'and'         Name.Builtin
' '           Text
'('           Punctuation
'listp'       Name.Builtin
' '           Text
'item'        Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'eql'         Name.Builtin
' '           Text
'('           Punctuation
'length'      Name.Builtin
' '           Text
'item'        Name.Variable
')'           Punctuation
' '           Text
'2'           Literal.Number.Integer
')'           Punctuation
'\n                               ' Text
'('           Punctuation
'symbolp'     Name.Builtin
' '           Text
'('           Punctuation
'first'       Name.Builtin
' '           Text
'item'        Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n                    ' Text
'('           Punctuation
'typespec-error' Name.Variable
' '           Text
"'the"        Literal.String.Symbol
' '           Text
'type'        Keyword
')'           Punctuation
')'           Punctuation
'\n                  ' Text
'('           Punctuation
'let'         Keyword
' '           Text
'('           Punctuation
'('           Punctuation
'kw'          Name.Variable
' '           Text
'('           Punctuation
'symbol-to-keyword' Name.Variable
' '           Text
'('           Punctuation
'first'       Name.Builtin
' '           Text
'item'        Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n                    ' Text
'('           Punctuation
'unless'      Name.Builtin
' '           Text
'('           Punctuation
'near-typep'  Name.Variable
' '           Text
'('           Punctuation
'getf'        Name.Builtin
' '           Text
'vals'        Name.Variable
' '           Text
'kw'          Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'second'      Name.Builtin
' '           Text
'item'        Name.Variable
')'           Punctuation
')'           Punctuation
'\n                      ' Text
'('           Punctuation
'return-from' Keyword
' '           Text
'%the'        Name.Variable
' '           Text
'nil'         Name.Constant
')'           Punctuation
')'           Punctuation
'\n                    ' Text
'('           Punctuation
'push'        Name.Builtin
' '           Text
'kw'          Name.Variable
' '           Text
'keywords'    Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n              ' Text
'('           Punctuation
'if'          Keyword
' '           Text
'('           Punctuation
'and'         Name.Builtin
' '           Text
'('           Punctuation
'consp'       Name.Builtin
' '           Text
'types'       Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'('           Punctuation
'car'         Name.Builtin
' '           Text
'types'       Name.Variable
')'           Punctuation
' '           Text
"'&allow-other-keys" Literal.String.Symbol
')'           Punctuation
')'           Punctuation
'\n                ' Text
'('           Punctuation
'setq'        Keyword
' '           Text
'types'       Name.Variable
' '           Text
'('           Punctuation
'cdr'         Name.Builtin
' '           Text
'types'       Name.Variable
')'           Punctuation
')'           Punctuation
'\n                ' Text
'('           Punctuation
'unless'      Name.Builtin
' '           Text
'('           Punctuation
'getf'        Name.Builtin
' '           Text
'vals'        Name.Variable
' '           Text
"'"           Operator
':allow-other-keys' Literal.String.Symbol
')'           Punctuation
'\n                  ' Text
'('           Punctuation
'do'          Name.Builtin
' '           Text
'('           Punctuation
'('           Punctuation
'L'           Name.Variable
' '           Text
'vals'        Name.Variable
' '           Text
'('           Punctuation
'cddr'        Name.Builtin
' '           Text
'L'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n                      ' Text
'('           Punctuation
'('           Punctuation
'atom'        Name.Builtin
' '           Text
'L'           Name.Variable
')'           Punctuation
')'           Punctuation
'\n                    ' Text
'('           Punctuation
'unless'      Name.Builtin
' '           Text
'('           Punctuation
'memq'        Name.Variable
' '           Text
'('           Punctuation
'car'         Name.Builtin
' '           Text
'L'           Name.Variable
')'           Punctuation
' '           Text
'keywords'    Name.Variable
')'           Punctuation
'\n                      ' Text
'('           Punctuation
'return-from' Keyword
' '           Text
'%the'        Name.Variable
' '           Text
'nil'         Name.Constant
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n          ' Text
'('           Punctuation
'when'        Name.Builtin
' '           Text
'('           Punctuation
'consp'       Name.Builtin
' '           Text
'types'       Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'typespec-error' Name.Variable
' '           Text
"'the"        Literal.String.Symbol
' '           Text
'type'        Keyword
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n        '  Text
't'           Name.Constant
')'           Punctuation
'\n      '    Text
'('           Punctuation
'near-typep'  Name.Variable
' '           Text
'('           Punctuation
'if'          Keyword
' '           Text
'('           Punctuation
'consp'       Name.Builtin
' '           Text
'values'      Name.Builtin
')'           Punctuation
' '           Text
'('           Punctuation
'car'         Name.Builtin
' '           Text
'values'      Name.Builtin
')'           Punctuation
' '           Text
'nil'         Name.Constant
')'           Punctuation
' '           Text
'type'        Keyword
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

';;; ===========================================================================' Comment.Single
'\n\n'        Text

';; SUBTYPEP' Comment.Single
'\n'          Text

'('           Punctuation
'load'        Name.Builtin
' '           Text
'"subtypep"'  Literal.String
')'           Punctuation
'\n\n\n'      Text

';; Returns the number of bytes that are needed to represent #\\Null in a' Comment.Single
'\n'          Text

';; given encoding.' Comment.Single
'\n'          Text

'('           Punctuation
'defun'       Name.Builtin
' '           Text
'encoding-zeroes' Name.Variable
' '           Text
'('           Punctuation
'encoding'    Name.Variable
')'           Punctuation
'\n  '        Text
'#+'          Operator
'UNICODE'     Name.Variable
'\n  '        Text
';; this should use min_bytes_per_char for cache, not the hash table' Comment.Single
'\n  '        Text
'('           Punctuation
'let'         Keyword
' '           Text
'('           Punctuation
'('           Punctuation
'name'        Name.Variable
' '           Text
'('           Punctuation
'ext:encoding-charset' Name.Variable
' '           Text
'encoding'    Name.Variable
')'           Punctuation
')'           Punctuation
'\n        '  Text
'('           Punctuation
'table'       Name.Variable
' '           Text
'#.'          Operator
'('           Punctuation
'make-hash-table' Name.Builtin
' '           Text
':key-type'   Literal.String.Symbol
' '           Text
"'"           Operator
'('           Punctuation
'or'          Name.Builtin
' '           Text
'string'      Name.Builtin
' '           Text
'symbol'      Name.Class
')'           Punctuation
' '           Text
':value-type' Literal.String.Symbol
' '           Text
"'fixnum"     Literal.String.Symbol
'\n                                  ' Text
':test'       Literal.String.Symbol
' '           Text
"'stablehash-equal" Literal.String.Symbol
' '           Text
':warn-if-needs-rehash-after-gc' Literal.String.Symbol
' '           Text
't'           Name.Constant
'\n                                  ' Text
':initial-contents' Literal.String.Symbol
' '           Text
"'"           Operator
'('           Punctuation
'('           Punctuation
'"UTF-7"'     Literal.String
' '           Text
'.'           Operator
' '           Text
'1'           Literal.Number.Integer
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n        '  Text
'('           Punctuation
'tester'      Name.Variable
' '           Text
'#.'          Operator
'('           Punctuation
'make-string' Name.Builtin
' '           Text
'2'           Literal.Number.Integer
' '           Text
':initial-element' Literal.String.Symbol
' '           Text
'('           Punctuation
'code-char'   Name.Builtin
' '           Text
'0'           Literal.Number.Integer
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n    '      Text
'('           Punctuation
'or'          Name.Builtin
' '           Text
'('           Punctuation
'gethash'     Name.Builtin
' '           Text
'name'        Name.Variable
' '           Text
'table'       Name.Variable
')'           Punctuation
'\n        '  Text
'('           Punctuation
'setf'        Name.Builtin
' '           Text
'('           Punctuation
'gethash'     Name.Builtin
' '           Text
'name'        Name.Variable
' '           Text
'table'       Name.Variable
')'           Punctuation
'\n              ' Text
'('           Punctuation
'-'           Name.Builtin
' '           Text
'('           Punctuation
'length'      Name.Builtin
' '           Text
'('           Punctuation
'ext:convert-string-to-bytes' Name.Variable
' '           Text
'tester'      Name.Variable
' '           Text
'encoding'    Name.Variable
')'           Punctuation
')'           Punctuation
'\n                 ' Text
'('           Punctuation
'length'      Name.Builtin
' '           Text
'('           Punctuation
'ext:convert-string-to-bytes' Name.Variable
' '           Text
'tester'      Name.Variable
' '           Text
'encoding'    Name.Variable
'\n                                                      ' Text
':end'        Literal.String.Symbol
' '           Text
'1'           Literal.Number.Integer
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n  '        Text
'#-'          Operator
'UNICODE'     Name.Variable
' '           Text
'1'           Literal.Number.Integer
')'           Punctuation
'\n\n'        Text

';; Determines two values low,high such that' Comment.Single
'\n'          Text

';;   (subtypep type `(INTEGER ,low ,high))' Comment.Single
'\n'          Text

';; holds and low is as large as possible and high is as small as possible.' Comment.Single
'\n'          Text

';; low = * means -infinity, high = * means infinity.' Comment.Single
'\n'          Text

";; When (subtypep type 'INTEGER) is false, the values NIL,NIL are returned." Comment.Single
'\n'          Text

';; We need this function only for MAKE-ARRAY, UPGRADED-ARRAY-ELEMENT-TYPE and' Comment.Single
'\n'          Text

';; OPEN and can therefore w.l.o.g. replace' Comment.Single
'\n'          Text

';;   type  with  `(OR ,type (MEMBER 0))' Comment.Single
'\n'          Text

'#|'          Comment.Multiline
" ;; The original implementation calls canonicalize-type and then applies\n   ;; a particular SUBTYPE variant:\n (defun subtype-integer (type)\n  (macrolet ((yes () '(return-from subtype-integer (values low high)))\n             (no () '(return-from subtype-integer nil))\n             (unknown () '(return-from subtype-integer nil)))\n    (setq type (canonicalize-type type))\n    (if (consp type)\n      (case (first type)\n        (MEMBER ; (MEMBER &rest objects)\n          ;; All elements must be of type INTEGER.\n          (let ((low 0) (high 0)) ; wlog!\n            (dolist (x (rest type) (yes))\n              (unless (typep x 'INTEGER) (return (no)))\n              (setq low (min low x) high (max high x)))))\n        (OR ; (OR type*)\n          ;; Every type must be subtype of INTEGER.\n          (let ((low 0) (high 0)) ; wlog!\n            (dolist (type1 (rest type) (yes))\n              (multiple-value-bind (low1 high1) (subtype-integer type1)\n                (unless low1 (return (no)))\n                (setq low (if (or (eq low '*) (eq low1 '*)) '* (min low low1))\n                      high (if (or (eq high '*) (eq high1 '*))\n                               '* (max high high1)))))))\n        (AND ; (AND type*)\n          ;; If one of the types is subtype of INTEGER, then yes,\n          ;; otherwise unknown.\n          (let ((low nil) (high nil))\n            (dolist (type1 (rest type))\n              (multiple-value-bind (low1 high1) (subtype-integer type1)\n                (when low1\n                  (if low\n                    (setq low (if (eq low '*) low1 (if (eq low1 '*) low (max low low1)))\n                          high (if (eq high '*) high1 (if (eq high1 '*) high (min high high1))))\n                    (setq low low1 high high1)))))\n            (if low\n              (progn\n                (when (and (numberp low) (numberp high) (not (<= low high)))\n                  (setq low 0 high 0) ; type equivalent to NIL)\n                (yes))\n              (unknown)))))\n      (setq type (list type)))\n    (if (eq (first type) 'INTEGER)\n      (let ((low (if (rest type) (second type) '*))\n            (high (if (cddr type) (third type) '*)))\n        (when (consp low)\n          (setq low (first low))\n          (when (numberp low) (incf low)))\n        (when (consp high)\n          (setq high (first high))\n          (when (numberp high) (decf high)))\n        (when (and (numberp low) (numberp high) (not (<= low high))) ; type leer?\n          (setq low 0 high 0))\n        (yes))\n      (if (and (eq (first type) 'INTERVALS) (eq (second type) 'INTEGER))\n        (let ((low (third type))\n              (high (car (last type))))\n          (when (consp low)\n            (setq low (first low))\n            (when (numberp low) (incf low)))\n          (when (consp high)\n            (setq high (first high))\n            (when (numberp high) (decf high)))\n          (yes))\n        (unknown)))))\n" Comment.Multiline

'|#'          Comment.Multiline
' '           Text
';; This implementation inlines the (tail-recursive) canonicalize-type' Comment.Single
'\n   '       Text
";; function. Its advantage is that it doesn't cons as much." Comment.Single
'\n   '       Text
";; (For example, (subtype-integer '(UNSIGNED-BYTE 8)) doesn't cons.)" Comment.Single
'\n'          Text

'('           Punctuation
'defun'       Name.Builtin
' '           Text
'subtype-integer' Name.Variable
' '           Text
'('           Punctuation
'type'        Keyword
')'           Punctuation
'\n  '        Text
'('           Punctuation
'macrolet'    Keyword
' '           Text
'('           Punctuation
'('           Punctuation
'yes'         Name.Variable
' '           Text
'('           Punctuation
')'           Punctuation
' '           Text
"'"           Operator
'('           Punctuation
'return-from' Keyword
' '           Text
'subtype-integer' Name.Variable
' '           Text
'('           Punctuation
'values'      Name.Builtin
' '           Text
'low'         Name.Variable
' '           Text
'high'        Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n             ' Text
'('           Punctuation
'no'          Name.Variable
' '           Text
'('           Punctuation
')'           Punctuation
' '           Text
"'"           Operator
'('           Punctuation
'return-from' Keyword
' '           Text
'subtype-integer' Name.Variable
' '           Text
'nil'         Name.Constant
')'           Punctuation
')'           Punctuation
'\n             ' Text
'('           Punctuation
'unknown'     Name.Variable
' '           Text
'('           Punctuation
')'           Punctuation
' '           Text
"'"           Operator
'('           Punctuation
'return-from' Keyword
' '           Text
'subtype-integer' Name.Variable
' '           Text
'nil'         Name.Constant
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n    '      Text
'('           Punctuation
'setq'        Keyword
' '           Text
'type'        Keyword
' '           Text
'('           Punctuation
'expand-deftype' Name.Variable
' '           Text
'type'        Keyword
')'           Punctuation
')'           Punctuation
'\n    '      Text
'('           Punctuation
'cond'        Name.Builtin
' '           Text
'('           Punctuation
'('           Punctuation
'symbolp'     Name.Builtin
' '           Text
'type'        Keyword
')'           Punctuation
'\n           ' Text
'('           Punctuation
'case'        Name.Builtin
' '           Text
'type'        Keyword
'\n             ' Text
'('           Punctuation
'BIT'         Name.Variable
' '           Text
'('           Punctuation
'let'         Keyword
' '           Text
'('           Punctuation
'('           Punctuation
'low'         Name.Variable
' '           Text
'0'           Literal.Number.Integer
')'           Punctuation
' '           Text
'('           Punctuation
'high'        Name.Variable
' '           Text
'1'           Literal.Number.Integer
')'           Punctuation
')'           Punctuation
' '           Text
'('           Punctuation
'yes'         Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n             ' Text
'('           Punctuation
'FIXNUM'      Name.Variable
'\n              ' Text
'('           Punctuation
'let'         Keyword
' '           Text
'('           Punctuation
'('           Punctuation
'low'         Name.Variable
' '           Text
"'"           Operator
'#,'          Operator
'most-negative-fixnum' Name.Variable
')'           Punctuation
'\n                    ' Text
'('           Punctuation
'high'        Name.Variable
' '           Text
"'"           Operator
'#,'          Operator
'most-positive-fixnum' Name.Variable
')'           Punctuation
')'           Punctuation
'\n                ' Text
'('           Punctuation
'yes'         Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n             ' Text
'('           Punctuation
'('           Punctuation
'INTEGER'     Name.Variable
' '           Text
'BIGNUM'      Name.Variable
' '           Text
'SIGNED-BYTE' Name.Variable
')'           Punctuation
'\n              ' Text
'('           Punctuation
'let'         Keyword
' '           Text
'('           Punctuation
'('           Punctuation
'low'         Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
' '           Text
'('           Punctuation
'high'        Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
')'           Punctuation
' '           Text
'('           Punctuation
'yes'         Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n             ' Text
'('           Punctuation
'UNSIGNED-BYTE' Name.Variable
'\n              ' Text
'('           Punctuation
'let'         Keyword
' '           Text
'('           Punctuation
'('           Punctuation
'low'         Name.Variable
' '           Text
'0'           Literal.Number.Integer
')'           Punctuation
' '           Text
'('           Punctuation
'high'        Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
')'           Punctuation
' '           Text
'('           Punctuation
'yes'         Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n             ' Text
'('           Punctuation
'('           Punctuation
'NIL'         Name.Constant
')'           Punctuation
'\n              ' Text
'('           Punctuation
'let'         Keyword
' '           Text
'('           Punctuation
'('           Punctuation
'low'         Name.Variable
' '           Text
'0'           Literal.Number.Integer
')'           Punctuation
' '           Text
'('           Punctuation
'high'        Name.Variable
' '           Text
'0'           Literal.Number.Integer
')'           Punctuation
')'           Punctuation
' '           Text
'('           Punctuation
'yes'         Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
' '           Text
'; wlog!'     Comment.Single
'\n             ' Text
'('           Punctuation
't'           Name.Constant
' '           Text
'('           Punctuation
'no'          Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n          ' Text
'('           Punctuation
'('           Punctuation
'and'         Name.Builtin
' '           Text
'('           Punctuation
'consp'       Name.Builtin
' '           Text
'type'        Keyword
')'           Punctuation
' '           Text
'('           Punctuation
'symbolp'     Name.Builtin
' '           Text
'('           Punctuation
'first'       Name.Builtin
' '           Text
'type'        Keyword
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n           ' Text
'('           Punctuation
'unless'      Name.Builtin
' '           Text
'('           Punctuation
'and'         Name.Builtin
' '           Text
'('           Punctuation
'list-length' Name.Builtin
' '           Text
'type'        Keyword
')'           Punctuation
' '           Text
'('           Punctuation
'null'        Name.Builtin
' '           Text
'('           Punctuation
'cdr'         Name.Builtin
' '           Text
'('           Punctuation
'last'        Name.Builtin
' '           Text
'type'        Keyword
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n             ' Text
'('           Punctuation
'typespec-error' Name.Variable
' '           Text
"'subtypep"   Literal.String.Symbol
' '           Text
'type'        Keyword
')'           Punctuation
')'           Punctuation
'\n           ' Text
'('           Punctuation
'case'        Name.Builtin
' '           Text
'('           Punctuation
'first'       Name.Builtin
' '           Text
'type'        Keyword
')'           Punctuation
'\n             ' Text
'('           Punctuation
'MEMBER'      Name.Variable
' '           Text
'; (MEMBER &rest objects)' Comment.Single
'\n              ' Text
';; All elements must be of type INTEGER.' Comment.Single
'\n              ' Text
'('           Punctuation
'let'         Keyword
' '           Text
'('           Punctuation
'('           Punctuation
'low'         Name.Variable
' '           Text
'0'           Literal.Number.Integer
')'           Punctuation
' '           Text
'('           Punctuation
'high'        Name.Variable
' '           Text
'0'           Literal.Number.Integer
')'           Punctuation
')'           Punctuation
' '           Text
'; wlog!'     Comment.Single
'\n                ' Text
'('           Punctuation
'dolist'      Name.Builtin
' '           Text
'('           Punctuation
'x'           Name.Variable
' '           Text
'('           Punctuation
'rest'        Name.Builtin
' '           Text
'type'        Keyword
')'           Punctuation
' '           Text
'('           Punctuation
'yes'         Name.Variable
')'           Punctuation
')'           Punctuation
'\n                  ' Text
'('           Punctuation
'unless'      Name.Builtin
' '           Text
'('           Punctuation
'typep'       Name.Builtin
' '           Text
'x'           Name.Variable
' '           Text
"'INTEGER"    Literal.String.Symbol
')'           Punctuation
' '           Text
'('           Punctuation
'return'      Name.Builtin
' '           Text
'('           Punctuation
'no'          Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n                  ' Text
'('           Punctuation
'setq'        Keyword
' '           Text
'low'         Name.Variable
' '           Text
'('           Punctuation
'min'         Name.Builtin
' '           Text
'low'         Name.Variable
' '           Text
'x'           Name.Variable
')'           Punctuation
' '           Text
'high'        Name.Variable
' '           Text
'('           Punctuation
'max'         Name.Builtin
' '           Text
'high'        Name.Variable
' '           Text
'x'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n             ' Text
'('           Punctuation
'EQL'         Name.Variable
' '           Text
'; (EQL object)' Comment.Single
'\n              ' Text
'('           Punctuation
'let'         Keyword
' '           Text
'('           Punctuation
'('           Punctuation
'x'           Name.Variable
' '           Text
'('           Punctuation
'second'      Name.Builtin
' '           Text
'type'        Keyword
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n                ' Text
'('           Punctuation
'if'          Keyword
' '           Text
'('           Punctuation
'typep'       Name.Builtin
' '           Text
'x'           Name.Variable
' '           Text
"'INTEGER"    Literal.String.Symbol
')'           Punctuation
'\n                  ' Text
'('           Punctuation
'let'         Keyword
' '           Text
'('           Punctuation
'('           Punctuation
'low'         Name.Variable
' '           Text
'('           Punctuation
'min'         Name.Builtin
' '           Text
'0'           Literal.Number.Integer
' '           Text
'x'           Name.Variable
')'           Punctuation
')'           Punctuation
' '           Text
'('           Punctuation
'high'        Name.Variable
' '           Text
'('           Punctuation
'max'         Name.Builtin
' '           Text
'0'           Literal.Number.Integer
' '           Text
'x'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
' '           Text
'('           Punctuation
'yes'         Name.Variable
')'           Punctuation
')'           Punctuation
'\n                  ' Text
'('           Punctuation
'no'          Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n             ' Text
'('           Punctuation
'OR'          Name.Variable
' '           Text
'; (OR type*)' Comment.Single
'\n              ' Text
';; Every type must be subtype of INTEGER.' Comment.Single
'\n              ' Text
'('           Punctuation
'let'         Keyword
' '           Text
'('           Punctuation
'('           Punctuation
'low'         Name.Variable
' '           Text
'0'           Literal.Number.Integer
')'           Punctuation
' '           Text
'('           Punctuation
'high'        Name.Variable
' '           Text
'0'           Literal.Number.Integer
')'           Punctuation
')'           Punctuation
' '           Text
'; wlog!'     Comment.Single
'\n                ' Text
'('           Punctuation
'dolist'      Name.Builtin
' '           Text
'('           Punctuation
'type1'       Name.Variable
' '           Text
'('           Punctuation
'rest'        Name.Builtin
' '           Text
'type'        Keyword
')'           Punctuation
' '           Text
'('           Punctuation
'yes'         Name.Variable
')'           Punctuation
')'           Punctuation
'\n                  ' Text
'('           Punctuation
'multiple-value-bind' Name.Builtin
' '           Text
'('           Punctuation
'low1'        Name.Variable
' '           Text
'high1'       Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'subtype-integer' Name.Variable
' '           Text
'type1'       Name.Variable
')'           Punctuation
'\n                    ' Text
'('           Punctuation
'unless'      Name.Builtin
' '           Text
'low1'        Name.Variable
' '           Text
'('           Punctuation
'return'      Name.Builtin
' '           Text
'('           Punctuation
'no'          Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n                    ' Text
'('           Punctuation
'setq'        Keyword
' '           Text
'low'         Name.Variable
' '           Text
'('           Punctuation
'if'          Keyword
' '           Text
'('           Punctuation
'or'          Name.Builtin
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'low'         Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'low1'        Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
')'           Punctuation
'\n                                  ' Text
"'*"          Literal.String.Symbol
' '           Text
'('           Punctuation
'min'         Name.Builtin
' '           Text
'low'         Name.Variable
' '           Text
'low1'        Name.Variable
')'           Punctuation
')'           Punctuation
'\n                          ' Text
'high'        Name.Variable
' '           Text
'('           Punctuation
'if'          Keyword
' '           Text
'('           Punctuation
'or'          Name.Builtin
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'high'        Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'high1'       Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
')'           Punctuation
'\n                                   ' Text
"'*"          Literal.String.Symbol
' '           Text
'('           Punctuation
'max'         Name.Builtin
' '           Text
'high'        Name.Variable
' '           Text
'high1'       Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n             ' Text
'('           Punctuation
'AND'         Name.Variable
' '           Text
'; (AND type*)' Comment.Single
'\n              ' Text
';; If one of the types is subtype of INTEGER, then yes,' Comment.Single
'\n              ' Text
';; otherwise unknown.' Comment.Single
'\n              ' Text
'('           Punctuation
'let'         Keyword
' '           Text
'('           Punctuation
'('           Punctuation
'low'         Name.Variable
' '           Text
'nil'         Name.Constant
')'           Punctuation
' '           Text
'('           Punctuation
'high'        Name.Variable
' '           Text
'nil'         Name.Constant
')'           Punctuation
')'           Punctuation
'\n                ' Text
'('           Punctuation
'dolist'      Name.Builtin
' '           Text
'('           Punctuation
'type1'       Name.Variable
' '           Text
'('           Punctuation
'rest'        Name.Builtin
' '           Text
'type'        Keyword
')'           Punctuation
')'           Punctuation
'\n                  ' Text
'('           Punctuation
'multiple-value-bind' Name.Builtin
' '           Text
'('           Punctuation
'low1'        Name.Variable
' '           Text
'high1'       Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'subtype-integer' Name.Variable
' '           Text
'type1'       Name.Variable
')'           Punctuation
'\n                    ' Text
'('           Punctuation
'when'        Name.Builtin
' '           Text
'low1'        Name.Variable
'\n                      ' Text
'('           Punctuation
'if'          Keyword
' '           Text
'low'         Name.Variable
'\n                        ' Text
'('           Punctuation
'setq'        Keyword
' '           Text
'low'         Name.Variable
' '           Text
'('           Punctuation
'if'          Keyword
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'low'         Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
' '           Text
'low1'        Name.Variable
'\n                                      ' Text
'('           Punctuation
'if'          Keyword
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'low1'        Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
' '           Text
'low'         Name.Variable
'\n                                          ' Text
'('           Punctuation
'max'         Name.Builtin
' '           Text
'low'         Name.Variable
' '           Text
'low1'        Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n                              ' Text
'high'        Name.Variable
' '           Text
'('           Punctuation
'if'          Keyword
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'high'        Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
' '           Text
'high1'       Name.Variable
'\n                                       ' Text
'('           Punctuation
'if'          Keyword
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'high1'       Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
' '           Text
'high'        Name.Variable
'\n                                           ' Text
'('           Punctuation
'min'         Name.Builtin
' '           Text
'high'        Name.Variable
' '           Text
'high1'       Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n                        ' Text
'('           Punctuation
'setq'        Keyword
' '           Text
'low'         Name.Variable
' '           Text
'low1'        Name.Variable
'\n                              ' Text
'high'        Name.Variable
' '           Text
'high1'       Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n                ' Text
'('           Punctuation
'if'          Keyword
' '           Text
'low'         Name.Variable
'\n                  ' Text
'('           Punctuation
'progn'       Keyword
'\n                    ' Text
'('           Punctuation
'when'        Name.Builtin
' '           Text
'('           Punctuation
'and'         Name.Builtin
' '           Text
'('           Punctuation
'numberp'     Name.Builtin
' '           Text
'low'         Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'numberp'     Name.Builtin
' '           Text
'high'        Name.Variable
')'           Punctuation
'\n                               ' Text
'('           Punctuation
'not'         Name.Builtin
' '           Text
'('           Punctuation
'<='          Name.Builtin
' '           Text
'low'         Name.Variable
' '           Text
'high'        Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n                      ' Text
'('           Punctuation
'setq'        Keyword
' '           Text
'low'         Name.Variable
' '           Text
'0'           Literal.Number.Integer
' '           Text
'high'        Name.Variable
' '           Text
'0'           Literal.Number.Integer
')'           Punctuation
')'           Punctuation
' '           Text
'; type equivalent to NIL' Comment.Single
'\n                    ' Text
'('           Punctuation
'yes'         Name.Variable
')'           Punctuation
')'           Punctuation
'\n                  ' Text
'('           Punctuation
'unknown'     Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n             ' Text
'('           Punctuation
'INTEGER'     Name.Variable
'\n              ' Text
'('           Punctuation
'let'         Keyword
' '           Text
'('           Punctuation
'('           Punctuation
'low'         Name.Variable
' '           Text
'('           Punctuation
'if'          Keyword
' '           Text
'('           Punctuation
'rest'        Name.Builtin
' '           Text
'type'        Keyword
')'           Punctuation
' '           Text
'('           Punctuation
'second'      Name.Builtin
' '           Text
'type'        Keyword
')'           Punctuation
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
')'           Punctuation
'\n                    ' Text
'('           Punctuation
'high'        Name.Variable
' '           Text
'('           Punctuation
'if'          Keyword
' '           Text
'('           Punctuation
'cddr'        Name.Builtin
' '           Text
'type'        Keyword
')'           Punctuation
' '           Text
'('           Punctuation
'third'       Name.Builtin
' '           Text
'type'        Keyword
')'           Punctuation
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n                ' Text
'('           Punctuation
'when'        Name.Builtin
' '           Text
'('           Punctuation
'consp'       Name.Builtin
' '           Text
'low'         Name.Variable
')'           Punctuation
'\n                  ' Text
'('           Punctuation
'setq'        Keyword
' '           Text
'low'         Name.Variable
' '           Text
'('           Punctuation
'first'       Name.Builtin
' '           Text
'low'         Name.Variable
')'           Punctuation
')'           Punctuation
'\n                  ' Text
'('           Punctuation
'when'        Name.Builtin
' '           Text
'('           Punctuation
'numberp'     Name.Builtin
' '           Text
'low'         Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'incf'        Name.Builtin
' '           Text
'low'         Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n                ' Text
'('           Punctuation
'when'        Name.Builtin
' '           Text
'('           Punctuation
'consp'       Name.Builtin
' '           Text
'high'        Name.Variable
')'           Punctuation
'\n                  ' Text
'('           Punctuation
'setq'        Keyword
' '           Text
'high'        Name.Variable
' '           Text
'('           Punctuation
'first'       Name.Builtin
' '           Text
'high'        Name.Variable
')'           Punctuation
')'           Punctuation
'\n                  ' Text
'('           Punctuation
'when'        Name.Builtin
' '           Text
'('           Punctuation
'numberp'     Name.Builtin
' '           Text
'high'        Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'decf'        Name.Builtin
' '           Text
'high'        Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n                ' Text
'('           Punctuation
'when'        Name.Builtin
' '           Text
'('           Punctuation
'and'         Name.Builtin
' '           Text
'('           Punctuation
'numberp'     Name.Builtin
' '           Text
'low'         Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'numberp'     Name.Builtin
' '           Text
'high'        Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'not'         Name.Builtin
' '           Text
'('           Punctuation
'<='          Name.Builtin
' '           Text
'low'         Name.Variable
' '           Text
'high'        Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n                  ' Text
'('           Punctuation
'setq'        Keyword
' '           Text
'low'         Name.Variable
' '           Text
'0'           Literal.Number.Integer
' '           Text
'high'        Name.Variable
' '           Text
'0'           Literal.Number.Integer
')'           Punctuation
')'           Punctuation
' '           Text
'; type equivalent to NIL' Comment.Single
'\n                ' Text
'('           Punctuation
'yes'         Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n             ' Text
'('           Punctuation
'INTERVALS'   Name.Variable
'\n              ' Text
'('           Punctuation
'if'          Keyword
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'('           Punctuation
'second'      Name.Builtin
' '           Text
'type'        Keyword
')'           Punctuation
' '           Text
"'INTEGER"    Literal.String.Symbol
')'           Punctuation
'\n                ' Text
'('           Punctuation
'let'         Keyword
' '           Text
'('           Punctuation
'('           Punctuation
'low'         Name.Variable
' '           Text
'('           Punctuation
'third'       Name.Builtin
' '           Text
'type'        Keyword
')'           Punctuation
')'           Punctuation
'\n                      ' Text
'('           Punctuation
'high'        Name.Variable
' '           Text
'('           Punctuation
'car'         Name.Builtin
' '           Text
'('           Punctuation
'last'        Name.Builtin
' '           Text
'type'        Keyword
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n                  ' Text
'('           Punctuation
'when'        Name.Builtin
' '           Text
'('           Punctuation
'consp'       Name.Builtin
' '           Text
'low'         Name.Variable
')'           Punctuation
'\n                    ' Text
'('           Punctuation
'setq'        Keyword
' '           Text
'low'         Name.Variable
' '           Text
'('           Punctuation
'first'       Name.Builtin
' '           Text
'low'         Name.Variable
')'           Punctuation
')'           Punctuation
'\n                    ' Text
'('           Punctuation
'when'        Name.Builtin
' '           Text
'('           Punctuation
'numberp'     Name.Builtin
' '           Text
'low'         Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'incf'        Name.Builtin
' '           Text
'low'         Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n                  ' Text
'('           Punctuation
'when'        Name.Builtin
' '           Text
'('           Punctuation
'consp'       Name.Builtin
' '           Text
'high'        Name.Variable
')'           Punctuation
'\n                    ' Text
'('           Punctuation
'setq'        Keyword
' '           Text
'high'        Name.Variable
' '           Text
'('           Punctuation
'first'       Name.Builtin
' '           Text
'high'        Name.Variable
')'           Punctuation
')'           Punctuation
'\n                    ' Text
'('           Punctuation
'when'        Name.Builtin
' '           Text
'('           Punctuation
'numberp'     Name.Builtin
' '           Text
'high'        Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'decf'        Name.Builtin
' '           Text
'high'        Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n                  ' Text
'('           Punctuation
'yes'         Name.Variable
')'           Punctuation
')'           Punctuation
'\n                ' Text
'('           Punctuation
'unknown'     Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n             ' Text
'('           Punctuation
'MOD'         Name.Variable
' '           Text
'; (MOD n)'   Comment.Single
'\n              ' Text
'('           Punctuation
'let'         Keyword
' '           Text
'('           Punctuation
'('           Punctuation
'n'           Name.Variable
' '           Text
'('           Punctuation
'second'      Name.Builtin
' '           Text
'type'        Keyword
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n                ' Text
'('           Punctuation
'unless'      Name.Builtin
' '           Text
'('           Punctuation
'and'         Name.Builtin
' '           Text
'('           Punctuation
'integerp'    Name.Builtin
' '           Text
'n'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'>='          Name.Builtin
' '           Text
'n'           Name.Variable
' '           Text
'0'           Literal.Number.Integer
')'           Punctuation
')'           Punctuation
'\n                  ' Text
'('           Punctuation
'typespec-error' Name.Variable
' '           Text
"'subtypep"   Literal.String.Symbol
' '           Text
'type'        Keyword
')'           Punctuation
')'           Punctuation
'\n                ' Text
'('           Punctuation
'if'          Keyword
' '           Text
'('           Punctuation
'eql'         Name.Builtin
' '           Text
'n'           Name.Variable
' '           Text
'0'           Literal.Number.Integer
')'           Punctuation
'\n                  ' Text
'('           Punctuation
'no'          Name.Variable
')'           Punctuation
'\n                  ' Text
'('           Punctuation
'let'         Keyword
' '           Text
'('           Punctuation
'('           Punctuation
'low'         Name.Variable
' '           Text
'0'           Literal.Number.Integer
')'           Punctuation
' '           Text
'('           Punctuation
'high'        Name.Variable
' '           Text
'('           Punctuation
'1-'          Name.Builtin
' '           Text
'n'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n                    ' Text
'('           Punctuation
'yes'         Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n             ' Text
'('           Punctuation
'SIGNED-BYTE' Name.Variable
' '           Text
'; (SIGNED-BYTE &optional s)' Comment.Single
'\n              ' Text
'('           Punctuation
'let'         Keyword
' '           Text
'('           Punctuation
'('           Punctuation
's'           Name.Variable
' '           Text
'('           Punctuation
'if'          Keyword
' '           Text
'('           Punctuation
'cdr'         Name.Builtin
' '           Text
'type'        Keyword
')'           Punctuation
' '           Text
'('           Punctuation
'second'      Name.Builtin
' '           Text
'type'        Keyword
')'           Punctuation
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n                ' Text
'('           Punctuation
'if'          Keyword
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
's'           Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
'\n                  ' Text
'('           Punctuation
'let'         Keyword
' '           Text
'('           Punctuation
'('           Punctuation
'low'         Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
' '           Text
'('           Punctuation
'high'        Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
')'           Punctuation
' '           Text
'('           Punctuation
'yes'         Name.Variable
')'           Punctuation
')'           Punctuation
'\n                  ' Text
'('           Punctuation
'progn'       Keyword
'\n                    ' Text
'('           Punctuation
'unless'      Name.Builtin
' '           Text
'('           Punctuation
'and'         Name.Builtin
' '           Text
'('           Punctuation
'integerp'    Name.Builtin
' '           Text
's'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'plusp'       Name.Builtin
' '           Text
's'           Name.Variable
')'           Punctuation
')'           Punctuation
'\n                      ' Text
'('           Punctuation
'typespec-error' Name.Variable
' '           Text
"'subtypep"   Literal.String.Symbol
' '           Text
'type'        Keyword
')'           Punctuation
')'           Punctuation
'\n                    ' Text
'('           Punctuation
'let'         Keyword
' '           Text
'('           Punctuation
'('           Punctuation
'n'           Name.Variable
' '           Text
'('           Punctuation
'ash'         Name.Builtin
' '           Text
'1'           Literal.Number.Integer
' '           Text
'('           Punctuation
'1-'          Name.Builtin
' '           Text
's'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
' '           Text
'; (ash 1 *) == (expt 2 *)' Comment.Single
'\n                      ' Text
'('           Punctuation
'let'         Keyword
' '           Text
'('           Punctuation
'('           Punctuation
'low'         Name.Variable
' '           Text
'('           Punctuation
'-'           Name.Builtin
' '           Text
'n'           Name.Variable
')'           Punctuation
')'           Punctuation
' '           Text
'('           Punctuation
'high'        Name.Variable
' '           Text
'('           Punctuation
'1-'          Name.Builtin
' '           Text
'n'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n                        ' Text
'('           Punctuation
'yes'         Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n             ' Text
'('           Punctuation
'UNSIGNED-BYTE' Name.Variable
' '           Text
'; (UNSIGNED-BYTE &optional s)' Comment.Single
'\n              ' Text
'('           Punctuation
'let'         Keyword
' '           Text
'('           Punctuation
'('           Punctuation
's'           Name.Variable
' '           Text
'('           Punctuation
'if'          Keyword
' '           Text
'('           Punctuation
'cdr'         Name.Builtin
' '           Text
'type'        Keyword
')'           Punctuation
' '           Text
'('           Punctuation
'second'      Name.Builtin
' '           Text
'type'        Keyword
')'           Punctuation
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n                ' Text
'('           Punctuation
'if'          Keyword
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
's'           Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
'\n                    ' Text
'('           Punctuation
'let'         Keyword
' '           Text
'('           Punctuation
'('           Punctuation
'low'         Name.Variable
' '           Text
'0'           Literal.Number.Integer
')'           Punctuation
' '           Text
'('           Punctuation
'high'        Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
')'           Punctuation
' '           Text
'('           Punctuation
'yes'         Name.Variable
')'           Punctuation
')'           Punctuation
'\n                    ' Text
'('           Punctuation
'progn'       Keyword
'\n                      ' Text
'('           Punctuation
'unless'      Name.Builtin
' '           Text
'('           Punctuation
'and'         Name.Builtin
' '           Text
'('           Punctuation
'integerp'    Name.Builtin
' '           Text
's'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'>='          Name.Builtin
' '           Text
's'           Name.Variable
' '           Text
'0'           Literal.Number.Integer
')'           Punctuation
')'           Punctuation
'\n                        ' Text
'('           Punctuation
'typespec-error' Name.Variable
' '           Text
"'subtypep"   Literal.String.Symbol
' '           Text
'type'        Keyword
')'           Punctuation
')'           Punctuation
'\n                      ' Text
'('           Punctuation
'let'         Keyword
' '           Text
'('           Punctuation
'('           Punctuation
'n'           Name.Variable
' '           Text
'('           Punctuation
'ash'         Name.Builtin
' '           Text
'1'           Literal.Number.Integer
' '           Text
's'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
' '           Text
'; (ash 1 *) == (expt 2 *)' Comment.Single
'\n                        ' Text
'('           Punctuation
'let'         Keyword
' '           Text
'('           Punctuation
'('           Punctuation
'low'         Name.Variable
' '           Text
'0'           Literal.Number.Integer
')'           Punctuation
' '           Text
'('           Punctuation
'high'        Name.Variable
' '           Text
'('           Punctuation
'1-'          Name.Builtin
' '           Text
'n'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n                          ' Text
'('           Punctuation
'yes'         Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n             ' Text
'('           Punctuation
't'           Name.Constant
' '           Text
'('           Punctuation
'no'          Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n          ' Text
'('           Punctuation
'('           Punctuation
'clos::defined-class-p' Name.Variable
' '           Text
'type'        Keyword
')'           Punctuation
'\n           ' Text
'('           Punctuation
'if'          Keyword
' '           Text
'('           Punctuation
'and'         Name.Builtin
' '           Text
'('           Punctuation
'clos::built-in-class-p' Name.Variable
' '           Text
'type'        Keyword
')'           Punctuation
'\n                    ' Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'('           Punctuation
'get'         Name.Builtin
' '           Text
'('           Punctuation
'clos:class-name' Name.Variable
' '           Text
'type'        Keyword
')'           Punctuation
' '           Text
"'CLOS::CLOSCLASS" Literal.String.Symbol
')'           Punctuation
' '           Text
'type'        Keyword
')'           Punctuation
')'           Punctuation
'\n             ' Text
'('           Punctuation
'return-from' Keyword
' '           Text
'subtype-integer' Name.Variable
'\n               ' Text
'('           Punctuation
'subtype-integer' Name.Variable
' '           Text
'('           Punctuation
'clos:class-name' Name.Variable
' '           Text
'type'        Keyword
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n             ' Text
'('           Punctuation
'no'          Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n          ' Text
'('           Punctuation
'('           Punctuation
'clos::eql-specializer-p' Name.Variable
' '           Text
'type'        Keyword
')'           Punctuation
'\n           ' Text
'('           Punctuation
'let'         Keyword
' '           Text
'('           Punctuation
'('           Punctuation
'x'           Name.Variable
' '           Text
'('           Punctuation
'clos::eql-specializer-singleton' Name.Variable
' '           Text
'type'        Keyword
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n             ' Text
'('           Punctuation
'if'          Keyword
' '           Text
'('           Punctuation
'typep'       Name.Builtin
' '           Text
'x'           Name.Variable
' '           Text
"'INTEGER"    Literal.String.Symbol
')'           Punctuation
'\n               ' Text
'('           Punctuation
'let'         Keyword
' '           Text
'('           Punctuation
'('           Punctuation
'low'         Name.Variable
' '           Text
'('           Punctuation
'min'         Name.Builtin
' '           Text
'0'           Literal.Number.Integer
' '           Text
'x'           Name.Variable
')'           Punctuation
')'           Punctuation
' '           Text
'('           Punctuation
'high'        Name.Variable
' '           Text
'('           Punctuation
'max'         Name.Builtin
' '           Text
'0'           Literal.Number.Integer
' '           Text
'x'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
' '           Text
'('           Punctuation
'yes'         Name.Variable
')'           Punctuation
')'           Punctuation
'\n               ' Text
'('           Punctuation
'no'          Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n          ' Text
'('           Punctuation
'('           Punctuation
'encodingp'   Name.Variable
' '           Text
'type'        Keyword
')'           Punctuation
' '           Text
'('           Punctuation
'no'          Name.Variable
')'           Punctuation
')'           Punctuation
'\n          ' Text
'('           Punctuation
't'           Name.Constant
' '           Text
'('           Punctuation
'typespec-error' Name.Variable
' '           Text
"'subtypep"   Literal.String.Symbol
' '           Text
'type'        Keyword
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'#|'          Comment.Multiline
" TODO: Fix subtype-integer such that this works.\nHenry Baker:\n (defun type-null (x)\n  (values (and (eq 'bit (upgraded-array-element-type `(or bit ,x)))\n               (not (typep 0 x))\n               (not (typep 1 x)))\n          t))\n (type-null '(and symbol number))\n (type-null '(and integer symbol))\n (type-null '(and integer character))\n" Comment.Multiline

'|#'          Comment.Multiline
'\n\n'        Text

';; Determines a sequence kind (an atom, as defined in defseq.lisp: one of' Comment.Single
'\n'          Text

';;   LIST - stands for LIST' Comment.Single
'\n'          Text

';;   VECTOR - stands for (VECTOR T)' Comment.Single
'\n'          Text

';;   STRING - stands for (VECTOR CHARACTER)' Comment.Single
'\n'          Text

';;   1, 2, 4, 8, 16, 32 - stands for (VECTOR (UNSIGNED-BYTE n))' Comment.Single
'\n'          Text

';;   0 - stands for (VECTOR NIL))' Comment.Single
'\n'          Text

';; that indicates the sequence type meant by the given type. Other possible' Comment.Single
'\n'          Text

';; return values are' Comment.Single
'\n'          Text

';;   SEQUENCE - denoting a type whose intersection with (OR LIST VECTOR) is not' Comment.Single
'\n'          Text

';;              subtype of LIST or VECTOR, or' Comment.Single
'\n'          Text

';;   NIL - indicating a type whose intersection with (OR LIST VECTOR) is empty.' Comment.Single
'\n'          Text

';; When the type is (OR (VECTOR eltype1) ... (VECTOR eltypeN)), the chosen' Comment.Single
'\n'          Text

';; element type is the smallest element type that contains all of eltype1 ...' Comment.Single
'\n'          Text

';; eltypeN.' Comment.Single
'\n'          Text

';;'          Comment.Single
'\n'          Text

';; User-defined sequence types are not supported here.' Comment.Single
'\n'          Text

';;'          Comment.Single
'\n'          Text

';; This implementation inlines the (tail-recursive) canonicalize-type' Comment.Single
'\n'          Text

";; function. Its advantage is that it doesn't cons as much. Also it employs" Comment.Single
'\n'          Text

';; some heuristics and does not have the full power of SUBTYPEP.' Comment.Single
'\n'          Text

'('           Punctuation
'defun'       Name.Builtin
' '           Text
'subtype-sequence' Name.Variable
' '           Text
'('           Punctuation
'type'        Keyword
')'           Punctuation
'\n  '        Text
'('           Punctuation
'setq'        Keyword
' '           Text
'type'        Keyword
' '           Text
'('           Punctuation
'expand-deftype' Name.Variable
' '           Text
'type'        Keyword
')'           Punctuation
')'           Punctuation
'\n  '        Text
'('           Punctuation
'cond'        Name.Builtin
' '           Text
'('           Punctuation
'('           Punctuation
'symbolp'     Name.Builtin
' '           Text
'type'        Keyword
')'           Punctuation
'\n         ' Text
'('           Punctuation
'case'        Name.Builtin
' '           Text
'type'        Keyword
'\n           ' Text
'('           Punctuation
'('           Punctuation
'LIST'        Name.Variable
' '           Text
'CONS'        Name.Variable
' '           Text
'NULL'        Name.Variable
')'           Punctuation
' '           Text
"'LIST"       Literal.String.Symbol
')'           Punctuation
'\n           ' Text
'('           Punctuation
'('           Punctuation
'NIL'         Name.Constant
')'           Punctuation
' '           Text
"'NIL"        Literal.String.Symbol
')'           Punctuation
'\n           ' Text
'('           Punctuation
'('           Punctuation
'BIT-VECTOR'  Name.Variable
' '           Text
'SIMPLE-BIT-VECTOR' Name.Variable
')'           Punctuation
' '           Text
"'1"          Literal.String.Symbol
')'           Punctuation
'\n           ' Text
'('           Punctuation
'('           Punctuation
'STRING'      Name.Variable
' '           Text
'SIMPLE-STRING' Name.Variable
' '           Text
'BASE-STRING' Name.Variable
' '           Text
'SIMPLE-BASE-STRING' Name.Variable
')'           Punctuation
' '           Text
"'STRING"     Literal.String.Symbol
')'           Punctuation
'\n           ' Text
'('           Punctuation
'('           Punctuation
'VECTOR'      Name.Variable
' '           Text
'SIMPLE-VECTOR' Name.Variable
' '           Text
'ARRAY'       Name.Variable
' '           Text
'SIMPLE-ARRAY' Name.Variable
')'           Punctuation
' '           Text
"'VECTOR"     Literal.String.Symbol
')'           Punctuation
'\n           ' Text
'('           Punctuation
'('           Punctuation
'SEQUENCE'    Name.Variable
')'           Punctuation
' '           Text
"'SEQUENCE"   Literal.String.Symbol
')'           Punctuation
'\n           ' Text
'('           Punctuation
't'           Name.Constant
' '           Text
"'NIL"        Literal.String.Symbol
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n        '  Text
'('           Punctuation
'('           Punctuation
'and'         Name.Builtin
' '           Text
'('           Punctuation
'consp'       Name.Builtin
' '           Text
'type'        Keyword
')'           Punctuation
' '           Text
'('           Punctuation
'symbolp'     Name.Builtin
' '           Text
'('           Punctuation
'first'       Name.Builtin
' '           Text
'type'        Keyword
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n         ' Text
'('           Punctuation
'unless'      Name.Builtin
' '           Text
'('           Punctuation
'and'         Name.Builtin
' '           Text
'('           Punctuation
'list-length' Name.Builtin
' '           Text
'type'        Keyword
')'           Punctuation
' '           Text
'('           Punctuation
'null'        Name.Builtin
' '           Text
'('           Punctuation
'cdr'         Name.Builtin
' '           Text
'('           Punctuation
'last'        Name.Builtin
' '           Text
'type'        Keyword
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n           ' Text
'('           Punctuation
'typespec-error' Name.Variable
' '           Text
"'subtypep"   Literal.String.Symbol
' '           Text
'type'        Keyword
')'           Punctuation
')'           Punctuation
'\n         ' Text
'('           Punctuation
'case'        Name.Builtin
' '           Text
'('           Punctuation
'first'       Name.Builtin
' '           Text
'type'        Keyword
')'           Punctuation
'\n           ' Text
'('           Punctuation
'MEMBER'      Name.Variable
' '           Text
'; (MEMBER &rest objects)' Comment.Single
'\n            ' Text
'('           Punctuation
'let'         Keyword
' '           Text
'('           Punctuation
'('           Punctuation
'kind'        Name.Variable
' '           Text
"'NIL"        Literal.String.Symbol
')'           Punctuation
')'           Punctuation
'\n              ' Text
'('           Punctuation
'dolist'      Name.Builtin
' '           Text
'('           Punctuation
'x'           Name.Variable
' '           Text
'('           Punctuation
'rest'        Name.Builtin
' '           Text
'type'        Keyword
')'           Punctuation
')'           Punctuation
'\n                ' Text
'('           Punctuation
'setq'        Keyword
' '           Text
'kind'        Name.Variable
' '           Text
'('           Punctuation
'sequence-type-union' Name.Variable
' '           Text
'kind'        Name.Variable
' '           Text
'('           Punctuation
'type-of-sequence' Name.Variable
' '           Text
'x'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n              ' Text
'kind'        Name.Variable
')'           Punctuation
')'           Punctuation
'\n           ' Text
'('           Punctuation
'EQL'         Name.Variable
' '           Text
'; (EQL object)' Comment.Single
'\n            ' Text
'('           Punctuation
'unless'      Name.Builtin
' '           Text
'('           Punctuation
'eql'         Name.Builtin
' '           Text
'('           Punctuation
'length'      Name.Builtin
' '           Text
'type'        Keyword
')'           Punctuation
' '           Text
'2'           Literal.Number.Integer
')'           Punctuation
'\n              ' Text
'('           Punctuation
'typespec-error' Name.Variable
' '           Text
"'subtypep"   Literal.String.Symbol
' '           Text
'type'        Keyword
')'           Punctuation
')'           Punctuation
'\n            ' Text
'('           Punctuation
'type-of-sequence' Name.Variable
' '           Text
'('           Punctuation
'second'      Name.Builtin
' '           Text
'type'        Keyword
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n           ' Text
'('           Punctuation
'OR'          Name.Variable
' '           Text
'; (OR type*)' Comment.Single
'\n            ' Text
'('           Punctuation
'let'         Keyword
' '           Text
'('           Punctuation
'('           Punctuation
'kind'        Name.Variable
' '           Text
"'NIL"        Literal.String.Symbol
')'           Punctuation
')'           Punctuation
'\n              ' Text
'('           Punctuation
'dolist'      Name.Builtin
' '           Text
'('           Punctuation
'x'           Name.Variable
' '           Text
'('           Punctuation
'rest'        Name.Builtin
' '           Text
'type'        Keyword
')'           Punctuation
')'           Punctuation
'\n                ' Text
'('           Punctuation
'setq'        Keyword
' '           Text
'kind'        Name.Variable
' '           Text
'('           Punctuation
'sequence-type-union' Name.Variable
' '           Text
'kind'        Name.Variable
' '           Text
'('           Punctuation
'subtype-sequence' Name.Variable
' '           Text
'x'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n              ' Text
'kind'        Name.Variable
')'           Punctuation
')'           Punctuation
'\n           ' Text
'('           Punctuation
'AND'         Name.Variable
' '           Text
'; (AND type*)' Comment.Single
'\n            ' Text
'('           Punctuation
'let'         Keyword
' '           Text
'('           Punctuation
'('           Punctuation
'kind'        Name.Variable
' '           Text
"'SEQUENCE"   Literal.String.Symbol
')'           Punctuation
')'           Punctuation
'\n              ' Text
'('           Punctuation
'dolist'      Name.Builtin
' '           Text
'('           Punctuation
'x'           Name.Variable
' '           Text
'('           Punctuation
'rest'        Name.Builtin
' '           Text
'type'        Keyword
')'           Punctuation
')'           Punctuation
'\n                ' Text
'('           Punctuation
'setq'        Keyword
' '           Text
'kind'        Name.Variable
' '           Text
'('           Punctuation
'sequence-type-intersection' Name.Variable
' '           Text
'kind'        Name.Variable
' '           Text
'('           Punctuation
'subtype-sequence' Name.Variable
' '           Text
'x'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n              ' Text
'kind'        Name.Variable
')'           Punctuation
')'           Punctuation
'\n           ' Text
'('           Punctuation
'('           Punctuation
'SIMPLE-BIT-VECTOR' Name.Variable
' '           Text
'BIT-VECTOR'  Name.Variable
')'           Punctuation
' '           Text
'; (SIMPLE-BIT-VECTOR &optional size)' Comment.Single
'\n            ' Text
'('           Punctuation
'when'        Name.Builtin
' '           Text
'('           Punctuation
'cddr'        Name.Builtin
' '           Text
'type'        Keyword
')'           Punctuation
'\n              ' Text
'('           Punctuation
'typespec-error' Name.Variable
' '           Text
"'subtypep"   Literal.String.Symbol
' '           Text
'type'        Keyword
')'           Punctuation
')'           Punctuation
'\n            ' Text
"'1"          Literal.String.Symbol
')'           Punctuation
'\n           ' Text
'('           Punctuation
'('           Punctuation
'SIMPLE-STRING' Name.Variable
' '           Text
'STRING'      Name.Variable
' '           Text
'SIMPLE-BASE-STRING' Name.Variable
' '           Text
'BASE-STRING' Name.Variable
')'           Punctuation
' '           Text
'; (SIMPLE-STRING &optional size)' Comment.Single
'\n            ' Text
'('           Punctuation
'when'        Name.Builtin
' '           Text
'('           Punctuation
'cddr'        Name.Builtin
' '           Text
'type'        Keyword
')'           Punctuation
'\n              ' Text
'('           Punctuation
'typespec-error' Name.Variable
' '           Text
"'subtypep"   Literal.String.Symbol
' '           Text
'type'        Keyword
')'           Punctuation
')'           Punctuation
'\n            ' Text
"'STRING"     Literal.String.Symbol
')'           Punctuation
'\n           ' Text
'('           Punctuation
'SIMPLE-VECTOR' Name.Variable
' '           Text
'; (SIMPLE-VECTOR &optional size)' Comment.Single
'\n            ' Text
'('           Punctuation
'when'        Name.Builtin
' '           Text
'('           Punctuation
'cddr'        Name.Builtin
' '           Text
'type'        Keyword
')'           Punctuation
'\n              ' Text
'('           Punctuation
'typespec-error' Name.Variable
' '           Text
"'subtypep"   Literal.String.Symbol
' '           Text
'type'        Keyword
')'           Punctuation
')'           Punctuation
'\n            ' Text
"'VECTOR"     Literal.String.Symbol
')'           Punctuation
'\n           ' Text
'('           Punctuation
'('           Punctuation
'VECTOR'      Name.Variable
' '           Text
'ARRAY'       Name.Variable
' '           Text
'SIMPLE-ARRAY' Name.Variable
')'           Punctuation
' '           Text
'; (VECTOR &optional el-type size), (ARRAY &optional el-type dimensions)' Comment.Single
'\n            ' Text
'('           Punctuation
'when'        Name.Builtin
' '           Text
'('           Punctuation
'cdddr'       Name.Builtin
' '           Text
'type'        Keyword
')'           Punctuation
'\n              ' Text
'('           Punctuation
'typespec-error' Name.Variable
' '           Text
"'subtypep"   Literal.String.Symbol
' '           Text
'type'        Keyword
')'           Punctuation
')'           Punctuation
'\n            ' Text
'('           Punctuation
'let'         Keyword
' '           Text
'('           Punctuation
'('           Punctuation
'el-type'     Name.Variable
' '           Text
'('           Punctuation
'if'          Keyword
' '           Text
'('           Punctuation
'cdr'         Name.Builtin
' '           Text
'type'        Keyword
')'           Punctuation
' '           Text
'('           Punctuation
'second'      Name.Builtin
' '           Text
'type'        Keyword
')'           Punctuation
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n              ' Text
'('           Punctuation
'if'          Keyword
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'el-type'     Name.Variable
' '           Text
"'*"          Literal.String.Symbol
')'           Punctuation
'\n                ' Text
"'VECTOR"     Literal.String.Symbol
'\n                ' Text
'('           Punctuation
'let'         Keyword
' '           Text
'('           Punctuation
'('           Punctuation
'eltype'      Name.Variable
' '           Text
'('           Punctuation
'upgraded-array-element-type' Name.Builtin
' '           Text
'el-type'     Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n                  ' Text
'('           Punctuation
'cond'        Name.Builtin
' '           Text
'('           Punctuation
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'eltype'      Name.Variable
' '           Text
"'T"          Literal.String.Symbol
')'           Punctuation
' '           Text
"'VECTOR"     Literal.String.Symbol
')'           Punctuation
'\n                        ' Text
'('           Punctuation
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'eltype'      Name.Variable
' '           Text
"'CHARACTER"  Literal.String.Symbol
')'           Punctuation
' '           Text
"'STRING"     Literal.String.Symbol
')'           Punctuation
'\n                        ' Text
'('           Punctuation
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'eltype'      Name.Variable
' '           Text
"'BIT"        Literal.String.Symbol
')'           Punctuation
' '           Text
"'1"          Literal.String.Symbol
')'           Punctuation
'\n                        ' Text
'('           Punctuation
'('           Punctuation
'and'         Name.Builtin
' '           Text
'('           Punctuation
'consp'       Name.Builtin
' '           Text
'eltype'      Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'('           Punctuation
'first'       Name.Builtin
' '           Text
'eltype'      Name.Variable
')'           Punctuation
' '           Text
"'UNSIGNED-BYTE" Literal.String.Symbol
')'           Punctuation
')'           Punctuation
' '           Text
'('           Punctuation
'second'      Name.Builtin
' '           Text
'eltype'      Name.Variable
')'           Punctuation
')'           Punctuation
'\n                        ' Text
'('           Punctuation
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'eltype'      Name.Variable
' '           Text
"'NIL"        Literal.String.Symbol
')'           Punctuation
' '           Text
"'0"          Literal.String.Symbol
')'           Punctuation
'\n                        ' Text
'('           Punctuation
't'           Name.Constant
' '           Text
'('           Punctuation
'error'       Name.Builtin
' '           Text
'('           Punctuation
'TEXT'        Name.Variable
' '           Text
'"~S is not up-to-date with ~S for element type ~S"' Literal.String
')'           Punctuation
'\n                                  ' Text
"'subtypep-sequence" Literal.String.Symbol
' '           Text
"'upgraded-array-element-type" Literal.String.Symbol
' '           Text
'eltype'      Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n           ' Text
'('           Punctuation
'('           Punctuation
'CONS'        Name.Variable
')'           Punctuation
' '           Text
'; (CONS &optional cartype cdrtype)' Comment.Single
'\n            ' Text
'('           Punctuation
'when'        Name.Builtin
' '           Text
'('           Punctuation
'cdddr'       Name.Builtin
' '           Text
'type'        Keyword
')'           Punctuation
'\n              ' Text
'('           Punctuation
'typespec-error' Name.Variable
' '           Text
"'subtypep"   Literal.String.Symbol
' '           Text
'type'        Keyword
')'           Punctuation
')'           Punctuation
'\n            ' Text
"'LIST"       Literal.String.Symbol
')'           Punctuation
'\n           ' Text
'('           Punctuation
't'           Name.Constant
' '           Text
"'NIL"        Literal.String.Symbol
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n        '  Text
'('           Punctuation
'('           Punctuation
'clos::defined-class-p' Name.Variable
' '           Text
'type'        Keyword
')'           Punctuation
'\n         ' Text
'('           Punctuation
'if'          Keyword
' '           Text
'('           Punctuation
'and'         Name.Builtin
' '           Text
'('           Punctuation
'clos::built-in-class-p' Name.Variable
' '           Text
'type'        Keyword
')'           Punctuation
'\n                  ' Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'('           Punctuation
'get'         Name.Builtin
' '           Text
'('           Punctuation
'clos:class-name' Name.Variable
' '           Text
'type'        Keyword
')'           Punctuation
' '           Text
"'CLOS::CLOSCLASS" Literal.String.Symbol
')'           Punctuation
' '           Text
'type'        Keyword
')'           Punctuation
')'           Punctuation
'\n           ' Text
'('           Punctuation
'subtype-sequence' Name.Variable
' '           Text
'('           Punctuation
'clos:class-name' Name.Variable
' '           Text
'type'        Keyword
')'           Punctuation
')'           Punctuation
'\n           ' Text
"'NIL"        Literal.String.Symbol
')'           Punctuation
')'           Punctuation
'\n        '  Text
'('           Punctuation
'('           Punctuation
'clos::eql-specializer-p' Name.Variable
' '           Text
'type'        Keyword
')'           Punctuation
'\n         ' Text
'('           Punctuation
'type-of-sequence' Name.Variable
' '           Text
'('           Punctuation
'clos::eql-specializer-singleton' Name.Variable
' '           Text
'type'        Keyword
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n        '  Text
'('           Punctuation
't'           Name.Constant
' '           Text
"'NIL"        Literal.String.Symbol
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n'          Text

'('           Punctuation
'defun'       Name.Builtin
' '           Text
'type-of-sequence' Name.Variable
' '           Text
'('           Punctuation
'x'           Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'cond'        Name.Builtin
' '           Text
'('           Punctuation
'('           Punctuation
'listp'       Name.Builtin
' '           Text
'x'           Name.Variable
')'           Punctuation
' '           Text
"'LIST"       Literal.String.Symbol
')'           Punctuation
'\n        '  Text
'('           Punctuation
'('           Punctuation
'vectorp'     Name.Builtin
' '           Text
'x'           Name.Variable
')'           Punctuation
'\n         ' Text
'('           Punctuation
'let'         Keyword
' '           Text
'('           Punctuation
'('           Punctuation
'eltype'      Name.Variable
' '           Text
'('           Punctuation
'array-element-type' Name.Builtin
' '           Text
'x'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n           ' Text
'('           Punctuation
'cond'        Name.Builtin
' '           Text
'('           Punctuation
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'eltype'      Name.Variable
' '           Text
"'T"          Literal.String.Symbol
')'           Punctuation
' '           Text
"'VECTOR"     Literal.String.Symbol
')'           Punctuation
'\n                 ' Text
'('           Punctuation
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'eltype'      Name.Variable
' '           Text
"'CHARACTER"  Literal.String.Symbol
')'           Punctuation
' '           Text
"'STRING"     Literal.String.Symbol
')'           Punctuation
'\n                 ' Text
'('           Punctuation
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'eltype'      Name.Variable
' '           Text
"'BIT"        Literal.String.Symbol
')'           Punctuation
' '           Text
"'1"          Literal.String.Symbol
')'           Punctuation
'\n                 ' Text
'('           Punctuation
'('           Punctuation
'and'         Name.Builtin
' '           Text
'('           Punctuation
'consp'       Name.Builtin
' '           Text
'eltype'      Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'('           Punctuation
'first'       Name.Builtin
' '           Text
'eltype'      Name.Variable
')'           Punctuation
' '           Text
"'UNSIGNED-BYTE" Literal.String.Symbol
')'           Punctuation
')'           Punctuation
' '           Text
'('           Punctuation
'second'      Name.Builtin
' '           Text
'eltype'      Name.Variable
')'           Punctuation
')'           Punctuation
'\n                 ' Text
'('           Punctuation
'('           Punctuation
'eq'          Name.Builtin
' '           Text
'eltype'      Name.Variable
' '           Text
"'NIL"        Literal.String.Symbol
')'           Punctuation
' '           Text
"'0"          Literal.String.Symbol
')'           Punctuation
'\n                 ' Text
'('           Punctuation
't'           Name.Constant
' '           Text
'('           Punctuation
'error'       Name.Builtin
' '           Text
'('           Punctuation
'TEXT'        Name.Variable
' '           Text
'"~S is not up-to-date with ~S for element type ~S"' Literal.String
')'           Punctuation
'\n                           ' Text
"'type-of-sequence" Literal.String.Symbol
' '           Text
"'array-element-type" Literal.String.Symbol
' '           Text
'eltype'      Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n        '  Text
'('           Punctuation
't'           Name.Constant
' '           Text
"'NIL"        Literal.String.Symbol
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n'          Text

'('           Punctuation
'defun'       Name.Builtin
' '           Text
'sequence-type-union' Name.Variable
' '           Text
'('           Punctuation
't1'          Name.Variable
' '           Text
't2'          Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'cond'        Name.Builtin
' '           Text
'; Simple general rules.' Comment.Single
'\n        '  Text
'('           Punctuation
'('           Punctuation
'eql'         Name.Builtin
' '           Text
't1'          Name.Variable
' '           Text
't2'          Name.Variable
')'           Punctuation
' '           Text
't1'          Name.Variable
')'           Punctuation
'\n        '  Text
'('           Punctuation
'('           Punctuation
'eq'          Name.Builtin
' '           Text
't1'          Name.Variable
' '           Text
"'NIL"        Literal.String.Symbol
')'           Punctuation
' '           Text
't2'          Name.Variable
')'           Punctuation
'\n        '  Text
'('           Punctuation
'('           Punctuation
'eq'          Name.Builtin
' '           Text
't2'          Name.Variable
' '           Text
"'NIL"        Literal.String.Symbol
')'           Punctuation
' '           Text
't1'          Name.Variable
')'           Punctuation
'\n        '  Text
'; Now the union of two different types.' Comment.Single
'\n        '  Text
'('           Punctuation
'('           Punctuation
'or'          Name.Builtin
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
't1'          Name.Variable
' '           Text
"'SEQUENCE"   Literal.String.Symbol
')'           Punctuation
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
't2'          Name.Variable
' '           Text
"'SEQUENCE"   Literal.String.Symbol
')'           Punctuation
')'           Punctuation
' '           Text
"'SEQUENCE"   Literal.String.Symbol
')'           Punctuation
'\n        '  Text
'('           Punctuation
'('           Punctuation
'or'          Name.Builtin
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
't1'          Name.Variable
' '           Text
"'LIST"       Literal.String.Symbol
')'           Punctuation
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
't2'          Name.Variable
' '           Text
"'LIST"       Literal.String.Symbol
')'           Punctuation
')'           Punctuation
'\n         ' Text
'; union of LIST and a vector type' Comment.Single
'\n         ' Text
"'SEQUENCE"   Literal.String.Symbol
')'           Punctuation
'\n        '  Text
'('           Punctuation
'('           Punctuation
'or'          Name.Builtin
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
't1'          Name.Variable
' '           Text
"'VECTOR"     Literal.String.Symbol
')'           Punctuation
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
't2'          Name.Variable
' '           Text
"'VECTOR"     Literal.String.Symbol
')'           Punctuation
')'           Punctuation
' '           Text
"'VECTOR"     Literal.String.Symbol
')'           Punctuation
'\n        '  Text
'('           Punctuation
'('           Punctuation
'eql'         Name.Builtin
' '           Text
't1'          Name.Variable
' '           Text
'0'           Literal.Number.Integer
')'           Punctuation
' '           Text
't2'          Name.Variable
')'           Punctuation
'\n        '  Text
'('           Punctuation
'('           Punctuation
'eql'         Name.Builtin
' '           Text
't2'          Name.Variable
' '           Text
'0'           Literal.Number.Integer
')'           Punctuation
' '           Text
't1'          Name.Variable
')'           Punctuation
'\n        '  Text
'('           Punctuation
'('           Punctuation
'or'          Name.Builtin
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
't1'          Name.Variable
' '           Text
"'STRING"     Literal.String.Symbol
')'           Punctuation
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
't2'          Name.Variable
' '           Text
"'STRING"     Literal.String.Symbol
')'           Punctuation
')'           Punctuation
'\n         ' Text
'; union of STRING and an integer-vector type' Comment.Single
'\n         ' Text
"'VECTOR"     Literal.String.Symbol
')'           Punctuation
'\n        '  Text
'('           Punctuation
't'           Name.Constant
' '           Text
'('           Punctuation
'max'         Name.Builtin
' '           Text
't1'          Name.Variable
' '           Text
't2'          Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n'          Text

'('           Punctuation
'defun'       Name.Builtin
' '           Text
'sequence-type-intersection' Name.Variable
' '           Text
'('           Punctuation
't1'          Name.Variable
' '           Text
't2'          Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'cond'        Name.Builtin
' '           Text
'; Simple general rules.' Comment.Single
'\n        '  Text
'('           Punctuation
'('           Punctuation
'eql'         Name.Builtin
' '           Text
't1'          Name.Variable
' '           Text
't2'          Name.Variable
')'           Punctuation
' '           Text
't1'          Name.Variable
')'           Punctuation
'\n        '  Text
'('           Punctuation
'('           Punctuation
'or'          Name.Builtin
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
't1'          Name.Variable
' '           Text
"'NIL"        Literal.String.Symbol
')'           Punctuation
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
't2'          Name.Variable
' '           Text
"'NIL"        Literal.String.Symbol
')'           Punctuation
')'           Punctuation
' '           Text
"'NIL"        Literal.String.Symbol
')'           Punctuation
'\n        '  Text
'; Now the intersection of two different types.' Comment.Single
'\n        '  Text
'('           Punctuation
'('           Punctuation
'eq'          Name.Builtin
' '           Text
't1'          Name.Variable
' '           Text
"'SEQUENCE"   Literal.String.Symbol
')'           Punctuation
' '           Text
't2'          Name.Variable
')'           Punctuation
'\n        '  Text
'('           Punctuation
'('           Punctuation
'eq'          Name.Builtin
' '           Text
't2'          Name.Variable
' '           Text
"'SEQUENCE"   Literal.String.Symbol
')'           Punctuation
' '           Text
't1'          Name.Variable
')'           Punctuation
'\n        '  Text
'('           Punctuation
'('           Punctuation
'or'          Name.Builtin
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
't1'          Name.Variable
' '           Text
"'LIST"       Literal.String.Symbol
')'           Punctuation
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
't2'          Name.Variable
' '           Text
"'LIST"       Literal.String.Symbol
')'           Punctuation
')'           Punctuation
'\n         ' Text
'; intersection of LIST and a vector type' Comment.Single
'\n         ' Text
"'NIL"        Literal.String.Symbol
')'           Punctuation
'\n        '  Text
'('           Punctuation
'('           Punctuation
'eq'          Name.Builtin
' '           Text
't1'          Name.Variable
' '           Text
"'VECTOR"     Literal.String.Symbol
')'           Punctuation
' '           Text
't2'          Name.Variable
')'           Punctuation
'\n        '  Text
'('           Punctuation
'('           Punctuation
'eq'          Name.Builtin
' '           Text
't2'          Name.Variable
' '           Text
"'VECTOR"     Literal.String.Symbol
')'           Punctuation
' '           Text
't1'          Name.Variable
')'           Punctuation
'\n        '  Text
'('           Punctuation
'('           Punctuation
'or'          Name.Builtin
' '           Text
'('           Punctuation
'eql'         Name.Builtin
' '           Text
't1'          Name.Variable
' '           Text
'0'           Literal.Number.Integer
')'           Punctuation
' '           Text
'('           Punctuation
'eql'         Name.Builtin
' '           Text
't2'          Name.Variable
' '           Text
'0'           Literal.Number.Integer
')'           Punctuation
')'           Punctuation
' '           Text
"'0"          Literal.String.Symbol
')'           Punctuation
'\n        '  Text
'('           Punctuation
'('           Punctuation
'or'          Name.Builtin
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
't1'          Name.Variable
' '           Text
"'STRING"     Literal.String.Symbol
')'           Punctuation
' '           Text
'('           Punctuation
'eq'          Name.Builtin
' '           Text
't2'          Name.Variable
' '           Text
"'STRING"     Literal.String.Symbol
')'           Punctuation
')'           Punctuation
'\n         ' Text
'; intersection of STRING and an integer-vector type' Comment.Single
'\n         ' Text
"'0"          Literal.String.Symbol
')'           Punctuation
'\n        '  Text
'('           Punctuation
't'           Name.Constant
' '           Text
'('           Punctuation
'min'         Name.Builtin
' '           Text
't1'          Name.Variable
' '           Text
't2'          Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

';; ============================================================================' Comment.Single
'\n\n'        Text

'('           Punctuation
'defun'       Name.Builtin
' '           Text
'type-expand' Name.Variable
' '           Text
'('           Punctuation
'typespec'    Name.Variable
' '           Text
'&optional'   Keyword
' '           Text
'once-p'      Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'multiple-value-bind' Name.Builtin
' '           Text
'('           Punctuation
'expanded'    Name.Variable
' '           Text
'user-defined-p' Name.Variable
')'           Punctuation
'\n      '    Text
'('           Punctuation
'expand-deftype' Name.Variable
' '           Text
'typespec'    Name.Variable
' '           Text
'once-p'      Name.Variable
')'           Punctuation
'\n    '      Text
'('           Punctuation
'if'          Keyword
' '           Text
'user-defined-p' Name.Variable
' '           Text
'('           Punctuation
'values'      Name.Builtin
' '           Text
'expanded'    Name.Variable
' '           Text
'user-defined-p' Name.Variable
')'           Punctuation
'\n      '    Text
'('           Punctuation
'cond'        Name.Builtin
' '           Text
'('           Punctuation
'('           Punctuation
'symbolp'     Name.Builtin
' '           Text
'typespec'    Name.Variable
')'           Punctuation
'\n             ' Text
'('           Punctuation
'cond'        Name.Builtin
' '           Text
'('           Punctuation
'('           Punctuation
'or'          Name.Builtin
' '           Text
'('           Punctuation
'get'         Name.Builtin
' '           Text
'typespec'    Name.Variable
' '           Text
"'TYPE-SYMBOL" Literal.String.Symbol
')'           Punctuation
' '           Text
'('           Punctuation
'get'         Name.Builtin
' '           Text
'typespec'    Name.Variable
' '           Text
"'TYPE-LIST"  Literal.String.Symbol
')'           Punctuation
')'           Punctuation
'\n                    ' Text
'('           Punctuation
'values'      Name.Builtin
' '           Text
'typespec'    Name.Variable
' '           Text
'nil'         Name.Constant
')'           Punctuation
')'           Punctuation
'\n                   ' Text
'('           Punctuation
'('           Punctuation
'or'          Name.Builtin
' '           Text
'('           Punctuation
'get'         Name.Builtin
' '           Text
'typespec'    Name.Variable
' '           Text
"'DEFSTRUCT-DESCRIPTION" Literal.String.Symbol
')'           Punctuation
'\n                        ' Text
'('           Punctuation
'clos-class'  Name.Variable
' '           Text
'typespec'    Name.Variable
')'           Punctuation
')'           Punctuation
'\n                    ' Text
'('           Punctuation
'values'      Name.Builtin
' '           Text
'typespec'    Name.Variable
' '           Text
'nil'         Name.Constant
')'           Punctuation
')'           Punctuation
'\n                   ' Text
'('           Punctuation
't'           Name.Constant
' '           Text
'('           Punctuation
'typespec-error' Name.Variable
' '           Text
"'type-expand" Literal.String.Symbol
' '           Text
'typespec'    Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n            ' Text
'('           Punctuation
'('           Punctuation
'and'         Name.Builtin
' '           Text
'('           Punctuation
'consp'       Name.Builtin
' '           Text
'typespec'    Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'symbolp'     Name.Builtin
' '           Text
'('           Punctuation
'first'       Name.Builtin
' '           Text
'typespec'    Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n             ' Text
'('           Punctuation
'case'        Name.Builtin
' '           Text
'('           Punctuation
'first'       Name.Builtin
' '           Text
'typespec'    Name.Variable
')'           Punctuation
'\n               ' Text
'('           Punctuation
'('           Punctuation
'SATISFIES'   Name.Variable
' '           Text
'MEMBER'      Name.Variable
' '           Text
'EQL'         Name.Variable
' '           Text
'NOT'         Name.Variable
' '           Text
'AND'         Name.Variable
' '           Text
'OR'          Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'values'      Name.Builtin
' '           Text
'typespec'    Name.Variable
' '           Text
'nil'         Name.Constant
')'           Punctuation
')'           Punctuation
'\n               ' Text
'('           Punctuation
't'           Name.Constant
' '           Text
'('           Punctuation
'cond'        Name.Builtin
' '           Text
'('           Punctuation
'('           Punctuation
'get'         Name.Builtin
' '           Text
'('           Punctuation
'first'       Name.Builtin
' '           Text
'typespec'    Name.Variable
')'           Punctuation
' '           Text
"'TYPE-LIST"  Literal.String.Symbol
')'           Punctuation
'\n                         ' Text
'('           Punctuation
'values'      Name.Builtin
' '           Text
'typespec'    Name.Variable
' '           Text
'nil'         Name.Constant
')'           Punctuation
')'           Punctuation
'\n                        ' Text
'('           Punctuation
't'           Name.Constant
' '           Text
'('           Punctuation
'typespec-error' Name.Variable
' '           Text
"'type-expand" Literal.String.Symbol
' '           Text
'typespec'    Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n            ' Text
'('           Punctuation
'('           Punctuation
'clos::defined-class-p' Name.Variable
' '           Text
'typespec'    Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'values'      Name.Builtin
' '           Text
'typespec'    Name.Variable
' '           Text
'nil'         Name.Constant
')'           Punctuation
')'           Punctuation
'\n            ' Text
'('           Punctuation
't'           Name.Constant
' '           Text
'('           Punctuation
'typespec-error' Name.Variable
' '           Text
"'type-expand" Literal.String.Symbol
' '           Text
'typespec'    Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

';; ============================================================================' Comment.Single
'\n\n'        Text

'('           Punctuation
'unless'      Name.Builtin
' '           Text
'('           Punctuation
'clos::funcallable-instance-p' Name.Variable
' '           Text
"#'"          Name.Function
'clos::class-name' Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'fmakunbound' Name.Builtin
' '           Text
"'clos::class-name" Literal.String.Symbol
')'           Punctuation
')'           Punctuation
'\n\n\n'      Text

'('           Punctuation
'keywordp'    Name.Builtin
' '           Text
':junk'       Literal.String.Symbol
')'           Punctuation
'\n  '        Text
'T'           Name.Constant
'\n\n'        Text

'('           Punctuation
'keywordp'    Name.Builtin
' '           Text
'::junk'      Literal.String.Symbol
')'           Punctuation
'\n  '        Text
'T'           Name.Constant
'\n\n'        Text

'('           Punctuation
'symbol-name' Name.Builtin
' '           Text
'::junk'      Literal.String.Symbol
')'           Punctuation
'\n  '        Text
'"JUNK"'      Literal.String
'\n\n'        Text

'('           Punctuation
'symbol-name' Name.Builtin
' '           Text
':#junk'      Literal.String.Symbol
')'           Punctuation
'\n  '        Text
'"#JUNK"'     Literal.String
'\n\n'        Text

'('           Punctuation
'symbol-name' Name.Builtin
' '           Text
':#.junk'     Literal.String.Symbol
')'           Punctuation
'\n  '        Text
'"#.JUNK"'    Literal.String
'\n'          Text
