GNU.WIKI: The GNU/Linux Knowledge Base

  [HOME] [PHP Manual] [HowTo] [ABS] [MAN1] [MAN2] [MAN3] [MAN4] [MAN5] [MAN6] [MAN7] [MAN8] [MAN9]

  [0-9] [Aa] [Bb] [Cc] [Dd] [Ee] [Ff] [Gg] [Hh] [Ii] [Jj] [Kk] [Ll] [Mm] [Nn] [Oo] [Pp] [Qq] [Rr] [Ss] [Tt] [Uu] [Vv] [Ww] [Xx] [Yy] [Zz]


       Inline::C::Cookbook - A Cornucopia of Inline C Recipes


       It's a lot easier for most of us to cook a meal from a recipe, rather
       than just throwing things into a pot until something edible forms. So
       it is with programming as well. "" makes C programming for
       Perl as easy as possible. Having a set of easy to understand samples,
       makes it simpler yet.

       This Cookbook is intended to be an evergrowing repository of small yet
       complete coding examples; each showing how to accomplish a particular
       task with Inline. Each example is followed by a short discussion,
       explaining in detail the particular features that are being

       Many of these recipes are adapted from email discussions I have had
       with Inline users around the world. It has been my experience so far,
       that Inline provides an elegant solution to almost all problems
       involving Perl and C.

       Bon Appetit!


   Hello, world

       It seems that the first thing any programmer wants to do when he learns
       a new programming technique is to use it to greet the Earth. How can I
       do this using Inline?

               use Inline C => <<'END_C';

               void greet() {
                   printf("Hello, world


           Nothing too fancy here. We define a single C function "greet()"
           which prints a message to STDOUT. One thing to note is that since
           the Inline code comes before the function call to "greet", we can
           call it as a bareword (no parentheses).

       See Also
           See Inline and Inline::C for basic info about "".

           ·   Brian Kernigan

           ·   Dennis Ritchie

   One Liner
           A concept is valid in Perl only if it can be shown to work in one
           line. Can Inline reduce the complexities of Perl/C interaction to a

               perl -e 'use Inline C=>q{void greet(){printf("Hello, world

           Try doing that in XS :-)

       See Also
           My email signature of late is:

               perl -le 'use Inline C=>q{SV*JAxH(char*x){return newSVpvf("Just Another %s Hacker",x);}};print JAxH+Perl'

           A bit fancier but a few bytes too long to qualify as a true one
           liner :-(

           "Eli the Bearded" <> gave me the idea that I
           should have an Inline one-liner as a signature.


   Data Types
           How do I pass different types of data to and from Inline C
           functions; like strings, numbers and integers?

               use Inline C;

               $filename = $ARGV[0];
               die "Usage: perl filename
" unless -f $filename;

               $text = join '', <>;           # slurp input file
               $vp = vowel_scan($text);       # call our function
               $vp = sprintf("%03.1f", $vp * 100);  # format for printing
               print "The letters in $filename are $vp% vowels.


               /* Find percentage of vowels to letters */
               double vowel_scan(char* str) {
                   int letters = 0;
                   int vowels = 0;
                   int i = 0;
                   char c;
                   char normalize = 'a' ^ 'A';
                   /* normalize forces lower case in ASCII; upper in EBCDIC */
                   char A = normalize | 'a';
                   char E = normalize | 'e';
                   char I = normalize | 'i';
                   char O = normalize | 'o';
                   char U = normalize | 'u';
                   char Z = normalize | 'z';

                   while(c = str[i++]) {
                       c |= normalize;
                       if (c >= A && c <= Z) {
                            if (c == A || c == E || c == I || c == O || c == U)

                   return letters ? ((double) vowels / letters) : 0.0;

           This script takes a file name from the command line and prints the
           ratio of vowels to letters in that file. "" uses an Inline
           C function called "vowel_scan", that takes a string argument, and
           returns the percentage of vowels as a floating point number between
           0 and 1. It handles upper and lower case letters, and works with
           ASCII and EBCDIC. It is also quite fast.

           Running this script produces:

               > perl /usr/share/dict/words
               The letters in /usr/share/dict/words are 37.5% vowels.

       See Also
           The Perl Journal vol #19 has an article about Inline which uses
           this example.

           This example was reprinted by permission of The Perl Journal. It
           was edited to work with Inline v0.30 and higher.

   Variable Argument Lists

       How do I pass a variable-sized list of arguments to an Inline C

               greet(qw(Sarathy Jan Sparky Murray Mike));

               use Inline C => <<'END_OF_C_CODE';

               void greet(SV* name1, ...) {
                   int i;

                   for (i = 0; i < Inline_Stack_Items; i++)
                       printf("Hello %s!
", SvPV(Inline_Stack_Item(i), PL_na));



           This little program greets a group of people, such as my coworkers.
           We use the "C" ellipsis syntax: ""..."", since the list can be of
           any size.

           Since there are no types or names associated with each argument, we
           can't expect XS to handle the conversions for us. We'll need to pop
           them off the Stack ourselves. Luckily there are two functions
           (macros) that make this a very easy task.

           First, we need to begin our function with a ""Inline_Stack_Vars""
           statement.  This defines a few internal variables that we need to
           access the Stack. Now we can use ""Inline_Stack_Items"", which
           returns an integer containing the number of arguments passed to us
           from Perl.

           NOTE: It is important to only use ""Inline_Stack_"" macros when
           there is an ellipsis ("...") in the argument list, or the function
           has a return type of void.

           Second, we use the Inline_Stack_Item(x) function to access each
           argument where "0 <= x < items".

           NOTE: When using a variable length argument list, you have to
           specify at least one argument before the ellipsis. (On my compiler,
           anyway.) When XS does it's argument checking, it will complain if
           you pass in less than the number of defined arguments. Therefore,
           there is currently no way to pass an empty list when a variable
           length list is expected.

       See Also

   Multiple Return Values
           How do I return a list of values from a C function?

               print map {"$_
"} get_localtime(time);

               use Inline C => <<'END_OF_C_CODE';

               #include <time.h>

               void get_localtime(SV * utc) {
                 const time_t utc_ = (time_t)SvIV(utc);
                 struct tm *ltime = localtime(&utc_);


           Perl is a language where it is common to return a list of values
           from a subroutine call instead of just a single value. C is not
           such a language. In order to accomplish this in C we need to
           manipulate the Perl call stack by hand. Luckily, Inline provides
           macros to make this easy.

           This example calls the system "localtime", and returns each of the
           parts of the time struct; much like the perl builtin "localtime()".
           On each stack push, we are creating a new Perl integer (SVIV) and
           mortalizing it. The sv_2mortal() call makes sure that the reference
           count is set properly. Without it, the program would leak memory.

           NOTE: The "#include" statement is not really needed, because Inline
                 automatically includes the Perl headers which include almost
                 standard system calls.

       See Also
           For more information on the Inline stack macros, see Inline::C.

           Richard Anderson <> contributed the original
           idea for this snippet.

   Multiple Return Values (Another Way)
           How can I pass back more than one value without using the Perl

               use Inline::Files;
               use Inline C;

               my ($foo, $bar);
               change($foo, $bar);

               print "\$foo = $foo
               print "\$bar = $bar


               int change(SV* var1, SV* var2) {
                   sv_setpvn(var1, "Perl Rocks!", 11);
                   sv_setpvn(var2, "Inline Rules!", 13);
                   return 1;

           Most perl function interfaces return values as a list of one or
           more scalars.  Very few like "chomp", will modify an input scalar
           in place. On the other hand, in C you do this quite often. Values
           are passed in by reference and modified in place by the called

           It turns out that we can do that with Inline as well. The secret is
           to use a type of '"SV*"' for each argument that is to be modified.
           This ensures passing by reference, because no typemapping is

           The function can then use the Perl5 API to operate on that
           argument. When control returns to Perl, the argument will retain
           the value set by the C function. In this example we passed in 2
           empty scalars and assigned values directly to them.

       See Also
           Ned Konz <> brought this behavior to my
           attention. He also pointed out that he is not the world famous
           computer cyclist Steve Roberts (<,> but he
           is close (<> Thanks Ned.

   Using Memory
           How should I allocate buffers in my Inline C code?

               print greeting('Ingy');

               use Inline C => <<'END_OF_C_CODE';

               SV* greeting(SV* sv_name) {
                   return (newSVpvf("Hello %s!
", SvPV(sv_name, PL_na)));


           In this example we will return the greeting to the caller, rather
           than printing it. This would seem mighty easy, except for the fact
           that we need to allocate a small buffer to create the greeting.

           I would urge you to stay away from "malloc"ing your own buffer.
           Just use Perl's built in memory management. In other words, just
           create a new Perl string scalar. The function "newSVpv" does just
           that. And "newSVpvf" includes "sprintf" functionality.

           The other problem is getting rid of this new scalar. How will the
           ref count get decremented after we pass the scalar back? Perl also
           provides a function called "sv_2mortal". Mortal variables die when
           the context goes out of scope.  In other words, Perl will wait
           until the new scalar gets passed back and then decrement the ref
           count for you, thereby making it eligible for garbage collection.
           See "perldoc perlguts".

           In this example the "sv_2mortal" call gets done under the hood by
           XS, because we declared the return type to be "SV*".

           To view the generated XS code, run the command ""perl -
           MInline=INFO,FORCE,NOCLEAN"". This will leave the
           build directory intact and tell you where to find it.

       See Also


   Inline CGI
           How do I use Inline securely in a CGI environment?


               use CGI qw(:standard);
               use Inline (Config =>
                           DIRECTORY => '/usr/local/apache/Inline',

               print (header,
                      start_html('Inline CGI Example'),

               use Inline C => <<END;
               SV* JAxH(char* x) {
                   return newSVpvf("Just Another %s Hacker", x);

           The problem with running Inline code from a CGI script is that
           Inline writes to a build area on your disk whenever it compiles
           code. Most CGI scripts don't (and shouldn't) be able to create a
           directory and write into it.

           The solution is to explicitly tell Inline which directory to use
           with the 'use Inline Config => DIRECTORY => ...' line. Then you
           need to give write access to that directory from the web server
           (CGI script).

           If you see this as a security hole, then there is another option.
           Give write access to yourself, but read-only access to the CGI
           script. Then run the script once by hand (from the command line).
           This will cause Inline to precompile the C code. That way the CGI
           will only need read access to the build directory (to load in the
           shared library from there).

           Just remember that whenever you change the C code, you need to
           precompile it again.

       See Also
           See CGI for more information on using the "" module.



       How do I use Inline with mod_perl?

               package Factorial;
               use strict;
               use Inline Config =>
                          DIRECTORY => '/usr/local/apache/Inline',
                          ENABLE => 'UNTAINT';
               use Inline 'C';

               sub handler {
                   my $r = shift;
                   printf "%3d! = %10d
", $_, factorial($_) for 1..100;
                   return Apache::Constants::OK;

               double factorial(double x) {
                   if (x < 2)  return 1;
                   return x * factorial(x - 1)

           This is a fully functional mod_perl handler that prints out the
           factorial values for the numbers 1 to 100. Since we are using
           Inline under mod_perl, there are a few considerations to , um,

           First, mod_perl handlers are usually run with "-T" taint detection.
           Therefore, we need to enable the UNTAINT option. The next thing to
           deal with is the fact that this handler will most likely be loaded
           after Perl's compile time. Since we are using the DATA section, we
           need to use the special "init()" call. And of course we need to
           specify a DIRECTORY that mod_perl can compile into. See the above
           CGI example for more info.

           Other than that, this is a pretty straightforward mod_perl handler,
           tuned for even more speed!

       See Also
           See Stas Bekman's upcoming O'Reilly book on mod_perl to which this
           example was contributed.


   Object Oriented Inline

       How do I implement Object Oriented programming in Perl using C objects?

               my $obj1 = Soldier->new('Benjamin', 'Private', 11111);
               my $obj2 = Soldier->new('Sanders', 'Colonel', 22222);
               my $obj3 = Soldier->new('Matt', 'Sergeant', 33333);

               for my $obj ($obj1, $obj2, $obj3) {
                   print  $obj->get_serial, ") ",
                          $obj->get_name, " is a ",
                          $obj->get_rank, "


               package Soldier;

               use Inline C => <<'END';

               Allocate memory with Newx if it's
               available - if it's an older perl
               that doesn't have Newx then we
               resort to using New.
               #ifndef Newx
               #  define Newx(v,n,t) New(0,v,n,t)

               typedef struct {
                 char* name;
                 char* rank;
                 long  serial;
               } Soldier;

               SV* new(const char * classname, const char * name, const char * rank, long serial) {
                 Soldier * soldier;
                 SV      * obj;
                 SV      * obj_ref;

                 Newx(soldier, 1, Soldier);
                 soldier->name = savepv(name);
                 soldier->rank = savepv(rank);
                 soldier->serial = serial;

                 obj = newSViv((IV)soldier);
                 obj_ref = newRV_noinc(obj);
                 sv_bless(obj_ref, gv_stashpv(classname, GV_ADD));

                 return obj_ref;

               char* get_name(SV* obj) {
                 return ((Soldier*)SvIV(SvRV(obj)))->name;

               char* get_rank(SV* obj) {
                 return ((Soldier*)SvIV(SvRV(obj)))->rank;

               long get_serial(SV* obj) {
                 return ((Soldier*)SvIV(SvRV(obj)))->serial;

               void DESTROY(SV* obj) {
                 Soldier* soldier = (Soldier*)SvIV(SvRV(obj));



       Damian Conway has given us myriad ways of implementing OOP in Perl.
       This is one he might not have thought of.

       The interesting thing about this example is that it uses Perl for all
       the OO bindings while using C for the attributes and methods.

       If you examine the Perl code everything looks exactly like a regular OO
       example. There is a "new" method and several accessor methods. The
       familiar 'arrow syntax' is used to invoke them.

       In the class definition (second part) the Perl "package" statement is
       used to name the object class or namespace. But that's where the
       similarities end Inline takes over.

       The idea is that we call a C subroutine called "new()" which returns a
       blessed scalar. The scalar contains a readonly integer which is a C
       pointer to a Soldier struct. This is our object.

       The "new()" function needs to malloc the memory for the struct and then
       copy the initial values into it using "savepv()". This also allocates
       more memory (which we have to keep track of).

       The accessor methods are pretty straightforward. They return the
       current value of their attribute.

       The last method "DESTROY()" is called automatically by Perl whenever an
       object goes out of scope. This is where we can free all the memory used
       by the object.

       That's it. It's a very simplistic example. It doesn't show off any
       advanced OO features, but it is pretty cool to see how easy the
       implementation can be. The important Perl call is "newSVrv()" which
       creates a blessed scalar.

       See Also

       Read "Object Oriented Perl" by Damian Conway, for more useful ways of
       doing OOP in Perl.

       You can learn more Perl calls in perlapi. If you don't have Perl 5.6.0
       or higher, visit <>



   Exposing Shared Libraries
           You have this great C library and you want to be able to access
           parts of it with Perl.

               print get('');

               use Inline C => Config =>
                          LIBS => '-lghttp';
               use Inline C => <<'END_OF_C_CODE';

               #include <ghttp.h>

               char *get(SV* uri) {
                  SV* buffer;
                  ghttp_request* request;

                  buffer = NEWSV(0,0);
                  request = ghttp_request_new();
                  ghttp_set_uri(request, SvPV(uri, PL_na));

                  ghttp_set_header(request, http_hdr_Connection, "close");


                  sv_catpv(buffer, ghttp_get_body(request));


                  return SvPV(buffer, PL_na);


           This example fetches and prints the HTML from
           <> It requires the GNOME http libraries.

           One of the most common questions I get is "How can I use Inline to
           make use of some shared library?". Although it has always been
           possible to do so, the configuration was ugly, and there were no
           specific examples.

           With version 0.30 and higher, you can specify the use of shared
           libraries easily with something like this:

               use Inline C => Config => LIBS => '-lghttp';
               use Inline C => "code ...";


               use Inline C => "code ...", LIBS => '-lghttp';

           To specify a specific library path, use:

               use Inline C => "code ...", LIBS => '-L/your/lib/path -lyourlib';

           To specify an include path use:

               use Inline C => "code ...",
                          LIBS => '-lghttp',
                          INC => '-I/your/inc/path';

       See Also
           The "LIBS" and "INC" configuration options are formatted and passed
           into MakeMaker. For more info see ExtUtils::MakeMaker. For more
           options see Inline::C.

           This code was written by Matt Sergeant <>, author
           of many CPAN modules. The configuration syntax has been modified
           for use with Inline v0.30.

   Automatic Function Wrappers
           You have some functions in a C library that you want to access from
           Perl exactly as you would from C.

           The error function "erf()" is probably defined in your standard
           math library.  Annoyingly, Perl does not let you access it. To
           print out a small table of its values, just say:

               perl -le 'use Inline C => q{ double erf(double); }, ENABLE => "AUTOWRAP"; print "$_ @{[erf($_)]}" for (0..10)'

           The excellent "Term::ReadLine::Gnu" implements Term::ReadLine using
           the GNU ReadLine library. Here is an easy way to access just
           "readline()" from that library:

               package MyTerm;

               use Inline C => Config =>
                          ENABLE => AUTOWRAP =>
                          LIBS => "-lreadline -lncurses -lterminfo -ltermcap ";
               use Inline C => q{ char * readline(char *); };

               package main;
               my $x = MyTerm::readline("xyz: ");

           Note however that it fails to "free()" the memory returned by
           readline, and that "Term::ReadLine::Gnu" offers a much richer

           We access existing functions by merely showing Inline their
           declarations, rather than a full definition. Of course the function
           declared must exist, either in a library already linked to Perl or
           in a library specified using the "LIBS" option.

           The first example wraps a function from the standard math library,
           so Inline requires no additional "LIBS" directive. The second uses
           the Config option to specify the libraries that contain the actual
           compiled C code.

           This behavior is always disabled by default. You must enable the
           "AUTOWRAP" option to make it work.

       See Also
           "readline", "Term::ReadLine::Gnu"

           GNU ReadLine was written by Brian Fox <> and Chet
           Ramey <>. Term::ReadLine::Gnu was written by Hiroo
           Hayashi <>. Both are far richer than the
           slim interface given here!

           The idea of producing wrapper code given only a function
           declaration is taken from Swig by David M. Beazley

           Ingy's inline editorial insight:

           This entire entry was contributed by Ariel Scolnicov
           <>.  Ariel also first suggested the idea for
           Inline to support function declaration processing.

   Complex Data

       How do I deal with complex data types like hashes in Inline C?

               use Inline C => <<'END_OF_C_CODE';

               void dump_hash(SV* hash_ref) {
                   HV* hash;
                   HE* hash_entry;
                   int num_keys, i;
                   SV* sv_key;
                   SV* sv_val;

                   if (! SvROK(hash_ref))
                       croak("hash_ref is not a reference");

                   hash = (HV*)SvRV(hash_ref);
                   num_keys = hv_iterinit(hash);
                   for (i = 0; i < num_keys; i++) {
                       hash_entry = hv_iternext(hash);
                       sv_key = hv_iterkeysv(hash_entry);
                       sv_val = hv_iterval(hash, hash_entry);
                       printf("%s => %s
", SvPV(sv_key, PL_na), SvPV(sv_val, PL_na));


               my %hash = (
                   Author => "Ingy doet Net",
                   Nickname => "INGY",
                   Module => "",
                   Version => "0.30",
                   Language => "C",


           The world is not made of scalars alone, although they are
           definitely the easiest creatures to deal with, when doing Inline
           stuff. Sometimes we need to deal with arrays, hashes, and code
           references, among other things.

           Since Perl subroutine calls only pass scalars as arguments, we'll
           need to use the argument type "SV*" and pass references to more
           complex types.

           The above program dumps the key/value pairs of a hash. To figure it
           out, just curl up with perlapi for a couple hours. Actually, its
           fairly straight forward once you are familiar with the calls.

           Note the "croak" function call. This is the proper way to die from
           your C extensions.

       See Also
           See perlapi for information about the Perl5 internal API.


   Hash of Lists

       How do I create a Hash of Lists from C?

               use Inline C;
               use Data::Dumper;

               $hash_ref = load_data("./cartoon.txt");
               print Dumper $hash_ref;


               static int next_word(char**, char*);

               SV* load_data(char* file_name) {
                   char buffer[100], word[100], * pos;
                   AV* array;
                   HV* hash = newHV();
                   FILE* fh = fopen(file_name, "r");

                   while (fgets(pos = buffer, sizeof(buffer), fh)) {
                       if (next_word(&pos, word)) {
                           hv_store(hash, word, strlen(word),
                                   newRV_noinc((SV*)array = newAV()), 0);
                           while (next_word(&pos, word))
                               av_push(array, newSVpvf("%s", word));
                   return newRV_noinc((SV*) hash);

               static int next_word(char** text_ptr, char* word) {
                   char* text = *text_ptr;
                   while(*text != '' &&
                         *text <= ' ')
                   if (*text <= ' ')
                       return 0;
                   while(*text != '' &&
                         *text > ' ') {
                       *word++ = *text++;
                   *word = '';
                   *text_ptr = text;
                   return 1;

           This is one of the larger recipes. But when you consider the number
           of calories it has, it's not so bad. The function "load_data" takes
           the name of a file as it's input. The file "cartoon.text" might
           look like:

               flintstones fred barney
               jetsons     george jane elroy
               simpsons    homer marge bart

           The function will read the file, parsing each line into words. Then
           it will create a new hash, whereby the first word in a line becomes
           a hash key and the remaining words are put into an array whose
           reference becomes the hash value.  The output looks like this:

               $VAR1 = {
                         'flintstones' => [
                         'simpsons' => [
                         'jetsons' => [

       See Also
           See perlapi for information about the Perl5 internal API.

           Al Danial <> requested a solution to this on
           comp.lang.perl.misc. He borrowed the idea from the "Hash of Lists"
           example in the Camel book.


           How do I access Win32 DLL-s using Inline?

               use Inline C => DATA =>
                          LIBS => '-luser32';

               $text = "@ARGV" || ' works with MSWin32. Scary...';

               WinBox('Inline Text Box', $text);


               #include <windows.h>

               int WinBox(char* Caption, char* Text) {
                 return MessageBoxA(0, Text, Caption, 0);

           This example runs on MS Windows. It makes a text box appear on the
           screen which contains a message of your choice.

           The important thing is that its proof that you can use Inline to
           interact with Windows DLL-s. Very scary indeed. 8-o

           To use Inline on Windows with ActivePerl (
           <> ) you'll need MS Visual Studio. You
           can also use the Cygwin environment, available at
           <> .

       See Also
           See Inline-Support for more info on MSWin32 programming with

           This example was adapted from some sample code written by Garrett
           Goebel <>

   Embedding Perl in C
           How do I use Perl from a regular C program?


               int main(void) {

                   printf("Using Perl version %s from a C program!

                          CPR_eval("use Config; $Config{version};"));

                   CPR_eval("use Data::Dumper;");
                   CPR_eval("print Dumper \%INC;");

                   return 0;


           By using CPR. (C Perl Run)

           This example uses another Inline module, "Inline::CPR", available
           separately on CPAN. When you install this module it also installs a
           binary interpreter called "/usr/bin/cpr". (The path may be
           different on your system)

           When you feed a C program to the CPR interpreter, it automatically
           compiles and runs your code using Inline. This gives you full
           access to the Perl internals. CPR also provides a set of easy to
           use C macros for calling Perl internals.

           This means that you can effectively "run" C source code by putting
           a CPR hashbang as the first line of your C program.

       See Also
           See Inline::CPR for more information on using CPR.

           "Inline::CPR" can be obtained from
           "/ CPR" in http:

           Randal Schwartz <>, Randolph Bentson
           <>, Richard Anderson
           <>, and Tim Maher <> helped
           me figure out how to write a program that would work as a hashbang.


       As of version 0.30, Inline has the ability to work in cooperation with
       other modules that want to expose a C API of their own. The general
       syntax for doing this is:

           use Inline with => 'Module';
           use Inline C => ... ;

       This tells "Module" to pass configuration options to Inline. Options
       like typemaps, include paths, and external libraries, are all resolved
       automatically so you can just concentrate on writing the functions.

   Event handling with
           You need to write a C callback for the "" module. Can this
           be done more easily with Inline?

               use Inline with => 'Event';

               Event->timer(desc     => 'Timer #1',
                            interval => 2,
                            cb       => \&my_callback,

               Event->timer(desc     => 'Timer #2',
                            interval => 3,
                            cb       => \&my_callback,

               print "Starting...

               use Inline C => <<'END';
               void my_callback(pe_event* event) {
                   pe_timer * watcher = event->up;

	Event priority = %d
	Watcher priority = %d


           The first line tells Inline to load the "" module. Inline
           then queries "Event" for configuration information. It gets the
           name and location of Event's header files, typemaps and shared
           objects. The parameters that "Event" returns look like:

               INC => "-I $path/Event",
               TYPEMAPS => "$path/Event/typemap",
               MYEXTLIB => "$path/auto/Event/Event.$so",
               AUTO_INCLUDE => '#include "EventAPI.h"',
               BOOT => 'I_EVENT_API("Inline");',

           Doing all of this automatically allows you, the programmer, to
           simply write a function that receives a pointer of type
           'pe_event*'. This gives you access to the "Event" structure that
           was passed to you.

           In this example, I simply print values out of the structure. The
           Perl code defines 2 timer events which each invoke the same
           callback. The first one, every two seconds, and the second one,
           every three seconds.

           As of this writing, "" is the only CPAN module that works
           in cooperation with Inline.

       See Also
           Read the "" documentation for more information. It contains
           a tutorial showing several examples of using Inline with "Event".

           Jochen Stenzel <> originally came up with the
           idea of mixing Inline and "Event". He also authored the "Event"

           Joshua Pritikin <> is the author of


   Calling C from both Perl and C
           I'd like to be able to call the same C function from both Perl and
           C.  Also I like to define a C function that doesn't get bound to
           Perl. How do I do that?

               print "9 + 5 = ", add(9, 5), "
               print "SQRT(9^2 + 5^2) = ", pyth(9, 5), "
               print "9 * 5 = ", mult(9, 5), "

               use Inline C => <<'END_C';
               int add(int x, int y) {
                   return x + y;
               static int mult(int x, int y) {
                   return x * y;
               double pyth(int x, int y) {
                   return sqrt(add(mult(x, x), mult(y, y)));

           The program produces:

               9 + 5 = 14
               SQRT(9^2 + 5^2) = 10.295630140987
               Can't locate auto/main/ in @INC ...

           Every Inline function that is bound to Perl is also callable by C.
           You don't have to do anything special. Inline arranges it so that
           all the typemap code gets done by XS and is out of sight. By the
           time the C function receives control, everything has been converted
           from Perl to C.

           Of course if your function manipulates the Perl Stack, you probably
           don't want to call it from C (unless you really know what you're

           If you declare a function as "static", Inline won't bind it to
           Perl. That's why we were able to call "mult()" from C but the call
           failed from Perl.

       See Also

   Calling Perl from C
           So now that I can call C from Perl, how do I call a Perl subroutine
           from an Inline C function.

               use Inline C;

               for(1..5) {
                  c_func_1('This is the first line');
                  c_func_2('This is the second line');
                  print "

               sub perl_sub_1 {
                   print map "$_
", @_;


               void c_func_2(SV* text) {


                    XPUSHs(sv_2mortal(newSVpvf("Plus an extra line")));

                    call_pv("perl_sub_1", G_DISCARD);


               void c_func_1(SV* text) {

           This demo previously made use of Inline Stack macros only - but
           that's not the correct way to do it. Instead, base the callbacks on
           the perlcall documentation (as we're now doing).

           Actually, this program demonstrates calling a C function which
           calls another C function which in turn calls a Perl subroutine.

           The nice thing about Inline C functions is that you can call them
           from both Perl-space and C-space. That's because Inline creates a
           wrapper function around each C function. When you use Perl to call
           C you're actually calling that function's wrapper. The wrapper
           handles typemapping and Stack management, and then calls your C

           The first time we call "c_func_1" which calls "c_func_2". The
           second time we call "c_func_2" directly. "c_func_2" calls the Perl
           subroutine ("perl_sub_1") using the internal "perl_call_pv"
           function. It has to put arguments on the stack by hand. Since there
           is already one argument on the stack when we enter the function,
           the "XPUSHs" ( which is equivalent to an "Inline_Stack_Push" ) adds
           a second argument.

           We iterate through a 'for' loop 5 times just to demonstrate that
           things still work correctly when we do that. (This was where the
           previous rendition, making use solely of Inline Stack macros, fell

       See Also
           See Inline::C for more information about Stack macros.

           See perlapi for more information about the Perl5 internal API.


   Evaling C
           I've totally lost my marbles and I want to generate C code at run
           time, and "eval" it into Perl. How do I do this?

               use Inline;
               use Code::Generator;

               my $c_code = generate('foo_function');

               Inline->bind(C => $c_code);

               foo_function(1, 2, 3);

           I can't think of a real life application where you would want to
           generate C code on the fly, but at least I know how I would do it.

           The "bind()" function of Inline let's you bind (compileloadexecute)
           C functions at run time. It takes all of the same arguments as 'use
           Inline C => ...'.

           The nice thing is that once a particular snippet is compiled, it
           remains cached so that it doesn't need to be compiled again. I can
           imagine that someday a mad scientist will dream up a self
           generating modeling system that would run faster and faster over

           If you know such a person, have them drop me a line.

       See Also

   Providing a pure perl alternative
           I want to write a script that will use a C subroutine if Inline::C
           is installed, but will otherwise use an equivalent pure perl
           subroutine if Inline::C is not already installed. How do I do this?

               use strict;
               use warnings;

               eval {
                require Inline;
                Inline->import (C => Config =>
                                BUILD_NOISY => 1);
                Inline->import (C =><<'EOC');

                int foo() {
                  warn("Using Inline
                  return 42;


               if($@) {
                 *foo =\&bar;

               sub bar {
                 warn("Using Pure Perl Implementation
                 return 42;

               my $x = foo();
               print "$x

           If Inline::C is installed and functioning properly, the C sub foo
           is called by the perl code. Otherwise, $@ gets set, and the
           equivalent pure perl function bar is instead called.

           Note, too, that the pure perl sub bar can still be explicitly
           called even if Inline::C is available.

   Accessing Fortran subs using Inline::C
           I've been given a neat little sub written in fortran that takes, as
           its args, two integers and returns their product. And I would like
           to use that sub as is from Inline::C. By way of example, let's say
           that the fortran source file is named 'prod.f', and that it looks
           like this:

               integer function sqarea(r,s)
               integer r, s
               sqarea = r*s

           We can't access that code directly, but we can compile it into a
           library which we can then access from Inline::C. Using gcc we could

               gfortran -c prod.f -o prod.o
               ar cru libprod.a prod.o

           The function is then accessible as follows:

               use warnings;

               use Inline C => Config =>
                 LIBS => '-L/full/path/to/libprod_location -lprod -lgfortran';

               use Inline C => <<'  EOC';

               int wrap_sqarea(int a, int b) {
                   return sqarea_(&a, &b);


               $x = 15;
               $y = $x + 3;
               $ret = wrap_sqarea($x, $y);
               print "Product of $x and $y is $ret

           Note firstly that, although the function is specified as 'sqarea'
           in the source file, gfortran appends an underscore to the name when
           the source is compiled. (I don't know if all fortran compilers do
           this.) Therefore Inline::C needs to call the function as 'sqarea_'.

           Secondly, because fortran subs pass args by reference, we need to
           pass the addresses of the two integer args to sqarea() when we call
           it from our Inline::C sub.

           If using g77 instead of gfortran, the only necessary change is that
           we specify '-lg2c' instead of '-lgfortran' in our 'LIBS' setting.


       For generic information about Inline, see Inline.

       For information about using Inline with C see Inline::C.

       For information on supported languages and platforms see Inline-

       For information on writing your own Inline language support module, see

       Inline's mailing list is

       To subscribe, send email to


       Ingy doet Net <>


       Copyright 2000-2014. Ingy doet Net.

       Copyright 2008, 2010-2014. Sisyphus.

       See <>

  All copyrights belong to their respective owners. Other content (c) 2014-2018, GNU.WIKI. Please report site errors to
Page load time: 0.082 seconds. Last modified: November 04 2018 12:49:43.