perm filename LUCITE.TXT[BB,DOC]4 blob sn#844909 filedate 1987-08-20 generic text, type C, neo UTF8
COMMENT ⊗   VALID 00032 PAGES
C REC  PAGE   DESCRIPTION
C00001 00001
C00006 00002	This file, LUCITE.TXT[BB,DOC] holds messages sent to the mailing list
C00007 00003	∂18-May-87  0811	FAHLMAN@C.CS.CMU.EDU 	Mailing List for Lucid Users
C00012 00004	∂20-May-87  1019	MCDONALD@C.CS.CMU.EDU 	Testing
C00013 00005	∂20-May-87  1114	MCDONALD@C.CS.CMU.EDU 	One more test.   
C00014 00006	∂22-May-87  0842	@C.CS.CMU.EDU:cole%dworkin.usc.edu@usc-oberon.arpa 	lucid   
C00016 00007	∂22-May-87  0944	@C.CS.CMU.EDU:cole%dworkin.usc.edu@usc-oberon.arpa 	lucid   
C00018 00008	∂22-May-87  1445	@C.CS.CMU.EDU:riedesel@aisunj.cs.uiuc.edu 	mailing list
C00020 00009	∂22-May-87  1457	@C.CS.CMU.EDU:riedesel@aisunj.cs.uiuc.edu 	sorry  
C00022 00010	∂22-May-87  1645	@C.CS.CMU.EDU:sundar@hermes.ai.mit.edu 	a question about versions
C00024 00011	∂26-May-87  0938	@C.CS.CMU.EDU:DALY@IBM.COM 	lucid on bsd 4.2 on rt
C00025 00012	∂26-May-87  0951	@C.CS.CMU.EDU:samalone@ATHENA.MIT.EDU 	Re: a question about versions  
C00027 00013	∂26-May-87  1403	@C.CS.CMU.EDU:bromley@think.com 	Cons monitoring  
C00029 00014	∂27-May-87  1155	@C.CS.CMU.EDU:Mailer@xx.lcs.mit.edu 	Cons monitoring   
C00032 00015	∂27-May-87  1511	@C.CS.CMU.EDU:samalone@ATHENA.MIT.EDU 	Re: lucid on bsd 4.2 on rt     
C00035 00016	∂29-May-87  0825	@C.CS.CMU.EDU:CAL@Think.COM 	Cons monitoring 
C00037 00017	∂29-May-87  2106	@C.CS.CMU.EDU:tsf@theory.cs.cmu.edu 	Should we post lisp bugs here?   
C00040 00018	∂05-Jun-87  1628	@C.CS.CMU.EDU:edsel!sunvalleymall!jlz@navajo.stanford.edu 	user group 
C00042 00019	∂16-Jun-87  1118	@C.CS.CMU.EDU:thoms@caen.engin.umich.edu 	OPS5    
C00044 00020	∂13-Jul-87  0918	@C.CS.CMU.EDU:skh@spice.cs.cmu.edu 	Sun Common Lisp 2.1 bug 
C00048 00021	∂13-Jul-87  2220	@C.CS.CMU.EDU,@RELAY.CS.NET:AIDEL@ecs.umass.edu 	Sun CommonLISP to SunCore Interface 
C00050 00022	∂05-Aug-87  0942	@C.CS.CMU.EDU:jpg@ALLEGHENY.SCRC.Symbolics.COM 	intercepting undefined function errors    
C00053 00023	∂05-Aug-87  1042	@C.CS.CMU.EDU:Dan@Think.COM 	intercepting undefined function errors   
C00057 00024	∂05-Aug-87  1136	@C.CS.CMU.EDU:bromley@Think.COM 	intercepting undefined function errors    
C00061 00025	∂05-Aug-87  1248	@C.CS.CMU.EDU:KAHLE@Think.COM 	intercepting undefined function errors 
C00066 00026	∂05-Aug-87  1618	@C.CS.CMU.EDU:Mailer@XX.LCS.MIT.EDU 	intercepting undefined function errors
C00069 00027	∂05-Aug-87  1911	@C.CS.CMU.EDU:DLA@DIAMOND.S4CC.Symbolics.COM 	intercepting undefined function errors 
C00073 00028	∂06-Aug-87  0744	@C.CS.CMU.EDU:gls@Think.COM 	intercepting undefined function errors   
C00077 00029	∂06-Aug-87  1104	@C.CS.CMU.EDU:primerd!Uenx@EDDIE.MIT.EDU 	Re: Intercepting undefined function errors 
C00079 00030	∂13-Aug-87  1646	@C.CS.CMU.EDU:tsf@theory.cs.cmu.edu 	Profiling and garbage collecting 
C00084 00031	∂13-Aug-87  1749	@C.CS.CMU.EDU:edsel!sunvalleymall!jlz@labrea.stanford.edu 	testing    
C00086 00032	∂14-Aug-87  0442	@C.CS.CMU.EDU:edsel!bhopal!jonl@labrea.stanford.edu 	AUTOLOADING [or "intercepting undefined function errors"]
C00093 ENDMK
C⊗;
This file, LUCITE.TXT[BB,DOC] holds messages sent to the mailing list
"lucites@c.cs.cmu.edu", which is for information related to Lucid Common
Lisp.  The first message (on the next page) describes the general facts
about the list.

∂18-May-87  0811	FAHLMAN@C.CS.CMU.EDU 	Mailing List for Lucid Users
Received: from C.CS.CMU.EDU by SAIL.STANFORD.EDU with TCP; 18 May 87  08:10:58 PDT
Received: ID <FAHLMAN@C.CS.CMU.EDU>; Mon 18 May 87 11:10:08-EDT
Date: Mon, 18 May 1987  11:10 EDT
Message-ID: <FAHLMAN.12303370022.BABYL@C.CS.CMU.EDU>
Sender: FAHLMAN@C.CS.CMU.EDU
From: "Scott E. Fahlman" <Fahlman@C.CS.CMU.EDU>
To:   Common-Lisp@SAIL.STANFORD.EDU, AIList@STRIPE.SRI.COM
Subject: Mailing List for Lucid Users


We have set up an ARPAnet mailing list, "lucites@c.cs.cmu.edu", for the
exchange of information related to Lucid Common Lisp.  This mailing list
is meant to function as a sort of informal users' group; it is not under
the control of Lucid, though some Lucid people will receive it.
"Lucites" is an appropriate channel for queries, programming hints, and
the sharing of software (large programs can be announced but should not
be distributed over this mailing list).  "Lucites" is not an appropriate
channel for bug reports, commercial announcements, or sales pitches.

Because our machine's capacity to forward mail is limited, we must
reserve the right to refuse any request to add more than two recipients
to the list from any given site; if you have three or more people who
want to receive this mail, you are expected to set up you own local
redistribution list or to direct the mail to a bulletin board that your
people can access.  (If anyone wants to set up a version of this list
without such restrictions, please contact us and we will gladly turn the
task over to you.)

To get your name on the list, send mail to
"lucites-request@c.cs.cmu.edu".  Requests sent to us personally will be
ignored.  Requests sent to the mailing list as a whole will result in
scorn and abuse being heaped upon you.  If any address on the list
starts bouncing mail sent to it, it will be excised from the list at
once.

Scott E. Fahlman
David B. McDonald

Computer Science Department
Carnegie-Mellon University

∂20-May-87  1019	MCDONALD@C.CS.CMU.EDU 	Testing
Received: from C.CS.CMU.EDU by SAIL.STANFORD.EDU with TCP; 20 May 87  10:19:15 PDT
Received: ID <MCDONALD@C.CS.CMU.EDU>; Wed 20 May 87 13:13:43-EDT
Date: Wed 20 May 87 13:12:40-EDT
From: David B. McDonald <David.McDonald@C.CS.CMU.EDU>
Subject: Testing
To: lucites@C.CS.CMU.EDU
Message-ID: <12303916632.18.MCDONALD@C.CS.CMU.EDU>

Now that several names have been added, I wanted to test the mailing
list.  Please ignore this message.
-------

∂20-May-87  1114	MCDONALD@C.CS.CMU.EDU 	One more test.   
Received: from C.CS.CMU.EDU by SAIL.STANFORD.EDU with TCP; 20 May 87  11:14:26 PDT
Received: ID <MCDONALD@C.CS.CMU.EDU>; Wed 20 May 87 14:12:19-EDT
Date: Wed 20 May 87 14:11:35-EDT
From: David B. McDonald <David.McDonald@C.CS.CMU.EDU>
Subject: One more test.
To: lucites@C.CS.CMU.EDU
Message-ID: <12303927356.18.MCDONALD@C.CS.CMU.EDU>

Please ignore.
-------

∂22-May-87  0842	@C.CS.CMU.EDU:cole%dworkin.usc.edu@usc-oberon.arpa 	lucid   
Received: from C.CS.CMU.EDU by SAIL.STANFORD.EDU with TCP; 22 May 87  08:42:04 PDT
Received: from oberon.USC.EDU by C.CS.CMU.EDU with TCP; Fri 22 May 87 11:40:17-EDT
Received: by oberon.USC.EDU (5.51/5.5) id AA00277; 
	Fri, 22 May 87 08:32:57 PDT
Received: by dworkin.usc.edu (4.12/SMI-3.0DEV3) id AA10137; 
                Fri, 22 May 87 08:32:50 pdt
Date: 22 May 1987 8:31-PDT
From: cole.%.dworkin%dworkin.usc.edu@usc-oberon.arpa
Subject: lucid
To: lucites@c.cs.cmu.edu
Message-Id: <87/05/22 0831.060@dworkin>

I would like to be included on the mailing list.
                         thx,
                           Bill
                          cole@dworkin.oberon.usc.edu

∂22-May-87  0944	@C.CS.CMU.EDU:cole%dworkin.usc.edu@usc-oberon.arpa 	lucid   
Received: from C.CS.CMU.EDU by SAIL.STANFORD.EDU with TCP; 22 May 87  09:43:47 PDT
Received: from oberon.USC.EDU by C.CS.CMU.EDU with TCP; Fri 22 May 87 12:41:36-EDT
Received: by oberon.USC.EDU (5.51/5.5) id AA00402; 
	Fri, 22 May 87 09:13:53 PDT
Received: by dworkin.usc.edu (4.12/SMI-3.0DEV3) id AA10195; 
                Fri, 22 May 87 09:13:46 pdt
Date: 22 May 1987 9:12-PDT
From: cole.%.dworkin%dworkin.usc.edu@usc-oberon.arpa
Subject: lucid
To: lucites@c.cs.cmu.edu
Message-Id: <87/05/22 0912.240@dworkin>

I would like to be included on the mailing list.
                         thx,
                           Bill
                          cole@dworkin.oberon.usc.edu

∂22-May-87  1445	@C.CS.CMU.EDU:riedesel@aisunj.cs.uiuc.edu 	mailing list
Received: from C.CS.CMU.EDU by SAIL.STANFORD.EDU with TCP; 22 May 87  14:45:13 PDT
Received: from a.cs.uiuc.edu by C.CS.CMU.EDU with TCP; Fri 22 May 87 17:44:02-EDT
Received: from aisunj.cs.uiuc.edu.cs.uiuc.e (aisunj.cs.uiuc.edu) by a.cs.uiuc.edu with SMTP (UIUC-5.52/9.7)
	id AA20030; Fri, 22 May 87 16:43:56 CDT
Received: by aisunj.cs.uiuc.edu.cs.uiuc.edu (1.1/9.6),
	id AA08934; Fri, 22 May 87 16:42:46 CDT
Date: Fri, 22 May 87 16:42:46 CDT
From: riedesel@aisunj.cs.uiuc.edu (Joel Riedesel)
Message-Id: <8705222142.AA08934@aisunj.cs.uiuc.edu.cs.uiuc.edu>
To: lucites@c.cs.cmu.edu
Subject: mailing list


Please add me to your mailing list:

riedesel@aisung.cs.uiuc.edu

Thanks.

∂22-May-87  1457	@C.CS.CMU.EDU:riedesel@aisunj.cs.uiuc.edu 	sorry  
Received: from C.CS.CMU.EDU by SAIL.STANFORD.EDU with TCP; 22 May 87  14:57:25 PDT
Received: from a.cs.uiuc.edu by C.CS.CMU.EDU with TCP; Fri 22 May 87 17:44:41-EDT
Received: from aisunj.cs.uiuc.edu.cs.uiuc.e (aisunj.cs.uiuc.edu) by a.cs.uiuc.edu with SMTP (UIUC-5.52/9.7)
	id AA20039; Fri, 22 May 87 16:44:30 CDT
Received: by aisunj.cs.uiuc.edu.cs.uiuc.edu (1.1/9.6),
	id AA08939; Fri, 22 May 87 16:43:20 CDT
Date: Fri, 22 May 87 16:43:20 CDT
From: riedesel@aisunj.cs.uiuc.edu (Joel Riedesel)
Message-Id: <8705222143.AA08939@aisunj.cs.uiuc.edu.cs.uiuc.edu>
To: lucites@c.cs.cmu.edu
Subject: sorry


sorry about that, I meant it to go to lucites-request.  Pleas ignore it.

∂22-May-87  1645	@C.CS.CMU.EDU:sundar@hermes.ai.mit.edu 	a question about versions
Received: from C.CS.CMU.EDU by SAIL.STANFORD.EDU with TCP; 22 May 87  16:45:21 PDT
Received: from hermes.ai.mit.edu by C.CS.CMU.EDU with TCP; Fri 22 May 87 19:44:01-EDT
Received: by hermes.ai.mit.edu; Fri, 22 May 87 19:08:13 EDT
Date: Fri, 22 May 87 19:08:13 EDT
From: sundar@hermes.ai.mit.edu (Sundar Narasimhan)
Message-Id: <8705222308.AA10171@hermes.ai.mit.edu>
To: lucites@hermes.ai.mit.edu
Subject: a question about versions

I thought I'd get some kind of discussion rolling with the following
question -- what version of Lucid's lisp are people currently using on
Sun-3's? Does anyone have a version yet, that has support for 
	a. X windows and
	b. stack groups? 

-Sundar


∂26-May-87  0938	@C.CS.CMU.EDU:DALY@IBM.COM 	lucid on bsd 4.2 on rt
Received: from C.CS.CMU.EDU by SAIL.STANFORD.EDU with TCP; 26 May 87  09:37:28 PDT
Received: from IBM.COM by C.CS.CMU.EDU with TCP; Tue 26 May 87 12:36:07-EDT
Date: 26 May 1987, 12:32:12 EDT
From: Timothy Daly <DALY@ibm.com>
To:   lucites@c.cs.cmu.edu
Message-Id: <052687.123213.daly@ibm.com>
Subject: lucid on bsd 4.2 on rt

Is there a version of Lucid Common Lisp that runs on
BSD 4.2 on the RT?

tim.
DALY@IBM.COM

∂26-May-87  0951	@C.CS.CMU.EDU:samalone@ATHENA.MIT.EDU 	Re: a question about versions  
Received: from C.CS.CMU.EDU by SAIL.STANFORD.EDU with TCP; 26 May 87  09:51:11 PDT
Received: from ATHENA (ATHENA.MIT.EDU) by C.CS.CMU.EDU with TCP; Tue 26 May 87 12:37:35-EDT
Received: by ATHENA (5.45/4.7)
	id AA16349; Tue, 26 May 87 12:38:04 EDT
From: <samalone@ATHENA.MIT.EDU>
Received: by HADES.MIT.EDU (5.45/4.7) id AA06649; Tue, 26 May 87 12:35:23 EDT
Message-Id: <8705261635.AA06649@HADES.MIT.EDU>
To: lucites@c.cs.cmu.edu
Subject: Re: a question about versions 
Date: Tue, 26 May 87 12:35:21 EDT


My research group (working on natural language processing) at MIT
Project Athena hopes to start using Lucid within the next few months.
Since Athena has been involved in the development of X, and since my
group plans to use the X window system to build its user interface, I
expect that we will develop our own Lucid interface to X if none is
otherwise available.  This will probably be distributed freely when it
is developed -- however, work on it hasn't even been started yet!

					--SAM

∂26-May-87  1403	@C.CS.CMU.EDU:bromley@think.com 	Cons monitoring  
Received: from C.CS.CMU.EDU by SAIL.STANFORD.EDU with TCP; 26 May 87  14:03:52 PDT
Received: from Think.COM by C.CS.CMU.EDU with TCP; Tue 26 May 87 17:02:30-EDT
Received: from urania.think.com (Lysippe.Think.COM) by Think.COM; Tue, 26 May 87 17:05:13 EDT
Received: by urania.think.com; Tue, 26 May 87 17:03:40 EDT
Date: Tue, 26 May 87 17:03:40 EDT
From: bromley@Think.COM
Message-Id: <8705262103.AA09433@urania.think.com>
To: lucites@Think.COM
Subject: Cons monitoring

Does anybody know of a way to find out how much consing occurs during the
evaluation of a form?  I would like something like the Symbolics time macro.

As a more general question, have people built any kind of performance monitoring
tools?

∂27-May-87  1155	@C.CS.CMU.EDU:Mailer@xx.lcs.mit.edu 	Cons monitoring   
Received: from C.CS.CMU.EDU by SAIL.STANFORD.EDU with TCP; 27 May 87  11:55:05 PDT
Received: from Think.COM by C.CS.CMU.EDU with TCP; Wed 27 May 87 14:53:48-EDT
Received: from XX.LCS.MIT.EDU by Think.COM; Wed, 27 May 87 14:42:53 EDT
Received: from LIVE-OAK.LCS.MIT.EDU by XX.LCS.MIT.EDU via Chaosnet; 27 May 87 14:36-EDT
Received: from PALLADIAN-JASPER.DialNet.Symbolics.COM by LIVE-OAK.LCS.MIT.EDU.ARPA via DIAL with SMTP id 44502; 27 May 87 14:35:40-EDT
Received: from WHITBY.Palladian.COM by JASPER.Palladian.COM via INTERNET with SMTP id 493; 27 May 87 13:13:43-EDT
Date: Wed, 27 May 87 13:13 EDT
From: Don Morrison <dfm@jasper.palladian.com>
Subject: Cons monitoring
To: bromley@think.com
Cc: lucites@think.com
In-Reply-To: <8705262103.AA09433@urania.think.com>
Message-Id: <870527131312.5.DFM@WHITBY.PALLADIAN.COM>
Reply-To: Don Morrison <DFM%JASPER@live-oak.lcs.mit.edu>

    Date: Tue, 26 May 87 17:03:40 EDT
    From: bromley@Think.COM

    Does anybody know of a way to find out how much consing occurs during the
    evaluation of a form?  I would like something like the Symbolics time macro.

Lucid LISP on Apollos reports consing as part of the time macro output.




∂27-May-87  1511	@C.CS.CMU.EDU:samalone@ATHENA.MIT.EDU 	Re: lucid on bsd 4.2 on rt     
Received: from C.CS.CMU.EDU by SAIL.STANFORD.EDU with TCP; 27 May 87  15:09:23 PDT
Received: from ATHENA (ATHENA.MIT.EDU) by C.CS.CMU.EDU with TCP; Wed 27 May 87 18:07:33-EDT
Received: by ATHENA (5.45/4.7)
	id AA08508; Wed, 27 May 87 18:08:39 EDT
From: <samalone@ATHENA.MIT.EDU>
Received: by HADES.MIT.EDU (5.45/4.7) id AA12981; Wed, 27 May 87 18:05:50 EDT
Message-Id: <8705272205.AA12981@HADES.MIT.EDU>
To: lucites@c.cs.cmu.edu
Cc: charlie@ATHENA.MIT.EDU, jhmurray@ATHENA.MIT.EDU, sfelshin@ATHENA.MIT.EDU
Subject: Re: lucid on bsd 4.2 on rt 
In-Reply-To: Your message of 26 May 87 00:00:00 +0000.
             <052687.123213.daly@ibm.com> 
Date: Wed, 27 May 87 18:05:49 EDT


	Is there a version of Lucid Common Lisp that runs on
	BSD 4.2 on the RT?

There is not a version of Lucid for an RT running 4.2.  MIT Project
Athena is currently negotiating with Lucid and IBM to have Lucid
ported to this environment, but IBM in Austin has so far refused to
release the "glue" code required for the port.

Charles Saltzbury is an IBM/Athena employee trying to get IBM in
Austin to release the glue code.  If you are actually interested in
licensing Lucid for an RT running 4.2, you might want to send him
mail.  The more demand he can show for the product, the better his
chance of convincing the powers that be.  His arpanet address is
"charlie@athena.mit.edu".

				--Stuart A. Malone

∂29-May-87  0825	@C.CS.CMU.EDU:CAL@Think.COM 	Cons monitoring 
Received: from C.CS.CMU.EDU by SAIL.STANFORD.EDU with TCP; 29 May 87  08:25:23 PDT
Received: from Think.COM by C.CS.CMU.EDU with TCP; Fri 29 May 87 11:23:19-EDT
Received: from kant by Think.COM via CHAOS; Thu, 28 May 87 21:49:42 EDT
Date: Thu, 28 May 87 21:47 EDT
From: Cliff Lasser <CAL@Think.COM>
Subject: Cons monitoring
To: DFM%JASPER@LIVE-OAK.LCS.MIT.EDU, bromley@think.com
Cc: lucites@think.com
In-Reply-To: <870527131312.5.DFM@WHITBY.PALLADIAN.COM>
Message-Id: <870528214727.3.CAL@KANT.THINK.COM>

    Date: Wed, 27 May 87 13:13 EDT
    From: Don Morrison <dfm@jasper.palladian.com>

	Date: Tue, 26 May 87 17:03:40 EDT
	From: bromley@Think.COM

	Does anybody know of a way to find out how much consing occurs during the
	evaluation of a form?  I would like something like the Symbolics time macro.

    Lucid LISP on Apollos reports consing as part of the time macro output.

You could hack cm:time to do some string hacking on the result of
(with-output-to-string (*standard-output*) (room t)).

∂29-May-87  2106	@C.CS.CMU.EDU:tsf@theory.cs.cmu.edu 	Should we post lisp bugs here?   
Received: from C.CS.CMU.EDU by SAIL.STANFORD.EDU with TCP; 29 May 87  21:06:00 PDT
Received: from Think.COM by C.CS.CMU.EDU with TCP; Sat 30 May 87 00:04:08-EDT
Received: from THEORY.CS.CMU.EDU by Think.COM; Sat, 30 May 87 00:07:22 EDT
Date: Saturday, 30 May 1987 00:04:17 EDT
From: Timothy.Freeman@theory.cs.cmu.edu
To: lucites@think.com
Subject: Should we post lisp bugs here?
Message-Id: <1987.5.30.4.0.58.Timothy.Freeman@theory.cs.cmu.edu>

Here's one, so you can decide.  If this group is for propagating
information about Lucid Common Lisp, then posting bugs fits my
interests.

This happened with Sun Common Lisp version 2.0.3.

Bug number: 56
Date found: 22 May 1987
Lisp version: 2.0.3
Unix release: 3.2
Discoverer: Tim Freeman
Brief description: 
   #', map, and labels interact incorrectly sometimes.

Terminal session:
   > (defun dagsave ()
     (labels
	 ((dagsaverec (form)
		      (when (equal form 3)
			(map 'nil #'dagsaverec '#(b)))))
       (dagsaverec 3)))
   DAGSAVE
   > (dagsave)
   NIL
   > (compile 'dagsave)
   ;;; Compiling function DAGSAVE...tail merging...assembling...(assembling...sharing code...)sharing code...emitting...done.
   DAGSAVE
   > (dagsave)
   >>Error: NIL cannot be called with 1 arguments
   unnamed function:
      Required arg 0 (G47): B
      Required arg 1 (FORM): #<Unknown-Object 302BEE>
   :A    Abort to Lisp Top Level

History of interaction with Sun:
   Reported 22 May 1987.  Sun was able to reproduce it with lisp
   version 2.0.5 as of 25 May 1987.

Known workarounds:
   Changing the occurrence of #'dagsave to #'(lambda (x) (dagsave x))
   causes the routine to complete normally.

∂05-Jun-87  1628	@C.CS.CMU.EDU:edsel!sunvalleymall!jlz@navajo.stanford.edu 	user group 
Received: from C.CS.CMU.EDU by SAIL.STANFORD.EDU with TCP; 5 Jun 87  16:28:18 PDT
Received: from navajo.stanford.edu by C.CS.CMU.EDU with TCP; Fri 5 Jun 87 19:26:53-EDT
Received: by navajo.stanford.edu; Fri, 5 Jun 87 16:23:39 PDT
Received: from sunvalleymall.edsel.uucp by edsel.uucp (3.2/SMI-2.0)
	id AA06653; Fri, 5 Jun 87 14:37:33 PDT
Received: by sunvalleymall.edsel.uucp (3.2/SMI-3.2)
	id AA01177; Fri, 5 Jun 87 14:38:03 PDT
Date: Fri, 5 Jun 87 14:38:03 PDT
From: edsel!sunvalleymall!jlz@navajo.stanford.edu (Jan Zubkoff)
Message-Id: <8706052138.AA01177@sunvalleymall.edsel.uucp>
To: navajo!lucites%c.cs.cmu.edu@navajo.stanford.edu
Subject: user group


Would you please add
edsel!lucites@navajo.stanford.edu
to the user's group mailing list?
Thanks.

---jan---

∂16-Jun-87  1118	@C.CS.CMU.EDU:thoms@caen.engin.umich.edu 	OPS5    
Received: from C.CS.CMU.EDU by SAIL.STANFORD.EDU with TCP; 16 Jun 87  11:18:28 PDT
Received: from caen.engin.umich.edu by C.CS.CMU.EDU with TCP; Tue 16 Jun 87 14:15:10-EDT
Received: by caen.engin.umich.edu (5.31/umix-2.0)
	id AA00219; Tue, 16 Jun 87 13:58:36 EDT
Date: Tue, 16 Jun 87 13:58:36 EDT
From: thoms@caen.engin.umich.edu (Dale E Thoms)
Message-Id: <8706161758.AA00219@caen.engin.umich.edu>
To: lucites@c.cs.cmu.edu
Subject: OPS5
Cc: kanya@caen.engin.umich.edu

   Does anyone know of an OPS5 interpreter written
in CommonLisp?  Any information you could give me
would be much appreciated.
  My net address is:
    
     thoms@caen.engin.umich.edu

  Thanks,
 
  Dale Thoms
  EECS Department
  University of Michigan
  

∂13-Jul-87  0918	@C.CS.CMU.EDU:skh@spice.cs.cmu.edu 	Sun Common Lisp 2.1 bug 
Received: from C.CS.CMU.EDU by SAIL.STANFORD.EDU with TCP; 13 Jul 87  09:18:12 PDT
Received: from Think.COM by C.CS.CMU.EDU with TCP; Mon 13 Jul 87 12:10:48-EDT
Received: from SPICE.CS.CMU.EDU by Think.COM; Mon, 13 Jul 87 11:29:30 EDT
Date: 13 Jul 1987 11:23-EDT 
From: Steve.Handerson@spice.cs.cmu.edu
To: alank@sun.com
Cc: fahlman@c.arpa, scherlis@c.arpa,
        edsel!sunvalleymall!hart@navajo.stanford.edu, rpg@sail.stanford.edu,
        lucites@think.com
Subject: Sun Common Lisp 2.1 bug
Message-Id: <553188196/skh@spice.cs.cmu.edu>

Folks, 

I'm the new coordinator for the  Sun Lisp beta release here at CMU.
I'm ccing this because my predecessor told me to -- hopefully whoever
knows of the bug can reply immediately.  
Let me know if you shouldn't/don't wanna be on the cclist.

One thing I don't know is how to get the patch version number.

Here's our initial bug report:

Bug number: <to be assigned>
Date found: 13 July 87
Lisp version: 2.1.1B, patch v?, patches 201011-pat, 1893, 1951, 1974, 1975
Unix release: 3.1
Discoverer:  Steve Handerson
Brief description: 
  char-code is broken for :target 68020.
Terminal session:
  File broken.lisp contains:
    (in-package "USER")
    (defun baz (huh)
      (char-code huh))
  Terminal interaction:
    > (Compile-file "/usr/skh/beta/broken.lisp")
    ;;; Reading input file #P"/usr/skh/beta/broken.lisp"
    ;;; Compiling function BAZ...assembling...
    >>Error: in lap: Unrecognized lap instruction: (LUCID::BFEXTU LUCID::D0 16 8 LUCID::D0)

    LUCID:COMPILE-FORM:

    :A    Abort to Lisp Top Level
    :C    will emit guaranteed illegal instruction
    -> 

History of interaction with Sun:
  Mailed 13 July 87.
Known workarounds:
  Don't do (compiler-options :target 68020), or do a
  (compiler-options :target '68K) to reset.


∂13-Jul-87  2220	@C.CS.CMU.EDU,@RELAY.CS.NET:AIDEL@ecs.umass.edu 	Sun CommonLISP to SunCore Interface 
Received: from C.CS.CMU.EDU by SAIL.STANFORD.EDU with TCP; 13 Jul 87  22:20:25 PDT
Received: from RELAY.CS.NET by C.CS.CMU.EDU with TCP; Tue 14 Jul 87 01:19:06-EDT
Received: from relay2.cs.net by RELAY.CS.NET id ae23834; 14 Jul 87 1:12 EDT
Received: from cs.umass.edu by RELAY.CS.NET id au17480; 14 Jul 87 1:05 EDT
Date:     Mon, 13 Jul 87 10:38 EST
From:     "Eugene C. Libardi, Jr. (413) 545-3599" <AIDEL%ecs.umass.edu@RELAY.CS.NET>
To:       lucites@C.CS.CMU.EDU
Subject:  Sun CommonLISP to SunCore Interface
X-VMS-To: CSNET%"lucites@c.cs.cmu.edu"

	I am trying to run SunCore from Sun CommonLISP (Lucid). Has anyone
done this? Ideally, I would also like to include either the Sunview window
interface (provided by Sun) or Lucid's Window Toolkit. Will this be a problem?
	Any info (people to contact, public domain code!) will be greatly
appreciated. Please respond directly to me and I will post the results if it
is warranted.

Thanks in advance,

Eugene C. Libardi, Jr.
Mechanical Design Automation Lab
Dept. of Mech. Eng.
University of Massachusetts
Amherst MA 01003
(413) 545-3599
aidel@umass-ece.csnet

∂05-Aug-87  0942	@C.CS.CMU.EDU:jpg@ALLEGHENY.SCRC.Symbolics.COM 	intercepting undefined function errors    
Received: from C.CS.CMU.EDU by SAIL.STANFORD.EDU with TCP; 5 Aug 87  09:42:51 PDT
Received: from ALLEGHENY.SCRC.Symbolics.COM ([128.81.41.45]) by C.CS.CMU.EDU with TCP; Wed 5 Aug 87 12:41:28-EDT
Received: from SPOONBILL.SCRC.Symbolics.COM by ALLEGHENY.SCRC.Symbolics.COM via CHAOS with CHAOS-MAIL id 55973; Wed 5-Aug-87 12:34:39 EDT
Date: Wed, 5 Aug 87 12:34 EDT
From: Jeffrey P. Golden <jpg@ALLEGHENY.SCRC.Symbolics.COM>
Subject: intercepting undefined function errors
To: lucites@c.cs.cmu.edu
Message-ID: <870805123416.3.JPG@SPOONBILL.SCRC.Symbolics.COM>

We are running Beta Version 2.00 on the Apollo.

As you may know, MACSYMA has long had an "autoload" feature 
whereby an "undefined function" may have an AUTOLOAD property 
which indicates a file which contains the function's definition. 
The file is loaded when a call to the undefined function is 
attempted.  (This scheme was very useful in the days of limited 
address space.  It is still used to autoload a few "share" files.)

To make it work under Lucid, we need a way to intercept 
undefined function errors.  (It would be interesting if Lucid had 
an autoload capability as did Maclisp, but I'm not expecting that.)
We are willing to intercept all errors if need be as long as we can 
detect which error we've got, handle those we can, and decline to 
handle the others. 

I cannot find the capability I need in the Lucid documentation. 
Can someone tell me if there is a way to do what I want in Lucid?

Also, is there a mailing list for asking questions like this 
directly of Lucid Inc.?

∂05-Aug-87  1042	@C.CS.CMU.EDU:Dan@Think.COM 	intercepting undefined function errors   
Received: from C.CS.CMU.EDU by SAIL.STANFORD.EDU with TCP; 5 Aug 87  10:42:29 PDT
Received: from Think.COM by C.CS.CMU.EDU with TCP; Wed 5 Aug 87 13:41:11-EDT
Return-Path: <Dan@Think.COM>
Received: from wittgenstein by Think.COM via CHAOS; Wed, 5 Aug 87 13:40:36 EDT
Date: Wed, 5 Aug 87 13:43 EDT
From: Dan Aronson <Dan@Think.COM>
Subject: intercepting undefined function errors
To: jpg@allegheny.scrc.symbolics.com
Cc: lucites@c.cs.cmu.edu
In-Reply-To: <870805123416.3.JPG@SPOONBILL.SCRC.Symbolics.COM>
Message-Id: <870805134302.2.DAN@WITTGENSTEIN.THINK.COM>

    Date: Wed, 5 Aug 87 12:34 EDT
    From: Jeffrey P. Golden <jpg@allegheny.scrc.symbolics.com>

    We are running Beta Version 2.00 on the Apollo.

    As you may know, MACSYMA has long had an "autoload" feature 
    whereby an "undefined function" may have an AUTOLOAD property 
    which indicates a file which contains the function's definition. 
    The file is loaded when a call to the undefined function is 
    attempted.  (This scheme was very useful in the days of limited 
    address space.  It is still used to autoload a few "share" files.)

    To make it work under Lucid, we need a way to intercept 
    undefined function errors.  (It would be interesting if Lucid had 
    an autoload capability as did Maclisp, but I'm not expecting that.)
    We are willing to intercept all errors if need be as long as we can 
    detect which error we've got, handle those we can, and decline to 
    handle the others. 

    I cannot find the capability I need in the Lucid documentation. 
    Can someone tell me if there is a way to do what I want in Lucid?

    Also, is there a mailing list for asking questions like this 
    directly of Lucid Inc.?



I have just written a handler for functions that are typed into the
wrong package (ie typeing (FOO) when you actually mean (SYSTEM::FOO))
that queries the user if FOO doesn't exist to ask if you actually meant
SYSTEM::FOO).  I did this by redefining SYMBOL-FUNCTION.  If you want
this code as an example let me know.

--Dan

∂05-Aug-87  1136	@C.CS.CMU.EDU:bromley@Think.COM 	intercepting undefined function errors    
Received: from C.CS.CMU.EDU by SAIL.STANFORD.EDU with TCP; 5 Aug 87  11:35:46 PDT
Received: from Think.COM by C.CS.CMU.EDU with TCP; Wed 5 Aug 87 14:32:56-EDT
Return-Path: <bromley@Think.COM>
Received: from lysippe.think.com by Think.COM; Wed, 5 Aug 87 14:32:45 EDT
Received: by lysippe.think.com; Wed, 5 Aug 87 14:32:41 EDT
Date: Wed, 5 Aug 87 14:32:41 EDT
From: bromley@Think.COM
Message-Id: <8708051832.AA00567@lysippe.think.com>
To: jpg@allegheny.scrc.symbolics.com
Cc: lucites@c.cs.cmu.edu
In-Reply-To: Jeffrey P. Golden's message of Wed, 5 Aug 87 12:34 EDT <870805123416.3.JPG@SPOONBILL.SCRC.Symbolics.COM>
Subject: intercepting undefined function errors

   Date: Wed, 5 Aug 87 12:34 EDT
   From: Jeffrey P. Golden <jpg@allegheny.scrc.symbolics.com>

   As you may know, MACSYMA has long had an "autoload" feature 
   whereby an "undefined function" may have an AUTOLOAD property 
   which indicates a file which contains the function's definition. 
   The file is loaded when a call to the undefined function is 
   attempted.  (This scheme was very useful in the days of limited 
   address space.  It is still used to autoload a few "share" files.)

   To make it work under Lucid, we need a way to intercept 
   undefined function errors.  (It would be interesting if Lucid had 
   an autoload capability as did Maclisp, but I'm not expecting that.)
   We are willing to intercept all errors if need be as long as we can 
   detect which error we've got, handle those we can, and decline to 
   handle the others. 

   I cannot find the capability I need in the Lucid documentation. 
   Can someone tell me if there is a way to do what I want in Lucid?


The error is "signalled" by symbol-function.  Try redefining symbol-function in
the following manner:

  (defvar *system-symbol-function* #'symbol-function)

  (defun symbol-function (symbol)
    (when (not (fboundp symbol))
      ;; Do autoloading here.
      ...)
    (funcall *system-symbol-function* symbol))

If Lucid provided a reasonable way to give advice (as in Symbolics advise) you
would use that instead of this rather ugly redefinition.


Mark Bromley

∂05-Aug-87  1248	@C.CS.CMU.EDU:KAHLE@Think.COM 	intercepting undefined function errors 
Received: from C.CS.CMU.EDU by SAIL.STANFORD.EDU with TCP; 5 Aug 87  12:47:57 PDT
Received: from Think.COM by C.CS.CMU.EDU with TCP; Wed 5 Aug 87 15:46:46-EDT
Return-Path: <KAHLE@Think.COM>
Received: from spinoza by Think.COM via CHAOS; Wed, 5 Aug 87 15:45:03 EDT
Date: Wed, 5 Aug 87 15:44 EDT
From: Brewster Kahle <KAHLE@Think.COM>
Subject: intercepting undefined function errors
To: jpg@allegheny.scrc.symbolics.com, lucites@c.cs.cmu.edu
In-Reply-To: <870805123416.3.JPG@SPOONBILL.SCRC.Symbolics.COM>
Message-Id: <870805154415.3.KAHLE@SPINOZA.THINK.COM>
Moon: 3 days, 18 hours, 57 minutes since the first quarter of the moon.

    Date: Wed, 5 Aug 87 12:34 EDT
    From: Jeffrey P. Golden <jpg@allegheny.scrc.symbolics.com>

    We are running Beta Version 2.00 on the Apollo.

    As you may know, MACSYMA has long had an "autoload" feature 
    whereby an "undefined function" may have an AUTOLOAD property 
    which indicates a file which contains the function's definition. 
    The file is loaded when a call to the undefined function is 
    attempted.  (This scheme was very useful in the days of limited 
    address space.  It is still used to autoload a few "share" files.)

I wrote a local hack that does the same thing, but in a different way:
Vdefun takes a function-name and a file-name (or system name).  It
creates a function that has the same name and takes &rest args.  The
function loads the file and recalls the function.  This takes alittle
more space than the maclisp property method, but it has the advantage that it
the compiler does not complain of undefined functions, it is easy to
write, and it works on any commonlisp.

My implementation does not deal with the source-file-name issue very
well (this is an issue on our locally hacked lucid, and symbolics
machines; hurray for meta-.)

I could send you the code, but I would rather someone rewrite it because
it is simple and mine is krufty.

    To make it work under Lucid, we need a way to intercept 
    undefined function errors.  (It would be interesting if Lucid had 
    an autoload capability as did Maclisp, but I'm not expecting that.)
    We are willing to intercept all errors if need be as long as we can 
    detect which error we've got, handle those we can, and decline to 
    handle the others. 

    I cannot find the capability I need in the Lucid documentation. 
    Can someone tell me if there is a way to do what I want in Lucid?

    Also, is there a mailing list for asking questions like this 
    directly of Lucid Inc.?

∂05-Aug-87  1618	@C.CS.CMU.EDU:Mailer@XX.LCS.MIT.EDU 	intercepting undefined function errors
Received: from C.CS.CMU.EDU by SAIL.STANFORD.EDU with TCP; 5 Aug 87  16:17:52 PDT
Received: from XX.LCS.MIT.EDU by C.CS.CMU.EDU with TCP; Wed 5 Aug 87 19:12:04-EDT
Received: from LIVE-OAK.LCS.MIT.EDU by XX.LCS.MIT.EDU via Chaosnet; 5 Aug 87 19:11-EDT
Received: from JASPER.Palladian.COM by MIT-LIVE-OAK.DialNet.Symbolics.COM via DIAL with SMTP id 54596; 5 Aug 87 19:10:30-EDT
Received: from WHITBY.Palladian.COM by JASPER.Palladian.COM via INTERNET with SMTP id 6729; 5 Aug 87 17:12:39-EDT
Date: Wed, 5 Aug 87 17:11 EDT
From: Don Morrison <dfm@JASPER.PALLADIAN.COM>
Subject: intercepting undefined function errors
To: bromley@Think.COM
cc: jpg@allegheny.scrc.symbolics.com, lucites@c.cs.cmu.edu
In-Reply-To: <8708051832.AA00567@lysippe.think.com>
Message-ID: <870805171141.3.DFM@WHITBY.PALLADIAN.COM>
Reply-To: Don Morrison <DFM%JASPER@LIVE-OAK.LCS.MIT.EDU>

    Date: Wed, 5 Aug 87 14:32:41 EDT
    From: bromley@Think.COM

       Date: Wed, 5 Aug 87 12:34 EDT
       From: Jeffrey P. Golden <jpg@allegheny.scrc.symbolics.com>

       As you may know, MACSYMA has long had an "autoload" feature 
       ...

    ...

    If Lucid provided a reasonable way to give advice (as in Symbolics advise) you
    would use that instead of this rather ugly redefinition.

At release 2.10 Lucid does provide defadvice.  See chapter 14 (Miscellaneous
Programming Features) in the "User's Guide" for details.  It appears to work fine,
'though the documentation has a couple of typos regarding its syntax, at least in the
version I've got (Apollo revision 01): the syntax description for defadvice is
missing a pair of parens, and that for advice-continue an &rest.


∂05-Aug-87  1911	@C.CS.CMU.EDU:DLA@DIAMOND.S4CC.Symbolics.COM 	intercepting undefined function errors 
Received: from C.CS.CMU.EDU by SAIL.STANFORD.EDU with TCP; 5 Aug 87  19:11:36 PDT
Received: from DIAMOND.S4CC.Symbolics.COM ([128.81.51.3]) by C.CS.CMU.EDU with TCP; Wed 5 Aug 87 22:10:36-EDT
Received: from LIMPKIN.S4CC.Symbolics.COM by DIAMOND.S4CC.Symbolics.COM via CHAOS with CHAOS-MAIL id 110949; Wed 5-Aug-87 20:44:54 EDT
Date: Wed, 5 Aug 87 20:45 EDT
From: David L. Andre <DLA@DIAMOND.S4CC.Symbolics.COM>
Subject: intercepting undefined function errors
To: KAHLE@Think.COM
cc: jpg@ALLEGHENY.SCRC.Symbolics.COM, lucites@c.cs.cmu.edu
In-Reply-To: <870805154415.3.KAHLE@SPINOZA.THINK.COM>
Message-ID: <870805204520.6.DLA@LIMPKIN.S4CC.Symbolics.COM>

    Date: Wed, 5 Aug 87 15:44 EDT
    From: Brewster Kahle <KAHLE@Think.COM>

	Date: Wed, 5 Aug 87 12:34 EDT
	From: Jeffrey P. Golden <jpg@allegheny.scrc.symbolics.com>

	We are running Beta Version 2.00 on the Apollo.

	As you may know, MACSYMA has long had an "autoload" feature 
	whereby an "undefined function" may have an AUTOLOAD property 
	which indicates a file which contains the function's definition. 
	The file is loaded when a call to the undefined function is 
	attempted.  (This scheme was very useful in the days of limited 
	address space.  It is still used to autoload a few "share" files.)

    I wrote a local hack that does the same thing, but in a different way:
    Vdefun takes a function-name and a file-name (or system name).  It
    creates a function that has the same name and takes &rest args.  The
    function loads the file and recalls the function.  This takes alittle
    more space than the maclisp property method, but it has the advantage that it
    the compiler does not complain of undefined functions, it is easy to
    write, and it works on any commonlisp.

I guess you would have a NOTINLINE declaration for the recursive call,
so that the compiler doesn't generate tail recursion.

∂06-Aug-87  0744	@C.CS.CMU.EDU:gls@Think.COM 	intercepting undefined function errors   
Received: from C.CS.CMU.EDU by SAIL.STANFORD.EDU with TCP; 6 Aug 87  07:44:51 PDT
Received: from Think.COM by C.CS.CMU.EDU with TCP; Thu 6 Aug 87 10:42:44-EDT
Return-Path: <gls@Think.COM>
Received: from boethius by Think.COM via CHAOS; Thu, 6 Aug 87 10:42:06 EDT
Date: Thu, 6 Aug 87 10:44 EDT
From: Guy Steele <gls@Think.COM>
Subject: intercepting undefined function errors
To: DLA@diamond.s4cc.symbolics.com, KAHLE@Think.COM
Cc: jpg@allegheny.scrc.symbolics.com, lucites@c.cs.cmu.edu, gls@Think.COM
In-Reply-To: <870805204520.6.DLA@LIMPKIN.S4CC.Symbolics.COM>
Message-Id: <870806104436.1.GLS@BOETHIUS.THINK.COM>

    Date: Wed, 5 Aug 87 20:45 EDT
    From: David L. Andre <DLA@diamond.s4cc.symbolics.com>

	Date: Wed, 5 Aug 87 15:44 EDT
	From: Brewster Kahle <KAHLE@Think.COM>

	    Date: Wed, 5 Aug 87 12:34 EDT
	    From: Jeffrey P. Golden <jpg@allegheny.scrc.symbolics.com>

	    We are running Beta Version 2.00 on the Apollo.

	    As you may know, MACSYMA has long had an "autoload" feature 
	    whereby an "undefined function" may have an AUTOLOAD property 
	    which indicates a file which contains the function's definition. 
	    The file is loaded when a call to the undefined function is 
	    attempted.  (This scheme was very useful in the days of limited 
	    address space.  It is still used to autoload a few "share" files.)

	I wrote a local hack that does the same thing, but in a different way:
	Vdefun takes a function-name and a file-name (or system name).  It
	creates a function that has the same name and takes &rest args.  The
	function loads the file and recalls the function.  This takes alittle
	more space than the maclisp property method, but it has the advantage that it
	the compiler does not complain of undefined functions, it is easy to
	write, and it works on any commonlisp.

    I guess you would have a NOTINLINE declaration for the recursive call,
    so that the compiler doesn't generate tail recursion.

This point about the use of NOTINLINE is very good, but I want to
clear up a point of terminology: "tail recursion" simply means that
the call is effected without net long-term growth of stack.  What is
meant here is something a bit stronger, namely that the compiler
translates a call as a jump back to the head of the code without
bothering to look in the function cell (which might have changed).
NOTINLINE is a reasonable means of suppressing that.
--Guy

∂06-Aug-87  1104	@C.CS.CMU.EDU:primerd!Uenx@EDDIE.MIT.EDU 	Re: Intercepting undefined function errors 
Received: from C.CS.CMU.EDU by SAIL.STANFORD.EDU with TCP; 6 Aug 87  11:04:34 PDT
Received: from EDDIE.MIT.EDU by C.CS.CMU.EDU with TCP; Thu 6 Aug 87 14:03:04-EDT
Received: by EDDIE.MIT.EDU with UUCP with smail2.3 with sendmail-5.45/4.7 id <AA20753@EDDIE.MIT.EDU>; Thu, 6 Aug 87 14:00:44 EDT
Received: by primerd.prime.com (3.2/SMI-3.0DEV3/smail)
	id AA11314; Thu, 6 Aug 87 11:16:59 EDT
Message-Id: <8708061516.AA11314@primerd.prime.com>
Received: (from user DOUG) by ENX.Prime.PDN; 06 Aug 87 11:03:13 EST
Subject: Re: Intercepting undefined function errors
To: lucites@c.cs.cmu.edu
From: primerd!DOUG@ENX.prime.com
Date: 06 Aug 87 11:03:14 EST

It would seem that redefining symbol-function is at best a poor man's 
solution.  The problem is that the compiler should (hopefully will) ignore
this by open coding function refs.  This means that the 'autoload' code will
only work in the interpreter.  The right solution is contributed by the 
current error proposal awaiting implementation.  This would allow user 
code to catch errors and define proceed functions as in the Symbolics
error handler style.

Doug

∂13-Aug-87  1646	@C.CS.CMU.EDU:tsf@theory.cs.cmu.edu 	Profiling and garbage collecting 
Received: from C.CS.CMU.EDU by SAIL.STANFORD.EDU with TCP; 13 Aug 87  16:45:52 PDT
Received: from Think.COM by C.CS.CMU.EDU with TCP; Thu 13 Aug 87 19:44:36-EDT
Return-Path: <tsf@theory.cs.cmu.edu>
Received: from THEORY.CS.CMU.EDU ([128.2.254.182]) by Think.COM; Thu, 13 Aug 87 19:44:35 EDT
Date: Thursday, 13 August 1987 19:45:10 EDT
From: Timothy.Freeman@theory.cs.cmu.edu
To: hotline@sun.com
Cc: fahlman@c.cs.cmu.edu, scherlis@c.cs.cmu.edu,
        edsel!sun-support@labrea.stanford.edu, rpg@sail.stanford.edu,
        lucites@Think.COM, James.reinders@SAM.CS.CMU.EDU
Subject: Profiling and garbage collecting
Message-Id: <1987.8.13.23.17.11.Timothy.Freeman@theory.cs.cmu.edu>

James Reinders (James.reinders@sam.cs.cmu.edu) is trying to write some
code to measure which user-written routines consume time with Sun
Common Lisp version 2.1.0 Beta.  His code works, except that when a
garbage collection happens, the routine that was executing gets
charged with the time consumed by the garbage collection.  He wants to
be able to measure the time spent by the garbage collection so that
the routine that was executing is not charged for it.  

Neither James nor I can figure out a way to do this.  Does anyone have
any ideas?

One thing he tried is to redefine the function system:gc so
that it does some accounting and then calls the garbage collector.
This loses miserably.  Here is the code he tried:

;;; -*- Mode: Lisp; Package: System; Syntax: Common-lisp; Base: 10. -*-

(in-package 'system)

(defun new-gc ()
    (system::old-gc))

(in-package 'user)

(defun setup ()
   (set (intern "*GCTIME*" 'user) 0)
   (if (not (fboundp 'system::old-gc))
       (setf (symbol-function 'system::old-gc) (symbol-function 'system::gc)))
   (setf (symbol-function 'system::gc) (symbol-function 'system::new-gc)))

(defmacro cgc() `(compile-file "~reinders/gc1.slisp"))
(defmacro lgc() `(load "~reinders/gc1"))

(defun mucho-cons( &rest args )
    (append (cons (apply #'+ args) '(1 2 3 -5))))

(defvar stuff '(0))

(defun doit ()
  (loop
   (setf stuff (apply #'mucho-cons stuff))))

And here's what happened:

;;; Sun Common Lisp, Beta Version 2.1.0B,  6-Jan-87
> (load "~/gc1")
#P"/usr/reinders/gc1.2bin"
> (setup)
#<Compiled-Function SYSTEM::NEW-GC 37B15F>
> (doit)
;;; GC: 10264 words [41056 bytes] of dynamic storage in use.
;;; 906988 words [3627952 bytes] of free storage available before a GC.
;;; 1824240 words [7296960 bytes] of free storage available if GC is disabled.

WARNING: The stack overflowed and was increased by #x10000 bytes.

WARNING: A serious error has occurred in the garbage collector.
You will probably lose this session.

WARNING: The stack overflowed and was increased by #x10000 bytes.

WARNING: A serious error has occurred in the garbage collector.
You will probably lose this session.

(((( etc. - infinitely ))))

∂13-Aug-87  1749	@C.CS.CMU.EDU:edsel!sunvalleymall!jlz@labrea.stanford.edu 	testing    
Received: from C.CS.CMU.EDU by SAIL.STANFORD.EDU with TCP; 13 Aug 87  17:49:06 PDT
Received: from labrea.stanford.edu by C.CS.CMU.EDU with TCP; Thu 13 Aug 87 20:48:03-EDT
Received: by labrea.stanford.edu; Thu, 13 Aug 87 17:08:34 PDT
Received: from sunvalleymall.edsel.com by edsel.uucp (3.2/SMI-2.0)
	id AA10569; Thu, 13 Aug 87 16:41:12 PDT
Received: by sunvalleymall.edsel.com (3.2/SMI-3.2)
	id AA03330; Thu, 13 Aug 87 16:41:31 PDT
Date: Thu, 13 Aug 87 16:41:31 PDT
From: edsel!sunvalleymall!jlz@labrea.stanford.edu (Jan Zubkoff)
Message-Id: <8708132341.AA03330@sunvalleymall.edsel.com>
To: sunvalleymall!lucitesbb@labrea.stanford.edu
Subject: testing

Please let me know if this message makes it to the Lucite mailing
list.

∂14-Aug-87  0442	@C.CS.CMU.EDU:edsel!bhopal!jonl@labrea.stanford.edu 	AUTOLOADING [or "intercepting undefined function errors"]
Received: from C.CS.CMU.EDU by SAIL.STANFORD.EDU with TCP; 14 Aug 87  04:41:57 PDT
Received: from labrea.stanford.edu by C.CS.CMU.EDU with TCP; Fri 14 Aug 87 07:40:48-EDT
Received: by labrea.stanford.edu; Fri, 14 Aug 87 04:01:11 PDT
Received: from bhopal.edsel.com by edsel.uucp (3.2/SMI-2.0)
	id AA11686; Fri, 14 Aug 87 04:25:26 PDT
Received: by bhopal.edsel.com (3.2/SMI-3.2)
	id AA05699; Fri, 14 Aug 87 04:25:42 PDT
Date: Fri, 14 Aug 87 04:25:42 PDT
From: edsel!bhopal!jonl@labrea.stanford.edu (Jon L White)
Message-Id: <8708141125.AA05699@bhopal.edsel.com>
To: labrea!jpg%ALLEGHENY.SCRC.Symbolics.COM@labrea.stanford.edu
Cc: labrea!lucites%c.cs.cmu.edu@labrea.stanford.edu
In-Reply-To: Your message of Wed, 5 Aug 87 12:34 EDT
Subject: AUTOLOADING [or "intercepting undefined function errors"]

Jeff, you may remember that I often criticized the idea of "hanging" Lisp 
features off the error handler.  Although during my time at MIT I was 
responsible for the MacLisp autoloading kludge that seemed to work this way,
I plead:
   (1) the limitations of a machine with a 256K virtual address space, and
   (2) the general ignorance of the early 1970's.
In fact, in Interlisp, there were several competing kludges hanging off
the error handler, and one could easily become confused as to just
which kludge would have priority!

Speaking, now, as one who has been around the Lisp community a long
time (rather than as a spokesman for Lucid), might I suggest that the
total number of autoloadable names in an application may well permit
a more space-consumptive solution.  What do you think, for example, of
the following approach:

    (defun set-up-autoloadable (fn-name path &optional module-name)
      ;; Calling this fn establishes a stub definition for 'fn-name', which
      ;;  just loads in the file containing its definition, and restarts
      ;;  the original call to 'fn-name'.
      (let ((name-and-path-data `#(,fn-name ,path ,module-name)))
        (define-function fn-name
            #'(lambda (&rest args) (do-autoloading name-and-path-data args)))
        fn-name))

    (defun do-autoloading (name-and-path-data args)
      ;; Use CL's "require" when possible, so that we don't spuriously
      ;;  load in a fruitless file.  Since the "stub" definition is unique,
      ;;  it will be replaced by something else in a successful loading.
      (let ((fn-name       (svref name-and-path-data 0))
            (path          (svref name-and-path-data 1))
            (module-name   (svref name-and-path-data 2)))
        (let ((old-proc (symbol-function fn-name)))
          (if module-name
              (require module-name path)
              (load path))
          (when (eq old-proc (symbol-function fn-name))
            (error "~&AUTOLOAD failure: no definition for ~S after loading ~S"
                   fn-name path))
          (apply (symbol-function fn-name) args))))


When these two "enabling" functions are compiled in Lucid Common Lisp, then 
each call to 'set-up-autoloadable' will cons only about 10 Q's (a Q is a 
pointer-sized quantum of memory).  This would be in addition to the amount 
of storage taken for the most minimal "database" to hold a mapping from 
symbols to file pathnames.  A little arithmetic will show that such 
"databasing" could easily cost 20 Q's per entry (depending on the length of
the symbol's name and the length of the file's name).  

To make 1000 functions "autoloadable" by this non-intrusive approach, the 
cost in storage  might be 30K words rather than 20K words.  Not a lot extra 
to pay for forgoing a Lisp-Lobotomy.   And after a disksave is done, the 
whole kit-and-kaboodle will put into "static" area; so there should be
relatively little impact on anything other than virtual memory consumption.


-- JonL --


P.S. Lexical closures really work.

∂20-Aug-87  1019	@C.CS.CMU.EDU:edsel!jack-jr!jeb@labrea.stanford.edu 	Re: Profiling and garbage collecting 
Received: from C.CS.CMU.EDU by SAIL.STANFORD.EDU with TCP; 20 Aug 87  10:19:30 PDT
Received: from labrea.stanford.edu by C.CS.CMU.EDU with TCP; Thu 20 Aug 87 13:18:20-EDT
Received: by labrea.stanford.edu; Thu, 20 Aug 87 10:14:58 PDT
Received: from jack-jr.edsel.com by edsel.uucp (3.2/SMI-2.0)
	id AA24925; Thu, 20 Aug 87 10:04:39 PDT
Received: by jack-jr.edsel.com (3.2/SMI-3.2)
	id AA00478; Thu, 20 Aug 87 10:04:52 PDT
Date: Thu, 20 Aug 87 10:04:52 PDT
From: edsel!jack-jr!jeb@labrea.stanford.edu (Jim Boyce)
Message-Id: <8708201704.AA00478@jack-jr.edsel.com>
To: jack-jr!lucitesbb@labrea.stanford.edu
Subject: Re: Profiling and garbage collecting

Concerning questions about metering the GC:
----------------
Return-Path: <tsf@theory.cs.cmu.edu>
Date: Thursday, 13 August 1987 19:45:10 EDT
From: labrea!Timothy.Freeman@theory.cs.cmu.edu
To: hotline@sun.com
Cc: fahlman@c.cs.cmu.edu, scherlis@c.cs.cmu.edu,
        edsel!sun-support@labrea.stanford.edu, rpg@sail.stanford.edu,
        lucites@Think.COM, James.reinders@SAM.CS.CMU.EDU
Subject: Profiling and garbage collecting

James Reinders (James.reinders@sam.cs.cmu.edu) is trying to write some
code to measure which user-written routines consume time with Sun
Common Lisp version 2.1.0 Beta.  His code works, except that when a
garbage collection happens, the routine that was executing gets
charged with the time consumed by the garbage collection.  He wants to
be able to measure the time spent by the garbage collection so that
the routine that was executing is not charged for it.  

Neither James nor I can figure out a way to do this.  Does anyone have
any ideas?

One thing he tried is to redefine the function system:gc so
that it does some accounting and then calls the garbage collector.
This loses miserably.  
	.
	.
	.
----------------
It appears that the code that did the accounting was consing.
Since it was called when there was no space available, it
triggered another GC recursively, and so on.

I do not know of a time function that does not cons.

The Release Notes for version 2.1 document that *gc-silence* can
have a value that is a compiled function.  When it is a function,
GC funcalls it instead of printing a message on the screen.  The
function should take a single argument, which argument will be
one of :before, :after, :reserved-expansion, or
:dynamic-expansion.  The function should use no more than about
1000 bytes of dynamic memory.  No object consed in dynamic space
by the function will survive the function call.

(This was originally intended to be used to let window-system
applications print the progress messages in visible windows.  It
was not intended to be a general purpose tool.)

If you write a function that saves, for example, the value
(logand #xFFFFFF (get-internal-real-time))
in the symbol *gc-start-time* when its argument is :before, and
that does appropriate things with other arguments, then you
should be able to get the measurements you want.


-jim