B<build-indep>, B<build>, B<clean>, B<install-indep>, B<install-arch>,
B<install>, B<binary-arch>, B<binary-indep>, and B<binary>.
-Commands in the B<build-indep>, B<install-indep> and B<binary-indep>
-sequences are passed the B<-i> option to ensure they only work on
-architecture independent packages, and commands in the B<build-arch>,
-B<install-arch> and B<binary-arch> sequences are passed the B<-a>
-option to ensure they only work on architecture dependent packages.
-
-If F<debian/rules> contains a target with a name like B<override_>I<dh_command>,
-then when it would normally run I<dh_command>, B<dh> will instead call that
-target. The override target can then run the command with additional options,
-or run entirely different commands instead. See examples below. (Note that to
-use this feature, you should Build-Depend on debhelper 7.0.50 or above.)
+=head1 OVERRIDE TARGETS
+
+A F<debian/rules> file using B<dh> can override the command that is run
+at any step in a sequence, by defining an override target.
+
+To override I<dh_command>, add a target named B<override_>I<dh_command> to
+the rules file. When it would normally run I<dh_command>, B<dh> will
+instead call that target. The override target can then run the command with
+additional options, or run entirely different commands instead. See
+examples below.
+(Note that to use this feature, you should Build-Depend on
+debhelper 7.0.50 or above.)
+
+Override targets can also be defined to run only when building
+architecture dependent or architecture independent packages.
+Use targets with names like B<override_>I<dh_command>B<-arch>
+and B<override_>I<dh_command>B<-indep>.
+(Note that to use this feature, you should Build-Depend on
+debhelper 8.9.7 or above.)
=head1 OPTIONS
Often you'll want to pass an option to a specific debhelper command. The
easy way to do with is by adding an override target for that command.
-
+
#!/usr/bin/make -f
%:
dh $@
-
+
override_dh_strip:
dh_strip -Xfoo
-
- override_dh_installdocs:
- dh_installdocs README TODO
+
+ override_dh_auto_configure:
+ dh_auto_configure -- --with-foo --disable-bar
Sometimes the automated L<dh_auto_configure(1)> and L<dh_auto_build(1)>
can't guess what to do for a strange package. Here's how to avoid running
dh_fixperms
chmod 4755 debian/foo/usr/bin/foo
-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 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
at build time, you can use some commands provided in B<autotools-dev>
%:
dh $@ --with autotools_dev
+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 python2
+
Here is how to force use of Perl's B<Module::Build> build system,
which can be necessary if debhelper wrongly detects that the package
uses MakeMaker.
# Commands not to run:
override_dh_auto_test override_dh_compress override_dh_fixperms:
-Sometimes, you may need to make an override target only run commands when a
-particular package is being built. This can be accomplished using
-L<dh_listpackages(1)> to test what is being built. For example:
+A long build process for a separate documentation package can
+be separated out using architecture independent overrides.
+These will be skipped when running build-arch and binary-arch sequences.
#!/usr/bin/make -f
%:
dh $@
- override_dh_fixperms:
- dh_fixperms
- ifneq (,$(filter foo, $(shell dh_listpackages)))
- chmod 4755 debian/foo/usr/bin/foo
- endif
+ override_dh_auto_build-indep:
+ $(MAKE) -C docs
-Finally, remember that you are not limited to using override targets in the
-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 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>.
+ # No tests needed for docs
+ override_dh_auto_test-indep:
- #!/usr/bin/make -f
- %:
- dh $@
-
- build-indep:
- $(MAKE) docs
- build-arch:
- $(MAKE) bins
+ override_dh_auto_install-indep:
+ $(MAKE) -C docs install
+
+Adding to the example above, suppose you need to chmod a file, but only
+when building the architecture dependent package, as it's not present
+when building only documentation.
-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.
+ override_dh_fixperms-arch:
+ dh_fixperms
+ chmod 4755 debian/foo/usr/bin/foo
=head1 INTERNALS
contents (and indeed, existence) of this environment variable, as the name
might suggest, is subject to change at any time.
+Commands in the B<build-indep>, B<install-indep> and B<binary-indep>
+sequences are passed the B<-i> option to ensure they only work on
+architecture independent packages, and commands in the B<build-arch>,
+B<install-arch> and B<binary-arch> sequences are passed the B<-a>
+option to ensure they only work on architecture dependent packages.
+
=head1 DEPRECATED OPTIONS
The following options are deprecated. It's much
# Stash this away before init modifies it.
my @ARGV_orig=@ARGV;
-if (compat(8)) {
+if (compat(8, 1)) {
# 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";
$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{'install'} = [rules("build"), rules("install-arch"), rules("install-indep")];
$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")];
# Now run the commands in the sequence.
foreach my $i (0..$stoppoint) {
+ my $command=$sequence[$i];
+
# Figure out which packages need to run this command.
- my @exclude;
+ my @todo;
+ my @opts=@options;
foreach my $package (@packages) {
if ($startpoint{$package} > $i ||
$logged{$package}{$sequence[$i]}) {
- push @exclude, $package;
+ push @opts, "-N$package";
+ }
+ else {
+ push @todo, $package;
}
}
-
- if (@exclude eq @packages) {
- # Command already done for all packages.
+ next unless @todo;
+
+ 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 commands.
+ delete $ENV{DH_INTERNAL_OPTIONS};
+ delete $ENV{DH_INTERNAL_OVERRIDE};
+ run("debian/rules", $rules_target);
next;
}
+
+ # Check for override targets in debian/rules, and run instead of
+ # the usual command. (The non-arch-specific override is tried first,
+ # for simplest semantics; mixing it with arch-specific overrides
+ # makes little sense.)
+ foreach my $override_type (undef, "arch", "indep") {
+ @todo = run_override($override_type, $command, \@todo, @opts);
+ }
+ next unless @todo;
- run($sequence[$i], \@packages, \@exclude, @options);
+ run($command, @opts);
}
sub run {
my $command=shift;
- my @packages=@{shift()};
- my @exclude=@{shift()};
my @options=@_;
-
- # If some packages are excluded, add flags
- # to prevent them from being acted on.
- push @options, map { "-N$_" } @exclude;
- # 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);
+ # Include additional command options if any
+ unshift @options, @{$command_opts{$command}}
+ if exists $command_opts{$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
- # commands.
- $override_command=$command;
- delete $ENV{DH_INTERNAL_OPTIONS};
- delete $ENV{DH_INTERNAL_OVERRIDE};
- $command="debian/rules";
- @options=$rules_target;
- }
- elsif (defined $has_explicit_target) {
- $override_command=$command;
- # Check if target isn't noop
- if ($has_explicit_target) {
- # This passes the options through to commands called
- # inside the target.
- $ENV{DH_INTERNAL_OPTIONS}=join("\x1e", @options);
- $ENV{DH_INTERNAL_OVERRIDE}=$command;
- $command="debian/rules";
- @options="override_".$override_command;
- }
- else {
- $command = undef;
- }
- }
- else {
- # Pass additional command options if any
- unshift @options, @{$command_opts{$command}} if exists $command_opts{$command};
- }
+ # 3 space indent lines the command being run up under the
+ # sequence name after "dh ".
+ print " ".escape_shell($command, @options)."\n";
- if (defined $command) {
- # 3 space indent lines the command being run up under the
- # sequence name after "dh ".
- print " ".escape_shell($command, @options)."\n";
+ return if $dh{NO_ACT};
+
+ my $ret=system($command, @options);
+ if ($ret >> 8 != 0) {
+ exit $ret >> 8;
}
- else {
- print " ", "# Skipping ", $override_command, " - empty override", "\n";
+ elsif ($ret) {
+ exit 1;
}
-
- if (! $dh{NO_ACT}) {
- if (defined $command) {
- my $ret=system($command, @options);
-
- if ($ret >> 8 != 0) {
- exit $ret >> 8;
+}
+
+# Tries to run an override target for a command. Returns the list of
+# packages that it was unable to run an override target for.
+sub run_override {
+ my $override_type=shift; # arch, indep, or undef
+ my $command=shift;
+ my @packages=@{shift()};
+ my @options=@_;
+
+ my $override="override_$command".
+ (defined $override_type ? "-".$override_type : "");
+
+ # Check which packages are of the right architecture for the
+ # override_type.
+ my (@todo, @rest);
+ if (defined $override_type) {
+ foreach my $package (@packages) {
+ my $isall=package_arch($package) eq 'all';
+ if (($override_type eq 'indep' && $isall) ||
+ ($override_type eq 'arch' && !$isall)) {
+ push @todo, $package;
}
- elsif ($ret) {
- exit 1;
+ else {
+ push @rest, $package;
+ push @options, "-N$package";
}
}
+ }
+ else {
+ @todo=@packages;
+ }
- if (defined $override_command) {
- # Update log for overridden command now that it has
- # finished successfully.
- # (But avoid logging for dh_clean since it removes
- # the log earlier.)
- if ($override_command ne 'dh_clean') {
- my %packages=map { $_ => 1 } @packages;
- map { delete $packages{$_} } @exclude;
- write_log($override_command, keys %packages);
- commit_override_log(keys %packages);
- }
+ my $has_explicit_target = rules_explicit_target($override);
+ return @packages unless defined $has_explicit_target; # no such override
+ return @rest if ! $has_explicit_target; # has empty override
+ return @rest unless @todo; # has override, but no packages to act on
- delete $ENV{DH_INTERNAL_OPTIONS};
- delete $ENV{DH_INTERNAL_OVERRIDE};
- }
+ if (defined $override_type) {
+ # Ensure appropriate -a or -i option is passed when running
+ # an arch-specific override target.
+ my $opt=$override_type eq "arch" ? "-a" : "-i";
+ push @options, $opt unless grep { $_ eq $opt } @options;
}
+
+ # This passes the options through to commands called
+ # inside the target.
+ $ENV{DH_INTERNAL_OPTIONS}=join("\x1e", @options);
+ $ENV{DH_INTERNAL_OVERRIDE}=$command;
+ run("debian/rules", $override);
+ delete $ENV{DH_INTERNAL_OPTIONS};
+ delete $ENV{DH_INTERNAL_OVERRIDE};
+
+ # Update log for overridden command now that it has
+ # finished successfully.
+ # (But avoid logging for dh_clean since it removes
+ # the log earlier.)
+ if (! $dh{NO_ACT} && $command ne 'dh_clean') {
+ write_log($command, @todo);
+ commit_override_log(@todo);
+ }
+
+ return @rest;
}
sub optimize_sequence {
projects / debhelper.git / blobdiff