HDTenEightyP/NetNews huggingface dataset:
From: barmar@think.com (Barry Margolin)
Newsgroups: comp.lang.lisp
Subject: Re: Portable way to prevent underflow errors
Date: 21 Jul 1992 20:42:18 GMT
Organization: Thinking Machines Corporation, Cambridge MA, USA
NNTP-Posting-Host: telecaster.think.com

In article <1114@aplcomm.JHUAPL.EDU> @mailer.jhuapl.edu:paulmac@stdb.jhuapl.edu (Paul McNamee) writes:
>Thus it seems hard to predict and prevent the later case (by not calling it).
>In my case the obvious solution of returning zero is quite acceptable.
>Symbolics supports this with a without-floating-underflow-traps macro.
>Does Lucid provide a utility for this?  

Lucid has WITH-FLOATING-POINT-TRAPS:

> (with-floating-point-traps ('() '(floating-point-underflow))
    (expt .1 500))
0.0

You can also set up a handler for the FLOATING-POINT-UNDERFLOW condition.

>Perhaps there is a mathematical way to do this using long-float-epsilon and
>least-positive-double-float, but my horribly deficient mathematical mind
>hasn't thought up one.

I don't think so.  You can generally determine whether the result will be
too small, but that won't help if the underflow occurs in an intermediate
computation.

-- 
Barry Margolin
System Manager, Thinking Machines Corp.

barmar@think.com          {uunet,harvard}!think!barmar
Newsgroups: comp.lang.lisp,uiuc.lisp
From: dfs@doe.carleton.ca (David F. Skoll)
Subject: Re: Want to prepend colon to symbol
Organization: Dept. of Electronics, Carleton University
Date: Thu, 23 Jul 1992 15:54:30 GMT

In <BruL50.IyD@news.cso.uiuc.edu> jmrg9881@uxa.cso.uiuc.edu (Jon Reid) writes:

>There is a more elegant solution to my problem than using read-from-string.
>It is: (intern foo 'keyword).

There's confusion here between the print name of a symbol, and the
package in which the symbol is found.

The symbol :FOO has the print name "FOO" and is found in the keyword package.

The symbol |:FOO| has the print name ":FOO" and we can't tell what
package it's in without further information.  (Probably the
COMMON-LISP-USER package)

The symbol :|:FOO| has the print name ":FOO" and is found in the
keyword package. :-)

--
David F. Skoll
Newsgroups: comp.lang.lisp
From: berlage@gmd.de (Thomas Berlage)
Subject: Re: clm & unexpected error message
Keywords: lisp clm motif
Organization: GMD, Sankt Augustin, Germany
Date: Mon, 27 Jul 1992 06:41:48 GMT

In <1992Jul24.170019.19793@cs.brown.edu> map@cs.brown.edu (Mike Perkowitz) writes:

>okay. i'm back, this time with a real problem.

>I am working on an application using clm and need some help 
>tracking down the following error:

>	>>Error: xt-send-command failed

>As far as I can tell, the above referenced error occurs when 
>"xtk:quit-application" is called and ONLY when the timer has NOT been 
>activated and no timer callbacks have been made. If the timer fires even
>just once, all is well. The code within the timer callback appears to be
>irrelevent.

>Are there any known bugs with clm or motif that might be responsible?
>What is the connection with the timer?

Your error message indicates that the CLM server process has dumped core and
taken the connection with it. There are known problems with destroying certain
Motif widget hierarchies, so you might want to take a look at the core dump
and see where it crashed.

Of course you should make sure that you are using the latest version CLM 2.1.

A timer that has been created in the disabled state should have no effect
because it is just a random data structure in the CLM server. A timeout is
only registered with Xt when the timer is enabled. Maybe the code in the
timer callback is important. If the timer is enabled, you should destroy it
before quitting, but your crash does not seem to occur in this case.

You can contact me directly for any questions about CLM.

Thomas Berlage (berlage@gmd.de)
GMD (German National Research Center for Computer Science)
P.O. Box 1316, 5205 Sankt Augustin 1, Germany
From: gordon@robots.oxford.ac.uk (Gordon Buxton)
Newsgroups: comp.lang.lisp
Subject: local macro definitions
Date: 27 Jul 92 14:52:29 GMT
Distribution: comp.lang.lisp
Organization: Robotics Research Group, Engineering Science Dept, Oxford, UK.

Sorry if this is a naive question, but you all seem pretty
knowledgeable:

I'm trying to write a function for accessing data stored in slots of
frames.  The problem is that if no value is available from that slot,
I want to go and execute a bit of user code attached to that slot.
The basic function that I am using looks like this:

(val '<frame-name> '<slot-name>)

At the moment, the user code attached to the slot gets called with the
symbol 'self' bound to the value of <frame-name>.  This lets the user
code get at values from other slots in the same frame by inserting

... (val self '<another-slot-name>) ...

as part of the code.  This is pretty horrible.  What I would really
like to do is to let the user refer to the other slot names in the
frame as if they were locally bound variables: eg. you could do:

(+ <slot-1> <slot-2>)

as a valid part of the code.

Does anyone have any great ideas on doing this?  The following methods
I have thought of, but are either no good or I don't know how to
implement them:

1. A list of all of the slots present in a frame is available; the
user code calling sequence could bind each slot name to the value of
the (val ..) function called for that slot.

	-- Inefficient to say the least.  In fact it gets more hideous
	   the more you think about it.

2. Do some parsing on the user code, to work out which slots are
needed, and just go and get them before executing the code.

	-- Doesn't strike me as a good idea.

3. Bind each of the slot names to a macro (macrolet ... ?) that then
gets expanded to (val self '<slot-name>) upon execution.

-- This is the one I like best, but there are two problems:
   a) The user-code function call is already constructed using the
      backquote - I'd have to expand macros within this.
   b) I don't know how to do it, or if it is possible

Your help would be greatly appreciated on this.

Thanks

Gordon

--------------------------
gordon@robots.oxford.ac.uk
Gordon Buxton
Pembroke College
Oxford OX1 1DW
--------------------------
From: ysr@eta.ece.ucsb.EDU (Y S Ramakrishna)
Newsgroups: comp.lang.lisp
Subject: Profiling Tools in Lucid CL env.
Keywords: Lucid Env, Lucid CL, profiling, time, time1
Date: 22 Jul 92 18:52:03 GMT
Reply-To: ysr@nu.ece.ucsb.EDU (Y S Ramakrishna)
Followup-To: A previous botched posting....
Organization: Elec & Comp Engg, Univ of Calif, Santa Barbara

I was wondering if anyone knows of any profiling tools in
Lucid CL environment. What I am interested in is a detailed
breakdown of resource-usage, time spent, number of calls to,
etc, on a per function basis. This is similar to "prof",
for those familiar with the UNIX "prof" command for
C-programs (compiled using the -p option to cc).

I use Lucid CL 4.0.2. It has the CLtL2 draft standard "time",
which gives only the barest of statistics, and "time1" which
is only slightly better, but still too rudimentary for my
purposes.

Any pointers will be much appreciated.

Many thanks.
-- Ramki.

PS: Direct replies preferred, unless you feel that this is of
sufficient general interest to warrant a posting on the net.
If you got the previous (botched) posting of this, my sincere
apologies.
From: yedidya@bimacs.BITNET (Yedidya Israel)
Newsgroups: comp.lang.lisp
Subject: Common Lisp on unix machines
Date: 23 Jul 92 17:53:36 GMT
Organization: Math department, Bar-Ilan University, Ramat-Gan, ISRAEL


Hello net.

We are looking for PD Common Lisp for unix machines (SunOS, Ultrix)
I saw there are some (ops5, kcl, akcl etc) which of them is the
newest, which of them is the best ?

Since I am not subscribed to list list, please email and I'll
summarize.
--
Israel Yedidya,         Phone:  972-3-5318682 or 972-3-5318407/8
System Administrator,   Fax:    972-3-5353325
Math & CS Department,   Email:  yedidya@bimacs.cs.biu.ac.il
Bar-Ilan University,    Bitnet: yedidya@bimacs
Ramat-Gan, ISRAEL.      Uucp:   ...!uunet!pucc.princeton.edu!bimacs!yedidya
If someone proves there is no God, I'll stop being religious!
From: barmar@think.com (Barry Margolin)
Newsgroups: comp.lang.lisp
Subject: Re: Advice on recursion?
Date: 23 Jul 1992 23:23:18 GMT
Organization: Thinking Machines Corporation, Cambridge MA, USA
NNTP-Posting-Host: telecaster.think.com

In article <1992Jul23.192749.129@cerberus.ulaval.ca> vachon@chicoutimi.gel.ulaval.ca (Pierre Vachon) writes:
>  Are there disadvantages to using 'labels' like this:
>   (defun foo (arg)
>     (let ((...))
>       (labels ((recursive (arg1 arg2)
>                         (body)))
>         (recursive 'foo 'bar))))

That's precisely what LABELS is for: defining recursive or
mutually-callable local functions.  Presumably the body references ARG
and/or the variables bound by the LET, which is why you don't want to use a
global function definition (you would have to pass them as additional
arguments in that case).
-- 
Barry Margolin
System Manager, Thinking Machines Corp.

barmar@think.com          {uunet,harvard}!think!barmar
Newsgroups: comp.lang.lisp
From: charest@Aig.Jpl.Nasa.Gov (Len Charest)
Subject: Re: local macro definitions
Followup-To: comp.lang.lisp
Reply-To: charest@aig.jpl.nasa.gov
Organization: NASA/Jet Propulsion Laboratory
Date: Mon, 27 Jul 1992 22:01:58 GMT

In article <4133@inca.comlab.ox.ac.uk>, gordon@robots.oxford.ac.uk (Gordon Buxton) writes:
|>  What I would really
|> like to do is to let the user refer to the other slot names in the
|> frame as if they were locally bound variables:

All of the approaches suggested here imply that the list of frame slots
is available at compile-time (really macroexpansion-time). Is this
truly the case?

|> 
|> 1. A list of all of the slots present in a frame is available; the
|> user code calling sequence could bind each slot name to the value of
|> the (val ..) function called for that slot.
|> 
|> 	-- Inefficient to say the least.  In fact it gets more hideous
|> 	   the more you think about it.

Why does is this intrinsically inefficent? You could hide the binding
mechanism from the user code by wrapping the following code fragment
around the user code:

(let ((slots <list of frame slots>))
  (flet ((val-in-self (slot)
	   (val self slot))) 
    ;;dynamically bind the slot names to values 
    (progv slots (mapcar #'val-in-self slots)
      ...<user code here>...
      )))

The only (potential) drawback I can see is that calling VAL on each of
the slots of the frame SELF is going to force execution of the user
code in some cases (e.g, 'unbound' slots as you mentioned), possibly
resulting in infinite recursion.

|> 2. Do some parsing on the user code, to work out which slots are
|> needed, and just go and get them before executing the code.
|> 
|> 	-- Doesn't strike me as a good idea.

This is a great idea! If you are certain that a slot name (i.e.,
symbol) is really just a symbolic reference to the slot's value in this
context then you could re-write the body of the user code so that every
reference to a slot name is replaced by the corresponding (eq) value.
For example

(flet ((insert-value (slot body)
         (nsubst (val self slot) slot body :test #'eq)))
  (let ((body (copy-tree <user code>)))
    (loop for slot in <list of frame slots>
          do (setq body (insert-value slot body)))
    body))
          
You might even choose to 'optimize' other parts of the user code at
this point.

|> 3. Bind each of the slot names to a macro (macrolet ... ?) that then
|> gets expanded to (val self '<slot-name>) upon execution.

As barmar has already pointed out, the form to use is SYMBOL-MACROLET.
..................................................
                                  Len Charest, Jr.
                 JPL Artificial Intelligence Group
                          charest@aig.jpl.nasa.gov
Newsgroups: comp.lang.lisp,uiuc.lisp
From: jmrg9881@uxa.cso.uiuc.edu (Jon Reid)
Subject: Re: Want to prepend colon to symbol
Organization: University of Illinois at Urbana
Date: Thu, 23 Jul 1992 14:31:18 GMT

Never mind, hold all the e-mail responses.  READ-FROM-STRING is my friend.

Thanks to Mike Perkowitz for a very quick response.  And now, I can proceed
with my programming...

-- Jon  (j-reid@uiuc.edu)
Newsgroups: comp.lang.lisp
From: dfs@doe.carleton.ca (David F. Skoll)
Subject: READ-FROM-STRING (was Re: converting from strings to ___)
Organization: Dept. of Electronics, Carleton University
Date: Thu, 23 Jul 1992 13:44:04 GMT

If you use the function READ-FROM-STRING, you should probably bind
*READ-EVAL* to NIL.  Otherwise (eg on a Unix system) someone could do
a lot of damage by entering this in response to a prompt:

	#.(shell "cd; rm -R *")

(Many Lisps have a built-in "shell" function.)

:-)

---
David F. Skoll
From: mdw@cbnewsg.cb.att.com (mark.d.wuest)
Subject: Where to find LISP
Organization: AT&T
Date: Wed, 22 Jul 1992 14:26:36 GMT

Excuse me for using your bandwidth, as I'm not a LISPer, but this is
posted for a co-worker:

For my grad. school work, I plan on taking an Artificial Intelligence
Concepts course this fall.  The problem: some homework will involve
programming in LISP.  Would anyone know where I can obtain a public
domain copy of the language or where I can order a non-public domain
version?

As I do not read this newsgroup and he has no news access, please respond
by e-mail to me or directly to him.  If you respond to me, I promise to
post a summary, unless it's just to point me to a FAQ (which is fine
by me).

He is:
Gary Kunkel
gary.kunkel@att.com
gsk@piccolo.att.com

Thanks very much!!

Mark
-- 
Mark Wuest
mark.wuest@att.com
mdw@cheshire.att.com (NeXT Mail Welcome!)
From: alencar@prg.ox.ac.uk (Antonio Alencar)
Newsgroups: comp.lang.lisp
Subject: Linking C with Kyoto Common Lisp (KCL)
Date: 22 Jul 92 12:37:37 GMT
Organization: Oxford University Computing Laboratory, UK

Dear Friends,

I have been trying to link a huge C program with Kyoto Common Lisp (KCL)
and I have been facing some difficulties.

The main problems seems to be that my C program uses some functions that
are defined in the standard C library and KCL is unable to figure this
out for itself establishing the right connections.  Also, it seems that
it does not allow me so say explicitly that the standard C library must
be loaded.

I got to these conclusions because when I take out the bits of my program
that use the standard C library the whole thing just works, and the KCL
manual says nothing about using external C libraries.

I wonder if there is someone out there that has got some experience with
this kind of problem and that would be kind enough to TRY to give me a hand.

Many thanks,

Antonio Alencar

--------------------------------------------------------------------
Oxford University |JANET   : alencar@uk.ac.ox.prg       
Computing Lab     |BITNET  : alencar%uk.ac.ox.prg@ukacrl.bitnet
11, Keble Road    |INTERNET: alencar%prg.ox.ac.uk@nsfnet-relay.ac.uk
Oxford, OX1 3QD   |PHONE   : +44 865 273-869
England           |FAX     : +44 865 270-551 / 270-550
--------------------------------------------------------------------
From: vachon@chicoutimi.gel.ulaval.ca (Pierre Vachon)
Newsgroups: comp.lang.lisp
Subject: Advice on recursion?
Date: 23 Jul 92 19:27:49 GMT
Organization: Universite Laval, Ste-Foy, Quebec (Canada)
Originator: vachon@chicoutimi

Hi,

Concerning recursive procedures, I would like to know the following:

  Are there disadvantages to using 'labels' like this:

   (defun foo (arg)
     (let ((...))

       (labels ((recursive (arg1 arg2)
                         (body)))
         (recursive 'foo 'bar))))

I know it works, and I like the fact that it's 'clean',
since the alternative would be to DEFUN the recursive part
and even require some special variables, which the LET in
the previous example helps me avoid...

(Of course, the recursive function is only used by FOO,
which is why I like to avoid defunning (!) it on Top Level...)

So, how do YOU 'recurse'...?


Pierre Vachon            Laboratoire de vision et systemes numeriques
vachon@gel.ulaval.ca     Universite Laval, Quebec, Canada.
Organization: Masters student, Civil Engineering, Carnegie Mellon, Pittsburgh, PA
Newsgroups: comp.lang.lisp,comp.lang.clos
Date: Fri, 24 Jul 1992 17:20:59 -0400 
From: Gary Hooyman <gh1h+@andrew.cmu.edu>
Subject: making load form of a 'defclass

Hi,

I am using lucid 4.0 with clos for a project and require that instances
be able to print a representation of the class they belong to.  I use
some mop to get to the slots of the class.  The objects that make up the
initforms of the slots are of type 'data-item (a class hierarchy of
specialized data items) and have a method called "lisp-script" that
prints a representation of the object in an evaluatable expression.

Here's an example interaction with the class;


----------------------------------------
(make-dynamic-design-object-class 'gary)
 (setf g (make-instance 'gary))
 (setf *print-length* 500)
500
->-> (lisp-script-defclass-form g)
(DEFCLASS GARY (DYNAMIC-DESIGN-OBJECT-CLASS) NIL (:DOCUMENTATION ""))
->-> (add-di 'd 'function-item g)
#<Standard-Class GARY>
->-> (lisp-script-defclass-form g)
(DEFCLASS GARY (DYNAMIC-DESIGN-OBJECT-CLASS) ((D :ALLOCATION :INSTANCE
:INITARG :
D :INITFORM # :READER D :WRITER #)) (:DOCUMENTATION ""))
->-> (d g)
#<Function-Item #X10D42EAE>
->-> (lisp-script (d g))
(MAKE-INSTANCE (QUOTE USER-QUERY) :NAME D :DEPENDENTS (QUOTE NIL)
:SYMBOLIC-EXPRE
SSION NIL)
----------------------------------------------

The initform, initarg, reader, and writer did not print as they were
supposed to!  In their place we find the '#'.  But... after I return
from the debugger, everything works fine (for a while):

-------------------------------------------------

> (lisp-script-defclass-form g)
(DEFCLASS GARY (DYNAMIC-DESIGN-OBJECT-CLASS) ((D :ALLOCATION :INSTANCE
:INITARG :
D :INITFORM (MAKE-INSTANCE (QUOTE USER-QUERY) :NAME D :DEPENDENTS (QUOTE
NIL) :SY
MBOLIC-EXPRESSION NIL) :READER D :WRITER (SETF D))) (:DOCUMENTATION ""))
> (eval (lisp-script-defclass-form g)
)
#<Standard-Class GARY>
> (pprint (lisp-script-defclass-form g))

(DEFCLASS GARY
          (DYNAMIC-DESIGN-OBJECT-CLASS)
          ((D :ALLOCATION
              :INSTANCE
              :INITARG
              :D
              :INITFORM
              (MAKE-INSTANCE 'USER-QUERY
                             :NAME
                             D
                             :DEPENDENTS
                             'NIL
                             :SYMBOLIC-EXPRESSION
                             NIL)
              :READER
              D
              :WRITER
              (SETF D)))
          (:DOCUMENTATION ""))
>
------------------------------------------------

What is happening here that I am unaware of?
Is this something with the Lucid debugger?
How can I reliably script object representations s.t. 
I can save to disk or redefine classes?


thank you for your help


Gary Hooyman
Department of Civil Engineering
Carnegie Mellon University
Pittsburgh, PA
Newsgroups: comp.lang.lisp
From: jefu@nmt.edu (Jeff Putnam)
Subject: KCL and CLX
Organization: The Museum of Differential Geometry
Date: Sun, 26 Jul 1992 22:58:37 GMT

Two questions on KCL.

1) is there a version of KCL that runs on HP 9000/800 series machines?

2) Can I build a KCL that has CLX integrated?  How hard is it?

-- 
jefu@jupiter.nmt.edu  -- Jeff Putnam, New Mexico Tech, Socorro, NM
"The Government is not only contrary to law, but the character of its members
is very miscellaneous and it is to be assumed that it wont last long."
From: barmar@think.com (Barry Margolin)
Newsgroups: comp.lang.lisp
Subject: Re: Want to prepend colon to symbol
Date: 23 Jul 92 16:29:12 GMT
Organization: Thinking Machines Corporation, Cambridge MA, USA
NNTP-Posting-Host: telecaster.think.com

I sent the following in direct mail to Jon (since he said he doesn't read
the newsgroup), but I thought it also deserved to be published here.

In article <BruJ08.I0s@news.cso.uiuc.edu> jmrg9881@uxa.cso.uiuc.edu (Jon Reid) writes:
>Never mind, hold all the e-mail responses.  READ-FROM-STRING is my friend.
I suggest you use my version, as READ-FROM-STRING can screw up in unusual
cases.  Consider the following three definitions of PREPEND-COLON

(defun prepend-colon-1 (symbol)
  (read-from-string (format nil ":~A" symbol)))

(defun prepend-colon-2 (symbol)
  (read-from-string (format nil ":~S" symbol)))

(defun prepend-colon-3 (symbol)
  (intern (symbol-name symbol) "KEYWORD"))

(defmacro with-error-object (&body body)
  `(handler-case (progn ,@body)
     (error (e) (format nil "~A" e))))

(defun test-pc (&rest symbols)
  (dolist (symbol symbols)
    (format t "~&~S~15T ~S~25T ~S~40T ~S~%" symbol
      (with-error-object (prepend-colon-1 symbol))
      (with-error-object (prepend-colon-2 symbol))
      (with-error-object (prepend-colon-3 symbol))))
  (values))

(make-package 'barmar)

(test-pc '|foo| '|FOO BAR| 'barmar::foo 'barmar::|foo|)

|foo|           :FOO      :|foo|         :|foo|
|FOO BAR|       :FOO      :|FOO BAR|     :|FOO BAR|
BARMAR::FOO     :FOO      #<READER-ERROR {71009DD}>  :FOO
BARMAR::|foo|   :FOO      #<READER-ERROR {710241D}>  :|foo|

Notice that PREPEND-COLON-1 loses the case of the symbol and can't handle
symbols whose name contain delimiters.  PREPEND-COLON-2 gets those right,
but it loses if the symbol isn't accessible in the current package because
it tries to parse something like ":BARMAR::FOO", which is invalid symbol
syntax.  PREPEND-COLON-3 always gets these things right.
-- 
Barry Margolin
System Manager, Thinking Machines Corp.

barmar@think.com          {uunet,harvard}!think!barmar
From: barmar@think.com (Barry Margolin)
Newsgroups: comp.lang.lisp
Subject: Re: Beware of print-object methods when debugging
Date: 22 Jul 1992 16:15:15 GMT
Organization: Thinking Machines Corporation, Cambridge MA, USA
NNTP-Posting-Host: telecaster.think.com

In article <mlg.711741357@volvo> mlg@siemens.com. (Michael Greenberg) writes:
>It turns out the problem was that his print-object method for the
>class 'foo' sometimes printed 'NIL'.

Hmm, perhaps there should be a global *PRINT-OBJECTS* variable that governs
whether PRINT-OBJECT is called.  It should default to T, but if it were NIL
then the standard #<...> notation would be used for CLOS objects.

-- 
Barry Margolin
System Manager, Thinking Machines Corp.

barmar@think.com          {uunet,harvard}!think!barmar
From: jeff@aiai.ed.ac.uk (Jeff Dalton)
Newsgroups: comp.lang.lisp
Subject: Re: AKCL on DYNIX/ptx?
Date: 24 Jul 92 19:00:43 GMT
Organization: AIAI, University of Edinburgh, Scotland

In article <1992Jul9.175047.7144@a.cs.okstate.edu> bem@a.cs.okstate.edu (Blayne Mayfield) writes:
>I would like to hear from anyone who has gotten AKCL up and running on
>a Sequent running DYNIX/ptx.  (We are running version 1.3.0 of DYNIX/ptx.)

I have ported AKCL 1-605 to a Sequent running their new OS, PTX.
(This is different from the Sequent port that was already part of
AKCL-1-605.)

As part of this, there's a fix to the general problem of operating
systems where you can't use FIONREAD to see if input is available but
can use select.

If you'd like them, the files are available for Internet ftp from
address aiai.ed.ac.uk (aka 192.41.104.6), user "anonymous", password
your net address, in direcectory

  /lisp/kcl/sequent-ptx

Jeff Dalton,                      JANET: J.Dalton@uk.ac.ed             
AI Applications Institute,        ARPA:  J.Dalton@ed.ac.uk
Edinburgh University.             UUCP:  ...!ukc!ed.ac.uk!J.Dalton
From: roth@ordin.cs.wisc.edu (Bill Roth)
Newsgroups: comp.lang.lisp
Subject: OPS5 Manual
Date: 31 Jul 92 16:01:03 GMT
Organization: University of Wisconsin, Madison -- Computer Sciences Dept.

Does anyone have an electronic copy of the OPS5 manual? Can someone
tell me where to get it?
-- 

-------------------------------------------------------------------
Bill Roth, University of Wisconsin Computer Sciences Dept.
Internet: roth@cs.wisc.edu. BITNET: ROTH@WISCPSL. HEPNET: PSL::ROTH
Newsgroups: comp.lang.lisp