Steel Bank Common Lisp

james@... (James A. Crippen) writes:

> I'm working on a telnet daemon written in Lisp and am using SBCL as my
> main platform. I'm using sb-bsd-sockets to do my networking dirty
> work. What I'd like to do is take the fd-stream that I get from
> socket-accept

Not socket-accept, actually, but socket-make-stream. Sorry.

'james

-- 
James A. Crippen <james at unlambda.com> Lambda Unlimited
61.2204N, 149.8964W                      Recursion 'R' Us
Anchorage, Alaska, USA, Earth            Y = \f.(\x.f(xx))(\x.f(xx))

I call what you're trying to do delegation and have a macro that makes 
it fairly easy. Here is the documentation:

EKSL-UTILITIES:DELEGATES-TO (class
                              delegate-class
                              delegate-slot)  &body methods
[macro]
Creates methods so that instances of class 'class' will delegate the
specified methods to their 'delegate-slot' slot. The class of the 
delegate
slot must be delegate-class. For example:

(delegates-to (shape geom geom-slot)
   (overlap-p geom geom)
   (geom-distance-< geom geom number))

Will let instances of shape act like instances for geom for the 
overlap-p and
geom-distance-< methods. It might help to read it as:

"class delegates to delegate-class unsing delegate-slot."

The macro use MOP introspection to figure out what methods it needs to 
write. It's just a short cut to writing the methods yourself but I 
think it makes things a little nicer and simpler. This works under MCL 
and OpenMCL and should under SBCL (though I haven't tried it). It 
should work with structures to. Let me know if you think that this 
would help.


On Mar 27, 2004, at 9:13 PM, James A. Crippen wrote:

> james@... (James A. Crippen) writes:
>
>> I'm working on a telnet daemon written in Lisp and am using SBCL as my
>> main platform. I'm using sb-bsd-sockets to do my networking dirty
>> work. What I'd like to do is take the fd-stream that I get from
>> socket-accept
>
> Not socket-accept, actually, but socket-make-stream. Sorry.
>
> 'james
>
> -- 
> James A. Crippen <james at unlambda.com> Lambda Unlimited
> 61.2204N, 149.8964W                      Recursion 'R' Us
> Anchorage, Alaska, USA, Earth            Y = \f.(\x.f(xx))(\x.f(xx))
>
>
> -------------------------------------------------------
> This SF.Net email is sponsored by: IBM Linux Tutorials
> Free Linux tutorial presented by Daniel Robbins, President and CEO of
> GenToo technologies. Learn everything from fundamentals to system
> administration.http://ads.osdn.com/?ad_id=1470&alloc_id=3638&op=click
> _______________________________________________
> Sbcl-help mailing list
> Sbcl-help@...
> https://lists.sourceforge.net/lists/listinfo/sbcl-help
>
>
-- 
Gary Warren King, Lab Manager
EKSL East, University of Massachusetts * 413 577 0176

All Windows users: Please be aware that there is a new unknown worm
spreading itself via email.  (Mac and Linux users don't have to read
this email)
   -- typical computing support e-mail

On 28. M=E4r 2004, at 14:24, Daniel Barlow wrote:

> james@... (James A. Crippen) writes:
>
>> Right now I'm implementing telnet-stream with a hackish class that
>> wraps up the fd-stream into a slot along with other stuff. This works
>> okay but it means that I have to provide implementations of *every*
>> stream function for this new class that know how to pull out the
>
> [...]
>
> This is not a recommendation as I've never used it myself, but you
> might want to look at the sb-simple-streams contrib and see if that
> helps.
>
> Perhaps someone who has (or has used Allegro-style simple streams on
> some other platform) can chip in.

Haven't used simple-streams in anger myself ...  my gut feeling is that=20=

they perhaps aren't a good match.  The key idea of simple-streams is=20
that the upper layers (read-char, write-sequence, ...) stay the same=20
and work on a common buffering layer, and new stream types customize=20
device-read, device-write, device-open etc.
So, I /think/ having a telnet simple-stream would mean you'd have to=20
sprinkle the application code with (finish-output) to empty the buffer=20=

at every step.  If that is not a problem, for a simple-telnet-stream=20
I'd have a look at subclassing socket-stream.  simple-streams are=20
created via `def-stream-class' and their slots are accessed with `sm'=20
instead of `slot-value' (see also the `with-simple-stream' macro &=20
friends).  (this protocol is an efficiency hack; Franz has=20
documentation for simple-streams on their web site.)

If you decide to try them out, I'd be interested to hear how it's=20
working out.

Cheers,

Rudi

Rudi Schlatte <rudi@...> writes:

> Haven't used simple-streams in anger myself ...  my gut feeling is
> that they perhaps aren't a good match.  The key idea of simple-streams
> is that the upper layers (read-char, write-sequence, ...) stay the
> same and work on a common buffering layer, and new stream types
> customize device-read, device-write, device-open etc.
> 
> So, I /think/ having a telnet simple-stream would mean you'd have to
> sprinkle the application code with (finish-output) to empty the buffer
> at every step.

It seems to me like you're right here, and having to call something
every time the stream changes would be a royal PITA. So I guess
simple-streams isn't a good match for what I'm trying to do.

I'm just going to go on doing it the ugly wrapper way. The idea for a
default wrapper macro is a good idea and I'm going to hack one up
now. Hopefully someone who needs generalized network streams a la the
LispM will someday hack them up based on file-stream and then I can
retcon my telnet-stream into it, but I don't feel ambitious enough to
do the work myself.

'james

-- 
James A. Crippen <james at unlambda.com> Lambda Unlimited
61.2204N, 149.8964W                      Recursion 'R' Us
Anchorage, Alaska, USA, Earth            Y = \f.(\x.f(xx))(\x.f(xx))