[catagits/Gitalist.git] / local-lib5 / lib / perl5 / ExtUtils / Depends.pm

#
# $Id$
#

package ExtUtils::Depends;

use strict;
use warnings;
use Carp;
use File::Find;
use File::Spec;
use Data::Dumper;

our $VERSION = '0.302';

sub import {
	my $class = shift;
	return unless @_;
        die "$class version $_[0] is required--this is only version $VERSION"
		if $VERSION < $_[0];
}

sub new {
	my ($class, $name, @deps) = @_;
	my $self = bless {
		name => $name,
		deps => {},
		inc => [],
		libs => '',

		pm => {},
		typemaps => [],
		xs => [],
		c => [],
	}, $class;

	$self->add_deps (@deps);

	# attempt to load these now, so we'll find out as soon as possible
	# whether the dependencies are valid.  we'll load them again in
	# get_makefile_vars to catch any added between now and then.
	$self->load_deps;

	return $self;
}

sub add_deps {
	my $self = shift;
	foreach my $d (@_) {
		$self->{deps}{$d} = undef
			unless $self->{deps}{$d};
	}
}

sub get_deps {
	my $self = shift;
	$self->load_deps; # just in case

	return %{$self->{deps}};
}

sub set_inc {
	my $self = shift;
	push @{ $self->{inc} }, @_;
}

sub set_libs {
	my ($self, $newlibs) = @_;
	$self->{libs} = $newlibs;
}

sub add_pm {
	my ($self, %pm) = @_;
	while (my ($key, $value) = each %pm) {
		$self->{pm}{$key} = $value;
	}
}

sub _listkey_add_list {
	my ($self, $key, @list) = @_;
	$self->{$key} = [] unless $self->{$key};
	push @{ $self->{$key} }, @list;
}

sub add_xs       { shift->_listkey_add_list ('xs',       @_) }
sub add_c        { shift->_listkey_add_list ('c',        @_) }
sub add_typemaps {
	my $self = shift;
	$self->_listkey_add_list ('typemaps', @_);
	$self->install (@_);
}

# no-op, only used for source back-compat
sub add_headers { carp "add_headers() is a no-op" }

####### PRIVATE
sub basename { (File::Spec->splitdir ($_[0]))[-1] }
# get the name in Makefile syntax.
sub installed_filename {
	my $self = shift;
	return '$(INST_ARCHLIB)/$(FULLEXT)/Install/'.basename ($_[0]);
}

sub install {
	# install things by adding them to the hash of pm files that gets
	# passed through WriteMakefile's PM key.
	my $self = shift;
	foreach my $f (@_) {
		$self->add_pm ($f, $self->installed_filename ($f));
	}
}

sub save_config {
	use Data::Dumper;
	use IO::File;

	my ($self, $filename) = @_;

	my $file = IO::File->new (">".$filename)
		or croak "can't open '$filename' for writing: $!\n";

	print $file "package $self->{name}\::Install::Files;\n\n";
	# for modern stuff
	print $file "".Data::Dumper->Dump([{
		inc => join (" ", @{ $self->{inc} }),
		libs => $self->{libs},
		typemaps => [ map { basename $_ } @{ $self->{typemaps} } ],
		deps => [keys %{ $self->{deps} }],
	}], ['self']);
	# for ancient stuff
	print $file "\n\n# this is for backwards compatiblity\n";
	print $file "\@deps = \@{ \$self->{deps} };\n";
	print $file "\@typemaps = \@{ \$self->{typemaps} };\n";
	print $file "\$libs = \$self->{libs};\n";
	print $file "\$inc = \$self->{inc};\n";
	# this is riduculous, but old versions of ExtUtils::Depends take
	# first $loadedmodule::CORE and then $INC{$file} --- the fallback
	# includes the Filename.pm, which is not useful.  so we must add
	# this crappy code.  we don't worry about portable pathnames,
	# as the old code didn't either.
	(my $mdir = $self->{name}) =~ s{::}{/}g;
	print $file <<"EOT";

	\$CORE = undef;
	foreach (\@INC) {
		if ( -f \$_ . "/$mdir/Install/Files.pm") {
			\$CORE = \$_ . "/$mdir/Install/";
			last;
		}
	}
EOT

	print $file "\n1;\n";

	close $file;

	# we need to ensure that the file we just created gets put into
	# the install dir with everything else.
	#$self->install ($filename);
	$self->add_pm ($filename, $self->installed_filename ('Files.pm'));
}

sub load {
	my $dep = shift;
	my @pieces = split /::/, $dep;
	my @suffix = qw/ Install Files /;
	my $relpath = File::Spec->catfile (@pieces, @suffix) . '.pm';
	my $depinstallfiles = join "::", @pieces, @suffix;
	eval {
		require $relpath 
	} or die " *** Can't load dependency information for $dep:\n   $@\n";
	#
	#print Dumper(\%INC);

	# effectively $instpath = dirname($INC{$relpath})
	@pieces = File::Spec->splitdir ($INC{$relpath});
	pop @pieces;
	my $instpath = File::Spec->catdir (@pieces);
	
	no strict;

	croak "No dependency information found for $dep"
		unless $instpath;

	if (not File::Spec->file_name_is_absolute ($instpath)) {
		$instpath = File::Spec->rel2abs ($instpath);
	}

	my @typemaps = map {
		File::Spec->rel2abs ($_, $instpath)
	} @{"$depinstallfiles\::typemaps"};

	{
		instpath => $instpath,
		typemaps => \@typemaps,
		inc      => "-I$instpath ".${"$depinstallfiles\::inc"},
		libs     => ${"$depinstallfiles\::libs"},
		# this will not exist when loading files from old versions
		# of ExtUtils::Depends.
		(exists ${"$depinstallfiles\::"}{deps}
		  ? (deps => \@{"$depinstallfiles\::deps"})
		  : ()), 
	}
}

sub load_deps {
	my $self = shift;
	my @load = grep { not $self->{deps}{$_} } keys %{ $self->{deps} };
	foreach my $d (@load) {
		my $dep = load ($d);
		$self->{deps}{$d} = $dep;
		if ($dep->{deps}) {
			foreach my $childdep (@{ $dep->{deps} }) {
				push @load, $childdep
					unless
						$self->{deps}{$childdep}
					or
						grep {$_ eq $childdep} @load;
			}
		}
	}
}

sub uniquify {
	my %seen;
	# we use a seen hash, but also keep indices to preserve
	# first-seen order.
	my $i = 0;
	foreach (@_) {
		$seen{$_} = ++$i
			unless exists $seen{$_};
	}
	#warn "stripped ".(@_ - (keys %seen))." redundant elements\n";
	sort { $seen{$a} <=> $seen{$b} } keys %seen;
}


sub get_makefile_vars {
	my $self = shift;

	# collect and uniquify things from the dependencies.
	# first, ensure they are completely loaded.
	$self->load_deps;
	
	##my @defbits = map { split } @{ $self->{defines} };
	my @incbits = map { split } @{ $self->{inc} };
	my @libsbits = split /\s+/, $self->{libs};
	my @typemaps = @{ $self->{typemaps} };
	foreach my $d (keys %{ $self->{deps} }) {
		my $dep = $self->{deps}{$d};
		#push @defbits, @{ $dep->{defines} };
		push @incbits, @{ $dep->{defines} } if $dep->{defines};
		push @incbits, split /\s+/, $dep->{inc} if $dep->{inc};
		push @libsbits, split /\s+/, $dep->{libs} if $dep->{libs};
		push @typemaps, @{ $dep->{typemaps} } if $dep->{typemaps};
	}

	# we have a fair bit of work to do for the xs files...
	my @clean = ();
	my @OBJECT = ();
	my %XS = ();
	foreach my $xs (@{ $self->{xs} }) {
		(my $c = $xs) =~ s/\.xs$/\.c/i;
		(my $o = $xs) =~ s/\.xs$/\$(OBJ_EXT)/i;
		$XS{$xs} = $c;
		push @OBJECT, $o;
		# according to the MakeMaker manpage, the C files listed in
		# XS will be added automatically to the list of cleanfiles.
		push @clean, $o;
	}

	# we may have C files, as well:
	foreach my $c (@{ $self->{c} }) {
		(my $o = $c) =~ s/\.c$/\$(OBJ_EXT)/i;
		push @OBJECT, $o;
		push @clean, $o;
	}

	my %vars = (
		INC => join (' ', uniquify @incbits),
		LIBS => join (' ', uniquify $self->find_extra_libs, @libsbits),
		TYPEMAPS => [@typemaps],
	);

	$self->build_dll_lib(\%vars) if $^O =~ /MSWin32/;

	# we don't want to provide these if there is no data in them;
	# that way, the caller can still get default behavior out of
	# MakeMaker when INC, LIBS and TYPEMAPS are all that are required.
	$vars{PM} = $self->{pm}
		if %{ $self->{pm} };
	$vars{clean} = { FILES => join (" ", @clean), }
		if @clean;
	$vars{OBJECT} = join (" ", @OBJECT)
		if @OBJECT;
	$vars{XS} = \%XS
		if %XS;

	%vars;
}

sub build_dll_lib {
	my ($self, $vars) = @_;
	$vars->{macro} ||= {};
	$vars->{macro}{'INST_DYNAMIC_LIB'} =
		'$(INST_ARCHAUTODIR)/$(BASEEXT)$(LIB_EXT)';
}

sub find_extra_libs {
	my $self = shift;

	my %mappers = (
		MSWin32 => sub { $_[0] . '\.(?:lib|a)' },
		cygwin	=> sub { $_[0] . '\.dll'},
	);
	my $mapper = $mappers{$^O};
	return () unless defined $mapper;

	my @found_libs = ();
	foreach my $name (keys %{ $self->{deps} }) {
		(my $stem = $name) =~ s/^.*:://;
		my $lib = $mapper->($stem);
		my $pattern = qr/$lib$/;

		my $matching_dir;
		my $matching_file;
		find (sub {
			if ((not $matching_file) && /$pattern/) {;
				$matching_dir = $File::Find::dir;
				$matching_file = $File::Find::name;
			}
		}, map { -d $_ ? ($_) : () } @INC); # only extant dirs

		if ($matching_file && -f $matching_file) {
			push @found_libs, ('-L' . $matching_dir, '-l' . $stem);
			next;
		}
	}

	return @found_libs;
}

# Hook into ExtUtils::MakeMaker to create an import library on MSWin32 when gcc
# is used.  FIXME: Ideally, this should be done in EU::MM itself.
package # wrap to fool the CPAN indexer
	ExtUtils::MM;
use Config;
sub static_lib {
	my $base = shift->SUPER::static_lib(@_);

	return $base unless $^O =~ /MSWin32/ && $Config{cc} =~ /^gcc/i;

	return <<'__EOM__';
# This isn't actually a static lib, it just has the same name on Win32.
$(INST_DYNAMIC_LIB): $(INST_DYNAMIC)
	dlltool --def $(EXPORT_LIST) --output-lib $@ --dllname $(BASEEXT).$(SO) $(INST_DYNAMIC)

dynamic:: $(INST_DYNAMIC_LIB)
__EOM__
}

1;

__END__

=head1 NAME

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

=head1 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()
	);

=head1 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.


=head1 METHODS

=over

=item $object = ExtUtils::Depends->new($name, @deps)

Create a new depends object named I<$name>.  Any modules listed in I<@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.

=item $depends->add_deps (@deps)

Add modules listed in I<@deps> as dependencies.

=item (hashes) = $depends->get_deps

Fetch information on the dependencies of I<$depends> as a hash of hashes,
which are dependency information indexed by module name.  See C<load>.

=item $depends->set_inc (@newinc)

Add strings to the includes or cflags variables.

=item $depends->set_libs (@newlibs)

Add strings to the libs (linker flags) variable.

=item $depends->add_pm (%pm_files)

Add files to the hash to be passed through ExtUtils::WriteMakefile's
PM key.

=item $depends->add_xs (@xs_files)

Add xs files to be compiled.

=item $depends->add_c (@c_files)

Add C files to be compiled.

=item $depends->add_typemaps (@typemaps)

Add typemap files to be used and installed.

=item $depends->add_headers (list)

No-op, for backward compatibility.

=item $depends->install (@files)

Install I<@files> to the data directory for I<$depends>.

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

=item $depends->save_config ($filename)

Save the important information from I<$depends> to I<$filename>, and
set it up to be installed as I<name>::Install::Files.

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

=item hash = $depends->get_makefile_vars

Return the information in I<$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

=item hashref = ExtUtils::Depends::load (name)

Load and return dependency information for I<name>.  Croaks if no such
information can be found.  The information is returned as an anonymous
hash containing these keys:

=over

=item instpath

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

=item typemaps

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

=item inc

CFLAGS string for this module.

=item libs

LIBS string for this module.

=item deps

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

=back

=item $depends->load_deps

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

=back


=head1 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.

=head1 SEE ALSO

ExtUtils::MakeMaker.

=head1 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.

=head1 MAINTAINER

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

=head1 LICENSE

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

=cut
Commit	Line	Data
3fea05b9	1	#
	2	# $Id$
	3	#
	4
	5	package ExtUtils::Depends;
	6
	7	use strict;
	8	use warnings;
	9	use Carp;
	10	use File::Find;
	11	use File::Spec;
	12	use Data::Dumper;
	13
	14	our $VERSION = '0.302';
	15
	16	sub import {
	17	my $class = shift;
	18	return unless @_;
	19	die "$class version $_[0] is required--this is only version $VERSION"
	20	if $VERSION < $_[0];
	21	}
	22
	23	sub new {
	24	my ($class, $name, @deps) = @_;
	25	my $self = bless {
	26	name => $name,
	27	deps => {},
	28	inc => [],
	29	libs => '',
	30
	31	pm => {},
	32	typemaps => [],
	33	xs => [],
	34	c => [],
	35	}, $class;
	36
	37	$self->add_deps (@deps);
	38
	39	# attempt to load these now, so we'll find out as soon as possible
	40	# whether the dependencies are valid. we'll load them again in
	41	# get_makefile_vars to catch any added between now and then.
	42	$self->load_deps;
	43
	44	return $self;
	45	}
	46
	47	sub add_deps {
	48	my $self = shift;
	49	foreach my $d (@_) {
	50	$self->{deps}{$d} = undef
	51	unless $self->{deps}{$d};
	52	}
	53	}
	54
	55	sub get_deps {
	56	my $self = shift;
	57	$self->load_deps; # just in case
	58
	59	return %{$self->{deps}};
	60	}
	61
	62	sub set_inc {
	63	my $self = shift;
	64	push @{ $self->{inc} }, @_;
65	}
66
67	sub set_libs {
68	my ($self, $newlibs) = @_;
69	$self->{libs} = $newlibs;
70	}
71
72	sub add_pm {
73	my ($self, %pm) = @_;
74	while (my ($key, $value) = each %pm) {
75	$self->{pm}{$key} = $value;
76	}
77	}
78
79	sub _listkey_add_list {
80	my ($self, $key, @list) = @_;
81	$self->{$key} = [] unless $self->{$key};
82	push @{ $self->{$key} }, @list;
83	}
84
85	sub add_xs { shift->_listkey_add_list ('xs', @_) }
86	sub add_c { shift->_listkey_add_list ('c', @_) }
87	sub add_typemaps {
88	my $self = shift;
89	$self->_listkey_add_list ('typemaps', @_);
90	$self->install (@_);
91	}
92
93	# no-op, only used for source back-compat
94	sub add_headers { carp "add_headers() is a no-op" }
95
96	####### PRIVATE
97	sub basename { (File::Spec->splitdir ($_[0]))[-1] }
98	# get the name in Makefile syntax.
99	sub installed_filename {
100	my $self = shift;
101	return '$(INST_ARCHLIB)/$(FULLEXT)/Install/'.basename ($_[0]);
102	}
103
104	sub install {
105	# install things by adding them to the hash of pm files that gets
106	# passed through WriteMakefile's PM key.
107	my $self = shift;
108	foreach my $f (@_) {
109	$self->add_pm ($f, $self->installed_filename ($f));
110	}
111	}
112
113	sub save_config {
114	use Data::Dumper;
115	use IO::File;
116
117	my ($self, $filename) = @_;
118
119	my $file = IO::File->new (">".$filename)
120	or croak "can't open '$filename' for writing: $!\n";
121
122	print $file "package $self->{name}\::Install::Files;\n\n";
123	# for modern stuff
124	print $file "".Data::Dumper->Dump([{
125	inc => join (" ", @{ $self->{inc} }),
126	libs => $self->{libs},
127	typemaps => [ map { basename $_ } @{ $self->{typemaps} } ],
128	deps => [keys %{ $self->{deps} }],
129	}], ['self']);
130	# for ancient stuff
131	print $file "\n\n# this is for backwards compatiblity\n";
132	print $file "\@deps = \@{ \$self->{deps} };\n";
133	print $file "\@typemaps = \@{ \$self->{typemaps} };\n";
134	print $file "\$libs = \$self->{libs};\n";
135	print $file "\$inc = \$self->{inc};\n";
136	# this is riduculous, but old versions of ExtUtils::Depends take
137	# first $loadedmodule::CORE and then $INC{$file} --- the fallback
138	# includes the Filename.pm, which is not useful. so we must add
139	# this crappy code. we don't worry about portable pathnames,
140	# as the old code didn't either.
141	(my $mdir = $self->{name}) =~ s{::}{/}g;
142	print $file <<"EOT";
143
144	\$CORE = undef;
145	foreach (\@INC) {
146	if ( -f \$_ . "/$mdir/Install/Files.pm") {
147	\$CORE = \$_ . "/$mdir/Install/";
148	last;
149	}
150	}
151	EOT
152
153	print $file "\n1;\n";
154
155	close $file;
156
157	# we need to ensure that the file we just created gets put into
158	# the install dir with everything else.
159	#$self->install ($filename);
160	$self->add_pm ($filename, $self->installed_filename ('Files.pm'));
161	}
162
163	sub load {
164	my $dep = shift;
165	my @pieces = split /::/, $dep;
166	my @suffix = qw/ Install Files /;
167	my $relpath = File::Spec->catfile (@pieces, @suffix) . '.pm';
168	my $depinstallfiles = join "::", @pieces, @suffix;
169	eval {
170	require $relpath
171	} or die " *** Can't load dependency information for $dep:\n $@\n";
172	#
173	#print Dumper(\%INC);
174
175	# effectively $instpath = dirname($INC{$relpath})
176	@pieces = File::Spec->splitdir ($INC{$relpath});
177	pop @pieces;
178	my $instpath = File::Spec->catdir (@pieces);
179
180	no strict;
181
182	croak "No dependency information found for $dep"
183	unless $instpath;
184
185	if (not File::Spec->file_name_is_absolute ($instpath)) {
186	$instpath = File::Spec->rel2abs ($instpath);
187	}
188
189	my @typemaps = map {
190	File::Spec->rel2abs ($_, $instpath)
191	} @{"$depinstallfiles\::typemaps"};
192
193	{
194	instpath => $instpath,
195	typemaps => \@typemaps,
196	inc => "-I$instpath ".${"$depinstallfiles\::inc"},
197	libs => ${"$depinstallfiles\::libs"},
198	# this will not exist when loading files from old versions
199	# of ExtUtils::Depends.
200	(exists ${"$depinstallfiles\::"}{deps}
201	? (deps => \@{"$depinstallfiles\::deps"})
202	: ()),
203	}
204	}
205
206	sub load_deps {
207	my $self = shift;
208	my @load = grep { not $self->{deps}{$_} } keys %{ $self->{deps} };
209	foreach my $d (@load) {
210	my $dep = load ($d);
211	$self->{deps}{$d} = $dep;
212	if ($dep->{deps}) {
213	foreach my $childdep (@{ $dep->{deps} }) {
214	push @load, $childdep
215	unless
216	$self->{deps}{$childdep}
217	or
218	grep {$_ eq $childdep} @load;
219	}
220	}
221	}
222	}
223
224	sub uniquify {
225	my %seen;
226	# we use a seen hash, but also keep indices to preserve
227	# first-seen order.
228	my $i = 0;
229	foreach (@_) {
230	$seen{$_} = ++$i
231	unless exists $seen{$_};
232	}
233	#warn "stripped ".(@_ - (keys %seen))." redundant elements\n";
234	sort { $seen{$a} <=> $seen{$b} } keys %seen;
235	}
236
237
238	sub get_makefile_vars {
239	my $self = shift;
240
241	# collect and uniquify things from the dependencies.
242	# first, ensure they are completely loaded.
243	$self->load_deps;
244
245	##my @defbits = map { split } @{ $self->{defines} };
246	my @incbits = map { split } @{ $self->{inc} };
247	my @libsbits = split /\s+/, $self->{libs};
248	my @typemaps = @{ $self->{typemaps} };
249	foreach my $d (keys %{ $self->{deps} }) {
250	my $dep = $self->{deps}{$d};
251	#push @defbits, @{ $dep->{defines} };
252	push @incbits, @{ $dep->{defines} } if $dep->{defines};
253	push @incbits, split /\s+/, $dep->{inc} if $dep->{inc};
254	push @libsbits, split /\s+/, $dep->{libs} if $dep->{libs};
255	push @typemaps, @{ $dep->{typemaps} } if $dep->{typemaps};
256	}
257
258	# we have a fair bit of work to do for the xs files...
259	my @clean = ();
260	my @OBJECT = ();
261	my %XS = ();
262	foreach my $xs (@{ $self->{xs} }) {
263	(my $c = $xs) =~ s/\.xs$/\.c/i;
264	(my $o = $xs) =~ s/\.xs$/\$(OBJ_EXT)/i;
265	$XS{$xs} = $c;
266	push @OBJECT, $o;
267	# according to the MakeMaker manpage, the C files listed in
268	# XS will be added automatically to the list of cleanfiles.
269	push @clean, $o;
270	}
271
272	# we may have C files, as well:
273	foreach my $c (@{ $self->{c} }) {
274	(my $o = $c) =~ s/\.c$/\$(OBJ_EXT)/i;
275	push @OBJECT, $o;
276	push @clean, $o;
277	}
278
279	my %vars = (
280	INC => join (' ', uniquify @incbits),
281	LIBS => join (' ', uniquify $self->find_extra_libs, @libsbits),
282	TYPEMAPS => [@typemaps],
283	);
284
285	$self->build_dll_lib(\%vars) if $^O =~ /MSWin32/;
286
287	# we don't want to provide these if there is no data in them;
288	# that way, the caller can still get default behavior out of
289	# MakeMaker when INC, LIBS and TYPEMAPS are all that are required.
290	$vars{PM} = $self->{pm}
291	if %{ $self->{pm} };
292	$vars{clean} = { FILES => join (" ", @clean), }
293	if @clean;
294	$vars{OBJECT} = join (" ", @OBJECT)
295	if @OBJECT;
296	$vars{XS} = \%XS
297	if %XS;
298
299	%vars;
300	}
301
302	sub build_dll_lib {
303	my ($self, $vars) = @_;
304	$vars->{macro} \|\|= {};
305	$vars->{macro}{'INST_DYNAMIC_LIB'} =
306	'$(INST_ARCHAUTODIR)/$(BASEEXT)$(LIB_EXT)';
307	}
308
309	sub find_extra_libs {
310	my $self = shift;
311
312	my %mappers = (
313	MSWin32 => sub { $_[0] . '\.(?:lib\|a)' },
314	cygwin => sub { $_[0] . '\.dll'},
315	);
316	my $mapper = $mappers{$^O};
317	return () unless defined $mapper;
318
319	my @found_libs = ();
320	foreach my $name (keys %{ $self->{deps} }) {
321	(my $stem = $name) =~ s/^.*:://;
322	my $lib = $mapper->($stem);
323	my $pattern = qr/$lib$/;
324
325	my $matching_dir;
326	my $matching_file;
327	find (sub {
328	if ((not $matching_file) && /$pattern/) {;
329	$matching_dir = $File::Find::dir;
330	$matching_file = $File::Find::name;
331	}
332	}, map { -d $_ ? ($_) : () } @INC); # only extant dirs
333
334	if ($matching_file && -f $matching_file) {
335	push @found_libs, ('-L' . $matching_dir, '-l' . $stem);
336	next;
337	}
338	}
339
340	return @found_libs;
341	}
342
343	# Hook into ExtUtils::MakeMaker to create an import library on MSWin32 when gcc
344	# is used. FIXME: Ideally, this should be done in EU::MM itself.
345	package # wrap to fool the CPAN indexer
346	ExtUtils::MM;
347	use Config;
348	sub static_lib {
349	my $base = shift->SUPER::static_lib(@_);
350
351	return $base unless $^O =~ /MSWin32/ && $Config{cc} =~ /^gcc/i;
352
353	return <<'__EOM__';
354	# This isn't actually a static lib, it just has the same name on Win32.
355	$(INST_DYNAMIC_LIB): $(INST_DYNAMIC)
356	dlltool --def $(EXPORT_LIST) --output-lib $@ --dllname $(BASEEXT).$(SO) $(INST_DYNAMIC)
357
358	dynamic:: $(INST_DYNAMIC_LIB)
359	__EOM__
360	}
361
362	1;
363
364	__END__
365
366	=head1 NAME
367
368	ExtUtils::Depends - Easily build XS extensions that depend on XS extensions
369
370	=head1 SYNOPSIS
371
372	use ExtUtils::Depends;
373	$package = new ExtUtils::Depends ('pkg::name', 'base::package')
374	# set the flags and libraries to compile and link the module
375	$package->set_inc("-I/opt/blahblah");
376	$package->set_libs("-lmylib");
377	# add a .c and an .xs file to compile
378	$package->add_c('code.c');
379	$package->add_xs('module-code.xs');
380	# add the typemaps to use
381	$package->add_typemaps("typemap");
382	# install some extra data files and headers
383	$package->install (qw/foo.h data.txt/);
384	# save the info
385	$package->save_config('Files.pm');
386
387	WriteMakefile(
388	'NAME' => 'Mymodule',
389	$package->get_makefile_vars()
390	);
391
392	=head1 DESCRIPTION
393
394	This module tries to make it easy to build Perl extensions that use
395	functions and typemaps provided by other perl extensions. This means
396	that a perl extension is treated like a shared library that provides
397	also a C and an XS interface besides the perl one.
398
399	This works as long as the base extension is loaded with the RTLD_GLOBAL
400	flag (usually done with a
401
402	sub dl_load_flags {0x01}
403
404	in the main .pm file) if you need to use functions defined in the module.
405
406	The basic scheme of operation is to collect information about a module
407	in the instance, and then store that data in the Perl library where it
408	may be retrieved later. The object can also reformat this information
409	into the data structures required by ExtUtils::MakeMaker's WriteMakefile
410	function.
411
412	When creating a new Depends object, you give it a name, which is the name
413	of the module you are building. You can also specify the names of modules
414	on which this module depends. These dependencies will be loaded
415	automatically, and their typemaps, header files, etc merged with your new
416	object's stuff. When you store the data for your object, the list of
417	dependencies are stored with it, so that another module depending on your
418	needn't know on exactly which modules yours depends.
419
420	For example:
421
422	Gtk2 depends on Glib
423
424	Gnome2::Canvas depends on Gtk2
425
426	ExtUtils::Depends->new ('Gnome2::Canvas', 'Gtk2');
427	this command automatically brings in all the stuff needed
428	for Glib, since Gtk2 depends on it.
429
430
431	=head1 METHODS
432
433	=over
434
435	=item $object = ExtUtils::Depends->new($name, @deps)
436
437	Create a new depends object named I<$name>. Any modules listed in I<@deps>
438	(which may be empty) are added as dependencies and their dependency
439	information is loaded. An exception is raised if any dependency information
440	cannot be loaded.
441
442	=item $depends->add_deps (@deps)
443
444	Add modules listed in I<@deps> as dependencies.
445
446	=item (hashes) = $depends->get_deps
447
448	Fetch information on the dependencies of I<$depends> as a hash of hashes,
449	which are dependency information indexed by module name. See C<load>.
450
451	=item $depends->set_inc (@newinc)
452
453	Add strings to the includes or cflags variables.
454
455	=item $depends->set_libs (@newlibs)
456
457	Add strings to the libs (linker flags) variable.
458
459	=item $depends->add_pm (%pm_files)
460
461	Add files to the hash to be passed through ExtUtils::WriteMakefile's
462	PM key.
463
464	=item $depends->add_xs (@xs_files)
465
466	Add xs files to be compiled.
467
468	=item $depends->add_c (@c_files)
469
470	Add C files to be compiled.
471
472	=item $depends->add_typemaps (@typemaps)
473
474	Add typemap files to be used and installed.
475
476	=item $depends->add_headers (list)
477
478	No-op, for backward compatibility.
479
480	=item $depends->install (@files)
481
482	Install I<@files> to the data directory for I<$depends>.
483
484	This actually works by adding them to the hash of pm files that gets
485	passed through WriteMakefile's PM key.
486
487	=item $depends->save_config ($filename)
488
489	Save the important information from I<$depends> to I<$filename>, and
490	set it up to be installed as I<name>::Install::Files.
491
492	Note: the actual value of I<$filename> seems to be irrelevant, but its
493	usage is kept for backward compatibility.
494
495	=item hash = $depends->get_makefile_vars
496
497	Return the information in I<$depends> in a format digestible by
498	WriteMakefile.
499
500	This sets at least the following keys:
501
502	INC
503	LIBS
504	TYPEMAPS
505	PM
506
507	And these if there is data to fill them:
508
509	clean
510	OBJECT
511	XS
512
513	=item hashref = ExtUtils::Depends::load (name)
514
515	Load and return dependency information for I<name>. Croaks if no such
516	information can be found. The information is returned as an anonymous
517	hash containing these keys:
518
519	=over
520
521	=item instpath
522
523	The absolute path to the data install directory for this module.
524
525	=item typemaps
526
527	List of absolute pathnames for this module's typemap files.
528
529	=item inc
530
531	CFLAGS string for this module.
532
533	=item libs
534
535	LIBS string for this module.
536
537	=item deps
538
539	List of modules on which this one depends. This key will not exist when
540	loading files created by old versions of ExtUtils::Depends.
541
542	=back
543
544	=item $depends->load_deps
545
546	Load I<$depends> dependencies, by calling C<load> on each dependency module.
547	This is usually done for you, and should only be needed if you want to call
548	C<get_deps> after calling C<add_deps> manually.
549
550	=back
551
552
553	=head1 BUGS
554
555	Version 0.2 discards some of the more esoteric features provided by the
556	older versions. As they were completely undocumented, and this module
557	has yet to reach 1.0, this may not exactly be a bug.
558
559	This module is tightly coupled to the ExtUtils::MakeMaker architecture.
560
561	=head1 SEE ALSO
562
563	ExtUtils::MakeMaker.
564
565	=head1 AUTHOR
566
567	Paolo Molaro <lupus at debian dot org> wrote the original version for
568	Gtk-Perl. muppet <scott at asofyet dot org> rewrote the innards for
569	version 0.2, borrowing liberally from Paolo's code.
570
571	=head1 MAINTAINER
572
573	The Gtk2 project, http://gtk2-perl.sf.net/
574
575	=head1 LICENSE
576
577	This library is free software; you may redistribute it and/or modify it
578	under the same terms as Perl itself.
579
580	=cut
581