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.
 261
 262 =head1 INTERNALS
 263
 264 If you're curious about B<dh>'s internals, here's how it works under the hood.
 265
 266 Each debhelper command will record when it's successfully run in
 267 F<debian/package.debhelper.log>. (Which B<dh_clean> deletes.) So B<dh> can tell
 268 which commands have already been run, for which packages, and skip running
 269 those commands again.
 270
 271 Each time B<dh> is run, it examines the log, and finds the last logged command
 272 that is in the specified sequence. It then continues with the next command
 273 in the sequence. The B<--until>, B<--before>, B<--after>, and B<--remaining>
 274 options can override this behavior.
 275
 276 A sequence can also run dependent targets in debian/rules.  For
 277 example, the "binary" sequence runs the "install" target.
 278
 279 B<dh> uses the B<DH_INTERNAL_OPTIONS> environment variable to pass information
 280 through to debhelper commands that are run inside override targets. The
 281 contents (and indeed, existence) of this environment variable, as the name
 282 might suggest, is subject to change at any time.
 283
 284 =cut
 285
 286 # Stash this away before init modifies it.
 287 my @ARGV_orig=@ARGV;
 288
 289 # python-support is enabled by default, at least for now
 290 # (and comes first so python-central loads later and can disable it).
 291 unshift @ARGV, "--with=python-support";
 292
 293 init(options => {
 294                 "until=s" => \$dh{UNTIL},
 295                 "after=s" => \$dh{AFTER},
 296                 "before=s" => \$dh{BEFORE},
 297                 "remaining" => \$dh{REMAINING},
 298                 "with=s" => sub {
 299                         my ($option,$value)=@_;
 300                         push @{$dh{WITH}},split(",", $value);
 301                 },
 302                 "without=s" => sub {
 303                         my ($option,$value)=@_;
 304                         @{$dh{WITH}} = grep { $_ ne $value } @{$dh{WITH}};
 305                 },
 306                 "l" => \&list_addons,
 307                 "list" => \&list_addons,
 308         },
 309         # Disable complaints about unknown options; they are passed on to
 310         # the debhelper commands.
 311         ignore_unknown_options => 1,
 312         # Bundling does not work well since there are unknown options.
 313         bundling => 0,
 314 );
 315 inhibit_log();
 316
 317
 318 # If make is using a jobserver, but it is not available
 319 # to this process, clean out MAKEFLAGS. This avoids
 320 # ugly warnings when calling make.
 321 if (is_make_jobserver_unavailable()) {
 322         clean_jobserver_makeflags();
 323 }
 324
 325 # Process the sequence parameter.
 326 my $sequence;
 327 if (! compat(7)) {
 328         # From v8, the sequence is the very first parameter.
 329         $sequence=shift @ARGV_orig;
 330         if ($sequence=~/^-/) {
 331                 error "Unknown sequence $sequence (options should not come before the sequence)";
 332         }
 333 }
 334 else {
 335         # Before v8, the sequence could be at any position in the parameters,
 336         # so was what was left after parsing.
 337         $sequence=shift;
 338         if (defined $sequence) {
 339                 @ARGV_orig=grep { $_ ne $sequence } @ARGV_orig;
 340         }
 341 }
 342 if (! defined $sequence) {
 343         error "specify a sequence to run";
 344 }
 345 # make -B causes the rules file to be run as a target.
 346 # Also support completly empty override targets.
 347 # Note: it's not safe to use rules_explicit_target before this check.
 348 if ($sequence eq 'debian/rules' ||
 349     $sequence =~ /^override_dh_/) {
 350         exit 0;
 351 }
 352
 353
 354 # Definitions of sequences.
 355 my %sequences;
 356 my @bd_minimal = qw{
 357         dh_testdir
 358 };
 359 my @bd = qw{
 360         dh_testdir
 361         dh_auto_configure
 362         dh_auto_build
 363         dh_auto_test
 364 };
 365 $sequences{'build-indep'} = [@bd];
 366 $sequences{'build-arch'} = [@bd];
 367 if (rules_explicit_target('build-arch') ||
 368     rules_explicit_target('build-indep')) {
 369         # run sequences separately
 370         $sequences{build} = [@bd_minimal, 'rules:build-arch', 'rules:build-indep'];
 371 }
 372 else {
 373         # run standard sequence (this is faster)
 374         $sequences{build} = [@bd];
 375 }
 376 $sequences{clean} = [qw{
 377         dh_testdir
 378         dh_auto_clean
 379         dh_clean
 380 }];
 381 my @i_minimal = qw{
 382         dh_testroot
 383 };
 384 my @i = qw{
 385         dh_testroot
 386         dh_prep
 387         dh_installdirs
 388         dh_auto_install
 389
 390         dh_install
 391         dh_installdocs
 392         dh_installchangelogs
 393         dh_installexamples
 394         dh_installman
 395
 396         dh_installcatalogs
 397         dh_installcron
 398         dh_installdebconf
 399         dh_installemacsen
 400         dh_installifupdown
 401         dh_installinfo
 402         dh_installinit
 403         dh_installmenu
 404         dh_installmime
 405         dh_installmodules
 406         dh_installlogcheck
 407         dh_installlogrotate
 408         dh_installpam
 409         dh_installppp
 410         dh_installudev
 411         dh_installwm
 412         dh_installxfonts
 413         dh_installgsettings
 414         dh_bugfiles
 415         dh_ucf
 416         dh_lintian
 417         dh_gconf
 418         dh_icons
 419         dh_perl
 420         dh_usrlocal
 421
 422         dh_link
 423         dh_compress
 424         dh_fixperms
 425 };
 426 $sequences{'install-indep'} = ['rules:build-indep', @i];
 427 $sequences{'install-arch'} = ['rules:build-arch', @i];
 428 if (rules_explicit_target('install-arch') ||
 429     rules_explicit_target('install-indep')) {
 430         # run sequences separately
 431         $sequences{'install'} = ['rules:build', @i_minimal, 'rules:install-arch', 'rules:install-indep'];
 432 }
 433 else {
 434         # run standard sequence (this is faster)
 435         $sequences{'install'} = ['rules:build', @i, 'rules:install-arch', 'rules:install-indep'];
 436 }
 437 my @ba=qw{
 438         dh_strip
 439         dh_makeshlibs
 440         dh_shlibdeps
 441 };
 442 my @b=qw{
 443         dh_installdeb
 444         dh_gencontrol
 445         dh_md5sums
 446         dh_builddeb
 447 };
 448 $sequences{'binary-indep'} = ['rules:install-indep', @b];
 449 $sequences{'binary-arch'} = ['rules:install-arch', @ba, @b];
 450 $sequences{binary} = ['rules:install', 'rules:binary-arch', 'rules:binary-indep'];
 451
 452 # Additional command options
 453 my %command_opts;
 454
 455 # sequence addon interface
 456 sub _insert {
 457         my $offset=shift;
 458         my $existing=shift;
 459         my $new=shift;
 460         foreach my $sequence (keys %sequences) {
 461                 my @list=@{$sequences{$sequence}};
 462                 next unless grep $existing, @list;
 463                 my @new;
 464                 foreach my $command (@list) {
 465                         if ($command eq $existing) {
 466                                 push @new, $new if $offset < 0;
 467                                 push @new, $command;
 468                                 push @new, $new if $offset > 0;
 469                         }
 470                         else {
 471                                 push @new, $command;
 472                         }
 473                 }
 474                 $sequences{$sequence}=\@new;
 475         }
 476 }
 477 sub insert_before {
 478         _insert(-1, @_);
 479 }
 480 sub insert_after {
 481         _insert(1, @_);
 482 }
 483 sub remove_command {
 484         my $command=shift;
 485         foreach my $sequence (keys %sequences) {
 486                 $sequences{$sequence}=[grep { $_ ne $command } @{$sequences{$sequence}}];
 487         }
 488
 489 }
 490 sub add_command {
 491         my $command=shift;
 492         my $sequence=shift;
 493         unshift @{$sequences{$sequence}}, $command;
 494 }
 495 sub add_command_options {
 496         my $command=shift;
 497         push @{$command_opts{$command}}, @_;
 498 }
 499 sub remove_command_options {
 500         my $command=shift;
 501         if (@_) {
 502                 # Remove only specified options
 503                 if (my $opts = $command_opts{$command}) {
 504                         foreach my $opt (@_) {
 505                                 $opts = [ grep { $_ ne $opt } @$opts ];
 506                         }
 507                         $command_opts{$command} = $opts;
 508                 }
 509         }
 510         else {
 511                 # Clear all additional options
 512                 delete $command_opts{$command};
 513         }
 514 }
 515
 516 sub list_addons {
 517         my %addons;
 518
 519         for my $inc (@INC) {
 520                 eval q{use File::Spec};
 521                 my $path = File::Spec->catdir($inc, "Debian/Debhelper/Sequence");
 522                 if (-d $path) {
 523                         for my $module_path (glob "$path/*.pm") {
 524                                 my $name = basename($module_path);
 525                                 $name =~ s/\.pm$//;
 526                                 $name =~ s/_/-/g;
 527                                 $addons{$name} = 1;
 528                         }
 529                 }
 530         }
 531
 532         for my $name (sort keys %addons) {
 533                 print "$name\n";
 534         }
 535
 536         exit 0;
 537 }
 538
 539 # Load addons, which can modify sequences.
 540 foreach my $addon (@{$dh{WITH}}) {
 541         my $mod="Debian::Debhelper::Sequence::$addon";
 542         $mod=~s/-/_/g;
 543         eval "use $mod";
 544         if ($@) {
 545                 error("unable to load addon $addon: $@");
 546         }
 547 }
 548
 549 if (! exists $sequences{$sequence}) {
 550         error "Unknown sequence $sequence (choose from: ".
 551                 join(" ", sort keys %sequences).")";
 552 }
 553 my @sequence=optimize_sequence(@{$sequences{$sequence}});
 554
 555 # The list of all packages that can be acted on.
 556 my @packages=@{$dh{DOPACKAGES}};
 557
 558 # Get the options to pass to commands in the sequence.
 559 # Filter out options intended only for this program.
 560 my @options;
 561 if ($sequence eq 'build-arch' ||
 562     $sequence eq 'install-arch' ||
 563     $sequence eq 'binary-arch') {
 564         push @options, "-a";
 565         # as an optimisation, remove from the list any packages
 566         # that are not arch dependent
 567         my %arch_packages = map { $_ => 1 } getpackages("arch");
 568         @packages = grep { $arch_packages{$_} } @packages;
 569 }
 570 elsif ($sequence eq 'build-indep' ||
 571        $sequence eq 'install-indep' ||
 572        $sequence eq 'binary-indep') {
 573         push @options, "-i";
 574         # ditto optimisation for arch indep
 575         my %indep_packages = map { $_ => 1 } getpackages("indep");
 576         @packages = grep { $indep_packages{$_} } @packages;
 577 }
 578 while (@ARGV_orig) {
 579         my $opt=shift @ARGV_orig;
 580         if ($opt =~ /^--?(after|until|before|with|without)$/) {
 581                 shift @ARGV_orig;
 582                 next;
 583         }
 584         elsif ($opt =~ /^--?(no-act|remaining|(after|until|before|with|without)=)/) {
 585                 next;
 586         }
 587         elsif ($opt=~/^-/) {
 588                 push @options, "-O".$opt;
 589         }
 590         elsif (@options) {
 591                 if ($options[$#options]=~/^-O--/) {
 592                         $options[$#options].="=".$opt;
 593                 }
 594                 else {
 595                         $options[$#options].=$opt;
 596                 }
 597         }
 598 }
 599
 600 # Figure out at what point in the sequence to start for each package.
 601 my %logged;
 602 my %startpoint;
 603 foreach my $package (@packages) {
 604         my @log=load_log($package, \%logged);
 605         if ($dh{AFTER}) {
 606                 # Run commands in the sequence that come after the
 607                 # specified command.
 608                 $startpoint{$package}=command_pos($dh{AFTER}, @sequence) + 1;
 609                 # Write a dummy log entry indicating that the specified
 610                 # command was, in fact, run. This handles the case where
 611                 # no commands remain to run after it, communicating to
 612                 # future dh instances that the specified command should not
 613                 # be run again.
 614                 write_log($sequence[$startpoint{$package}-1], $package);
 615         }
 616         elsif ($dh{REMAINING}) {
 617                 # Start at the beginning so all remaining commands will get
 618                 # run.
 619                 $startpoint{$package}=0;
 620         }
 621         else {
 622                 # Find the last logged command that is in the sequence, and
 623                 # continue with the next command after it. If no logged
 624                 # command is in the sequence, we're starting at the beginning..
 625                 $startpoint{$package}=0;
 626 COMMAND:        foreach my $command (reverse @log) {
 627                         foreach my $i (0..$#sequence) {
 628                                 if ($command eq $sequence[$i]) {
 629                                         $startpoint{$package}=$i+1;
 630                                         last COMMAND;
 631                                 }
 632                         }
 633                 }
 634         }
 635 }
 636
 637 # Figure out what point in the sequence to go to.
 638 my $stoppoint=$#sequence;
 639 if ($dh{UNTIL}) {
 640         $stoppoint=command_pos($dh{UNTIL}, @sequence);
 641 }
 642 elsif ($dh{BEFORE}) {
 643         $stoppoint=command_pos($dh{BEFORE}, @sequence) - 1;
 644 }
 645
 646 # Now run the commands in the sequence.
 647 foreach my $i (0..$stoppoint) {
 648         # Figure out which packages need to run this command.
 649         my @exclude;
 650         foreach my $package (@packages) {
 651                 if ($startpoint{$package} > $i ||
 652                     $logged{$package}{$sequence[$i]}) {
 653                         push @exclude, $package;
 654                 }
 655         }
 656
 657         if (@exclude eq @packages) {
 658                 # Command already done for all packages.
 659                 next;
 660         }
 661
 662         run($sequence[$i], \@packages, \@exclude, @options);
 663 }
 664
 665 sub run {
 666         my $command=shift;
 667         my @packages=@{shift()};
 668         my @exclude=@{shift()};
 669         my @options=@_;
 670
 671         # If some packages are excluded, add flags
 672         # to prevent them from being acted on.
 673         push @options, map { "-N$_" } @exclude;
 674
 675         # Check for override targets in debian/rules and
 676         # run them instead of running the command directly.
 677         my $override_command;
 678         my $has_explicit_target = rules_explicit_target("override_".$command);
 679
 680         # If the command has a rules: prefix, run debian/rules with
 681         # the remainder as the target.
 682         my $rules_target = rules_target($command);
 683         if (defined $rules_target) {
 684                 # Don't pass DH_ environment variables, since this is
 685                 # a fresh invocation of debian/rules and any sub-dh
 686                 # commands.
 687                 $override_command=$command;
 688                 delete $ENV{DH_INTERNAL_OPTIONS};
 689                 delete $ENV{DH_INTERNAL_OVERRIDE};
 690                 $command="debian/rules";
 691                 @options=$rules_target;
 692         }
 693         elsif (defined $has_explicit_target) {
 694                 $override_command=$command;
 695                 # Check if target isn't noop
 696                 if ($has_explicit_target) {
 697                         # This passes the options through to commands called
 698                         # inside the target.
 699                         $ENV{DH_INTERNAL_OPTIONS}=join("\x1e", @options);
 700                         $ENV{DH_INTERNAL_OVERRIDE}=$command;
 701                         $command="debian/rules";
 702                         @options="override_".$override_command;
 703                 }
 704                 else {
 705                         $command = undef;
 706                 }
 707         }
 708         else {
 709                 # Pass additional command options if any
 710                 unshift @options, @{$command_opts{$command}} if exists $command_opts{$command};
 711         }
 712
 713         if (defined $command) {
 714                 # 3 space indent lines the command being run up under the
 715                 # sequence name after "dh ".
 716                 print "   ".escape_shell($command, @options)."\n";
 717         }
 718         else {
 719                 print "   ", "# Skipping ", $override_command, " - empty override", "\n";
 720         }
 721
 722         if (! $dh{NO_ACT}) {
 723                 if (defined $command) {
 724                         my $ret=system($command, @options);
 725
 726                         if ($ret >> 8 != 0) {
 727                                 exit $ret >> 8;
 728                         }
 729                         elsif ($ret) {
 730                                 exit 1;
 731                         }
 732                 }
 733
 734                 if (defined $override_command) {
 735                         # Update log for overridden command now that it has
 736                         # finished successfully.
 737                         # (But avoid logging for dh_clean since it removes
 738                         # the log earlier.)
 739                         if ($override_command ne 'dh_clean') {
 740                                 my %packages=map { $_ => 1 } @packages;
 741                                 map { delete $packages{$_} } @exclude;
 742                                 write_log($override_command, keys %packages);
 743                                 commit_override_log(keys %packages);
 744                         }
 745
 746                         delete $ENV{DH_INTERNAL_OPTIONS};
 747                         delete $ENV{DH_INTERNAL_OVERRIDE};
 748                 }
 749         }
 750 }
 751
 752 sub optimize_sequence {
 753         my @sequence;
 754         my %seen;
 755         my $add=sub {
 756                 # commands can appear multiple times when sequences are
 757                 # inlined together; only the first should be needed
 758                 my $command=shift;
 759                 if (! $seen{$command}) {
 760                         $seen{$command}=1;
 761                         push @sequence, $command;
 762                 }
 763         };
 764         foreach my $command (@_) {
 765                 my $rules_target=rules_target($command);
 766                 if (defined $rules_target &&
 767                     ! rules_explicit_target($rules_target)) {
 768                         # inline the sequence for this implicit target
 769                         $add->($_) foreach optimize_sequence(@{$sequences{$rules_target}});
 770                 }
 771                 else {
 772                         $add->($command);
 773                 }
 774         }
 775         return @sequence;
 776 }
 777
 778 sub rules_target {
 779         my $command=shift;
 780         if ($command =~ /^rules:(.*)/) {
 781                 return $1
 782         }
 783         else {
 784                 return undef;
 785         }
 786 }
 787
 788 {
 789 my %targets;
 790 my $rules_parsed;
 791
 792 sub rules_explicit_target {
 793         # Checks if a specified target exists as an explicit target
 794         # in debian/rules.
 795         # undef is returned if target does not exist, 0 if target is noop
 796         # and 1 if target has dependencies or executes commands.
 797         my $target=shift;
 798
 799         if (! $rules_parsed) {
 800                 my $processing_targets = 0;
 801                 my $not_a_target = 0;
 802                 my $current_target;
 803                 open(MAKE, "LC_ALL=C make -Rrnpsf debian/rules debhelper-fail-me 2>/dev/null |");
 804                 while (<MAKE>) {
 805                         if ($processing_targets) {
 806                                 if (/^# Not a target:/) {
 807                                         $not_a_target = 1;
 808                                 }
 809                                 else {
 810                                         if (!$not_a_target && /^([^#:]+)::?\s*(.*)$/) {
 811                                                 # Target is defined. NOTE: if it is a depenency of
 812                                                 # .PHONY it will be defined too but that's ok.
 813                                                 # $2 contains target dependencies if any.
 814                                                 $current_target = $1;
 815                                                 $targets{$current_target} = ($2) ? 1 : 0;
 816                                         }
 817                                         else {
 818                                                 if (defined $current_target) {
 819                                                         if (/^#/) {
 820                                                                 # Check if target has commands to execute
 821                                                                 if (/^#\s*commands to execute/) {
 822                                                                         $targets{$current_target} = 1;
 823                                                                 }
 824                                                         }
 825                                                         else {
 826                                                                 # Target parsed.
 827                                                                 $current_target = undef;
 828                                                         }
 829                                                 }
 830                                         }
 831                                         # "Not a target:" is always followed by
 832                                         # a target name, so resetting this one
 833                                         # here is safe.
 834                                         $not_a_target = 0;
 835                                 }
 836                         }
 837                         elsif (/^# Files$/) {
 838                                 $processing_targets = 1;
 839                         }
 840                 }
 841                 close MAKE;
 842                 $rules_parsed = 1;
 843         }
 844
 845         return $targets{$target};
 846 }
 847
 848 }
 849
 850 =head1 SEE ALSO
 851
 852 L<debhelper(7)>
 853
 854 This program is a part of debhelper.
 855
 856 =head1 AUTHOR
 857
 858 Joey Hess <joeyh@debian.org>
 859
 860 =cut