Revert of Linux build: Use sysroot when calculating dependencies

third_party/dpkg-dev/scripts/Dpkg/Control/HashCore.pm

Index: third_party/dpkg-dev/scripts/Dpkg/Control/HashCore.pm
diff --git a/third_party/dpkg-dev/scripts/Dpkg/Control/HashCore.pm b/third_party/dpkg-dev/scripts/Dpkg/Control/HashCore.pm
deleted file mode 100644
index e2ceb66d5c66b1e839f4eddcdafdcb0741351ce7..0000000000000000000000000000000000000000
--- a/third_party/dpkg-dev/scripts/Dpkg/Control/HashCore.pm
+++ /dev/null
@@ -1,540 +0,0 @@
-# Copyright © 2007-2009 Raphaël Hertzog <hertzog@debian.org>
-#
-# 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 <https://www.gnu.org/licenses/>.
-
-package Dpkg::Control::HashCore;
-
-use strict;
-use warnings;
-
-our $VERSION = '1.01';
-
-use Dpkg::Gettext;
-use Dpkg::ErrorHandling;
-use Dpkg::Control::FieldsCore;
-
-# This module cannot use Dpkg::Control::Fields, because that one makes use
-# of Dpkg::Vendor which at the same time uses this module, which would turn
-# into a compilation error. We can use Dpkg::Control::FieldsCore instead.
-
-use parent qw(Dpkg::Interface::Storable);
-
-use overload
-    '%{}' => sub { ${$_[0]}->{fields} },
-    'eq' => sub { "$_[0]" eq "$_[1]" };
-
-=encoding utf8
-
-=head1 NAME
-
-Dpkg::Control::HashCore - parse and manipulate a block of RFC822-like fields
-
-=head1 DESCRIPTION
-
-The Dpkg::Control::Hash object is a hash-like representation of a set of
-RFC822-like fields. The fields names are case insensitive and are always
-capitalized the same when output (see field_capitalize function in
-Dpkg::Control::Fields).
-The order in which fields have been set is remembered and is used
-to be able to dump back the same content. The output order can also be
-overridden if needed.
-
-You can store arbitrary values in the hash, they will always be properly
-escaped in the output to conform to the syntax of control files. This is
-relevant mainly for multilines values: while the first line is always output
-unchanged directly after the field name, supplementary lines are
-modified. Empty lines and lines containing only dots are prefixed with
-" ." (space + dot) while other lines are prefixed with a single space.
-
-During parsing, trailing spaces are stripped on all lines while leading
-spaces are stripped only on the first line of each field.
-
-=head1 FUNCTIONS
-
-=over 4
-
-=item my $c = Dpkg::Control::Hash->new(%opts)
-
-Creates a new object with the indicated options. Supported options
-are:
-
-=over 8
-
-=item allow_pgp
-
-Configures the parser to accept PGP signatures around the control
-information. Value can be 0 (default) or 1.
-
-=item allow_duplicate
-
-Configures the parser to allow duplicate fields in the control
-information. Value can be 0 (default) or 1.
-
-=item drop_empty
-
-Defines if empty fields are dropped during the output. Value can be 0
-(default) or 1.
-
-=item name
-
-The user friendly name of the information stored in the object. It might
-be used in some error messages or warnings. A default name might be set
-depending on the type.
-
-=back
-
-=cut
-
-sub new {
-    my ($this, %opts) = @_;
-    my $class = ref($this) || $this;
-
-    # Object is a scalar reference and not a hash ref to avoid
-    # infinite recursion due to overloading hash-derefencing
-    my $self = \{
-        in_order => [],
-        out_order => [],
-        is_pgp_signed => 0,
-        allow_pgp => 0,
-        allow_duplicate => 0,
-        drop_empty => 0,
-    };
-    bless $self, $class;
-
-    $$self->{fields} = Dpkg::Control::HashCore::Tie->new($self);
-
-    # Options set by the user override default values
-    $$self->{$_} = $opts{$_} foreach keys %opts;
-
-    return $self;
-}
-
-# There is naturally a circular reference between the tied hash and its
-# containing object. Happily, the extra layer of scalar reference can
-# be used to detect the destruction of the object and break the loop so
-# that everything gets garbage-collected.
-
-sub DESTROY {
-    my ($self) = @_;
-    delete $$self->{fields};
-}
-
-=item $c->set_options($option, %opts)
-
-Changes the value of one or more options.
-
-=cut
-
-sub set_options {
-    my ($self, %opts) = @_;
-    $$self->{$_} = $opts{$_} foreach keys %opts;
-}
-
-=item my $value = $c->get_option($option)
-
-Returns the value of the corresponding option.
-
-=cut
-
-sub get_option {
-    my ($self, $k) = @_;
-    return $$self->{$k};
-}
-
-=item $c->load($file)
-
-Parse the content of $file. Exits in case of errors. Returns true if some
-fields have been parsed.
-
-=item $c->parse_error($file, $fmt, ...)
-
-Prints an error message and dies on syntax parse errors.
-
-=cut
-
-sub parse_error {
-    my ($self, $file, $msg) = (shift, shift, shift);
-
-    $msg = sprintf($msg, @_) if (@_);
-    error(_g('syntax error in %s at line %d: %s'), $file, $., $msg);
-}
-
-=item $c->parse($fh, $description)
-
-Parse a control file from the given filehandle. Exits in case of errors.
-$description is used to describe the filehandle, ideally it's a filename
-or a description of where the data comes from. It's used in error
-messages. Returns true if some fields have been parsed.
-
-=cut
-
-sub parse {
-    my ($self, $fh, $desc) = @_;
-
-    my $paraborder = 1;
-    my $parabody = 0;
-    my $cf; # Current field
-    my $expect_pgp_sig = 0;
-
-    while (<$fh>) {
-	chomp;
-	next if m/^\s*$/ and $paraborder;
-	next if (m/^#/);
-	$paraborder = 0;
-	if (m/^(\S+?)\s*:\s*(.*)$/) {
-	    $parabody = 1;
-	    if ($1 =~ m/^-/) {
-		$self->parse_error($desc, _g('field cannot start with a hyphen'));
-	    }
-	    my ($name, $value) = ($1, $2);
-	    if (exists $self->{$name}) {
-		unless ($$self->{allow_duplicate}) {
-		    $self->parse_error($desc, _g('duplicate field %s found'), $name);
-		}
-	    }
-	    $value =~ s/\s*$//;
-	    $self->{$name} = $value;
-	    $cf = $name;
-	} elsif (m/^\s(\s*\S.*)$/) {
-	    my $line = $1;
-	    unless (defined($cf)) {
-		$self->parse_error($desc, _g('continued value line not in field'));
-            }
-	    if ($line =~ /^\.+$/) {
-		$line = substr $line, 1;
-	    }
-	    $line =~ s/\s*$//;
-	    $self->{$cf} .= "\n$line";
-	} elsif (m/^-----BEGIN PGP SIGNED MESSAGE-----[\r\t ]*$/) {
-	    $expect_pgp_sig = 1;
-	    if ($$self->{allow_pgp} and not $parabody) {
-		# Skip PGP headers
-		while (<$fh>) {
-		    last if m/^\s*$/;
-		}
-	    } else {
-		$self->parse_error($desc, _g('PGP signature not allowed here'));
-	    }
-	} elsif (m/^\s*$/ ||
-	         ($expect_pgp_sig && m/^-----BEGIN PGP SIGNATURE-----[\r\t ]*$/)) {
-	    if ($expect_pgp_sig) {
-		# Skip empty lines
-		$_ = <$fh> while defined($_) && $_ =~ /^\s*$/;
-		unless (length $_) {
-		    $self->parse_error($desc, _g('expected PGP signature, ' .
-		                                 'found EOF after blank line'));
-		}
-		chomp;
-		unless (m/^-----BEGIN PGP SIGNATURE-----[\r\t ]*$/) {
-		    $self->parse_error($desc, _g('expected PGP signature, ' .
-		                                 "found something else \`%s'"), $_);
-                }
-		# Skip PGP signature
-		while (<$fh>) {
-		    chomp;
-		    last if m/^-----END PGP SIGNATURE-----[\r\t ]*$/;
-		}
-		unless (defined($_)) {
-		    $self->parse_error($desc, _g('unfinished PGP signature'));
-                }
-		# This does not mean the signature is correct, that needs to
-		# be verified by gnupg.
-		$$self->{is_pgp_signed} = 1;
-	    }
-	    last; # Finished parsing one block
-	} else {
-	    $self->parse_error($desc,
-	                       _g('line with unknown format (not field-colon-value)'));
-	}
-    }
-
-    if ($expect_pgp_sig and not $$self->{is_pgp_signed}) {
-	$self->parse_error($desc, _g('unfinished PGP signature'));
-    }
-
-    return defined($cf);
-}
-
-=item $c->find_custom_field($name)
-
-Scan the fields and look for a user specific field whose name matches the
-following regex: /X[SBC]*-$name/i. Return the name of the field found or
-undef if nothing has been found.
-
-=cut
-
-sub find_custom_field {
-    my ($self, $name) = @_;
-    foreach my $key (keys %$self) {
-        return $key if $key =~ /^X[SBC]*-\Q$name\E$/i;
-    }
-    return;
-}
-
-=item $c->get_custom_field($name)
-
-Identify a user field and retrieve its value.
-
-=cut
-
-sub get_custom_field {
-    my ($self, $name) = @_;
-    my $key = $self->find_custom_field($name);
-    return $self->{$key} if defined $key;
-    return;
-}
-
-=item $c->save($filename)
-
-Write the string representation of the control information to a
-file.
-
-=item my $str = $c->output()
-
-=item "$c"
-
-Get a string representation of the control information. The fields
-are sorted in the order in which they have been read or set except
-if the order has been overridden with set_output_order().
-
-=item $c->output($fh)
-
-Print the string representation of the control information to a
-filehandle.
-
-=cut
-
-sub output {
-    my ($self, $fh) = @_;
-    my $str = '';
-    my @keys;
-    if (@{$$self->{out_order}}) {
-        my $i = 1;
-        my $imp = {};
-        $imp->{$_} = $i++ foreach @{$$self->{out_order}};
-        @keys = sort {
-            if (defined $imp->{$a} && defined $imp->{$b}) {
-                $imp->{$a} <=> $imp->{$b};
-            } elsif (defined($imp->{$a})) {
-                -1;
-            } elsif (defined($imp->{$b})) {
-                1;
-            } else {
-                $a cmp $b;
-            }
-        } keys %$self;
-    } else {
-        @keys = @{$$self->{in_order}};
-    }
-
-    foreach my $key (@keys) {
-	if (exists $self->{$key}) {
-	    my $value = $self->{$key};
-            # Skip whitespace-only fields
-            next if $$self->{drop_empty} and $value !~ m/\S/;
-	    # Escape data to follow control file syntax
-	    my @lines = split(/\n/, $value);
-	    $value = (scalar @lines) ? shift @lines : '';
-	    foreach (@lines) {
-		s/\s+$//;
-		if (/^$/ or /^\.+$/) {
-		    $value .= "\n .$_";
-		} else {
-		    $value .= "\n $_";
-		}
-	    }
-	    # Print it out
-            if ($fh) {
-	        print { $fh } "$key: $value\n"
-	            or syserr(_g('write error on control data'));
-            }
-	    $str .= "$key: $value\n" if defined wantarray;
-	}
-    }
-    return $str;
-}
-
-=item $c->set_output_order(@fields)
-
-Define the order in which fields will be displayed in the output() method.
-
-=cut
-
-sub set_output_order {
-    my ($self, @fields) = @_;
-
-    $$self->{out_order} = [@fields];
-}
-
-=item $c->apply_substvars($substvars)
-
-Update all fields by replacing the variables references with
-the corresponding value stored in the Dpkg::Substvars object.
-
-=cut
-
-sub apply_substvars {
-    my ($self, $substvars, %opts) = @_;
-
-    # Add substvars to refer to other fields
-    foreach my $f (keys %$self) {
-        $substvars->set_as_used("F:$f", $self->{$f});
-    }
-
-    foreach my $f (keys %$self) {
-        my $v = $substvars->substvars($self->{$f}, %opts);
-	if ($v ne $self->{$f}) {
-	    my $sep;
-
-	    $sep = field_get_sep_type($f);
-
-	    # If we replaced stuff, ensure we're not breaking
-	    # a dependency field by introducing empty lines, or multiple
-	    # commas
-
-	    if ($sep & (FIELD_SEP_COMMA | FIELD_SEP_LINE)) {
-	        # Drop empty/whitespace-only lines
-	        $v =~ s/\n[ \t]*(\n|$)/$1/;
-	    }
-
-	    if ($sep & FIELD_SEP_COMMA) {
-	        $v =~ s/,[\s,]*,/,/g;
-	        $v =~ s/^\s*,\s*//;
-	        $v =~ s/\s*,\s*$//;
-	    }
-	}
-        $v =~ s/\$\{\}/\$/g; # XXX: what for?
-
-        $self->{$f} = $v;
-    }
-}
-
-package Dpkg::Control::HashCore::Tie;
-
-# This object is used to tie a hash. It implements hash-like functions by
-# normalizing the name of fields received in keys (using
-# Dpkg::Control::Fields::field_capitalize). It also stores the order in
-# which fields have been added in order to be able to dump them in the
-# same order. But the order information is stored in a parent object of
-# type Dpkg::Control.
-
-use Dpkg::Checksums;
-use Dpkg::Control::FieldsCore;
-
-use Carp;
-use Tie::Hash;
-use parent -norequire, qw(Tie::ExtraHash);
-
-# $self->[0] is the real hash
-# $self->[1] is a reference to the hash contained by the parent object.
-# This reference bypasses the top-level scalar reference of a
-# Dpkg::Control::Hash, hence ensuring that that reference gets DESTROYed
-# properly.
-
-# Dpkg::Control::Hash->new($parent)
-#
-# Return a reference to a tied hash implementing storage of simple
-# "field: value" mapping as used in many Debian-specific files.
-
-sub new {
-    my $class = shift;
-    my $hash = {};
-    tie %{$hash}, $class, @_;
-    return $hash;
-}
-
-sub TIEHASH  {
-    my ($class, $parent) = @_;
-    croak 'parent object must be Dpkg::Control::Hash'
-        if not $parent->isa('Dpkg::Control::HashCore') and
-           not $parent->isa('Dpkg::Control::Hash');
-    return bless [ {}, $$parent ], $class;
-}
-
-sub FETCH {
-    my ($self, $key) = @_;
-    $key = lc($key);
-    return $self->[0]->{$key} if exists $self->[0]->{$key};
-    return;
-}
-
-sub STORE {
-    my ($self, $key, $value) = @_;
-    my $parent = $self->[1];
-    $key = lc($key);
-    if (not exists $self->[0]->{$key}) {
-	push @{$parent->{in_order}}, field_capitalize($key);
-    }
-    $self->[0]->{$key} = $value;
-}
-
-sub EXISTS {
-    my ($self, $key) = @_;
-    $key = lc($key);
-    return exists $self->[0]->{$key};
-}
-
-sub DELETE {
-    my ($self, $key) = @_;
-    my $parent = $self->[1];
-    my $in_order = $parent->{in_order};
-    $key = lc($key);
-    if (exists $self->[0]->{$key}) {
-	delete $self->[0]->{$key};
-	@$in_order = grep { lc($_) ne $key } @$in_order;
-	return 1;
-    } else {
-	return 0;
-    }
-}
-
-sub FIRSTKEY {
-    my $self = shift;
-    my $parent = $self->[1];
-    foreach (@{$parent->{in_order}}) {
-	return $_ if exists $self->[0]->{lc($_)};
-    }
-}
-
-sub NEXTKEY {
-    my ($self, $last) = @_;
-    my $parent = $self->[1];
-    my $found = 0;
-    foreach (@{$parent->{in_order}}) {
-	if ($found) {
-	    return $_ if exists $self->[0]->{lc($_)};
-	} else {
-	    $found = 1 if $_ eq $last;
-	}
-    }
-    return;
-}
-
-1;
-
-=back
-
-=head1 CHANGES
-
-=head2 Version 1.01
-
-New method: parse_error().
-
-=head1 AUTHOR
-
-Raphaël Hertzog <hertzog@debian.org>.
-
-=cut
-
-1;