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