Replace uncatchable (break ..) by (error ..) to support automatic build testing

Author: metawilm

Diff for: compiler/compiler.lisp

@@ -622,7 +622,7 @@ an assigment statement. This changes at least the returned 'store' form.")
   (with-matching (ast ([module-stmt] ?suite))
     (multiple-value-bind (globals-ns globals-param)
         (typecase globals
-          (symbol-hash-table (break "never"))
+          (symbol-hash-table (error "never"))
           (eq-hash-table     (values (make-hash-table-ns
                                       :dict-form '%exec-globals-ns
                                       :scope :exec-globals
@@ -639,7 +639,7 @@ an assigment statement. This changes at least the returned 'store' form.")
                                       globals)))
         (multiple-value-bind (locals-ns locals-param)
             (typecase locals
-              (symbol-hash-table (break "never"))
+              (symbol-hash-table (error "never"))
               (eq-hash-table     (values (make-hash-table-w/excl-ns
                                           :dict-form '%exec-locals-ns
                                           :excluded-names locals-excluded-names
@@ -1467,7 +1467,7 @@ LOCALS shares share tail structure with input arg locals."
 (defun in-module-1 (&rest args)
   "Ensures the module exists"
   (unless *load-truename*
-    (break "*LOAD-TRUENAME* is not set?!"))
+    (error "*LOAD-TRUENAME* is not set?!"))
   (setf (gethash (derive-pathname *load-truename*) *load-file->module*)
     (apply #'ensure-module args))
   (unless *habitat*
@@ -1691,7 +1691,7 @@ LOCALS shares share tail structure with input arg locals."
   ;; ERROR does not support _classes_ as first condition argument; it
   ;; must be an _instance_ or condition type _name_.
   (cond ((stringp (deproxy exc))
-         (break "String exceptions are not supported (got: ~S)" (deproxy exc))
+         (error "String exceptions are not supported (got: ~S)" (deproxy exc))
          (py-raise '{TypeError}
                    "String exceptions are not supported (got: ~S)" (deproxy exc)))
 

Diff for: compiler/csetup.lisp

@@ -30,7 +30,7 @@
   (signal (make-condition 'raise-syntax-error-please
             :syntax-error-args syntax-error-args))
   ;; If no-one is listening (so not inside with-compiler-generated-syntax-errors)
-  (break "Uncaught SyntaxError: ~A" (apply #'format nil syntax-error-args)))
+  (error "Uncaught SyntaxError: ~A" (apply #'format nil syntax-error-args)))
 
 (defmacro with-compiler-generated-syntax-errors (() &body body)
   `(handler-bind ((raise-syntax-error-please

Diff for: compiler/generator.lisp

@@ -157,7 +157,7 @@
 
 (defmacro %cps-convert (ast k &key nil-allowed)
   (cond ((and (null ast) (not nil-allowed))
-         (break "%CPS-CONVERT of NIL (k=~S)" k))
+         (error "%CPS-CONVERT of NIL (k=~S)" k))
         ((null ast)
          `(funcall ,k ,ast))
         ((listp ast)

Diff for: compiler/namespace.lisp

@@ -241,7 +241,7 @@
       when (member (car subnames) (cdr subnames))
       collect (car subnames) into dups
       finally (when dups 
-                (break "Namespace ~A contains duplicate names: ~A" ns dups)))
+                (error "Namespace ~A contains duplicate names: ~A" ns dups)))
   `(let ,(ns.names ns)
      ;; Python has no way to declare variables unused, so suppress those warnings.
      (declare (ignorable ,@(ns.names ns)))
@@ -284,7 +284,7 @@
 (defmethod ns.expand-with ((ns let-w/locals-ns) body-form environment)
   (declare (ignore environment))
   (whereas ((non-local-lets (set-difference (ns.let-names ns) (ns.names ns))))
-    (break "Namespace ~A violates: ns.let-names <= ns.names: ~A." ns non-local-lets))
+    (error "Namespace ~A violates: ns.let-names <= ns.names: ~A." ns non-local-lets))
   `(let ,(ns.let-names ns)
      ;; Python has no way to declare variables unused, so suppress those warnings.
      (declare (ignorable ,@(ns.let-names ns)))
@@ -471,13 +471,13 @@
   (:method (environment)
            #+allegro (check-type environment sys::augmentable-environment)
            (get-module-namespace (or (get-pydecl :namespace environment)
-                                     (break "Cannot determine module namespace: ~
+                                     (error "Cannot determine module namespace: ~
                                              environment ~A has no namespace."
                                             environment))))
   (:method ((namespace namespace))
            (loop for ns = namespace then (ns.parent ns)
                while ns
                when (member (ns.scope ns) '(:module :exec-globals))
                return ns
-               finally (break "No global namespace found among parents, for: ~A."
+               finally (error "No global namespace found among parents, for: ~A."
                               namespace))))

Diff for: contrib/executable.lisp

@@ -12,7 +12,7 @@
 (defun command-line-args ()
   ;; List of strings, first item = executable path
    #+sbcl cl-user::*POSIX-ARGV*
-   #-sbcl (break "COMMAND-LINE-ARGS undefined in this implementation"))
+   #-sbcl (error "COMMAND-LINE-ARGS undefined in this implementation"))
 
 #+cmu
 (defun build-executable (&rest args)

Diff for: contrib/lispy.lisp

@@ -82,7 +82,7 @@ Ends by signalling one of: %PARSE.FINISHED, %PARSE.SWITCH-LANGUAGE, %PARSE.UNEXP
     (when (>= *debug-recursion-count* 10)
       (check-type *lisp-standard-readtable* readtable)
       (setf *readtable* *lisp-standard-readtable*)
-      (break "READ-LANGUAGE-FORMS: Too much recursion; *readtable* reset"))
+      (error "READ-LANGUAGE-FORMS: Too much recursion; *readtable* reset"))
     (call-next-method)))
 
 (defvar *lisp-readtable*)
@@ -165,7 +165,7 @@ Ends by signalling one of: %PARSE.FINISHED, %PARSE.SWITCH-LANGUAGE, %PARSE.UNEXP
       (when *lispy-debug*
         (format t "~&READ-LANGUAGE-FORMS :LISP says: reader-error: ~S" c))
       (error '%parse.switch-language :language :lisp :start-ix start-ix :reason c)))
-  (break "never"))
+  (error "never"))
 
 (defun read-mixed-source-string (string &key lisp-readtable interactive-p)
   "Returns a list of Python and Lisp source elements, like: ((:lang form) (:lang2 form2) ..)
@@ -247,7 +247,7 @@ If INTERACTIVE-P then the last item is possibly (:lang :incomplete)"
                                                   (declare (ignore c))
                                                   (finish-parsing))))
                   (read-language-forms language string start-ix :lisp-readtable lisp-readtable)
-                  (break "never"))))))))))
+                  (error "never"))))))))))
 
 (defgeneric read-toplevel-forms (thing &key lisp-readtable))
 
@@ -333,7 +333,7 @@ STREAM can be an interactive (REPL) stream"
                                        (format t "~& Input EOF reached~%")
                                        (setf eof-reached t))
                                      (when (and interactive-p (not (input-ends-with-newline input-string)))
-                                       (break "READ-CHAR on interactive steam failed unexpectedly: last char was ~S but expected ~S."
+                                       (error "READ-CHAR on interactive steam failed unexpectedly: last char was ~S but expected ~S."
                                               (when (plusp (length input-string))
                                                 (aref input-string (1- (length input-string))))
                                               #\Newline))))
@@ -349,7 +349,7 @@ STREAM can be an interactive (REPL) stream"
                          ;; Should hold only during debugging of interactive parsing rules, e.g. by passing
                          ;; STRING-INPUT-STREAM but forcing :INTERACTIVE-P to T
                          (unless *lispy-debug*
-                           (break "Unexpected: parsed-incomplete=~A interactive-p=~A eof-reached=~A"
+                           (error "Unexpected: parsed-incomplete=~A interactive-p=~A eof-reached=~A"
                                   parsed-incomplete interactive-p eof-reached)))
                        (cond (parsed-incomplete
                               (if (and interactive-p (not eof-reached))

Diff for: contrib/source.lisp

@@ -14,7 +14,7 @@
 
 #-clpython-source-level-debugging
 (eval-when (:compile-toplevel :load-toplevel :execute)
-  (break "This module is for Allegro 8.2+"))
+  (error "This module is for Allegro 8.2+"))
 
 
 ;;; The unit of source information is the SUBFORM, which links one Python AST node
@@ -170,7 +170,7 @@ Error when no table found."
                   (eq (first src) 'defun)
                   (eq (second src) module-func-name))
         do (or (find-it src)
-               (break "Found DEFUN record but not :PYTHON-SOURCE-LOCATION-TABLE in src ~S for func ~S"
+               (error "Found DEFUN record but not :PYTHON-SOURCE-LOCATION-TABLE in src ~S for func ~S"
                       src module-func-name))
         finally (error "No Python source information found for module-function ~S." module-func-name))))
 
@@ -277,7 +277,7 @@ The :PYTHON records are thus a subset of the :LISP records."
                     (when (and (listp src)
                                (eq (car src) 'defun))
                       (return-from find (second src))))
-                  (break "no func for ix ~A" ix)))
+                  (error "no func for ix ~A" ix)))
          (sum-asm-ranges (vec start end)
            (loop with result
                for ix from start to end

Diff for: lib/_random.lisp

@@ -31,7 +31,7 @@ import _random
   (check-type seed integer)
   ;; http://www.franz.com/support/documentation/8.1/doc/implementation.htm#cl-random-2
   #+allegro (make-random-state t seed)
-  #-allegro (break "Don't know how to create random-state with given seed ~
+  #-allegro (error "Don't know how to create random-state with given seed ~
                     in this Lisp implementation."))
 
 (def-py-method |Random.seed| (x &optional n)

Diff for: lib/_socket.lisp

@@ -17,20 +17,20 @@
 
 (defun |gethostname| ()
   #+allegro (excl.osi:gethostname)
-  #-allegro (break "todo"))
+  #-allegro (cl:error "todo"))
 
 (defun |gethostbyaddr| (address)
   (check-type address string)
   (let* ((hostname #+allegro (if (socket:dotted-address-p address)
                                  (excl.osi:gethostbyaddr address)
                                (excl.osi:gethostbyname address))
-                   #-allegro (break "todo"))
+                   #-allegro (cl:error "todo"))
          (alias-list (clpython:make-py-list-from-list ())) ;; todo
          (ip-addr-list (clpython:make-py-list-from-list (list #+allegro (socket:ipaddr-to-dotted (socket:lookup-hostname hostname))
-                                                     #-allegro (break "todo")))))
+                                                     #-allegro (cl:error "todo")))))
     (make-tuple-from-list (list hostname alias-list ip-addr-list)))
 
-  #-allegro (break "todo"))
+  #-allegro (cl:error "todo"))
 
 
 ;; Socket class
@@ -45,43 +45,43 @@
   "Socket")
 
 (def-py-method |socket.close| (x)
-  (break "todo"))
+  (cl:error "todo"))
 
 (def-py-method |socket.accept| (x)
   #+allegro (let* ((stream (socket:accept-connection (socket.socket x) :wait t))
                    (remote-address (format nil "~A:~A" (socket:lookup-hostname (socket:remote-host stream)) (socket:remote-port stream))))
               (make-tuple-from-list (list (make-instance '|socket| :stream stream)
                                           remote-address)))
-  #-allegro (break "todo"))
+  #-allegro (cl:error "todo"))
 
 (def-py-method |socket.bind| (x address)
   (setf (socket.address x) address))
 
 (def-py-method |socket.connect| (x address)
-  (break "todo"))
+  (cl:error "todo"))
 
 (def-py-method |socket.connect_ex| (x address)
-  (break "todo"))
+  (cl:error "todo"))
 
 (def-py-method |socket.fileno| (x)
-  (break "todo"))
+  (cl:error "todo"))
 
 (def-py-method |socket.getpeername| (x)
-  (break "todo"))
+  (cl:error "todo"))
 
 (def-py-method |socket.getsockname| (x)
   (whereas ((socket (socket.socket x)))
     (let ((hostname #+allegro (socket:ipaddr-to-dotted (socket:local-host socket))
-                    #-allegro (break "todo"))
+                    #-allegro (error "todo"))
           (port #+allegro (socket:local-port socket)
-                #-allegro (break "todo")))
+                #-allegro (cl:error "todo")))
       (return-from |socket.getsockname|
         (make-tuple-from-list (list hostname port)))))
    ;; default same as CPython does
   (make-tuple-from-list (list "0.0.0.0" 0)))
 
 (def-py-method |socket.getsockopt| (x opt-name &optional buflen)
-  (break "todo"))
+  (cl:error "todo"))
 
 (defparameter *all-sockets* ())
 
@@ -92,51 +92,51 @@
                  (integerp (second address)))
         (address) "Cannot socket.listen() without an address: ~S." address)
     (let ((socket #+allegro (socket:make-socket :connect :passive :local-port (+ (second address) (random 100))) ;; XXX random
-                  #-allegro (break "todo")))
+                  #-allegro (cl:error "todo")))
       (push socket *all-sockets*)
       (setf (socket.socket x) socket))))
 
 (def-py-method |socket.makefile| (x &optional mode bufsize)
-  (break "todo"))
+  (cl:error "todo"))
 
 (def-py-method |socket.recv| (x bufsize &optional flags)
   (unless (socket.stream x)
-    (break "Can't socket.recv(): no socket stream."))
+    (cl:error "Can't socket.recv(): no socket stream."))
   ;; todo: multiple bytes
   (read-byte (socket.stream x)))
 
 (def-py-method |socket.recvfrom| (x bufsize &optional flags)
-  (break "todo"))
+  (cl:error "todo"))
 
 (def-py-method |socket.recvfrom_into| (x buffer &optional nbytes flags)
-  (break "todo"))
+  (cl:error "todo"))
 
 (def-py-method |socket.recv_into| (x buffer &optional nbytes flags)
-  (break "todo"))
+  (cl:error "todo"))
 
 (def-py-method |socket.send| (x string &optional flags)
-  (break "todo"))
+  (cl:error "todo"))
 
 (def-py-method |socket.sendall| (x string &optional flags)
-  (break "todo"))
+  (cl:error "todo"))
 
 (def-py-method |socket.sendto| (x string &optional flags address)
-  (break "todo"))
+  (cl:error "todo"))
 
 (def-py-method |socket.setblocking| (x flag)
-  (break "todo"))
+  (cl:error "todo"))
 
 (def-py-method |socket.settimeout| (x value)
-  (break "todo"))
+  (cl:error "todo"))
 
 (def-py-method |socket.gettimeout| (x)
-  (break "todo"))
+  (cl:error "todo"))
 
 (def-py-method |socket.setsockopt| (x level optname value)
   (warn "socket.setsockopt(..) ignored"))
 
 (def-py-method |socket.shutdown| (x how)
-  (break "todo"))
+  (cl:error "todo"))
 
 
 ;;; Constants

Diff for: lib/imp.lisp

@@ -15,11 +15,11 @@
 
 (defun |find_module| (name path)
   (declare (ignore name path))
-  (break "Todo: imp.find_module()"))
+  (error "Todo: imp.find_module()"))
 
 (defun |load_module| (&rest args)
   (declare (ignore args))
-  (break "Todo: imp.load_module()"))
+  (error "Todo: imp.load_module()"))
 
 ;; imp.PY_SOURCE
 ;; imp.PY_COMPILED

Diff for: lib/operator.lisp

@@ -24,13 +24,13 @@
     (with-standard-io-syntax
       (let ((name (format nil "~A-~A" '#:py op)))
         (or (find-symbol name :clpython)
-            (break "No such symbol in pkg clpython: ~A" name)))))
+            (error "No such symbol in pkg clpython: ~A" name)))))
 
   (defun sym->iop (op)
     (with-standard-io-syntax
       (let ((name (format nil "~A-~A=" '#:py op)))
         (or (find-symbol name :clpython)
-            (break "No such symbol in pkg clpython: ~A" name)))))
+            (error "No such symbol in pkg clpython: ~A" name)))))
 
   (defmacro def-magic-twins (name params &body body)
     `(progn (defun ,name ,params ,@body)

Diff for: lib/thread.lisp

@@ -49,7 +49,7 @@
           (:process-lock (values 'allegro-process-lock
                                  (list :process-lock (mp:make-process-lock :name (format nil "lock ~A" id))))))
       (apply #'make-instance type :id id :wait-msg wait-msg args))
-    #-allegro (break "todo")))
+    #-allegro (error "todo")))
 
 (def-py-method |lock.acquire| (x &optional (waitflag 1))
   (let ((wait (ecase waitflag

Diff for: parser/lexer.lisp

@@ -943,4 +943,4 @@ Returns NEWLINE-P, NEW-INDENT, EOF-P."
     (if clpython:*exceptions-loaded*
 	(funcall 'clpython:py-raise '{UnexpectedEofError} msg)
       (raise-syntax-error msg)))
-  (break "unreachable"))
+  (error "unreachable"))

Diff for: parser/pprint.lisp

@@ -240,7 +240,7 @@ output to a string does not start with a newline."
 			    (items-s (mapcar (lambda (x) (format nil "~A" x)) items)))
 
 			(with-standard-io-syntax
-			  (break "body-s: ~S item-s: ~S" body-s items-s))
+			  (warn "body-s: ~S item-s: ~S" body-s items-s))
 
 			;; standard syntax, otherwise strings are
 			;; printed with Python string escapes

Diff for: parser/walk.lisp

@@ -76,7 +76,7 @@ CLASSDEF, FUNCDEF or LAMBDA."
              (when *walk-debug*
                (warn "w> ~A" ast))
              (unless ast
-               (break "Attempt to WALK-PY-AST into an AST that is NIL"))
+               (error "Attempt to WALK-PY-AST into an AST that is NIL"))
 
              ;; Call user function on whole form. The returned values
 	     ;; control how we proceed.
@@ -253,7 +253,7 @@ CLASSDEF, FUNCDEF or LAMBDA."
 
 (defun ast-recurse-fun (f ast &key value target)
   (when (null ast) 
-    (break "AST-RECURSE-FUN got NIL"))
+    (error "AST-RECURSE-FUN got NIL"))
 
   (unless (consp ast)
     (return-from ast-recurse-fun ast))