source: trunk/abcl/src/org/armedbear/lisp/compile-file.lisp @ 11841

Last change on this file since 11841 was 11841, checked in by ehuelsmann, 13 years ago

Simplify PROCESS-DEFCONSTANT;
the only thing the code we're removing was doing is prevent a #. reader macro
on the dumped third list element.

  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 24.2 KB
Line 
1;;; compile-file.lisp
2;;;
3;;; Copyright (C) 2004-2006 Peter Graves
4;;; $Id: compile-file.lisp 11841 2009-05-08 18:58:03Z ehuelsmann $
5;;;
6;;; This program is free software; you can redistribute it and/or
7;;; modify it under the terms of the GNU General Public License
8;;; as published by the Free Software Foundation; either version 2
9;;; of the License, or (at your option) any later version.
10;;;
11;;; This program is distributed in the hope that it will be useful,
12;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
13;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14;;; GNU General Public License for more details.
15;;;
16;;; You should have received a copy of the GNU General Public License
17;;; along with this program; if not, write to the Free Software
18;;; Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
19;;;
20;;; As a special exception, the copyright holders of this library give you
21;;; permission to link this library with independent modules to produce an
22;;; executable, regardless of the license terms of these independent
23;;; modules, and to copy and distribute the resulting executable under
24;;; terms of your choice, provided that you also meet, for each linked
25;;; independent module, the terms and conditions of the license of that
26;;; module.  An independent module is a module which is not derived from
27;;; or based on this library.  If you modify this library, you may extend
28;;; this exception to your version of the library, but you are not
29;;; obligated to do so.  If you do not wish to do so, delete this
30;;; exception statement from your version.
31
32(in-package #:system)
33
34(require '#:jvm)
35
36(defvar *fbound-names*)
37
38(defvar *class-number*)
39
40(defvar *output-file-pathname*)
41
42(declaim (ftype (function (t) t) compute-classfile-name))
43(defun compute-classfile-name (n &optional (output-file-pathname
44                                            *output-file-pathname*))
45  "Computes the name of the class file associated with number `n'."
46  (let ((name
47         (%format nil "~A-~D"
48                  (substitute #\_ #\.
49                              (pathname-name output-file-pathname)) n)))
50    (namestring (merge-pathnames (make-pathname :name name :type "cls")
51                                 output-file-pathname))))
52
53(declaim (ftype (function () t) next-classfile-name))
54(defun next-classfile-name ()
55  (compute-classfile-name (incf *class-number*)))
56
57(defmacro report-error (&rest forms)
58  `(handler-case (progn ,@forms)
59     (compiler-unsupported-feature-error (condition)
60       (fresh-line)
61       (%format t "; UNSUPPORTED-FEATURE: ~A~%" condition)
62       (values nil condition))))
63
64;; Dummy function. Should never be called.
65(defun dummy (&rest ignored)
66  (declare (ignore ignored))
67  (assert nil))
68
69(declaim (ftype (function (t) t) verify-load))
70(defun verify-load (classfile)
71  (and classfile
72       (let ((*load-truename* *output-file-pathname*))
73         (report-error
74          (load-compiled-function classfile)))))
75
76(declaim (ftype (function (t stream) t) process-defconstant))
77(defun process-defconstant (form stream)
78  ;; "If a DEFCONSTANT form appears as a top level form, the compiler
79  ;; must recognize that [the] name names a constant variable. An
80  ;; implementation may choose to evaluate the value-form at compile
81  ;; time, load time, or both. Therefore, users must ensure that the
82  ;; initial-value can be evaluated at compile time (regardless of
83  ;; whether or not references to name appear in the file) and that
84  ;; it always evaluates to the same value."
85  (eval form)
86  (dump-form form stream)
87  (%stream-terpri stream))
88
89(declaim (ftype (function (t) t) note-toplevel-form))
90(defun note-toplevel-form (form)
91  (when *compile-print*
92    (fresh-line)
93    (princ "; ")
94    (let ((*print-length* 2)
95          (*print-level* 2)
96          (*print-pretty* nil))
97      (prin1 form))
98    (terpri)))
99
100(declaim (ftype (function (t stream t) t) process-toplevel-form))
101(defun process-toplevel-form (form stream compile-time-too)
102  (cond ((atom form)
103         (when compile-time-too
104           (eval form)))
105        (t
106         (let ((operator (%car form)))
107           (case operator
108             (MACROLET
109              (process-toplevel-macrolet form stream compile-time-too)
110              (return-from process-toplevel-form))
111             ((IN-PACKAGE DEFPACKAGE)
112              (note-toplevel-form form)
113              (setf form (precompile-form form nil))
114              (eval form)
115              ;; Force package prefix to be used when dumping form.
116              (let ((*package* +keyword-package+))
117                (dump-form form stream))
118              (%stream-terpri stream)
119              (return-from process-toplevel-form))
120             ((DEFVAR DEFPARAMETER)
121              (note-toplevel-form form)
122              (if compile-time-too
123                  (eval form)
124                  ;; "If a DEFVAR or DEFPARAMETER form appears as a top level form,
125                  ;; the compiler must recognize that the name has been proclaimed
126                  ;; special. However, it must neither evaluate the initial-value
127                  ;; form nor assign the dynamic variable named NAME at compile
128                  ;; time."
129                  (let ((name (second form)))
130                    (%defvar name))))
131             (DEFCONSTANT
132              (note-toplevel-form form)
133              (process-defconstant form stream)
134              (return-from process-toplevel-form))
135             (DEFUN
136              (note-toplevel-form form)
137              (let* ((name (second form))
138                     (block-name (fdefinition-block-name name))
139                     (lambda-list (third form))
140                     (body (nthcdr 3 form))
141                     (*speed* *speed*)
142                     (*space* *space*)
143                     (*safety* *safety*)
144                     (*debug* *debug*))
145                (multiple-value-bind (body decls doc)
146                    (parse-body body)
147                  (let* ((expr `(lambda ,lambda-list ,@decls (block ,block-name ,@body)))
148                         (classfile-name (next-classfile-name))
149                         (classfile (report-error
150                                     (jvm:compile-defun name expr nil classfile-name)))
151                         (compiled-function (verify-load classfile)))
152                    (cond (compiled-function
153                           (setf form
154                                 `(fset ',name
155                                        (load-compiled-function ,(file-namestring classfile))
156                                        ,*source-position*
157                                        ',lambda-list
158                                        ,doc))
159                           (when compile-time-too
160                             (fset name compiled-function)))
161                          (t
162                           ;; FIXME This should be a warning or error of some sort...
163                           (format *error-output* "; Unable to compile function ~A~%" name)
164                           (let ((precompiled-function (precompile-form expr nil)))
165                             (setf form
166                                   `(fset ',name
167                                          ,precompiled-function
168                                          ,*source-position*
169                                          ',lambda-list
170                                          ,doc)))
171                           (when compile-time-too
172                             (eval form)))))
173                  (when (and (symbolp name) (eq (get name '%inline) 'INLINE))
174                    ;; FIXME Need to support SETF functions too!
175                    (setf (inline-expansion name)
176                          (jvm::generate-inline-expansion block-name lambda-list body))
177                    (dump-form `(setf (inline-expansion ',name) ',(inline-expansion name))
178                               stream)
179                    (%stream-terpri stream)))
180                (push name jvm::*functions-defined-in-current-file*)
181                (note-name-defined name)
182                ;; If NAME is not fbound, provide a dummy definition so that
183                ;; getSymbolFunctionOrDie() will succeed when we try to verify that
184                ;; functions defined later in the same file can be loaded correctly.
185                (unless (fboundp name)
186                  (setf (fdefinition name) #'dummy)
187                  (push name *fbound-names*))))
188             ((DEFGENERIC DEFMETHOD)
189              (note-toplevel-form form)
190              (note-name-defined (second form))
191              (let ((*compile-print* nil))
192                (process-toplevel-form (macroexpand-1 form *compile-file-environment*)
193                                       stream compile-time-too))
194              (return-from process-toplevel-form))
195             (DEFMACRO
196              (note-toplevel-form form)
197              (let ((name (second form)))
198                (eval form)
199                (let* ((expr (function-lambda-expression (macro-function name)))
200                       (classfile-name (next-classfile-name))
201                       (classfile
202                        (ignore-errors
203                         (jvm:compile-defun nil expr nil classfile-name))))
204                  (if (verify-load classfile)
205                      (progn
206                        (setf form
207                              (if (special-operator-p name)
208                                  `(put ',name 'macroexpand-macro
209                                        (make-macro ',name
210                                                    (load-compiled-function
211                                                     ,(file-namestring classfile))))
212                                  `(fset ',name
213                                         (make-macro ',name
214                                                     (load-compiled-function
215                                                      ,(file-namestring classfile)))
216                                         ,*source-position*
217                                         ',(third form)))))
218                      ;; FIXME error or warning
219                      (format *error-output* "; Unable to compile macro ~A~%" name)))))
220             (DEFTYPE
221              (note-toplevel-form form)
222              (eval form))
223             (EVAL-WHEN
224              (multiple-value-bind (ct lt e)
225                  (parse-eval-when-situations (cadr form))
226                (let ((new-compile-time-too (or ct
227                                                (and compile-time-too e)))
228                      (body (cddr form)))
229                  (cond (lt
230                         (process-toplevel-progn body stream new-compile-time-too))
231                        (new-compile-time-too
232                         (eval `(progn ,@body)))))
233                (return-from process-toplevel-form)))
234             (LOCALLY
235              ;; FIXME Need to handle special declarations too!
236              (let ((*speed* *speed*)
237                    (*safety* *safety*)
238                    (*debug* *debug*)
239                    (*space* *space*)
240                    (*inline-declarations* *inline-declarations*))
241                (multiple-value-bind (forms decls)
242                    (parse-body (cdr form) nil)
243                  (process-optimization-declarations decls)
244                  (process-toplevel-progn forms stream compile-time-too)
245                  (return-from process-toplevel-form))))
246             (PROGN
247              (process-toplevel-progn (cdr form) stream compile-time-too)
248              (return-from process-toplevel-form))
249             (DECLARE
250              (compiler-style-warn "Misplaced declaration: ~S" form))
251             (t
252              (when (and (symbolp operator)
253                         (macro-function operator *compile-file-environment*))
254                (note-toplevel-form form)
255                ;; Note that we want MACROEXPAND-1 and not MACROEXPAND here, in
256                ;; case the form being expanded expands into something that needs
257                ;; special handling by PROCESS-TOPLEVEL-FORM (e.g. DEFMACRO).
258                (let ((*compile-print* nil))
259                  (process-toplevel-form (macroexpand-1 form *compile-file-environment*)
260                                         stream compile-time-too))
261                (return-from process-toplevel-form))
262
263              (cond ((eq operator 'QUOTE)
264;;                      (setf form (precompile-form form nil))
265                     (when compile-time-too
266                       (eval form))
267                     (return-from process-toplevel-form)
268                     )
269                    ((eq operator 'PUT)
270                     (setf form (precompile-form form nil)))
271                    ((eq operator 'COMPILER-DEFSTRUCT)
272                     (setf form (precompile-form form nil)))
273                    ((eq operator 'PROCLAIM)
274                     (setf form (precompile-form form nil)))
275                    ((and (memq operator '(EXPORT REQUIRE PROVIDE SHADOW))
276                          (or (keywordp (second form))
277                              (and (listp (second form))
278                                   (eq (first (second form)) 'QUOTE))))
279                     (setf form (precompile-form form nil)))
280                    ((eq operator 'IMPORT)
281                     (setf form (precompile-form form nil))
282                     ;; Make sure package prefix is printed when symbols are imported.
283                     (let ((*package* +keyword-package+))
284                       (dump-form form stream))
285                     (%stream-terpri stream)
286                     (when compile-time-too
287                       (eval form))
288                     (return-from process-toplevel-form))
289                    ((and (eq operator '%SET-FDEFINITION)
290                          (eq (car (second form)) 'QUOTE)
291                          (consp (third form))
292                          (eq (%car (third form)) 'FUNCTION)
293                          (symbolp (cadr (third form))))
294                     (setf form (precompile-form form nil)))
295;;                     ((memq operator '(LET LET*))
296;;                      (let ((body (cddr form)))
297;;                        (if (dolist (subform body nil)
298;;                              (when (and (consp subform) (eq (%car subform) 'DEFUN))
299;;                                (return t)))
300;;                            (setf form (convert-toplevel-form form))
301;;                            (setf form (precompile-form form nil)))))
302                    ((eq operator 'mop::ensure-method)
303                     (setf form (convert-ensure-method form)))
304                    ((and (symbolp operator)
305                          (not (special-operator-p operator))
306                          (null (cdr form)))
307                     (setf form (precompile-form form nil)))
308                    (t
309;;                      (setf form (precompile-form form nil))
310                     (note-toplevel-form form)
311                     (setf form (convert-toplevel-form form))
312                     )))))))
313  (when (consp form)
314    (dump-form form stream)
315    (%stream-terpri stream))
316  ;; Make sure the compiled-function loader knows where
317  ;; to load the compiled functions. Note that this trickery
318  ;; was already used in verify-load before I used it,
319  ;; however, binding *load-truename* isn't fully compliant, I think.
320  (let ((*load-truename* *output-file-pathname*))
321    (when compile-time-too
322      (eval form))))
323
324(declaim (ftype (function (t) t) convert-ensure-method))
325(defun convert-ensure-method (form)
326  (c-e-m-1 form :function)
327  (c-e-m-1 form :fast-function)
328  (precompile-form form nil))
329
330(declaim (ftype (function (t t) t) c-e-m-1))
331(defun c-e-m-1 (form key)
332  (let* ((tail (cddr form))
333         (function-form (getf tail key)))
334    (when (and function-form (consp function-form)
335               (eq (%car function-form) 'FUNCTION))
336      (let ((lambda-expression (cadr function-form)))
337        (let* ((*speed* *speed*)
338               (*space* *space*)
339               (*safety* *safety*)
340               (*debug* *debug*))
341          (let* ((classfile-name (next-classfile-name))
342                 (classfile (report-error
343                             (jvm:compile-defun nil lambda-expression nil classfile-name)))
344                 (compiled-function (verify-load classfile)))
345            (cond (compiled-function
346                   (setf (getf tail key)
347                         `(load-compiled-function ,(file-namestring classfile))))
348                  (t
349                   ;; FIXME This should be a warning or error of some sort...
350                   (format *error-output* "; Unable to compile method~%")))))))))
351
352(declaim (ftype (function (t) t) convert-toplevel-form))
353(defun convert-toplevel-form (form)
354  (let* ((expr `(lambda () ,form))
355         (classfile-name (next-classfile-name))
356         (classfile (report-error (jvm:compile-defun nil expr nil classfile-name)))
357         (compiled-function (verify-load classfile)))
358    (setf form
359          (if compiled-function
360              `(funcall (load-compiled-function ,(file-namestring classfile)))
361              (precompile-form form nil)))))
362
363
364(defun process-toplevel-macrolet (form stream compile-time-too)
365  (let ((*compile-file-environment* (make-environment *compile-file-environment*)))
366    (dolist (definition (cadr form))
367      (environment-add-macro-definition *compile-file-environment*
368                                        (car definition)
369                                        (make-macro (car definition)
370                                                    (make-expander-for-macrolet definition))))
371    (dolist (body-form (cddr form))
372      (process-toplevel-form body-form stream compile-time-too))))
373
374(declaim (ftype (function (t stream t) t) process-toplevel-progn))
375(defun process-toplevel-progn (forms stream compile-time-too)
376  (dolist (form forms)
377    (process-toplevel-form form stream compile-time-too)))
378
379;;; Adapted from SBCL.
380;;; Parse an EVAL-WHEN situations list, returning three flags,
381;;; (VALUES COMPILE-TOPLEVEL LOAD-TOPLEVEL EXECUTE), indicating
382;;; the types of situations present in the list.
383(defun parse-eval-when-situations (situations)
384  (when (or (not (listp situations))
385      (set-difference situations
386          '(:compile-toplevel
387            compile
388            :load-toplevel
389            load
390            :execute
391            eval)))
392    (error "Bad EVAL-WHEN situation list: ~S." situations))
393  (values (intersection '(:compile-toplevel compile) situations)
394    (intersection '(:load-toplevel load) situations)
395    (intersection '(:execute eval) situations)))
396
397(defun compile-file (input-file
398                     &key
399                     output-file
400                     ((:verbose *compile-verbose*) *compile-verbose*)
401                     ((:print *compile-print*) *compile-print*)
402                     external-format)
403  (declare (ignore external-format)) ; FIXME
404  (unless (or (and (probe-file input-file) (not (file-directory-p input-file)))
405              (pathname-type input-file))
406    (let ((pathname (merge-pathnames (make-pathname :type "lisp") input-file)))
407      (when (probe-file pathname)
408        (setf input-file pathname))))
409  (setf output-file (if output-file
410                        (merge-pathnames output-file *default-pathname-defaults*)
411                        (compile-file-pathname input-file)))
412  (let* ((*output-file-pathname* output-file)
413         (type (pathname-type output-file))
414         (temp-file (merge-pathnames (make-pathname :type (concatenate 'string type "-tmp"))
415                                     output-file))
416         (warnings-p nil)
417         (failure-p nil))
418    (with-open-file (in input-file :direction :input)
419      (let* ((*compile-file-pathname* (pathname in))
420             (*compile-file-truename* (truename in))
421             (*source* *compile-file-truename*)
422             (*class-number* 0)
423             (namestring (namestring *compile-file-truename*))
424             (start (get-internal-real-time))
425             elapsed)
426        (when *compile-verbose*
427          (format t "; Compiling ~A ...~%" namestring))
428        (with-compilation-unit ()
429          (with-open-file (out temp-file :direction :output :if-exists :supersede)
430            (let ((*readtable* *readtable*)
431                  (*read-default-float-format* *read-default-float-format*)
432                  (*read-base* *read-base*)
433                  (*package* *package*)
434                  (*speed* *speed*)
435                  (*space* *space*)
436                  (*safety* *safety*)
437                  (*debug* *debug*)
438                  (*explain* *explain*)
439                  (jvm::*functions-defined-in-current-file* '())
440                  (*fbound-names* '())
441                  (*fasl-anonymous-package* (%make-package)))
442              (jvm::with-file-compilation
443                (write "; -*- Mode: Lisp -*-" :escape nil :stream out)
444                (%stream-terpri out)
445                (let ((*package* (find-package '#:cl)))
446                  (write (list 'init-fasl :version *fasl-version*) :stream out)
447                  (%stream-terpri out)
448                  (write (list 'setq '*source* *compile-file-truename*) :stream out)
449                  (%stream-terpri out))
450                (handler-bind ((style-warning #'(lambda (c)
451                                                  (declare (ignore c))
452                                                  (setf warnings-p t)
453                                                  nil))
454                               ((or warning
455                                    compiler-error) #'(lambda (c)
456                                                        (declare (ignore c))
457                                                        (setf warnings-p t
458                                                              failure-p t)
459                                                        nil)))
460                  (loop
461                     (let* ((*source-position* (file-position in))
462                            (jvm::*source-line-number* (stream-line-number in))
463                            (form (read in nil in))
464                            (*compiler-error-context* form))
465                       (when (eq form in)
466                         (return))
467                       (process-toplevel-form form out nil))))
468                (dolist (name *fbound-names*)
469                  (fmakunbound name))))))
470        (rename-file temp-file output-file)
471
472        (when *compile-file-zip*
473          (let* ((type ;; Don't use ".zip", it'll result in an extension
474                       ;;  with a dot, which is rejected by NAMESTRING
475                  (%format nil "~A~A" (pathname-type output-file) "-zip"))
476                 (zipfile (namestring
477                           (merge-pathnames (make-pathname :type type)
478                                            output-file)))
479                 (pathnames ()))
480            (dotimes (i *class-number*)
481              (let* ((pathname (compute-classfile-name (1+ i))))
482                (when (probe-file pathname)
483                  (push pathname pathnames))))
484            (setf pathnames (nreverse pathnames))
485            (let ((load-file (merge-pathnames (make-pathname :type "_")
486                                              output-file)))
487              (rename-file output-file load-file)
488              (push load-file pathnames))
489            (zip zipfile pathnames)
490            (dolist (pathname pathnames)
491              (let ((truename (probe-file pathname)))
492                (when truename
493                  (delete-file truename))))
494            (rename-file zipfile output-file)))
495
496        (setf elapsed (/ (- (get-internal-real-time) start) 1000.0))
497        (when *compile-verbose*
498          (format t "~&; Wrote ~A (~A seconds)~%" (namestring output-file) elapsed))))
499    (values (truename output-file) warnings-p failure-p)))
500
501(defun compile-file-if-needed (input-file &rest allargs &key force-compile
502                               &allow-other-keys)
503  (setf input-file (truename input-file))
504  (cond (force-compile
505         (remf allargs :force-compile)
506         (apply 'compile-file input-file allargs))
507        (t
508         (let* ((source-write-time (file-write-date input-file))
509                (output-file       (or (getf allargs :output-file)
510                                       (compile-file-pathname input-file)))
511                (target-write-time (and (probe-file output-file)
512                                        (file-write-date output-file))))
513           (if (or (null target-write-time)
514                   (<= target-write-time source-write-time))
515               (apply 'compile-file input-file allargs)
516               output-file)))))
517
518(provide 'compile-file)
Note: See TracBrowser for help on using the repository browser.