Alien-ROOT
view release on metacpan or search on metacpan
Throws an exception if ROOT was not found, so wrap this in an "eval" or
check "$aroot->installed" before using this.
$aroot->version
Determine the installed version of ROOT, as a string.
Example code:
my $version = $aroot->version;
$aroot->ldflags
$aroot->linker_flags
This returns the flags required to link C code with the local
installation of ROOT.
Example code:
my $ldflags = $aroot->ldflags;
$aroot->cflags
$aroot->compiler_flags
This method returns the compiler option flags to compile C++ code which
uses the ROOT library (typically in the CFLAGS variable).
Example code:
my $cflags = $aroot->cflags;
$aroot->features
This method returns a string of ROOT features that were enabled when
ROOT was compiled.
Example code:
my $features = $aroot->features;
if ($features !~ /\bexplicitlink\b/) {
warn "ROOT was built without the --explicitlink option";
inc/inc_Archive-Extract/Archive/Extract.pm view on Meta::CPAN
is_gz => { bin => '_gunzip_bin', pp => '_gunzip_cz' },
is_zip => { bin => '_unzip_bin', pp => '_unzip_az' },
is_tbz => { bin => '_untar_bin', pp => '_untar_at' },
is_bz2 => { bin => '_bunzip2_bin', pp => '_bunzip2_bz2'},
is_Z => { bin => '_uncompress_bin', pp => '_gunzip_cz' },
is_lzma => { bin => '_unlzma_bin', pp => '_unlzma_cz' },
is_xz => { bin => '_unxz_bin', pp => '_unxz_cz' },
is_txz => { bin => '_untar_bin', pp => '_untar_at' },
};
{ ### use subs so we re-generate array refs etc for the no-override flags
### if we don't, then we reuse the same arrayref, meaning objects store
### previous errors
my $tmpl = {
archive => sub { { required => 1, allow => FILE_EXISTS } },
type => sub { { default => '', allow => [ @Types ] } },
_error_msg => sub { { no_override => 1, default => [] } },
_error_msg_long => sub { { no_override => 1, default => [] } },
};
### build accessors ###
inc/inc_IPC-Cmd/IPC/Cmd.pm view on Meta::CPAN
The C<can_run> function can tell you if a certain binary is installed
and if so where, whereas the C<run> function can actually execute any
of the commands you give it and give you a clear return value, as well
as adhere to your verbosity settings.
=head1 CLASS METHODS
=head2 $ipc_run_version = IPC::Cmd->can_use_ipc_run( [VERBOSE] )
Utility function that tells you if C<IPC::Run> is available.
If the C<verbose> flag is passed, it will print diagnostic messages
if L<IPC::Run> can not be found or loaded.
=cut
sub can_use_ipc_run {
my $self = shift;
my $verbose = shift || 0;
### IPC::Run doesn't run on win98
inc/inc_IPC-Cmd/IPC/Cmd.pm view on Meta::CPAN
verbose => ($WARN && $verbose),
);
### otherwise, we're good to go
return $IPC::Run::VERSION;
}
=head2 $ipc_open3_version = IPC::Cmd->can_use_ipc_open3( [VERBOSE] )
Utility function that tells you if C<IPC::Open3> is available.
If the verbose flag is passed, it will print diagnostic messages
if C<IPC::Open3> can not be found or loaded.
=cut
sub can_use_ipc_open3 {
my $self = shift;
my $verbose = shift || 0;
### IPC::Open3 is not working on VMS because of a lack of fork.
inc/inc_IPC-Cmd/IPC/Cmd.pm view on Meta::CPAN
my $start_time = time();
my $pid;
if ($pid = fork) {
# we are a parent
close($parent_stdout_socket);
close($parent_stderr_socket);
close($parent_info_socket);
my $flags;
# prepare sockets to read from child
$flags = 0;
fcntl($child_stdout_socket, POSIX::F_GETFL, $flags) || die "can't fnctl F_GETFL: $!";
$flags |= POSIX::O_NONBLOCK;
fcntl($child_stdout_socket, POSIX::F_SETFL, $flags) || die "can't fnctl F_SETFL: $!";
$flags = 0;
fcntl($child_stderr_socket, POSIX::F_GETFL, $flags) || die "can't fnctl F_GETFL: $!";
$flags |= POSIX::O_NONBLOCK;
fcntl($child_stderr_socket, POSIX::F_SETFL, $flags) || die "can't fnctl F_SETFL: $!";
$flags = 0;
fcntl($child_info_socket, POSIX::F_GETFL, $flags) || die "can't fnctl F_GETFL: $!";
$flags |= POSIX::O_NONBLOCK;
fcntl($child_info_socket, POSIX::F_SETFL, $flags) || die "can't fnctl F_SETFL: $!";
# print "child $pid started\n";
my $child_timedout = 0;
my $child_finished = 0;
my $child_stdout = '';
my $child_stderr = '';
my $child_merged = '';
my $child_exit_code = 0;
my $child_killed_by_signal = 0;
inc/inc_IPC-Cmd/IPC/Cmd.pm view on Meta::CPAN
$cmd = [ grep { defined } @$cmd ] if ref $cmd;
}
else {
$cmd = [ grep { defined && length } @$cmd ] if ref $cmd;
}
my $pp_cmd = (ref $cmd ? "@$cmd" : $cmd);
print loc("Running [%1]...\n", $pp_cmd ) if $verbose;
### did the user pass us a buffer to fill or not? if so, set this
### flag so we know what is expected of us
### XXX this is now being ignored. in the future, we could add diagnostic
### messages based on this logic
#my $user_provided_buffer = $buffer == \$def_buf ? 0 : 1;
### buffers that are to be captured
my( @buffer, @buff_err, @buff_out );
### capture STDOUT
my $_out_handler = sub {
my $buf = shift;
inc/inc_IPC-Cmd/IPC/Cmd.pm view on Meta::CPAN
my $_err_handler = sub {
my $buf = shift;
return unless defined $buf;
print STDERR $buf if $verbose;
push @buffer, $buf;
push @buff_err, $buf;
};
### flag to indicate we have a buffer captured
my $have_buffer = $self->can_capture_buffer ? 1 : 0;
### flag indicating if the subcall went ok
my $ok;
### dont look at previous errors:
local $?;
local $@;
local $!;
### we might be having a timeout set
eval {
local $SIG{ALRM} = sub { die bless sub {
inc/inc_IPC-Cmd/IPC/Cmd.pm view on Meta::CPAN
### another error happened, set by the dispatchub
} else {
$err = $self->error;
}
}
### fill the buffer;
$$buffer = join '', @buffer if @buffer;
### return a list of flags and buffers (if available) in list
### context, or just a simple 'ok' in scalar
return wantarray
? $have_buffer
? ($ok, $err, \@buffer, \@buff_out, \@buff_err)
: ($ok, $err )
: $ok
}
inc/inc_Module-Build/Module/Build.pm view on Meta::CPAN
=item diff
[version 0.14]
This action will compare the files about to be installed with their
installed counterparts. For .pm and .pod files, a diff will be shown
(this currently requires a 'diff' program to be in your PATH). For
other files like compiled binary files, we simply report whether they
differ.
A C<flags> parameter may be passed to the action, which will be passed
to the 'diff' program. Consult your 'diff' documentation for the
parameters it will accept - a good one is C<-u>:
./Build diff flags=-u
=item dist
[version 0.02]
This action is helpful for module authors who want to package up their
module for source distribution through a medium like CPAN. It will create a
tarball of the files listed in F<MANIFEST> and compress the tarball using
GZIP compression.
inc/inc_Module-Build/Module/Build.pm view on Meta::CPAN
is considered a comment, and is stripped before parsing. If more than
one line begins with the same action name, those lines are merged into
one set of options.
Besides the regular actions, there are two special pseudo-actions: the
key C<*> (asterisk) denotes any global options that should be applied
to all actions, and the key 'Build_PL' specifies options to be applied
when you invoke C<perl Build.PL>.
* verbose=1 # global options
diff flags=-u
install --install_base /home/ken
--install_path html=/home/ken/docs/html
installdeps --cpan_client 'cpanp -i'
If you wish to locate your resource file in a different location, you
can set the environment variable C<MODULEBUILDRC> to the complete
absolute path of the file containing your options.
=head2 Environment variables
inc/inc_Module-Build/Module/Build/API.pod view on Meta::CPAN
better.
If the target file of L</dist_version_from> contains more than one package
declaration, the version returned will be the one matching the configured
L</module_name>.
=item dynamic_config
[version 0.07]
A boolean flag indicating whether the F<Build.PL> file must be
executed, or whether this module can be built, tested and installed
solely from consulting its metadata file. The main reason to set this
to a true value is that your module performs some dynamic
configuration as part of its build/install process. If the flag is
omitted, the F<META.yml> spec says that installation tools should
treat it as 1 (true), because this is a safer way to behave.
Currently C<Module::Build> doesn't actually do anything with this flag
- it's up to higher-level tools like C<CPAN.pm> to do something useful
with it. It can potentially bring lots of security, packaging, and
convenience improvements.
=item extra_compiler_flags
=item extra_linker_flags
[version 0.19]
These parameters can contain array references (or strings, in which
case they will be split into arrays) to pass through to the compiler
and linker phases when compiling/linking C code. For example, to tell
the compiler that your code is C++, you might do:
my $build = Module::Build->new
(
module_name => 'Foo::Bar',
extra_compiler_flags => ['-x', 'c++'],
);
To link your XS code against glib you might write something like:
my $build = Module::Build->new
(
module_name => 'Foo::Bar',
dynamic_config => 1,
extra_compiler_flags => scalar `glib-config --cflags`,
extra_linker_flags => scalar `glib-config --libs`,
);
=item get_options
[version 0.26]
You can pass arbitrary command line options to F<Build.PL> or
F<Build>, and they will be stored in the Module::Build object and can
be accessed via the L</args()> method. However, sometimes you want
more flexibility out of your argument processing than this allows. In
inc/inc_Module-Build/Module/Build/API.pod view on Meta::CPAN
method will print the command to C<STDOUT>, and then execute it using
Perl's C<system()>. It returns true or false to indicate success or
failure (the opposite of how C<system()> works, but more intuitive).
Note that if you supply a single argument to C<do_system()>, it
will/may be processed by the system's shell, and any special
characters will do their special things. If you supply multiple
arguments, no shell will get involved and the command will be executed
directly.
=item extra_compiler_flags()
=item extra_compiler_flags(@flags)
[version 0.25]
Set or retrieve the extra compiler flags. Returns an arrayref of flags.
=item extra_linker_flags()
=item extra_linker_flags(@flags)
[version 0.25]
Set or retrieve the extra linker flags. Returns an arrayref of flags.
=item feature($name)
=item feature($name => $value)
[version 0.26]
With a single argument, returns true if the given feature is set.
With two arguments, sets the given feature to the given boolean value.
In this context, a "feature" is any optional functionality of an
inc/inc_Module-Build/Module/Build/Base.pm view on Meta::CPAN
$p->{bindoc_dirs} ||= [ $blibdir->("script") ];
$p->{libdoc_dirs} ||= [ $blibdir->("lib"), $blibdir->("arch") ];
$p->{dist_author} = [ $p->{dist_author} ] if defined $p->{dist_author} and not ref $p->{dist_author};
# Synonyms
$p->{requires} = delete $p->{prereq} if defined $p->{prereq};
$p->{script_files} = delete $p->{scripts} if defined $p->{scripts};
# Convert to from shell strings to arrays
for ('extra_compiler_flags', 'extra_linker_flags') {
$p->{$_} = [ $self->split_like_shell($p->{$_}) ] if exists $p->{$_};
}
# Convert to arrays
for ('include_dirs') {
$p->{$_} = [ $p->{$_} ] if exists $p->{$_} && !ref $p->{$_}
}
$self->add_to_cleanup( @{delete $p->{add_to_cleanup}} )
if $p->{add_to_cleanup};
inc/inc_Module-Build/Module/Build/Base.pm view on Meta::CPAN
create_makefile_pl
create_readme
debugger
destdir
dist_abstract
dist_author
dist_name
dist_suffix
dist_version
dist_version_from
extra_compiler_flags
extra_linker_flags
has_config_data
install_base
libdoc_dirs
magic_number
mb_version
module_name
needs_compiler
orig_dir
perl
pm_files
inc/inc_Module-Build/Module/Build/Base.pm view on Meta::CPAN
} @{"$current\::ISA"};
# I.e., if this class has any parents (at least, ones I've never seen
# before), push them, in order, onto the stack of classes I need to
# explore.
}
shift @out;
return @out;
}
sub extra_linker_flags { shift->_list_accessor('extra_linker_flags', @_) }
sub extra_compiler_flags { shift->_list_accessor('extra_compiler_flags', @_) }
sub _list_accessor {
(my $self, local $_) = (shift, shift);
my $p = $self->{properties};
$p->{$_} = [@_] if @_;
$p->{$_} = [] unless exists $p->{$_};
return ref($p->{$_}) ? $p->{$_} : [$p->{$_}];
}
# XXX Problem - if Module::Build is loaded from a different directory,
inc/inc_Module-Build/Module/Build/Base.pm view on Meta::CPAN
sub _translate_option {
my $self = shift;
my $opt = shift;
(my $tr_opt = $opt) =~ tr/-/_/;
return $tr_opt if grep $tr_opt =~ /^(?:no_?)?$_$/, qw(
create_license
create_makefile_pl
create_readme
extra_compiler_flags
extra_linker_flags
install_base
install_path
meta_add
meta_merge
test_files
use_rcfile
use_tap_harness
tap_harness_args
cpan_client
); # normalize only selected option names
inc/inc_Module-Build/Module/Build/Base.pm view on Meta::CPAN
if ( grep $opt =~ /^no[-_]?$_$/, @bool_opts ) {
$opt =~ s/^no-?//;
return ($opt, 0);
}
# non-boolean option; return option unchanged along with its argument
return ($opt, shift(@$argv)) unless grep $_ eq $opt, @bool_opts;
# we're punting a bit here, if an option appears followed by a digit
# we take the digit as the argument for the option. If there is
# nothing that looks like a digit, we pretend the option is a flag
# that is being set and has no argument.
my $arg = 1;
$arg = shift(@$argv) if @$argv && $argv->[0] =~ /^\d+$/;
return ($opt, $arg);
}
sub read_args {
my $self = shift;
inc/inc_Module-Build/Module/Build/Base.pm view on Meta::CPAN
my($opt, $arg) = $self->_optional_arg($1, \@_);
$self->_read_arg(\%args, $opt, $arg);
} elsif ( /^($opt_re)$/ and !defined($action)) {
$action = $1;
} else {
push @argv, $_;
}
}
$args{ARGV} = \@argv;
for ('extra_compiler_flags', 'extra_linker_flags') {
$args{$_} = [ $self->split_like_shell($args{$_}) ] if exists $args{$_};
}
# Convert to arrays
for ('include_dirs') {
$args{$_} = [ $args{$_} ] if exists $args{$_} && !ref $args{$_}
}
# Hashify these parameters
for ($self->hash_properties, 'config') {
inc/inc_Module-Build/Module/Build/Base.pm view on Meta::CPAN
# For systems that don't have 'diff' executable, should use Algorithm::Diff
sub ACTION_diff {
my $self = shift;
$self->depends_on('build');
my $local_lib = File::Spec->rel2abs('lib');
my @myINC = grep {$_ ne $local_lib} @INC;
# The actual install destination might not be in @INC, so check there too.
push @myINC, map $self->install_destination($_), qw(lib arch);
my @flags = @{$self->{args}{ARGV}};
@flags = $self->split_like_shell($self->{args}{flags} || '') unless @flags;
my $installmap = $self->install_map;
delete $installmap->{read};
delete $installmap->{write};
my $text_suffix = $self->file_qr('\.(pm|pod)$');
while (my $localdir = each %$installmap) {
my @localparts = File::Spec->splitdir($localdir);
my $files = $self->rscan_dir($localdir, sub {-f});
inc/inc_Module-Build/Module/Build/Base.pm view on Meta::CPAN
if (not $installed) {
print "Only in lib: $file\n";
next;
}
my $status = File::Compare::compare($installed, $file);
next if $status == 0; # Files are the same
die "Can't compare $installed and $file: $!" if $status == -1;
if ($file =~ $text_suffix) {
$self->do_system('diff', @flags, $installed, $file);
} else {
print "Binary files $file and $installed differ\n";
}
}
}
}
sub ACTION_pure_install {
shift()->depends_on('install');
}
inc/inc_Module-Build/Module/Build/Base.pm view on Meta::CPAN
return \%result;
}
sub make_tarball {
my ($self, $dir, $file) = @_;
$file ||= $dir;
$self->log_info("Creating $file.tar.gz\n");
if ($self->{args}{tar}) {
my $tar_flags = $self->verbose ? 'cvf' : 'cf';
$self->do_system($self->split_like_shell($self->{args}{tar}), $tar_flags, "$file.tar", $dir);
$self->do_system($self->split_like_shell($self->{args}{gzip}), "$file.tar") if $self->{args}{gzip};
} else {
eval { require Archive::Tar && Archive::Tar->VERSION(1.09); 1 }
or die "You must install Archive::Tar 1.09+ to make a distribution tarball\n".
"or specify a binary tar program with the '--tar' option.\n".
"See the documentation for the 'dist' action.\n";
my $files = $self->rscan_dir($dir);
# Archive::Tar versions >= 1.09 use the following to enable a compatibility
inc/inc_Module-Build/Module/Build/Base.pm view on Meta::CPAN
my $b = $self->cbuilder;
my $obj_file = $b->object_file($file);
$self->add_to_cleanup($obj_file);
return $obj_file if $self->up_to_date($file, $obj_file);
$b->compile(source => $file,
defines => $args{defines},
object_file => $obj_file,
include_dirs => $self->include_dirs,
extra_compiler_flags => $self->extra_compiler_flags,
);
return $obj_file;
}
sub link_c {
my ($self, $spec) = @_;
my $p = $self->{properties}; # For convenience
$self->add_to_cleanup($spec->{lib_file});
inc/inc_Module-Build/Module/Build/Base.pm view on Meta::CPAN
return $spec->{lib_file}
if $self->up_to_date([$spec->{obj_file}, @$objects],
$spec->{lib_file});
my $module_name = $spec->{module_name} || $self->module_name;
$self->cbuilder->link(
module_name => $module_name,
objects => [$spec->{obj_file}, @$objects],
lib_file => $spec->{lib_file},
extra_linker_flags => $p->{extra_linker_flags} );
return $spec->{lib_file};
}
sub compile_xs {
my ($self, $file, %args) = @_;
$self->log_verbose("$file -> $args{outfile}\n");
if (eval {require ExtUtils::ParseXS; 1}) {
inc/inc_Module-Build/Module/Build/Compat.pm view on Meta::CPAN
my %convert_installdirs = (
PERL => 'core',
SITE => 'site',
VENDOR => 'vendor',
);
my %makefile_to_build =
(
TEST_VERBOSE => 'verbose',
VERBINST => 'verbose',
INC => sub { map {(extra_compiler_flags => $_)} Module::Build->split_like_shell(shift) },
POLLUTE => sub { (extra_compiler_flags => '-DPERL_POLLUTE') },
INSTALLDIRS => sub { (installdirs => $convert_installdirs{uc shift()}) },
LIB => sub {
my $lib = shift;
my %config = (
installprivlib => $lib,
installsitelib => $lib,
installarchlib => "$lib/$Config{archname}",
installsitearch => "$lib/$Config{archname}"
);
return map { (config => "$_=$config{$_}") } keys %config;
inc/inc_Module-Build/Module/Build/Cookbook.pm view on Meta::CPAN
you don't need to re-invoke the F<Build> script with the complete perl
path each time. If you invoke it with the I<wrong> perl path, you'll
get a warning or a fatal error.
=head2 Modifying Config.pm values
C<Module::Build> relies heavily on various values from perl's
C<Config.pm> to do its work. For example, default installation paths
are given by C<installsitelib> and C<installvendorman3dir> and
friends, C linker & compiler settings are given by C<ld>,
C<lddlflags>, C<cc>, C<ccflags>, and so on. I<If you're pretty sure
you know what you're doing>, you can tell C<Module::Build> to pretend
there are different values in F<Config.pm> than what's really there,
by passing arguments for the C<--config> parameter on the command
line:
perl Build.PL --config cc=gcc --config ld=gcc
Inside the C<Build.PL> script the same thing can be accomplished by
passing values for the C<config> parameter to C<new()>:
inc/inc_Module-Build/Module/Build/Cookbook.pm view on Meta::CPAN
=head2 Installing in the same location as ExtUtils::MakeMaker
With the introduction of C<--prefix> in Module::Build 0.28 and
C<INSTALL_BASE> in C<ExtUtils::MakeMaker> 6.31 its easy to get them both
to install to the same locations.
First, ensure you have at least version 0.28 of Module::Build
installed and 6.31 of C<ExtUtils::MakeMaker>. Prior versions have
differing (and in some cases quite strange) installation behaviors.
The following installation flags are equivalent between
C<ExtUtils::MakeMaker> and C<Module::Build>.
MakeMaker Module::Build
PREFIX=... --prefix ...
INSTALL_BASE=... --install_base ...
DESTDIR=... --destdir ...
LIB=... --install_path lib=...
INSTALLDIRS=... --installdirs ...
INSTALLDIRS=perl --installdirs core
UNINST=... --uninst ...
INC=... --extra_compiler_flags ...
POLLUTE=1 --extra_compiler_flags -DPERL_POLLUTE
For example, if you are currently installing C<MakeMaker> modules with
this command:
perl Makefile.PL PREFIX=~
make test
make install UNINST=1
You can install into the same location with Module::Build using this:
inc/inc_Module-Build/Module/Build/WithXSpp.pm view on Meta::CPAN
# => to be documented another time. This is really not a feature that
# should be commonly used.
sub new {
my $proto = shift;
my $class = ref($proto) || $proto;
my %args = @_;
# This gives us the correct settings for the C++ compile (hopefully)
my $guess = ExtUtils::CppGuess->new();
if (defined $args{extra_compiler_flags}) {
if (ref($args{extra_compiler_flags})) {
$guess->add_extra_compiler_flags($_) for @{$args{extra_compiler_flags}};
}
else {
$guess->add_extra_compiler_flags($args{extra_compiler_flags})
}
delete $args{extra_compiler_flags};
}
if (defined $args{extra_linker_flags}) {
if (ref($args{extra_linker_flags})) {
$guess->add_extra_linker_flags($_) for @{$args{extra_linker_flags}};
}
else {
$guess->add_extra_linker_flags($args{extra_linker_flags})
}
delete $args{extra_linker_flags};
}
# add the typemap modules to the build dependencies
my $build_requires = $args{build_requires}||{};
my $extra_typemap_modules = $args{extra_typemap_modules}||{};
# FIXME: This prevents any potential subclasses from fudging with the extra typemaps?
foreach my $module (keys %$extra_typemap_modules) {
if (not defined $build_requires->{$module}
or defined($extra_typemap_modules->{$module})
&& $build_requires->{$module} < $extra_typemap_modules->{$module})
inc/inc_Module-Build/Module/Build/WithXSpp.pm view on Meta::CPAN
}
}
$args{build_requires} = $build_requires;
# Construct object using C++ options guess
my $self = $class->SUPER::new(
%args,
$guess->module_build_options # FIXME find a way to let the user override this
);
push @{$self->extra_compiler_flags},
map "-I$_",
(@{$self->cpp_source_dirs||[]}, $self->build_dir);
$self->_init(\%args);
return $self;
}
sub _init {
my $self = shift;
inc/inc_Module-Build/Module/Build/WithXSpp.pm view on Meta::CPAN
extra_typemap_modules => {
'ExtUtils::Typemaps::ObjectMap' => '0',
# ...
},
);
$build->create_build_script;
If you need to link against some library C<libfoo>, add this to
the options:
extra_linker_flags => [qw(-lfoo)],
There is C<extra_compiler_flags>, too, if you need it.
=item *
You create two folders in the main distribution folder:
F<src> and F<xsp>.
=item *
You put any C++ code that you want to build and include
in the module into F<src/>. All the typical C(++) file
inc/inc_Module-Load/Module/Load.pm view on Meta::CPAN
sub load (*;@) {
my $mod = shift or return;
my $who = _who();
if( _is_file( $mod ) ) {
require $mod;
} else {
LOAD: {
my $err;
for my $flag ( qw[1 0] ) {
my $file = _to_file( $mod, $flag);
eval { require $file };
$@ ? $err .= $@ : last LOAD;
}
die $err if $err;
}
}
### This addresses #41883: Module::Load cannot import
### non-Exporter module. ->import() routines weren't
### properly called when load() was used.
inc/inc_Params-Check/Params/Check.pm view on Meta::CPAN
=over 4
=item default
This is the default value if none was provided by the user.
This is also the type C<strict_type> will look at when checking type
integrity (see below).
=item required
A boolean flag that indicates if this argument was a required
argument. If marked as required and not provided, check() will fail.
=item strict_type
This does a C<ref()> check on the argument provided. The C<ref> of the
argument must be the same as the C<ref> of the default value for this
check to pass.
This is very useful if you insist on taking an array reference as
argument for example.
inc/inc_Params-Check/Params/Check.pm view on Meta::CPAN
), 1, 0 ) unless ref $tmpl->{'store'};
}
}
push @want_store, $key if $tmpl->{'store'};
}
### errors found ###
return if $fail;
### flag to see if anything went wrong ###
my $wrong;
### flag to see if we warned for anything, needed for warnings_fatal
my $warned;
for my $key (keys %$args) {
my $arg = $args->{$key};
### you gave us this key, but it's not in the template ###
unless( $utmpl->{$key} ) {
### but we'll allow it anyway ###
if( $ALLOW_UNKNOWN ) {
inc/inc_Params-Check/Params/Check.pm view on Meta::CPAN
$wrong ||= 1;
next;
}
### we got here, then all must be OK ###
$defs{$key} = $arg;
}
### croak with the collected errors if there were errors and
### we have the fatal flag toggled.
croak(__PACKAGE__->last_error) if ($wrong || $warned) && $WARNINGS_FATAL;
### done with our loop... if $wrong is set, something went wrong
### and the user is already informed, just return...
return if $wrong;
### check if we need to store any of the keys ###
### can't do it before, because something may go wrong later,
### leaving the user with a few set variables
for my $key (@want_store) {
inc/inc_Params-Check/Params/Check.pm view on Meta::CPAN
return (caller(2 + $CALLER_DEPTH + $level))[3] || 'ANON'
}
=head2 last_error()
Returns a string containing all warnings and errors reported during
the last time C<check> was called.
This is useful if you want to report then some other way than
C<carp>'ing when the verbose flag is on.
It is exported upon request.
=cut
{ $_ERROR_STRING = '';
sub _store_error {
my($err, $verbose, $offset) = @_[0..2];
$verbose ||= 0;
inc/inc_Params-Check/Params/Check.pm view on Meta::CPAN
=head2 $Params::Check::STRICT_TYPE
This works like the C<strict_type> option you can pass to C<check>,
which will turn on C<strict_type> globally for all calls to C<check>.
The default is 0;
=head2 $Params::Check::ALLOW_UNKNOWN
If you set this flag, unknown options will still be present in the
return value, rather than filtered out. This is useful if your
subroutine is only interested in a few arguments, and wants to pass
the rest on blindly to perhaps another subroutine.
The default is 0;
=head2 $Params::Check::STRIP_LEADING_DASHES
If you set this flag, all keys passed in the following manner:
function( -key => 'val' );
will have their leading dashes stripped.
=head2 $Params::Check::NO_DUPLICATES
If set to true, all keys in the template that are marked as to be
stored in a scalar, will also be removed from the result set.
lib/Alien/ROOT.pm view on Meta::CPAN
sub new {
my $class = shift;
Carp::croak('You must call this as a class method') if ref($class);
my $self = {
installed => 0,
root_config => undef,
version => undef,
cflags => undef,
ldflags => undef,
features => undef,
libdir => undef,
bindir => undef,
incdir => undef,
etcdir => undef,
archdir => undef, # internal
private_root => undef,
};
bless($self, $class);
lib/Alien/ROOT.pm view on Meta::CPAN
sub version {
my ($self) = @_;
Carp::croak('You must call this method as an object') unless ref($self);
return $self->_config_get_one_line_param('version', '--version');
}
=head2 $aroot->ldflags
=head2 $aroot->linker_flags
This returns the flags required to link C code with the local installation of
ROOT.
Example code:
my $ldflags = $aroot->ldflags;
=cut
sub ldflags {
my $self = shift;
Carp::croak('You must call this method as an object') unless ref($self);
return $self->_config_get_one_line_param('ldflags', qw(--ldflags --glibs --auxlibs));
}
# Glob to create an alias to ldflags
*linker_flags = *ldflags;
=head2 $aroot->cflags
=head2 $aroot->compiler_flags
This method returns the compiler option flags to compile C++ code which uses
the ROOT library (typically in the CFLAGS variable).
Example code:
my $cflags = $aroot->cflags;
=cut
sub cflags {
my $self = shift;
Carp::croak('You must call this method as an object') unless ref($self);
return $self->_config_get_one_line_param('cflags', qw(--cflags --auxcflags));
}
*compiler_flags = *cflags;
=head2 $aroot->features
This method returns a string of ROOT features that were enabled when ROOT
was compiled.
Example code:
my $features = $aroot->features;
( run in 0.690 second using v1.01-cache-2.11-cpan-94b05bcf43c )