NAME
   ExtUtils::Depends - Easily build XS extensions that depend on XS
   extensions

SYNOPSIS
           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()
           );

DESCRIPTION
   This module tries to make it easy to build Perl extensions that use
   functions and typemaps provided by other perl extensions. This means
   that a perl extension is treated like a shared library that provides
   also a C and an XS interface besides the perl one.

   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.

   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.

METHODS
   $object = ExtUtils::Depends->new($name, @deps)
       Create a new depends object named *$name*. Any modules listed in
       *@deps* (which may be empty) are added as dependencies and their
       dependency information is loaded. An exception is raised if any
       dependency information cannot be loaded.

   $depends->add_deps (@deps)
       Add modules listed in *@deps* as dependencies.

   (hashes) = $depends->get_deps
       Fetch information on the dependencies of *$depends* as a hash of
       hashes, which are dependency information indexed by module name. See
       "load".

   $depends->set_inc (@newinc)
       Add strings to the includes or cflags variables.

   $depends->set_libs (@newlibs)
       Add strings to the libs (linker flags) variable.

   $depends->add_pm (%pm_files)
       Add files to the hash to be passed through ExtUtils::WriteMakefile's
       PM key.

   $depends->add_xs (@xs_files)
       Add xs files to be compiled.

   $depends->add_c (@c_files)
       Add C files to be compiled.

   $depends->add_typemaps (@typemaps)
       Add typemap files to be used and installed.

   $depends->add_headers (list)
       No-op, for backward compatibility.

   $depends->install (@files)
       Install *@files* to the data directory for *$depends*.

       This actually works by adding them to the hash of pm files that gets
       passed through WriteMakefile's PM key.

   $depends->save_config ($filename)
       Save the important information from *$depends* to *$filename*, and
       set it up to be installed as *name*::Install::Files.

       Note: the actual value of *$filename* seems to be irrelevant, but
       its usage is kept for backward compatibility.

   hash = $depends->get_makefile_vars
       Return the information in *$depends* in a format digestible by
       WriteMakefile.

       This sets at least the following keys:

               INC
               LIBS
               TYPEMAPS
               PM

       And these if there is data to fill them:

               clean
               OBJECT
               XS

   hashref = ExtUtils::Depends::load (name)
       Load and return dependency information for *name*. Croaks if no such
       information can be found. The information is returned as an
       anonymous hash containing these keys:

       instpath
           The absolute path to the data install directory for this module.

       typemaps
           List of absolute pathnames for this module's typemap files.

       inc CFLAGS string for this module.

       libs
           LIBS string for this module.

       deps
           List of modules on which this one depends. This key will not
           exist when loading files created by old versions of
           ExtUtils::Depends.

   $depends->load_deps
       Load *$depends* dependencies, by calling "load" on each dependency
       module. This is usually done for you, and should only be needed if
       you want to call "get_deps" after calling "add_deps" manually.

BUGS
   Version 0.2 discards some of the more esoteric features provided by the
   older versions. As they were completely undocumented, and this module
   has yet to reach 1.0, this may not exactly be a bug.

   This module is tightly coupled to the ExtUtils::MakeMaker architecture.

SEE ALSO
   ExtUtils::MakeMaker.

AUTHOR
   Paolo Molaro <lupus at debian dot org> wrote the original version for
   Gtk-Perl. muppet <scott at asofyet dot org> rewrote the innards for
   version 0.2, borrowing liberally from Paolo's code.

MAINTAINER
   The Gtk2 project, http://gtk2-perl.sf.net/

LICENSE
   This library is free software; you may redistribute it and/or modify it
   under the same terms as Perl itself.

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.