diff options
Diffstat (limited to 'tests/lexers/common-lisp/example.txt')
| -rw-r--r-- | tests/lexers/common-lisp/example.txt | 12550 |
1 files changed, 12550 insertions, 0 deletions
diff --git a/tests/lexers/common-lisp/example.txt b/tests/lexers/common-lisp/example.txt new file mode 100644 index 00000000..ef52b5ce --- /dev/null +++ b/tests/lexers/common-lisp/example.txt @@ -0,0 +1,12550 @@ +---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 |