]> git.donarmstrong.com Git - debhelper.git/blobdiff - Debian/Debhelper/Dh_Buildsystems.pm
makefile: Support the (asking for trouble) case of MAKE being set to something with...
[debhelper.git] / Debian / Debhelper / Dh_Buildsystems.pm
index aa2dff99635710815b1f5193cc479b6db645be78..0f34a2e2d24cf04293f33ebb654450badc929a2b 100644 (file)
@@ -1,4 +1,5 @@
-# A module for loading and managing debhelper buildsystem plugins.
+# A module for loading and managing debhelper build system classes.
+# This module is intended to be used by all dh_auto_* programs.
 #
 # Copyright: © 2009 Modestas Vainius
 # License: GPL-2+
@@ -8,183 +9,223 @@ package Debian::Debhelper::Dh_Buildsystems;
 use strict;
 use warnings;
 use Debian::Debhelper::Dh_Lib;
-
-use Exporter qw( import );
-our @EXPORT_OK = qw( DEFAULT_BUILD_DIRECTORY );
-
-# IMPORTANT: more specific buildsystems should go first
-# XXX JEH as noted, this has to match historical order for back-compat
-my @BUILDSYSTEMS = (
-    "autotools",
-    "cmake",
-    "perl_build",
-    "perl_makefile",
-    "python_distutils",
-    "makefile",
+use File::Spec;
+
+use base 'Exporter';
+our @EXPORT=qw(&buildsystems_init &buildsystems_do &load_buildsystem &load_all_buildsystems);
+
+use constant BUILD_STEPS => qw(configure build test install clean);
+
+# Historical order must be kept for backwards compatibility. New
+# build systems MUST be added to the END of the list.
+our @BUILDSYSTEMS = (
+       "autoconf",
+       "perl_makemaker",
+       "makefile",
+       "python_distutils",
+       "perl_build",
+       "cmake",
+       "ant",
 );
 
-sub DEFAULT_BUILD_DIRECTORY {
-       return "obj-" . dpkg_architecture_value("DEB_BUILD_GNU_TYPE");
-}
-
-sub new {
-       my $cls=shift;
-       my %opts=@_;
-       my $self = bless({
-           'o_dir' => undef,
-           'o_system' => undef,
-           'loaded_buildsystems' => [] }, $cls);
-
-       # XXX JEH AFAICS, these 2 env variables are never used or documented
-       if (!exists $opts{noenv}) {
-               if (exists $ENV{DH_AUTO_BUILDDIRECTORY}) {
-                       $self->_set_build_directory_option("env", $ENV{DH_AUTO_BUILDDIRECTORY});
-               }
-               if (exists $ENV{DH_AUTO_BUILDSYSTEM}) {
-                       $self->{o_system} = $ENV{DH_AUTO_BUILDSYSTEM};
-               }
-       }
-       return $self;
-}
+my $opt_buildsys;
+my $opt_sourcedir;
+my $opt_builddir;
+my $opt_list;
+my $opt_parallel;
 
-sub get_options {
-       my $self=shift;
-       my @options=@_;
-
-       my $set_dir = sub { $self->_set_build_directory_option(@_) };
-       my $list_bs = sub { $self->list_buildsystems(@_); exit 0 };
-
-       push @options, (
-           "b:s" => $set_dir,
-           "build-directory:s" => $set_dir,
-           "builddirectory:s" => $set_dir,
-
-           "m=s" => \$self->{o_system},
-           "build-system=s" => \$self->{o_system},
-           "buildsystem=s" => \$self->{o_system},
+sub create_buildsystem_instance {
+       my $system=shift;
+       my %bsopts=@_;
+       my $module = "Debian::Debhelper::Buildsystem::$system";
 
-           "l" => $list_bs,
-           "--list" => $list_bs,
-       );
-       my %options = @options;
-       return \%options;
-}
+       eval "use $module";
+       if ($@) {
+               error("unable to load build system class '$system': $@");
+       }
 
-sub _set_build_directory_option {
-       # XXX JEH option argument is not used, would be less confusing to
-       # not pass extra getopt value in
-       my ($self, $option, $value) = @_;
-       if (!$value || $value eq "auto") {
-               # Autogenerate build directory name
-               $self->{o_dir} = DEFAULT_BUILD_DIRECTORY;
+       if (!exists $bsopts{builddir} && defined $opt_builddir) {
+               $bsopts{builddir} = ($opt_builddir eq "") ? undef : $opt_builddir;
        }
-       else {
-               $self->{o_dir} = $value;
+       if (!exists $bsopts{sourcedir} && defined $opt_sourcedir) {
+               $bsopts{sourcedir} = ($opt_sourcedir eq "") ? undef : $opt_sourcedir;
        }
-}
-
-# XXX JEH this sub is not used
-sub _dump_options {
-       my $self=shift;
-       for my $opt (qw(o_dir o_system)) {
-               if (defined $self->{$opt}) {
-                       print $opt, ": ", $self->{$opt}, "\n";
-               }
+       if (!exists $bsopts{parallel}) {
+               $bsopts{parallel} = $opt_parallel;
        }
+       return $module->new(%bsopts);
 }
 
-sub _get_buildsystem_module {
-       my ($self, $system) = @_;
-       my $module = "Debian::Debhelper::Buildsystem::$system";
-
-       if (grep $module, @{$self->{loaded_buildsystems}} == 0) {
-               eval "use $module";
-               if ($@) {
-                       error("Unable to load buildsystem '$system': $@");
+# Autoselect a build system from the list of instances
+sub autoselect_buildsystem {
+       my $step=shift;
+       my $selected;
+       my $selected_level = 0;
+
+       foreach my $inst (@_) {
+               # Only derived (i.e. more specific) build system can be
+               # considered beyond the currently selected one.
+               next if defined $selected && !$inst->isa(ref $selected);
+
+               # If the build system says it is auto-buildable at the current
+               # step and it can provide more specific information about its
+               # status than its parent (if any), auto-select it.
+               my $level = $inst->check_auto_buildable($step);
+               if ($level > $selected_level) {
+                       $selected = $inst;
+                       $selected_level = $level;
                }
-               push @{$self->{loaded_buildsystems}}, $module;
        }
-       return $module;
+       return $selected;
 }
 
+# Similar to create_build system_instance(), but it attempts to autoselect
+# a build system if none was specified. In case autoselection fails, undef
+# is returned.
 sub load_buildsystem {
-       # XXX JEH the $system param is never passed
-       # by any call to this function
-       my ($self, $action, $system) = @_;
-
-       if (!defined $system) {
-               $system = $self->{o_system};
-       }
+       my $system=shift;
+       my $step=shift;
        if (defined $system) {
-               my $module =  $self->_get_buildsystem_module($system);
-               verbose_print("Selected buildsystem (specified): ".$module->NAME());
-               return $module->new($self->{o_dir});
+               my $inst = create_buildsystem_instance($system, @_);
+               return $inst;
        }
        else {
                # Try to determine build system automatically
-               for $system (@BUILDSYSTEMS) {
-                       my $module = $self->_get_buildsystem_module($system);
-                       my $inst = $module->new($self->{o_dir});
-                       if ($inst->is_buildable($action)) {
-                               verbose_print("Selected buildsystem (auto): ".$module->NAME());
-                               return $inst;
-                       }
+               my @buildsystems;
+               foreach $system (@BUILDSYSTEMS) {
+                       push @buildsystems, create_buildsystem_instance($system, @_);
                }
+               return autoselect_buildsystem($step, @buildsystems);
        }
-       return;
 }
 
 sub load_all_buildsystems {
-       my $self=shift;
-       for my $system (@BUILDSYSTEMS) {
-               $self->_get_buildsystem_module($system);
+       my $incs=shift || \@INC;
+       my (%buildsystems, @buildsystems);
+
+       foreach my $inc (@$incs) {
+               my $path = File::Spec->catdir($inc, "Debian/Debhelper/Buildsystem");
+               if (-d $path) {
+                       foreach my $module_path (glob "$path/*.pm") {
+                               my $name = basename($module_path);
+                               $name =~ s/\.pm$//;
+                               next if exists $buildsystems{$name};
+                               $buildsystems{$name} = create_buildsystem_instance($name, @_);
+                       }
+               }
        }
-       return @{$self->{loaded_buildsystems}};
+
+       # Standard debhelper build systems first
+       foreach my $name (@BUILDSYSTEMS) {
+               error("standard debhelper build system '$name' could not be found/loaded")
+                   if not exists $buildsystems{$name};
+               push @buildsystems, $buildsystems{$name};
+               delete $buildsystems{$name};
+       }
+
+       # The rest are 3rd party build systems
+       foreach my $name (keys %buildsystems) {
+               my $inst = $buildsystems{$name};
+               $inst->{thirdparty} = 1;
+               push @buildsystems, $inst;
+       }
+
+       return @buildsystems;
+}
+
+sub buildsystems_init {
+       my %args=@_;
+
+       my $max_parallel=1;
+
+       # Available command line options
+       my %options = (
+           "D=s" => \$opt_sourcedir,
+           "sourcedirectory=s" => \$opt_sourcedir,
+
+           "B:s" => \$opt_builddir,
+           "builddirectory:s" => \$opt_builddir,
+
+           "S=s" => \$opt_buildsys,
+           "buildsystem=s" => \$opt_buildsys,
+
+           "l" => \$opt_list,
+           "list" => \$opt_list,
+
+           "parallel" => sub { $max_parallel = -1 },
+           "max-parallel=i" => \$max_parallel,
+       );
+       $args{options}{$_} = $options{$_} foreach keys(%options);
+       Debian::Debhelper::Dh_Lib::init(%args);
+       set_parallel($max_parallel);
 }
 
-sub list_buildsystems {
-       my $self=shift;
-       for my $system ($self->load_all_buildsystems()) {
-               printf("%s - %s.\n", $system->NAME(), $system->DESCRIPTION());
+sub set_parallel {
+       my $max=shift;
+
+       $opt_parallel=1;
+
+       if (exists $ENV{DEB_BUILD_OPTIONS}) {
+               # Get number of processes from parallel=n tag limiting it
+               # with $max if needed
+               foreach my $opt (split(/\s+/, $ENV{DEB_BUILD_OPTIONS})) {
+                       if ($opt =~ /^parallel=(-?\d+)$/) {
+                               $opt_parallel = $1;
+                               if ($max > 0 && $opt_parallel > $max) {
+                                       $opt_parallel = $max;
+                               }
+                       }
+               }
        }
 }
 
-sub init_dh_auto_tool {
-       my $self=shift;
+sub buildsystems_list {
+       my $step=shift;
 
-       Debian::Debhelper::Dh_Lib::init(
-           options => $self->get_options(@_));
-       $self->{initialized}=1;
+       my @buildsystems = load_all_buildsystems();
+       my $auto = autoselect_buildsystem($step, grep { ! $_->{thirdparty} } @buildsystems);
+       my $specified;
+
+       # List build systems (including auto and specified status)
+       foreach my $inst (@buildsystems) {
+               if (! defined $specified && defined $opt_buildsys && $opt_buildsys eq $inst->NAME()) {
+                       $specified = $inst;
+               }
+               printf("%-20s %s", $inst->NAME(), $inst->DESCRIPTION());
+               print " [3rd party]" if $inst->{thirdparty};
+               print "\n";
+       }
+       print "\n";
+       print "Auto-selected: ", $auto->NAME(), "\n" if defined $auto;
+       print "Specified: ", $specified->NAME(), "\n" if defined $specified;
+       print "No system auto-selected or specified\n"
+               if ! defined $auto && ! defined $specified;
 }
 
-sub run_dh_auto_tool {
-       my $self=shift;
-       my $toolname = basename($0);
-       my $buildsystem;
+sub buildsystems_do {
+       my $step=shift;
 
-       # XXX JEH does this if ever not fire?
-       if (!exists $self->{initialized}) {
-               $self->init_dh_auto_tool();
+       if (!defined $step) {
+               $step = basename($0);
+               $step =~ s/^dh_auto_//;
        }
 
-       # Guess action from the dh_auto_* name
-       $toolname =~ s/^dh_auto_//;
-       if (grep(/^\Q$toolname\E$/, qw{configure build test install clean}) == 0) {
-               error("Unrecognized dh auto tool: ".basename($0));
+       if (grep(/^\Q$step\E$/, BUILD_STEPS) == 0) {
+               error("unrecognized build step: " . $step);
        }
 
-       $buildsystem = $self->load_buildsystem($toolname);
+       if ($opt_list) {
+               buildsystems_list($step);
+               exit 0;
+       }
+
+       my $buildsystem = load_buildsystem($opt_buildsys, $step);
        if (defined $buildsystem) {
-               return $buildsystem->$toolname(@_, @{$dh{U_PARAMS}});
+               $buildsystem->pre_building_step($step);
+               $buildsystem->$step(@_, @{$dh{U_PARAMS}});
+               $buildsystem->post_building_step($step);
        }
        return 0;
 }
 
-# XXX JEH generally, why does this need to be an OO object at all?
-# The entire state stored in this object is o_dir and o_system;
-# and the object is used as a singleton. So why not have a single sub
-# that parses the command line, loads the specified system, and uses it,
-# passing it the build directory. It would be both shorter and easier to
-# understand.
-
-1;
+1