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