dh

   1 #!/usr/bin/perl -w
   2
   3 =head1 NAME
   4
   5 dh - debhelper command sequencer
   6
   7 =cut
   8
   9 use strict;
  10 use Debian::Debhelper::Dh_Lib;
  11
  12 =head1 SYNOPSIS
  13
  14 B<dh> I<sequence> [B<--with> I<addon>[B<,>I<addon> ...]] [B<--list>] [B<--until> I<cmd>] [B<--before> I<cmd>] [B<--after> I<cmd>] [B<--remaining>] [S<I<debhelper options>>]
  15
  16 =head1 DESCRIPTION
  17
  18 B<dh> runs a sequence of debhelper commands. The supported I<sequence>s
  19 correspond to the targets of a F<debian/rules> file: B<build-arch>,
  20 B<build-indep>, B<build>, B<clean>, B<install-indep>, B<install-arch>,
  21 B<install>, B<binary-arch>, B<binary-indep>, and B<binary>.
  22
  23 Commands in the B<build-indep>, B<install-indep> and B<binary-indep>
  24 sequences are passed the B<-i> option to ensure they only work on
  25 architecture independent packages, and commands in the B<build-arch>,
  26 B<install-arch> and B<binary-arch> sequences are passed the B<-a>
  27 option to ensure they only work on architecture dependent packages.
  28
  29 If F<debian/rules> contains a target with a name like B<override_>I<dh_command>,
  30 then when it would normally run I<dh_command>, B<dh> will instead call that
  31 target. The override target can then run the command with additional options,
  32 or run entirely different commands instead. See examples below. (Note that to
  33 use this feature, you should Build-Depend on debhelper 7.0.50 or above.)
  34
  35 =head1 OPTIONS
  36
  37 =over 4
  38
  39 =item B<--with> I<addon>[B<,>I<addon> ...]
  40
  41 Add the debhelper commands specified by the given addon to appropriate places
  42 in the sequence of commands that is run. This option can be repeated more
  43 than once, or multiple addons can be listed, separated by commas.
  44 This is used when there is a third-party package that provides
  45 debhelper commands. See the F<PROGRAMMING> file for documentation about
  46 the sequence addon interface.
  47
  48 =item B<--without> I<addon>
  49
  50 The inverse of B<--with>, disables using the given addon.
  51
  52 =item B<--list>, B<-l>
  53
  54 List all available addons.
  55
  56 =item B<--until> I<cmd>
  57
  58 Run commands in the sequence until and including I<cmd>, then stop.
  59
  60 =item B<--before> I<cmd>
  61
  62 Run commands in the sequence before I<cmd>, then stop.
  63
  64 =item B<--after> I<cmd>
  65
  66 Run commands in the sequence that come after I<cmd>.
  67
  68 =item B<--remaining>
  69
  70 Run all commands in the sequence that have yet to be run.
  71
  72 =item B<--no-act>
  73
  74 Prints commands that would run for a given sequence, but does not run them.
  75
  76 =back
  77
  78 All other options passed to B<dh> are passed on to each command it runs. This
  79 can be used to set an option like B<-v> or B<-X> or B<-N>, as well as for more
  80 specialised options.
  81
  82 In the above options, I<cmd> can be a full name of a debhelper command, or
  83 a substring. It'll first search for a command in the sequence exactly
  84 matching the name, to avoid any ambiguity. If there are multiple substring
  85 matches, the last one in the sequence will be used.
  86
  87 =cut
  88
  89 sub command_pos {
  90         my $command=shift;
  91         my @sequence=@_;
  92
  93         foreach my $i (0..$#sequence) {
  94                 if ($command eq $sequence[$i]) {
  95                         return $i;
  96                 }
  97         }
  98
  99         my @matches;
 100         foreach my $i (0..$#sequence) {
 101                 if ($sequence[$i] =~ /\Q$command\E/) {
 102                         push @matches, $i;
 103                 }
 104         }
 105         if (! @matches) {
 106                 error "command specification \"$command\" does not match any command in the sequence"
 107         }
 108         else {
 109                 return pop @matches;
 110         }
 111 }
 112
 113 =head1 EXAMPLES
 114
 115 To see what commands are included in a sequence, without actually doing
 116 anything:
 117
 118         dh binary-arch --no-act
 119
 120 This is a very simple rules file, for packages where the default sequences of
 121 commands work with no additional options.
 122
 123         #!/usr/bin/make -f
 124         %:
 125                 dh $@
 126
 127 Often you'll want to pass an option to a specific debhelper command. The
 128 easy way to do with is by adding an override target for that command.
 129
 130         #!/usr/bin/make -f
 131         %:
 132                 dh $@
 133
 134         override_dh_strip:
 135                 dh_strip -Xfoo
 136
 137         override_dh_installdocs:
 138                 dh_installdocs README TODO
 139
 140 Sometimes the automated L<dh_auto_configure(1)> and L<dh_auto_build(1)>
 141 can't guess what to do for a strange package. Here's how to avoid running
 142 either and instead run your own commands.
 143
 144         #!/usr/bin/make -f
 145         %:
 146                 dh $@
 147
 148         override_dh_auto_configure:
 149                 ./mondoconfig
 150
 151         override_dh_auto_build:
 152                 make universe-explode-in-delight
 153
 154 Another common case is wanting to do something manually before or
 155 after a particular debhelper command is run.
 156
 157         #!/usr/bin/make -f
 158         %:
 159                 dh $@
 160
 161         override_dh_fixperms:
 162                 dh_fixperms
 163                 chmod 4755 debian/foo/usr/bin/foo
 164
 165 If your package is a Python package, B<dh> will use B<dh_pysupport> by
 166 default. This is how to use B<dh_pycentral> instead.
 167
 168         #!/usr/bin/make -f
 169         %:
 170                 dh $@ --with python-central
 171
 172 If your package uses autotools and you want to freshen F<config.sub> and
 173 F<config.guess> with newer versions from the B<autotools-dev> package
 174 at build time, you can use some commands provided in B<autotools-dev>
 175 that automate it, like this.
 176
 177         #!/usr/bin/make -f
 178         %:
 179                 dh $@ --with autotools_dev
 180
 181 Here is how to force use of Perl's B<Module::Build> build system,
 182 which can be necessary if debhelper wrongly detects that the package
 183 uses MakeMaker.
 184
 185         #!/usr/bin/make -f
 186         %:
 187                 dh $@ --buildsystem=perl_build
 188
 189 To patch your package using quilt, you can tell B<dh> to use quilt's B<dh>
 190 sequence addons like this:
 191
 192         #!/usr/bin/make -f
 193         %:
 194                 dh $@ --with quilt
 195
 196 Here is an example of overriding where the B<dh_auto_>I<*> commands find
 197 the package's source, for a package where the source is located in a
 198 subdirectory.
 199
 200         #!/usr/bin/make -f
 201         %:
 202                 dh $@ --sourcedirectory=src
 203
 204 And here is an example of how to tell the B<dh_auto_>I<*> commands to build
 205 in a subdirectory, which will be removed on B<clean>.
 206
 207         #!/usr/bin/make -f
 208         %:
 209                 dh $@ --builddirectory=build
 210
 211 If your package can be built in parallel, you can support parallel building
 212 as follows. Then B<dpkg-buildpackage -j> will work.
 213
 214         #!/usr/bin/make -f
 215         %:
 216                 dh $@ --parallel
 217
 218 Here is a way to prevent B<dh> from running several commands that you don't
 219 want it to run, by defining empty override targets for each command.
 220
 221         #!/usr/bin/make -f
 222         %:
 223                 dh $@
 224
 225         # Commands not to run:
 226         override_dh_auto_test override_dh_compress override_dh_fixperms:
 227
 228 Sometimes, you may need to make an override target only run commands when a
 229 particular package is being built. This can be accomplished using
 230 L<dh_listpackages(1)> to test what is being built. For example:
 231
 232         #!/usr/bin/make -f
 233         %:
 234                 dh $@
 235
 236         override_dh_fixperms:
 237                 dh_fixperms
 238         ifneq (,$(filter foo, $(shell dh_listpackages)))
 239                 chmod 4755 debian/foo/usr/bin/foo
 240         endif
 241
 242 Finally, remember that you are not limited to using override targets in the
 243 rules file when using B<dh>. You can also explicitly define any of the regular
 244 rules file targets when it makes sense to do so. A common reason to do this
 245 is when your package needs different B<build-arch> and B<build-indep> targets.
 246 For example, a package with a long document build process can put it in
 247 B<build-indep>.
 248
 249         #!/usr/bin/make -f
 250         %:
 251                 dh $@
 252
 253         build-indep:
 254                 $(MAKE) docs
 255         build-arch:
 256                 $(MAKE) bins
 257
 258 Note that in the example above, dh will arrange for "debian/rules build"
 259 to call your build-indep and build-arch targets. You do not need to
 260 explicitly define the dependencies in the rules file when using dh with
 261 compatability level v9. This example would be more complicated with
 262 earlier compatability levels.
 263
 264 =head1 INTERNALS
 265
 266 If you're curious about B<dh>'s internals, here's how it works under the hood.
 267
 268 Each debhelper command will record when it's successfully run in
 269 F<debian/package.debhelper.log>. (Which B<dh_clean> deletes.) So B<dh> can tell
 270 which commands have already been run, for which packages, and skip running
 271 those commands again.
 272
 273 Each time B<dh> is run, it examines the log, and finds the last logged command
 274 that is in the specified sequence. It then continues with the next command
 275 in the sequence. The B<--until>, B<--before>, B<--after>, and B<--remaining>
 276 options can override this behavior.
 277
 278 A sequence can also run dependent targets in debian/rules.  For
 279 example, the "binary" sequence runs the "install" target.
 280
 281 B<dh> sets environment variables listed by B<dpkg-buildflags>, unless
 282 they are already set. It supports DEB_BUILD_OPTIONS=noopt too.
 283
 284 B<dh> uses the B<DH_INTERNAL_OPTIONS> environment variable to pass information
 285 through to debhelper commands that are run inside override targets. The
 286 contents (and indeed, existence) of this environment variable, as the name
 287 might suggest, is subject to change at any time.
 288
 289 =cut
 290
 291 # Stash this away before init modifies it.
 292 my @ARGV_orig=@ARGV;
 293
 294 # python-support is enabled by default, at least for now
 295 # (and comes first so python-central loads later and can disable it).
 296 unshift @ARGV, "--with=python-support";
 297
 298 init(options => {
 299                 "until=s" => \$dh{UNTIL},
 300                 "after=s" => \$dh{AFTER},
 301                 "before=s" => \$dh{BEFORE},
 302                 "remaining" => \$dh{REMAINING},
 303                 "with=s" => sub {
 304                         my ($option,$value)=@_;
 305                         push @{$dh{WITH}},split(",", $value);
 306                 },
 307                 "without=s" => sub {
 308                         my ($option,$value)=@_;
 309                         @{$dh{WITH}} = grep { $_ ne $value } @{$dh{WITH}};
 310                 },
 311                 "l" => \&list_addons,
 312                 "list" => \&list_addons,
 313         },
 314         # Disable complaints about unknown options; they are passed on to
 315         # the debhelper commands.
 316         ignore_unknown_options => 1,
 317         # Bundling does not work well since there are unknown options.
 318         bundling => 0,
 319 );
 320 inhibit_log();
 321 set_buildflags();
 322
 323 # If make is using a jobserver, but it is not available
 324 # to this process, clean out MAKEFLAGS. This avoids
 325 # ugly warnings when calling make.
 326 if (is_make_jobserver_unavailable()) {
 327         clean_jobserver_makeflags();
 328 }
 329
 330 # Process the sequence parameter.
 331 my $sequence;
 332 if (! compat(7)) {
 333         # From v8, the sequence is the very first parameter.
 334         $sequence=shift @ARGV_orig;
 335         if ($sequence=~/^-/) {
 336                 error "Unknown sequence $sequence (options should not come before the sequence)";
 337         }
 338 }
 339 else {
 340         # Before v8, the sequence could be at any position in the parameters,
 341         # so was what was left after parsing.
 342         $sequence=shift;
 343         if (defined $sequence) {
 344                 @ARGV_orig=grep { $_ ne $sequence } @ARGV_orig;
 345         }
 346 }
 347 if (! defined $sequence) {
 348         error "specify a sequence to run";
 349 }
 350 # make -B causes the rules file to be run as a target.
 351 # Also support completly empty override targets.
 352 # Note: it's not safe to use rules_explicit_target before this check,
 353 # since it causes dh to be run.
 354 my $dummy_target="debhelper-fail-me";
 355 if ($sequence eq 'debian/rules' ||
 356     $sequence =~ /^override_dh_/ ||
 357     $sequence eq $dummy_target) {
 358         exit 0;
 359 }
 360
 361
 362 # Definitions of sequences.
 363 my %sequences;
 364 my @bd_minimal = qw{
 365         dh_testdir
 366 };
 367 my @bd = qw{
 368         dh_testdir
 369         dh_auto_configure
 370         dh_auto_build
 371         dh_auto_test
 372 };
 373 my @i_minimal = qw{
 374         dh_testroot
 375 };
 376 my @i = qw{
 377         dh_testroot
 378         dh_prep
 379         dh_installdirs
 380         dh_auto_install
 381
 382         dh_install
 383         dh_installdocs
 384         dh_installchangelogs
 385         dh_installexamples
 386         dh_installman
 387
 388         dh_installcatalogs
 389         dh_installcron
 390         dh_installdebconf
 391         dh_installemacsen
 392         dh_installifupdown
 393         dh_installinfo
 394         dh_installinit
 395         dh_installmenu
 396         dh_installmime
 397         dh_installmodules
 398         dh_installlogcheck
 399         dh_installlogrotate
 400         dh_installpam
 401         dh_installppp
 402         dh_installudev
 403         dh_installwm
 404         dh_installxfonts
 405         dh_installgsettings
 406         dh_bugfiles
 407         dh_ucf
 408         dh_lintian
 409         dh_gconf
 410         dh_icons
 411         dh_perl
 412         dh_usrlocal
 413
 414         dh_link
 415         dh_compress
 416         dh_fixperms
 417 };
 418 my @ba=qw{
 419         dh_strip
 420         dh_makeshlibs
 421         dh_shlibdeps
 422 };
 423 my @b=qw{
 424         dh_installdeb
 425         dh_gencontrol
 426         dh_md5sums
 427         dh_builddeb
 428 };
 429 $sequences{clean} = [qw{
 430         dh_testdir
 431         dh_auto_clean
 432         dh_clean
 433 }];
 434 $sequences{'build-indep'} = [@bd];
 435 $sequences{'build-arch'} = [@bd];
 436 if (! compat(8)) {
 437         # From v9, sequences take standard rules targets into account.
 438         if (rules_explicit_target('build-arch') ||
 439             rules_explicit_target('build-indep')) {
 440                 # run sequences separately
 441                 $sequences{build} = [@bd_minimal, rules("build-arch"), rules("build-indep")];
 442         }
 443         else {
 444                 # run standard sequence (this is faster)
 445                 $sequences{build} = [@bd];
 446         }
 447         $sequences{'install-indep'} = [rules("build-indep"), @i];
 448         $sequences{'install-arch'} = [rules("build-arch"), @i];
 449         if (rules_explicit_target('install-arch') ||
 450             rules_explicit_target('install-indep')) {
 451                 # run sequences separately
 452                 $sequences{'install'} = [rules("build"), @i_minimal, rules("install-arch"), rules("install-indep")];
 453         }
 454         else {
 455                 # run standard sequence (this is faster)
 456                 $sequences{'install'} = [rules("build"), @i, rules("install-arch"), rules("install-indep")];
 457         }
 458         $sequences{'binary-indep'} = [rules("install-indep"), @b];
 459         $sequences{'binary-arch'} = [rules("install-arch"), @ba, @b];
 460         $sequences{binary} = [rules("install"), rules("binary-arch"), rules("binary-indep")];
 461 }
 462 else {
 463         $sequences{build} = [@bd];
 464         $sequences{'install'} = [@{$sequences{build}}, @i];
 465         $sequences{'install-indep'} = [@{$sequences{'build-indep'}}, @i];
 466         $sequences{'install-arch'} = [@{$sequences{'build-arch'}}, @i];
 467         $sequences{binary} = [@{$sequences{install}}, @ba, @b];
 468         $sequences{'binary-indep'} = [@{$sequences{'install-indep'}}, @b];
 469         $sequences{'binary-arch'} = [@{$sequences{'install-arch'}}, @ba, @b];
 470 }
 471
 472 # Additional command options
 473 my %command_opts;
 474
 475 # sequence addon interface
 476 sub _insert {
 477         my $offset=shift;
 478         my $existing=shift;
 479         my $new=shift;
 480         foreach my $sequence (keys %sequences) {
 481                 my @list=@{$sequences{$sequence}};
 482                 next unless grep $existing, @list;
 483                 my @new;
 484                 foreach my $command (@list) {
 485                         if ($command eq $existing) {
 486                                 push @new, $new if $offset < 0;
 487                                 push @new, $command;
 488                                 push @new, $new if $offset > 0;
 489                         }
 490                         else {
 491                                 push @new, $command;
 492                         }
 493                 }
 494                 $sequences{$sequence}=\@new;
 495         }
 496 }
 497 sub insert_before {
 498         _insert(-1, @_);
 499 }
 500 sub insert_after {
 501         _insert(1, @_);
 502 }
 503 sub remove_command {
 504         my $command=shift;
 505         foreach my $sequence (keys %sequences) {
 506                 $sequences{$sequence}=[grep { $_ ne $command } @{$sequences{$sequence}}];
 507         }
 508
 509 }
 510 sub add_command {
 511         my $command=shift;
 512         my $sequence=shift;
 513         unshift @{$sequences{$sequence}}, $command;
 514 }
 515 sub add_command_options {
 516         my $command=shift;
 517         push @{$command_opts{$command}}, @_;
 518 }
 519 sub remove_command_options {
 520         my $command=shift;
 521         if (@_) {
 522                 # Remove only specified options
 523                 if (my $opts = $command_opts{$command}) {
 524                         foreach my $opt (@_) {
 525                                 $opts = [ grep { $_ ne $opt } @$opts ];
 526                         }
 527                         $command_opts{$command} = $opts;
 528                 }
 529         }
 530         else {
 531                 # Clear all additional options
 532                 delete $command_opts{$command};
 533         }
 534 }
 535
 536 sub list_addons {
 537         my %addons;
 538
 539         for my $inc (@INC) {
 540                 eval q{use File::Spec};
 541                 my $path = File::Spec->catdir($inc, "Debian/Debhelper/Sequence");
 542                 if (-d $path) {
 543                         for my $module_path (glob "$path/*.pm") {
 544                                 my $name = basename($module_path);
 545                                 $name =~ s/\.pm$//;
 546                                 $name =~ s/_/-/g;
 547                                 $addons{$name} = 1;
 548                         }
 549                 }
 550         }
 551
 552         for my $name (sort keys %addons) {
 553                 print "$name\n";
 554         }
 555
 556         exit 0;
 557 }
 558
 559 # Load addons, which can modify sequences.
 560 foreach my $addon (@{$dh{WITH}}) {
 561         my $mod="Debian::Debhelper::Sequence::$addon";
 562         $mod=~s/-/_/g;
 563         eval "use $mod";
 564         if ($@) {
 565                 error("unable to load addon $addon: $@");
 566         }
 567 }
 568
 569 if (! exists $sequences{$sequence}) {
 570         error "Unknown sequence $sequence (choose from: ".
 571                 join(" ", sort keys %sequences).")";
 572 }
 573 my @sequence=optimize_sequence(@{$sequences{$sequence}});
 574
 575 # The list of all packages that can be acted on.
 576 my @packages=@{$dh{DOPACKAGES}};
 577
 578 # Get the options to pass to commands in the sequence.
 579 # Filter out options intended only for this program.
 580 my @options;
 581 if ($sequence eq 'build-arch' ||
 582     $sequence eq 'install-arch' ||
 583     $sequence eq 'binary-arch') {
 584         push @options, "-a";
 585         # as an optimisation, remove from the list any packages
 586         # that are not arch dependent
 587         my %arch_packages = map { $_ => 1 } getpackages("arch");
 588         @packages = grep { $arch_packages{$_} } @packages;
 589 }
 590 elsif ($sequence eq 'build-indep' ||
 591        $sequence eq 'install-indep' ||
 592        $sequence eq 'binary-indep') {
 593         push @options, "-i";
 594         # ditto optimisation for arch indep
 595         my %indep_packages = map { $_ => 1 } getpackages("indep");
 596         @packages = grep { $indep_packages{$_} } @packages;
 597 }
 598 while (@ARGV_orig) {
 599         my $opt=shift @ARGV_orig;
 600         if ($opt =~ /^--?(after|until|before|with|without)$/) {
 601                 shift @ARGV_orig;
 602                 next;
 603         }
 604         elsif ($opt =~ /^--?(no-act|remaining|(after|until|before|with|without)=)/) {
 605                 next;
 606         }
 607         elsif ($opt=~/^-/) {
 608                 push @options, "-O".$opt;
 609         }
 610         elsif (@options) {
 611                 if ($options[$#options]=~/^-O--/) {
 612                         $options[$#options].="=".$opt;
 613                 }
 614                 else {
 615                         $options[$#options].=$opt;
 616                 }
 617         }
 618 }
 619
 620 # Figure out at what point in the sequence to start for each package.
 621 my %logged;
 622 my %startpoint;
 623 foreach my $package (@packages) {
 624         my @log=load_log($package, \%logged);
 625         if ($dh{AFTER}) {
 626                 # Run commands in the sequence that come after the
 627                 # specified command.
 628                 $startpoint{$package}=command_pos($dh{AFTER}, @sequence) + 1;
 629                 # Write a dummy log entry indicating that the specified
 630                 # command was, in fact, run. This handles the case where
 631                 # no commands remain to run after it, communicating to
 632                 # future dh instances that the specified command should not
 633                 # be run again.
 634                 write_log($sequence[$startpoint{$package}-1], $package);
 635         }
 636         elsif ($dh{REMAINING}) {
 637                 # Start at the beginning so all remaining commands will get
 638                 # run.
 639                 $startpoint{$package}=0;
 640         }
 641         else {
 642                 # Find the last logged command that is in the sequence, and
 643                 # continue with the next command after it. If no logged
 644                 # command is in the sequence, we're starting at the beginning..
 645                 $startpoint{$package}=0;
 646 COMMAND:        foreach my $command (reverse @log) {
 647                         foreach my $i (0..$#sequence) {
 648                                 if ($command eq $sequence[$i]) {
 649                                         $startpoint{$package}=$i+1;
 650                                         last COMMAND;
 651                                 }
 652                         }
 653                 }
 654         }
 655 }
 656
 657 # Figure out what point in the sequence to go to.
 658 my $stoppoint=$#sequence;
 659 if ($dh{UNTIL}) {
 660         $stoppoint=command_pos($dh{UNTIL}, @sequence);
 661 }
 662 elsif ($dh{BEFORE}) {
 663         $stoppoint=command_pos($dh{BEFORE}, @sequence) - 1;
 664 }
 665
 666 # Now run the commands in the sequence.
 667 foreach my $i (0..$stoppoint) {
 668         # Figure out which packages need to run this command.
 669         my @exclude;
 670         foreach my $package (@packages) {
 671                 if ($startpoint{$package} > $i ||
 672                     $logged{$package}{$sequence[$i]}) {
 673                         push @exclude, $package;
 674                 }
 675         }
 676
 677         if (@exclude eq @packages) {
 678                 # Command already done for all packages.
 679                 next;
 680         }
 681
 682         run($sequence[$i], \@packages, \@exclude, @options);
 683 }
 684
 685 sub run {
 686         my $command=shift;
 687         my @packages=@{shift()};
 688         my @exclude=@{shift()};
 689         my @options=@_;
 690
 691         # If some packages are excluded, add flags
 692         # to prevent them from being acted on.
 693         push @options, map { "-N$_" } @exclude;
 694
 695         # Check for override targets in debian/rules and
 696         # run them instead of running the command directly.
 697         my $override_command;
 698         my $has_explicit_target = rules_explicit_target("override_".$command);
 699
 700         my $rules_target = rules_target($command);
 701         if (defined $rules_target) {
 702                 # Don't pass DH_ environment variables, since this is
 703                 # a fresh invocation of debian/rules and any sub-dh
 704                 # commands.
 705                 $override_command=$command;
 706                 delete $ENV{DH_INTERNAL_OPTIONS};
 707                 delete $ENV{DH_INTERNAL_OVERRIDE};
 708                 $command="debian/rules";
 709                 @options=$rules_target;
 710         }
 711         elsif (defined $has_explicit_target) {
 712                 $override_command=$command;
 713                 # Check if target isn't noop
 714                 if ($has_explicit_target) {
 715                         # This passes the options through to commands called
 716                         # inside the target.
 717                         $ENV{DH_INTERNAL_OPTIONS}=join("\x1e", @options);
 718                         $ENV{DH_INTERNAL_OVERRIDE}=$command;
 719                         $command="debian/rules";
 720                         @options="override_".$override_command;
 721                 }
 722                 else {
 723                         $command = undef;
 724                 }
 725         }
 726         else {
 727                 # Pass additional command options if any
 728                 unshift @options, @{$command_opts{$command}} if exists $command_opts{$command};
 729         }
 730
 731         if (defined $command) {
 732                 # 3 space indent lines the command being run up under the
 733                 # sequence name after "dh ".
 734                 print "   ".escape_shell($command, @options)."\n";
 735         }
 736         else {
 737                 print "   ", "# Skipping ", $override_command, " - empty override", "\n";
 738         }
 739
 740         if (! $dh{NO_ACT}) {
 741                 if (defined $command) {
 742                         my $ret=system($command, @options);
 743
 744                         if ($ret >> 8 != 0) {
 745                                 exit $ret >> 8;
 746                         }
 747                         elsif ($ret) {
 748                                 exit 1;
 749                         }
 750                 }
 751
 752                 if (defined $override_command) {
 753                         # Update log for overridden command now that it has
 754                         # finished successfully.
 755                         # (But avoid logging for dh_clean since it removes
 756                         # the log earlier.)
 757                         if ($override_command ne 'dh_clean') {
 758                                 my %packages=map { $_ => 1 } @packages;
 759                                 map { delete $packages{$_} } @exclude;
 760                                 write_log($override_command, keys %packages);
 761                                 commit_override_log(keys %packages);
 762                         }
 763
 764                         delete $ENV{DH_INTERNAL_OPTIONS};
 765                         delete $ENV{DH_INTERNAL_OVERRIDE};
 766                 }
 767         }
 768 }
 769
 770 sub optimize_sequence {
 771         my @sequence;
 772         my %seen;
 773         my $add=sub {
 774                 # commands can appear multiple times when sequences are
 775                 # inlined together; only the first should be needed
 776                 my $command=shift;
 777                 if (! $seen{$command}) {
 778                         $seen{$command}=1;
 779                         push @sequence, $command;
 780                 }
 781         };
 782         foreach my $command (@_) {
 783                 my $rules_target=rules_target($command);
 784                 if (defined $rules_target &&
 785                     ! defined rules_explicit_target($rules_target)) {
 786                         # inline the sequence for this implicit target
 787                         $add->($_) foreach optimize_sequence(@{$sequences{$rules_target}});
 788                 }
 789                 else {
 790                         $add->($command);
 791                 }
 792         }
 793         return @sequence;
 794 }
 795
 796 sub rules_target {
 797         my $command=shift;
 798         if ($command =~ /^debian\/rules\s+(.*)/) {
 799                 return $1
 800         }
 801         else {
 802                 return undef;
 803         }
 804 }
 805
 806 sub rules {
 807         return "debian/rules ".join(" ", @_);
 808 }
 809
 810 {
 811 my %targets;
 812 my $rules_parsed;
 813
 814 sub rules_explicit_target {
 815         # Checks if a specified target exists as an explicit target
 816         # in debian/rules.
 817         # undef is returned if target does not exist, 0 if target is noop
 818         # and 1 if target has dependencies or executes commands.
 819         my $target=shift;
 820
 821         if (! $rules_parsed) {
 822                 my $processing_targets = 0;
 823                 my $not_a_target = 0;
 824                 my $current_target;
 825                 open(MAKE, "LC_ALL=C make -Rrnpsf debian/rules $dummy_target 2>/dev/null |");
 826                 while (<MAKE>) {
 827                         if ($processing_targets) {
 828                                 if (/^# Not a target:/) {
 829                                         $not_a_target = 1;
 830                                 }
 831                                 else {
 832                                         if (!$not_a_target && /^([^#:]+)::?\s*(.*)$/) {
 833                                                 # Target is defined. NOTE: if it is a depenency of
 834                                                 # .PHONY it will be defined too but that's ok.
 835                                                 # $2 contains target dependencies if any.
 836                                                 $current_target = $1;
 837                                                 $targets{$current_target} = ($2) ? 1 : 0;
 838                                         }
 839                                         else {
 840                                                 if (defined $current_target) {
 841                                                         if (/^#/) {
 842                                                                 # Check if target has commands to execute
 843                                                                 if (/^#\s*commands to execute/) {
 844                                                                         $targets{$current_target} = 1;
 845                                                                 }
 846                                                         }
 847                                                         else {
 848                                                                 # Target parsed.
 849                                                                 $current_target = undef;
 850                                                         }
 851                                                 }
 852                                         }
 853                                         # "Not a target:" is always followed by
 854                                         # a target name, so resetting this one
 855                                         # here is safe.
 856                                         $not_a_target = 0;
 857                                 }
 858                         }
 859                         elsif (/^# Files$/) {
 860                                 $processing_targets = 1;
 861                         }
 862                 }
 863                 close MAKE;
 864                 $rules_parsed = 1;
 865         }
 866
 867         return $targets{$target};
 868 }
 869
 870 }
 871
 872 =head1 SEE ALSO
 873
 874 L<debhelper(7)>
 875
 876 This program is a part of debhelper.
 877
 878 =head1 AUTHOR
 879
 880 Joey Hess <joeyh@debian.org>
 881
 882 =cut