X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=tests%2Fcompiler-1.impure-cload.lisp;h=4d5b1047dc6493cda50238a59dd070e3213e314c;hb=caf8bb05a82659e688c125b418783bc8a3bd2be8;hp=5a9c05b8a5babfe0426e77e05233a78139ae526d;hpb=6c765578c8dc4bcc7798e37c9918715f198b30da;p=sbcl.git diff --git a/tests/compiler-1.impure-cload.lisp b/tests/compiler-1.impure-cload.lisp index 5a9c05b..4d5b104 100644 --- a/tests/compiler-1.impure-cload.lisp +++ b/tests/compiler-1.impure-cload.lisp @@ -1,4 +1,4 @@ -;;;; miscellaneous compiler tests with side-effects (e.g. DEFUN +;;;; miscellaneous compiler tests with side effects (e.g. DEFUN ;;;; changing FDEFINITIONs and globaldb stuff) ;;;; This software is part of the SBCL system. See the README file for @@ -14,6 +14,10 @@ (cl:in-package :cl-user) +(eval-when (:compile-toplevel :load-toplevel :execute) + (load "assertoid") + (use-package "ASSERTOID")) + (declaim (optimize (debug 3) (speed 2) (space 1))) ;;; Until version 0.6.9 or so, SBCL's version of Python couldn't do @@ -43,28 +47,149 @@ (+ i f))) (assert (= (exercise-valuesify 1.25) 2.25)) -;;; Don Geddis reported this test case 25 December 1999 on a CMU CL -;;; mailing list: dumping circular lists caused an infinite loop. -;;; Douglas Crosher reported a patch 27 Dec 1999. The patch was tested -;;; on SBCL by Martin Atzmueller 2 Nov 2000, and merged in -;;; sbcl-0.6.8.11. -(defun q-dg1999-1 () (dolist (x '#1=("A" "B" . #1#)) x)) -(defun q-dg1999-2 () (dolist (x '#1=("C" "D" . #1#)) x)) -(defun q-dg1999-3 () (dolist (x '#1=("E" "F" . #1#)) x)) -(defun q-dg1999-4 () (dolist (x '#1=("C" "D" . #1#)) x)) -(defun useful-dg1999 (keys) - (declare (type list keys)) - (loop - for c in '#1=("Red" "Blue" . #1#) - for key in keys )) - ;;; An early version (sbcl-0.6.11.33) of code to check FTYPEs from DEFUN ;;; against DECLAIMed FTYPEs blew up when an FTYPE was DECLAIMed ;;; to be pure FUNCTION, because the internal representation of ;;; FUNCTION itself (as opposed to subtypes of FUNCTION, such as -;;; (FUNCTION () T)) is a BUILT-IN-CLASS object, not a FUNCTION-TYPE +;;; (FUNCTION () T)) is a BUILT-IN-CLASS object, not a FUN-TYPE ;;; object. (declaim (ftype function i-am-just-a-function)) (defun i-am-just-a-function (x y) (+ x y 1)) +;;; Stig E Sandoe reported in cclan-Bugs-431263 that SBCL couldn't +;;; compile this. sbcl-0.6.12.26 died in CIRCULAR-LIST-P with "The +;;; value \"EST\" is not of type LIST." Dan Barlow fixed it. +(defvar +time-zones+ + '((5 "EDT" . "EST") (6 "CDT" . "CST") (7 "MDT" . +"MST") (8 "PDT" . "PST") + (0 "GMT" . "GDT") (-2 "MET" . "MET DST")) + "*The string representations of the time zones.") + +;;; The old CMU CL Python compiler assumed that it was safe to infer +;;; function types (including return types) from function definitions +;;; and then use them to optimize code later. This is of course bad +;;; when functions are redefined. The problem was fixed in +;;; sbcl-0.6.12.57. +(defun foo (x) + (if (plusp x) + 1.0 + 0)) +(defun bar (x) + (typecase (foo x) + (fixnum :fixnum) + (real :real) + (string :string) + (t :t))) +(assert (eql (bar 11) :real)) +(assert (eql (bar -11) :fixnum)) +(setf (symbol-function 'foo) #'identity) +(assert (eql (bar 11) :fixnum)) +(assert (eql (bar -11.0) :real)) +(assert (eql (bar "this is a test") :string)) +(assert (eql (bar (make-hash-table)) :t)) + +;;; bug reported by Brian Spilsbury sbcl-devel 2001-09-30, fixed by +;;; Alexey Dejneka patch sbcl-devel 2001-10-02 +(defun pixarray-element-size (pixarray) + (let ((eltype (array-element-type pixarray))) + (cond ((eq eltype 'bit) 1) + ((and (listp eltype) + (eq (first eltype) 'unsigned-byte)) + (second eltype)) + (t + (error "Invalid pixarray: ~S." pixarray))))) +(assert (eql 1 (pixarray-element-size #*110))) + +;;; bug 31 turned out to be a manifestation of non-ANSI array type +;;; handling, fixed by CSR in sbcl-0.7.3.8. +(defun array-element-type-handling (x) + (declare (type (vector cons) x)) + (when (consp (aref x 0)) + (aref x 0))) +(assert (eq (array-element-type-handling + (make-array 3 :element-type t :initial-element 0)) + nil)) + +;;; bug 220: type check inserted after all arguments in MV-CALL caused +;;; failure of stack analysis +(defun bug220-helper () + 13) +(assert (equal (multiple-value-call #'list + (the integer (bug220-helper)) + nil) + '(13 nil))) + +;;; bug 221: sbcl 0.7.9.13 failed to compile the following function +(declaim (ftype (function (fixnum) (values package boolean)) bug221-f1)) +(declaim (ftype (function (t) (values package boolean)) bug221-f2)) +(defun bug221 (b x) + (funcall (if b #'bug221-f1 #'bug221-f2) x)) + +;;; bug 166: compiler failure +(defstruct bug166s) +(defmethod permanentize ((uustk bug166s)) + (flet ((frob (hash-table test-for-deletion) + ) + (obj-entry.stale? (oe) + (destructuring-bind (key . datum) oe + (declare (type simple-vector key)) + (deny0 (void? datum)) + (some #'stale? key)))) + (declare (inline frob obj-entry.stale?)) + (frob (uustk.args-hash->obj-alist uustk) + #'obj-entry.stale?) + (frob (uustk.hash->memoized-objs-list uustk) + #'objs.stale?)) + (call-next-method)) + +;;; bugs 115, 226: compiler failure in lifetime analysis +(defun bug115-1 () + (declare (optimize (speed 2) (debug 3))) + (flet ((m1 () + (unwind-protect nil))) + (if (catch nil) + (m1) + (m1)))) + +(defun bug115-2 () + (declare (optimize (speed 2) (debug 3))) + (flet ((m1 () + (bar (if (foo) 1 2)) + (let ((x (foo))) + (bar x (list x))))) + (if (catch nil) + (m1) + (m1)))) + +(defun bug226 () + (declare (optimize (speed 0) (safety 3) (debug 3))) + (flet ((safe-format (stream string &rest r) + (unless (ignore-errors (progn + (apply #'format stream string r) + t)) + (format stream "~&foo ~S" string)))) + (cond + ((eq my-result :ERROR) + (cond + ((ignore-errors (typep condition result)) + (safe-format t "~&bar ~S" result)) + (t + (safe-format t "~&baz ~S (~A) ~S" condition condition result))))))) + +;;; bug 231: SETQ did not check the type of the variable being set +(defun bug231-1 (x) + (declare (optimize safety) (type (integer 0 8) x)) + (incf x)) +(assert (raises-error? (bug231-1 8) type-error)) + +(defun bug231-2 (x) + (declare (optimize safety) (type (integer 0 8) x)) + (list (lambda (y) (setq x y)) + (lambda () x))) +(destructuring-bind (set get) (bug231-2 0) + (funcall set 8) + (assert (eql (funcall get) 8)) + (assert (raises-error? (funcall set 9) type-error)) + (assert (eql (funcall get) 8))) + (sb-ext:quit :unix-status 104) ; success