Changeset 13491 for trunk/abcl/src/org


Ignore:
Timestamp:
08/14/11 10:18:25 (10 years ago)
Author:
ehuelsmann
Message:

Start cutting up the huge CASE statement that makes up our file compilation,
in favor of using dispatch tables just like other parts of our compilation
process (precompile, pass1, pass2).

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/abcl/src/org/armedbear/lisp/compile-file.lisp

    r13465 r13491  
    9595  t)
    9696
    97 (declaim (ftype (function (t) t) process-defconstant))
    98 (defun process-defconstant (form)
    99   ;; "If a DEFCONSTANT form appears as a top level form, the compiler
    100   ;; must recognize that [the] name names a constant variable. An
    101   ;; implementation may choose to evaluate the value-form at compile
    102   ;; time, load time, or both. Therefore, users must ensure that the
    103   ;; initial-value can be evaluated at compile time (regardless of
    104   ;; whether or not references to name appear in the file) and that
    105   ;; it always evaluates to the same value."
    106   (eval form)
    107   (output-form form))
    108 
    10997(declaim (ftype (function (t) t) note-toplevel-form))
    11098(defun note-toplevel-form (form)
     
    118106    (terpri)))
    119107
     108
     109(declaim (ftype (function (t t t) t) process-toplevel-defconstant))
     110(defun process-toplevel-defconstant (form stream compile-time-too)
     111  (declare (ignore stream compile-time-too))
     112  ;; "If a DEFCONSTANT form appears as a top level form, the compiler
     113  ;; must recognize that [the] name names a constant variable. An
     114  ;; implementation may choose to evaluate the value-form at compile
     115  ;; time, load time, or both. Therefore, users must ensure that the
     116  ;; initial-value can be evaluated at compile time (regardless of
     117  ;; whether or not references to name appear in the file) and that
     118  ;; it always evaluates to the same value."
     119  (note-toplevel-form form)
     120  (eval form)
     121  form)
     122
     123(declaim (ftype (function (t t t) t) process-toplevel-defvar/defparameter))
     124(defun process-toplevel-defvar/defparameter (form stream compile-time-too)
     125  (declare (ignore stream))
     126  (note-toplevel-form form)
     127  (if compile-time-too
     128      (eval form)
     129      ;; "If a DEFVAR or DEFPARAMETER form appears as a top level form,
     130      ;; the compiler must recognize that the name has been proclaimed
     131      ;; special. However, it must neither evaluate the initial-value
     132      ;; form nor assign the dynamic variable named NAME at compile
     133      ;; time."
     134      (let ((name (second form)))
     135        (%defvar name)))
     136  form)
     137
     138(declaim (ftype (function (t t t) t) process-toplevel-defpackage/in-package))
     139(defun process-toplevel-defpackage/in-package (form stream compile-time-too)
     140  (declare (ignore stream compile-time-too))
     141  (note-toplevel-form form)
     142  (setf form
     143        (precompiler:precompile-form form nil *compile-file-environment*))
     144  (eval form)
     145  ;; Force package prefix to be used when dumping form.
     146  (let ((*package* +keyword-package+))
     147    (output-form form))
     148  nil)
     149
     150(declaim (ftype (function (t t t) t) process-toplevel-declare))
     151(defun process-toplevel-declare (form stream compile-time-too)
     152  (declare (ignore stream compile-time-too))
     153  (compiler-style-warn "Misplaced declaration: ~S" form)
     154  nil)
     155
     156(declaim (ftype (function (t t t) t) process-toplevel-progn))
     157(defun process-toplevel-progn (form stream compile-time-too)
     158  (process-progn (cdr form) stream compile-time-too)
     159  nil)
     160
     161(declaim (ftype (function (t t t) t) process-toplevel-deftype))
     162(defun process-toplevel-deftype (form stream compile-time-too)
     163  (declare (ignore stream compile-time-too))
     164  (note-toplevel-form form)
     165  (eval form)
     166  form)
     167
     168(declaim (ftype (function (t t t) t) process-toplevel-eval-when))
     169(defun process-toplevel-eval-when (form stream compile-time-too)
     170  (multiple-value-bind (ct lt e)
     171      (parse-eval-when-situations (cadr form))
     172    (let ((new-compile-time-too (or ct (and compile-time-too e)))
     173          (body (cddr form)))
     174      (if lt
     175          (process-progn body stream new-compile-time-too)
     176          (when new-compile-time-too
     177            (eval `(progn ,@body))))))
     178  nil)
     179
     180
     181(declaim (ftype (function (t t t) t) process-toplevel-defmethod/defgeneric))
     182(defun process-toplevel-defmethod/defgeneric (form stream compile-time-too)
     183  (note-toplevel-form form)
     184  (note-name-defined (second form))
     185  (let ((*compile-print* nil))
     186    (process-toplevel-form (macroexpand-1 form *compile-file-environment*)
     187                           stream compile-time-too))
     188  nil)
     189
     190(declaim (ftype (function (t t t) t) process-toplevel-locally))
     191(defun process-toplevel-locally (form stream compile-time-too)
     192  (jvm::with-saved-compiler-policy
     193      (multiple-value-bind (forms decls)
     194          (parse-body (cdr form) nil)
     195        (process-optimization-declarations decls)
     196        (let* ((jvm::*visible-variables* jvm::*visible-variables*)
     197               (specials (jvm::process-declarations-for-vars (cdr form)
     198                                                             nil nil)))
     199          (dolist (special specials)
     200            (push special jvm::*visible-variables*))
     201          (process-progn forms stream compile-time-too))))
     202  nil)
     203
     204(declaim (ftype (function (t t t) t) process-toplevel-defmacro))
     205(defun process-toplevel-defmacro (form stream compile-time-too)
     206  (declare (ignore stream compile-time-too))
     207  (note-toplevel-form form)
     208  (let ((name (second form)))
     209    (eval form)
     210    (let* ((expr (function-lambda-expression (macro-function name)))
     211           (saved-class-number *class-number*)
     212           (classfile (next-classfile-name)))
     213      (with-open-file
     214          (f classfile
     215             :direction :output
     216             :element-type '(unsigned-byte 8)
     217             :if-exists :supersede)
     218        (ignore-errors
     219          (jvm:compile-defun nil expr *compile-file-environment*
     220                             classfile f nil)))
     221      (when (null (verify-load classfile))
     222        ;; FIXME error or warning
     223        (format *error-output* "; Unable to compile macro ~A~%" name)
     224        (return-from process-toplevel-defmacro form))
     225
     226      (if (special-operator-p name)
     227          `(put ',name 'macroexpand-macro
     228                (make-macro ',name
     229                            (sys::get-fasl-function *fasl-loader* ,saved-class-number)))
     230          `(fset ',name
     231                 (make-macro ',name
     232                             (sys::get-fasl-function *fasl-loader* ,saved-class-number))
     233                 ,*source-position*
     234                 ',(third form))))))
     235
     236(declaim (ftype (function (t t t) t) process-toplevel-defun))
     237(defun process-toplevel-defun (form stream compile-time-too)
     238  (declare (ignore stream))
     239  (note-toplevel-form form)
     240  (let* ((name (second form))
     241         (block-name (fdefinition-block-name name))
     242         (lambda-list (third form))
     243         (body (nthcdr 3 form)))
     244    (jvm::with-saved-compiler-policy
     245        (multiple-value-bind (body decls doc)
     246            (parse-body body)
     247          (let* ((expr `(lambda ,lambda-list
     248                          ,@decls (block ,block-name ,@body)))
     249                 (saved-class-number *class-number*)
     250                 (classfile (next-classfile-name))
     251                 (internal-compiler-errors nil)
     252                 (result (with-open-file
     253                             (f classfile
     254                                :direction :output
     255                                :element-type '(unsigned-byte 8)
     256                                :if-exists :supersede)
     257                           (handler-bind
     258                               ((internal-compiler-error
     259                                 #'(lambda (e)
     260                                     (push e internal-compiler-errors)
     261                                     (continue))))
     262                             (report-error
     263                              (jvm:compile-defun name expr *compile-file-environment*
     264                                                 classfile f nil)))))
     265                 (compiled-function (if (not internal-compiler-errors)
     266                                        (verify-load classfile)
     267                                        nil)))
     268            (declare (ignore result))
     269            (cond
     270              ((and (not internal-compiler-errors)
     271                    compiled-function)
     272               (when compile-time-too
     273                 (eval form))
     274               (setf form
     275                     `(fset ',name
     276                            (sys::get-fasl-function *fasl-loader*
     277                                                    ,saved-class-number)
     278                            ,*source-position*
     279                            ',lambda-list
     280                            ,doc)))
     281              (t
     282               (compiler-warn "Unable to compile function ~A.  Using interpreted form instead.~%" name)
     283               (when internal-compiler-errors
     284                 (dolist (e internal-compiler-errors)
     285                   (format *error-output*
     286                           "; ~A~%" e)))
     287               (let ((precompiled-function
     288                      (precompiler:precompile-form expr nil
     289                                                   *compile-file-environment*)))
     290                 (setf form
     291                       `(fset ',name
     292                              ,precompiled-function
     293                              ,*source-position*
     294                              ',lambda-list
     295                              ,doc)))
     296               (when compile-time-too
     297                 (eval form)))))
     298          (when (and (symbolp name) (eq (get name '%inline) 'INLINE))
     299            ;; FIXME Need to support SETF functions too!
     300            (setf (inline-expansion name)
     301                  (jvm::generate-inline-expansion block-name
     302                                                  lambda-list body))
     303            (output-form `(setf (inline-expansion ',name)
     304                                ',(inline-expansion name))))))
     305    (push name jvm::*functions-defined-in-current-file*)
     306    (note-name-defined name)
     307    ;; If NAME is not fbound, provide a dummy definition so that
     308    ;; getSymbolFunctionOrDie() will succeed when we try to verify that
     309    ;; functions defined later in the same file can be loaded correctly.
     310    (unless (fboundp name)
     311      (setf (fdefinition name) #'dummy)
     312      (push name *fbound-names*)))
     313  form)
     314
     315
     316;; toplevel handlers
     317;;   each toplevel handler takes a form and stream as input
     318
     319(defun install-toplevel-handler (symbol handler)
     320  (setf (get symbol 'toplevel-handler) handler))
     321
     322(dolist (pair '(
     323                (DECLARE process-toplevel-declare)
     324                (DEFCONSTANT process-toplevel-defconstant)
     325                (DEFGENERIC process-toplevel-defmethod/defgeneric)
     326                (DEFMACRO process-toplevel-defmacro)
     327                (DEFMETHOD process-toplevel-defmethod/defgeneric)
     328                (DEFPACKAGE process-toplevel-defpackage/in-package)
     329                (DEFPARAMETER process-toplevel-defvar/defparameter)
     330                (DEFTYPE process-toplevel-deftype)
     331                (DEFUN process-toplevel-defun)
     332                (DEFVAR process-toplevel-defvar/defparameter)
     333                (EVAL-WHEN process-toplevel-eval-when)
     334                (IN-PACKAGE process-toplevel-defpackage/in-package)
     335                (LOCALLY process-toplevel-locally)
     336                (MACROLET process-toplevel-macrolet)
     337                (PROGN process-toplevel-progn)
     338))
     339  (install-toplevel-handler (car pair) (cadr pair)))
     340
    120341(declaim (ftype (function (t stream t) t) process-toplevel-form))
    121342(defun process-toplevel-form (form stream compile-time-too)
     
    124345        (eval form))
    125346    (progn
    126       (let ((operator (%car form)))
    127         (case operator
    128           (MACROLET
    129            (process-toplevel-macrolet form stream compile-time-too)
     347      (let* ((operator (%car form))
     348             (handler (get operator 'toplevel-handler)))
     349        (when handler
     350          (let ((out-form (funcall handler form stream compile-time-too)))
     351            (when out-form
     352              (output-form out-form)))
     353          (return-from process-toplevel-form))
     354        (when (and (symbolp operator)
     355                   (macro-function operator *compile-file-environment*))
     356          (note-toplevel-form form)
     357          ;; Note that we want MACROEXPAND-1 and not MACROEXPAND here, in
     358          ;; case the form being expanded expands into something that needs
     359          ;; special handling by PROCESS-TOPLEVEL-FORM (e.g. DEFMACRO).
     360          (let ((*compile-print* nil))
     361            (process-toplevel-form (macroexpand-1 form *compile-file-environment*)
     362                                   stream compile-time-too))
     363          (return-from process-toplevel-form))
     364
     365        (cond
     366          ((eq operator 'QUOTE)
     367;;;                      (setf form (precompiler:precompile-form form nil
     368;;;                                                  *compile-file-environment*))
     369           (when compile-time-too
     370             (eval form))
    130371           (return-from process-toplevel-form))
    131           ((IN-PACKAGE DEFPACKAGE)
    132            (note-toplevel-form form)
     372          ((eq operator 'PUT)
     373           (setf form (precompiler:precompile-form form nil *compile-file-environment*)))
     374          ((eq operator 'COMPILER-DEFSTRUCT)
     375           (setf form (precompiler:precompile-form form nil *compile-file-environment*)))
     376          ((eq operator 'PROCLAIM)
     377           (setf form (precompiler:precompile-form form nil *compile-file-environment*)))
     378          ((and (memq operator '(EXPORT REQUIRE PROVIDE SHADOW))
     379                (or (keywordp (second form))
     380                    (and (listp (second form))
     381                         (eq (first (second form)) 'QUOTE))))
     382           (setf form (precompiler:precompile-form form nil *compile-file-environment*)))
     383          ((eq operator 'IMPORT)
    133384           (setf form (precompiler:precompile-form form nil *compile-file-environment*))
    134            (eval form)
    135            ;; Force package prefix to be used when dumping form.
     385           ;; Make sure package prefix is printed when symbols are imported.
    136386           (let ((*package* +keyword-package+))
    137387             (output-form form))
     388           (when compile-time-too
     389             (eval form))
    138390           (return-from process-toplevel-form))
    139           ((DEFVAR DEFPARAMETER)
    140            (note-toplevel-form form)
    141            (if compile-time-too
    142                (eval form)
    143                ;; "If a DEFVAR or DEFPARAMETER form appears as a top level form,
    144                ;; the compiler must recognize that the name has been proclaimed
    145                ;; special. However, it must neither evaluate the initial-value
    146                ;; form nor assign the dynamic variable named NAME at compile
    147                ;; time."
    148                (let ((name (second form)))
    149                  (%defvar name))))
    150           (DEFCONSTANT
    151            (note-toplevel-form form)
    152            (process-defconstant form)
    153            (return-from process-toplevel-form))
    154           (DEFUN
    155            (note-toplevel-form form)
    156            (let* ((name (second form))
    157                   (block-name (fdefinition-block-name name))
    158                   (lambda-list (third form))
    159                   (body (nthcdr 3 form)))
    160              (jvm::with-saved-compiler-policy
    161                (multiple-value-bind (body decls doc)
    162                    (parse-body body)
    163                  (let* ((expr `(lambda ,lambda-list
    164                                  ,@decls (block ,block-name ,@body)))
    165       (saved-class-number *class-number*)
    166                         (classfile (next-classfile-name))
    167                         (internal-compiler-errors nil)
    168                         (result (with-open-file
    169             (f classfile
    170                :direction :output
    171                :element-type '(unsigned-byte 8)
    172                :if-exists :supersede)
    173                                   (handler-bind
    174                                       ((internal-compiler-error
    175                                         #'(lambda (e)
    176                                             (push e internal-compiler-errors)
    177                                             (continue))))
    178                                     (report-error
    179                                      (jvm:compile-defun name expr *compile-file-environment*
    180                                                         classfile f nil)))))
    181                         (compiled-function (if (not internal-compiler-errors)
    182                                                (verify-load classfile)
    183                                                nil)))
    184        (declare (ignore result))
    185                    (cond
    186                      ((and (not internal-compiler-errors)
    187                            compiled-function)
    188                       (setf form
    189                             `(fset ',name
    190            (sys::get-fasl-function *fasl-loader*
    191                  ,saved-class-number)
    192                                    ,*source-position*
    193                                    ',lambda-list
    194                                    ,doc))
    195                       (when compile-time-too
    196                         (fset name compiled-function)))
    197                      (t
    198                       ;; Add this warning when the stock ABCL compiles
    199                       ;; again, as all warnings in COMPILE-SYSTEM
    200                       ;; produce a non-zero exit status that stops
    201                       ;; build.xml in its tracks.
    202                       #+nil
    203                       (compiler-warn "Unable to compile function ~A.  Using interpreted form instead.~%" name)
    204                       (format *error-output*
    205                               "; Unable to compile function ~A.  Using interpreted form instead.~%" name)
    206                       (when internal-compiler-errors
    207                         (dolist (e internal-compiler-errors)
    208                           (format *error-output*
    209                                   "; ~A~%" e)))
    210                       (let ((precompiled-function
    211                              (precompiler:precompile-form expr nil
    212                                               *compile-file-environment*)))
    213                         (setf form
    214                               `(fset ',name
    215                                      ,precompiled-function
    216                                      ,*source-position*
    217                                      ',lambda-list
    218                                      ,doc)))
    219                       (when compile-time-too
    220                         (eval form)))))
    221                  (when (and (symbolp name) (eq (get name '%inline) 'INLINE))
    222                  ;; FIXME Need to support SETF functions too!
    223                    (setf (inline-expansion name)
    224                          (jvm::generate-inline-expansion block-name
    225                                                          lambda-list body))
    226                    (output-form `(setf (inline-expansion ',name)
    227                                        ',(inline-expansion name))))))
    228              (push name jvm::*functions-defined-in-current-file*)
    229              (note-name-defined name)
    230              ;; If NAME is not fbound, provide a dummy definition so that
    231              ;; getSymbolFunctionOrDie() will succeed when we try to verify that
    232              ;; functions defined later in the same file can be loaded correctly.
    233              (unless (fboundp name)
    234                (setf (fdefinition name) #'dummy)
    235                (push name *fbound-names*))))
    236           ((DEFGENERIC DEFMETHOD)
    237            (note-toplevel-form form)
    238            (note-name-defined (second form))
    239            (let ((*compile-print* nil))
    240              (process-toplevel-form (macroexpand-1 form *compile-file-environment*)
    241                                     stream compile-time-too))
    242              (return-from process-toplevel-form))
    243           (DEFMACRO
    244            (note-toplevel-form form)
    245            (let ((name (second form)))
    246              (eval form)
    247              (let* ((expr (function-lambda-expression (macro-function name)))
    248         (saved-class-number *class-number*)
    249                     (classfile (next-classfile-name)))
    250          (with-open-file
    251        (f classfile
    252           :direction :output
    253           :element-type '(unsigned-byte 8)
    254           :if-exists :supersede)
    255      (ignore-errors
    256        (jvm:compile-defun nil expr *compile-file-environment*
    257                                       classfile f nil)))
    258                (if (null (verify-load classfile))
    259                    ;; FIXME error or warning
    260                    (format *error-output* "; Unable to compile macro ~A~%" name)
    261                  (progn
    262                    (setf form
    263                          (if (special-operator-p name)
    264                              `(put ',name 'macroexpand-macro
    265                                    (make-macro ',name
    266                  (sys::get-fasl-function *fasl-loader* ,saved-class-number)))
    267                              `(fset ',name
    268                                     (make-macro ',name
    269             (sys::get-fasl-function *fasl-loader* ,saved-class-number))
    270                                     ,*source-position*
    271                                     ',(third form)))))))))
    272           (DEFTYPE
    273            (note-toplevel-form form)
    274            (eval form))
    275           (EVAL-WHEN
    276            (multiple-value-bind (ct lt e)
    277                (parse-eval-when-situations (cadr form))
    278              (let ((new-compile-time-too (or ct (and compile-time-too e)))
    279                    (body (cddr form)))
    280                (if lt
    281                    (process-toplevel-progn body stream new-compile-time-too)
    282                  (when new-compile-time-too
    283                    (eval `(progn ,@body)))))
    284            (return-from process-toplevel-form)))
    285           (LOCALLY
    286            ;; FIXME Need to handle special declarations too!
    287            (jvm::with-saved-compiler-policy
    288              (multiple-value-bind (forms decls)
    289                  (parse-body (cdr form) nil)
    290                (process-optimization-declarations decls)
    291                (let* ((jvm::*visible-variables* jvm::*visible-variables*)
    292                       (specials (jvm::process-declarations-for-vars (cdr form)
    293                                                                     nil nil)))
    294                  (dolist (special specials)
    295                    (push special jvm::*visible-variables*))
    296                  (process-toplevel-progn forms stream compile-time-too))
    297                (return-from process-toplevel-form))))
    298           (PROGN
    299            (process-toplevel-progn (cdr form) stream compile-time-too)
    300            (return-from process-toplevel-form))
    301           (DECLARE
    302            (compiler-style-warn "Misplaced declaration: ~S" form))
    303           (t
    304            (when (and (symbolp operator)
    305                       (macro-function operator *compile-file-environment*))
    306              (note-toplevel-form form)
    307              ;; Note that we want MACROEXPAND-1 and not MACROEXPAND here, in
    308              ;; case the form being expanded expands into something that needs
    309              ;; special handling by PROCESS-TOPLEVEL-FORM (e.g. DEFMACRO).
    310              (let ((*compile-print* nil))
    311                (process-toplevel-form (macroexpand-1 form *compile-file-environment*)
    312                                       stream compile-time-too))
    313              (return-from process-toplevel-form))
    314 
    315            (cond ((eq operator 'QUOTE)
    316 ;;;                      (setf form (precompiler:precompile-form form nil
    317 ;;;                                                  *compile-file-environment*))
    318                   (when compile-time-too
    319                     (eval form))
    320                   (return-from process-toplevel-form))
    321                  ((eq operator 'PUT)
    322                   (setf form (precompiler:precompile-form form nil *compile-file-environment*)))
    323                  ((eq operator 'COMPILER-DEFSTRUCT)
    324                   (setf form (precompiler:precompile-form form nil *compile-file-environment*)))
    325                  ((eq operator 'PROCLAIM)
    326                   (setf form (precompiler:precompile-form form nil *compile-file-environment*)))
    327                  ((and (memq operator '(EXPORT REQUIRE PROVIDE SHADOW))
    328                        (or (keywordp (second form))
    329                            (and (listp (second form))
    330                                 (eq (first (second form)) 'QUOTE))))
    331                   (setf form (precompiler:precompile-form form nil *compile-file-environment*)))
    332                  ((eq operator 'IMPORT)
    333                   (setf form (precompiler:precompile-form form nil *compile-file-environment*))
    334                   ;; Make sure package prefix is printed when symbols are imported.
    335                   (let ((*package* +keyword-package+))
    336                     (output-form form))
    337                   (when compile-time-too
    338                     (eval form))
    339                   (return-from process-toplevel-form))
    340                  ((and (eq operator '%SET-FDEFINITION)
    341                        (eq (car (second form)) 'QUOTE)
    342                        (consp (third form))
    343                        (eq (%car (third form)) 'FUNCTION)
    344                        (symbolp (cadr (third form))))
    345                   (setf form (precompiler:precompile-form form nil *compile-file-environment*)))
     391          ((and (eq operator '%SET-FDEFINITION)
     392                (eq (car (second form)) 'QUOTE)
     393                (consp (third form))
     394                (eq (%car (third form)) 'FUNCTION)
     395                (symbolp (cadr (third form))))
     396           (setf form (precompiler:precompile-form form nil *compile-file-environment*)))
    346397;;;                     ((memq operator '(LET LET*))
    347398;;;                      (let ((body (cddr form)))
     
    351402;;;                            (setf form (convert-toplevel-form form))
    352403;;;                            (setf form (precompiler:precompile-form form nil)))))
    353                  ((eq operator 'mop::ensure-method)
    354                   (setf form (convert-ensure-method form)))
    355                  ((and (symbolp operator)
    356                        (not (special-operator-p operator))
    357                        (null (cdr form)))
    358                   (setf form (precompiler:precompile-form form nil *compile-file-environment*)))
    359                  (t
     404          ((eq operator 'mop::ensure-method)
     405           (setf form (convert-ensure-method form)))
     406          ((and (symbolp operator)
     407                (not (special-operator-p operator))
     408                (null (cdr form)))
     409           (setf form (precompiler:precompile-form form nil *compile-file-environment*)))
     410          (t
    360411;;;                      (setf form (precompiler:precompile-form form nil))
    361                   (note-toplevel-form form)
    362                   (setf form (convert-toplevel-form form nil)))))))))
     412           (note-toplevel-form form)
     413           (setf form (convert-toplevel-form form nil)))))))
    363414  (when (consp form)
    364415    (output-form form))
     
    464515                                                    (make-expander-for-macrolet definition))))
    465516    (dolist (body-form (cddr form))
    466       (process-toplevel-form body-form stream compile-time-too))))
    467 
    468 (declaim (ftype (function (t stream t) t) process-toplevel-progn))
    469 (defun process-toplevel-progn (forms stream compile-time-too)
     517      (process-toplevel-form body-form stream compile-time-too)))
     518  nil) ;; nothing to be sent to output
     519
     520(declaim (ftype (function (t stream t) t) process-progn))
     521(defun process-progn (forms stream compile-time-too)
    470522  (dolist (form forms)
    471     (process-toplevel-form form stream compile-time-too)))
     523    (process-toplevel-form form stream compile-time-too))
     524  nil)
    472525
    473526;;; Adapted from SBCL.
Note: See TracChangeset for help on using the changeset viewer.