NAME
"ExtUtils::H2PM" - automatically generate perl modules to wrap C header
files
DESCRIPTION
This module assists in generating wrappers around system functionallity,
such as "socket()" types or "ioctl()" calls, where the only interesting
features required are the values of some constants or layouts of
structures normally only known to the C header files. Rather than
writing an entire XS module just to contain some constants and
pack/unpack functions, this module allows the author to generate, at
module build time, a pure perl module containing constant declarations
and structure utility functions. The module then requires no XS module
to be loaded at run time.
In comparison to h2ph, "C::Scan::Constants", and so on, this module
works by generating a small C program containing "printf()" lines to
output the values of the constants, compiling it, and running it. This
allows it to operate without needing tricky syntax parsing or guessing
of the contents of C header files.
It can also automatically build pack/unpack functions for simple
structure layouts, whose members are all simple integer or character
array fields. It is not intended as a full replacement of arbitrary code
written in XS modules. If structures should contain pointers, or require
special custom handling, then likely an XS module will need to be
written.
FUNCTIONS
module $name
Sets the name of the perl module to generate. This will apply a
"package" header.
include $file
Adds a file to the list of headers which will be included by the C
program, to obtain the constants or structures from
constant $name, %args
Adds a numerical constant.
The following additional named arguments are also recognised:
* name => STRING
Use the given name for the generated constant function. If not
specified, the C name for the constant will be used.
* ifdef => STRING
If present, guard the constant with an "#ifdef STRING"
preprocessor macro. If the given string is not defined, no
constant will be generated.
structure $name, %args
Adds a structure definition. This requires a named argument, "members".
This should be an ARRAY ref containing an even number of name-definition
pairs. The first of each pair should be a member name. The second should
be one of the following structure member definitions.
The following additional named arguments are also recognised:
* pack_func => STRING
* unpack_func => STRING
Use the given names for the generated pack or unpack functions.
* with_tail => BOOL
If true, the structure is a header with more data behind it. The
pack function takes an optional extra string value for the data
tail, and the unpack function will return an extra string value
containing it.
* no_length_check => BOOL
If true, the generated unpack function will not first check the
length of its argument before attempting to unpack it. If the
buffer is not long enough to unpack all the required values, the
remaining ones will not be returned. This may be useful, for
example, in cases where various versions of a structure have
been designed, later versions adding extra members, but where
the exact version found may not be easy to determine beforehand.
* arg_style => STRING
Defines the style in which the functions take arguments or
return values. Defaults to "list", which take or return a list
of values in the given order. The other allowed value is
"hashref", where the pack function takes a HASH reference and
the unpack function returns one. Each will consist of keys named
after the structure members. If a data tail is included, it will
use the hash key of "_tail".
* ifdef => STRING
If present, guard the structure with an "#ifdef STRING"
preprocessor macro. If the given string is not defined, no
functions will be generated.
The following structure member definitions are allowed:
* member_numeric
The field contains a single signed or unsigned number. Its size
and signedness will be automatically detected.
* member_strarray
The field contains a NULL-padded string of characters. Its size
will be automatically detected.
The structure definition results in two new functions being created,
"pack_$name" and "unpack_$name", where $name is the name of the
structure (with the leading "struct" prefix stripped). These behave
similarly to the familiar functions such as "pack_sockaddr_in"; the
"pack_" function will take a list of fields and return a packed string,
the "unpack_" function will take a string and return a list of fields.
no_export, use_export, use_export_ok
Controls the export behaviour of the generated symbols. "no_export"
creates symbols that are not exported by their package, they must be
used fully- qualified. "use_export" creates symbols that are exported by
default. "use_export_ok" creates symbols that are exported if they are
specifically requested at "use" time.
The mode can be changed at any time to affect only the symbols that
follow it. It defaults to "use_export_ok".
$perl = gen_output
Returns the generated perl code. This is used internally for testing
purposes but normally would not be necessary; see instead
"write_output".
write_output $filename
Write the generated perl code into the named file. This would normally
be used as the last function in the containing script, to generate the
output file. In the case of "ExtUtils::MakeMaker" or "Module::Build"
invoking the script, the path to the file to be generated should be
given in $ARGV[0]. Normally, therefore, the script would end with
write_output $ARGV[0];
EXAMPLES
Normally this module would be used by another module at build time, to
construct the relevant constants and structure functions from system
headers.
For example, suppose your operating system defines a new type of socket,
which has its own packet and address families, and perhaps some new
socket options which are valid on this socket. We can build a module to
contain the relevant constants and structure functions by writing, for
example:
#!/usr/bin/perl
use ExtUtils::H2PM;
module "Socket::Moonlaser";
include "moon/laser.h";
constant "AF_MOONLASER";
constant "PF_MOONLASER";
constant "SOL_MOONLASER";
constant "MOONLASER_POWER", name => "POWER";
constant "MOONLASER_WAVELENGTH", name => "WAVELENGTH";
structure "struct laserwl",
members => [
lwl_nm_coarse => member_numeric,
lwl_nm_fine => member_numeric,
];
write_output $ARGV[0];
If we save this script as, say, lib/Socket/Moonlaser.pm.PL, then when
the distribution is built, the script will be used to generate the
contents of the file lib/Socket/Moonlaser.pm. Once installed, any other
code can simply
use Socket::Moonlaser qw( AF_MOONLASER );
to import a constant.
The method described above doesn't allow us any room to actually include
other code in the module. Perhaps, as well as these simple constants,
we'd like to include functions, documentation, etc... To allow this,
name the script instead something like lib/Socket/Moonlaser_const.pm.PL,
so that this is the name used for the generated output. The code can
then be included in the actual lib/Socket/Moonlaser.pm (which will just
be a normal perl module) by
package Socket::Moonlaser;
use Socket::Moonlaser_const;
sub get_power
{
getsockopt( $_[0], SOL_MOONLASER, POWER );
}
sub set_power
{
setsockopt( $_[0], SOL_MOONLASER, POWER, $_[1] );
}
sub get_wavelength
{
my $wl = getsockopt( $_[0], SOL_MOONLASER, WAVELENGTH );
defined $wl or return;
unpack_laserwl( $wl );
}
sub set_wavelength
{
my $wl = pack_laserwl( $_[1], $_[2] );
setsockopt( $_[0], SOL_MOONLASER, WAVELENGTH, $wl );
}
1;
Sometimes, the actual C structure layout may not exactly match the
semantics we wish to present to perl modules using this extension
wrapper. Socket address structures typically contain their address
family as the first member, whereas this detail isn't exposed by, for
example, the "sockaddr_in" and "sockaddr_un" functions. To cope with
this case, the low-level structure packing and unpacking functions can
be generated with a different name, and wrapped in higher-level
functions in the main code. For example, in Moonlaser_const.pm.PL:
no_export;
structure "struct sockaddr_ml",
pack_func => "_pack_sockaddr_ml",
unpack_func => "_unpack_sockaddr_ml",
members => [
ml_family => member_numeric,
ml_lat_deg => member_numeric,
ml_long_deg => member_numeric,
ml_lat_fine => member_numeric,
ml_long_fine => member_numeric,
];
This will generate a pack/unpack function pair taking or returning five
arguments; these functions will not be exported. In our main
Moonlaser.pm file we can wrap these to actually expose a different API:
sub pack_sockaddr_ml
{
@_ == 2 or croak "usage: pack_sockaddr_ml(lat, long)";
my ( $lat, $long ) = @_;
return _pack_sockaddr_ml( AF_MOONLASER, int $lat, int $long,
($lat - int $lat) * 1_000_000, ($long - int $long) * 1_000_000);
}
sub unpack_sockaddr_ml
{
my ( $family, $lat, $long, $lat_fine, $long_fine ) =
_unpack_sockaddr_ml( $_[0] );
$family == AF_MOONLASER or croak "expected family AF_MOONLASER";
return ( $lat + $lat_fine/1_000_000, $long + $long_fine/1_000_000 );
}
Sometimes, a structure will contain members which are themselves
structures. Suppose a different definition of the above address, which
at the C layer is defined as
struct angle
{
short deg;
unsigned long fine;
};
struct sockaddr_ml
{
short ml_family;
struct angle ml_lat, ml_long;
};
We can instead "flatten" this structure tree to obtain the five fields
by naming the sub-members of the outer structure:
structure "struct sockaddr_ml",
members => [
"ml_family" => member_numeric,
"ml_lat.deg" => member_numeric,
"ml_lat.fine" => member_numeric,
"ml_long.deg" => member_numeric,
"ml_long.fine" => member_numeric,
];
TODO
* Consider more structure members. With strings comes the requirement
to have members that store a size. This requires cross-referential
members. And while we're at it it might be nice to have constant
members; fill in constants without consuming arguments when packing,
assert the right value on unpacking.
AUTHOR
Paul Evans <leonerd@leonerd.org.uk>