=item * An Event-Driven Program
The classic example of where callbacks are used is when writing an
-event driven program, such as for an X windows application. In this case
+event driven program, such as for an X11 application. In this case
you register functions to be called whenever specific events occur,
e.g., a mouse button is pressed, the cursor moves into a window or a
menu item is selected.
L<perlembed>.
Before you launch yourself head first into the rest of this document,
-it would be a good idea to have read the following two documents -
-
L<perlxs> and L<perlguts>.
+it would be a good idea to have read the following two documents--L<perlxs>
+and L<perlguts>.
=head1 THE CALL_ FUNCTIONS
I32 call_sv(SV* sv, I32 flags);
I32 call_pv(char *subname, I32 flags);
I32 call_method(char *methname, I32 flags);
- I32 call_argv(char *subname, I32 flags, register char **argv);
+ I32 call_argv(char *subname, I32 flags, char **argv);
The key function is I<call_sv>. All the other functions are
fairly simple wrappers which make it easier to call Perl subroutines in
All the I<call_*> functions have a C<flags> parameter which is
used to pass a bit mask of options to Perl. This bit mask operates
identically for each of the functions. The settings available in the
-bit mask are discussed in L<FLAG VALUES>.
+bit mask are discussed in L</FLAG VALUES>.
Each of the functions will now be discussed in turn.
=item call_sv
-I<call_sv> takes two parameters, the first, C<sv>, is an SV*.
+I<call_sv> takes two parameters. The first, C<sv>, is an SV*.
This allows you to specify the Perl subroutine to be called either as a
C string (which has first been converted to an SV) or a reference to a
-subroutine. The section, I<Using call_sv>, shows how you can make
+subroutine. The section, L</Using call_sv>, shows how you can make
use of I<call_sv>.
=item call_pv
on the Perl stack rather than in the parameter list. This class can be
either the name of the class (for a static method) or a reference to an
object (for a virtual method). See L<perlobj> for more information on
-static and virtual methods and L<Using call_method> for an example
+static and virtual methods and L</Using call_method> for an example
of using I<call_method>.
=item call_argv
I<call_argv> calls the Perl subroutine specified by the C string
stored in the C<subname> parameter. It also takes the usual C<flags>
-parameter. The final parameter, C<argv>, consists of a NULL terminated
+parameter. The final parameter, C<argv>, consists of a NULL-terminated
list of C strings to be passed as parameters to the Perl subroutine.
-See I<Using call_argv>.
+See L</Using call_argv>.
=back
=back
The value returned by the I<call_*> function indicates how many
-items have been returned by the Perl subroutine - in this case it will
+items have been returned by the Perl subroutine--in this case it will
be 0.
If 0, then you have specified the G_DISCARD flag.
If 1, then the item actually returned by the Perl subroutine will be
-stored on the Perl stack - the section I<Returning a Scalar> shows how
+stored on the Perl stack - the section L</Returning a Scalar> shows how
to access this value on the stack. Remember that regardless of how
many items the Perl subroutine returns, only the last one will be
accessible from the stack - think of the case where only one value is
returned as being a list with only one element. Any other items that
were returned will not exist by the time control returns from the
-I<call_*> function. The section I<Returning a list in a scalar
-context> shows an example of this behavior.
+I<call_*> function. The section L</Returning a List in Scalar
+Context> shows an example of this behavior.
=head2 G_ARRAY
It indicates to the subroutine being called that it is executing in a
list context (if it executes I<wantarray> the result will be true).
-
=item 2.
It ensures that all items returned from the subroutine will be
If not 0, then it will be a count of the number of items returned by
the subroutine. These items will be stored on the Perl stack. The
-section I<Returning a list of values> gives an example of using the
+section L</Returning a List of Values> gives an example of using the
G_ARRAY flag and the mechanics of accessing the returned items from the
Perl stack.
If you do not set this flag then it is I<very> important that you make
sure that any temporaries (i.e., parameters passed to the Perl
subroutine and values returned from the subroutine) are disposed of
-yourself. The section I<Returning a Scalar> gives details of how to
-dispose of these temporaries explicitly and the section I<Using Perl to
-dispose of temporaries> discusses the specific circumstances where you
+yourself. The section L</Returning a Scalar> gives details of how to
+dispose of these temporaries explicitly and the section L</Using Perl to
+Dispose of Temporaries> discusses the specific circumstances where you
can ignore the problem and let Perl deal with it for you.
=head2 G_NOARGS
Although the functionality provided by this flag may seem
straightforward, it should be used only if there is a good reason to do
-so. The reason for being cautious is that even if you have specified
+so. The reason for being cautious is that, even if you have specified
the G_NOARGS flag, it is still possible for the Perl subroutine that
has been called to think that you have passed it parameters.
=back
-See I<Using G_EVAL> for details on using G_EVAL.
+See L</Using G_EVAL> for details on using G_EVAL.
=head2 G_KEEPERR
The G_KEEPERR flag was introduced in Perl version 5.002.
-See I<Using G_KEEPERR> for an example of a situation that warrants the
+See L</Using G_KEEPERR> for an example of a situation that warrants the
use of this flag.
=head2 Determining the Context
executing subroutine in Perl with I<wantarray>. The equivalent test
can be made in C by using the C<GIMME_V> macro, which returns
C<G_ARRAY> if you have been called in a list context, C<G_SCALAR> if
-in a scalar context, or C<G_VOID> if in a void context (i.e. the
+in a scalar context, or C<G_VOID> if in a void context (i.e., the
return value will not be used). An older version of this macro is
called C<GIMME>; in a void context it returns C<G_SCALAR> instead of
C<G_VOID>. An example of using the C<GIMME_V> macro is shown in
-section I<Using GIMME_V>.
+section L</Using GIMME_V>.
=head1 EXAMPLES
-Enough of the definition talk, let's have a few examples.
+Enough of the definition talk! Let's have a few examples.
Perl provides many macros to assist in accessing the Perl stack.
Wherever possible, these macros should always be used when interfacing
to keep the code simpler and ease you into the topic. Wherever
possible, if the choice is between using I<call_pv> and
I<call_sv>, you should always try to use I<call_sv>. See
-I<Using call_sv> for details.
+L</Using call_sv> for details.
-=head2 No Parameters, Nothing returned
+=head2 No Parameters, Nothing Returned
This first trivial example will call a Perl subroutine, I<PrintUID>, to
print out the UID of the process.
call_pv("PrintUID", G_DISCARD|G_NOARGS);
}
-Simple, eh.
+Simple, eh?
-A few points to note about this example.
+A few points to note about this example:
=over 5
string ($s) and an integer ($n). The subroutine will simply
print the first $n characters of the string.
-So the Perl subroutine would look like this
+So the Perl subroutine would look like this:
sub LeftString
{
print substr($s, 0, $n), "\n";
}
-The C function required to call I<LeftString> would look like this.
+The C function required to call I<LeftString> would look like this:
static void
call_LeftString(a, b)
SAVETMPS;
PUSHMARK(SP);
- XPUSHs(sv_2mortal(newSVpv(a, 0)));
- XPUSHs(sv_2mortal(newSViv(b)));
+ EXTEND(SP, 2);
+ PUSHs(sv_2mortal(newSVpv(a, 0)));
+ PUSHs(sv_2mortal(newSViv(b)));
PUTBACK;
call_pv("LeftString", G_DISCARD);
The C<PUSHMARK> macro tells Perl to make a mental note of the current
stack pointer. Even if you aren't passing any parameters (like the
-example shown in the section I<No Parameters, Nothing returned>) you
+example shown in the section L</No Parameters, Nothing Returned>) you
must still call the C<PUSHMARK> macro before you can call any of the
I<call_*> functions--Perl still needs to know that there are no
parameters.
The C<PUTBACK> macro sets the global copy of the stack pointer to be
-the same as our local copy. If we didn't do this I<call_pv>
+the same as our local copy. If we didn't do this, I<call_pv>
wouldn't know where the two parameters we pushed were--remember that
up to now all the stack pointer manipulation we have done is with our
local copy, I<not> the global copy.
=item 4.
-Next, we come to XPUSHs. This is where the parameters actually get
-pushed onto the stack. In this case we are pushing a string and an
-integer.
+Next, we come to EXTEND and PUSHs. This is where the parameters
+actually get pushed onto the stack. In this case we are pushing a
+string and an integer.
+
+Alternatively you can use the XPUSHs() macro, which combines a
+C<EXTEND(SP, 1)> and C<PUSHs()>. This is less efficient if you're
+pushing multiple values.
See L<perlguts/"XSUBs and the Argument Stack"> for details
-on how the XPUSH macros work.
+on how the PUSH macros work.
=item 5.
mortal SVs we have created. Having C<ENTER>/C<SAVETMPS> at the
beginning of the code makes sure that no other mortals are destroyed.
-Think of these macros as working a bit like using C<{> and C<}> in Perl
+Think of these macros as working a bit like C<{> and C<}> in Perl
to limit the scope of local variables.
-See the section I<Using Perl to dispose of temporaries> for details of
+See the section L</Using Perl to Dispose of Temporaries> for details of
an alternative to using these macros.
=item 6.
SAVETMPS;
PUSHMARK(SP);
- XPUSHs(sv_2mortal(newSViv(a)));
- XPUSHs(sv_2mortal(newSViv(b)));
+ EXTEND(SP, 2);
+ PUSHs(sv_2mortal(newSViv(a)));
+ PUSHs(sv_2mortal(newSViv(b)));
PUTBACK;
count = call_pv("Adder", G_SCALAR);
=item 1.
-The only flag specified this time was G_SCALAR. That means the C<@_>
+The only flag specified this time was G_SCALAR. That means that the C<@_>
array will be created and that the value returned by I<Adder> will
still exist after the call to I<call_pv>.
The purpose of the macro C<SPAGAIN> is to refresh the local copy of the
stack pointer. This is necessary because it is possible that the memory
-allocated to the Perl stack has been reallocated whilst in the
+allocated to the Perl stack has been reallocated during the
I<call_pv> call.
If you are making use of the Perl stack pointer in your code you must
they return.
POPs SV
- POPp pointer
- POPn double
- POPi integer
+ POPp pointer (PV)
+ POPpbytex pointer to bytes (PV)
+ POPn double (NV)
+ POPi integer (IV)
+ POPu unsigned integer (UV)
POPl long
+ POPul unsigned long
+
+Since these macros have side-effects don't use them as arguments to
+macros that may evaluate their argument several times, for example:
+
+ /* Bad idea, don't do this */
+ STRLEN len;
+ const char *s = SvPV(POPs, len);
+
+Instead, use a temporary:
+
+ STRLEN len;
+ SV *sv = POPs;
+ const char *s = SvPV(sv, len);
+
+or a macro that guarantees it will evaluate its arguments only once:
+
+ STRLEN len;
+ const char *s = SvPVx(POPs, len);
=item 5.
=back
-=head2 Returning a list of values
+=head2 Returning a List of Values
Now, let's extend the previous example to return both the sum of the
parameters and the difference.
SAVETMPS;
PUSHMARK(SP);
- XPUSHs(sv_2mortal(newSViv(a)));
- XPUSHs(sv_2mortal(newSViv(b)));
+ EXTEND(SP, 2);
+ PUSHs(sv_2mortal(newSViv(a)));
+ PUSHs(sv_2mortal(newSViv(b)));
PUTBACK;
count = call_pv("AddSubtract", G_ARRAY);
=back
-=head2 Returning a list in a scalar context
+=head2 Returning a List in Scalar Context
Say the Perl subroutine in the previous section was called in a scalar
context, like this
SAVETMPS;
PUSHMARK(SP);
- XPUSHs(sv_2mortal(newSViv(a)));
- XPUSHs(sv_2mortal(newSViv(b)));
+ EXTEND(SP, 2);
+ PUSHs(sv_2mortal(newSViv(a)));
+ PUSHs(sv_2mortal(newSViv(b)));
PUTBACK;
count = call_pv("AddSubtract", G_SCALAR);
Value 1 = 3
In this case the main point to note is that only the last item in the
-list is returned from the subroutine
, I<AddSubtract> actually made it back to
+list is returned from the subroutine
. I<AddSubtract> actually made it back to
I<call_AddSubScalar>.
-=head2 Returning Data from Perl via the parameter list
+=head2 Returning Data from Perl via the Parameter List
-It is also possible to return values directly via the parameter list -
-whether it is actually desirable to do it is another matter entirely.
+It is also possible to return values directly via the parameter
+list--whether it is actually desirable to do it is another matter entirely.
The Perl subroutine, I<Inc>, below takes 2 parameters and increments
each directly.
svb = sv_2mortal(newSViv(b));
PUSHMARK(SP);
- XPUSHs(sva);
- XPUSHs(svb);
+ EXTEND(SP, 2);
+ PUSHs(sva);
+ PUSHs(svb);
PUTBACK;
count = call_pv("Inc", G_DISCARD);
{
dSP;
int count;
+ SV *err_tmp;
ENTER;
SAVETMPS;
PUSHMARK(SP);
- XPUSHs(sv_2mortal(newSViv(a)));
- XPUSHs(sv_2mortal(newSViv(b)));
+ EXTEND(SP, 2);
+ PUSHs(sv_2mortal(newSViv(a)));
+ PUSHs(sv_2mortal(newSViv(b)));
PUTBACK;
count = call_pv("Subtract", G_EVAL|G_SCALAR);
SPAGAIN;
/* Check the eval first */
- if (SvTRUE(ERRSV))
+ err_tmp = ERRSV;
+ if (SvTRUE(err_tmp))
{
- printf ("Uh oh - %s\n", SvPV_nolen(ERRSV));
+ printf ("Uh oh - %s\n", SvPV_nolen(err_tmp));
POPs;
}
else
The code
- if (SvTRUE(ERRSV))
+ err_tmp = ERRSV;
+ if (SvTRUE(err_tmp))
{
- printf ("Uh oh - %s\n", SvPV_nolen(ERRSV));
+ printf ("Uh oh - %s\n", SvPV_nolen(err_tmp));
POPs;
}
print "Uh oh - $@\n" if $@;
-C<PL_errgv> is a perl global of type C<GV *> that points to the
-symbol table entry containing the error. C<ERRSV> therefore
-refers to the C equivalent of C<$@>.
+C<PL_errgv> is a perl global of type C<GV *> that points to the symbol
+table entry containing the error. C<ERRSV> therefore refers to the C
+equivalent of C<$@>. We use a local temporary, C<err_tmp>, since
+C<ERRSV> is a macro that calls a function, and C<SvTRUE(ERRSV)> would
+end up calling that function multiple times.
=item 3.
Note that the stack is popped using C<POPs> in the block where
-C<SvTRUE(ERRSV)> is true. This is necessary because whenever a
+C<SvTRUE(err_tmp)> is true. This is necessary because whenever a
I<call_*> function invoked with G_EVAL|G_SCALAR returns an error,
the top of the stack holds the value I<undef>. Because we want the
program to continue after detecting this error, it is essential that
-the stack is tidied up by removing the I<undef>.
+the stack be tidied up by removing the I<undef>.
=back
In all the previous examples I have 'hard-wired' the name of the Perl
subroutine to be called from C. Most of the time though, it is more
convenient to be able to specify the name of the Perl subroutine from
-within the Perl script.
+within the Perl script, and you'll want to use
+L<call_sv|perlapi/call_sv>.
Consider the Perl code below
call_pv(name, G_DISCARD|G_NOARGS);
That is fine as far as it goes. The thing is, the Perl subroutine
-can be specified as only a string. For Perl 4 this was adequate,
-but Perl 5 allows references to subroutines and anonymous subroutines.
+can be specified as only a string, however, Perl allows references
+to subroutines and anonymous subroutines.
This is where I<call_sv> is useful.
The code below for I<CallSubSV> is identical to I<CallSubPV> except
PUSHMARK(SP);
call_sv(name, G_DISCARD|G_NOARGS);
-Because we are using an SV to call I<fred> the following can all be used
+Because we are using an SV to call I<fred> the following can all be used:
CallSubSV("fred");
CallSubSV(\&fred);
As you can see, I<call_sv> gives you much greater flexibility in
how you can specify the Perl subroutine.
-You should note that if it is necessary to store the SV (C<name> in the
+You should note that, if it is necessary to store the SV (C<name> in the
example above) which corresponds to the Perl subroutine so that it can
be used later in the program, it not enough just to store a copy of the
-pointer to the SV. Say the code above had been like this
+pointer to the SV. Say the code above had been like this:
static SV * rememberSub;
PUSHMARK(SP);
call_sv(rememberSub, G_DISCARD|G_NOARGS);
-The reason this is wrong is that by the time you come to use the
+The reason this is wrong is that, by the time you come to use the
pointer C<rememberSub> in C<CallSavedSub1>, it may or may not still refer
to the Perl subroutine that was recorded in C<SaveSub1>. This is
-particularly true for these cases
+particularly true for these cases:
SaveSub1(\&fred);
CallSavedSub1();
SaveSub1( sub { print "Hello there\n" } );
CallSavedSub1();
-By the time each of the C<SaveSub1> statements above have been executed,
+By the time each of the C<SaveSub1> statements above has been executed,
the SV*s which corresponded to the parameters will no longer exist.
Expect an error message from Perl of the form
though, it now refers to the integer C<47>, so expect Perl to complain
loudly.
-A similar but more subtle problem is illustrated with this code
+A similar but more subtle problem is illustrated with this code:
$ref = \&fred;
SaveSub1($ref);
$ref = \&joe;
CallSavedSub1();
-This time whenever C<CallSavedSub1> get called it will execute the Perl
+This time whenever C<CallSavedSub1> gets called it will execute the Perl
subroutine C<joe> (assuming it exists) rather than C<fred> as was
originally requested in the call to C<SaveSub1>.
To get around these problems it is necessary to take a full copy of the
-SV. The code below shows C<SaveSub2> modified to do that
+SV. The code below shows C<SaveSub2> modified to do that.
+ /* this isn't thread-safe */
static SV * keepSub = (SV*)NULL;
void
To avoid creating a new SV every time C<SaveSub2> is called,
the function first checks to see if it has been called before. If not,
then space for a new SV is allocated and the reference to the Perl
-subroutine, C<name> is copied to the variable C<keepSub> in one
-operation using C<newSVsv>. Thereafter, whenever C<SaveSub2> is called
+subroutine C<name> is copied to the variable C<keepSub> in one
+operation using C<newSVsv>. Thereafter, whenever C<SaveSub2> is called,
the existing SV, C<keepSub>, is overwritten with the new value using
C<SvSetSV>.
+Note: using a static or global variable to store the SV isn't
+thread-safe. You can either use the C<MY_CXT> mechanism documented in
+L<perlxs/Safely Storing Static Data in XS> which is fast, or store the
+values in perl global variables, using get_sv(), which is much slower.
+
=head2 Using call_argv
Here is a Perl subroutine which prints whatever parameters are passed
foreach (@list) { print "$_\n" }
}
-and here is an example of I<call_argv> which will call
+And here is an example of I<call_argv> which will call
I<PrintList>.
static char * words[] = {"alpha", "beta", "gamma", "delta", NULL};
=head2 Using call_method
-Consider the following Perl code
+Consider the following Perl code:
{
package Mine;
the constructor, C<new>, it declares methods, one static and one
virtual. The static method, C<PrintID>, prints out simply the class
name and a version number. The virtual method, C<Display>, prints out a
-single element of the array. Here is an all Perl example of using it.
+single element of the array. Here is an all-Perl example of using it.
$a = Mine->new('red', 'green', 'blue');
$a->Display(1);
This is Class Mine version 1.0
Calling a Perl method from C is fairly straightforward. The following
-things are required
+things are required:
=over 5
=item *
-a reference to the object for a virtual method or the name of the class
-for a static method.
+A reference to the object for a virtual method or the name of the class
+for a static method
=item *
-the name of the method.
+The name of the method
=item *
-any other parameters specific to the method.
+Any other parameters specific to the method
=back
int index
CODE:
PUSHMARK(SP);
- XPUSHs(ref);
- XPUSHs(sv_2mortal(newSViv(index)));
+ EXTEND(SP, 2);
+ PUSHs(ref);
+ PUSHs(sv_2mortal(newSViv(index)));
PUTBACK;
call_method(method, G_DISCARD);
call_method(method, G_DISCARD);
-So the methods C<PrintID> and C<Display> can be invoked like this
+So the methods C<PrintID> and C<Display> can be invoked like this:
$a = Mine->new('red', 'green', 'blue');
call_Method($a, 'Display', 1);
call_PrintID('Mine', 'PrintID');
-The only thing to note is that in both the static and virtual methods,
+The only thing to note is that, in both the static and virtual methods,
the method name is not passed via the stack--it is used as the first
parameter to I<call_method>.
else
printf ("Context is Array\n");
-and here is some Perl to test it
+And here is some Perl to test it.
PrintContext;
$a = PrintContext;
Context is Scalar
Context is Array
-=head2 Using Perl to dispose of temporaries
+=head2 Using Perl to Dispose of Temporaries
In the examples given to date, any temporaries created in the callback
(i.e., parameters passed on the stack to the I<call_*> function or
-values returned via the stack) have been freed by one of these methods
+values returned via the stack) have been freed by one of these methods:
=over 5
=item *
-specifying the G_DISCARD flag with I<call_*>.
+Specifying the G_DISCARD flag with I<call_*>
=item *
-explicitly disposed of using the C<ENTER>/C<SAVETMPS> -
-C<FREETMPS>/C<LEAVE> pairing.
+Explicitly using the C<ENTER>/C<SAVETMPS>--C<FREETMPS>/C<LEAVE> pairing
=back
those temporaries for you, you might be in for a long wait. For Perl
to dispose of your temporaries, control must drop back to the
enclosing scope at some stage. In the event driven scenario that may
-never happen. This means that as time goes on, your program will
+never happen. This means that, as time goes on, your program will
create more and more temporaries, none of which will ever be freed. As
each of these temporaries consumes some memory your program will
eventually consume all the available memory in your system--kapow!
uncertain about what to do, it doesn't do any harm to tidy up anyway.
-=head2 Strategies for storing Callback Context Information
+=head2 Strategies for Storing Callback Context Information
Potentially one of the trickiest problems to overcome when designing a
croak("Internal error...\n");
PUSHMARK(SP);
- XPUSHs(sv_2mortal(newSViv(fh)));
- XPUSHs(sv_2mortal(newSVpv(buffer, 0)));
+ EXTEND(SP, 2);
+ PUSHs(sv_2mortal(newSViv(fh)));
+ PUSHs(sv_2mortal(newSVpv(buffer, 0)));
PUTBACK;
/* Call the Perl sub */
macros and read the stack using the C<ST> macro (See L<perlxs> for a
full description of the C<ST> macro).
-Most of the time the C<POP*> macros should be adequate, the main
+Most of the time the C<POP*> macros should be adequate; the main
problem with them is that they force you to process the returned values
in sequence. This may not be the most suitable way to process the
values in some cases. What we want is to be able to access the stack in
a random order. The C<ST> macro as used when coding an XSUB is ideal
for this purpose.
-The code below is the example given in the section I<Returning a list
-of
values> recoded to use C<ST> instead of C<POP*>.
+The code below is the example given in the section L</Returning a List
+of
Values> recoded to use C<ST> instead of C<POP*>.
static void
call_AddSubtract2(a, b)
SAVETMPS;
PUSHMARK(SP);
- XPUSHs(sv_2mortal(newSViv(a)));
- XPUSHs(sv_2mortal(newSViv(b)));
+ EXTEND(SP, 2);
+ PUSHs(sv_2mortal(newSViv(a)));
+ PUSHs(sv_2mortal(newSViv(b)));
PUTBACK;
count = call_pv("AddSubtract", G_ARRAY);
Notice that it was necessary to define the variable C<ax>. This is
because the C<ST> macro expects it to exist. If we were in an XSUB it
would not be necessary to define C<ax> as it is already defined for
-you.
+us.
=item 2.
=back
-=head2 Creating and calling an anonymous subroutine in C
+=head2 Creating and Calling an Anonymous Subroutine in C
As we've already shown, C<call_sv> can be used to invoke an
anonymous subroutine. However, our example showed a Perl script
...
- SV *cvrv = eval_pv("sub { print 'You will not find me cluttering any namespace!' }", TRUE);
+ SV *cvrv = eval_pv("sub {
+ print 'You will not find me cluttering any namespace!'
+ }", TRUE);
...
dMULTICALL; /* Declare local variables */
I32 gimme = G_SCALAR; /* context of the call: G_SCALAR,
- * G_LIST, or G_VOID */
+ * G_ARRAY, or G_VOID */
PUSH_MULTICALL(cv); /* Set up the context for calling cv,
and set local vars appropriately */
=head1 DATE
-Version 1.3, 14th Apr 1997
+Last updated for perl 5.23.1.
https://perl5.git.perl.org / perl5.git / blobdiff