This tutorial starts with very simple examples and becomes more complex, with each new example adding new features. Certain concepts may not be completely explained until later in the tutorial in order to slowly ease the reader into building extensions.
This tutorial can still be used on such a system. The XSUB build mechanism will check the system and build a dynamically-loadable library if possible, or else a static library and then, optionally, a new statically-linked executable with that static library linked in.
Should you wish to build a statically-linked executable on a system which can dynamically load libraries, you may, in all the following examples, where the command ``make'' with no arguments is executed, run the command ``make perl'' instead.
If you have generated such a statically-linked executable by choice, then instead of saying ``make test'', you should say ``make test_static''. On systems that cannot build dynamically-loadable libraries at all, simply saying "make test" is sufficient.
Run ``h2xs -A -n Mytest''. This creates a directory named Mytest, possibly under ext/ if that directory exists in the current working directory. Several files will be created in the Mytest dir, including MANIFEST, Makefile.PL, Mytest.pm, Mytest.xs, test.pl, and Changes.
The MANIFEST file contains the names of all the files created.
The file Makefile.PL should look something like this:
The file Mytest.pm should start with something like this:
And the Mytest.xs file should look something like this:
Let's edit the .xs file by adding this to the end of the file:
Now we'll run ``perl Makefile.PL''. This will create a real Makefile, which make needs. It's output looks something like:
Now, running make will produce output that looks something like this (some long lines shortened for clarity):
Now, although there is already a test.pl template ready for us, for this example only, we'll create a special test script. Create a file called hello that looks like this:
Now we run the script and we should see the following output:
Add the following to the end of Mytest.xs:
There does not need to be white space at the start of the ``int input'' line, but it is useful for improving readability. The semi-colon at the end of that line is also optional.
Any white space may be between the ``int'' and ``input''. It is also okay for the four lines starting at the ``CODE:'' line to not be indented. However, for readability purposes, it is suggested that you indent them 8 spaces (or one normal tab stop).
Now re-run make to rebuild our new shared library.
Now perform the same steps as before, generating a Makefile from the Makefile.PL file, and running make.
In order to test that our extension works, we now need to look at the file test.pl. This file is set up to imitate the same kind of testing structure that Perl itself has. Within the test script, you perform a number of tests to confirm the behavior of the extension, printing ``ok'' when the test is correct, ``not ok'' when it is not.
Remove the line that starts with ``use lib'', change the print statement in the BEGIN block to print ``1..4'', and add the following code to the end of the file:
We will be calling the test script through the command ``make test''. You should see output that looks something like this:
h2xs creates a number of files in the extension directory. The file Makefile.PL is a perl script which will generate a true Makefile to build the extension. We'll take a closer look at it later.
The files <extension>.pm and <extension>.xs contain the meat of the extension. The .xs file holds the C routines that make up the extension. The .pm file contains routines that tell Perl how to load your extension.
Generating and invoking the Makefile created a directory blib (which stands for ``build library'') in the current working directory. This directory will contain the shared library that we will build. Once we have tested it, we can install it into its final location.
Invoking the test script via ``make test'' did something very important. It invoked perl with all those -I arguments so that it could find the various files that are part of the extension.
It is very important that while you are still testing extensions that you use ``make test''. If you try to run the test script all by itself, you will get a fatal error.
Another reason it is important to use ``make test'' to run your test script is that if you are testing an upgrade to an already-existing version, using ``make test'' insures that you use your new extension, not the already-existing version.
When Perl sees a use extension; , it searches for a file with the same name as the use'd extension that has a .pm suffix. If that file cannot be found, Perl dies with a fatal error. The default search path is contained in the @INC array.
In our case, Mytest.pm tells perl that it will need the Exporter and Dynamic Loader extensions. It then sets the @ISA and @EXPORT arrays and the $VERSION scalar; finally it tells perl to bootstrap the module. Perl will call its dynamic loader routine (if there is one) and load the shared library.
The two arrays that are set in the .pm file are very important. The @ISA array contains a list of other packages in which to search for methods (or subroutines) that do not exist in the current package. The @EXPORT array tells Perl which of the extension's routines should be placed into the calling package's namespace.
It's important to select what to export carefully. Do NOT export method names and do NOT export anything else by default without a good reason.
As a general rule, if the module is trying to be object-oriented then don't export anything. If it's just a collection of functions then you can export any of the functions via another array, called @EXPORT_OK.
See the perlmod manpage for more information.
The $VERSION variable is used to ensure that the .pm file and the shared library are ``in sync'' with each other. Any time you make changes to the .pm or .xs files, you should increment the value of this variable.
By running ``make test'', you ensure that your test.pl script runs and uses the correct version of your extension. If you have many test cases, you might want to copy Perl's test style. Create a directory named ``t'', and ensure all your test files end with the suffix ``.t''. The Makefile will properly run all these test files.
Add the following to the end of Mytest.xs:
Edit the Makefile.PL file so that the corresponding line looks like this:
Generate the Makefile and run make. Change the BEGIN block to print out ``1..9'' and add the following to test.pl:
Running ``make test'' should now print out that all nine tests are okay.
You might be wondering if you can round a constant. To see what happens, add the following line to test.pl temporarily:
Run ``make test'' and notice that Perl dies with a fatal error. Perl won't let you change the value of constants!
Second, the value of the function is being passed back not as the function's return value, but through the same variable that was passed into the function.
The list of output parameters occurs after the OUTPUT: directive. The use of RETVAL tells Perl that you wish to send this value back as the return value of the XSUB function. In Example 3, the value we wanted returned was contained in the same variable we passed in, so we listed it (and not RETVAL) in the OUTPUT: section.
The first part attempts to map various C data types to a coded flag, which has some correspondence with the various Perl types. The second part contains C code which xsubpp uses for input parameters. The third part contains C code which xsubpp uses for output parameters. We'll talk more about the C code later.
Let's now take a look at a portion of the .c file created for our extension.
Notice the two lines marked with ``XXXXX''. If you check the first section of the typemap file, you'll see that doubles are of type T_DOUBLE. In the INPUT section, an argument that is T_DOUBLE is assigned to the variable arg by calling the routine SvNV on something, then casting it to double, then assigned to the variable arg. Similarly, in the OUTPUT section, once arg has its final value, it is passed to the sv_setnv function to be passed back to the calling subroutine. These two functions are explained in the perlguts manpage ; we'll talk more later about what that ``ST(0)'' means in the section on the argument stack.
Create a new directory called Mytest2 at the same level as the directory Mytest. In the Mytest2 directory, create another directory called mylib, and cd into that directory.
Here we'll create some files that will generate a test library. These will include a C source file and a header file. We'll also create a Makefile.PL in this directory. Then we'll make sure that running make at the Mytest2 level will automatically run this Makefile.PL file and the resulting Makefile.
In the testlib directory, create a file mylib.h that looks like this:
Also create a file mylib.c that looks like this:
And finally create a file Makefile.PL that looks like this:
We will now create the main top-level Mytest2 files. Change to the directory above Mytest2 and run the following command:
This will print out a warning about overwriting Mytest2, but that's okay. Our files are stored in Mytest2/mylib, and will be untouched.
The normal Makefile.PL that h2xs generates doesn't know about the mylib directory. We need to tell it that there is a subdirectory and that we will be generating a library in it. Let's add the following key-value pair to the WriteMakefile call:
and a new replacement subroutine too:
(Note: Most makes will require that there be a tab character that indents the line ``cd mylib && $( MAKE)''.)
Let's also fix the MANIFEST file so that it accurately reflects the contents of our extension. The single line that says ``mylib'' should be replaced by the following three lines:
To keep our namespace nice and unpolluted, edit the .pm file and change the line setting @EXPORT to @EXPORT_OK. And finally, in the .xs file, edit the #include line to read:
And also add the following function definition to the end of the .xs file:
Now we also need to create a typemap file because the default Perl doesn't currently support the const char * type. Create a file called typemap and place the following in it:
Now run perl on the top-level Makefile.PL. Notice that it also created a Makefile in the mylib directory. Run make and see that it does cd into the mylib directory and run make in there as well.
Now edit the test.pl script and change the BEGIN block to print ``1..4'', and add the following lines to the end of the script:
(When dealing with floating-point comparisons, it is often useful to not check for equality, but rather the difference being below a certain epsilon factor, 0.01 in this case)
Run ``make test'' and all should be well.
constantroutine is to make the values that are #define'd in the header file available to the Perl script (in this case, by calling
&main::TESTVAL). There's also some XS code to allow calls to the
When you specify arguments in the .xs file, you are really passing three pieces of information for each one listed. The first piece is the order of that argument relative to the others (first, second, etc). The second is the type of argument, and consists of the type declaration of the argument (e.g., int, char*, etc). The third piece is the exact way in which the argument should be used in the call to the library function from this XSUB. This would mean whether or not to place a ``&'' before the argument or not, meaning the argument expects to be passed the address of the specified data type.
There is a difference between the two arguments in this hypothetical function:
The first argument to this function would be treated as a char and assigned to the variable a, and its address would be passed into the function foo. The second argument would be treated as a string pointer and assigned to the variable b. The value of b would be passed into the function foo. The actual call to the function foo that xsubpp generates would look like this:
Xsubpp will identically parse the following function argument lists:
However, to help ease understanding, it is suggested that you place a ``&'' next to the variable name and away from the variable type), and place a ``*'' near the variable type, but away from the variable name (as in the complete example above). By doing so, it is easy to understand exactly what will be passed to the C function -- it will be whatever is in the ``last column''.
You should take great pains to try to pass the function the type of variable it wants, when possible. It will save you a lot of trouble in the long run.
When you list the arguments to the XSUB in the .xs file, that tell xsubpp which argument corresponds to which of the argument stack (i.e., the first one listed is the first argument, and so on). You invite disaster if you do not list them in the same order as the function expects them.
You may intersperse documentation and Perl code within the .pm file. In fact, if you want to use method autoloading, you must do this, as the comment inside the .pm file explains.
See the perlpod manpage for more information about the pod format.
Reviewed and assisted by Dean Roehrich, Ilya Zakharevich, Andreas Koenig, and Tim Bunce.