Manpages - Alien_Base.3pm

my $dir = Alien::MyLibrary->dist_dir;

Returns the directory that contains the install root for the packaged software, if it was built from install (i.e., if install_type is share).

my $alien = Alien::MyLibrary->new;

Creates an instance of an Alien::Base object. This is typically unnecessary.

my $cflags = Alien::MyLibrary->cflags; use Text::ParseWords qw( shellwords ); my @cflags = shellwords( Alien::MyLibrary->cflags );

Returns the C compiler flags necessary to compile an XS module using the alien software. If you need this in list form (for example if you are calling system with a list argument) you can pass this value into shellwords from the Perl core Text::ParseWords module.

my $cflags = Alien::MyLibrary->cflags_static;

Same as cflags above, but gets the static compiler flags, if they are different.

my $libs = Alien::MyLibrary->libs; use Text::ParseWords qw( shellwords ); my @cflags = shellwords( Alien::MyLibrary->libs );

Returns the library linker flags necessary to link an XS module against the alien software. If you need this in list form (for example if you are calling system with a list argument) you can pass this value into shellwords from the Perl core Text::ParseWords module.

my $libs = Alien::MyLibrary->libs_static;

Same as libs above, but gets the static linker flags, if they are different.

my $version = Alien::MyLibrary->version;

Returns the version of the alienized library or tool that was determined at install time.

my $ok = Alien::MyLibrary->atleast_version($wanted_version); my $ok = Alien::MyLibrary->exact_version($wanted_version); my $ok = Alien::MyLibrary->max_version($wanted_version);

Returns true if the version of the alienized library or tool is at least, exactly, or at most the version specified, respectively.

$cmp = Alien::MyLibrary->version_cmp($x, $y)

Comparison method used by atleast_version, exact_version and max_version. May be useful to implement custom comparisons, or for subclasses to overload to get different version comparison semantics than the default rules, for packages that have some other rules than the pkg-config behaviour.

Should return a number less than, equal to, or greater than zero; similar in behaviour to the <=> and cmp operators.

my $install_type = Alien::MyLibrary->install_type; my $bool = Alien::MyLibrary->install_type($install_type);

Returns the install type that was used when Alien::MyLibrary was installed. If a type is provided (the second form in the synopsis) returns true if the actual install type matches. Types include:

system

The library was provided by the operating system

share

The library was not available when Alien::MyLibrary was installed, so it was built from source code, either downloaded from the Internet or bundled with Alien::MyLibrary.

my $value = Alien::MyLibrary->config($key);

Returns the configuration data as determined during the install of Alien::MyLibrary. For the appropriate config keys, see Alien::Base::ModuleBuild::API#CONFIG-DATA.

This is not typically used by Alien::Base and alienfile, but a compatible interface will be provided.

my @dlls = Alien::MyLibrary->dynamic_libs; my($dll) = Alien::MyLibrary->dynamic_libs;

Returns a list of the dynamic library or shared object files for the alien software.

my(@dir) = Alien::MyLibrary->bin_dir

Returns a list of directories with executables in them. For a system install this will be an empty list. For a share install this will be a directory under dist_dir named bin if it exists. You may wish to override the default behavior if you have executables or scripts that get installed into non-standard locations.

Example usage:

use Env qw( @PATH ); unshift @PATH, Alien::MyLibrary->bin_dir;

my(@dir) = Alien::MyLibrary->dynamic_dir

Returns the dynamic dir for a dynamic build (if the main build is static). For a share install this will be a directory under dist_dir named dynamic if it exists. System builds return an empty list.

Example usage:

use Env qw( @PATH ); unshift @PATH, Alien::MyLibrary->dynamic_dir;

my $helpers = Alien::MyLibrary->alien_helper;

Returns a hash reference of helpers provided by the Alien module. The keys are helper names and the values are code references. The code references will be executed at command time and the return value will be interpolated into the command before execution. The default implementation returns an empty hash reference, and you are expected to override the method to create your own helpers.

For use with commands specified in and alienfile or in your Build.Pl when used with Alien::Base::ModuleBuild.

Helpers allow users of your Alien module to use platform or environment determined logic to compute command names or arguments in your installer logic. Helpers allow you to do this without making your Alien module a requirement when a build from source code is not necessary.

As a concrete example, consider Alien::gmake, which provides the helper gmake:

package Alien::gmake; … sub alien_helper { my($class) = @_; return { gmake => sub { # return the executable name for GNU make, # usually either make or gmake depending on # the platform and environment $class->exe; } }, }

Now consider Alien::nasm. nasm requires GNU Make to build from source code, but if the system nasm package is installed we don’t need it. From the alienfile of Alien::nasm:

use alienfile; plugin Probe::CommandLine => ( command => nasm, args => [-v], match => qr/NASM version/, ); share { … plugin Extract => tar.gz; plugin Build::MSYS; build [ sh configure –prefix=%{alien.install.prefix}, %{gmake}, %{gmake} install, ]; }; …

my(@headers) = Alien::MyLibrary->inline_auto_include;

List of header files to automatically include in inline C and C++ code when using Inline::C or Inline::CPP. This is provided as a public interface primarily so that it can be overridden at run time. This can also be specified in your Build.PL with Alien::Base::ModuleBuild using the alien_inline_auto_include property.

my $hashref = Alien::MyLibrary->runtime_prop;

Returns a hash reference of the runtime properties computed by Alien::Build during its install process. If the Alien::Base based Alien was not built using Alien::Build, then this will return undef.

my $new_alien = Alien::MyLibrary->alt($alt_name); my $new_alien = $old_alien->alt($alt_name);

Returns an Alien::Base instance with the alternate configuration.

Some packages come with multiple libraries, and multiple .pc files to use with them. This method can be used with pkg-config plugins to access different configurations. (It could also be used with non-pkg-config based packages too, though there are not as of this writing any build time plugins that take advantage of this feature).

From your alienfile

use alienfile; plugin PkgConfig => ( pkg_name => [ libfoo, libbar, ], );

Then in your base class works like normal:

package Alien::MyLibrary; use parent qw( Alien::Base ); 1;

Then you can use it:

use Alien::MyLibrary; my $cflags = Alien::MyLibrary->alt(foo1)->cflags; my $libs = Alien::MyLibrary->alt(foo1)->libs;

my @alt_names = Alien::MyLibrary->alt_names

Returns the list of all available alternative configuration names.

my $bool = Alien::MyLibrary->alt_exists($alt_name)

Returns true if the given alternative configuration exists.