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