use ExtUtils::Depends;
$package = new ExtUtils::Depends ('pkg::name', 'base::package')
# set the flags and libraries to compile and link the module
$package->set_inc("-I/opt/blahblah");
$package->set_libs("-lmylib");
# add a .c and an .xs file to compile
$package->add_c('code.c');
$package->add_xs('module-code.xs');
# add the typemaps to use
$package->add_typemaps("typemap");
# install some extra data files and headers
$package->install (qw/foo.h data.txt/);
# save the info
$package->save_config('Files.pm');
WriteMakefile(
'NAME' => 'Mymodule',
$package->get_makefile_vars()
);
This works as long as the base extension is loaded with the RTLD_GLOBAL flag (usually done with a
sub dl_load_flags {0x01}
in the main .pm file) if you need to use functions defined in the module.
The basic scheme of operation is to collect information about a module in the instance, and then store that data in the Perl library where it may be retrieved later. The object can also reformat this information into the data structures required by ExtUtils::MakeMaker's WriteMakefile function.
For information on how to make your module fit into this scheme, see ``hashref = ExtUtils::Depends::load (name)''.
When creating a new Depends object, you give it a name, which is the name of the module you are building. You can also specify the names of modules on which this module depends. These dependencies will be loaded automatically, and their typemaps, header files, etc merged with your new object's stuff. When you store the data for your object, the list of dependencies are stored with it, so that another module depending on your needn't know on exactly which modules yours depends.
For example:
Gtk2 depends on Glib
Gnome2::Canvas depends on Gtk2
ExtUtils::Depends->new ('Gnome2::Canvas', 'Gtk2');
this command automatically brings in all the stuff needed
for Glib, since Gtk2 depends on it.
When the configuration information is saved, it also includes a class method called "Inline", inheritable by your module. This allows you in your module to simply say at the top:
package Mymod; use parent 'Mymod::Install::Files'; # to inherit 'Inline' method
And users of "Mymod" who want to write inline code (using Inline) will simply be able to write:
use Inline with => 'Mymod';
And all the necessary header files, defines, and libraries will be added for them.
The "Mymod::Install::Files" will also implement a "deps" method, which will return a list of any modules that "Mymod" depends on - you will not normally need to use this:
require Mymod::Install::Files; @deps = Mymod::Install::Files->deps;
This actually works by adding them to the hash of pm files that gets passed through WriteMakefile's PM key.
Note: the actual value of $filename is unimportant so long as it doesn't clash with any other local files. It will be installed as name::Install::Files.
This sets at least the following keys:
INC
LIBS
TYPEMAPS
PM
And these if there is data to fill them:
clean
OBJECT
XS
If you want to make module name support this, you must provide a module name::Install::Files, which on loading will implement the following class methods:
$hashref = name::Install::Files->Inline('C');
# hash to contain any necessary TYPEMAPS (array-ref), LIBS, INC
@deps = name::Install::Files->deps;
# any modules on which "name" depends
An easy way to achieve this is to use the method ``$depends->save_config ($filename)'', but your package may have different facilities already.
This module is tightly coupled to the ExtUtils::MakeMaker architecture.
You can submit new bugs/feature requests by using one of two bug trackers (below).
Patches that implement new features with test cases, and/or test cases that exercise existing bugs are always welcome.
The Gtk-Perl mailing list is at ``gtk-perl-list at gnome dot org''.
git clone git://git.gnome.org/perl-ExtUtils-Depends (Git protocol) git clone https://git.gnome.org/browse/perl-ExtUtils-Depends/ (HTTPS)