← Back to branch summary

~ubuntu-branches/ubuntu/utopic/dpkg/utopic

« back to all changes in this revision

Viewing changes to scripts/dpkg-source.pl

  • Committer: Package Import Robot
  • Author(s): Adam Conrad
  • Date: 2013-11-17 10:42:09 UTC
  • mfrom: (1.6.2 sid) (1.5.18 jessie)
  • Revision ID: package-import@ubuntu.com-20131117104209-ixwjosuxm5q99qt7
Tags: 1.17.1ubuntu1
* Merge from Debian unstable.  Remaining changes:
  - Change the multiarch downgrade version checks in prerm/postrm
    from 1.16.2 to 1.16.0~ to reflect when multiarch landed in Ubuntu.
  - Migrate dpkg multiarch conffile (and other multi-arch-related
    conf settings) to the new DB with dpkg --add-architecture, but
    keep a copy of the old conffile if it was modified.
  - Out of paranoia, keep an option handler for foreign-architecture
    that informs people that they need to scrub their config files
    and upgrade, on the off chance that the above migration fails
    for some reason (this mitigates the chances of leaving users with
    a dpkg that fails to run due to a broken config).
  - Add DPKG_UNTRANSLATED_MESSAGES environment check so that higher-level
    tools can get untranslated dpkg terminal log messages while at the
    same time having translated debconf prompts.  This is useful for tools
    that hide the dpkg terminal by default and use apport for bug
    reporting with the untranslated error message.
  - Apply patch from Steve McIntyre to special-case armhf/armel ELF
    objects in Shlibs/Objdump.pm, so we don't get incorrect deps.
  - lib/dpkg/pkg-spec.c: map unqualified package names of multiarch-same
    packages to the native arch instead of throwing an error, so that we
    don't break on upgrade when there are unqualified names stored in
    dpkg's own trigger database.
  - Add logic to the postinst to `dpkg --add-architecture i386' on new
    installs on amd64, and to also do so on upgrades from pre-conffile
    Ubuntu versions, mimicking our previous behaviour with the conffile.
  - Apply a workaround from mvo to consider RC packages as multiarch,
    during the dpkg consistency checks. (see LP: 1015567 and 1057367).
  - Add ppc64el/powerpc64le support to cputable (backported from 1.17.2).
* Forward-port manpages-it dpkg/dpkg-dev/dselect Replaces from 1.16.12.

Show diffs side-by-side

added added

removed removed

Lines of Context:
scripts/dpkg-source.pl
1
1
#! /usr/bin/perl
2
 
# vim: set et sw=4 ts=8
3
2
#
4
3
# dpkg-source
5
4
#
29
28
use strict;
30
29
use warnings;
31
30
 
32
 
use Dpkg;
 
31
use Dpkg ();
33
32
use Dpkg::Gettext;
34
33
use Dpkg::ErrorHandling;
 
34
use Dpkg::Util qw(:list);
35
35
use Dpkg::Arch qw(debarch_eq debarch_is debarch_is_wildcard);
36
36
use Dpkg::Deps;
37
37
use Dpkg::Compression;
49
49
use File::Basename;
50
50
use File::Spec;
51
51
 
52
 
textdomain("dpkg-dev");
 
52
textdomain('dpkg-dev');
53
53
 
54
54
my $controlfile;
55
55
my $changelogfile;
60
60
    # Compression related
61
61
    compression => compression_get_default(),
62
62
    comp_level => compression_get_default_level(),
63
 
    comp_ext => compression_get_property(compression_get_default(), "file_ext"),
 
63
    comp_ext => compression_get_property(compression_get_default(), 'file_ext'),
64
64
    # Ignore files
65
65
    tar_ignore => [],
66
66
    diff_ignore_regexp => '',
98
98
}
99
99
 
100
100
my $dir;
101
 
if (defined($options{'opmode'}) &&
102
 
    $options{'opmode'} =~ /^(-b|--print-format|--(before|after)-build|--commit)$/) {
 
101
if (defined($options{opmode}) &&
 
102
    $options{opmode} =~ /^(-b|--print-format|--(before|after)-build|--commit)$/) {
103
103
    if (not scalar(@ARGV)) {
104
 
        usageerr(_g("%s needs a directory"), $options{'opmode'})
105
 
            unless $1 eq "--commit";
106
 
        $dir = ".";
 
104
        usageerr(_g('%s needs a directory'), $options{opmode})
 
105
            unless $1 eq '--commit';
 
106
        $dir = '.';
107
107
    } else {
108
108
        $dir = File::Spec->catdir(shift(@ARGV));
109
109
    }
110
 
    stat($dir) || syserr(_g("cannot stat directory %s"), $dir);
 
110
    stat($dir) || syserr(_g('cannot stat directory %s'), $dir);
111
111
    if (not -d $dir) {
112
 
        error(_g("directory argument %s is not a directory"), $dir);
 
112
        error(_g('directory argument %s is not a directory'), $dir);
113
113
    }
114
 
    if ($dir eq ".") {
 
114
    if ($dir eq '.') {
115
115
        # . is never correct, adjust automatically
116
116
        $dir = basename(cwd());
117
 
        chdir("..") || syserr(_g("unable to chdir to `%s'"), "..");
 
117
        chdir('..') || syserr(_g("unable to chdir to `%s'"), '..');
118
118
    }
119
119
    # --format options are not allowed, they would take precedence
120
120
    # over real command line options, debian/source/format should be used
122
122
    # --unapply-patches is only allowed in local-options as it's a matter
123
123
    # of personal taste and the default should be to keep patches applied
124
124
    my $forbidden_opts_re = {
125
 
        "options" => qr/^--(?:format=|unapply-patches$|abort-on-upstream-changes$)/,
126
 
        "local-options" => qr/^--format=/,
 
125
        'options' => qr/^--(?:format=|unapply-patches$|abort-on-upstream-changes$)/,
 
126
        'local-options' => qr/^--format=/,
127
127
    };
128
 
    foreach my $filename ("local-options", "options") {
 
128
    foreach my $filename ('local-options', 'options') {
129
129
        my $conf = Dpkg::Conf->new();
130
 
        my $optfile = File::Spec->catfile($dir, "debian", "source", $filename);
 
130
        my $optfile = File::Spec->catfile($dir, 'debian', 'source', $filename);
131
131
        next unless -f $optfile;
132
132
        $conf->load($optfile);
133
133
        $conf->filter(remove => sub { $_[0] =~ $forbidden_opts_re->{$filename} });
134
134
        if (@$conf) {
135
 
            info(_g("using options from %s: %s"), $optfile, join(" ", @$conf))
136
 
                unless $options{'opmode'} eq "--print-format";
 
135
            info(_g('using options from %s: %s'), $optfile, join(' ', @$conf))
 
136
                unless $options{opmode} eq '--print-format';
137
137
            unshift @options, @$conf;
138
138
        }
139
139
    }
142
142
while (@options) {
143
143
    $_ = shift(@options);
144
144
    if (m/^--format=(.*)$/) {
145
 
        $build_format = $1 unless defined $build_format;
 
145
        $build_format //= $1;
146
146
    } elsif (m/^-(?:Z|-compression=)(.*)$/) {
147
147
        my $compression = $1;
148
 
        $options{'compression'} = $compression;
149
 
        $options{'comp_ext'} = compression_get_property($compression, "file_ext");
150
 
        usageerr(_g("%s is not a supported compression"), $compression)
 
148
        $options{compression} = $compression;
 
149
        $options{comp_ext} = compression_get_property($compression, 'file_ext');
 
150
        usageerr(_g('%s is not a supported compression'), $compression)
151
151
            unless compression_is_supported($compression);
152
152
        compression_set_default($compression);
153
153
    } elsif (m/^-(?:z|-compression-level=)(.*)$/) {
154
154
        my $comp_level = $1;
155
 
        $options{'comp_level'} = $comp_level;
156
 
        usageerr(_g("%s is not a compression level"), $comp_level)
 
155
        $options{comp_level} = $comp_level;
 
156
        usageerr(_g('%s is not a compression level'), $comp_level)
157
157
            unless compression_is_valid_level($comp_level);
158
158
        compression_set_default_level($comp_level);
159
159
    } elsif (m/^-c(.*)$/) {
167
167
    } elsif (m/^-U([^\=:]+)$/) {
168
168
        $remove{$1} = 1;
169
169
    } elsif (m/^-(?:i|-diff-ignore(?:$|=))(.*)$/) {
170
 
        $options{'diff_ignore_regexp'} = $1 ? $1 : $Dpkg::Source::Package::diff_ignore_default_regexp;
 
170
        $options{diff_ignore_regexp} = $1 ? $1 : $Dpkg::Source::Package::diff_ignore_default_regexp;
171
171
    } elsif (m/^--extend-diff-ignore=(.+)$/) {
172
172
        $Dpkg::Source::Package::diff_ignore_default_regexp .= "|$1";
173
 
        if ($options{'diff_ignore_regexp'}) {
174
 
            $options{'diff_ignore_regexp'} .= "|$1";
 
173
        if ($options{diff_ignore_regexp}) {
 
174
            $options{diff_ignore_regexp} .= "|$1";
175
175
        }
176
176
    } elsif (m/^-(?:I|-tar-ignore=)(.+)$/) {
177
 
        push @{$options{'tar_ignore'}}, $1;
 
177
        push @{$options{tar_ignore}}, $1;
178
178
    } elsif (m/^-(?:I|-tar-ignore)$/) {
179
179
        unless ($tar_ignore_default_pattern_done) {
180
 
            push @{$options{'tar_ignore'}}, @Dpkg::Source::Package::tar_ignore_default_pattern;
 
180
            push @{$options{tar_ignore}}, @Dpkg::Source::Package::tar_ignore_default_pattern;
181
181
            # Prevent adding multiple times
182
182
            $tar_ignore_default_pattern_done = 1;
183
183
        }
184
184
    } elsif (m/^--no-copy$/) {
185
 
        $options{'copy_orig_tarballs'} = 0;
 
185
        $options{copy_orig_tarballs} = 0;
186
186
    } elsif (m/^--no-check$/) {
187
 
        $options{'no_check'} = 1;
 
187
        $options{no_check} = 1;
188
188
    } elsif (m/^--require-valid-signature$/) {
189
 
        $options{'require_valid_signature'} = 1;
 
189
        $options{require_valid_signature} = 1;
190
190
    } elsif (m/^-V(\w[-:0-9A-Za-z]*)[=:](.*)$/s) {
191
191
        $substvars->set($1, $2);
192
192
    } elsif (m/^-T(.*)$/) {
199
199
        exit(0);
200
200
    } elsif (m/^-[EW]$/) {
201
201
        # Deprecated option
202
 
        warning(_g("-E and -W are deprecated, they are without effect"));
 
202
        warning(_g('-E and -W are deprecated, they are without effect'));
203
203
    } elsif (m/^-q$/) {
204
204
        report_options(quiet_warnings => 1);
205
 
        $options{'quiet'} = 1;
 
205
        $options{quiet} = 1;
206
206
    } elsif (m/^--$/) {
207
207
        last;
208
208
    } else {
210
210
    }
211
211
}
212
212
 
213
 
unless (defined($options{'opmode'})) {
214
 
    usageerr(_g("need a command (-x, -b, --before-build, --after-build, --print-format, --commit)"));
 
213
unless (defined($options{opmode})) {
 
214
    usageerr(_g('need a command (-x, -b, --before-build, --after-build, --print-format, --commit)'));
215
215
}
216
216
 
217
 
if ($options{'opmode'} =~ /^(-b|--print-format|--(before|after)-build|--commit)$/) {
 
217
if ($options{opmode} =~ /^(-b|--print-format|--(before|after)-build|--commit)$/) {
218
218
 
219
 
    $options{'ARGV'} = \@ARGV;
 
219
    $options{ARGV} = \@ARGV;
220
220
 
221
221
    $changelogfile ||= "$dir/debian/changelog";
222
222
    $controlfile ||= "$dir/debian/control";
223
 
    
 
223
 
224
224
    my %ch_options = (file => $changelogfile);
225
 
    $ch_options{"changelogformat"} = $changelogformat if $changelogformat;
 
225
    $ch_options{changelogformat} = $changelogformat if $changelogformat;
226
226
    my $changelog = changelog_parse(%ch_options);
227
227
    my $control = Dpkg::Control::Info->new($controlfile);
228
228
 
229
229
    my $srcpkg = Dpkg::Source::Package->new(options => \%options);
230
 
    my $fields = $srcpkg->{'fields'};
 
230
    my $fields = $srcpkg->{fields};
231
231
 
232
232
    my @sourcearch;
233
233
    my %archadded;
237
237
    my $src_fields = $control->get_source();
238
238
    error(_g("%s doesn't contain any information about the source package"),
239
239
          $controlfile) unless defined $src_fields;
240
 
    my $src_sect = $src_fields->{'Section'} || "unknown";
241
 
    my $src_prio = $src_fields->{'Priority'} || "unknown";
242
 
    foreach $_ (keys %{$src_fields}) {
 
240
    my $src_sect = $src_fields->{'Section'} || 'unknown';
 
241
    my $src_prio = $src_fields->{'Priority'} || 'unknown';
 
242
    foreach (keys %{$src_fields}) {
243
243
        my $v = $src_fields->{$_};
244
244
        if (m/^Source$/i) {
245
245
            set_source_package($v);
250
250
            my $dep;
251
251
            my $type = field_get_dep_type($_);
252
252
            $dep = deps_parse($v, build_dep => 1, union => $type eq 'union');
253
 
            error(_g("error occurred while parsing %s"), $_) unless defined $dep;
 
253
            error(_g('error occurred while parsing %s'), $_) unless defined $dep;
254
254
            my $facts = Dpkg::Deps::KnownFacts->new();
255
255
            $dep->simplify_deps($facts);
256
256
            $dep->sort() if $type eq 'union';
268
268
        my $prio = $pkg->{'Priority'} || $src_prio;
269
269
        my $type = $pkg->{'Package-Type'} ||
270
270
                $pkg->get_custom_field('Package-Type') || 'deb';
271
 
        push @pkglist, sprintf("%s %s %s %s", $p, $type, $sect, $prio);
 
271
        push @pkglist, sprintf('%s %s %s %s', $p, $type, $sect, $prio);
272
272
        push(@binarypackages,$p);
273
 
        foreach $_ (keys %{$pkg}) {
 
273
        foreach (keys %{$pkg}) {
274
274
            my $v = $pkg->{$_};
275
275
            if (m/^Architecture$/) {
276
276
                # Gather all binary architectures in one set. 'any' and 'all'
283
283
                        error(_g("`%s' is not a legal architecture string"),
284
284
                              $a)
285
285
                            unless $a =~ /^[\w-]+$/;
286
 
                        error(_g("architecture %s only allowed on its " .
 
286
                        error(_g('architecture %s only allowed on its ' .
287
287
                                 "own (list for package %s is `%s')"),
288
288
                              $a, $p, $a)
289
 
                            if grep($a eq $_, 'any', 'all');
 
289
                            if $a eq 'any' or $a eq 'all';
290
290
                        push(@sourcearch, $a) unless $archadded{$a}++;
291
291
                    }
292
292
                }
300
300
    unless (scalar(@pkglist)) {
301
301
        error(_g("%s doesn't list any binary package"), $controlfile);
302
302
    }
303
 
    if (grep($_ eq 'any', @sourcearch)) {
 
303
    if (any { $_ eq 'any' } @sourcearch) {
304
304
        # If we encounter one 'any' then the other arches become insignificant
305
305
        # except for 'all' that must also be kept
306
 
        if (grep($_ eq 'all', @sourcearch)) {
307
 
            @sourcearch = ('any', 'all');
 
306
        if (any { $_ eq 'all' } @sourcearch) {
 
307
            @sourcearch = qw(any all);
308
308
        } else {
309
 
            @sourcearch = ('any');
 
309
            @sourcearch = qw(any);
310
310
        }
311
311
    } else {
312
 
        # Minimize arch list, by remoing arches already covered by wildcards
313
 
        my @arch_wildcards = grep(debarch_is_wildcard($_), @sourcearch);
 
312
        # Minimize arch list, by removing arches already covered by wildcards
 
313
        my @arch_wildcards = grep { debarch_is_wildcard($_) } @sourcearch;
314
314
        my @mini_sourcearch = @arch_wildcards;
315
315
        foreach my $arch (@sourcearch) {
316
 
            if (!grep(debarch_is($arch, $_), @arch_wildcards)) {
 
316
            if (none { debarch_is($arch, $_) } @arch_wildcards) {
317
317
                push @mini_sourcearch, $arch;
318
318
            }
319
319
        }
323
323
    $fields->{'Package-List'} = "\n" . join("\n", sort @pkglist);
324
324
 
325
325
    # Scan fields of dpkg-parsechangelog
326
 
    foreach $_ (keys %{$changelog}) {
 
326
    foreach (keys %{$changelog}) {
327
327
        my $v = $changelog->{$_};
328
328
 
329
329
        if (m/^Source$/) {
334
334
            error($error) unless $ok;
335
335
            $fields->{$_} = $v;
336
336
        } elsif (m/^Binary-Only$/) {
337
 
            error(_g("building source for a binary-only release"))
338
 
                if $v eq "yes" and $options{'opmode'} eq "-b";
 
337
            error(_g('building source for a binary-only release'))
 
338
                if $v eq 'yes' and $options{opmode} eq '-b';
339
339
        } elsif (m/^Maintainer$/i) {
340
340
            # Do not replace the field coming from the source entry
341
341
        } else {
342
342
            field_transfer_single($changelog, $fields);
343
343
        }
344
344
    }
345
 
    
 
345
 
346
346
    $fields->{'Binary'} = join(', ', @binarypackages);
347
347
    # Avoid overly long line by splitting over multiple lines
348
348
    if (length($fields->{'Binary'}) > 980) {
352
352
    # Select the format to use
353
353
    if (not defined $build_format) {
354
354
        if (-e "$dir/debian/source/format") {
355
 
            open(FORMAT, "<", "$dir/debian/source/format") ||
356
 
                syserr(_g("cannot read %s"), "$dir/debian/source/format");
357
 
            $build_format = <FORMAT>;
 
355
            open(my $format_fh, '<', "$dir/debian/source/format") ||
 
356
                syserr(_g('cannot read %s'), "$dir/debian/source/format");
 
357
            $build_format = <$format_fh>;
358
358
            chomp($build_format) if defined $build_format;
359
 
            error(_g("%s is empty"), "$dir/debian/source/format")
 
359
            error(_g('%s is empty'), "$dir/debian/source/format")
360
360
                unless defined $build_format and length $build_format;
361
 
            close(FORMAT);
 
361
            close($format_fh);
362
362
        } else {
363
 
            warning(_g("no source format specified in %s, " .
364
 
                       "see dpkg-source(1)"), "debian/source/format")
365
 
                if $options{'opmode'} eq "-b";
366
 
            $build_format = "1.0";
 
363
            warning(_g('no source format specified in %s, ' .
 
364
                       'see dpkg-source(1)'), 'debian/source/format')
 
365
                if $options{opmode} eq '-b';
 
366
            $build_format = '1.0';
367
367
        }
368
368
    }
369
369
    $fields->{'Format'} = $build_format;
372
372
    $srcpkg->init_options();
373
373
    $srcpkg->parse_cmdline_options(@cmdline_options);
374
374
 
375
 
    if ($options{'opmode'} eq "--print-format") {
 
375
    if ($options{opmode} eq '--print-format') {
376
376
        print $fields->{'Format'} . "\n";
377
377
        exit(0);
378
 
    } elsif ($options{'opmode'} eq "--before-build") {
 
378
    } elsif ($options{opmode} eq '--before-build') {
379
379
        $srcpkg->before_build($dir);
380
380
        exit(0);
381
 
    } elsif ($options{'opmode'} eq "--after-build") {
 
381
    } elsif ($options{opmode} eq '--after-build') {
382
382
        $srcpkg->after_build($dir);
383
383
        exit(0);
384
 
    } elsif ($options{'opmode'} eq "--commit") {
 
384
    } elsif ($options{opmode} eq '--commit') {
385
385
        $srcpkg->commit($dir);
386
386
        exit(0);
387
387
    }
392
392
 
393
393
    # Only -b left
394
394
    info(_g("using source format `%s'"), $fields->{'Format'});
395
 
    run_vendor_hook("before-source-build", $srcpkg);
 
395
    run_vendor_hook('before-source-build', $srcpkg);
396
396
    # Build the files (.tar.gz, .diff.gz, etc)
397
397
    $srcpkg->build($dir);
398
398
 
399
399
    # Write the .dsc
400
 
    my $dscname = $srcpkg->get_basename(1) . ".dsc";
401
 
    info(_g("building %s in %s"), $sourcepackage, $dscname);
 
400
    my $dscname = $srcpkg->get_basename(1) . '.dsc';
 
401
    info(_g('building %s in %s'), $sourcepackage, $dscname);
402
402
    $srcpkg->write_dsc(filename => $dscname,
403
403
                       remove => \%remove,
404
404
                       override => \%override,
405
405
                       substvars => $substvars);
406
406
    exit(0);
407
407
 
408
 
} elsif ($options{'opmode'} eq '-x') {
 
408
} elsif ($options{opmode} eq '-x') {
409
409
 
410
410
    # Check command line
411
411
    unless (scalar(@ARGV)) {
412
 
        usageerr(_g("-x needs at least one argument, the .dsc"));
 
412
        usageerr(_g('-x needs at least one argument, the .dsc'));
413
413
    }
414
414
    if (scalar(@ARGV) > 2) {
415
 
        usageerr(_g("-x takes no more than two arguments"));
 
415
        usageerr(_g('-x takes no more than two arguments'));
416
416
    }
417
417
    my $dsc = shift(@ARGV);
418
418
    if (-d $dsc) {
419
 
        usageerr(_g("-x needs the .dsc file as first argument, not a directory"));
 
419
        usageerr(_g('-x needs the .dsc file as first argument, not a directory'));
420
420
    }
421
421
 
422
422
    # Create the object that does everything
432
432
    if (@ARGV) {
433
433
        $newdirectory = File::Spec->catdir(shift(@ARGV));
434
434
        if (-e $newdirectory) {
435
 
            error(_g("unpack target exists: %s"), $newdirectory);
 
435
            error(_g('unpack target exists: %s'), $newdirectory);
436
436
        }
437
437
    }
438
438
 
439
439
    # Various checks before unpacking
440
 
    unless ($options{'no_check'}) {
 
440
    unless ($options{no_check}) {
441
441
        if ($srcpkg->is_signed()) {
442
442
            $srcpkg->check_signature();
443
443
        } else {
444
 
            if ($options{'require_valid_signature'}) {
 
444
            if ($options{require_valid_signature}) {
445
445
                error(_g("%s doesn't contain a valid OpenPGP signature"), $dsc);
446
446
            } else {
447
 
                warning(_g("extracting unsigned source package (%s)"), $dsc);
 
447
                warning(_g('extracting unsigned source package (%s)'), $dsc);
448
448
            }
449
449
        }
450
450
        $srcpkg->check_checksums();
451
451
    }
452
452
 
453
453
    # Unpack the source package (delegated to Dpkg::Source::Package::*)
454
 
    info(_g("extracting %s in %s"), $srcpkg->{'fields'}{'Source'}, $newdirectory);
 
454
    info(_g('extracting %s in %s'), $srcpkg->{fields}{'Source'}, $newdirectory);
455
455
    $srcpkg->extract($newdirectory);
456
456
 
457
457
    exit(0);
458
458
}
459
459
 
460
460
sub setopmode {
461
 
    if (defined($options{'opmode'})) {
462
 
        usageerr(_g("only one of -x, -b or --print-format allowed, and only once"));
 
461
    if (defined($options{opmode})) {
 
462
        usageerr(_g('only one of -x, -b or --print-format allowed, and only once'));
463
463
    }
464
 
    $options{'opmode'} = $_[0];
 
464
    $options{opmode} = $_[0];
465
465
}
466
466
 
467
467
sub version {
468
 
    printf _g("Debian %s version %s.\n"), $progname, $version;
 
468
    printf _g("Debian %s version %s.\n"), $Dpkg::PROGNAME, $Dpkg::PROGVERSION;
469
469
 
470
 
    print _g("
 
470
    print _g('
471
471
This is free software; see the GNU General Public License version 2 or
472
472
later for copying conditions. There is NO warranty.
473
 
");
 
473
');
474
474
}
475
475
 
476
476
sub usage {
477
477
    printf _g(
478
 
"Usage: %s [<option>...] <command>")
 
478
'Usage: %s [<option>...] <command>')
479
479
    . "\n\n" . _g(
480
 
"Commands:
 
480
'Commands:
481
481
  -x <filename>.dsc [<output-dir>]
482
482
                           extract source package.
483
483
  -b <dir>                 build source package.
484
484
  --print-format <dir>     print the source format that would be
485
485
                           used to build the source package.
486
486
  --commit [<dir> [<patch-name>]]
487
 
                           store upstream changes in a new patch.")
 
487
                           store upstream changes in a new patch.')
488
488
    . "\n\n" . _g(
489
489
"Build options:
490
490
  -c<control-file>         get control info from this file.
509
509
  --no-check               don't check signature and checksums before unpacking
510
510
  --require-valid-signature abort if the package doesn't have a valid signature")
511
511
    . "\n\n" . _g(
512
 
"General options:
 
512
'General options:
513
513
  -?, --help               show this help message.
514
 
      --version            show the version.")
 
514
      --version            show the version.')
515
515
    . "\n\n" . _g(
516
 
"More options are available but they depend on the source package format.
517
 
See dpkg-source(1) for more info.") . "\n",
518
 
    $progname,
 
516
'More options are available but they depend on the source package format.
 
517
See dpkg-source(1) for more info.') . "\n",
 
518
    $Dpkg::PROGNAME,
519
519
    $Dpkg::Source::Package::diff_ignore_default_regexp,
520
520
    join(' ', map { "-I$_" } @Dpkg::Source::Package::tar_ignore_default_pattern),
521
521
    compression_get_default(),
522
 
    join(" ", compression_get_list()),
 
522
    join(' ', compression_get_list()),
523
523
    compression_get_default_level();
524
524
}