GitLab

at 2026-04-30T07:04:04-07:00

Add comments to bootstrap file.

Just clarify what we're doing and for what issue

Print out the source location for the deftype

The source location is stored in :deftype so we need to use that for
the source location instead of :defvar.

Updated cmucl.pot for new strings.

Cross-compile build needs a cross boostrap file

Add new variable "crossboot" to hold the option to specify a cross
bootstrap file for cross-build-world to use.

In this case, we need one for the deftype changes, and it's the same
boot file we would use for the normal build.

   download_url: "https://common-lisp.net/project/cmucl/downloads/release/$release"

   version: "$release-x86"

   tar_ext: "xz"

+  # bootstrap is for normal builds

   bootstrap: "-B boot-21f"

+  # crossboot is for cross-compiles where the cross-compile script

+  # isn't enough and we need an extra file.

+  crossboot: "-B src/bootfiles/21f/boot-21f"

 workflow:

   rules:

   script:

     - bin/create-target.sh xtarget $CONFIG

     - bin/create-target.sh xcross $CONFIG

-    - bin/cross-build-world.sh -crl xtarget xcross src/tools/cross-scripts/cross-x86-x86.lisp snapshot/bin/lisp

+    - bin/cross-build-world.sh $crossboot -crl xtarget xcross src/tools/cross-scripts/cross-x86-x86.lisp snapshot/bin/lisp

     - bin/build.sh -b xlinux $bootstrap -R -C $CONFIG -o "xtarget/lisp/lisp -lib xtarget/lisp"

     - bin/make-dist.sh -I xdist xlinux-4

+;; Bootstrap file for issue #495 to add more information when

+;; describing user-defined types.

+;;

 (setf lisp::*enable-package-locked-errors* nil)

 (in-package "C")

-;; deftype information

+;; New deftype information.

+;;

+;; We define a :lambda-list for types where we can store the

+;; lambda-list of the deftype.  We also add a :defype source-location

+;; for deftypes so we don't use :defvar for this.

 (define-info-type type lambda-list list nil)

 (define-info-type source-location deftype (or form-numbers null) nil)

 (in-package "LISP")

+;; New deftype macro to saves the lambda-list of the type.  %deftype

+;; is updated to take the extra arg for the lambda-list.

 (defmacro deftype (name arglist &body body)

   "Syntax like DEFMACRO, but defines a new type."

   (unless (symbolp name)

 	  (describe pcl-class)))))

   ;;

   ;; Print out information about any types named by the symbol

-  #+nil

-  (when (eq (info type kind x) :defined)

-    (format t (intl:gettext "~&It names a type specifier.")))

-  (format t "info type kind = ~A~%" (info type kind x))

-  (case (info type kind x)

+  (case (info :type :kind x)

     (:defined

      ;; User defined type

      (format t (intl:gettext "~&It names a type specifier."))

      (let ((lambda-list (info type lambda-list x)))

        (when lambda-list

-	 (format t (intl:gettext "~& Lambda list: ~S") lambda-list)))

-     (let ((expander (info type expander x)))

+	 (format t (intl:gettext "~&  Lambda list: ~S") lambda-list)))

+     (let ((expander (info :type :expander x)))

        (when expander

 	 (let ((expansion (ignore-errors (funcall expander (list x)))))

 	   (when expansion

 		     (list x) expansion))))))

     (:primitive

      ;; Primitive built-in type

-     (format t (intl:gettext "~&It names a type specifier."))

-     (let ((builtin (info type builtin x)))

+     (format t (intl:gettext "~&It names a primitive type specifier."))

+     (let ((builtin (info :type :builtin x)))

        (when builtin

-	 (format t (intl:gettext "~& Internal type: ~S") builtin)))))

+	 (format t (intl:gettext "~&  Internal type: ~S") builtin)))))

   ;;

   ;; Print out properties, possibly ignoring implementation details.

   (do ((plist (symbol-plist X) (cddr plist)))

       (describe (cadr plist))))

   ;; Describe where it was defined.

+  ;;

+  ;; Note: Source location for user-defined types is stored in

+  ;; :deftype.  However :defvar is currently used for defvar,

+  ;; defparameter, defconstant.  Just try printing both :defvar and

+  ;; :deftype locations.  They should be distinct.

   (let ((locn (info :source-location :defvar x)))

     (when locn

-      (format t (intl:gettext "~&It is defined in:~&~A") (c::file-source-location-pathname locn)))))
+      (format t (intl:gettext "~&It is defined in:~&~A") (c::file-source-location-pathname locn))))

+  (let ((locn (info :source-location :deftype x)))

+    (when locn

+      (format t (intl:gettext "~&The type is defined in:~&~A")

+	      (c::file-source-location-pathname locn)))))

Raymond Toy pushed to branch issue-495-describe-deftypes at cmucl / cmucl

Commits:

4 changed files:

Changes: