X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=dh;h=bf9685d7f9a53a6f21e16f3e6947d1501b9b1bf4;hb=6693ccf9146d8d9bb29e99276f6e30af3eab02c2;hp=8af408c453046e3c8e8a6f2fd5973023ac1fd993;hpb=99ad2a71e45b1d015bd4539ba093a9fae9fbf53b;p=debhelper.git

diff --git a/dh b/dh
index 8af408c..bf9685d 100755
--- a/dh
+++ b/dh
@@ -151,16 +151,6 @@ either and instead run your own commands.
 	override_dh_auto_build:
 		make universe-explode-in-delight
 
-If running a configure script, it may be necessary to prevent it being
-run twice, once for architecture-independent packages, and again for
-architecture-dependent packages.  This may be accomplished by
-overriding L<dh_autoconfigure(1)>:
-
-	override_dh_auto_configure: config.status
-
-	config.status:
-		dh_auto_configure -- $configure_options
-
 Another common case is wanting to do something manually before or
 after a particular debhelper command is run.
 
@@ -172,12 +162,13 @@ after a particular debhelper command is run.
 		dh_fixperms
 		chmod 4755 debian/foo/usr/bin/foo
 
-If your package is a Python package, B<dh> will use B<dh_pysupport> by
-default. This is how to use B<dh_pycentral> instead.
+Python tools are not run by dh by default, due to the continual change
+in that area. (Before compatability level v9, dh does run B<dh_pysupport>.)
+Here is how to use B<dh_python2>.
 
 	#!/usr/bin/make -f
 	%:
-		dh $@ --with python-central
+		dh $@ --with python2
 
 If your package uses autotools and you want to freshen F<config.sub> and
 F<config.guess> with newer versions from the B<autotools-dev> package
@@ -250,9 +241,9 @@ L<dh_listpackages(1)> to test what is being built. For example:
 	endif
 
 Finally, remember that you are not limited to using override targets in the
-rules file when using B<dh>. You can also explicitly define the regular
+rules file when using B<dh>. You can also explicitly define any of the regular
 rules file targets when it makes sense to do so. A common reason to do this
-is if your package needs different B<build-arch> and B<build-indep> targets.
+is when your package needs different B<build-arch> and B<build-indep> targets.
 For example, a package with a long document build process can put it in
 B<build-indep>.
 
@@ -260,15 +251,17 @@ B<build-indep>.
 	%:
 		dh $@
 	
-	binary: binary-arch binary-indep ;
-	binary-arch:: build-arch
-	binary-indep:: build-indep
-	build: build-arch build-indep ;
 	build-indep:
 		$(MAKE) docs
 	build-arch:
 		$(MAKE) bins
 
+Note that in the example above, dh will arrange for "debian/rules build"
+to call your build-indep and build-arch targets. You do not need to
+explicitly define those dependencies in the rules file when using dh with
+compatibility level v9. This example would be more complicated with
+earlier compatibility levels.
+
 =head1 INTERNALS
 
 If you're curious about B<dh>'s internals, here's how it works under the hood.
@@ -284,11 +277,10 @@ in the sequence. The B<--until>, B<--before>, B<--after>, and B<--remaining>
 options can override this behavior.
 
 A sequence can also run dependent targets in debian/rules.  For
-example, the "binary" sequence runs the "install" target.  This will
-show up in the dh output as "debian/rules install", but internally
-will be called "rules:install" in the sequence.  The "install"
-sequence likewise runs "debian/rules build", internally named
-"rules:build".
+example, the "binary" sequence runs the "install" target.
+
+B<dh> sets environment variables listed by B<dpkg-buildflags>, unless
+they are already set. It supports DEB_BUILD_OPTIONS=noopt too.
 
 B<dh> uses the B<DH_INTERNAL_OPTIONS> environment variable to pass information
 through to debhelper commands that are run inside override targets. The
@@ -300,9 +292,11 @@ might suggest, is subject to change at any time.
 # Stash this away before init modifies it.
 my @ARGV_orig=@ARGV;
 
-# python-support is enabled by default, at least for now
-# (and comes first so python-central loads later and can disable it).
-unshift @ARGV, "--with=python-support";
+if (compat(8)) {
+	# python-support was enabled by default before v9.
+	# (and comes first so python-central loads later and can disable it).
+	unshift @ARGV, "--with=python-support";
+}
 		
 init(options => {
 		"until=s" => \$dh{UNTIL},
@@ -327,7 +321,7 @@ init(options => {
 	bundling => 0,
 );
 inhibit_log();
-
+set_buildflags();
 
 # If make is using a jobserver, but it is not available
 # to this process, clean out MAKEFLAGS. This avoids
@@ -336,11 +330,42 @@ if (is_make_jobserver_unavailable()) {
 	clean_jobserver_makeflags();
 }
 
+# Process the sequence parameter.
+my $sequence;
+if (! compat(7)) {
+	# From v8, the sequence is the very first parameter.
+	$sequence=shift @ARGV_orig;
+	if (defined $sequence && $sequence=~/^-/) {
+		error "Unknown sequence $sequence (options should not come before the sequence)";
+	}
+}
+else {
+	# Before v8, the sequence could be at any position in the parameters,
+	# so was what was left after parsing.
+	$sequence=shift;
+	if (defined $sequence) {
+		@ARGV_orig=grep { $_ ne $sequence } @ARGV_orig;
+	}
+}
+if (! defined $sequence) {
+	error "specify a sequence to run";
+}
+# make -B causes the rules file to be run as a target.
+# Also support completly empty override targets.
+# Note: it's not safe to use rules_explicit_target before this check,
+# since it causes dh to be run.
+my $dummy_target="debhelper-fail-me";
+if ($sequence eq 'debian/rules' ||
+    $sequence =~ /^override_dh_/ ||
+    $sequence eq $dummy_target) {
+	exit 0;
+}
+
+
 # Definitions of sequences.
 my %sequences;
 my @bd_minimal = qw{
 	dh_testdir
-	dh_auto_configure
 };
 my @bd = qw{
 	dh_testdir
@@ -348,22 +373,6 @@ my @bd = qw{
 	dh_auto_build
 	dh_auto_test
 };
-# The build sequences will call 'debian/rules build-arch' and
-# 'debian/rules build-indep' after running the standard sequence;
-# these will typically be no-ops but this permits the standard targets
-# to be customised by the user and still run as a side-effect of the
-# build target.
-$sequences{build} = [@bd, 'rules:build-arch', 'rules:build-indep'];
-$sequences{'build-indep'} = [@bd];
-$sequences{'build-arch'} = [@bd];
-$sequences{clean} = [qw{
-	dh_testdir
-	dh_auto_clean
-	dh_clean
-}];
-my @i_minimal = qw{
-	dh_testroot
-};
 my @i = qw{
 	dh_testroot
 	dh_prep
@@ -406,15 +415,6 @@ my @i = qw{
 	dh_compress
 	dh_fixperms
 };
-# The install sequences will call 'debian/rules build' before running
-# the standard sequence, and 'debian/rules install-arch' and
-# 'debian/rules install-indep' after running the standard sequence;
-# these will typically be no-ops but this permits the install-arch and
-# install-indep targets to be customised by the user and still run as
-# a side-effect of the install target.
-$sequences{'install'} = ['rules:build', @i, 'rules:install-arch', 'rules:install-indep'];
-$sequences{'install-indep'} = ['rules:build-indep', @i];
-$sequences{'install-arch'} = ['rules:build-arch', @i];
 my @ba=qw{
 	dh_strip
 	dh_makeshlibs
@@ -426,11 +426,32 @@ my @b=qw{
 	dh_md5sums
 	dh_builddeb
 };
-# The binary sequences will call 'debian/rules install' before running
-# the standard sequence.
-$sequences{binary} = ['rules:install', 'rules:binary-arch', 'rules:binary-indep'];
-$sequences{'binary-indep'} = ['rules:install-indep', @b];
-$sequences{'binary-arch'} = ['rules:install-arch', @ba, @b];
+$sequences{clean} = [qw{
+	dh_testdir
+	dh_auto_clean
+	dh_clean
+}];
+$sequences{'build-indep'} = [@bd];
+$sequences{'build-arch'} = [@bd];
+if (! compat(8)) {
+	# From v9, sequences take standard rules targets into account.
+	$sequences{build} = [@bd_minimal, rules("build-arch"), rules("build-indep")];
+	$sequences{'install-indep'} = [rules("build-indep"), @i];
+	$sequences{'install-arch'} = [rules("build-arch"), @i];
+	$sequences{'install'} = [rules("build"), rules("install-arch"), rules("install-indep"), @i];
+	$sequences{'binary-indep'} = [rules("install-indep"), @b];
+	$sequences{'binary-arch'} = [rules("install-arch"), @ba, @b];
+	$sequences{binary} = [rules("install"), rules("binary-arch"), rules("binary-indep")];
+}
+else {
+	$sequences{build} = [@bd];
+	$sequences{'install'} = [@{$sequences{build}}, @i];
+	$sequences{'install-indep'} = [@{$sequences{'build-indep'}}, @i];
+	$sequences{'install-arch'} = [@{$sequences{'build-arch'}}, @i];
+	$sequences{binary} = [@{$sequences{install}}, @ba, @b];
+	$sequences{'binary-indep'} = [@{$sequences{'install-indep'}}, @b];
+	$sequences{'binary-arch'} = [@{$sequences{'install-arch'}}, @ba, @b];
+}
 
 # Additional command options
 my %command_opts;
@@ -519,6 +540,7 @@ sub list_addons {
 	exit 0;
 }
 
+# Load addons, which can modify sequences.
 foreach my $addon (@{$dh{WITH}}) {
 	my $mod="Debian::Debhelper::Sequence::$addon";
 	$mod=~s/-/_/g;
@@ -528,53 +550,11 @@ foreach my $addon (@{$dh{WITH}}) {
 	}
 }
 
-my $sequence;
-if (! compat(7)) {
-	# From v8, the sequence is the very first parameter.
-	$sequence=shift @ARGV_orig;
-	if ($sequence=~/^-/) {
-		error "Unknown sequence $sequence (options should not come before the sequence)";
-	}
-}
-else {
-	# Before v8, the sequence could be at any position in the parameters,
-	# so was what was left after parsing.
-	$sequence=shift;
-	if (defined $sequence) {
-		@ARGV_orig=grep { $_ ne $sequence } @ARGV_orig;
-	}
-}
-if (! defined $sequence) {
-	error "specify a sequence to run";
-}
-if ($sequence eq 'debian/rules' ||
-    $sequence =~ /^override_dh_/) {
-	# make -B causes the rules file to be run as a target.
-	# Also support completly empty override targets.
-	exit 0;
-}
-elsif (! exists $sequences{$sequence}) {
+if (! exists $sequences{$sequence}) {
 	error "Unknown sequence $sequence (choose from: ".
 		join(" ", sort keys %sequences).")";
 }
-
-# Note: it's not safe to run rules_explicit_target before this point
-# due to dh being recursively invoked with debhelper-fail-me as the
-# sequence
-# If debian/rules defines build-arch or build-indep, run sequences
-# separately.
-if (rules_explicit_target('build-arch') ||
-    rules_explicit_target('build-indep')) {
-    $sequences{build} = [@bd_minimal, 'rules:build-arch', 'rules:build-indep'];
-}
-# If debian/rules defines install-arch or install-indep, run sequences
-# separately.
-if (rules_explicit_target('install-arch') ||
-    rules_explicit_target('install-indep')) {
-	$sequences{'install'} = ['rules:build', @i_minimal, 'rules:install-arch', 'rules:install-indep'];
-}
-
-my @sequence=@{$sequences{$sequence}};
+my @sequence=optimize_sequence(@{$sequences{$sequence}});
 
 # The list of all packages that can be acted on.
 my @packages=@{$dh{DOPACKAGES}};
@@ -696,18 +676,12 @@ sub run {
 	# to prevent them from being acted on.
 	push @options, map { "-N$_" } @exclude;
 
-	# If the command has a rules: prefix, run debian/rules with
-	# the remainder as the target.
-	my $rules_target = undef;
-	if ($command =~ /^rules:(.*)/) {
-		$rules_target = $1;
-	}
-
 	# Check for override targets in debian/rules and
 	# run them instead of running the command directly.
 	my $override_command;
 	my $has_explicit_target = rules_explicit_target("override_".$command);
 
+	my $rules_target = rules_target($command);
 	if (defined $rules_target) {
 		# Don't pass DH_ environment variables, since this is
 		# a fresh invocation of debian/rules and any sub-dh
@@ -777,6 +751,46 @@ sub run {
 	}
 }
 
+sub optimize_sequence {
+	my @sequence;
+	my %seen;
+	my $add=sub {
+		# commands can appear multiple times when sequences are
+		# inlined together; only the first should be needed
+		my $command=shift;
+		if (! $seen{$command}) {
+			$seen{$command}=1;
+			push @sequence, $command;
+		}
+	};
+	foreach my $command (@_) {
+		my $rules_target=rules_target($command);
+		if (defined $rules_target &&
+		    ! defined rules_explicit_target($rules_target)) {
+			# inline the sequence for this implicit target
+			$add->($_) foreach optimize_sequence(@{$sequences{$rules_target}});
+		}
+		else {
+			$add->($command);
+		}
+	}
+	return @sequence;
+}
+
+sub rules_target {
+	my $command=shift;
+	if ($command =~ /^debian\/rules\s+(.*)/) {
+		return $1
+	}
+	else {
+		return undef;
+	}
+}
+
+sub rules {
+	return "debian/rules ".join(" ", @_);
+}
+
 {
 my %targets;
 my $rules_parsed;
@@ -792,7 +806,7 @@ sub rules_explicit_target {
 		my $processing_targets = 0;
 		my $not_a_target = 0;
 		my $current_target;
-		open(MAKE, "LC_ALL=C make -Rrnpsf debian/rules debhelper-fail-me 2>/dev/null |");
+		open(MAKE, "LC_ALL=C make -Rrnpsf debian/rules $dummy_target 2>/dev/null |");
 		while (<MAKE>) {
 			if ($processing_targets) {
 				if (/^# Not a target:/) {
@@ -810,7 +824,7 @@ sub rules_explicit_target {
 						if (defined $current_target) {
 							if (/^#/) {
 								# Check if target has commands to execute
-								if (/^#\s*commands to execute/) {
+								if (/^#\s*(commands|recipe) to execute/) {
 									$targets{$current_target} = 1;
 								}
 							}