From 156a608f62f5ce0c4253bb42c7ac7ac5180bfe51 Mon Sep 17 00:00:00 2001
From: ram <ram>
Date: Mon, 30 Aug 1993 10:39:13 +0000
Subject: [PATCH] Moved forcing out of pending top-level forms from
 COMPILE-LOAD-TIME-STUFF to EMIT-MAKE-LOAD-FORM, and check if the constant was
 dumped by top-level code before proceeding.  We were getting spurious
 recursive constant errors when top-level code referred to the same constant
 as a following definition.

---
 compiler/main.lisp | 28 ++++++++++++++++------------
 1 file changed, 16 insertions(+), 12 deletions(-)

diff --git a/compiler/main.lisp b/compiler/main.lisp
index 891ea3404..8ab9e9c7b 100644
--- a/compiler/main.lisp
+++ b/compiler/main.lisp
@@ -7,7 +7,7 @@
 ;;; Scott Fahlman or slisp-group@cs.cmu.edu.
 ;;;
 (ext:file-comment
-  "$Header: /Volumes/share2/src/cmucl/cvs2git/cvsroot/src/compiler/main.lisp,v 1.98 1993/08/24 02:12:21 wlott Exp $")
+  "$Header: /Volumes/share2/src/cmucl/cvs2git/cvsroot/src/compiler/main.lisp,v 1.99 1993/08/30 10:39:13 ram Exp $")
 ;;;
 ;;; **********************************************************************
 ;;;
@@ -1102,6 +1102,8 @@
 
 ;;;; Load time value support.
 
+;;; See EMIT-MAKE-LOAD-FORM.
+
 ;;; PRODUCING-FASL-FILE  --  interface.
 ;;;
 ;;; Returns T iff we are currently producing a fasl-file and hence constants
@@ -1147,7 +1149,6 @@
 ;;; INIT-FORMS.
 ;;; 
 (defun compile-load-time-stuff (form name for-value)
-  (compile-top-level-lambdas () t)
   (with-ir1-namespace
    (let* ((*lexical-environment* (make-null-environment))
 	  (lambda (ir1-top-level form *current-path* for-value)))
@@ -1189,8 +1190,8 @@
 ;;; It's not necessarily an error for this to happen.  If we are processing the
 ;;; init form for some object that showed up *after* the original reference
 ;;; to this constant, then we just need to defer the processing of that init
-;;; form.  To detect this, we maintain *constants-created-sense-last-init* as
-;;; a list of the constants created sense the last time we started processing
+;;; form.  To detect this, we maintain *constants-created-since-last-init* as
+;;; a list of the constants created since the last time we started processing
 ;;; an init form.  If the constant passed to emit-make-load-form shows up in
 ;;; this list, then there is a circular chain through creation forms, which is
 ;;; an error.
@@ -1206,26 +1207,26 @@
 ;;; do anything.  The dumper will eventually get it's hands on the object
 ;;; and use the normal structure dumping noise on it.
 ;;;
-;;; Otherwise, we bind *constants-being-created* and *constants-created-sense-
+;;; Otherwise, we bind *constants-being-created* and *constants-created-since-
 ;;; last-init* and compile the creation form a la load-time-value.  When this
 ;;; finishes, we tell the dumper to use that result instead whenever it sees
 ;;; this constant.
 ;;;
-;;; Now we try to compile the init form.  We bind *constants-created-sense-
+;;; Now we try to compile the init form.  We bind *constants-created-since-
 ;;; last-init* to NIL and compile the init form (and any init forms that were
 ;;; added because of circularity detection).  If this works, great.  If not,
 ;;; we add the init forms to the init forms for the object that caused the
 ;;; problems and let it deal with it.
 ;;; 
 (defvar *constants-being-created* nil)
-(defvar *constants-created-sense-last-init* nil)
-;;;
+(defvar *constants-created-since-last-init* nil)
+;;; 
 (defun emit-make-load-form (constant)
   (assert (fasl-file-p *compile-object*))
   (unless (fasl-constant-already-dumped constant *compile-object*)
     (let ((circular-ref (assoc constant *constants-being-created* :test #'eq)))
       (when circular-ref
-	(when (find constant *constants-created-sense-last-init* :test #'eq)
+	(when (find constant *constants-created-since-last-init* :test #'eq)
 	  (throw constant t))
 	(throw 'pending-init circular-ref)))
     (multiple-value-bind
@@ -1246,6 +1247,9 @@
 	(:ignore-it
 	 nil)
 	(t
+	 (compile-top-level-lambdas () t)
+	 (when (fasl-constant-already-dumped constant *compile-object*)
+	   (return-from emit-make-load-form nil))
 	 (let* ((name (let ((*print-level* 1) (*print-length* 2))
 			(with-output-to-string (stream)
 			  (write constant :stream stream))))
@@ -1254,8 +1258,8 @@
 			  (list constant))))
 	   (let ((*constants-being-created*
 		  (cons info *constants-being-created*))
-		 (*constants-created-sense-last-init*
-		  (cons constant *constants-created-sense-last-init*)))
+		 (*constants-created-since-last-init*
+		  (cons constant *constants-created-since-last-init*)))
 	     (when
 		 (catch constant
 		   (fasl-note-handle-for-constant
@@ -1268,7 +1272,7 @@
 	       (compiler-error "Circular references in creation form for ~S"
 			       constant)))
 	   (when (cdr info)
-	     (let* ((*constants-created-sense-last-init* nil)
+	     (let* ((*constants-created-since-last-init* nil)
 		    (circular-ref
 		     (catch 'pending-init
 		       (loop for (name form) on (cdr info) by #'cddr
-- 
GitLab