perlembed - how to embed perl in your C program
Do you want to:
Read perlcall and perlxs.
Read about back-quotes and about system and exec in perlfunc.
system
exec
Read about do and eval in "do" in perlfunc and "eval" in perlfunc and use and require in perlmod and "require" in perlfunc, "use" in perlfunc.
do
eval
use
require
Rethink your design.
Read on...
"Compiling your C program"
There's one example in each of the eight sections:
"Adding a Perl interpreter to your C program"
"Calling a Perl subroutine from your C program"
"Evaluating a Perl statement from your C program"
"Performing Perl pattern matches and substitutions from your C program"
"Fiddling with the Perl stack from your C program"
"Maintaining a persistent interpreter"
"Maintaining multiple interpreter instances"
"Using Perl modules, which themselves use C libraries, from your C program"
This documentation is UNIX specific.
Every C program that uses Perl must link in the perl library.
What's that, you ask? Perl is itself written in C; the perl library is the collection of compiled C programs that were used to create your perl executable (/usr/bin/perl or equivalent). (Corollary: you can't use Perl from your C program unless Perl has been compiled on your machine, or installed properly--that's why you shouldn't blithely copy Perl executables from machine to machine without also copying the lib directory.)
Your C program will--usually--allocate, "run", and deallocate a PerlInterpreter object, which is defined in the perl library.
If your copy of Perl is recent enough to contain this documentation (version 5.002 or later), then the perl library (and EXTERN.h and perl.h, which you'll also need) will reside in a directory resembling this:
/usr/local/lib/perl5/your_architecture_here/CORE
or perhaps just
/usr/local/lib/perl5/CORE
or maybe something like
/usr/opt/perl5/CORE
Execute this statement for a hint about where to find CORE:
perl -MConfig -e 'print $Config{archlib}'
Here's how you might compile the example in the next section, "Adding a Perl interpreter to your C program", on a DEC Alpha running the OSF operating system:
% cc -o interp interp.c -L/usr/local/lib/perl5/alpha-dec_osf/CORE -I/usr/local/lib/perl5/alpha-dec_osf/CORE -lperl -lm
You'll have to choose the appropriate compiler (cc, gcc, et al.) and library directory (/usr/local/lib/...) for your machine. If your compiler complains that certain functions are undefined, or that it can't locate -lperl, then you need to change the path following the -L. If it complains that it can't find EXTERN.h or perl.h, you need to change the path following the -I.
You may have to add extra libraries as well. Which ones? Perhaps those printed by
perl -MConfig -e 'print $Config{libs}'
We strongly recommend you use the ExtUtils::Embed module to determine all of this information for you:
% cc -o interp interp.c `perl -MExtUtils::Embed -e ccopts -e ldopts`
If the ExtUtils::Embed module is not part of your perl kit's distribution you can retrieve it from: http://www.perl.com/cgi-bin/cpan_mod?module=ExtUtils::Embed.
In a sense, perl (the C program) is a good example of embedding Perl (the language), so I'll demonstrate embedding with miniperlmain.c, from the source distribution. Here's a bastardized, non-portable version of miniperlmain.c containing the essentials of embedding:
#include <EXTERN.h> /* from the Perl distribution */ #include <perl.h> /* from the Perl distribution */ static PerlInterpreter *my_perl; /*** The Perl interpreter ***/ int main(int argc, char **argv, char **env) { my_perl = perl_alloc(); perl_construct(my_perl); perl_parse(my_perl, NULL, argc, argv, (char **)NULL); perl_run(my_perl); perl_destruct(my_perl); perl_free(my_perl); }
Note that we do not use the env pointer here or in any of the following examples. Normally handed to perl_parse as its final argument, we hand it a NULL instead, in which case the current environment is used.
env
perl_parse
Now compile this program (I'll call it interp.c) into an executable:
After a successful compilation, you'll be able to use interp just like perl itself:
% interp print "Pretty Good Perl \n"; print "10890 - 9801 is ", 10890 - 9801; <CTRL-D> Pretty Good Perl 10890 - 9801 is 1089
or
% interp -e 'printf("%x", 3735928559)' deadbeef
You can also read and execute Perl statements from a file while in the midst of your C program, by placing the filename in argv[1] before calling perl_run().
To call individual Perl subroutines, you can use any of the perl_call_* functions documented in the perlcall man page. In this example we'll use perl_call_argv.
That's shown below, in a program I'll call showtime.c.
#include <EXTERN.h> #include <perl.h> static PerlInterpreter *my_perl; int main(int argc, char **argv, char **env) { char *args[] = { NULL }; my_perl = perl_alloc(); perl_construct(my_perl); perl_parse(my_perl, NULL, argc, argv, NULL); /*** skipping perl_run() ***/ perl_call_argv("showtime", G_DISCARD | G_NOARGS, args); perl_destruct(my_perl); perl_free(my_perl); }
where showtime is a Perl subroutine that takes no arguments (that's the G_NOARGS) and for which I'll ignore the return value (that's the G_DISCARD). Those flags, and others, are discussed in perlcall.
I'll define the showtime subroutine in a file called showtime.pl:
print "I shan't be printed."; sub showtime { print time; }
Simple enough. Now compile and run:
% cc -o showtime showtime.c `perl -MExtUtils::Embed -e ccopts -e ldopts` % showtime showtime.pl 818284590
yielding the number of seconds that elapsed between January 1, 1970 (the beginning of the UNIX epoch), and the moment I began writing this sentence.
Note that in this particular case we are not required to call perl_run, however, in general it's considered good practice to ensure proper initialization of library code including execution of all object DESTROY methods and package END {} blocks.
DESTROY
END {}
If you want to pass some arguments to the Perl subroutine, you may add strings to the NULL terminated args list passed to perl_call_argv. In order to pass arguments of another data type and/or examine return values of the subroutine you'll need to manipulate the Perl stack, demonstrated in the last section of this document: "Fiddling with the Perl stack from your C program"
NULL
args
One way to evaluate pieces of Perl code is to use "perl_eval_sv" in perlguts. We have wrapped this function with our own perl_eval() function, which converts a command string to an SV, passing this and the "G_DISCARD" in perlcall flag to "perl_eval_sv" in perlguts.
Arguably, this is the only routine you'll ever need to execute snippets of Perl code from within your C program. Your string can be as long as you wish; it can contain multiple statements; it can include "use" in perlfunc, "require" in perlfunc and "do" in perlfunc to include external Perl files.
Our perl_eval() lets us evaluate individual Perl strings, and then extract variables for coercion into C types. The following program, string.c, executes three Perl strings, extracting an int from the first, a float from the second, and a char * from the third.
int
float
char *
#include <EXTERN.h> #include <perl.h> static PerlInterpreter *my_perl; I32 perl_eval(char *string) { return perl_eval_sv(newSVpv(string,0), G_DISCARD); } main (int argc, char **argv, char **env) { char *embedding[] = { "", "-e", "0" }; STRLEN length; my_perl = perl_alloc(); perl_construct( my_perl ); perl_parse(my_perl, NULL, 3, embedding, NULL); perl_run(my_perl); /** Treat $a as an integer **/ perl_eval("$a = 3; $a **= 2"); printf("a = %d\n", SvIV(perl_get_sv("a", FALSE))); /** Treat $a as a float **/ perl_eval("$a = 3.14; $a **= 2"); printf("a = %f\n", SvNV(perl_get_sv("a", FALSE))); /** Treat $a as a string **/ perl_eval("$a = 'rekcaH lreP rehtonA tsuJ'; $a = reverse($a); "); printf("a = %s\n", SvPV(perl_get_sv("a", FALSE), length)); perl_destruct(my_perl); perl_free(my_perl); }
All of those strange functions with sv in their names help convert Perl scalars to C types. They're described in perlguts.
If you compile and run string.c, you'll see the results of using SvIV() to create an int, SvNV() to create a float, and SvPV() to create a string:
a = 9 a = 9.859600 a = Just Another Perl Hacker
Our perl_eval() lets us evaluate strings of Perl code, so we can define some functions that use it to "specialize" in matches and substitutions: match(), substitute(), and matches().
char match(char *string, char *pattern);
Given a string and a pattern (e.g., "m/clasp/" or "/\b\w*\b/", which in your program might be represented as "/\\b\\w*\\b/"), returns 1 if the string matches the pattern and 0 otherwise.
"/\\b\\w*\\b/"
int substitute(char *string[], char *pattern);
Given a pointer to a string and an "=~" operation (e.g., "s/bob/robert/g" or "tr[A-Z][a-z]"), modifies the string according to the operation, returning the number of substitutions made.
int matches(char *string, char *pattern, char **matches[]);
Given a string, a pattern, and a pointer to an empty array of strings, evaluates $string =~ $pattern in an array context, and fills in matches with the array elements (allocating memory as it does so), returning the number of matches found.
$string =~ $pattern
Here's a sample program, match.c, that uses all three (long lines have been wrapped here):
#include <EXTERN.h> #include <perl.h> static PerlInterpreter *my_perl; I32 perl_eval(char *string) { return perl_eval_sv(newSVpv(string,0), G_DISCARD); } /** match(string, pattern) ** ** Used for matches in a scalar context. ** ** Returns 1 if the match was successful; 0 otherwise. **/ char match(char *string, char *pattern) { char *command; command = malloc(sizeof(char) * strlen(string) + strlen(pattern) + 37); sprintf(command, "$string = '%s'; $return = $string =~ %s", string, pattern); perl_eval(command); free(command); return SvIV(perl_get_sv("return", FALSE)); } /** substitute(string, pattern) ** ** Used for =~ operations that modify their left-hand side (s/// and tr///) ** ** Returns the number of successful matches, and ** modifies the input string if there were any. **/ int substitute(char *string[], char *pattern) { char *command; STRLEN length; command = malloc(sizeof(char) * strlen(*string) + strlen(pattern) + 35); sprintf(command, "$string = '%s'; $ret = ($string =~ %s)", *string, pattern); perl_eval(command); free(command); *string = SvPV(perl_get_sv("string", FALSE), length); return SvIV(perl_get_sv("ret", FALSE)); } /** matches(string, pattern, matches) ** ** Used for matches in an array context. ** ** Returns the number of matches, ** and fills in **matches with the matching substrings (allocates memory!) **/ int matches(char *string, char *pattern, char **match_list[]) { char *command; SV *current_match; AV *array; I32 num_matches; STRLEN length; int i; command = malloc(sizeof(char) * strlen(string) + strlen(pattern) + 38); sprintf(command, "$string = '%s'; @array = ($string =~ %s)", string, pattern); perl_eval(command); free(command); array = perl_get_av("array", FALSE); num_matches = av_len(array) + 1; /** assume $[ is 0 **/ *match_list = (char **) malloc(sizeof(char *) * num_matches); for (i = 0; i <= num_matches; i++) { current_match = av_shift(array); (*match_list)[i] = SvPV(current_match, length); } return num_matches; } main (int argc, char **argv, char **env) { char *embedding[] = { "", "-e", "0" }; char *text, **match_list; int num_matches, i; int j; my_perl = perl_alloc(); perl_construct( my_perl ); perl_parse(my_perl, NULL, 3, embedding, NULL); perl_run(my_perl); text = (char *) malloc(sizeof(char) * 486); /** A long string follows! **/ sprintf(text, "%s", "When he is at a convenience store and the bill \ comes to some amount like 76 cents, Maynard is aware that there is \ something he *should* do, something that will enable him to get back \ a quarter, but he has no idea *what*. He fumbles through his red \ squeezey changepurse and gives the boy three extra pennies with his \ dollar, hoping that he might luck into the correct amount. The boy \ gives him back two of his own pennies and then the big shiny quarter \ that is his prize. -RICHH"); if (match(text, "m/quarter/")) /** Does text contain 'quarter'? **/ printf("match: Text contains the word 'quarter'.\n\n"); else printf("match: Text doesn't contain the word 'quarter'.\n\n"); if (match(text, "m/eighth/")) /** Does text contain 'eighth'? **/ printf("match: Text contains the word 'eighth'.\n\n"); else printf("match: Text doesn't contain the word 'eighth'.\n\n"); /** Match all occurrences of /wi../ **/ num_matches = matches(text, "m/(wi..)/g", &match_list); printf("matches: m/(wi..)/g found %d matches...\n", num_matches); for (i = 0; i < num_matches; i++) printf("match: %s\n", match_list[i]); printf("\n"); for (i = 0; i < num_matches; i++) { free(match_list[i]); } free(match_list); /** Remove all vowels from text **/ num_matches = substitute(&text, "s/[aeiou]//gi"); if (num_matches) { printf("substitute: s/[aeiou]//gi...%d substitutions made.\n", num_matches); printf("Now text is: %s\n\n", text); } /** Attempt a substitution **/ if (!substitute(&text, "s/Perl/C/")) { printf("substitute: s/Perl/C...No substitution made.\n\n"); } free(text); perl_destruct(my_perl); perl_free(my_perl); }
which produces the output (again, long lines have been wrapped here)
perl_match: Text contains the word 'quarter'. perl_match: Text doesn't contain the word 'eighth'. perl_matches: m/(wi..)/g found 2 matches... match: will match: with perl_substitute: s/[aeiou]//gi...139 substitutions made. Now text is: Whn h s t cnvnnc str nd th bll cms t sm mnt lk 76 cnts, Mynrd s wr tht thr s smthng h *shld* d, smthng tht wll nbl hm t gt bck qrtr, bt h hs n d *wht*. H fmbls thrgh hs rd sqzy chngprs nd gvs th by thr xtr pnns wth hs dllr, hpng tht h mght lck nt th crrct mnt. Th by gvs hm bck tw f hs wn pnns nd thn th bg shny qrtr tht s hs prz. -RCHH perl_substitute: s/Perl/C...No substitution made.
When trying to explain stacks, most computer science textbooks mumble something about spring-loaded columns of cafeteria plates: the last thing you pushed on the stack is the first thing you pop off. That'll do for our purposes: your C program will push some arguments onto "the Perl stack", shut its eyes while some magic happens, and then pop the results--the return value of your Perl subroutine--off the stack.
First you'll need to know how to convert between C types and Perl types, with newSViv() and sv_setnv() and newAV() and all their friends. They're described in perlguts.
Then you'll need to know how to manipulate the Perl stack. That's described in perlcall.
Once you've understood those, embedding Perl in C is easy.
Because C has no built-in function for integer exponentiation, let's make Perl's ** operator available to it (this is less useful than it sounds, because Perl implements ** with C's pow() function). First I'll create a stub exponentiation function in power.pl:
sub expo { my ($a, $b) = @_; return $a ** $b; }
Now I'll create a C program, power.c, with a function PerlPower() that contains all the perlguts necessary to push the two arguments into expo() and to pop the return value out. Take a deep breath...
#include <EXTERN.h> #include <perl.h> static PerlInterpreter *my_perl; static void PerlPower(int a, int b) { dSP; /* initialize stack pointer */ ENTER; /* everything created after here */ SAVETMPS; /* ...is a temporary variable. */ PUSHMARK(sp); /* remember the stack pointer */ XPUSHs(sv_2mortal(newSViv(a))); /* push the base onto the stack */ XPUSHs(sv_2mortal(newSViv(b))); /* push the exponent onto stack */ PUTBACK; /* make local stack pointer global */ perl_call_pv("expo", G_SCALAR); /* call the function */ SPAGAIN; /* refresh stack pointer */ /* pop the return value from stack */ printf ("%d to the %dth power is %d.\n", a, b, POPi); PUTBACK; FREETMPS; /* free that return value */ LEAVE; /* ...and the XPUSHed "mortal" args.*/ } int main (int argc, char **argv, char **env) { char *my_argv[2]; my_perl = perl_alloc(); perl_construct( my_perl ); my_argv[1] = (char *) malloc(10); sprintf(my_argv[1], "power.pl"); perl_parse(my_perl, NULL, argc, my_argv, NULL); perl_run(my_perl); PerlPower(3, 4); /*** Compute 3 ** 4 ***/ perl_destruct(my_perl); perl_free(my_perl); }
Compile and run:
% cc -o power power.c `perl -MExtUtils::Embed -e ccopts -e ldopts` % power 3 to the 4th power is 81.
When developing interactive, potentially long-running applications, it's a good idea to maintain a persistent interpreter rather than allocating and constructing a new interpreter multiple times. The major gain here is speed, avoiding the penalty of Perl start-up time. However, a persistent interpreter will require you to be more cautious in your use of namespace and variable scoping. In previous examples we've been using global variables in the default package main. We knew exactly what code would be run, making it safe to assume we'd avoid any variable collision or outrageous symbol table growth.
Let's say your application is a server, which must run perl code from an arbitrary file during each transaction. Your server has no way of knowing what code is inside anyone of these files. If the file was pulled in by perl_parse(), compiled into a newly constructed interpreter, then cleaned out with perl_destruct() after the the transaction, you'd be shielded from most namespace troubles.
One way to avoid namespace collisions in this scenerio, is to translate the file name into a valid Perl package name, which is most likely to be unique, then compile the code into that package using "eval" in perlfunc. In the example below, each file will only be compiled once, unless it is updated on disk. Optionally, the application may choose to clean out the symbol table associated with the file after we are done with it. We'll call the subroutine Embed::Persistent::eval_file which lives in the file persistent.pl, with "perl_call_argv" in perlcall, passing the filename and boolean cleanup/cache flag as arguments.
Note that the process will continue to grow for each file that is compiled, and each file it pulls in via "require" in perlfunc, "use" in perlfunc or "do" in perlfunc. In addition, there maybe AUTOLOADed subroutines and other conditions that cause Perl's symbol table to grow. You may wish to add logic which keeps track of process size or restarts itself after n number of requests to ensure memory consumption is kept to a minimum. You also need to consider the importance of variable scoping with "my" in perlfunc to futher reduce symbol table growth.
package Embed::Persistent; #persistent.pl use strict; use vars '%Cache'; #use Devel::Symdump (); sub valid_package_name { my($string) = @_; $string =~ s/([^A-Za-z0-9\/])/sprintf("_%2x",unpack("C",$1))/eg; # second pass only for words starting with a digit $string =~ s|/(\d)|sprintf("/_%2x",unpack("C",$1))|eg; # Dress it up as a real package name $string =~ s|/|::|g; return "Embed" . $string; } #borrowed from Safe.pm sub delete_package { my $pkg = shift; my ($stem, $leaf); no strict 'refs'; $pkg = "main::$pkg\::"; # expand to full symbol table name ($stem, $leaf) = $pkg =~ m/(.*::)(\w+::)$/; my $stem_symtab = *{$stem}{HASH}; delete $stem_symtab->{$leaf}; } sub eval_file { my($filename, $delete) = @_; my $package = valid_package_name($filename); my $mtime = -M $filename; if(defined $Cache{$package}{mtime} && $Cache{$package}{mtime} <= $mtime) { # we have compiled this subroutine already, # it has not been updated on disk, nothing left to do print STDERR "already compiled $package->handler\n"; } else { local *FH; open FH, $filename or die "open '$filename' $!"; local($/) = undef; my $sub = <FH>; close FH; #wrap the code into a subroutine inside our unique package my $eval = qq{package $package; sub handler { $sub; }}; { # hide our variables within this block my($filename,$mtime,$package,$sub); eval $eval; } die $@ if $@; #cache it unless we're cleaning out each time $Cache{$package}{mtime} = $mtime unless $delete; } eval {$package->handler;}; die $@ if $@; delete_package($package) if $delete; #take a look if you want #print Devel::Symdump->rnew($package)->as_string, $/; } 1; __END__ /* persistent.c */ #include <EXTERN.h> #include <perl.h> /* 1 = clean out filename's symbol table after each request, 0 = don't */ #ifndef DO_CLEAN #define DO_CLEAN 0 #endif static PerlInterpreter *perl = NULL; int main(int argc, char **argv, char **env) { char *embedding[] = { "", "persistent.pl" }; char *args[] = { "", DO_CLEAN, NULL }; char filename [1024]; int exitstatus = 0; if((perl = perl_alloc()) == NULL) { fprintf(stderr, "no memory!"); exit(1); } perl_construct(perl); exitstatus = perl_parse(perl, NULL, 2, embedding, NULL); if(!exitstatus) { exitstatus = perl_run(perl); while(printf("Enter file name: ") && gets(filename)) { /* call the subroutine, passing it the filename as an argument */ args[0] = filename; perl_call_argv("Embed::Persistent::eval_file", G_DISCARD | G_EVAL, args); /* check $@ */ if(SvTRUE(GvSV(errgv))) fprintf(stderr, "eval error: %s\n", SvPV(GvSV(errgv),na)); } } perl_destruct_level = 0; perl_destruct(perl); perl_free(perl); exit(exitstatus); }
Now compile:
% cc -o persistent persistent.c `perl -MExtUtils::Embed -e ldopts`
Here's a example script file:
#test.pl my $string = "hello"; foo($string); sub foo { print "foo says: @_\n"; }
Now run:
% persistent Enter file name: test.pl foo says: hello Enter file name: test.pl already compiled Embed::test_2epl->handler foo says: hello Enter file name: ^C
The previous examples have gone through several steps to startup, use and shutdown an embedded Perl interpreter. Certain applications may require more than one instance of an interpreter to be created during the lifespan of a single process. Such an application may take different approaches in it's use of interpreter objects. For example, a particular transaction may want to create an interpreter instance, then release any resources associated with the object once the transaction is completed. When a single process does this once, resources are released upon exit of the program and the next time it starts, the interpreter's global state is fresh.
In the same process, the program must take care to ensure that these actions take place before constructing a new interpreter. By default, the global variable perl_destruct_level is set to 0 since extra cleaning is not needed when a program constructs a single interpreter, such as the perl executable itself in /usr/bin/perl or some such.
perl_destruct_level
0
/usr/bin/perl
You can tell Perl to make everything squeeky clean by setting perl_destruct_level to 1.
1
perl_destruct_level = 1; /* perl global variable */ while(1) { ... /* reset global variables here with perl_destruct_level = 1 */ perl_contruct(my_perl); ... /* clean and reset _everything_ during perl_destruct */ perl_destruct(my_perl); /* ah, nice and fresh */ perl_free(my_perl); ... /* let's go do it again! */ }
Now, when perl_destruct() is called, the interpreter's syntax parsetree and symbol tables are cleaned out, along with reseting global variables.
So, we've seen how to startup and shutdown an interpreter more than once in the same process, but there was only one instance in existance at any one time. Hmm, wonder if we can have more than one interpreter instance running at the _same_ time? Indeed this is possible, however when you build Perl, you must compile with -DMULTIPLICITY.
-DMULTIPLICITY
It's a little tricky for the Perl runtime to handle multiple interpreters, introducing some overhead that most programs with a single interpreter don't get burdened with. When you compile with -DMULTIPLICITY, by default, perl_destruct_level is set to 1 for each interpreter.
Let's give it a try:
#include <EXTERN.h> #include <perl.h> /* we're going to embed two interpreters */ /* we're going to embed two interpreters */ #define SAY_HELLO "-e", "print qq(Hi, I'm $^X\n)" int main(int argc, char **argv, char **env) { PerlInterpreter *one_perl = perl_alloc(), *two_perl = perl_alloc(); char *one_args[] = { "one_perl", SAY_HELLO }; char *two_args[] = { "two_perl", SAY_HELLO }; perl_construct(one_perl); perl_construct(two_perl); perl_parse(one_perl, NULL, 3, one_args, (char **)NULL); perl_parse(two_perl, NULL, 3, two_args, (char **)NULL); perl_run(one_perl); perl_run(two_perl); perl_destruct(one_perl); perl_destruct(two_perl); perl_free(one_perl); perl_free(two_perl); }
Compile as usual:
% cc -o multiplicity multiplicity.c `perl -MExtUtils::Embed -e ccopts -e ldopts`
Run it, Run it:
% multiplicity Hi, I'm one_perl Hi, I'm two_perl
If you've played with the examples above and tried to embed a script that use()s a Perl module (such as Socket) which itself uses a C or C++ library, this probably happened:
Can't load module Socket, dynamic loading not available in this perl. (You may need to build a new perl executable which either supports dynamic loading or has the Socket module statically linked into it.)
What's wrong?
Your interpreter doesn't know how to communicate with these extensions on its own. A little glue will help. Up until now you've been calling perl_parse(), handing it NULL for the second argument:
perl_parse(my_perl, NULL, argc, my_argv, NULL);
That's where the glue code can be inserted to create the initial contact between Perl and linked C/C++ routines. Let's take a look some pieces of perlmain.c to see how Perl does this:
#ifdef __cplusplus # define EXTERN_C extern "C" #else # define EXTERN_C extern #endif static void xs_init _((void)); EXTERN_C void boot_DynaLoader _((CV* cv)); EXTERN_C void boot_Socket _((CV* cv)); EXTERN_C void xs_init() { char *file = __FILE__; /* DynaLoader is a special case */ newXS("DynaLoader::boot_DynaLoader", boot_DynaLoader, file); newXS("Socket::bootstrap", boot_Socket, file); }
Simply put: for each extension linked with your Perl executable (determined during its initial configuration on your computer or when adding a new extension), a Perl subroutine is created to incorporate the extension's routines. Normally, that subroutine is named Module::bootstrap() and is invoked when you say use Module. In turn, this hooks into an XSUB, boot_Module, which creates a Perl counterpart for each of the extension's XSUBs. Don't worry about this part; leave that to the xsubpp and extension authors. If your extension is dynamically loaded, DynaLoader creates Module::bootstrap() for you on the fly. In fact, if you have a working DynaLoader then there is rarely any need to link in any other extensions statically.
Once you have this code, slap it into the second argument of perl_parse():
perl_parse(my_perl, xs_init, argc, my_argv, NULL);
Then compile:
% cc -o interp interp.c `perl -MExtUtils::Embed -e ldopts` % interp use Socket; use SomeDynamicallyLoadedModule; print "Now I can use extensions!\n"'
ExtUtils::Embed can also automate writing the xs_init glue code.
% perl -MExtUtils::Embed -e xsinit -o perlxsi.c % cc -c perlxsi.c `perl -MExtUtils::Embed -e ccopts` % cc -c interp.c `perl -MExtUtils::Embed -e ccopts` % cc -o interp perlxsi.o interp.o `perl -MExtUtils::Embed -e ldopts`
Consult perlxs and perlguts for more details.
You can sometimes write faster code in C, but you can always write code faster in Perl. Because you can use each from the other, combine them as you wish.
Jon Orwant <orwant@media.mit.edu>, co-authored by Doug MacEachern <dougm@osf.org>, with contributions from Tim Bunce, Tom Christiansen, Dov Grobgeld, and Ilya Zakharevich.
June 17, 1996
Some of this material is excerpted from my book: Perl 5 Interactive, Waite Group Press, 1996 (ISBN 1-57169-064-6) and appears courtesy of Waite Group Press.
To install lib, copy and paste the appropriate command in to your terminal.
cpanm
cpanm lib
CPAN shell
perl -MCPAN -e shell install lib
For more information on module installation, please visit the detailed CPAN module installation guide.