On Wednesday 07 April 2004 17:42, Leopold Toetsch wrote:
> Jens Rieks <[EMAIL PROTECTED]> wrote:
> > here is a working version of my new Stream library. I will add more
> > documentation later this month, the examples should be enough to
> > understand the usage.
>
> I'm currently investigating a bunch of SIGSEGVs when tracing the examples.
> They are all coming from Stream::Sub's usage of continuations:
Oops yes, I forgot to mention that. I though it is related to string handling,
running parrot with -G works, and it crashes only after processing some lines.
> ,--[ Stream::Sub ]------------------------------------------------------
>
> | This special "method" can call C<write>, which will internally create
> | a Continuation to return to the current execution point when read is
> | called the next time. The C<read> method creates a continuation before
> | invoking the provided sub or the continuation captured by the write
> | method. C<read>'s continuation is used to return the string parameter
> | passed to C<write> as the return value of the read method.
>
> `-----------------------------------------------------------------------
>
> The problem seems to be context handling. When C<write> creates the
> Continuation, it saves a different context as that one that is inplace
> and will be restored, when the Continuation is invoked.
>
> Further, in C<rawRead> P1 is stored away (and invoked later), which
> isn't allowed. But cloning it doesn't help because the continuation
> context is still wrong.
>
> I think to get that right we need some more support to copy contexts
> around.
>
> How exactly should these contexts look like for these two
> continuations?
It should be a snapshot of the current execution chain, so that exactly the
same context is restored when invoking the continuation.
It is some kind of "context swapping":
main exec chain sub chain
---------------------------------------------
Stream::Sub created
sub created
stored as "source"
read()
create "read cont"
call "source"
execution start
do something
write()
create continuation
store it as new "source"
call "read cont"
back in read, directly
after the invokation of
the "source" sub/cont
return the value passed to
the "read cont" as return
values of read()
do something
read()
create "read cont"
back in write
return from write
do something
write()
create "write cont"
call "read cont"
...
> leo
jens
