Hello Marc

I'm writing an interface to perl, and am trying to get exception handling right.

At the moment, I'm only caring about exceptions thrown in perl code (which has been called by scheme), I may be dealing with exceptions thrown in scheme code called by perl later.

One way to handle perl exceptions would be to catch exceptions on every perl-from-scheme function call (using the G_EVAL flag to call_sv, like: call_sv(perlfunction,G_EVAL);), and reraise them as scheme exceptions. But I expect this to be relatively costly (several hundred cpu cycles per call), and I think placing perl exception catchers manually might also make more sense. So I'm imaging a solution like:

(with-perl-exception-catcher (lambda (sv) ;; sv is the perl scalar value representing $@ (display "Got a perl exception: ") (display (sv->string sv)) #f) (lambda () (perl-call "thrower") #t))

where the perl interpreter has this perl code loaded:

sub thrower { print "(thrower called)\n"; die "Hi from thrower"; } sub nothrower { print "(nothrower called)\n"; }

Running the scheme program would then print "Got a perl exception: Hi from thrower at file.pl line 2" and return #f.

I've got perl-call, sv->string and such already running, now I'm trying to implement with-perl-exception-catcher.

Perl is using setjmp/longjmp for implementing exceptions (or, at the user's request, can throw C++ exceptions). It maintains a linked list of extended jmp_buf buffers. The exception value is stored in the perl global "$@". An exception classifyer is stored in the extended jmp buffer upon calling longjmp and copied to a user variable by the JMPENV_PUSH() macro.

scheme code:

(define with-perl-exception-catcher (c-lambda (scheme-object scheme-object) scheme-object "gperl__with_perl_exception_catcher"))

(c-define (trampoline-0 cont) (scheme-object) scheme-object "gperl_trampoline_0" "" (cont))

(c-define (trampoline-1 cont v1) (scheme-object scheme-object) scheme-object "gperl_trampoline_1" "" (cont v1))

C code:

___SCMOBJ gperl__with_perl_exception_catcher(___SCMOBJ handler, ___SCMOBJ thunk) { if (gperl_current_interpreter) { dJMPENV; // macro from perl: declares jmp environment. int rEtV = 0; ___SCMOBJ res;

JMPENV_PUSH(rEtV); // macro from perl: make the new environment // the current (and link it to the previous), // call setjmp, set rEtV to 0 at first or // to the error classifyer upon longjmp. if (rEtV == 0) { // now either throw a perl exception directly: // croak("Hello this is a perl exception"); // or call thunk through gperl-trampoline-0: // res= gperl_trampoline_0(thunk); // or call thunk through this scary code: #define ___NARGS 1 ___BEGIN_SFUN_SCMOBJ(___MLBL(___C_LBL_gperl_trampoline_0)) /* label reused :o) */ ___BEGIN_SFUN_ARG_SCMOBJ(1) #define ___ARG1 thunk ___BEGIN_SFUN_BODY ___SFUN_ARG(1,___ARG1) ___SFUN_CALL_SCMOBJ ___SFUN_SET_RESULT_SCMOBJ ___END_SFUN_BODY #undef ___ARG1 ___END_SFUN_ARG_SCMOBJ(1) ___SFUN_ERROR_SCMOBJ ___SFUN_SET_RESULT_SCMOBJ ___END_SFUN_SCMOBJ #undef ___NARGS res= ___result; fprintf(stderr,"gperl_with_perl_exception_catcher: no exception occured in perl.\n"); } JMPENV_POP; // make the previous environment the current. if (rEtV != 0) { fprintf(stderr,"gperl_with_perl_exception_catcher: an exception occured in perl!\n"); // now call handler and return it's value return gperl_trampoline_1(handler, ___FIX(1234)); //todo: replace with gperl_get_sv("$@") } else { // return thunk's value. return res; } } else { return ___FIX(-1235); //(todo: produce a scheme exception) } }

Note that I've first tried to call back to the scheme lambdas using c-define'd trampoline functions. It worked just fine so far when calling the perl function "nothrower", i.e.

(with-perl-exception-catcher (lambda (sv) (display "Got a perl exception\n")) (lambda () (perl-call "nothrower")))

but when calling "thrower", it is outputting "(nothrower called)", "gperl_with_perl_exception_catcher: an exception occured in perl!" and "Got a perl exception", but then is hanging in an infinite loop, which ctl-c doesn't interrupt. Call graph:

scheme -> C -> scheme: thunk -> C -> perl: nothrower <- <- <- <- ok.

scheme -> C -> scheme: thunk -> C -> perl: thrower <-------------------longjmp- -> scheme: handler [ somewhere here it loops: ] <- <-

Then I've replaced the gperl_trampoline_0(thunk); call with the above code which is an excerpt from what the compiler produced for the former; this still works for "nothrower", but terminates the program with signal 4 (illegal instruction) for "thrower".

When commenting out both the gperl_trampoline_0 and compiler-produced code and directly call the C function croak("Hello this is a perl exception"); which to the best of my knowledge acts exactly as the perl die function, there is no crash or endless loop, everything seems to work. Call graph:

scheme -> C croak(); <-longjmp- -> scheme: handler <- <-

So I would guess it must be the call to the thunk which makes it loop.

My questions:

- is it at all possible to longjmp over scheme<->C boundaries? - what is the most natural way to call back into a scheme lambda from C? (I've noticed the C closure code in os_dyn.c, is this code used in one of the above situations?)

I'll be happy to give you more information or real code for testing.

I've tested on Debian/x86.

Thanks Christian.