Calling multiple perl subroutines from XS procedure

XS manual pages, "Advanced perl programming" etc all mention the
more-or-less such sequence to be used while calling perl subroutine
from C code:

    {
        dSP;
        ENTER;
        SAVETMPS;
        PUSHMARK(sp);
        /* ... populating params with XPUSHs */
        PUTBACK;
        int n = perl_call_method(...); /* Or perl_call_pv or similar */
        /* ... reading return values with POPs */
        SPAGAIN;
        PUTBACK;
        FREETMPS;
        LEAVE;
    }

my question, for which I could not find the answer, is: which of those
macros must I repeat and which can I reuse while calling MORE THAN ONE
perl subroutine. In other words, how can the code below be
simplified/shortened:

  int somefun()
  {
    SV *val = 0;
    {
        dSP;
        ENTER;
        SAVETMPS;
        PUSHMARK(sp);
        XPUSHs(sv_2mortal(newSVpv("someparam", 0)));
        PUTBACK;
        int n = perl_call_pv("somefun", G_SCALAR);
        if( n == 1 )
        {
            val = newSVsv(POPs);
        }
        SPAGAIN;
        PUTBACK;
        FREETMPS;
        LEAVE;

        if( ! val)
              croak("something is wrong");
    }
    {
        dSP;
        ENTER;
        SAVETMPS;
        PUSHMARK(sp);
        XPUSHs(val);
        PUTBACK;
        int n = perl_call_pv("otherfun", G_DISCARD);
        SPAGAIN;
        PUTBACK;
        FREETMPS;
        LEAVE;
    }
  }

(code above compiled with C++ compiler so anonymous { .. } can be used)

I suspect I can move dSP to the top of the function and use it only
once but what with ENTER, SAVETMPS etc? Can I for instance use
SAVETMPS once and FREETMPS once? What about ENTER/LEAVE?

----- End forwarded message -----

In my expirience (and after checking source codes) you don't need
anonymous { ... } at all. Just put dSP; at the top of function and
then use ENTER; SAVETMPS; ... FREETMPS; LEAVE; before the call to
routine. The main idea of ENTER is to define scope for local variables.
So if you run routines within the same scope then probably nothing
terrible would happen (though I didn't try it). Just to summarize. I
usually write the above function as 

  int somefun()
  {
    dSP;
    SV *val = 0;
        ENTER;
        SAVETMPS;
        PUSHMARK(sp);
        XPUSHs(sv_2mortal(newSVpv("someparam", 0)));
        PUTBACK;
        int n = perl_call_pv("somefun", G_SCALAR);
        if( n == 1 )
        {
            val = newSVsv(POPs);
        }
        SPAGAIN;
        PUTBACK;
        FREETMPS;
        LEAVE;

        if( ! val)
              croak("something is wrong");
        ENTER;
        SAVETMPS;
        PUSHMARK(sp);
        XPUSHs(val);
        PUTBACK;
        int n = perl_call_pv("otherfun", G_DISCARD);
        SPAGAIN;
        PUTBACK;
        FREETMPS;
        LEAVE;
  }

Maybe you can leave only one pair of ENTER; SAVETMPS and FREETMPS;
LEAVE; And stack manipulation have to stay as it is.

Andrei

----- End forwarded message -----

Could anyone confirm whether it is safe? I will probably have
situation where I call some perl subroutine within the loop so it is
likely that calling ENTER, SAVETMPS, FREETMPS and LEAVE once instead
of calling it at every loop iteration will give me some gain - but I
would not like to get strange errors...

So the question is: can I do:

   (only once)
   ENTER;
   SAVETMPS;

   (sequence below repeated a few or maybe even a lot of times)
        PUSHMARK(sp);
        (...XPUSHsing parameters...)
        PUTBACK;
        int n = perl_call_pv("otherfun", G_DISCARD);
        SPAGAIN;
        (...POPsing output...)        
        PUTBACK;

   (only once)
   FREETMPS;
   LEAVE;

And the releated question: can I croak before calling FREETMPS and
LEAVE? Will I leak memory if croaking then?

----- End forwarded message -----