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>] [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<--no-act>
  57
  58 Prints commands that would run for a given sequence, but does not run them.
  59
  60 =back
  61
  62 Other options passed to B<dh> are passed on to each command it runs. This
  63 can be used to set an option like B<-v> or B<-X> or B<-N>, as well as for more
  64 specialised options.
  65
  66 =head1 EXAMPLES
  67
  68 To see what commands are included in a sequence, without actually doing
  69 anything:
  70
  71         dh binary-arch --no-act
  72
  73 This is a very simple rules file, for packages where the default sequences of
  74 commands work with no additional options.
  75
  76         #!/usr/bin/make -f
  77         %:
  78                 dh $@
  79
  80 Often you'll want to pass an option to a specific debhelper command. The
  81 easy way to do with is by adding an override target for that command.
  82
  83         #!/usr/bin/make -f
  84         %:
  85                 dh $@
  86
  87         override_dh_strip:
  88                 dh_strip -Xfoo
  89
  90         override_dh_installdocs:
  91                 dh_installdocs README TODO
  92
  93 Sometimes the automated L<dh_auto_configure(1)> and L<dh_auto_build(1)>
  94 can't guess what to do for a strange package. Here's how to avoid running
  95 either and instead run your own commands.
  96
  97         #!/usr/bin/make -f
  98         %:
  99                 dh $@
 100
 101         override_dh_auto_configure:
 102                 ./mondoconfig
 103
 104         override_dh_auto_build:
 105                 make universe-explode-in-delight
 106
 107 Another common case is wanting to do something manually before or
 108 after a particular debhelper command is run.
 109
 110         #!/usr/bin/make -f
 111         %:
 112                 dh $@
 113
 114         override_dh_fixperms:
 115                 dh_fixperms
 116                 chmod 4755 debian/foo/usr/bin/foo
 117
 118 Python tools are not run by dh by default, due to the continual change
 119 in that area. (Before compatability level v9, dh does run B<dh_pysupport>.)
 120 Here is how to use B<dh_python2>.
 121
 122         #!/usr/bin/make -f
 123         %:
 124                 dh $@ --with python2
 125
 126 If your package uses autotools and you want to freshen F<config.sub> and
 127 F<config.guess> with newer versions from the B<autotools-dev> package
 128 at build time, you can use some commands provided in B<autotools-dev>
 129 that automate it, like this.
 130
 131         #!/usr/bin/make -f
 132         %:
 133                 dh $@ --with autotools_dev
 134
 135 Here is how to force use of Perl's B<Module::Build> build system,
 136 which can be necessary if debhelper wrongly detects that the package
 137 uses MakeMaker.
 138
 139         #!/usr/bin/make -f
 140         %:
 141                 dh $@ --buildsystem=perl_build
 142
 143 Here is an example of overriding where the B<dh_auto_>I<*> commands find
 144 the package's source, for a package where the source is located in a
 145 subdirectory.
 146
 147         #!/usr/bin/make -f
 148         %:
 149                 dh $@ --sourcedirectory=src
 150
 151 And here is an example of how to tell the B<dh_auto_>I<*> commands to build
 152 in a subdirectory, which will be removed on B<clean>.
 153
 154         #!/usr/bin/make -f
 155         %:
 156                 dh $@ --builddirectory=build
 157
 158 If your package can be built in parallel, you can support parallel building
 159 as follows. Then B<dpkg-buildpackage -j> will work.
 160
 161         #!/usr/bin/make -f
 162         %:
 163                 dh $@ --parallel
 164
 165 Here is a way to prevent B<dh> from running several commands that you don't
 166 want it to run, by defining empty override targets for each command.
 167
 168         #!/usr/bin/make -f
 169         %:
 170                 dh $@
 171
 172         # Commands not to run:
 173         override_dh_auto_test override_dh_compress override_dh_fixperms:
 174
 175 Sometimes, you may need to make an override target only run commands when a
 176 particular package is being built. This can be accomplished using
 177 L<dh_listpackages(1)> to test what is being built. For example:
 178
 179         #!/usr/bin/make -f
 180         %:
 181                 dh $@
 182
 183         override_dh_fixperms:
 184                 dh_fixperms
 185         ifneq (,$(filter foo, $(shell dh_listpackages)))
 186                 chmod 4755 debian/foo/usr/bin/foo
 187         endif
 188
 189 Finally, remember that you are not limited to using override targets in the
 190 rules file when using B<dh>. You can also explicitly define any of the regular
 191 rules file targets when it makes sense to do so. A common reason to do this
 192 is when your package needs different B<build-arch> and B<build-indep> targets.
 193 For example, a package with a long document build process can put it in
 194 B<build-indep>.
 195
 196         #!/usr/bin/make -f
 197         %:
 198                 dh $@
 199
 200         build-indep:
 201                 $(MAKE) docs
 202         build-arch:
 203                 $(MAKE) bins
 204
 205 Note that in the example above, dh will arrange for "debian/rules build"
 206 to call your build-indep and build-arch targets. You do not need to
 207 explicitly define those dependencies in the rules file when using dh with
 208 compatibility level v9. This example would be more complicated with
 209 earlier compatibility levels.
 210
 211 =head1 INTERNALS
 212
 213 If you're curious about B<dh>'s internals, here's how it works under the hood.
 214
 215 Each debhelper command will record when it's successfully run in
 216 F<debian/package.debhelper.log>. (Which B<dh_clean> deletes.) So B<dh> can tell
 217 which commands have already been run, for which packages, and skip running
 218 those commands again.
 219
 220 Each time B<dh> is run, it examines the log, and finds the last logged command
 221 that is in the specified sequence. It then continues with the next command
 222 in the sequence. The B<--until>, B<--before>, B<--after>, and B<--remaining>
 223 options can override this behavior.
 224
 225 A sequence can also run dependent targets in debian/rules.  For
 226 example, the "binary" sequence runs the "install" target.
 227
 228 B<dh> uses the B<DH_INTERNAL_OPTIONS> environment variable to pass information
 229 through to debhelper commands that are run inside override targets. The
 230 contents (and indeed, existence) of this environment variable, as the name
 231 might suggest, is subject to change at any time.
 232
 233 =head1 DEPRECATED OPTIONS
 234
 235 The following options are deprecated. It's much
 236 better to use override targets instead.
 237
 238 =over 4
 239
 240 =item B<--until> I<cmd>
 241
 242 Run commands in the sequence until and including I<cmd>, then stop.
 243
 244 =item B<--before> I<cmd>
 245
 246 Run commands in the sequence before I<cmd>, then stop.
 247
 248 =item B<--after> I<cmd>
 249
 250 Run commands in the sequence that come after I<cmd>.
 251
 252 =item B<--remaining>
 253
 254 Run all commands in the sequence that have yet to be run.
 255
 256 =back
 257
 258 In the above options, I<cmd> can be a full name of a debhelper command, or
 259 a substring. It'll first search for a command in the sequence exactly
 260 matching the name, to avoid any ambiguity. If there are multiple substring
 261 matches, the last one in the sequence will be used.
 262
 263 =cut
 264
 265 # Stash this away before init modifies it.
 266 my @ARGV_orig=@ARGV;
 267
 268 if (compat(8)) {
 269         # python-support was enabled by default before v9.
 270         # (and comes first so python-central loads later and can disable it).
 271         unshift @ARGV, "--with=python-support";
 272 }
 273
 274 init(options => {
 275                 "until=s" => \$dh{UNTIL},
 276                 "after=s" => \$dh{AFTER},
 277                 "before=s" => \$dh{BEFORE},
 278                 "remaining" => \$dh{REMAINING},
 279                 "with=s" => sub {
 280                         my ($option,$value)=@_;
 281                         push @{$dh{WITH}},split(",", $value);
 282                 },
 283                 "without=s" => sub {
 284                         my ($option,$value)=@_;
 285                         @{$dh{WITH}} = grep { $_ ne $value } @{$dh{WITH}};
 286                 },
 287                 "l" => \&list_addons,
 288                 "list" => \&list_addons,
 289         },
 290         # Disable complaints about unknown options; they are passed on to
 291         # the debhelper commands.
 292         ignore_unknown_options => 1,
 293         # Bundling does not work well since there are unknown options.
 294         bundling => 0,
 295 );
 296 inhibit_log();
 297 set_buildflags();
 298 warn_deprecated();
 299
 300 # If make is using a jobserver, but it is not available
 301 # to this process, clean out MAKEFLAGS. This avoids
 302 # ugly warnings when calling make.
 303 if (is_make_jobserver_unavailable()) {
 304         clean_jobserver_makeflags();
 305 }
 306
 307 # Process the sequence parameter.
 308 my $sequence;
 309 if (! compat(7)) {
 310         # From v8, the sequence is the very first parameter.
 311         $sequence=shift @ARGV_orig;
 312         if (defined $sequence && $sequence=~/^-/) {
 313                 error "Unknown sequence $sequence (options should not come before the sequence)";
 314         }
 315 }
 316 else {
 317         # Before v8, the sequence could be at any position in the parameters,
 318         # so was what was left after parsing.
 319         $sequence=shift;
 320         if (defined $sequence) {
 321                 @ARGV_orig=grep { $_ ne $sequence } @ARGV_orig;
 322         }
 323 }
 324 if (! defined $sequence) {
 325         error "specify a sequence to run";
 326 }
 327 # make -B causes the rules file to be run as a target.
 328 # Also support completly empty override targets.
 329 # Note: it's not safe to use rules_explicit_target before this check,
 330 # since it causes dh to be run.
 331 my $dummy_target="debhelper-fail-me";
 332 if ($sequence eq 'debian/rules' ||
 333     $sequence =~ /^override_dh_/ ||
 334     $sequence eq $dummy_target) {
 335         exit 0;
 336 }
 337
 338
 339 # Definitions of sequences.
 340 my %sequences;
 341 my @bd_minimal = qw{
 342         dh_testdir
 343 };
 344 my @bd = qw{
 345         dh_testdir
 346         dh_auto_configure
 347         dh_auto_build
 348         dh_auto_test
 349 };
 350 my @i = qw{
 351         dh_testroot
 352         dh_prep
 353         dh_installdirs
 354         dh_auto_install
 355
 356         dh_install
 357         dh_installdocs
 358         dh_installchangelogs
 359         dh_installexamples
 360         dh_installman
 361
 362         dh_installcatalogs
 363         dh_installcron
 364         dh_installdebconf
 365         dh_installemacsen
 366         dh_installifupdown
 367         dh_installinfo
 368         dh_installinit
 369         dh_installmenu
 370         dh_installmime
 371         dh_installmodules
 372         dh_installlogcheck
 373         dh_installlogrotate
 374         dh_installpam
 375         dh_installppp
 376         dh_installudev
 377         dh_installwm
 378         dh_installxfonts
 379         dh_installgsettings
 380         dh_bugfiles
 381         dh_ucf
 382         dh_lintian
 383         dh_gconf
 384         dh_icons
 385         dh_perl
 386         dh_usrlocal
 387
 388         dh_link
 389         dh_compress
 390         dh_fixperms
 391 };
 392 my @ba=qw{
 393         dh_strip
 394         dh_makeshlibs
 395         dh_shlibdeps
 396 };
 397 if (! getpackages("arch")) {
 398         @ba=();
 399 }
 400 my @b=qw{
 401         dh_installdeb
 402         dh_gencontrol
 403         dh_md5sums
 404         dh_builddeb
 405 };
 406 $sequences{clean} = [qw{
 407         dh_testdir
 408         dh_auto_clean
 409         dh_clean
 410 }];
 411 $sequences{'build-indep'} = [@bd];
 412 $sequences{'build-arch'} = [@bd];
 413 if (! compat(8)) {
 414         # From v9, sequences take standard rules targets into account.
 415         $sequences{build} = [@bd_minimal, rules("build-arch"), rules("build-indep")];
 416         $sequences{'install-indep'} = [rules("build-indep"), @i];
 417         $sequences{'install-arch'} = [rules("build-arch"), @i];
 418         $sequences{'install'} = [rules("build"), rules("install-arch"), rules("install-indep"), @i];
 419         $sequences{'binary-indep'} = [rules("install-indep"), @b];
 420         $sequences{'binary-arch'} = [rules("install-arch"), @ba, @b];
 421         $sequences{binary} = [rules("install"), rules("binary-arch"), rules("binary-indep")];
 422 }
 423 else {
 424         $sequences{build} = [@bd];
 425         $sequences{'install'} = [@{$sequences{build}}, @i];
 426         $sequences{'install-indep'} = [@{$sequences{'build-indep'}}, @i];
 427         $sequences{'install-arch'} = [@{$sequences{'build-arch'}}, @i];
 428         $sequences{binary} = [@{$sequences{install}}, @ba, @b];
 429         $sequences{'binary-indep'} = [@{$sequences{'install-indep'}}, @b];
 430         $sequences{'binary-arch'} = [@{$sequences{'install-arch'}}, @ba, @b];
 431 }
 432
 433 # Additional command options
 434 my %command_opts;
 435
 436 # sequence addon interface
 437 sub _insert {
 438         my $offset=shift;
 439         my $existing=shift;
 440         my $new=shift;
 441         foreach my $sequence (keys %sequences) {
 442                 my @list=@{$sequences{$sequence}};
 443                 next unless grep $existing, @list;
 444                 my @new;
 445                 foreach my $command (@list) {
 446                         if ($command eq $existing) {
 447                                 push @new, $new if $offset < 0;
 448                                 push @new, $command;
 449                                 push @new, $new if $offset > 0;
 450                         }
 451                         else {
 452                                 push @new, $command;
 453                         }
 454                 }
 455                 $sequences{$sequence}=\@new;
 456         }
 457 }
 458 sub insert_before {
 459         _insert(-1, @_);
 460 }
 461 sub insert_after {
 462         _insert(1, @_);
 463 }
 464 sub remove_command {
 465         my $command=shift;
 466         foreach my $sequence (keys %sequences) {
 467                 $sequences{$sequence}=[grep { $_ ne $command } @{$sequences{$sequence}}];
 468         }
 469
 470 }
 471 sub add_command {
 472         my $command=shift;
 473         my $sequence=shift;
 474         unshift @{$sequences{$sequence}}, $command;
 475 }
 476 sub add_command_options {
 477         my $command=shift;
 478         push @{$command_opts{$command}}, @_;
 479 }
 480 sub remove_command_options {
 481         my $command=shift;
 482         if (@_) {
 483                 # Remove only specified options
 484                 if (my $opts = $command_opts{$command}) {
 485                         foreach my $opt (@_) {
 486                                 $opts = [ grep { $_ ne $opt } @$opts ];
 487                         }
 488                         $command_opts{$command} = $opts;
 489                 }
 490         }
 491         else {
 492                 # Clear all additional options
 493                 delete $command_opts{$command};
 494         }
 495 }
 496
 497 sub list_addons {
 498         my %addons;
 499
 500         for my $inc (@INC) {
 501                 eval q{use File::Spec};
 502                 my $path = File::Spec->catdir($inc, "Debian/Debhelper/Sequence");
 503                 if (-d $path) {
 504                         for my $module_path (glob "$path/*.pm") {
 505                                 my $name = basename($module_path);
 506                                 $name =~ s/\.pm$//;
 507                                 $name =~ s/_/-/g;
 508                                 $addons{$name} = 1;
 509                         }
 510                 }
 511         }
 512
 513         for my $name (sort keys %addons) {
 514                 print "$name\n";
 515         }
 516
 517         exit 0;
 518 }
 519
 520 # Load addons, which can modify sequences.
 521 foreach my $addon (@{$dh{WITH}}) {
 522         my $mod="Debian::Debhelper::Sequence::$addon";
 523         $mod=~s/-/_/g;
 524         eval "use $mod";
 525         if ($@) {
 526                 error("unable to load addon $addon: $@");
 527         }
 528 }
 529
 530 if (! exists $sequences{$sequence}) {
 531         error "Unknown sequence $sequence (choose from: ".
 532                 join(" ", sort keys %sequences).")";
 533 }
 534 my @sequence=optimize_sequence(@{$sequences{$sequence}});
 535
 536 # The list of all packages that can be acted on.
 537 my @packages=@{$dh{DOPACKAGES}};
 538
 539 # Get the options to pass to commands in the sequence.
 540 # Filter out options intended only for this program.
 541 my @options;
 542 if ($sequence eq 'build-arch' ||
 543     $sequence eq 'install-arch' ||
 544     $sequence eq 'binary-arch') {
 545         push @options, "-a";
 546         # as an optimisation, remove from the list any packages
 547         # that are not arch dependent
 548         my %arch_packages = map { $_ => 1 } getpackages("arch");
 549         @packages = grep { $arch_packages{$_} } @packages;
 550 }
 551 elsif ($sequence eq 'build-indep' ||
 552        $sequence eq 'install-indep' ||
 553        $sequence eq 'binary-indep') {
 554         push @options, "-i";
 555         # ditto optimisation for arch indep
 556         my %indep_packages = map { $_ => 1 } getpackages("indep");
 557         @packages = grep { $indep_packages{$_} } @packages;
 558 }
 559 while (@ARGV_orig) {
 560         my $opt=shift @ARGV_orig;
 561         if ($opt =~ /^--?(after|until|before|with|without)$/) {
 562                 shift @ARGV_orig;
 563                 next;
 564         }
 565         elsif ($opt =~ /^--?(no-act|remaining|(after|until|before|with|without)=)/) {
 566                 next;
 567         }
 568         elsif ($opt=~/^-/) {
 569                 push @options, "-O".$opt;
 570         }
 571         elsif (@options) {
 572                 if ($options[$#options]=~/^-O--/) {
 573                         $options[$#options].="=".$opt;
 574                 }
 575                 else {
 576                         $options[$#options].=$opt;
 577                 }
 578         }
 579 }
 580
 581 # Figure out at what point in the sequence to start for each package.
 582 my %logged;
 583 my %startpoint;
 584 foreach my $package (@packages) {
 585         my @log=load_log($package, \%logged);
 586         if ($dh{AFTER}) {
 587                 # Run commands in the sequence that come after the
 588                 # specified command.
 589                 $startpoint{$package}=command_pos($dh{AFTER}, @sequence) + 1;
 590                 # Write a dummy log entry indicating that the specified
 591                 # command was, in fact, run. This handles the case where
 592                 # no commands remain to run after it, communicating to
 593                 # future dh instances that the specified command should not
 594                 # be run again.
 595                 write_log($sequence[$startpoint{$package}-1], $package);
 596         }
 597         elsif ($dh{REMAINING}) {
 598                 # Start at the beginning so all remaining commands will get
 599                 # run.
 600                 $startpoint{$package}=0;
 601         }
 602         else {
 603                 # Find the last logged command that is in the sequence, and
 604                 # continue with the next command after it. If no logged
 605                 # command is in the sequence, we're starting at the beginning..
 606                 $startpoint{$package}=0;
 607 COMMAND:        foreach my $command (reverse @log) {
 608                         foreach my $i (0..$#sequence) {
 609                                 if ($command eq $sequence[$i]) {
 610                                         $startpoint{$package}=$i+1;
 611                                         last COMMAND;
 612                                 }
 613                         }
 614                 }
 615         }
 616 }
 617
 618 # Figure out what point in the sequence to go to.
 619 my $stoppoint=$#sequence;
 620 if ($dh{UNTIL}) {
 621         $stoppoint=command_pos($dh{UNTIL}, @sequence);
 622 }
 623 elsif ($dh{BEFORE}) {
 624         $stoppoint=command_pos($dh{BEFORE}, @sequence) - 1;
 625 }
 626
 627 # Now run the commands in the sequence.
 628 foreach my $i (0..$stoppoint) {
 629         my $command=$sequence[$i];
 630
 631         # Figure out which packages need to run this command.
 632         my @todo;
 633         my @opts=@options;
 634         foreach my $package (@packages) {
 635                 if ($startpoint{$package} > $i ||
 636                     $logged{$package}{$sequence[$i]}) {
 637                         push @opts, "-N$package";
 638                 }
 639                 else {
 640                         push @todo, $package;
 641                 }
 642         }
 643         next unless @todo;
 644
 645         my $rules_target = rules_target($command);
 646         if (defined $rules_target) {
 647                 # Don't pass DH_ environment variables, since this is
 648                 # a fresh invocation of debian/rules and any sub-dh commands.
 649                 delete $ENV{DH_INTERNAL_OPTIONS};
 650                 delete $ENV{DH_INTERNAL_OVERRIDE};
 651                 run("debian/rules", $rules_target);
 652                 next;
 653         }
 654
 655         # Check for override targets in debian/rules, and run instead of
 656         # the usual command.
 657         next if run_override("override_".$command, $command, \@todo, @opts);
 658
 659         run($command, @opts);
 660 }
 661
 662 sub run {
 663         my $command=shift;
 664         my @options=@_;
 665
 666         # Include additional command options if any
 667         unshift @options, @{$command_opts{$command}}
 668                 if exists $command_opts{$command};
 669
 670         # 3 space indent lines the command being run up under the
 671         # sequence name after "dh ".
 672         print "   ".escape_shell($command, @options)."\n";
 673
 674         return if $dh{NO_ACT};
 675
 676         my $ret=system($command, @options);
 677         if ($ret >> 8 != 0) {
 678                 exit $ret >> 8;
 679         }
 680         elsif ($ret) {
 681                 exit 1;
 682         }
 683 }
 684
 685 # Returns true if an override target exists for a command.
 686 sub run_override {
 687         my $override=shift;
 688         my $command=shift;
 689         my @packages=@{shift()};
 690         my @options=@_;
 691
 692         my $has_explicit_target = rules_explicit_target($override);
 693         return 0 unless defined $has_explicit_target; # no such override
 694         return 1 if ! $has_explicit_target; # has empty override
 695
 696         # This passes the options through to commands called
 697         # inside the target.
 698         $ENV{DH_INTERNAL_OPTIONS}=join("\x1e", @options);
 699         $ENV{DH_INTERNAL_OVERRIDE}=$command;
 700         run("debian/rules", "override_".$command);
 701         delete $ENV{DH_INTERNAL_OPTIONS};
 702         delete $ENV{DH_INTERNAL_OVERRIDE};
 703
 704         # Update log for overridden command now that it has
 705         # finished successfully.
 706         # (But avoid logging for dh_clean since it removes
 707         # the log earlier.)
 708         if (! $dh{NO_ACT} && $command ne 'dh_clean') {
 709                 write_log($command, @packages);
 710                 commit_override_log(@packages);
 711         }
 712
 713         return 1;
 714 }
 715
 716 sub optimize_sequence {
 717         my @sequence;
 718         my %seen;
 719         my $add=sub {
 720                 # commands can appear multiple times when sequences are
 721                 # inlined together; only the first should be needed
 722                 my $command=shift;
 723                 if (! $seen{$command}) {
 724                         $seen{$command}=1;
 725                         push @sequence, $command;
 726                 }
 727         };
 728         foreach my $command (@_) {
 729                 my $rules_target=rules_target($command);
 730                 if (defined $rules_target &&
 731                     ! defined rules_explicit_target($rules_target)) {
 732                         # inline the sequence for this implicit target
 733                         $add->($_) foreach optimize_sequence(@{$sequences{$rules_target}});
 734                 }
 735                 else {
 736                         $add->($command);
 737                 }
 738         }
 739         return @sequence;
 740 }
 741
 742 sub rules_target {
 743         my $command=shift;
 744         if ($command =~ /^debian\/rules\s+(.*)/) {
 745                 return $1
 746         }
 747         else {
 748                 return undef;
 749         }
 750 }
 751
 752 sub rules {
 753         return "debian/rules ".join(" ", @_);
 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 $dummy_target 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|recipe) 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 sub warn_deprecated {
 819         foreach my $deprecated ('until', 'after', 'before', 'remaining') {
 820                 if (defined $dh{uc $deprecated}) {
 821                         warning("The --$deprecated option is deprecated. Use override targets instead.");
 822                 }
 823         }
 824 }
 825
 826 sub command_pos {
 827         my $command=shift;
 828         my @sequence=@_;
 829
 830         foreach my $i (0..$#sequence) {
 831                 if ($command eq $sequence[$i]) {
 832                         return $i;
 833                 }
 834         }
 835
 836         my @matches;
 837         foreach my $i (0..$#sequence) {
 838                 if ($sequence[$i] =~ /\Q$command\E/) {
 839                         push @matches, $i;
 840                 }
 841         }
 842         if (! @matches) {
 843                 error "command specification \"$command\" does not match any command in the sequence"
 844         }
 845         else {
 846                 return pop @matches;
 847         }
 848 }
 849
 850 =head1 SEE ALSO
 851
 852 L<debhelper(7)>
 853
 854 This program is a part of debhelper.
 855
 856 =head1 AUTHOR
 857
 858 Joey Hess <joeyh@debian.org>
 859
 860 =cut