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