The following commit has been merged in the master branch:
commit 8bec4de4df57cf814169ece1ab555ac2b44ab983
Author: Modestas Vainius <[email protected]>
Date: Wed Feb 3 04:36:03 2010 +0200
Dpkg::Shlibs:* add more abstract methods and clean up API.
* Make SymbolFile::lookup_*(), SymbolFile::find_matching_pattern() accept
both
symbol/pattern objects AND names.
* Make SymbolFile::lookup_*(), SymbolFile::find_matching_pattern() accept
both
single soname and an array of sonames.
* Make SymbolFile::lookup_*(), SymbolFile::find_matching_pattern() detect
context and return either a hash of ( soname => .., symbol => .. ) or
just a
scalar symbol reference. In either case, do NOT clone symbols.
* SymbolFile::get_{new,lost}_symbols() returns an array of { soname =>
.., symbol => .. } hashes where 'symbol' is a real reference, not a clone.
* Add new abstract methods and use them everywhere:
- SymbolFile::get_arch() - architecture the file is processed under/for.
- SymbolFile::get_sonames() - names of all sonames.
- SymbolFile::get_object() - soname object reference by name or object
reference.
- SymbolFile::get_symbols($soname) - if $soname is undef, returns ALL
symbol file symbols.
- SymbolFile::get_patterns($soname) - if $soname is undef, returns ALL
symbol file patterns.
- SymbolFile::get_symbol_object(Ssym, $soname) - a convenience method
combining both SymbolFile::lookup_{symbol,pattern} methods.
* Make SymbolFile::create_symbol() more flexible. Now it can parse a dummy
spec
without minver.
* Remove Symbol::sclone() as no longer used and needed. Rename
Symbol::dclone()
back to Symbol::clone().
diff --git a/scripts/Dpkg/Shlibs/Symbol.pm b/scripts/Dpkg/Shlibs/Symbol.pm
index 337e498..dc3d55f 100644
--- a/scripts/Dpkg/Shlibs/Symbol.pm
+++ b/scripts/Dpkg/Shlibs/Symbol.pm
@@ -45,19 +45,8 @@ sub new {
return $self;
}
-# Shallow clone
-sub sclone {
- my $self = shift;
- my $clone = { %$self };
- if (@_) {
- my %ar...@_;
- $clone->{$_} = $args{$_} foreach keys %args;
- }
- return bless $clone, ref $self;
-}
-
# Deep clone
-sub dclone {
+sub clone {
my $self = shift;
my $clone = Storable::dclone($self);
if (@_) {
@@ -93,7 +82,7 @@ sub parse_tagspec {
}
sub parse {
- my ($self, $symbolspec) = @_;
+ my ($self, $symbolspec, %opts) = @_;
my $symbol;
my $symbol_templ;
my $symbol_quoted;
@@ -135,6 +124,9 @@ sub parse {
if ($rest =~ /^\s(\S+)(?:\s(\d+))?/) {
$self->{minver} = $1;
$self->{dep_id} = defined($2) ? $2 : 0;
+ } elsif (defined $opts{default_minver}) {
+ $self->{minver} = $opts{default_minver};
+ $self->{dep_id} = 0;
} else {
return 0;
}
@@ -354,7 +346,7 @@ sub create_pattern_match {
# Leave out 'pattern' subfield while deep-cloning
my $pattern_stuff = $self->{pattern};
delete $self->{pattern};
- my $newsym = $self->dclone(@_);
+ my $newsym = $self->clone(@_);
$self->{pattern} = $pattern_stuff;
# Clean up symbol name related internal fields
diff --git a/scripts/Dpkg/Shlibs/SymbolFile.pm
b/scripts/Dpkg/Shlibs/SymbolFile.pm
index edc30ab..5dfb77f 100644
--- a/scripts/Dpkg/Shlibs/SymbolFile.pm
+++ b/scripts/Dpkg/Shlibs/SymbolFile.pm
@@ -88,6 +88,11 @@ sub new {
return $self;
}
+sub get_arch {
+ my ($self) = @_;
+ return $self->{arch};
+}
+
sub clear {
my ($self) = @_;
$self->{objects} = {};
@@ -102,13 +107,52 @@ sub clear_except {
}
}
+sub get_sonames {
+ my ($self) = @_;
+ return keys %{$self->{objects}};
+}
+
+sub get_symbols {
+ my ($self, $soname) = @_;
+ if (defined $soname) {
+ my $obj = $self->get_object($soname);
+ return (defined $obj) ? values %{$obj->{syms}} : ();
+ } else {
+ my @syms;
+ foreach my $soname ($self->get_sonames()) {
+ push @syms, $self->get_symbols($soname);
+ }
+ return @syms;
+ }
+}
+
+sub get_patterns {
+ my ($self, $soname) = @_;
+ my @patterns;
+ if (defined $soname) {
+ my $obj = $self->get_object($soname);
+ foreach my $alias (values %{$obj->{patterns}{aliases}}) {
+ push @patterns, values %$alias;
+ }
+ return (@patterns, @{$obj->{patterns}{generic}});
+ } else {
+ foreach my $soname ($self->get_sonames()) {
+ push @patterns, $self->get_patterns($soname);
+ }
+ return @patterns;
+ }
+}
+
# Create a symbol from the supplied string specification.
sub create_symbol {
- my ($self, $spec, $symbol) = @_;
- $symbol = Dpkg::Shlibs::Symbol->new() unless defined $symbol;
-
- if ($symbol->parse($spec)) {
- $symbol->initialize(arch => $self->{arch});
+ my ($self, $spec, %opts) = @_;
+ my $symbol = (exists $opts{base}) ? $opts{base} :
+ Dpkg::Shlibs::Symbol->new();
+
+ my $ret = ($opts{dummy}) ? $symbol->parse($spec, default_minver => 0) :
+ $symbol->parse($spec);
+ if ($ret) {
+ $symbol->initialize(arch => $self->get_arch());
return $symbol;
}
return undef;
@@ -116,7 +160,7 @@ sub create_symbol {
sub add_symbol {
my ($self, $symbol, $soname) = @_;
- my $object = (ref $soname) ? $soname : $self->{objects}{$soname};
+ my $object = $self->get_object($soname);
if ($symbol->is_pattern()) {
if (my $alias_type = $symbol->get_alias_type()) {
@@ -146,7 +190,7 @@ sub load {
sub new_symbol {
my $base = shift || 'Dpkg::Shlibs::Symbol';
- return (ref $base) ? $base->dclone(@_) : $base->new(@_);
+ return (ref $base) ? $base->clone(@_) : $base->new(@_);
}
if (defined($seen)) {
@@ -173,7 +217,7 @@ sub load {
# Symbol specification
my $deprecated = ($1) ? $1 : 0;
my $sym = new_symbol($base_symbol, deprecated => $deprecated);
- if ($self->create_symbol($2, $sym)) {
+ if ($self->create_symbol($2, base => $sym)) {
$self->add_symbol($sym, $$obj_ref);
} else {
warning(_g("Failed to parse line in %s: %s"), $file, $_);
@@ -220,7 +264,7 @@ sub load {
sub merge_object_from_symfile {
my ($self, $src, $objid) = @_;
if (not $self->has_object($objid)) {
- $self->{objects}{$objid} = $src->{objects}{$objid};
+ $self->{objects}{$objid} = $src->get_object($objid);
} else {
warning(_g("Tried to merge the same object (%s) twice in a symfile."),
$objid);
}
@@ -245,8 +289,8 @@ sub dump {
$opts{template_mode} = 0 unless exists $opts{template_mode};
$opts{with_deprecated} = 1 unless exists $opts{with_deprecated};
$opts{with_pattern_matches} = 0 unless exists $opts{with_pattern_matches};
- foreach my $soname (sort keys %{$self->{objects}}) {
- my @deps = @{$self->{objects}{$soname}{deps}};
+ foreach my $soname (sort $self->get_sonames()) {
+ my @deps = $self->get_dependencies($soname);
my $dep = shift @deps;
$dep =~ s/#PACKAGE#/$opts{package}/g if exists $opts{package};
print $fh "$soname $dep\n";
@@ -261,21 +305,20 @@ sub dump {
print $fh "* $field: $value\n";
}
- my $syms = $self->{objects}{$soname}{syms};
my @symbols;
if ($opts{template_mode}) {
# Exclude symbols matching a pattern, but include patterns
themselves
- @symbols = grep { not $_->get_pattern() } values %$syms;
- push @symbols, $self->get_soname_patterns($soname);
+ @symbols = grep { not $_->get_pattern() }
$self->get_symbols($soname);
+ push @symbols, $self->get_patterns($soname);
} else {
- @symbols = values %$syms;
+ @symbols = $self->get_symbols($soname);
}
foreach my $sym (sort { $a->get_symboltempl() cmp
$b->get_symboltempl() } @symbols) {
next if $sym->{deprecated} and not $opts{with_deprecated};
# Do not dump symbols from foreign arch unless dumping a template.
next if not $opts{template_mode} and
- not $sym->arch_is_concerned($self->{arch});
+ not $sym->arch_is_concerned($self->get_arch());
# Dump symbol specification. Dump symbol tags only in template mode.
print $fh $sym->get_symbolspec($opts{template_mode}), "\n";
# Dump pattern matches as comments (if requested)
@@ -293,17 +336,18 @@ sub dump {
# Tries to match a symbol name and/or version against the patterns defined.
# Returns a pattern which matches (if any).
sub find_matching_pattern {
- my ($self, $name, $sonames, $inc_deprecated) = @_;
+ my ($self, $refsym, $sonames, $inc_deprecated) = @_;
$inc_deprecated = 0 unless defined $inc_deprecated;
+ my $name = (ref $refsym) ? $refsym->get_symbolname() : $refsym;
my $pattern_ok = sub {
my $p = shift;
return defined $p && ($inc_deprecated || !$p->{deprecated}) &&
- $p->arch_is_concerned($self->{arch});
+ $p->arch_is_concerned($self->get_arch());
};
- foreach my $soname (@$sonames) {
- my $obj = (ref $soname) ? $soname : $self->{objects}{$soname};
+ foreach my $soname ((ref($sonames) eq 'ARRAY') ? @$sonames : $sonames) {
+ my $obj = $self->get_object($soname);
my ($type, $pattern);
next unless defined $obj;
@@ -332,10 +376,11 @@ sub find_matching_pattern {
}
}
if (defined $pattern) {
- return $pattern;
+ return (wantarray) ?
+ ( symbol => $pattern, soname => $soname ) : $pattern;
}
}
- return undef;
+ return (wantarray) ? () : undef;
}
# merge_symbols($object, $minver)
@@ -349,36 +394,33 @@ sub merge_symbols {
foreach my $sym ($object->get_exported_dynamic_symbols()) {
my $name = $sym->{name} . '@' .
($sym->{version} ? $sym->{version} : "Base");
- my $symobj = $self->lookup_symbol($name, [ $soname ]);
+ my $symobj = $self->lookup_symbol($name, $soname);
if (exists $blacklist{$sym->{name}}) {
next unless (defined $symobj and
$symobj->has_tag("ignore-blacklist"));
}
$dynsyms{$name} = $sym;
}
- unless (exists $self->{objects}{$soname}) {
+ unless ($self->has_object($soname)) {
$self->create_object($soname, '');
}
# Scan all symbols provided by the objects
- my $obj = $self->{objects}{$soname};
- my @obj = ( $obj );
+ my $obj = $self->get_object($soname);
# invalidate the minimum version cache - it is not sufficient to
# invalidate in add_symbol, since we might change a minimum
# version for a particular symbol without adding it
$obj->{minver_cache} = [];
foreach my $name (keys %dynsyms) {
my $sym;
- if (exists $obj->{syms}{$name}) {
+ if ($sym = $self->lookup_symbol($name, $obj, 1)) {
# If the symbol is already listed in the file
- $sym = $obj->{syms}{$name};
- $sym->mark_found_in_library($minver, $self->{arch});
+ $sym->mark_found_in_library($minver, $self->get_arch());
} else {
# The exact symbol is not present in the file, but it might match a
# pattern.
- my $symobj = $dynsyms{$name};
- my $pattern = $self->find_matching_pattern($name, \...@obj, 1);
+ my $pattern = $self->find_matching_pattern($name, $obj, 1);
if (defined $pattern) {
- $pattern->mark_found_in_library($minver, $self->{arch});
+ $pattern->mark_found_in_library($minver, $self->get_arch());
$sym = $pattern->create_pattern_match(symbol => $name);
} else {
# Symbol without any special info as no pattern matched
@@ -390,17 +432,16 @@ sub merge_symbols {
}
# Process all symbols which could not be found in the library.
- foreach my $name (keys %{$self->{objects}{$soname}{syms}}) {
- if (not exists $dynsyms{$name}) {
- my $sym = $self->{objects}{$soname}{syms}{$name};
- $sym->mark_not_found_in_library($minver, $self->{arch});
+ foreach my $sym ($self->get_symbols($soname)) {
+ if (not exists $dynsyms{$sym->get_symbolname()}) {
+ $sym->mark_not_found_in_library($minver, $self->get_arch());
}
}
# Deprecate patterns which didn't match anything
for my $pattern (grep { $_->get_pattern_matches() == 0 }
- $self->get_soname_patterns($soname)) {
- $pattern->mark_not_found_in_library($minver, $self->{arch});
+ $self->get_patterns($soname)) {
+ $pattern->mark_not_found_in_library($minver, $self->get_arch());
}
}
@@ -414,6 +455,11 @@ sub has_object {
return exists $self->{objects}{$soname};
}
+sub get_object {
+ my ($self, $soname) = @_;
+ return ref($soname) ? $soname : $self->{objects}{$soname};
+}
+
sub create_object {
my ($self, $soname, @deps) = @_;
$self->{objects}{$soname} = {
@@ -431,16 +477,16 @@ sub create_object {
sub get_dependency {
my ($self, $soname, $dep_id) = @_;
$dep_id = 0 unless defined($dep_id);
- return $self->{objects}{$soname}{deps}[$dep_id];
+ return $self->get_object($soname)->{deps}[$dep_id];
}
sub get_smallest_version {
my ($self, $soname, $dep_id) = @_;
$dep_id = 0 unless defined($dep_id);
- my $so_object = $self->{objects}{$soname};
+ my $so_object = $self->get_object($soname);
return $so_object->{minver_cache}[$dep_id]
if(defined($so_object->{minver_cache}[$dep_id]));
my $minver;
- foreach my $sym (values %{$so_object->{syms}}) {
+ foreach my $sym ($self->get_symbols($so_object)) {
next if $dep_id != $sym->{dep_id};
$minver = $sym->{minver} unless defined($minver);
if (version_compare($minver, $sym->{minver}) > 0) {
@@ -453,78 +499,83 @@ sub get_smallest_version {
sub get_dependencies {
my ($self, $soname) = @_;
- return @{$self->{objects}{$soname}{deps}};
+ return @{$self->get_object($soname)->{deps}};
}
sub get_field {
my ($self, $soname, $name) = @_;
- if (exists $self->{objects}{$soname}{fields}{$name}) {
- return $self->{objects}{$soname}{fields}{$name};
+ if (my $obj = $self->get_object($soname)) {
+ if (exists $obj->{fields}{$name}) {
+ return $obj->{fields}{$name};
+ }
}
return undef;
}
+# Tries to find a symbol like the $refsym and returns its descriptor.
+# $refsym may also be a symbol name.
sub lookup_symbol {
- my ($self, $name, $sonames, $inc_deprecated) = @_;
+ my ($self, $refsym, $sonames, $inc_deprecated) = @_;
$inc_deprecated = 0 unless defined($inc_deprecated);
- foreach my $so (@{$sonames}) {
- next if (! exists $self->{objects}{$so});
- if (exists $self->{objects}{$so}{syms}{$name} and
- ($inc_deprecated or not
- $self->{objects}{$so}{syms}{$name}{deprecated}))
- {
- my $dep_id = $self->{objects}{$so}{syms}{$name}{dep_id};
- my $clone = $self->{objects}{$so}{syms}{$name}->sclone();
- $clone->{depends} = $self->{objects}{$so}{deps}[$dep_id];
- $clone->{soname} = $so;
- return $clone;
+ my $name = (ref $refsym) ? $refsym->get_symbolname() : $refsym;
+
+ foreach my $so ((ref($sonames) eq 'ARRAY') ? @$sonames : $sonames) {
+ if (my $obj = $self->get_object($so)) {
+ my $sym = $obj->{syms}{$name};
+ if ($sym and ($inc_deprecated or not $sym->{deprecated}))
+ {
+ return (wantarray) ?
+ ( symbol => $sym, soname => $so ) : $sym;
+ }
}
}
- return undef;
+ return (wantarray) ? () : undef;
}
-# Tries to find a pattern like the $refpat and returns it. If not found, undef
-# is returned.
+# Tries to find a pattern like the $refpat and returns its descriptor.
+# $refpat may also be a pattern spec.
sub lookup_pattern {
my ($self, $refpat, $sonames, $inc_deprecated) = @_;
$inc_deprecated = 0 unless defined($inc_deprecated);
-
- foreach my $soname (@$sonames) {
- my $object = (ref $soname) ? $soname : $self->{objects}{$soname};
- my $pat;
-
- next unless defined $object;
- if (my $type = $refpat->get_alias_type()) {
- if (exists $object->{patterns}{aliases}{$type}) {
- $pat =
$object->{patterns}{aliases}{$type}{$refpat->get_symbolname()};
- }
- } elsif ($refpat->get_pattern_type() eq "generic") {
- for my $p (@{$object->{patterns}{generic}}) {
- if (($inc_deprecated || !$p->{deprecated}) &&
- $p->equals($refpat, versioning => 0))
- {
- $pat = $p;
- last;
+ # If $refsym is a string, we need to create a dummy ref symbol.
+ $refpat = $self->create_symbol($refpat, dummy => 1) if ! ref($refpat);
+
+ if ($refpat && $refpat->is_pattern()) {
+ foreach my $soname ((ref($sonames) eq 'ARRAY') ? @$sonames : $sonames) {
+ if (my $obj = $self->get_object($soname)) {
+ my $pat;
+ if (my $type = $refpat->get_alias_type()) {
+ if (exists $obj->{patterns}{aliases}{$type}) {
+ $pat =
$obj->{patterns}{aliases}{$type}{$refpat->get_symbolname()};
+ }
+ } elsif ($refpat->get_pattern_type() eq "generic") {
+ for my $p (@{$obj->{patterns}{generic}}) {
+ if (($inc_deprecated || !$p->{deprecated}) &&
+ $p->equals($refpat, versioning => 0))
+ {
+ $pat = $p;
+ last;
+ }
+ }
+ }
+ if ($pat && ($inc_deprecated || !$pat->{deprecated})) {
+ return (wantarray) ?
+ (symbol => $pat, soname => $soname) : $pat;
}
}
}
- if ($pat && ($inc_deprecated || !$pat->{deprecated})) {
- return $pat;
- }
}
- return undef;
+ return (wantarray) ? () : undef;
}
-# Collects all patterns of the given soname and returns them as an array.
-sub get_soname_patterns {
- my ($self, $soname) = @_;
- my $object = (ref $soname) ? $soname : $self->{objects}{$soname};
- my @aliases;
-
- foreach my $alias (values %{$object->{patterns}{aliases}}) {
- push @aliases, values %$alias;
+# Get symbol object reference either by symbol name or by a reference object.
+sub get_symbol_object {
+ my ($self, $refsym, $soname) = @_;
+ my $sym = $self->lookup_symbol($refsym, $soname, 1);
+ if (! defined $sym) {
+ $sym = $self->lookup_pattern($refsym, $soname, 1);
}
- return (@aliases, @{$object->{patterns}{generic}});
+ return $sym;
}
sub get_new_symbols {
@@ -532,23 +583,20 @@ sub get_new_symbols {
my $with_optional = (exists $opts{with_optional}) ?
$opts{with_optional} : 0;
my @res;
- foreach my $soname (keys %{$self->{objects}}) {
- my $mysyms = $self->{objects}{$soname}{syms};
- next if not exists $ref->{objects}{$soname};
- my $refsyms = $ref->{objects}{$soname}{syms};
- my @soname = ( $soname );
+ foreach my $soname ($self->get_sonames()) {
+ next if not $ref->has_object($soname);
# Scan raw symbols first.
foreach my $sym (grep { ($with_optional || ! $_->is_optional())
- && $_->is_legitimate($self->{arch}) }
- values %$mysyms)
+ && $_->is_legitimate($self->get_arch()) }
+ $self->get_symbols($soname))
{
- my $refsym = $refsyms->{$sym->get_symbolname()};
+ my $refsym = $ref->lookup_symbol($sym, $soname, 1);
my $isnew;
if (defined $refsym) {
# If the symbol exists in the $ref symbol file, it might
# still be new if $refsym is not legitimate.
- $isnew = not $refsym->is_legitimate($self->{arch});
+ $isnew = not $refsym->is_legitimate($self->get_arch());
} else {
# If the symbol does not exist in the $ref symbol file, it does
# not mean that it's new. It might still match a pattern in the
@@ -556,25 +604,25 @@ sub get_new_symbols {
# if the pattern that the symbol matches (if any) exists in the
# ref symbol file as well.
$isnew = not (
- ($sym->get_pattern() and
$ref->lookup_pattern($sym->get_pattern(), \...@soname, 1)) or
- $ref->find_matching_pattern($sym->get_symbolname(),
\...@soname, 1)
+ ($sym->get_pattern() and
$ref->lookup_pattern($sym->get_pattern(), $soname, 1)) or
+ $ref->find_matching_pattern($sym, $soname, 1)
);
}
- push @res, $sym->sclone(soname => $soname) if $isnew;
+ push @res, { symbol => $sym, soname => $soname } if $isnew;
}
# Now scan patterns
foreach my $p (grep { ($with_optional || ! $_->is_optional())
- && $_->is_legitimate($self->{arch}) }
- $self->get_soname_patterns($soname))
+ && $_->is_legitimate($self->get_arch()) }
+ $self->get_patterns($soname))
{
- my $refpat = $ref->lookup_pattern($p, \...@soname, 0);
+ my $refpat = $ref->lookup_pattern($p, $soname, 0);
# If reference pattern was not found or it is not legitimate,
# considering current one as new.
if (not defined $refpat or
- not $refpat->is_legitimate($self->{arch}))
+ not $refpat->is_legitimate($self->get_arch()))
{
- push @res, $p->sclone(soname => $soname);
+ push @res, { symbol => $p , soname => $soname };
}
}
}
@@ -590,8 +638,8 @@ sub get_lost_symbols {
sub get_new_libs {
my ($self, $ref) = @_;
my @res;
- foreach my $soname (keys %{$self->{objects}}) {
- push @res, $soname if not exists $ref->{objects}{$soname};
+ foreach my $soname ($self->get_sonames()) {
+ push @res, $soname if not $ref->get_object($soname);
}
return @res;
}
diff --git a/scripts/dpkg-gensymbols.pl b/scripts/dpkg-gensymbols.pl
index 98bdfff..14b561a 100755
--- a/scripts/dpkg-gensymbols.pl
+++ b/scripts/dpkg-gensymbols.pl
@@ -260,7 +260,7 @@ if ($compare) {
_g("see diff output below"));
$exitcode = 2 if ($compare >= 2);
}
- if (my @syms = $symfile->get_lost_symbols($ref_symfile)) {
+ if ($symfile->get_lost_symbols($ref_symfile)) {
warning(_g("some symbols or patterns disappeared in the symbols file:
%s"),
_g("see diff output below"));
$exitcode = 1 if ($compare >= 1);
diff --git a/scripts/dpkg-shlibdeps.pl b/scripts/dpkg-shlibdeps.pl
index 016d454..084fb48 100755
--- a/scripts/dpkg-shlibdeps.pl
+++ b/scripts/dpkg-shlibdeps.pl
@@ -320,19 +320,20 @@ foreach my $file (keys %exec) {
$name .= "\...@base";
}
print " Looking up symbol $name\n" if $debug > 1;
- my $symdep = $symfile->lookup_symbol($name, \...@sonames);
- if (defined($symdep)) {
- print " Found in symbols file of $symdep->{soname} (minver: " .
- "$symdep->{minver}, dep: $symdep->{depends})\n" if $debug >
1;
- $soname_used{$symdep->{soname}}++;
- $global_soname_used{$symdep->{soname}}++;
- if (exists $alt_soname{$symdep->{soname}}) {
+ my %symdep = $symfile->lookup_symbol($name, \...@sonames);
+ if (keys %symdep) {
+ my $depends = $symfile->get_dependency($symdep{soname},
+ $symdep{symbol}{dep_id});
+ print " Found in symbols file of $symdep{soname} (minver: " .
+ "$symdep{symbol}{minver}, dep: $depends)\n" if $debug > 1;
+ $soname_used{$symdep{soname}}++;
+ $global_soname_used{$symdep{soname}}++;
+ if (exists $alt_soname{$symdep{soname}}) {
# Also count usage on alternate soname
- $soname_used{$alt_soname{$symdep->{soname}}}++;
- $global_soname_used{$alt_soname{$symdep->{soname}}}++;
+ $soname_used{$alt_soname{$symdep{soname}}}++;
+ $global_soname_used{$alt_soname{$symdep{soname}}}++;
}
- update_dependency_version($symdep->{depends},
- $symdep->{minver});
+ update_dependency_version($depends, $symdep{symbol}{minver});
} else {
my $syminfo = $dumplibs_wo_symfile->locate_symbol($name);
if (not defined($syminfo)) {
diff --git a/scripts/t/200_Dpkg_Shlibs.t b/scripts/t/200_Dpkg_Shlibs.t
index 207481f..d634e74 100644
--- a/scripts/t/200_Dpkg_Shlibs.t
+++ b/scripts/t/200_Dpkg_Shlibs.t
@@ -22,7 +22,9 @@ use warnings;
use_ok('Dpkg::Shlibs');
+my $tmp;
my @tmp;
+my %tmp;
my @save_paths = @Dpkg::Shlibs::librarypaths;
@Dpkg::Shlibs::librarypaths = ();
@@ -137,23 +139,22 @@ ok( $sym_file_old->get_lost_symbols($sym_file), 'has lost
symbols' );
is( $sym_file_old->lookup_symbol('__bss_st...@base', ['libc.so.6']),
undef, 'internal symbols are blacklisted' );
-$sym = $sym_file->lookup_symbol('_er...@glibc_2.0', ['libc.so.6'], 1);
-isa_ok($sym, 'Dpkg::Shlibs::Symbol');
-is_deeply($sym, Dpkg::Shlibs::Symbol->new( 'symbol' => '_er...@glibc_2.0',
+%tmp = $sym_file->lookup_symbol('_er...@glibc_2.0', ['libc.so.6'], 1);
+isa_ok($tmp{symbol}, 'Dpkg::Shlibs::Symbol');
+is_deeply(\%tmp, { symbol => Dpkg::Shlibs::Symbol->new( 'symbol' =>
'_er...@glibc_2.0',
'minver' => '2.3.6.ds1-13', 'dep_id' => 0,
- 'deprecated' => '2.6-1', 'depends' => '',
- 'soname' => 'libc.so.6' ), 'deprecated symbol');
+ 'deprecated' => '2.6-1'), 'soname' => 'libc.so.6' },
+ 'deprecated symbol');
# Wildcard test
my $pat = $sym_file_old->create_symbol('*...@glibc_private 2.3.6.wildcard');
$sym_file_old->add_symbol($pat, 'libc.so.6');
$sym_file_old->merge_symbols($obj, "2.6-1");
-$sym = $sym_file_old->lookup_symbol('__nss_services_loo...@glibc_private',
['libc.so.6']);
+$sym = $sym_file_old->lookup_symbol('__nss_services_loo...@glibc_private',
'libc.so.6');
is_deeply($sym, Dpkg::Shlibs::Symbol->new( 'symbol' =>
'__nss_services_loo...@glibc_private',
- 'minver' => '2.3.6.wildcard', 'dep_id' => 0,
- 'deprecated' => 0, 'depends' => '',
+ 'minver' => '2.3.6.wildcard', 'dep_id' => 0, 'deprecated' =>
0,
'tags' => { 'symver' => undef, optional => undef },
'tagorder' => [ 'symver', 'optional' ],
- 'soname' => 'libc.so.6', 'matching_pattern' => $pat ),
'wildcarded symbol');
+ 'matching_pattern' => $pat ), 'wildcarded symbol');
# Save -> Load test
use File::Temp;
@@ -183,26 +184,22 @@ $sym_file = Dpkg::Shlibs::SymbolFile->new(file =>
"$datadir/symbols.include-1");
$sym = $sym_file->lookup_symbol('symbol_bef...@base', ['libfake.so.1']);
is_deeply($sym, Dpkg::Shlibs::Symbol->new( 'symbol' => 'symbol_bef...@base',
- 'minver' => '0.9', 'dep_id' => 0, 'deprecated' => 0,
- 'depends' => 'libfake1 #MINVER#', 'soname' => 'libfake.so.1'
),
+ 'minver' => '0.9', 'dep_id' => 0, 'deprecated' => 0 ),
'symbol before include not lost');
$sym = $sym_file->lookup_symbol('symbol_af...@base', ['libfake.so.1']);
is_deeply($sym, Dpkg::Shlibs::Symbol->new( 'symbol' => 'symbol_af...@base',
- 'minver' => '1.1', 'dep_id' => 0, 'deprecated' => 0,
- 'depends' => 'libfake1 #MINVER#', 'soname' => 'libfake.so.1'
),
+ 'minver' => '1.1', 'dep_id' => 0, 'deprecated' => 0 ),
'symbol after include not lost');
$sym = $sym_file->lookup_symbol('symbol1_fa...@base', ['libfake.so.1']);
is_deeply($sym, Dpkg::Shlibs::Symbol->new( 'symbol' => 'symbol1_fa...@base',
- 'minver' => '1.0', 'dep_id' => 0, 'deprecated' => 0,
- 'depends' => 'libfake1 #MINVER#', 'soname' => 'libfake.so.1'
),
+ 'minver' => '1.0', 'dep_id' => 0, 'deprecated' => 0 ),
'overrides order with #include');
$sym = $sym_file->lookup_symbol('symbol3_fa...@base', ['libfake.so.1']);
is_deeply($sym, Dpkg::Shlibs::Symbol->new ( 'symbol' => 'symbol3_fa...@base',
- 'minver' => '0', 'dep_id' => 0, 'deprecated' => 0,
- 'depends' => 'libfake1 #MINVER#', 'soname' => 'libfake.so.1'
),
+ 'minver' => '0', 'dep_id' => 0, 'deprecated' => 0 ),
'overrides order with #include');
is($sym_file->get_smallest_version('libfake.so.1'), "0",
@@ -210,16 +207,14 @@ is($sym_file->get_smallest_version('libfake.so.1'), "0",
$sym = $sym_file->lookup_symbol('symbol_in_libdiv...@base',
['libdivert.so.1']);
is_deeply($sym, Dpkg::Shlibs::Symbol->new ( 'symbol' =>
'symbol_in_libdiv...@base',
- 'minver' => '1.0~beta1', 'dep_id' => 0, 'deprecated' => 0,
- 'depends' => 'libdivert1 #MINVER#', 'soname' =>
'libdivert.so.1'),
+ 'minver' => '1.0~beta1', 'dep_id' => 0, 'deprecated' => 0 ),
'#include can change current object');
$sym_file = Dpkg::Shlibs::SymbolFile->new(file =>
"$datadir/symbols.include-2");
$sym = $sym_file->lookup_symbol('symbol1_fa...@base', ['libfake.so.1']);
is_deeply($sym, Dpkg::Shlibs::Symbol->new ( 'symbol' => 'symbol1_fa...@base',
- 'minver' => '1.0', 'dep_id' => 1, 'deprecated' => 0,
- 'depends' => 'libvirtualfake', 'soname' => 'libfake.so.1' ),
+ 'minver' => '1.0', 'dep_id' => 1, 'deprecated' => 0 ),
'overrides order with circular #include');
is($sym_file->get_smallest_version('libfake.so.1'), "1.0",
@@ -317,7 +312,6 @@ $sym_file->merge_symbols($tags_obj_i386, '100.MISSING');
$sym = $sym_file->lookup_symbol('symbol11_optio...@base',
['libbasictags.so.1'], 1);
is_deeply($sym, Dpkg::Shlibs::Symbol->new( 'symbol' =>
'symbol11_optio...@base', 'symbol_templ' => 'symbol11_optio...@base',
'minver' => '1.1', 'dep_id' => 1, 'deprecated' =>
'100.MISSING',
- 'depends' => 'libbasictags1 (>= 1.1)', 'soname' =>
'libbasictags.so.1',
'tags' => { 'optional' => undef }, 'tagorder' => [ 'optional'
] ),
'disappered optional symbol gets deprecated');
@@ -325,7 +319,6 @@ $sym_file->merge_symbols($tags_obj_i386, '101.MISSING');
$sym = $sym_file->lookup_symbol('symbol11_optio...@base',
['libbasictags.so.1'], 1);
is_deeply($sym, Dpkg::Shlibs::Symbol->new( 'symbol' =>
'symbol11_optio...@base', 'symbol_templ' => 'symbol11_optio...@base',
'minver' => '1.1', 'dep_id' => 1, 'deprecated' =>
'101.MISSING',
- 'depends' => 'libbasictags1 (>= 1.1)', 'soname' =>
'libbasictags.so.1',
'tags' => { 'optional' => undef }, 'tagorder' => [ 'optional'
] ),
'deprecated text of MISSING optional symbol gets rebumped each
merge');
@@ -337,7 +330,6 @@ $sym_file->merge_symbols($tags_obj_i386, '100.MISSING');
$sym = $sym_file->lookup_symbol('symbol11_optio...@base',
['libbasictags.so.1']);
is_deeply($sym, Dpkg::Shlibs::Symbol->new( 'symbol' =>
'symbol11_optio...@base', 'symbol_templ' => 'symbol11_optio...@base',
'minver' => '1.1', 'dep_id' => 1, 'deprecated' => 0,
- 'depends' => 'libbasictags1 (>= 1.1)', 'soname' =>
'libbasictags.so.1',
'tags' => { 'optional' => undef }, 'tagorder' => [ 'optional'
] ),
'reappered optional symbol gets undeprecated + minver');
is( scalar($sym_file->get_lost_symbols($sym_file_dup) +
@@ -350,10 +342,9 @@ $tags_obj_i386->add_dynamic_symbol($symbol21);
$sym_file->merge_symbols($tags_obj_i386, '100.MISSING');
$sym = $sym_file->lookup_symbol('symbol21_am...@base', ['libbasictags.so.1']);
is_deeply($sym, Dpkg::Shlibs::Symbol->new( 'symbol' => 'symbol21_am...@base',
'symbol_templ' => 'symbol21_am...@base',
- 'symbol_quoted' => "'", 'minver' => '2.1', 'dep_id' => 0,
'deprecated' => 0,
- 'depends' => 'libbasictags1 #MINVER#', 'soname' =>
'libbasictags.so.1' ),
+ 'symbol_quoted' => "'", 'minver' => '2.1', 'dep_id' => 0,
'deprecated' => 0 ),
'symbol appears on foreign arch, arch tag should be removed');
-...@tmp = map { $_->get_symbolname() }
$sym_file->get_new_symbols($sym_file_dup);
+...@tmp = map { $_->{symbol}->get_symbolname() }
$sym_file->get_new_symbols($sym_file_dup);
is_deeply( \...@tmp, [ 'symbol21_am...@base' ], "symbol from foreign arch is
NEW");
is( $sym->get_symbolspec(1), ' symbol21_am...@base 2.1', 'no tags => no quotes
in the symbol name' );
@@ -365,50 +356,43 @@ $sym_file->merge_symbols($tags_obj_i386, '100.MISSING');
$sym = $sym_file->lookup_symbol('symbol22_i...@base', ['libbasictags.so.1'],
1);
is_deeply($sym, Dpkg::Shlibs::Symbol->new( 'symbol' => 'symbol22_i...@base',
'symbol_templ' => 'symbol22_i...@base',
'minver' => '2.2', 'dep_id' => 0, 'deprecated' =>
'100.MISSING',
- 'depends' => 'libbasictags1 #MINVER#', 'soname' =>
'libbasictags.so.1',
'tags' => { 'arch' => '!amd64 !ia64 !alpha' }, 'tagorder' =>
[ 'arch' ] ),
'disappeared arch specific symbol gets deprecated');
$sym = $sym_file->lookup_symbol('symbol41_i386_and_optio...@base',
['libbasictags.so.1'], 1);
is_deeply($sym, Dpkg::Shlibs::Symbol->new( 'symbol' =>
'symbol41_i386_and_optio...@base',
'symbol_templ' => 'symbol41_i386_and_optio...@base',
'symbol_quoted' => '"',
'minver' => '4.1', 'dep_id' => 0, 'deprecated' =>
'100.MISSING',
- 'depends' => 'libbasictags1 #MINVER#', 'soname' =>
'libbasictags.so.1',
'tags' => { 'arch' => 'i386', 'optional' => 'reason' },
'tagorder' => [ 'arch', 'optional' ] ),
'disappeared optional arch specific symbol gets deprecated');
-...@tmp = map { $_->get_symbolname() }
$sym_file->get_lost_symbols($sym_file_dup);
+...@tmp = map { $_->{symbol}->get_symbolname() }
$sym_file->get_lost_symbols($sym_file_dup);
is_deeply( \...@tmp, [ 'symbol22_i...@base' ], "missing arch specific is LOST,
but optional arch specific isn't");
# Tests for tagged #includes
$sym_file = Dpkg::Shlibs::SymbolFile->new(file =>
"$datadir/symbols.include-3", arch => 'i386');
$sym = $sym_file->lookup_symbol('symbol2_fa...@base', ['libbasictags.so.2']);
is_deeply($sym, Dpkg::Shlibs::Symbol->new( 'symbol' => 'symbol2_fa...@base',
- 'minver' => '1.0', 'depends' => 'libbasictags2', 'soname' =>
'libbasictags.so.2',
- 'tags' => { 'optional' => undef, 'random tag' => 'random
value' },
+ 'minver' => '1.0', 'tags' => { 'optional' => undef, 'random
tag' => 'random value' },
'tagorder' => [ 'optional', 'random tag' ] ),
'symbols from #included file inherits tags');
$sym = $sym_file->lookup_symbol('symbol41_i386_and_optio...@base',
['libbasictags.so.1']);
is_deeply($sym, Dpkg::Shlibs::Symbol->new( 'symbol' =>
'symbol41_i386_and_optio...@base',
'symbol_templ' => 'symbol41_i386_and_optio...@base',
symbol_quoted => '"',
- 'minver' => '4.1', 'depends' => 'libbasictags1 #MINVER#',
'soname' => 'libbasictags.so.1',
- 'tags' => { 'optional' => 'reason', 't' => 'v', 'arch' =>
'i386' },
+ 'minver' => '4.1', 'tags' => { 'optional' => 'reason', 't' =>
'v', 'arch' => 'i386' },
'tagorder' => [ 'optional', 't', 'arch' ] ),
'symbols in #included file can override tag values');
$sym = $sym_file->lookup_symbol('symbol51_untag...@base',
['libbasictags.so.1']);
is_deeply($sym, Dpkg::Shlibs::Symbol->new( 'symbol' =>
'symbol51_untag...@base',
- 'minver' => '5.1', 'depends' => 'libbasictags1 #MINVER#',
'soname' => 'libbasictags.so.1',
- 'tags' => { 'optional' => 'from parent', 't' => 'v' },
+ 'minver' => '5.1', 'tags' => { 'optional' => 'from parent',
't' => 'v' },
'tagorder' => [ 'optional', 't' ] ),
'symbols are properly cloned when #including');
-# Test Symbol::sclone() and Symbol::dclone()
+# Test Symbol::clone()
$sym = Dpkg::Shlibs::Symbol->new(symbol => 'foobar', testfield => 1,
teststruct => { 'foo' => 1 });
-...@tmp = ( $sym->sclone(), $sym->dclone() );
-$tmp[0]->{teststruct}{foo} = 2;
-$tmp[0]->{testfield} = 2;
-$tmp[1]->{teststruct}{foo} = 3;
-$tmp[1]->{testfield} = 3;
-is ( $sym->{teststruct}{foo}, 2, 'struct changed via sclone()' );
-is ( $sym->{testfield}, 1, 'original field not changed' );
+$tmp = $sym->clone();
+$tmp->{teststruct}{foo} = 3;
+$tmp->{testfield} = 3;
+is ( $sym->{teststruct}{foo}, 1, 'original field "foo" not changed' );
+is ( $sym->{testfield}, 1, 'original field "testfield" not changed' );
############ Test symbol patterns ###########
sub load_patterns_obj {
@@ -431,7 +415,7 @@ load_patterns_symbols();
save_load_test($sym_file, 'save -> load test of patterns template',
template_mode => 1);
-isnt( $sym_file->get_soname_patterns('libpatterns.so.1') , 0,
+isnt( $sym_file->get_patterns('libpatterns.so.1') , 0,
"patterns.symbols has patterns" );
$sym_file->merge_symbols($obj, '100.MISSING');
@@ -442,17 +426,17 @@ is_deeply( \...@tmp, [], "no LOST symbols if all patterns
matched." );
is_deeply( \...@tmp, [], "no NEW symbols if all patterns matched." );
# Pattern resolution order: aliases (c++, symver), generic
-$sym = $sym_file->lookup_symbol('symve...@symver_1',['libpatterns.so.1']);
+$sym = $sym_file->lookup_symbol('symve...@symver_1','libpatterns.so.1');
is ( $sym->{minver}, '1', "specific SYMVER_1 symbol" );
-$sym = $sym_file->lookup_symbol('_zn3nsb6symver14symver_method...@symver_1',
['libpatterns.so.1']);
+$sym = $sym_file->lookup_symbol('_zn3nsb6symver14symver_method...@symver_1',
'libpatterns.so.1');
is ( $sym->{minver}, '1.method1', "specific symbol prefered over pattern" );
-$sym = $sym_file->lookup_symbol('_zn3nsb6symver14symver_method...@symver_1',
['libpatterns.so.1']);
+$sym = $sym_file->lookup_symbol('_zn3nsb6symver14symver_method...@symver_1',
'libpatterns.so.1');
is ( $sym->{minver}, '1.method2', "c++ alias pattern preferred over generic
pattern" );
is ( $sym->get_pattern()->get_symbolname(),
'NSB::Symver::symver_method2()@SYMVER_1' );
-$sym = $sym_file->lookup_symbol('_zn3nsb6symverd...@symver_1',
['libpatterns.so.1']);
+$sym = $sym_file->lookup_symbol('_zn3nsb6symverd...@symver_1',
'libpatterns.so.1');
is ( $sym->{minver}, '1.generic', 'generic (c++ & symver) pattern covers the
rest (destructor)' );
ok (
$sym->get_pattern()->equals($sym_file->create_symbol('(c++|symver)SYMVER_1
1.generic')) );
@@ -463,7 +447,7 @@ ok ( $sym->is_optional(), "Old style wildcard is optional");
is ( $sym->get_alias_type(), "symver", "old style wildcard is a symver
pattern" );
is ( $sym->get_symbolname(), 'SYMVEROPT_2', "wildcard pattern got renamed" );
-$pat =
$sym_file->lookup_pattern($sym_file->create_symbol('(symver|optional)SYMVEROPT_2
2'), ['libpatterns.so.1']);
+$pat = $sym_file->lookup_pattern('(symver|optional)SYMVEROPT_2',
'libpatterns.so.1');
$sym->{symbol_templ} = $pat->{symbol_templ};
is_deeply( $pat, $sym, "old style wildcard is the same as (symver|optional)" );
@@ -475,14 +459,14 @@ $sym_file->merge_symbols($obj, '100.MISSING');
is_deeply ( [ map { $_->get_symbolname() } $pat->get_pattern_matches() ],
[], "old style wildcard matches nothing.");
is ( $pat->{deprecated}, '100.MISSING', "old style wildcard gets deprecated."
);
-...@tmp = map { $_->get_symbolname() }
$sym_file->get_lost_symbols($sym_file_dup);
+...@tmp = map { $_->{symbol}->get_symbolname() }
$sym_file->get_lost_symbols($sym_file_dup);
is_deeply( \...@tmp, [], "but old style wildcard is not LOST." );
# 'Internal' pattern covers all internal symbols
load_patterns_obj();
-...@tmp = grep { $_->get_symbolname() =~ /Internal/ } values
%{$sym_file->{objects}{'libpatterns.so.1'}{syms}};
+...@tmp = grep { $_->get_symbolname() =~ /Internal/ }
$sym_file->get_symbols('libpatterns.so.1');
$sym =
$sym_file->create_symbol('(regex|c++)^_Z(T[ISV])?n3nsa6classa8interna...@base$
1.internal'),
-$pat = $sym_file->lookup_pattern($sym, ['libpatterns.so.1']);
+$pat = $sym_file->lookup_pattern($sym, 'libpatterns.so.1');
is_deeply ([ sort $pat->get_pattern_matches() ], [ sort @tmp ],
"Pattern covers all internal symbols");
is ( $tmp[0]->{minver}, '1.internal' );
@@ -501,13 +485,13 @@ my @private_symnames = sort qw(
_ztvn3nsa6classa7priva...@base
);
$sym =
$sym_file->create_symbol('(c++|regex|optional)NSA::ClassA::Private(::.*)?...@base
1');
-$pat = $sym_file->lookup_pattern($sym, ['libpatterns.so.1']);
+$pat = $sym_file->lookup_pattern($sym, 'libpatterns.so.1');
isnt( $pat, undef, 'pattern for private class has been found' );
is_deeply( [ sort map { $_->get_symbolname() } $pat->get_pattern_matches() ],
\...@private_symnames, "private pattern matched expected symbols" );
ok( ($pat->get_pattern_matches())[0]->is_optional(),
"private symbol is optional like its pattern" );
-ok(
$sym_file->lookup_symbol(($pat->get_pattern_matches())[0]->get_symbolname(),
['libpatterns.so.1']),
+ok( $sym_file->lookup_symbol(($pat->get_pattern_matches())[0],
'libpatterns.so.1'),
"lookup_symbol() finds symbols matched by pattern (after merge)"),
# Get rid of a private symbol, it should not be lost
@@ -515,8 +499,8 @@ delete $obj->{dynsyms}{$private_symnames[0]};
load_patterns_symbols();
$sym_file->merge_symbols($obj, '100.MISSING');
-$pat = $sym_file->lookup_pattern($sym, ['libpatterns.so.1']);
-...@tmp = map { $_->get_symbolname() }
$sym_file->get_lost_symbols($sym_file_dup);
+$pat = $sym_file->lookup_pattern($sym, 'libpatterns.so.1');
+...@tmp = map { $_->{symbol}->get_symbolname() }
$sym_file->get_lost_symbols($sym_file_dup);
is_deeply( \...@tmp, [], "no LOST symbols when got rid of patterned optional
symbol." );
ok( ! $pat->{deprecated} , "there are still matches, pattern is not
deprecated." );
@@ -527,7 +511,7 @@ foreach my $tmp (@private_symnames) {
load_patterns_symbols();
$sym_file->merge_symbols($obj, '100.MISSING');
-$pat = $sym_file->lookup_pattern($sym, ['libpatterns.so.1'], 1);
+$pat = $sym_file->lookup_pattern($sym, 'libpatterns.so.1', 1);
@tmp = $sym_file->get_lost_symbols($sym_file_dup);
is_deeply( \...@tmp, [ ],
"All private symbols gone, but pattern is not LOST because it is
optional." );
@@ -537,14 +521,14 @@ is( $pat->{deprecated}, '100.MISSING',
# Internal symbols. All covered by the pattern?
@tmp = grep { $_->get_symbolname() =~ /Internal/ } values
%{$sym_file->{objects}{'libpatterns.so.1'}{syms}};
$sym =
$sym_file->create_symbol('(regex|c++)^_Z(T[ISV])?n3nsa6classa8interna...@base$
1.internal'),
-$pat = $sym_file->lookup_pattern($sym, ['libpatterns.so.1']);
+$pat = $sym_file->lookup_pattern($sym, 'libpatterns.so.1');
is_deeply ([ sort $pat->get_pattern_matches() ], [ sort @tmp ],
"Pattern covers all internal symbols");
is ( $tmp[0]->{minver}, '1.internal' );
# Delete matches of the non-optional pattern
$sym = $sym_file->create_symbol('(c++)"non-virtual thunk to
NSB::ClassD::generate_vt(char const*) co...@base" 1');
-$pat = $sym_file->lookup_pattern($sym, ['libpatterns.so.1']);
+$pat = $sym_file->lookup_pattern($sym, 'libpatterns.so.1');
isnt( $pat, undef, 'lookup_pattern() finds alias-based pattern' );
is( scalar($pat->get_pattern_matches()), 2, "two matches for the generate_vt
pattern" );
@@ -554,8 +538,8 @@ foreach my $tmp ($pat->get_pattern_matches()) {
load_patterns_symbols();
$sym_file->merge_symbols($obj, '100.MISSING');
-$pat = $sym_file->lookup_pattern($sym, ['libpatterns.so.1'], 1);
-...@tmp = map { $sym_file->lookup_pattern($_, ['libpatterns.so.1'], 1) }
+$pat = $sym_file->lookup_pattern($sym, 'libpatterns.so.1', 1);
+...@tmp = map { scalar $sym_file->lookup_pattern($_->{symbol},
'libpatterns.so.1', 1) }
$sym_file->get_lost_symbols($sym_file_dup);
is_deeply( \...@tmp, [ $pat ], "No matches - generate_vt() pattern is LOST." );
is( $pat->{deprecated}, '100.MISSING',
@@ -565,9 +549,9 @@ is( $pat->{deprecated}, '100.MISSING',
load_patterns_obj();
load_patterns_symbols();
-$pat = $sym_file_dup->lookup_pattern($sym, ['libpatterns.so.1']);
+$pat = $sym_file_dup->lookup_pattern($sym, 'libpatterns.so.1');
$pat->{deprecated} = '0.1-1';
-$pat = $sym_file->lookup_pattern($sym, ['libpatterns.so.1']);
+$pat = $sym_file->lookup_pattern($sym, 'libpatterns.so.1');
$pat->{deprecated} = '0.1-1';
$sym_file->merge_symbols($obj, '100.FOUND');
@@ -575,7 +559,7 @@ ok( ! $pat->{deprecated},
"Previously deprecated pattern with matches got undeprecated" );
is( $pat->{minver}, '100.FOUND',
"Previously deprecated pattern with matches got minver bumped" );
-...@tmp = map { $_->get_symbolspec(1) }
$sym_file->get_new_symbols($sym_file_dup);
+...@tmp = map { $_->{symbol}->get_symbolspec(1) }
$sym_file->get_new_symbols($sym_file_dup);
is_deeply( \...@tmp, [ $pat->get_symbolspec(1) ],
"Previously deprecated pattern with matches is NEW. Matches themselves are
not NEW." );
foreach my $sym ($pat->get_pattern_matches()) {
--
dpkg's main repository
--
To UNSUBSCRIBE, email to [email protected]
with a subject of "unsubscribe". Trouble? Contact [email protected]
