HDTenEightyP/NetNews huggingface dataset:
From: barmar@think.com (Barry Margolin)
Newsgroups: comp.lang.lisp
Subject: Re: floating point precision
Date: 15 Aug 1992 08:55:48 GMT
Organization: Thinking Machines Corporation, Cambridge MA, USA
NNTP-Posting-Host: gandalf.think.com

In article <1992Aug14.175857.7314@cs.yale.edu> yip-ken@CS.YALE.EDU (ken yip) writes:
>That's what I hope is the case.  But apparently in the Lucid implementation,
>all floats are automatically coerced into double-float (51-bit precision).
>E.g.  (* 1.2 3.4)
>will still return a float with 51-bit precision.  Correct me
>if I am wrong on this.   So my questions are:
>(1) Can one emulate 13-bit or 24-bit precision in Lucid? (2) Which
>lisp implementation actually does what Barry said?

This depends on the architecture.  LCL/SPARC only has one float type, and
it's double precision (except they have a special exception for arrays of
single floats, but they're converted to double floats when they're
extracted).  I think LCL/VAX only has single precision floats.  Common Lisp
permits an implementation to implement any subset of the four float types,
and Lucid generally only implements one of them.

In an implementation that doesn't have all four float types, some of the
type names are synonyms.  In Lucid, they are all synonyms for FLOAT.

Symbolics impements all four floating point types.

I don't think there's an easy way to get an implementation that only has
one floating point type to emulate the others.  Complain to Lucid.
-- 
Barry Margolin
System Manager, Thinking Machines Corp.

barmar@think.com          {uunet,harvard}!think!barmar
From: yeh@cs.purdue.EDU (Wei Jen Yeh)
Newsgroups: comp.lang.lisp
Subject: Re: portable O(1) strlen
Summary: Solution found.
Keywords: strlen, format, AKCL
Date: 13 Aug 92 07:50:02 GMT
Organization: Department of Computer Science, Purdue University

In article <19247@ector.cs.purdue.edu>, I wrote...
> Hello,
>   I just found a bug in my program caused by thinking that
> 	(array-dimension (format NIL "1234") 0) = 4.
> ...
> 
> So, is there a portable O(1) STRLEN?
> 

Thanks. I found the answer --- LENGTH.

Wei Jen Yeh                      yeh@cs.purdue.edu
                                 Department of Computer Science
                                 Purdue University
                                 West Lafayette, Indiana
From: barmar@think.com (Barry Margolin)
Newsgroups: comp.lang.lisp
Subject: Re: run-program in kcl
Date: 14 Aug 1992 08:10:44 GMT
Organization: Thinking Machines Corporation, Cambridge MA, USA
NNTP-Posting-Host: gandalf.think.com
Keywords: run-program, common lisp, kcl, load.

In article <1992Aug13.194657.6098@cs.albany.edu> saxena@cs.albany.edu (Tushar Saxena) writes:
>There is a function in common lisp called RUN-PROGRAM in Sun Common Lisp.

This isn't a Common Lisp function, it's a Lucid extension.

>First of all, has anyone ever heard of it? Secondly, what does this
>function do? 

It runs a normal Unix program, as if you'd executed it from the shell.  It
can optionally connect the input and/or output streams of the program to
Lisp streams.  It's fully documented in the Working Beyond the Lisp
Environment section of the Advanced User's Guide chapter of the manual.

>	      And lastly, what is its counterpart in kcl. I know for sure
>that my version of kcl does not support it.

There probably isn't a direct counterpart in KCL, since KCL doesn't provide
many extensions to CL.  The closest thing is probably calling the Unix
execlp(3) function.

>Another thing that I would like to know is about the -load option of invoking
>common lisp. In common lisp, you can invoke lisp by an option -load <filename>
>which will load a given file into the interpreter before getting into it. I
>was wondering what its counterpart in kcl is. I know (again) for sure that
>my version of kcl does not do anything for -load or -l.

Common Lisp doesn't specify anything about how Lisp is started, let alone
comand line options.  This is another Lucid extension.  There may not be a
KCL facility like this.
-- 
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: need some help with conditions and CLIM
Date: 21 Aug 92 03:18:14 GMT
Distribution: comp
Organization: Thinking Machines Corporation, Cambridge MA, USA
NNTP-Posting-Host: gandalf.think.com

In article <CHYDE.92Aug20142411@pecos.ads.com> chyde@pecos.ads.com (Clinton Hyde) writes:
>at the moment, I'm getting a ABORT or some sort signalled out of
>CLIM's accepting-values, but if I use handler-case to try to grab it,
>I seem to have the wrong name or something. so what I need today is to
>know what gets signalled when I click on the <abort> exit-box. for the
>future I'd like to know how to find ANYTHING that's signalled.

If it's done correctly, aborting should be implemented by invoking a
restart, not by signalling a condition.  If you want to establish a handler
for this, you can use WITH-SIMPLE-RESTART or RESTART-CASE, specifying the
restart named ABORT.

You'll have to do this inside the ACCEPTING-VALUES, since ACCEPTING-VALUES
presumably sets up its own ABORT restart, and the innermost one is the one
that will be invoked.

It's also possible that ACCEPTING-VALUES is using some other mechanism to
implement the exit boxes.  It could just be doing a RETURN-FROM.

I don't know of a way to find out what restarts or other exit mechanisms
are being invoked, the way you can for conditions being signalled.  And if
it's using a lexical mechanism like GO or RETURN-FROM, there's no way for
you to intercept it even if you do find out.

-- 
Barry Margolin
System Manager, Thinking Machines Corp.

barmar@think.com          {uunet,harvard}!think!barmar
From: ojuarez@mtecv2.mty.itesm.mx (Octavio Juarez Espinosa)
Newsgroups: comp.lang.lisp
Subject: looking information about lambda calculus
Summary: help
Keywords: lambda calculus
Date: 19 Aug 92 03:42:16 GMT
Organization: I.T.E.S.M. Campus Monterrey



Hi,

I'll appreciate if you send me some regerences about lamda calculus for
beginers.

Thanks in advanace.

Sincerely,

Octavio Juarez Espinosa

-- 
Octavio Juarez Espinosa
Gabriel Valerio 1134 
Saltillo, Coahuila    CP 25000
Mexico  email ojuarez@mtecv2.mty.itesm.mx
Newsgroups: comp.lang.lisp
From: rdavis@jhunix.hcf.jhu.edu (Robert Davis)
Subject: Wanted: SPICE LISP Version M3
Organization: HAC - Johns Hopkins University, Baltimore
Date: Sat, 15 Aug 1992 06:54:43 GMT

Could anyone please point me in the direction to finding a copy of the
SPICE LISP software, Version M3, that will run on a PERQ graphics
workstation running the version S6 of the Accent operating system?
Does anyone know if a version of SIPCE LISP that would run under Accent
S7 was produced?  No, this posting is _not_ a joke; I am still using
a PERQ :-) and would like to obtain a version of SPICE-LISP that will
run under a later version of Accent.  Having to have several OS versions
on the hard disk can be a real disk-space waster.  Thanks in advance
for any help with this!  





-- 
============================================================================
Robert D. Davis            |        
rdavis@jhunix.hcf.jhu.edu  !     HELP!  Martians have landed on
uunet!mystica!rdd          |     /dev/rfp021 and they're getting dizzy!
From: barmar@think.com (Barry Margolin)
Newsgroups: comp.lang.lisp
Subject: Re: portable O(1) strlen
Date: 13 Aug 1992 09:18:05 GMT
Organization: Thinking Machines Corporation, Cambridge MA, USA
NNTP-Posting-Host: gandalf.think.com
Keywords: strlen, format, AKCL

In article <19247@ector.cs.purdue.edu> yeh@cs.purdue.EDU (Wei Jen Yeh) writes:
>Hello,
>  I just found a bug in my program caused by thinking that
>	(array-dimension (format NIL "1234") 0) = 4.

Is FORMAT returning a longer string with a fill pointer?  I thought that
functions that create strings were supposed to return simple strings.  What
Lisp does this?

>So, is there a portable O(1) STRLEN?

LENGTH is O(1) when the argument is a vector, although the coefficient will
usually be higher than ARRAY-DIMENSION, since it has to check whether the
argument is a vector or list, and whether it has a fill pointer.
-- 
Barry Margolin
System Manager, Thinking Machines Corp.

barmar@think.com          {uunet,harvard}!think!barmar
From: gh1h+@andrew.cmu.edu (Gary Hooyman)
Newsgroups: comp.lang.lisp
Subject: Re: power
Date: 19 Aug 92 08:20:55 GMT
Article-I.D.: andrew.seYbHbe00iUz02m3Al
Organization: Masters student, Civil Engineering, Carnegie Mellon, Pittsburgh, PA

Hello:

My problem with (expt base-number exponent-number) has occurred on Lucid
4.0 running on a DEC 5000/120.  I am convinced that the problem is a bug
in my copy and I'll have to patch in a fix.  Can anyone give me one?

Thank you for your replies to my previous post.


Gary Hooyman
Department of Civil Engineering
Carnegie Mellon University
Pittsburgh, PA
Xref: sparky comp.lang.lisp:2216 news.answers:2477
From: chyde@pecos.ads.com (Clinton Hyde)
Newsgroups: comp.lang.lisp
Subject: Re: Comparison BTW Franz/Lucid
Date: 19 Aug 92 17:19:52 GMT
	<YORK.92Aug17113150@oakland-hills.lucid.com>
Organization: Advanced Decision Systems, Mountain View, CA 94043, +1 (415)
	960-7300


I'm a 'happy' user of Franz Inc's Allegro CL and CLIM. I use it with
Epoch, because you get better X11 integration, and far more mouse
control & behavior.

I've noticed that binaries can be 4x larger than source files. the
speed on a Sparc 2 is quite respectable. lightweight threaded
multiprocessing works pretty well, but Lisp can get locked into
something that you can't break out of (mapcar #'some-fn
'circular-list) [i've gotten caught with this twice], and the only
solution is to shut down lisp completely, via some other window. (in
epoch, I just kill the buffer and it's gone)

I haven't figured out how to get it to read special keys (f1-12,
l11-10, r1-15, help) on the keyboard. i run under Motif, but it's not
Motif's fault (i think).

Allegro CL has some good extensions, good CLOS support, conditions,
andthat sort of thing. it appears to be a very complete implmentation
of CLtL2, which I what I want. I like CLIM better than XCW, but not as
well as the LispM window system.

It ain't a Lisp Machine, however. I've not spent any time with Lucid
CL, so I can't make a comparison.

we are getting another license, and doing more with it, so obviously
it's meeting our needs...

 -- clint
--

Clint Hyde		"Give me a LispM or give me death!" -- anonymous

Advanced Decision Systems	Internet:  chyde@chesapeake.ads.com
2111 Wilson Blvd #800
Arlington, VA 22201		(703) 875-0327
From: sbate@atl.ge.com (Stephen Bate)
Newsgroups: comp.lang.lisp
Subject: Re: Allegro SQL interface?
Date: 20 Aug 92 19:05:55 GMT
Reply-To: sbate@atl.ge.com
Organization: GE Advanced Technology Laboratories

In article <HMENDENHALL.92Aug20093944@andrew.atl.ge.com> 
    hmendenhall@atl.ge.com (Henry H Mendenhall) writes:

> We're about to write our own software to parse SQL return data into Lisp
> data-structures.  Is there a tool somewhere that already does this (from
> Allegro)?

Franz, Inc. tech support says they don't know of any product that provides a
SQL interface to Allegro (I assume you want a Sybase interface). Are you
absolutely tied to Allegro? If not, there are several other knowledge base
development environments that support database interfaces to a number of
RDBMSs. The products I know about are: Mercury KBE (Lisp), 
Knowledgeworks 2.0 (Lisp), Prokappa (C), and Nexpert Object (language?).

If you decide to write your own foreign function binding to Sybase's API,
you may want to look at the Allegro-to-Postgres interface code
distributed with Postgres. You certaintly won't be able to use it as is,
but it might get you started.

Good Luck!

--
Stephen Bate                |
GE Advanced Technology Labs | Internet: sbate@atl.ge.com
300 Route 38, Bldg. 145-2   | Voice: 609-866-6603
Moorestown, NJ 08057        | Fax:   609-866-6397
Newsgroups: comp.lang.lisp
From: gregor@parc.xerox.com (Gregor Kiczales)
Subject: Re: having a tiny prob with CLOS
Organization: Xerox Palo Alto Research Center
Date: 12 Aug 92 13:39:51

In article <CHYDE.92Aug10150355@pecos.ads.com> chyde@pecos.ads.com (Clinton Hyde) writes:

   From: chyde@pecos.ads.com (Clinton Hyde)
   Date: 10 Aug 92 20:03:55 GMT

   i have a method I want to remove. to do so, I need to find it with
   find-method, but i haven't been able to figure out what FIND-METHOD
   really wants as args.

   (find-method (ensure-generic-function my-method-name) NIL '(t))

   but this doesn't work.

The specializers have to be "specializers" not "specializer names."  The
AMOP makes this distinction more clear than it is in CLtLII.  So, you can
fix this case by saying:
  
  (find-method #'foo
               ()
               (mapcar #'find-class '(t)))


Another way that is often much easier, especially in the common case
where there are only a few methods on the generic function, is to grovel
through the result of GENERIC-FUNCTION-METHODS.  Like this:

(defmethod f1 ((x foo)) ..)
#<Method F1 (FOO) ..>
(defmethod f1 ((x bar)) ..)
#<Method F1 (BAR) ..>

(generic-function-methods #'f1) 
(#<Method F1 (BAR) ..> #<Method F1 (FOO) ..>)

(remove-method #'f1 (cadr *))  ; this removes the method specialized to FOO

Newsgroups: comp.lang.lisp
From: cannell@ed8217.ped.pto.ford.com (Larry Cannell)
Subject: Lucid Lisp w/Knowledge Craft and CLX running under Motif?
Organization: Powertrain Electronics, Ford Motor Co.
Date: Thu, 20 Aug 1992 20:40:16 GMT

I'm a system administrator so forgive me if I sound stupid in this
newsgroup ;-).

We have a homebrew application that is built on Knowledge Craft, Lucid Lisp,
and CLX.  This isn't the only application that our workstations will run
(although it is a VERY important one).

These are DEC Ultrix workstations and we are seeing writing on the wall which
says that we must get to OSF/Motif eventually.  Most of our OA applications we
will be running on these workstations supposedly require OSF/Motif, as well as
some other software we will probably get in soon.

Question: Will the KC/Lucid/CLX application have problems running under
OSF/Motif?  If so, what kind of problems?

Any help would be apprecaited.

Larry Cannell
Powertrain Electronics
Ford Motor Co.
From: barmar@think.com (Barry Margolin)
Newsgroups: comp.lang.lisp
Subject: Re: Lucid Lisp w/Knowledge Craft and CLX running under Motif?
Date: 21 Aug 92 03:38:47 GMT
Organization: Thinking Machines Corporation, Cambridge MA, USA
NNTP-Posting-Host: gandalf.think.com

In article <1992Aug20.204016.23188@e3u001.ped.pto.ford.com> cannell@ed8217.ped.pto.ford.com (Larry Cannell) writes:
>We have a homebrew application that is built on Knowledge Craft, Lucid Lisp,
>and CLX.  This isn't the only application that our workstations will run
>(although it is a VERY important one).
>Question: Will the KC/Lucid/CLX application have problems running under
>OSF/Motif?  If so, what kind of problems?

What do you mean by "running under OSF/Motif"?  Motif isn't a window
system, it's a specification of a user interface look and feel and an API
to a toolkit that implements this UI.  It also includes a window manager
that conforms to the UI spec.

If your question is "will the application run under the Motif window
manager" then the answer is that it should.  In general, the choice of
window manager should be transparent to applications, although it's
possible for applications to take advantage of window manager-specific
extensions if they want to.

However, running under the Motif window manager isn't enough to make an
application conform to the Motif UI specification.  Motif specifies the way
an application's UI works inside, not just how windows are manipulated.
For instance, it specifies how menu choices are made and how keyboard
shortcuts are provided.  Your UI will almost certainly have to be rewritten
to provide this level of Motif compliance.

There's a facility called CLM that provides an interface to Motif for
applications written in Common Lisp.  Instead of using CLX, it uses a
separate C program that uses the Motif toolkit.  The Lisp API communicates
with this program over a stream, and it then makes the corresponding Motif
calls.

The Garnet window interface library implemented at CMU includes a Motif
toolkit written entirely in CL using CLX.

For more information on CLM and Garnet, see the section on window system
interfaces in the FAQ.
-- 
Barry Margolin
System Manager, Thinking Machines Corp.

barmar@think.com          {uunet,harvard}!think!barmar
Newsgroups: comp.lang.ada
From: lodhi@seas.gwu.edu (Fakhar Lodhi)
Subject: Some Questions about protected records
Originator: lodhi@seas.gwu.edu
Organization: George Washington University
Date: Tue, 18 Aug 1992 21:40:29 GMT

I have some questions about protected records and would greatly 
appreciate if some one could provide the answers. Thanks.

Section 9.7 (Ada 9X Mapping Vol. II, Ver. 4.0, 24 Dec. 1991) gives the
semantics of the execution of the protected operation as follows:
(paragraphs 9-12)

The actual execution of a protected operation is synchronized with other
protected operations on the same protected record object, as follows:

No two protected operations on the same protected record object
may proceed concurrently, unless both ar functions.

As the first step for an operation that is an entry call, the
barrier condition is evaluated. If it yields FALSE, the call is queued,
and does not proceed further until the barrier is reevluated and no longer
yeilds FALSE.

As the final step of a protected operation that is not a function,
if any calls are queued, the barrier conditions are reevaluated. If the 
barrier of an entry with a queued call no longer evalutes to FALSE,
one call on such a queue is selected as the next protected operation to be
performed on the protected record. If more than one call is 
eligible, an implementation defined rule is used to select among them.


Now I have the following questions.

1. What will happen to the procedure and function calls
that cannot be executed immediately?  Will they be queued or what?
I think it is not mentioned anywhere in this document, or have I missed
some thing?

2. Will the barriers for all entries be evaluated before making a selection
(just like in the select statement), or is it left to the implementation?

3. As I understand, functions are provided in a protected record to allow
concurrent read. Now assuming this is true, should they have a lower priority
than procedure and entry operations when it comes to selecting a protected
operation?

Once again, I would really appreciate any one clearing this thing out for me.
Thanks.

Fakhar Lodhi
lodhi@gwusun.gwu.edu
Newsgroups: comp.lang.ada
From: sinan@milton.u.washington.edu (Sinan Karasu)
Subject: Need to free local storage
Keywords: Ada
Organization: University of Washington, Seattle
Date: Fri, 14 Aug 1992 14:40:15 GMT

   
In the following code ( which is from Stars Xlib bindings) the lines
flagged by -- sjw are needed in an Alsys environment, 
since otherwise we end up a memory leakage problem .. What does LRM say 
about this? is this a bug or normal ? is there a simple way to take care 
of this? Any suggestions are heartily welcome.
-------------------------------------------------------------------------

      function set_event
          (untyped_event_record : x_crossing_event_record) return event_record
          is
         untyped_event : x_event :=
            new x_crossing_event_record'(untyped_event_record);

         procedure free is new unchecked_deallocation -- sjw
           (object => X_Crossing_Event_Record,        -- sjw
            name   => X_Event);                       -- sjw

      begin
         case event_type'val (untyped_event.kind) is
            when button_press  =>
               declare
                  the_x_event : x_button_event :=
                     to_x_button_event (untyped_event);
               begin
                  free(untyped_event); --sjw
                  return
                     (kind       => button_press,
                      serial => x_long_integer (the_x_event.serial),
                      send_event => to_ada_boolean (the_x_event.send_event),
                      display_id => the_x_event.display_id,
                      window_id  => to_ada_window (the_x_event.window_id),
                      button =>
                         (root => to_ada_window (the_x_event.root),
                          subwindow => to_ada_window (the_x_event.subwindow),
                          event_time => time (the_x_event.event_time),
                          x => coordinate (the_x_event.x),
                          y => coordinate (the_x_event.y),
                          x_root => coordinate (the_x_event.x_root),
                          y_root => coordinate (the_x_event.y_root),
                          state => key_and_button_mask (to_mask (the_x_event.state)),
                          button => button_name_type (the_x_event.button),
                          same_screen =>
                             to_ada_boolean (the_x_event.same_screen)));
               end;
            when button_release     =>
               declare
                  the_x_event : x_button_event :=
                     to_x_button_event (untyped_event);
               begin
                  free(untyped_event); -- sjw
                  return
                     (kind       => button_release,
                      serial => x_long_integer (the_x_event.serial),
                      send_event => to_ada_boolean (the_x_event.send_event),




  --- Thanx for your help
      Sinan
From: reashore@hac2arpa (Frank Reashore)
Newsgroups: comp.lang.ada
Subject: (none)
Date: 12 Aug 92 17:36:04 GMT
Distribution: world
Organization: The Internet


Newsgroups: comp.lang.ada
From: lodhi@seas.gwu.edu (Fakhar Lodhi)
Subject: Another Question about protected records
Originator: lodhi@seas.gwu.edu
Organization: George Washington University
Date: Wed, 19 Aug 1992 22:29:49 GMT

Yesterday I asked two questions about protected records. While I am 
still waiting for the answers, I have another question about their syntax.
I would greatly appreciate if some body, especially some one in the Ada9x 
design team, could provide me the answers. Thanks.

Now the question is:

Section 9.5 of the Ada 9X Mapping Vol. II (Mapping Specification),
version 4.0, 24 Dec. 91, gives the syntax of a protected record specification
as follows:

(para 5)

   protected_record_specification ::=
     protected [type] identifier [discriminat_part] is
       {protected_operation_declaration}
     private
       {protected_operation_declaration}
     record
       component_list
     end [protected_record_simple_name]

The same syntax is used in example given in section 9.6

But, an example in section 3.3.2.1 of Ada 9X Mapping Vol. I (Mapping Rationale)
ver. 4.1, 4 March 92 uses a different syntax. The code is as follows:

    < some stuff deleted >
    protected record type mailbox is
      
       < stuff deleted >
    private record
       
       < stuff deleted>

    end record;

which is clearly different from the syntax given above.
(end record is not a valid syntax.)

Now the question is, which one of the two is correct?

Once again, I would greatly appreciate your help. Thanks.

Fakhar Lodhi