This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
Add descriptions for $^E and $^O, and squash a typo.
[perl5.git] / pod / perlxs.pod
CommitLineData
a0d0e21e
LW
1=head1 NAME
2
8e07c86e 3perlxs - XS language reference manual
a0d0e21e
LW
4
5=head1 DESCRIPTION
6
7=head2 Introduction
8
9XS is a language used to create an extension interface
10between Perl and some C library which one wishes to use with
11Perl. The XS interface is combined with the library to
12create a new library which can be linked to Perl. An B<XSUB>
13is a function in the XS language and is the core component
14of the Perl application interface.
15
16The XS compiler is called B<xsubpp>. This compiler will embed
17the constructs necessary to let an XSUB, which is really a C
18function in disguise, manipulate Perl values and creates the
19glue necessary to let Perl access the XSUB. The compiler
20uses B<typemaps> to determine how to map C function parameters
21and variables to Perl values. The default typemap handles
22many common C types. A supplement typemap must be created
23to handle special structures and types for the library being
24linked.
25
cb1a09d0 26See L<perlxstut> for a tutorial on the whole extension creation process.
8e07c86e
AD
27
28=head2 On The Road
29
a5f75d66
AD
30Many of the examples which follow will concentrate on creating an interface
31between Perl and the ONC+ RPC bind library functions. The rpcb_gettime()
32function is used to demonstrate many features of the XS language. This
33function has two parameters; the first is an input parameter and the second
34is an output parameter. The function also returns a status value.
a0d0e21e
LW
35
36 bool_t rpcb_gettime(const char *host, time_t *timep);
37
38From C this function will be called with the following
39statements.
40
41 #include <rpc/rpc.h>
42 bool_t status;
43 time_t timep;
44 status = rpcb_gettime( "localhost", &timep );
45
46If an XSUB is created to offer a direct translation between this function
47and Perl, then this XSUB will be used from Perl with the following code.
48The $status and $timep variables will contain the output of the function.
49
50 use RPC;
51 $status = rpcb_gettime( "localhost", $timep );
52
53The following XS file shows an XS subroutine, or XSUB, which
54demonstrates one possible interface to the rpcb_gettime()
55function. This XSUB represents a direct translation between
56C and Perl and so preserves the interface even from Perl.
57This XSUB will be invoked from Perl with the usage shown
58above. Note that the first three #include statements, for
59C<EXTERN.h>, C<perl.h>, and C<XSUB.h>, will always be present at the
60beginning of an XS file. This approach and others will be
61expanded later in this document.
62
63 #include "EXTERN.h"
64 #include "perl.h"
65 #include "XSUB.h"
66 #include <rpc/rpc.h>
67
68 MODULE = RPC PACKAGE = RPC
69
70 bool_t
71 rpcb_gettime(host,timep)
8e07c86e
AD
72 char *host
73 time_t &timep
a0d0e21e
LW
74 OUTPUT:
75 timep
76
77Any extension to Perl, including those containing XSUBs,
78should have a Perl module to serve as the bootstrap which
79pulls the extension into Perl. This module will export the
80extension's functions and variables to the Perl program and
81will cause the extension's XSUBs to be linked into Perl.
82The following module will be used for most of the examples
83in this document and should be used from Perl with the C<use>
84command as shown earlier. Perl modules are explained in
85more detail later in this document.
86
87 package RPC;
88
89 require Exporter;
90 require DynaLoader;
91 @ISA = qw(Exporter DynaLoader);
92 @EXPORT = qw( rpcb_gettime );
93
94 bootstrap RPC;
95 1;
96
97Throughout this document a variety of interfaces to the rpcb_gettime()
98XSUB will be explored. The XSUBs will take their parameters in different
99orders or will take different numbers of parameters. In each case the
100XSUB is an abstraction between Perl and the real C rpcb_gettime()
101function, and the XSUB must always ensure that the real rpcb_gettime()
102function is called with the correct parameters. This abstraction will
103allow the programmer to create a more Perl-like interface to the C
104function.
105
106=head2 The Anatomy of an XSUB
107
8e07c86e
AD
108The following XSUB allows a Perl program to access a C library function
109called sin(). The XSUB will imitate the C function which takes a single
110argument and returns a single value.
a0d0e21e
LW
111
112 double
113 sin(x)
8e07c86e 114 double x
a0d0e21e 115
8e07c86e
AD
116When using C pointers the indirection operator C<*> should be considered
117part of the type and the address operator C<&> should be considered part of
118the variable, as is demonstrated in the rpcb_gettime() function above. See
119the section on typemaps for more about handling qualifiers and unary
120operators in C types.
a0d0e21e 121
a0d0e21e
LW
122The function name and the return type must be placed on
123separate lines.
124
125 INCORRECT CORRECT
126
127 double sin(x) double
8e07c86e
AD
128 double x sin(x)
129 double x
a0d0e21e 130
c07a80fd
PP
131The function body may be indented or left-adjusted. The following example
132shows a function with its body left-adjusted. Most examples in this
133document will indent the body.
134
135 CORRECT
136
137 double
138 sin(x)
139 double x
140
a0d0e21e
LW
141=head2 The Argument Stack
142
143The argument stack is used to store the values which are
144sent as parameters to the XSUB and to store the XSUB's
145return value. In reality all Perl functions keep their
146values on this stack at the same time, each limited to its
147own range of positions on the stack. In this document the
148first position on that stack which belongs to the active
149function will be referred to as position 0 for that function.
150
8e07c86e
AD
151XSUBs refer to their stack arguments with the macro B<ST(x)>, where I<x>
152refers to a position in this XSUB's part of the stack. Position 0 for that
a0d0e21e
LW
153function would be known to the XSUB as ST(0). The XSUB's incoming
154parameters and outgoing return values always begin at ST(0). For many
155simple cases the B<xsubpp> compiler will generate the code necessary to
156handle the argument stack by embedding code fragments found in the
157typemaps. In more complex cases the programmer must supply the code.
158
159=head2 The RETVAL Variable
160
161The RETVAL variable is a magic variable which always matches
162the return type of the C library function. The B<xsubpp> compiler will
163supply this variable in each XSUB and by default will use it to hold the
164return value of the C library function being called. In simple cases the
165value of RETVAL will be placed in ST(0) of the argument stack where it can
166be received by Perl as the return value of the XSUB.
167
168If the XSUB has a return type of C<void> then the compiler will
169not supply a RETVAL variable for that function. When using
170the PPCODE: directive the RETVAL variable may not be needed.
171
172=head2 The MODULE Keyword
173
174The MODULE keyword is used to start the XS code and to
175specify the package of the functions which are being
176defined. All text preceding the first MODULE keyword is
177considered C code and is passed through to the output
178untouched. Every XS module will have a bootstrap function
179which is used to hook the XSUBs into Perl. The package name
180of this bootstrap function will match the value of the last
181MODULE statement in the XS source files. The value of
182MODULE should always remain constant within the same XS
183file, though this is not required.
184
185The following example will start the XS code and will place
186all functions in a package named RPC.
187
188 MODULE = RPC
189
190=head2 The PACKAGE Keyword
191
192When functions within an XS source file must be separated into packages
193the PACKAGE keyword should be used. This keyword is used with the MODULE
194keyword and must follow immediately after it when used.
195
196 MODULE = RPC PACKAGE = RPC
197
198 [ XS code in package RPC ]
199
200 MODULE = RPC PACKAGE = RPCB
201
202 [ XS code in package RPCB ]
203
204 MODULE = RPC PACKAGE = RPC
205
206 [ XS code in package RPC ]
207
208Although this keyword is optional and in some cases provides redundant
209information it should always be used. This keyword will ensure that the
210XSUBs appear in the desired package.
211
212=head2 The PREFIX Keyword
213
214The PREFIX keyword designates prefixes which should be
215removed from the Perl function names. If the C function is
216C<rpcb_gettime()> and the PREFIX value is C<rpcb_> then Perl will
217see this function as C<gettime()>.
218
219This keyword should follow the PACKAGE keyword when used.
220If PACKAGE is not used then PREFIX should follow the MODULE
221keyword.
222
223 MODULE = RPC PREFIX = rpc_
224
225 MODULE = RPC PACKAGE = RPCB PREFIX = rpcb_
226
227=head2 The OUTPUT: Keyword
228
229The OUTPUT: keyword indicates that certain function parameters should be
230updated (new values made visible to Perl) when the XSUB terminates or that
231certain values should be returned to the calling Perl function. For
232simple functions, such as the sin() function above, the RETVAL variable is
233automatically designated as an output value. In more complex functions
234the B<xsubpp> compiler will need help to determine which variables are output
235variables.
236
237This keyword will normally be used to complement the CODE: keyword.
238The RETVAL variable is not recognized as an output variable when the
239CODE: keyword is present. The OUTPUT: keyword is used in this
240situation to tell the compiler that RETVAL really is an output
241variable.
242
243The OUTPUT: keyword can also be used to indicate that function parameters
244are output variables. This may be necessary when a parameter has been
245modified within the function and the programmer would like the update to
8e07c86e 246be seen by Perl.
a0d0e21e
LW
247
248 bool_t
249 rpcb_gettime(host,timep)
8e07c86e
AD
250 char *host
251 time_t &timep
a0d0e21e
LW
252 OUTPUT:
253 timep
254
255The OUTPUT: keyword will also allow an output parameter to
256be mapped to a matching piece of code rather than to a
257typemap.
258
259 bool_t
260 rpcb_gettime(host,timep)
8e07c86e
AD
261 char *host
262 time_t &timep
a0d0e21e 263 OUTPUT:
8e07c86e 264 timep sv_setnv(ST(1), (double)timep);
a0d0e21e
LW
265
266=head2 The CODE: Keyword
267
268This keyword is used in more complicated XSUBs which require
269special handling for the C function. The RETVAL variable is
270available but will not be returned unless it is specified
271under the OUTPUT: keyword.
272
273The following XSUB is for a C function which requires special handling of
274its parameters. The Perl usage is given first.
275
276 $status = rpcb_gettime( "localhost", $timep );
277
278The XSUB follows.
279
d1b91892
AD
280 bool_t
281 rpcb_gettime(host,timep)
8e07c86e
AD
282 char *host
283 time_t timep
a0d0e21e
LW
284 CODE:
285 RETVAL = rpcb_gettime( host, &timep );
286 OUTPUT:
287 timep
288 RETVAL
289
c07a80fd
PP
290=head2 The INIT: Keyword
291
292The INIT: keyword allows initialization to be inserted into the XSUB before
293the compiler generates the call to the C function. Unlike the CODE: keyword
294above, this keyword does not affect the way the compiler handles RETVAL.
295
296 bool_t
297 rpcb_gettime(host,timep)
298 char *host
299 time_t &timep
300 INIT:
301 printf("# Host is %s\n", host );
302 OUTPUT:
303 timep
a0d0e21e
LW
304
305=head2 The NO_INIT Keyword
306
307The NO_INIT keyword is used to indicate that a function
d1b91892 308parameter is being used as only an output value. The B<xsubpp>
a0d0e21e
LW
309compiler will normally generate code to read the values of
310all function parameters from the argument stack and assign
311them to C variables upon entry to the function. NO_INIT
312will tell the compiler that some parameters will be used for
313output rather than for input and that they will be handled
314before the function terminates.
315
316The following example shows a variation of the rpcb_gettime() function.
d1b91892 317This function uses the timep variable as only an output variable and does
a0d0e21e
LW
318not care about its initial contents.
319
320 bool_t
321 rpcb_gettime(host,timep)
8e07c86e
AD
322 char *host
323 time_t &timep = NO_INIT
a0d0e21e
LW
324 OUTPUT:
325 timep
326
327=head2 Initializing Function Parameters
328
329Function parameters are normally initialized with their
330values from the argument stack. The typemaps contain the
331code segments which are used to transfer the Perl values to
332the C parameters. The programmer, however, is allowed to
333override the typemaps and supply alternate initialization
334code.
335
336The following code demonstrates how to supply initialization code for
337function parameters. The initialization code is eval'd by the compiler
338before it is added to the output so anything which should be interpreted
339literally, such as double quotes, must be protected with backslashes.
340
341 bool_t
342 rpcb_gettime(host,timep)
8e07c86e
AD
343 char *host = (char *)SvPV(ST(0),na);
344 time_t &timep = 0;
a0d0e21e
LW
345 OUTPUT:
346 timep
347
348This should not be used to supply default values for parameters. One
349would normally use this when a function parameter must be processed by
350another library function before it can be used. Default parameters are
351covered in the next section.
352
353=head2 Default Parameter Values
354
355Default values can be specified for function parameters by
356placing an assignment statement in the parameter list. The
357default value may be a number or a string. Defaults should
358always be used on the right-most parameters only.
359
360To allow the XSUB for rpcb_gettime() to have a default host
361value the parameters to the XSUB could be rearranged. The
362XSUB will then call the real rpcb_gettime() function with
363the parameters in the correct order. Perl will call this
364XSUB with either of the following statements.
365
366 $status = rpcb_gettime( $timep, $host );
367
368 $status = rpcb_gettime( $timep );
369
370The XSUB will look like the code which follows. A CODE:
371block is used to call the real rpcb_gettime() function with
372the parameters in the correct order for that function.
373
374 bool_t
375 rpcb_gettime(timep,host="localhost")
8e07c86e
AD
376 char *host
377 time_t timep = NO_INIT
a0d0e21e
LW
378 CODE:
379 RETVAL = rpcb_gettime( host, &timep );
380 OUTPUT:
381 timep
382 RETVAL
383
c07a80fd
PP
384=head2 The PREINIT: Keyword
385
386The PREINIT: keyword allows extra variables to be declared before the
387typemaps are expanded. If a variable is declared in a CODE: block then that
388variable will follow any typemap code. This may result in a C syntax
389error. To force the variable to be declared before the typemap code, place
390it into a PREINIT: block. The PREINIT: keyword may be used one or more
391times within an XSUB.
392
393The following examples are equivalent, but if the code is using complex
394typemaps then the first example is safer.
395
396 bool_t
397 rpcb_gettime(timep)
398 time_t timep = NO_INIT
399 PREINIT:
400 char *host = "localhost";
401 CODE:
402 RETVAL = rpcb_gettime( host, &timep );
403 OUTPUT:
404 timep
405 RETVAL
406
407A correct, but error-prone example.
408
409 bool_t
410 rpcb_gettime(timep)
411 time_t timep = NO_INIT
412 CODE:
413 char *host = "localhost";
414 RETVAL = rpcb_gettime( host, &timep );
415 OUTPUT:
416 timep
417 RETVAL
418
419=head2 The INPUT: Keyword
420
421The XSUB's parameters are usually evaluated immediately after entering the
422XSUB. The INPUT: keyword can be used to force those parameters to be
423evaluated a little later. The INPUT: keyword can be used multiple times
424within an XSUB and can be used to list one or more input variables. This
425keyword is used with the PREINIT: keyword.
426
427The following example shows how the input parameter C<timep> can be
428evaluated late, after a PREINIT.
429
430 bool_t
431 rpcb_gettime(host,timep)
432 char *host
433 PREINIT:
434 time_t tt;
435 INPUT:
436 time_t timep
437 CODE:
438 RETVAL = rpcb_gettime( host, &tt );
439 timep = tt;
440 OUTPUT:
441 timep
442 RETVAL
443
444The next example shows each input parameter evaluated late.
445
446 bool_t
447 rpcb_gettime(host,timep)
448 PREINIT:
449 time_t tt;
450 INPUT:
451 char *host
452 PREINIT:
453 char *h;
454 INPUT:
455 time_t timep
456 CODE:
457 h = host;
458 RETVAL = rpcb_gettime( h, &tt );
459 timep = tt;
460 OUTPUT:
461 timep
462 RETVAL
463
a0d0e21e
LW
464=head2 Variable-length Parameter Lists
465
466XSUBs can have variable-length parameter lists by specifying an ellipsis
467C<(...)> in the parameter list. This use of the ellipsis is similar to that
468found in ANSI C. The programmer is able to determine the number of
469arguments passed to the XSUB by examining the C<items> variable which the
470B<xsubpp> compiler supplies for all XSUBs. By using this mechanism one can
471create an XSUB which accepts a list of parameters of unknown length.
472
473The I<host> parameter for the rpcb_gettime() XSUB can be
474optional so the ellipsis can be used to indicate that the
475XSUB will take a variable number of parameters. Perl should
d1b91892 476be able to call this XSUB with either of the following statements.
a0d0e21e
LW
477
478 $status = rpcb_gettime( $timep, $host );
479
480 $status = rpcb_gettime( $timep );
481
482The XS code, with ellipsis, follows.
483
484 bool_t
485 rpcb_gettime(timep, ...)
8e07c86e 486 time_t timep = NO_INIT
c07a80fd 487 PREINIT:
a0d0e21e 488 char *host = "localhost";
c07a80fd
PP
489 CODE:
490 if( items > 1 )
491 host = (char *)SvPV(ST(1), na);
492 RETVAL = rpcb_gettime( host, &timep );
a0d0e21e
LW
493 OUTPUT:
494 timep
495 RETVAL
496
497=head2 The PPCODE: Keyword
498
499The PPCODE: keyword is an alternate form of the CODE: keyword and is used
500to tell the B<xsubpp> compiler that the programmer is supplying the code to
d1b91892 501control the argument stack for the XSUBs return values. Occasionally one
a0d0e21e
LW
502will want an XSUB to return a list of values rather than a single value.
503In these cases one must use PPCODE: and then explicitly push the list of
504values on the stack. The PPCODE: and CODE: keywords are not used
505together within the same XSUB.
506
507The following XSUB will call the C rpcb_gettime() function
508and will return its two output values, timep and status, to
509Perl as a single list.
510
d1b91892
AD
511 void
512 rpcb_gettime(host)
8e07c86e 513 char *host
c07a80fd 514 PREINIT:
a0d0e21e
LW
515 time_t timep;
516 bool_t status;
c07a80fd 517 PPCODE:
a0d0e21e
LW
518 status = rpcb_gettime( host, &timep );
519 EXTEND(sp, 2);
cb1a09d0
AD
520 PUSHs(sv_2mortal(newSViv(status)));
521 PUSHs(sv_2mortal(newSViv(timep)));
a0d0e21e
LW
522
523Notice that the programmer must supply the C code necessary
524to have the real rpcb_gettime() function called and to have
525the return values properly placed on the argument stack.
526
527The C<void> return type for this function tells the B<xsubpp> compiler that
528the RETVAL variable is not needed or used and that it should not be created.
529In most scenarios the void return type should be used with the PPCODE:
530directive.
531
532The EXTEND() macro is used to make room on the argument
533stack for 2 return values. The PPCODE: directive causes the
534B<xsubpp> compiler to create a stack pointer called C<sp>, and it
535is this pointer which is being used in the EXTEND() macro.
536The values are then pushed onto the stack with the PUSHs()
537macro.
538
539Now the rpcb_gettime() function can be used from Perl with
540the following statement.
541
542 ($status, $timep) = rpcb_gettime("localhost");
543
544=head2 Returning Undef And Empty Lists
545
d1b91892 546Occasionally the programmer will want to simply return
a0d0e21e
LW
547C<undef> or an empty list if a function fails rather than a
548separate status value. The rpcb_gettime() function offers
549just this situation. If the function succeeds we would like
550to have it return the time and if it fails we would like to
551have undef returned. In the following Perl code the value
552of $timep will either be undef or it will be a valid time.
553
554 $timep = rpcb_gettime( "localhost" );
555
556The following XSUB uses the C<void> return type to disable the generation of
557the RETVAL variable and uses a CODE: block to indicate to the compiler
558that the programmer has supplied all the necessary code. The
559sv_newmortal() call will initialize the return value to undef, making that
560the default return value.
561
562 void
563 rpcb_gettime(host)
564 char * host
c07a80fd 565 PREINIT:
a0d0e21e
LW
566 time_t timep;
567 bool_t x;
c07a80fd 568 CODE:
a0d0e21e
LW
569 ST(0) = sv_newmortal();
570 if( rpcb_gettime( host, &timep ) )
571 sv_setnv( ST(0), (double)timep);
a0d0e21e
LW
572
573The next example demonstrates how one would place an explicit undef in the
574return value, should the need arise.
575
576 void
577 rpcb_gettime(host)
578 char * host
c07a80fd 579 PREINIT:
a0d0e21e
LW
580 time_t timep;
581 bool_t x;
c07a80fd 582 CODE:
a0d0e21e
LW
583 ST(0) = sv_newmortal();
584 if( rpcb_gettime( host, &timep ) ){
585 sv_setnv( ST(0), (double)timep);
586 }
587 else{
588 ST(0) = &sv_undef;
589 }
a0d0e21e
LW
590
591To return an empty list one must use a PPCODE: block and
592then not push return values on the stack.
593
594 void
595 rpcb_gettime(host)
8e07c86e 596 char *host
c07a80fd 597 PREINIT:
a0d0e21e 598 time_t timep;
c07a80fd 599 PPCODE:
a0d0e21e 600 if( rpcb_gettime( host, &timep ) )
cb1a09d0 601 PUSHs(sv_2mortal(newSViv(timep)));
a0d0e21e
LW
602 else{
603 /* Nothing pushed on stack, so an empty */
604 /* list is implicitly returned. */
605 }
a0d0e21e 606
4633a7c4
LW
607=head2 The REQUIRE: Keyword
608
609The REQUIRE: keyword is used to indicate the minimum version of the
610B<xsubpp> compiler needed to compile the XS module. An XS module which
611contains the following statement will only compile with B<xsubpp> version
6121.922 or greater:
613
614 REQUIRE: 1.922
615
a0d0e21e
LW
616=head2 The CLEANUP: Keyword
617
618This keyword can be used when an XSUB requires special cleanup procedures
619before it terminates. When the CLEANUP: keyword is used it must follow
620any CODE:, PPCODE:, or OUTPUT: blocks which are present in the XSUB. The
621code specified for the cleanup block will be added as the last statements
622in the XSUB.
623
624=head2 The BOOT: Keyword
625
626The BOOT: keyword is used to add code to the extension's bootstrap
627function. The bootstrap function is generated by the B<xsubpp> compiler and
628normally holds the statements necessary to register any XSUBs with Perl.
629With the BOOT: keyword the programmer can tell the compiler to add extra
630statements to the bootstrap function.
631
632This keyword may be used any time after the first MODULE keyword and should
633appear on a line by itself. The first blank line after the keyword will
634terminate the code block.
635
636 BOOT:
637 # The following message will be printed when the
638 # bootstrap function executes.
639 printf("Hello from the bootstrap!\n");
640
c07a80fd
PP
641=head2 The VERSIONCHECK: Keyword
642
643The VERSIONCHECK: keyword corresponds to B<xsubpp>'s C<-versioncheck> and
644C<-noversioncheck> options. This keyword overrides the commandline
645options. Version checking is enabled by default. When version checking is
646enabled the XS module will attempt to verify that its version matches the
647version of the PM module.
648
649To enable version checking:
650
651 VERSIONCHECK: ENABLE
652
653To disable version checking:
654
655 VERSIONCHECK: DISABLE
656
657=head2 The PROTOTYPES: Keyword
658
659The PROTOTYPES: keyword corresponds to B<xsubpp>'s C<-prototypes> and
660C<-noprototypes> options. This keyword overrides the commandline options.
661Prototypes are enabled by default. When prototypes are enabled XSUBs will
662be given Perl prototypes. This keyword may be used multiple times in an XS
663module to enable and disable prototypes for different parts of the module.
664
665To enable prototypes:
666
667 PROTOTYPES: ENABLE
668
669To disable prototypes:
670
671 PROTOTYPES: DISABLE
672
673=head2 The PROTOTYPE: Keyword
674
675This keyword is similar to the PROTOTYPES: keyword above but can be used to
676force B<xsubpp> to use a specific prototype for the XSUB. This keyword
677overrides all other prototype options and keywords but affects only the
678current XSUB. Consult L<perlsub/Prototypes> for information about Perl
679prototypes.
680
681 bool_t
682 rpcb_gettime(timep, ...)
683 time_t timep = NO_INIT
684 PROTOTYPE: $;$
685 PREINIT:
686 char *host = "localhost";
687 CODE:
688 if( items > 1 )
689 host = (char *)SvPV(ST(1), na);
690 RETVAL = rpcb_gettime( host, &timep );
691 OUTPUT:
692 timep
693 RETVAL
694
695=head2 The ALIAS: Keyword
696
697The ALIAS: keyword allows an XSUB to have two more more unique Perl names
698and to know which of those names was used when it was invoked. The Perl
699names may be fully-qualified with package names. Each alias is given an
700index. The compiler will setup a variable called C<ix> which contain the
701index of the alias which was used. When the XSUB is called with its
702declared name C<ix> will be 0.
703
704The following example will create aliases C<FOO::gettime()> and
705C<BAR::getit()> for this function.
706
707 bool_t
708 rpcb_gettime(host,timep)
709 char *host
710 time_t &timep
711 ALIAS:
712 FOO::gettime = 1
713 BAR::getit = 2
714 INIT:
715 printf("# ix = %d\n", ix );
716 OUTPUT:
717 timep
718
719=head2 The INCLUDE: Keyword
720
721This keyword can be used to pull other files into the XS module. The other
722files may have XS code. INCLUDE: can also be used to run a command to
723generate the XS code to be pulled into the module.
724
725The file F<Rpcb1.xsh> contains our C<rpcb_gettime()> function:
726
727 bool_t
728 rpcb_gettime(host,timep)
729 char *host
730 time_t &timep
731 OUTPUT:
732 timep
733
734The XS module can use INCLUDE: to pull that file into it.
735
736 INCLUDE: Rpcb1.xsh
737
738If the parameters to the INCLUDE: keyword are followed by a pipe (C<|>) then
739the compiler will interpret the parameters as a command.
740
741 INCLUDE: cat Rpcb1.xsh |
742
743=head2 The CASE: Keyword
744
745The CASE: keyword allows an XSUB to have multiple distinct parts with each
746part acting as a virtual XSUB. CASE: is greedy and if it is used then all
747other XS keywords must be contained within a CASE:. This means nothing may
748precede the first CASE: in the XSUB and anything following the last CASE: is
749included in that case.
750
751A CASE: might switch via a parameter of the XSUB, via the C<ix> ALIAS:
752variable (see L<"The ALIAS: Keyword">), or maybe via the C<items> variable
753(see L<"Variable-length Parameter Lists">). The last CASE: becomes the
754B<default> case if it is not associated with a conditional. The following
755example shows CASE switched via C<ix> with a function C<rpcb_gettime()>
756having an alias C<x_gettime()>. When the function is called as
757C<rpcb_gettime()> it's parameters are the usual C<(char *host, time_t
758*timep)>, but when the function is called as C<x_gettime()> is parameters are
759reversed, C<(time_t *timep, char *host)>.
760
761 long
762 rpcb_gettime(a,b)
763 CASE: ix == 1
764 ALIAS:
765 x_gettime = 1
766 INPUT:
767 # 'a' is timep, 'b' is host
768 char *b
769 time_t a = NO_INIT
770 CODE:
771 RETVAL = rpcb_gettime( b, &a );
772 OUTPUT:
773 a
774 RETVAL
775 CASE:
776 # 'a' is host, 'b' is timep
777 char *a
778 time_t &b = NO_INIT
779 OUTPUT:
780 b
781 RETVAL
782
783That function can be called with either of the following statements. Note
784the different argument lists.
785
786 $status = rpcb_gettime( $host, $timep );
787
788 $status = x_gettime( $timep, $host );
789
790=head2 The & Unary Operator
791
792The & unary operator is used to tell the compiler that it should dereference
793the object when it calls the C function. This is used when a CODE: block is
794not used and the object is a not a pointer type (the object is an C<int> or
795C<long> but not a C<int*> or C<long*>).
796
797The following XSUB will generate incorrect C code. The xsubpp compiler will
798turn this into code which calls C<rpcb_gettime()> with parameters C<(char
799*host, time_t timep)>, but the real C<rpcb_gettime()> wants the C<timep>
800parameter to be of type C<time_t*> rather than C<time_t>.
801
802 bool_t
803 rpcb_gettime(host,timep)
804 char *host
805 time_t timep
806 OUTPUT:
807 timep
808
809That problem is corrected by using the C<&> operator. The xsubpp compiler
810will now turn this into code which calls C<rpcb_gettime()> correctly with
811parameters C<(char *host, time_t *timep)>. It does this by carrying the
812C<&> through, so the function call looks like C<rpcb_gettime(host, &timep)>.
813
814 bool_t
815 rpcb_gettime(host,timep)
816 char *host
817 time_t &timep
818 OUTPUT:
819 timep
820
a0d0e21e
LW
821=head2 Inserting Comments and C Preprocessor Directives
822
823Comments and C preprocessor directives are allowed within
824CODE:, PPCODE:, BOOT:, and CLEANUP: blocks. The compiler
825will pass the preprocessor directives through untouched and
826will remove the commented lines. Comments can be added to
827XSUBs by placing a C<#> at the beginning of the line. Care
828should be taken to avoid making the comment look like a C
829preprocessor directive, lest it be interpreted as such.
830
831=head2 Using XS With C++
832
833If a function is defined as a C++ method then it will assume
834its first argument is an object pointer. The object pointer
835will be stored in a variable called THIS. The object should
836have been created by C++ with the new() function and should
cb1a09d0
AD
837be blessed by Perl with the sv_setref_pv() macro. The
838blessing of the object by Perl can be handled by a typemap. An example
839typemap is shown at the end of this section.
a0d0e21e
LW
840
841If the method is defined as static it will call the C++
842function using the class::method() syntax. If the method is not static
843the function will be called using the THIS->method() syntax.
844
cb1a09d0 845The next examples will use the following C++ class.
a0d0e21e 846
a5f75d66 847 class color {
cb1a09d0 848 public:
a5f75d66
AD
849 color();
850 ~color();
cb1a09d0
AD
851 int blue();
852 void set_blue( int );
853
854 private:
855 int c_blue;
856 };
857
858The XSUBs for the blue() and set_blue() methods are defined with the class
859name but the parameter for the object (THIS, or "self") is implicit and is
860not listed.
861
862 int
863 color::blue()
a0d0e21e
LW
864
865 void
cb1a09d0
AD
866 color::set_blue( val )
867 int val
a0d0e21e 868
cb1a09d0
AD
869Both functions will expect an object as the first parameter. The xsubpp
870compiler will call that object C<THIS> and will use it to call the specified
871method. So in the C++ code the blue() and set_blue() methods will be called
872in the following manner.
a0d0e21e 873
cb1a09d0 874 RETVAL = THIS->blue();
a0d0e21e 875
cb1a09d0 876 THIS->set_blue( val );
a0d0e21e 877
cb1a09d0
AD
878If the function's name is B<DESTROY> then the C++ C<delete> function will be
879called and C<THIS> will be given as its parameter.
a0d0e21e 880
d1b91892 881 void
cb1a09d0
AD
882 color::DESTROY()
883
884The C++ code will call C<delete>.
885
886 delete THIS;
a0d0e21e 887
cb1a09d0
AD
888If the function's name is B<new> then the C++ C<new> function will be called
889to create a dynamic C++ object. The XSUB will expect the class name, which
890will be kept in a variable called C<CLASS>, to be given as the first
891argument.
a0d0e21e 892
cb1a09d0
AD
893 color *
894 color::new()
a0d0e21e 895
cb1a09d0 896The C++ code will call C<new>.
a0d0e21e 897
cb1a09d0
AD
898 RETVAL = new color();
899
900The following is an example of a typemap that could be used for this C++
901example.
902
903 TYPEMAP
904 color * O_OBJECT
905
906 OUTPUT
907 # The Perl object is blessed into 'CLASS', which should be a
908 # char* having the name of the package for the blessing.
909 O_OBJECT
910 sv_setref_pv( $arg, CLASS, (void*)$var );
c07a80fd 911
cb1a09d0
AD
912 INPUT
913 O_OBJECT
914 if( sv_isobject($arg) && (SvTYPE(SvRV($arg)) == SVt_PVMG) )
915 $var = ($type)SvIV((SV*)SvRV( $arg ));
916 else{
917 warn( \"${Package}::$func_name() -- $var is not a blessed SV reference\" );
918 XSRETURN_UNDEF;
919 }
a0d0e21e 920
d1b91892 921=head2 Interface Strategy
a0d0e21e
LW
922
923When designing an interface between Perl and a C library a straight
924translation from C to XS is often sufficient. The interface will often be
925very C-like and occasionally nonintuitive, especially when the C function
926modifies one of its parameters. In cases where the programmer wishes to
927create a more Perl-like interface the following strategy may help to
928identify the more critical parts of the interface.
929
930Identify the C functions which modify their parameters. The XSUBs for
931these functions may be able to return lists to Perl, or may be
932candidates to return undef or an empty list in case of failure.
933
d1b91892 934Identify which values are used by only the C and XSUB functions
a0d0e21e
LW
935themselves. If Perl does not need to access the contents of the value
936then it may not be necessary to provide a translation for that value
937from C to Perl.
938
939Identify the pointers in the C function parameter lists and return
940values. Some pointers can be handled in XS with the & unary operator on
941the variable name while others will require the use of the * operator on
942the type name. In general it is easier to work with the & operator.
943
944Identify the structures used by the C functions. In many
945cases it may be helpful to use the T_PTROBJ typemap for
946these structures so they can be manipulated by Perl as
947blessed objects.
948
a0d0e21e
LW
949=head2 Perl Objects And C Structures
950
951When dealing with C structures one should select either
952B<T_PTROBJ> or B<T_PTRREF> for the XS type. Both types are
953designed to handle pointers to complex objects. The
954T_PTRREF type will allow the Perl object to be unblessed
955while the T_PTROBJ type requires that the object be blessed.
956By using T_PTROBJ one can achieve a form of type-checking
d1b91892 957because the XSUB will attempt to verify that the Perl object
a0d0e21e
LW
958is of the expected type.
959
960The following XS code shows the getnetconfigent() function which is used
8e07c86e 961with ONC+ TIRPC. The getnetconfigent() function will return a pointer to a
a0d0e21e
LW
962C structure and has the C prototype shown below. The example will
963demonstrate how the C pointer will become a Perl reference. Perl will
964consider this reference to be a pointer to a blessed object and will
965attempt to call a destructor for the object. A destructor will be
966provided in the XS source to free the memory used by getnetconfigent().
967Destructors in XS can be created by specifying an XSUB function whose name
968ends with the word B<DESTROY>. XS destructors can be used to free memory
969which may have been malloc'd by another XSUB.
970
971 struct netconfig *getnetconfigent(const char *netid);
972
973A C<typedef> will be created for C<struct netconfig>. The Perl
974object will be blessed in a class matching the name of the C
975type, with the tag C<Ptr> appended, and the name should not
976have embedded spaces if it will be a Perl package name. The
977destructor will be placed in a class corresponding to the
978class of the object and the PREFIX keyword will be used to
979trim the name to the word DESTROY as Perl will expect.
980
981 typedef struct netconfig Netconfig;
982
983 MODULE = RPC PACKAGE = RPC
984
985 Netconfig *
986 getnetconfigent(netid)
8e07c86e 987 char *netid
a0d0e21e
LW
988
989 MODULE = RPC PACKAGE = NetconfigPtr PREFIX = rpcb_
990
991 void
992 rpcb_DESTROY(netconf)
8e07c86e 993 Netconfig *netconf
a0d0e21e
LW
994 CODE:
995 printf("Now in NetconfigPtr::DESTROY\n");
996 free( netconf );
997
998This example requires the following typemap entry. Consult the typemap
999section for more information about adding new typemaps for an extension.
1000
1001 TYPEMAP
1002 Netconfig * T_PTROBJ
1003
1004This example will be used with the following Perl statements.
1005
1006 use RPC;
1007 $netconf = getnetconfigent("udp");
1008
1009When Perl destroys the object referenced by $netconf it will send the
1010object to the supplied XSUB DESTROY function. Perl cannot determine, and
1011does not care, that this object is a C struct and not a Perl object. In
1012this sense, there is no difference between the object created by the
1013getnetconfigent() XSUB and an object created by a normal Perl subroutine.
1014
a0d0e21e
LW
1015=head2 The Typemap
1016
1017The typemap is a collection of code fragments which are used by the B<xsubpp>
1018compiler to map C function parameters and values to Perl values. The
1019typemap file may consist of three sections labeled C<TYPEMAP>, C<INPUT>, and
1020C<OUTPUT>. The INPUT section tells the compiler how to translate Perl values
1021into variables of certain C types. The OUTPUT section tells the compiler
1022how to translate the values from certain C types into values Perl can
1023understand. The TYPEMAP section tells the compiler which of the INPUT and
1024OUTPUT code fragments should be used to map a given C type to a Perl value.
1025Each of the sections of the typemap must be preceded by one of the TYPEMAP,
1026INPUT, or OUTPUT keywords.
1027
1028The default typemap in the C<ext> directory of the Perl source contains many
1029useful types which can be used by Perl extensions. Some extensions define
1030additional typemaps which they keep in their own directory. These
1031additional typemaps may reference INPUT and OUTPUT maps in the main
1032typemap. The B<xsubpp> compiler will allow the extension's own typemap to
1033override any mappings which are in the default typemap.
1034
1035Most extensions which require a custom typemap will need only the TYPEMAP
1036section of the typemap file. The custom typemap used in the
1037getnetconfigent() example shown earlier demonstrates what may be the typical
1038use of extension typemaps. That typemap is used to equate a C structure
1039with the T_PTROBJ typemap. The typemap used by getnetconfigent() is shown
1040here. Note that the C type is separated from the XS type with a tab and
1041that the C unary operator C<*> is considered to be a part of the C type name.
1042
1043 TYPEMAP
1044 Netconfig *<tab>T_PTROBJ
1045
1046=head1 EXAMPLES
1047
1048File C<RPC.xs>: Interface to some ONC+ RPC bind library functions.
1049
1050 #include "EXTERN.h"
1051 #include "perl.h"
1052 #include "XSUB.h"
1053
1054 #include <rpc/rpc.h>
1055
1056 typedef struct netconfig Netconfig;
1057
1058 MODULE = RPC PACKAGE = RPC
1059
1060 void
1061 rpcb_gettime(host="localhost")
8e07c86e 1062 char *host
c07a80fd 1063 PREINIT:
a0d0e21e 1064 time_t timep;
c07a80fd 1065 CODE:
a0d0e21e
LW
1066 ST(0) = sv_newmortal();
1067 if( rpcb_gettime( host, &timep ) )
1068 sv_setnv( ST(0), (double)timep );
a0d0e21e
LW
1069
1070 Netconfig *
1071 getnetconfigent(netid="udp")
8e07c86e 1072 char *netid
a0d0e21e
LW
1073
1074 MODULE = RPC PACKAGE = NetconfigPtr PREFIX = rpcb_
1075
1076 void
1077 rpcb_DESTROY(netconf)
8e07c86e 1078 Netconfig *netconf
a0d0e21e
LW
1079 CODE:
1080 printf("NetconfigPtr::DESTROY\n");
1081 free( netconf );
1082
1083File C<typemap>: Custom typemap for RPC.xs.
1084
1085 TYPEMAP
1086 Netconfig * T_PTROBJ
1087
1088File C<RPC.pm>: Perl module for the RPC extension.
1089
1090 package RPC;
1091
1092 require Exporter;
1093 require DynaLoader;
1094 @ISA = qw(Exporter DynaLoader);
1095 @EXPORT = qw(rpcb_gettime getnetconfigent);
1096
1097 bootstrap RPC;
1098 1;
1099
1100File C<rpctest.pl>: Perl test program for the RPC extension.
1101
1102 use RPC;
1103
1104 $netconf = getnetconfigent();
1105 $a = rpcb_gettime();
1106 print "time = $a\n";
1107 print "netconf = $netconf\n";
1108
1109 $netconf = getnetconfigent("tcp");
1110 $a = rpcb_gettime("poplar");
1111 print "time = $a\n";
1112 print "netconf = $netconf\n";
1113
1114
c07a80fd
PP
1115=head1 XS VERSION
1116
a5f75d66 1117This document covers features supported by C<xsubpp> 1.933.
c07a80fd 1118
a0d0e21e
LW
1119=head1 AUTHOR
1120
d1b91892 1121Dean Roehrich F<E<lt>roehrich@cray.comE<gt>>
a5f75d66 1122Feb 13, 1996