ExtUtils::Depends man page on aLinux

Man page or keyword search:  
man Server   7435 pages
apropos Keyword Search (all sections)
Output format
aLinux logo
[printable version]

ExtUtils::Depends(3)  User Contributed Perl Documentation ExtUtils::Depends(3)

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_lib("-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->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
       As written, this module expects that RTLD_GLOBAL works on your
       platform, which is not always true, most notably, on win32.  We need to
       include a way to find the actual shared libraries created for extension
       modules so new extensions may be linked explicitly with them.

       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.

perl v5.10.0			  2005-01-23		  ExtUtils::Depends(3)
[top]

List of man pages available for aLinux

Copyright (c) for man pages and the logo by the respective OS vendor.

For those who want to learn more, the polarhome community provides shell access and support.

[legal] [privacy] [GNU] [policy] [cookies] [netiquette] [sponsors] [FAQ]
Tweet
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
...................................................................
Vote for polarhome
Free Shell Accounts :: the biggest list on the net