home *** CD-ROM | disk | FTP | other *** search
/ Clickx 115 / Clickx 115.iso / software / tools / windows / tails-i386-0.16.iso / live / filesystem.squashfs / usr / share / perl5 / Dpkg / Changelog.pm < prev    next >
Encoding:
Perl POD Document  |  2012-09-17  |  18.2 KB  |  696 lines
  1. # Copyright ┬⌐ 2005, 2007 Frank Lichtenheld <frank@lichtenheld.de>
  2. # Copyright ┬⌐ 2009       Rapha├½l Hertzog <hertzog@debian.org>
  3. #
  4. # This program is free software; you can redistribute it and/or modify
  5. # it under the terms of the GNU General Public License as published by
  6. # the Free Software Foundation; either version 2 of the License, or
  7. # (at your option) any later version.
  8. #
  9. # This program is distributed in the hope that it will be useful,
  10. # but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12. # GNU General Public License for more details.
  13. #
  14. # You should have received a copy of the GNU General Public License
  15. # along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16.  
  17. =encoding utf8
  18.  
  19. =head1 NAME
  20.  
  21. Dpkg::Changelog - base class to implement a changelog parser
  22.  
  23. =head1 DESCRIPTION
  24.  
  25. Dpkg::Changelog is a class representing a changelog file
  26. as an array of changelog entries (Dpkg::Changelog::Entry).
  27. By deriving this object and implementing its parse method, you
  28. add the ability to fill this object with changelog entries.
  29.  
  30. =head2 FUNCTIONS
  31.  
  32. =cut
  33.  
  34. package Dpkg::Changelog;
  35.  
  36. use strict;
  37. use warnings;
  38.  
  39. our $VERSION = "1.00";
  40.  
  41. use Dpkg;
  42. use Dpkg::Gettext;
  43. use Dpkg::ErrorHandling qw(:DEFAULT report);
  44. use Dpkg::Control;
  45. use Dpkg::Control::Changelog;
  46. use Dpkg::Control::Fields;
  47. use Dpkg::Index;
  48. use Dpkg::Version;
  49. use Dpkg::Vendor qw(run_vendor_hook);
  50.  
  51. use base qw(Dpkg::Interface::Storable);
  52.  
  53. use overload
  54.     '@{}' => sub { return $_[0]->{data} };
  55.  
  56. =over 4
  57.  
  58. =item my $c = Dpkg::Changelog->new(%options)
  59.  
  60. Creates a new changelog object.
  61.  
  62. =cut
  63.  
  64. sub new {
  65.     my ($this, %opts) = @_;
  66.     my $class = ref($this) || $this;
  67.     my $self = {
  68.     verbose => 1,
  69.     parse_errors => []
  70.     };
  71.     bless $self, $class;
  72.     $self->set_options(%opts);
  73.     return $self;
  74. }
  75.  
  76. =item $c->load($filename)
  77.  
  78. Parse $filename as a changelog.
  79.  
  80. =cut
  81.  
  82. =item $c->set_options(%opts)
  83.  
  84. Change the value of some options. "verbose" (defaults to 1) defines
  85. whether parse errors are displayed as warnings by default. "reportfile"
  86. is a string to use instead of the name of the file parsed, in particular
  87. in error messages. "range" defines the range of entries that we want to
  88. parse, the parser will stop as soon as it has parsed enough data to
  89. satisfy $c->get_range($opts{'range'}).
  90.  
  91. =cut
  92.  
  93. sub set_options {
  94.     my ($self, %opts) = @_;
  95.     $self->{$_} = $opts{$_} foreach keys %opts;
  96. }
  97.  
  98. =item $c->reset_parse_errors()
  99.  
  100. Can be used to delete all information about errors ocurred during
  101. previous L<parse> runs.
  102.  
  103. =cut
  104.  
  105. sub reset_parse_errors {
  106.     my ($self) = @_;
  107.     $self->{parse_errors} = [];
  108. }
  109.  
  110. =item $c->parse_error($line_nr, $error, [$line])
  111.  
  112. Record a new parse error at line $line_nr. The error message is specified
  113. with $error and a copy of the line can be recorded in $line.
  114.  
  115. =cut
  116.  
  117. sub parse_error {
  118.     my ($self, $file, $line_nr, $error, $line) = @_;
  119.     shift;
  120.  
  121.     push @{$self->{parse_errors}}, [ @_ ];
  122.  
  123.     if ($self->{verbose}) {
  124.     if ($line) {
  125.         warning("%20s(l$line_nr): $error\nLINE: $line", $file);
  126.     } else {
  127.         warning("%20s(l$line_nr): $error", $file);
  128.     }
  129.     }
  130. }
  131.  
  132. =item $c->get_parse_errors()
  133.  
  134. Returns all error messages from the last L<parse> run.
  135. If called in scalar context returns a human readable
  136. string representation. If called in list context returns
  137. an array of arrays. Each of these arrays contains
  138.  
  139. =over 4
  140.  
  141. =item 1.
  142.  
  143. a string describing the origin of the data (a filename usually). If the
  144. reportfile configuration option was given, its value will be used instead.
  145.  
  146. =item 2.
  147.  
  148. the line number where the error occurred
  149.  
  150. =item 3.
  151.  
  152. an error description
  153.  
  154. =item 4.
  155.  
  156. the original line
  157.  
  158. =back
  159.  
  160. =cut
  161.  
  162. sub get_parse_errors {
  163.     my ($self) = @_;
  164.  
  165.     if (wantarray) {
  166.     return @{$self->{parse_errors}};
  167.     } else {
  168.     my $res = "";
  169.     foreach my $e (@{$self->{parse_errors}}) {
  170.         if ($e->[3]) {
  171.         $res .= report(_g('warning'),_g("%s(l%s): %s\nLINE: %s"), @$e );
  172.         } else {
  173.         $res .= report(_g('warning'),_g("%s(l%s): %s"), @$e );
  174.         }
  175.     }
  176.     return $res;
  177.     }
  178. }
  179.  
  180. =item $c->set_unparsed_tail($tail)
  181.  
  182. Add a string representing unparsed lines after the changelog entries.
  183. Use undef as $tail to remove the unparsed lines currently set.
  184.  
  185. =item $c->get_unparsed_tail()
  186.  
  187. Return a string representing the unparsed lines after the changelog
  188. entries. Returns undef if there's no such thing.
  189.  
  190. =cut
  191.  
  192. sub set_unparsed_tail {
  193.     my ($self, $tail) = @_;
  194.     $self->{'unparsed_tail'} = $tail;
  195. }
  196.  
  197. sub get_unparsed_tail {
  198.     my ($self) = @_;
  199.     return $self->{'unparsed_tail'};
  200. }
  201.  
  202. =item @{$c}
  203.  
  204. Returns all the Dpkg::Changelog::Entry objects contained in this changelog
  205. in the order in which they have been parsed.
  206.  
  207. =item $c->get_range($range)
  208.  
  209. Returns an array (if called in list context) or a reference to an array of
  210. Dpkg::Changelog::Entry objects which each represent one entry of the
  211. changelog. $range is a hash reference describing the range of entries
  212. to return. See section L<"RANGE SELECTION">.
  213.  
  214. =cut
  215.  
  216. sub __sanity_check_range {
  217.     my ($self, $r) = @_;
  218.     my $data = $self->{data};
  219.  
  220.     if (defined($r->{offset}) and not defined($r->{count})) {
  221.     warning(_g("'offset' without 'count' has no effect")) if $self->{verbose};
  222.     delete $r->{offset};
  223.     }
  224.  
  225.     if ((defined($r->{count}) || defined($r->{offset})) &&
  226.         (defined($r->{from}) || defined($r->{since}) ||
  227.      defined($r->{to}) || defined($r->{'until'})))
  228.     {
  229.     warning(_g("you can't combine 'count' or 'offset' with any other " .
  230.            "range option")) if $self->{verbose};
  231.     delete $r->{from};
  232.     delete $r->{since};
  233.     delete $r->{to};
  234.     delete $r->{'until'};
  235.     }
  236.     if (defined($r->{from}) && defined($r->{since})) {
  237.     warning(_g("you can only specify one of 'from' and 'since', using " .
  238.            "'since'")) if $self->{verbose};
  239.     delete $r->{from};
  240.     }
  241.     if (defined($r->{to}) && defined($r->{'until'})) {
  242.     warning(_g("you can only specify one of 'to' and 'until', using " .
  243.            "'until'")) if $self->{verbose};
  244.     delete $r->{to};
  245.     }
  246.  
  247.     # Handle non-existing versions
  248.     my (%versions, @versions);
  249.     foreach my $entry (@{$data}) {
  250.         $versions{$entry->get_version()->as_string()} = 1;
  251.         push @versions, $entry->get_version()->as_string();
  252.     }
  253.     if ((defined($r->{since}) and not exists $versions{$r->{since}})) {
  254.         warning(_g("'%s' option specifies non-existing version"), "since");
  255.         warning(_g("use newest entry that is earlier than the one specified"));
  256.         foreach my $v (@versions) {
  257.             if (version_compare_relation($v, REL_LT, $r->{since})) {
  258.                 $r->{since} = $v;
  259.                 last;
  260.             }
  261.         }
  262.         if (not exists $versions{$r->{since}}) {
  263.             # No version was earlier, include all
  264.             warning(_g("none found, starting from the oldest entry"));
  265.             delete $r->{since};
  266.             $r->{from} = $versions[-1];
  267.         }
  268.     }
  269.     if ((defined($r->{from}) and not exists $versions{$r->{from}})) {
  270.         warning(_g("'%s' option specifies non-existing version"), "from");
  271.         warning(_g("use oldest entry that is later than the one specified"));
  272.         my $oldest;
  273.         foreach my $v (@versions) {
  274.             if (version_compare_relation($v, REL_GT, $r->{from})) {
  275.                 $oldest = $v;
  276.             }
  277.         }
  278.         if (defined($oldest)) {
  279.             $r->{from} = $oldest;
  280.         } else {
  281.             warning(_g("no such entry found, ignoring '%s' parameter"), "from");
  282.             delete $r->{from}; # No version was oldest
  283.         }
  284.     }
  285.     if (defined($r->{'until'}) and not exists $versions{$r->{'until'}}) {
  286.         warning(_g("'%s' option specifies non-existing version"), "until");
  287.         warning(_g("use oldest entry that is later than the one specified"));
  288.         my $oldest;
  289.         foreach my $v (@versions) {
  290.             if (version_compare_relation($v, REL_GT, $r->{'until'})) {
  291.                 $oldest = $v;
  292.             }
  293.         }
  294.         if (defined($oldest)) {
  295.             $r->{'until'} = $oldest;
  296.         } else {
  297.             warning(_g("no such entry found, ignoring '%s' parameter"), "until");
  298.             delete $r->{'until'}; # No version was oldest
  299.         }
  300.     }
  301.     if (defined($r->{to}) and not exists $versions{$r->{to}}) {
  302.         warning(_g("'%s' option specifies non-existing version"), "to");
  303.         warning(_g("use newest entry that is earlier than the one specified"));
  304.         foreach my $v (@versions) {
  305.             if (version_compare_relation($v, REL_LT, $r->{to})) {
  306.                 $r->{to} = $v;
  307.                 last;
  308.             }
  309.         }
  310.         if (not exists $versions{$r->{to}}) {
  311.             # No version was earlier
  312.             warning(_g("no such entry found, ignoring '%s' parameter"), "to");
  313.             delete $r->{to};
  314.         }
  315.     }
  316.  
  317.     if (defined($r->{since}) and $data->[0]->get_version() eq $r->{since}) {
  318.     warning(_g("'since' option specifies most recent version, ignoring"));
  319.     delete $r->{since};
  320.     }
  321.     if (defined($r->{'until'}) and $data->[-1]->get_version() eq $r->{'until'}) {
  322.     warning(_g("'until' option specifies oldest version, ignoring"));
  323.     delete $r->{'until'};
  324.     }
  325. }
  326.  
  327. sub get_range {
  328.     my ($self, $range) = @_;
  329.     $range = {} unless defined $range;
  330.     my $res = $self->_data_range($range);
  331.     if (defined $res) {
  332.     return @$res if wantarray;
  333.     return $res;
  334.     } else {
  335.     return () if wantarray;
  336.     return undef;
  337.     }
  338. }
  339.  
  340. sub _data_range {
  341.     my ($self, $range) = @_;
  342.  
  343.     my $data = $self->{data} or return undef;
  344.  
  345.     return [ @$data ] if $range->{all};
  346.  
  347.     unless (grep { m/^(since|until|from|to|count|offset)$/ } keys %$range) {
  348.     return [ @$data ];
  349.     }
  350.  
  351.     $self->__sanity_check_range($range);
  352.  
  353.     my ($start, $end);
  354.     if (defined($range->{count})) {
  355.     my $offset = $range->{offset} || 0;
  356.     my $count = $range->{count};
  357.     # Convert count/offset in start/end
  358.     if ($offset > 0) {
  359.         $offset -= ($count < 0);
  360.     } elsif ($offset < 0) {
  361.         $offset = $#$data + ($count > 0) + $offset;
  362.     } else {
  363.         $offset = $#$data if $count < 0;
  364.     }
  365.     $start = $end = $offset;
  366.     $start += $count+1 if $count < 0;
  367.     $end += $count-1 if $count > 0;
  368.     # Check limits
  369.     $start = 0 if $start < 0;
  370.     return if $start > $#$data;
  371.     $end = $#$data if $end > $#$data;
  372.     return if $end < 0;
  373.     $end = $start if $end < $start;
  374.     return [ @{$data}[$start .. $end] ];
  375.     }
  376.  
  377.     my @result;
  378.     my $include = 1;
  379.     $include = 0 if defined($range->{to}) or defined($range->{'until'});
  380.     foreach (@$data) {
  381.     my $v = $_->get_version();
  382.     $include = 1 if defined($range->{to}) and $v eq $range->{to};
  383.     last if defined($range->{since}) and $v eq $range->{since};
  384.  
  385.     push @result, $_ if $include;
  386.  
  387.     $include = 1 if defined($range->{'until'}) and $v eq $range->{'until'};
  388.     last if defined($range->{from}) and $v eq $range->{from};
  389.     }
  390.  
  391.     return \@result if scalar(@result);
  392.     return undef;
  393. }
  394.  
  395. =item $c->abort_early()
  396.  
  397. Returns true if enough data have been parsed to be able to return all
  398. entries selected by the range set at creation (or with set_options).
  399.  
  400. =cut
  401.  
  402. sub abort_early {
  403.     my ($self) = @_;
  404.  
  405.     my $data = $self->{data} or return;
  406.     my $r = $self->{range} or return;
  407.     my $count = $r->{count} || 0;
  408.     my $offset = $r->{offset} || 0;
  409.  
  410.     return if $r->{all};
  411.     return unless grep { m/^(since|until|from|to|count|offset)$/ } keys %$r;
  412.     return if $offset < 0 or $count < 0;
  413.     if (defined($r->{count})) {
  414.     if ($offset > 0) {
  415.         $offset -= ($count < 0);
  416.     }
  417.     my $start = my $end = $offset;
  418.     $end += $count-1 if $count > 0;
  419.     return ($start < @$data and $end < @$data);
  420.     }
  421.  
  422.     return unless defined($r->{since}) or defined($r->{from});
  423.     foreach (@$data) {
  424.     my $v = $_->get_version();
  425.     return 1 if defined($r->{since}) and $v eq $r->{since};
  426.     return 1 if defined($r->{from}) and $v eq $r->{from};
  427.     }
  428.  
  429.     return;
  430. }
  431.  
  432. =item $c->save($filename)
  433.  
  434. Save the changelog in the given file.
  435.  
  436. =item $c->output()
  437.  
  438. =item "$c"
  439.  
  440. Returns a string representation of the changelog (it's a concatenation of
  441. the string representation of the individual changelog entries).
  442.  
  443. =item $c->output($fh)
  444.  
  445. Output the changelog to the given filehandle.
  446.  
  447. =cut
  448.  
  449. sub output {
  450.     my ($self, $fh) = @_;
  451.     my $str = "";
  452.     foreach my $entry (@{$self}) {
  453.     my $text = $entry->output();
  454.     print $fh $text if defined $fh;
  455.     $str .= $text if defined wantarray;
  456.     }
  457.     my $text = $self->get_unparsed_tail();
  458.     if (defined $text) {
  459.     print $fh $text if defined $fh;
  460.     $str .= $text if defined wantarray;
  461.     }
  462.     return $str;
  463. }
  464.  
  465. =item my $control = $c->dpkg($range)
  466.  
  467. Returns a Dpkg::Control::Changelog object representing the entries selected
  468. by the optional range specifier (see L<"RANGE SELECTION"> for details).
  469. Returns undef in no entries are matched.
  470.  
  471. The following fields are contained in the object:
  472.  
  473. =over 4
  474.  
  475. =item Source
  476.  
  477. package name (in the first entry)
  478.  
  479. =item Version
  480.  
  481. packages' version (from first entry)
  482.  
  483. =item Distribution
  484.  
  485. target distribution (from first entry)
  486.  
  487. =item Urgency
  488.  
  489. urgency (highest of all printed entries)
  490.  
  491. =item Maintainer
  492.  
  493. person that created the (first) entry
  494.  
  495. =item Date
  496.  
  497. date of the (first) entry
  498.  
  499. =item Closes
  500.  
  501. bugs closed by the entry/entries, sorted by bug number
  502.  
  503. =item Changes
  504.  
  505. content of the the entry/entries
  506.  
  507. =back
  508.  
  509. =cut
  510.  
  511. our ( @URGENCIES, %URGENCIES );
  512. BEGIN {
  513.     @URGENCIES = qw(low medium high critical emergency);
  514.     my $i = 1;
  515.     %URGENCIES = map { $_ => $i++ } @URGENCIES;
  516. }
  517.  
  518. sub dpkg {
  519.     my ($self, $range) = @_;
  520.  
  521.     my @data = $self->get_range($range) or return undef;
  522.     my $entry = shift @data;
  523.  
  524.     my $f = Dpkg::Control::Changelog->new();
  525.     $f->{Urgency} = $entry->get_urgency() || "unknown";
  526.     $f->{Source} = $entry->get_source() || "unknown";
  527.     $f->{Version} = $entry->get_version();
  528.     $f->{Version} = "unknown" unless defined $f->{Version};
  529.     $f->{Distribution} = join(" ", $entry->get_distributions());
  530.     $f->{Maintainer} = $entry->get_maintainer() || '';
  531.     $f->{Date} = $entry->get_timestamp() || '';
  532.     $f->{Changes} = $entry->get_dpkg_changes();
  533.  
  534.     # handle optional fields
  535.     my $opts = $entry->get_optional_fields();
  536.     my %closes;
  537.     foreach (keys %$opts) {
  538.     if (/^Urgency$/i) { # Already dealt
  539.     } elsif (/^Closes$/i) {
  540.         $closes{$_} = 1 foreach (split(/\s+/, $opts->{Closes}));
  541.     } else {
  542.         field_transfer_single($opts, $f);
  543.     }
  544.     }
  545.  
  546.     foreach $entry (@data) {
  547.     my $oldurg = $f->{Urgency} || '';
  548.     my $oldurgn = $URGENCIES{$f->{Urgency}} || -1;
  549.     my $newurg = $entry->get_urgency() || '';
  550.     my $newurgn = $URGENCIES{$newurg} || -1;
  551.     $f->{Urgency} = ($newurgn > $oldurgn) ? $newurg : $oldurg;
  552.     $f->{Changes} .= "\n" . $entry->get_dpkg_changes();
  553.  
  554.     # handle optional fields
  555.     $opts = $entry->get_optional_fields();
  556.     foreach (keys %$opts) {
  557.         if (/^Closes$/i) {
  558.         $closes{$_} = 1 foreach (split(/\s+/, $opts->{Closes}));
  559.         } elsif (not exists $f->{$_}) { # Don't overwrite an existing field
  560.         field_transfer_single($opts, $f);
  561.         }
  562.     }
  563.     }
  564.  
  565.     if (scalar keys %closes) {
  566.     $f->{Closes} = join " ", sort { $a <=> $b } keys %closes;
  567.     }
  568.     run_vendor_hook("post-process-changelog-entry", $f);
  569.  
  570.     return $f;
  571. }
  572.  
  573. =item my @controls = $c->rfc822($range)
  574.  
  575. Returns a Dpkg::Index containing Dpkg::Control::Changelog objects where
  576. each object represents one entry in the changelog that is part of the
  577. range requested (see L<"RANGE SELECTION"> for details). For the format of
  578. such an object see the description of the L<"dpkg"> method (while ignoring
  579. the remarks about which values are taken from the first entry).
  580.  
  581. =cut
  582.  
  583. sub rfc822 {
  584.     my ($self, $range) = @_;
  585.  
  586.     my @data = $self->get_range($range) or return undef;
  587.     my $index = Dpkg::Index->new(type => CTRL_CHANGELOG);
  588.  
  589.     foreach my $entry (@data) {
  590.     my $f = Dpkg::Control::Changelog->new();
  591.     $f->{Urgency} = $entry->get_urgency() || "unknown";
  592.     $f->{Source} = $entry->get_source() || "unknown";
  593.     $f->{Version} = $entry->get_version();
  594.     $f->{Version} = "unknown" unless defined $f->{Version};
  595.     $f->{Distribution} = join(" ", $entry->get_distributions());
  596.     $f->{Maintainer} = $entry->get_maintainer() || "";
  597.     $f->{Date} = $entry->get_timestamp() || "";
  598.     $f->{Changes} = $entry->get_dpkg_changes();
  599.  
  600.     # handle optional fields
  601.     my $opts = $entry->get_optional_fields();
  602.     foreach (keys %$opts) {
  603.         field_transfer_single($opts, $f) unless exists $f->{$_};
  604.     }
  605.  
  606.         run_vendor_hook("post-process-changelog-entry", $f);
  607.  
  608.     $index->add($f);
  609.     }
  610.     return $index;
  611. }
  612.  
  613. =back
  614.  
  615. =head1 RANGE SELECTION
  616.  
  617. A range selection is described by a hash reference where
  618. the allowed keys and values are described below.
  619.  
  620. The following options take a version number as value.
  621.  
  622. =over 4
  623.  
  624. =item since
  625.  
  626. Causes changelog information from all versions strictly
  627. later than B<version> to be used.
  628.  
  629. =item until
  630.  
  631. Causes changelog information from all versions strictly
  632. earlier than B<version> to be used.
  633.  
  634. =item from
  635.  
  636. Similar to C<since> but also includes the information for the
  637. specified B<version> itself.
  638.  
  639. =item to
  640.  
  641. Similar to C<until> but also includes the information for the
  642. specified B<version> itself.
  643.  
  644. =back
  645.  
  646. The following options don't take version numbers as values:
  647.  
  648. =over 4
  649.  
  650. =item all
  651.  
  652. If set to a true value, all entries of the changelog are returned,
  653. this overrides all other options.
  654.  
  655. =item count
  656.  
  657. Expects a signed integer as value. Returns C<value> entries from the
  658. top of the changelog if set to a positive integer, and C<abs(value)>
  659. entries from the tail if set to a negative integer.
  660.  
  661. =item offset
  662.  
  663. Expects a signed integer as value. Changes the starting point for
  664. C<count>, either counted from the top (positive integer) or from
  665. the tail (negative integer). C<offset> has no effect if C<count>
  666. wasn't given as well.
  667.  
  668. =back
  669.  
  670. Some examples for the above options. Imagine an example changelog with
  671. entries for the versions 1.2, 1.3, 2.0, 2.1, 2.2, 3.0 and 3.1.
  672.  
  673.             Range                           Included entries
  674.  C<{ since =E<gt> '2.0' }>                  3.1, 3.0, 2.2
  675.  C<{ until =E<gt> '2.0' }>                  1.3, 1.2
  676.  C<{ from =E<gt> '2.0' }>                   3.1, 3.0, 2.2, 2.1, 2.0
  677.  C<{ to =E<gt> '2.0' }>                     2.0, 1.3, 1.2
  678.  C<{ count =E<gt> 2 }>                      3.1, 3.0
  679.  C<{ count =E<gt> -2 }>                        1.3, 1.2
  680.  C<{ count =E<gt> 3, offset=E<gt> 2 }>      2.2, 2.1, 2.0
  681.  C<{ count =E<gt> 2, offset=E<gt> -3 }>     2.0, 1.3
  682.  C<{ count =E<gt> -2, offset=E<gt> 3 }>     3.0, 2.2
  683.  C<{ count =E<gt> -2, offset=E<gt> -3 }>    2.2, 2.1
  684.  
  685. Any combination of one option of C<since> and C<from> and one of
  686. C<until> and C<to> returns the intersection of the two results
  687. with only one of the options specified.
  688.  
  689. =head1 AUTHOR
  690.  
  691. Frank Lichtenheld, E<lt>frank@lichtenheld.deE<gt>
  692. Rapha├½l Hertzog, E<lt>hertzog@debian.orgE<gt>
  693.  
  694. =cut
  695. 1;
  696.