Raymond Toy pushed to branch master at cmucl / cmucl

Commits:

2 changed files:

Changes:

  • src/bootfiles/21a/boot-21b.lisp
    1
     ;;;;
    
    2
     ;;;; Boot file for changing the fasl file version numbers to 21a.
    
    3
     ;;;;
    
    4
     
    
    5
     (in-package :c)
    
    6
     
    
    7
     (setf lisp::*enable-package-locked-errors* nil)
    
    8
     
    
    9
     ;;;
    
    10
     ;;; Note that BYTE-FASL-FILE-VERSION is a constant.
    
    11
     ;;;
    
    12
     ;;; (Be sure to change BYTE-FASL-FILE-VERSION in
    
    13
     ;;; compiler/byte-comp.lisp to the correct value too!)
    
    14
     ;;;
    
    15
     #-cmu21b
    
    16
     (setf (symbol-value 'byte-fasl-file-version)       #x21b)
    
    17
     #-cmu21b
    
    18
     (setf (backend-fasl-file-version *target-backend*) #x21b)
    
    19
     
    
    20
     ;;;
    
    21
     ;;; Don't check fasl versions in the compiling Lisp because we'll
    
    22
     ;;; load files compiled with the new version numbers.
    
    23
     ;;;
    
    24
     #-cmu21b
    
    25
     (setq lisp::*skip-fasl-file-version-check* t)
    
    26
     
    
    27
     ;;;
    
    28
     ;;; This is here because BYTE-FASL-FILE-VERSION is constant-folded in
    
    29
     ;;; OPEN-FASL-FILE.  To make the new version number take effect, we
    
    30
     ;;; have to redefine the function.
    
    31
     ;;;
    
    32
     #-cmu21b
    
    33
     (defun open-fasl-file (name where &optional byte-p)
    
    34
       (declare (type pathname name))
    
    35
       (let* ((stream (open name :direction :output
    
    36
     			    :if-exists :new-version
    
    37
     			    :element-type '(unsigned-byte 8)
    
    38
     			    :class 'binary-text-stream))
    
    39
     	 (res (make-fasl-file :stream stream)))
    
    40
         (multiple-value-bind
    
    41
     	(version f-vers f-imp)
    
    42
     	(if byte-p
    
    43
     	    (values "Byte code"
    
    44
     		    byte-fasl-file-version
    
    45
     		    (backend-byte-fasl-file-implementation *backend*))
    
    46
     	    (values (backend-version *backend*)
    
    47
     		    (backend-fasl-file-version *backend*)
    
    48
     		    (backend-fasl-file-implementation *backend*)))
    
    49
           (format stream
    
    50
     	      "FASL FILE output from ~A.~@
    
    51
     	       Compiled ~A on ~A~@
    
    52
     	       Compiler ~A, Lisp ~A~@
    
    53
     	       Targeted for ~A, FASL version ~X~%"
    
    54
     	      where
    
    55
     	      (ext:format-universal-time nil (get-universal-time))
    
    56
     	      (machine-instance) compiler-version
    
    57
     	      (lisp-implementation-version)
    
    58
     	      version f-vers)
    
    59
           ;;
    
    60
           ;; Terminate header.
    
    61
           (dump-byte 255 res)
    
    62
           ;;
    
    63
           ;; Specify code format.
    
    64
           (dump-fop 'lisp::fop-long-code-format res)
    
    65
           (dump-byte f-imp res)
    
    66
           (dump-unsigned-32 f-vers res))
    
    67
         res))
    
    68
     

  • src/compiler/byte-comp.lisp
    ... ... @@ -38,7 +38,7 @@
    38 38
     ;; 0-9 followed by a single hex digit in the range a-f.  Then the
    
    39 39
     ;; version looks like a decimal number followed by a minor release
    
    40 40
     ;; letter of a to f.
    
    41
     (defconstant byte-fasl-file-version #x21a)
    
    41
     (defconstant byte-fasl-file-version #x21b)
    
    42 42
     
    
    43 43
     (let* ((version-string (format nil "~X" byte-fasl-file-version)))
    
    44 44
       ;; Add :cmu<n> to *features*