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