npm - javonet-nodejs-sdk - Versions diffs - 2.0.5 → 2.1.1 - Mend

javonet-nodejs-sdk 2.0.5 → 2.1.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1123) hide show

package/Binaries/Perl/MacOs/X64/deps/bin/ppkg-config DELETED Viewed

@@ -1,1786 +0,0 @@
-#!/usr/local/opt/perl/bin/perl
-# lightweight no-dependency version of pkg-config. This will work on any machine
-# with Perl installed.
-# Copyright (C) 2012 M. Nunberg.
-# You may use and distribute this software under the same terms and conditions
-# as Perl itself.
-package
-    PkgConfig::Vars;
-# this is a namespace for .pc files to hold their variables without
-# relying on lexical scope.
-package
-    PkgConfig::UDefs;
-# This namespace provides user-defined variables which are to override any
-# declarations within the .pc file itself.
-package PkgConfig;
-#First two digits are Perl version, second two are pkg-config version
-our $VERSION = '0.25026';
-$VERSION =~ /([0-9]{2})$/;
-my $compat_version = $1;
-use strict;
-use warnings;
-use 5.006;
-use Config;
-use File::Spec;
-use File::Glob 'bsd_glob';
-use Class::Struct; #in core since 5.004
-use File::Basename qw( dirname );
-use Text::ParseWords qw( shellwords );
-our $UseDebugging;
-################################################################################
-### Check for Log::Fu                                                        ###
-################################################################################
-BEGIN {
-    my $ret = eval q{
-        use Log::Fu 0.25 { level => "warn" };
-        1;
-    };
-    if(!$ret) {
-        my $log_base = sub {
-            my (@args) = @_;
-            print STDERR "[DEBUG] ", join(' ', @args);
-            print STDERR "\n";
-        };
-        *log_debug = *log_debugf = sub { return unless $UseDebugging; goto &$log_base };
-        *log_err = *log_errf = *log_warn = *log_warnf = *log_info = *log_infof =
-            $log_base;
-    }
-}
-our $VarClassSerial = 0;
-################################################################################
-### Sane Defaults                                                            ###
-################################################################################
-our @DEFAULT_SEARCH_PATH = qw(
-    /usr/local/lib/pkgconfig /usr/local/share/pkgconfig
-    /usr/lib/pkgconfig /usr/share/pkgconfig
-);
-our @DEFAULT_EXCLUDE_CFLAGS = qw(-I/usr/include -I/usr/local/include);
-# don't include default link/search paths!
-our @DEFAULT_EXCLUDE_LFLAGS = map { ( "-L$_", "-R$_" ) } qw( /lib /lib32 /lib64 /usr/lib /usr/lib32 /usr/lib/64 /usr/local/lib /usr/local/lib32 /usr/local/lib64 );
-if($ENV{PKG_CONFIG_NO_OS_CUSTOMIZATION}) {
-    # use the defaults regardless of detected platform
-} elsif($ENV{PKG_CONFIG_LIBDIR}) {
-    @DEFAULT_SEARCH_PATH = split $Config{path_sep}, $ENV{PKG_CONFIG_LIBDIR};
-} elsif($^O eq 'msys') {
-    # MSYS2 seems to actually set PKG_CONFIG_PATH in its /etc/profile
-    # god bless it.  But.  The defaults if you unset the environment
-    # variable are different
-    @DEFAULT_SEARCH_PATH = qw(
-        /usr/lib/pkgconfig
-        /usr/share/pkgconfig
-    );
-} elsif($^O eq 'solaris' && $Config{ptrsize} == 8) {
-    @DEFAULT_SEARCH_PATH = qw(
-        /usr/local/lib/64/pkgconfig /usr/local/share/pkgconfig
-        /usr/lib/64/pkgconfig /usr/share/pkgconfig
-    );
-} elsif($^O eq 'linux' and -f '/etc/gentoo-release') {
-    # OK, we're running on Gentoo
-    # Fetch ptrsize value
-    my $ptrsize = $Config{ptrsize};
-    # Are we running on 64 bit system?
-    if ($ptrsize eq 8) {
-        # We do
-        @DEFAULT_SEARCH_PATH = qw!
-          /usr/lib64/pkgconfig/ /usr/share/pkgconfig/
-        !;
-    } else {
-        # We're running on a 32 bit system (hopefully)
-        @DEFAULT_SEARCH_PATH = qw!
-          /usr/lib/pkgconfig/ /usr/share/pkgconfig/
-        !;
-    }
-} elsif($^O =~ /^(gnukfreebsd|linux)$/ && -r "/etc/debian_version") {
-    my $arch;
-    if(-x "/usr/bin/dpkg-architecture") {
-        # works if dpkg-dev is installed
-        # rt96694
-        ($arch) = map { chomp; (split /=/)[1] }
-                  grep /^DEB_HOST_MULTIARCH=/,
-                  `/usr/bin/dpkg-architecture`;
-    } elsif(-x "/usr/bin/gcc") {
-        # works if gcc is installed
-        $arch = `/usr/bin/gcc -dumpmachine`;
-        chomp $arch;
-    } else {
-        my $deb_arch = `dpkg --print-architecture`;
-        if($deb_arch =~ /^amd64/) {
-            if($^O eq 'linux') {
-                $arch = 'x86_64-linux-gnu';
-            } elsif($^O eq 'gnukfreebsd') {
-                $arch = 'x86_64-kfreebsd-gnu';
-            }
-        } elsif($deb_arch =~ /^i386/) {
-            if($^O eq 'linux') {
-                $arch = 'i386-linux-gnu';
-            } elsif($^O eq 'gnukfreebsd') {
-                $arch = 'i386-kfreebsd-gnu';
-            }
-        }
-    }
-    if($arch) {
-        if(scalar grep /--print-foreign-architectures/, `dpkg --help`)
-        {
-            # multi arch support / Debian 7+
-            @DEFAULT_SEARCH_PATH = (
-                "/usr/local/lib/$arch/pkgconfig",
-                "/usr/local/lib/pkgconfig",
-                "/usr/local/share/pkgconfig",
-                "/usr/lib/$arch/pkgconfig",
-                "/usr/lib/pkgconfig",
-                "/usr/share/pkgconfig",
-            );
-            push @DEFAULT_EXCLUDE_LFLAGS, map { ("-L$_", "-R$_") }
-                "/usr/local/lib/$arch",
-                "/usr/lib/$arch";
-        } else {
-            @DEFAULT_SEARCH_PATH = (
-                "/usr/local/lib/pkgconfig",
-                "/usr/local/lib/pkgconfig/$arch",
-                "/usr/local/share/pkgconfig",
-                "/usr/lib/pkgconfig",
-                "/usr/lib/pkgconfig/$arch",
-                "/usr/share/pkgconfig",
-            );
-        }
-    } else {
-        @DEFAULT_SEARCH_PATH = (
-            "/usr/local/lib/pkgconfig",
-            "/usr/local/share/pkgconfig",
-            "/usr/lib/pkgconfig",
-            "/usr/share/pkgconfig",
-        );
-    }
-} elsif($^O eq 'linux' && -r "/etc/redhat-release") {
-    if(-d "/usr/lib64/pkgconfig") {
-        @DEFAULT_SEARCH_PATH = qw(
-            /usr/lib64/pkgconfig
-            /usr/share/pkgconfig
-        );
-    } else {
-        @DEFAULT_SEARCH_PATH = qw(
-            /usr/lib/pkgconfig
-            /usr/share/pkgconfig
-        );
-    }
-} elsif($^O eq 'linux' && -r "/etc/slackware-version") {
-    # Fetch ptrsize value
-    my $ptrsize = $Config{ptrsize};
-    # Are we running on 64 bit system?
-    if ($ptrsize == 8) {
-        # We do
-        @DEFAULT_SEARCH_PATH = qw!
-          /usr/lib64/pkgconfig/ /usr/share/pkgconfig/
-        !;
-    } else {
-        # We're running on a 32 bit system (hopefully)
-        @DEFAULT_SEARCH_PATH = qw!
-          /usr/lib/pkgconfig/ /usr/share/pkgconfig/
-        !;
-    }
-} elsif($^O eq 'freebsd') {
-    # TODO: FreeBSD 10-12's version of pkg-config does not
-    # support PKG_CONFIG_DEBUG_SPEW so I can't verify
-    # the path there.
-    @DEFAULT_SEARCH_PATH = qw(
-        /usr/local/libdata/pkgconfig
-        /usr/libdata/pkgconfig
-    );
-} elsif($^O eq 'netbsd') {
-    @DEFAULT_SEARCH_PATH = qw(
-        /usr/pkg/lib/pkgconfig
-        /usr/pkg/share/pkgconfig
-        /usr/X11R7/lib/pkgconfig
-        /usr/lib/pkgconfig
-    );
-} elsif($^O eq 'openbsd') {
-    @DEFAULT_SEARCH_PATH = qw(
-        /usr/lib/pkgconfig
-        /usr/local/lib/pkgconfig
-        /usr/local/share/pkgconfig
-        /usr/X11R6/lib/pkgconfig
-        /usr/X11R6/share/pkgconfig
-    );
-} elsif($^O eq 'MSWin32') {
-    # Caveats:
-    # 1. This pulls in Config,
-    #    which we don't load on non MSWin32
-    #    but it is in the core.
-    # 2. Slight semantic difference in that we are treating
-    #    Strawberry as the "system" rather than Windows, but
-    #    since pkg-config is rarely used in MSWin32, it is
-    #    better to have something that is useful rather than
-    #    worry about if it is exactly the same as other
-    #    platforms.
-    # 3. It is a little brittle in that Strawberry might
-    #    one day change its layouts.  If it has and you are
-    #    reading this, please send a pull request or simply
-    #    let me know -plicease
-    require Config;
-    if($Config::Config{myuname} =~ /strawberry-perl/)
-    {
-        #  handle PAR::Packer executables which have $^X eq "perl.exe"
-        if ($ENV{PAR_0})
-        {
-            my $path = $ENV{PAR_TEMP};
-            $path =~ s{\\}{/}g;
-            @DEFAULT_SEARCH_PATH = ($path);
-        }
-        else {
-            my($vol, $dir, $file) = File::Spec->splitpath($^X);
-            my @dirs = File::Spec->splitdir($dir);
-            splice @dirs, -3;
-            my $path = (File::Spec->catdir($vol, @dirs, qw( c lib pkgconfig )));
-            $path =~ s{\\}{/}g;
-            @DEFAULT_SEARCH_PATH = $path;
-        }
-    }
-    my @reg_paths;
-    eval q{
-        package
-            PkgConfig::WinReg;
-        use Win32API::Registry 0.21 qw( :ALL );
-        foreach my $top (HKEY_LOCAL_MACHINE, HKEY_CURRENT_USER) {
-            my $key;
-            RegOpenKeyEx( $top, "Software\\\\pkgconfig\\\\PKG_CONFIG_PATH", 0, KEY_READ, $key) || next;
-            my $nlen = 1024;
-            my $pos = 0;
-            my $name = '';
-            while(RegEnumValue($key, $pos++, $name, $nlen, [], [], [], [])) {
-                my $type;
-                my $data;
-                RegQueryValueEx($key, $name, [], $type, $data, []);
-                push @reg_paths, $data;
-            }
-            RegCloseKey( $key );
-        }
-    };
-    unless($@) {
-        unshift @DEFAULT_SEARCH_PATH, @reg_paths;
-    }
-    if($Config::Config{cc} =~ /cl(\.exe)?$/i)
-    {
-        @DEFAULT_EXCLUDE_LFLAGS = ();
-        @DEFAULT_EXCLUDE_CFLAGS = ();
-    }
-    else
-    {
-        @DEFAULT_EXCLUDE_LFLAGS = (
-            "-L/mingw/lib",
-            "-R/mingw/lib",
-            "-L/mingw/lib/pkgconfig/../../lib",
-            "-R/mingw/lib/pkgconfig/../../lib",
-        );
-        @DEFAULT_EXCLUDE_CFLAGS = (
-            "-I/mingw/include",
-            "-I/mingw/lib/pkgconfig/../../include",
-        );
-    }
-    # See caveats above for Strawberry and PAR::Packer
-    require Config;
-    if(not $ENV{PAR_0} and $Config::Config{myuname} =~ /strawberry-perl/)
-    {
-        my($vol, $dir, $file) = File::Spec->splitpath($^X);
-        my @dirs = File::Spec->splitdir($dir);
-        splice @dirs, -3;
-        my $path = (File::Spec->catdir($vol, @dirs, qw( c )));
-        $path =~ s{\\}{/}g;
-        push @DEFAULT_EXCLUDE_LFLAGS, (
-            "-L$path/lib",
-            "-L$path/lib/pkgconfig/../../lib",
-            "-R$path/lib",
-            "-R$path/lib/pkgconfig/../../lib",
-        );
-        push @DEFAULT_EXCLUDE_CFLAGS, (
-            "-I$path/include",
-            "-I$path/lib/pkgconfig/../../include",
-        );
-    }
-} elsif($^O eq 'darwin') {
-    if(-x '/usr/local/Homebrew/bin/brew') {
-        # Mac OS X with homebrew installed
-        push @DEFAULT_SEARCH_PATH,
-            bsd_glob '/usr/local/opt/*/lib/pkgconfig'
-        ;
-    }
-}
-my @ENV_SEARCH_PATH = split($Config{path_sep}, $ENV{PKG_CONFIG_PATH} || "");
-unshift @DEFAULT_SEARCH_PATH, @ENV_SEARCH_PATH;
-if($^O eq 'MSWin32') {
-  @DEFAULT_SEARCH_PATH = map { s{\\}{/}g; $_ } map { /\s/ ? Win32::GetShortPathName($_) : $_ } @DEFAULT_SEARCH_PATH;
-}
-if($ENV{PKG_CONFIG_ALLOW_SYSTEM_CFLAGS}) {
-    @DEFAULT_EXCLUDE_CFLAGS = ();
-}
-if($ENV{PKG_CONFIG_ALLOW_SYSTEM_LIBS}) {
-    @DEFAULT_EXCLUDE_LFLAGS = ();
-}
-my $LD_OUTPUT_RE = qr/
-    SEARCH_DIR\("
-    ([^"]+)
-    "\)
-/x;
-sub GuessPaths {
-    my $pkg = shift;
-    local $ENV{LD_LIBRARY_PATH} = "";
-    local $ENV{C_INCLUDE_PATH} = "";
-    local $ENV{LD_RUN_PATH} = "";
-    my $ld = $ENV{LD} || 'ld';
-    my $ld_output = qx(ld -verbose);
-    my @defl_search_dirs = ($ld_output =~ m/$LD_OUTPUT_RE/g);
-    @DEFAULT_EXCLUDE_LFLAGS = ();
-    foreach my $path (@defl_search_dirs) {
-        push @DEFAULT_EXCLUDE_LFLAGS, (map { "$_".$path }
-            (qw(-R -L -rpath= -rpath-link= -rpath -rpath-link)));
-    }
-    log_debug("Determined exclude LDFLAGS", @DEFAULT_EXCLUDE_LFLAGS);
-    #now get the include paths:
-    my @cpp_output = qx(cpp --verbose 2>&1 < /dev/null);
-    @cpp_output = map  { chomp $_; $_ } @cpp_output;
-    #log_info(join("!", @cpp_output));
-    while (my $cpp_line = shift @cpp_output) {
-        chomp($cpp_line);
-        if($cpp_line =~ /\s*#include\s*<.+search starts here/) {
-            last;
-        }
-    }
-    #log_info(@cpp_output);
-    my @include_paths;
-    while (my $path = shift @cpp_output) {
-        if($path =~ /\s*End of search list/) {
-            last;
-        }
-        push @include_paths, $path;
-    }
-    @DEFAULT_EXCLUDE_CFLAGS = map { "-I$_" } @include_paths;
-    log_debug("Determine exclude CFLAGS", @DEFAULT_EXCLUDE_CFLAGS);
-}
-################################################################################
-### Define our fields                                                        ###
-################################################################################
-struct(
-    __PACKAGE__,
-    [
-     # .pc search paths, defaults to PKG_CONFIG_PATH in environment
-     'search_path' => '@',
-     # whether to also spit out static dependencies
-     'static' => '$',
-     # whether we replace references to -L and friends with -Wl,-rpath, etc.
-     'rpath' => '$',
-     # build rpath-search,
-     # no recursion. set if we just want a version, or to see if the
-     # package exists.
-     'no_recurse' => '$',
-     #list of cflags and ldflags to exclude
-     'exclude_ldflags' => '@',
-     'exclude_cflags' => '@',
-     # what level of recursion we're at
-     'recursion' => '$',
-     # hash of libraries, keyed by recursion levels. Lower recursion numbers
-     # will be listed first
-     'libs_deplist' => '*%',
-     # cumulative cflags and ldflags
-     'ldflags'   => '*@',
-     'cflags'    => '*@',
-     # whether we print the c/ldflags
-     'print_cflags' => '$',
-     'print_ldflags' => '$',
-     # information about our top-level package
-     'pkg'  => '$',
-     'pkg_exists' => '$',
-     'pkg_version' => '$',
-     'pkg_url', => '$',
-     'pkg_description' => '$',
-     'errmsg'   => '$',
-     # classes used for storing persistent data
-     'varclass' => '$',
-     'udefclass' => '$',
-     'filevars' => '*%',
-     'uservars' => '*%',
-     # options for printing variables
-     'print_variables' => '$',
-     'print_variable' => '$',
-     'print_values' => '$',
-     'defined_variables' => '*%',
-     # for creating PkgConfig objects with identical
-     # settings
-     'original' => '$',
-    ]
-);
-################################################################################
-################################################################################
-### Variable Storage                                                         ###
-################################################################################
-################################################################################
-sub _get_pc_varname {
-    my ($self,$vname_base) = @_;
-    $self->varclass . "::" . $vname_base;
-}
-sub _get_pc_udefname {
-    my ($self,$vname_base) = @_;
-    $self->udefclass . "::" . $vname_base;
-}
-sub _pc_var {
-    my ($self,$vname) = @_;
-    $vname =~ s,\.,DOT,g;
-    no strict 'refs';
-    $vname = $self->_get_pc_varname($vname);
-    no warnings qw(once);
-    my $glob = *{$vname};
-    $glob ? $$glob : ();
-}
-sub _quote_cvt($)  {
-    join ' ', map { s/(\s|"|')/\\$1/g; $_ } shellwords(shift)
-}
-sub assign_var {
-    my ($self,$field,$value) = @_;
-    no strict 'refs';
-    # if the user has provided a definition, use that.
-    if(exists ${$self->udefclass."::"}{$field}) {
-        log_debug("Prefix already defined by user");
-        return;
-    }
-    my $evalstr = sprintf('$%s = PkgConfig::_quote_cvt(%s)',
-                    $self->_get_pc_varname($field), $value);
-    log_debug("EVAL", $evalstr);
-    do {
-        no warnings 'uninitialized';
-        eval $evalstr;
-    };
-    if($@) {
-        log_err($@);
-    }
-}
-sub prepare_vars {
-    my $self = shift;
-    my $varclass = $self->varclass;
-    no strict 'refs';
-    %{$varclass . "::"} = ();
-    while (my ($name,$glob) = each %{$self->udefclass."::"}) {
-        my $ref = *$glob{SCALAR};
-        next unless defined $ref;
-        ${"$varclass\::$name"} = $$ref;
-    }
-}
-################################################################################
-################################################################################
-### Initializer                                                              ###
-################################################################################
-################################################################################
-sub find {
-    my ($cls,$library,%options) = @_;
-    my @uspecs = (
-        ['search_path', \@DEFAULT_SEARCH_PATH],
-        ['exclude_ldflags', \@DEFAULT_EXCLUDE_LFLAGS],
-        ['exclude_cflags', \@DEFAULT_EXCLUDE_CFLAGS]
-    );
-    my %original = %options;
-    foreach (@uspecs) {
-        my ($basekey,$default) = @$_;
-        my $list = [ @{$options{$basekey} ||= [] } ];
-        if($options{$basekey . "_override"}) {
-            @$list = @{ delete $options{$basekey."_override"} };
-        } else {
-            push @$list, @$default;
-        }
-        $options{$basekey} = $list;
-        #print "$basekey: " . Dumper($list);
-    }
-    $VarClassSerial++;
-    $options{varclass} = sprintf("PkgConfig::Vars::SERIAL_%d", $VarClassSerial);
-    $options{udefclass} = sprintf("PkgConfig::UDefs::SERIAL_%d", $VarClassSerial);
-    $options{original} = \%original;
-    my $udefs = delete $options{VARS} || {};
-    while (my ($k,$v) = each %$udefs) {
-        no strict 'refs';
-        my $vname = join('::', $options{udefclass}, $k);
-        ${$vname} = $v;
-    }
-    my $o = $cls->new(%options);
-    my @libraries;
-    if(ref $library eq 'ARRAY') {
-        @libraries = @$library;
-    } else {
-        @libraries = ($library);
-    }
-    if($options{file_path}) {
-        if(-r $options{file_path}) {
-            $o->recursion(1);
-            $o->parse_pcfile($options{file_path});
-            $o->recursion(0);
-        } else {
-            $o->errmsg("No such file $options{file_path}\n");
-        }
-    } else {
-        foreach my $lib (@libraries) {
-            $o->recursion(0);
-            my($op,$ver);
-            ($lib,$op,$ver) = ($1,$2,PkgConfig::Version->new($3))
-                if $lib =~ /^(.*)\s+(!=|=|>=|<=|>|<)\s+(.*)$/;
-            $o->find_pcfile($lib);
-            if(!$o->errmsg && defined $op) {
-                $op = '==' if $op eq '=';
-                unless(eval qq{ PkgConfig::Version->new(\$o->pkg_version) $op \$ver })
-                {
-                    $o->errmsg("Requested '$lib $op $ver' but version of $lib is " .
-                        ($o->pkg_version ? $o->pkg_version : '') . "\n");
-                }
-            }
-        }
-    }
-    $o;
-}
-################################################################################
-################################################################################
-### Modify our flags stack                                                   ###
-################################################################################
-################################################################################
-sub append_ldflags {
-    my ($self,@flags) = @_;
-    my @ld_flags = _split_flags(@flags);
-    foreach my $ldflag (@ld_flags) {
-        next unless $ldflag =~ /^-Wl/;
-        my (@wlflags) = split(/,/, $ldflag);
-        shift @wlflags; #first is -Wl,
-        filter_omit(\@wlflags, $self->exclude_ldflags);
-        if(!@wlflags) {
-            $ldflag = "";
-            next;
-        }
-        $ldflag = join(",", '-Wl', @wlflags);
-    }
-    @ld_flags = grep $_, @ld_flags;
-    return unless @ld_flags;
-    push @{($self->libs_deplist->{$self->recursion} ||=[])},
-        @ld_flags;
-}
-# notify us about extra compiler flags
-sub append_cflags {
-    my ($self,@flags) = @_;
-    push @{$self->cflags}, _split_flags(@flags);
-}
-################################################################################
-################################################################################
-### All sorts of parsing is here                                             ###
-################################################################################
-################################################################################
-sub get_requires {
-    my ($self,$requires) = @_;
-    return () unless $requires;
-    my @reqlist = split(/[\s,]+/, $requires);
-    my @ret;
-    while (defined (my $req = shift @reqlist) ) {
-        my $reqlet = [ $req ];
-        push @ret, $reqlet;
-        last unless @reqlist;
-        #check if we need some version scanning:
-        my $cmp_op;
-        my $want;
-        GT_PARSE_REQ:
-        {
-            #all in one word:
-            ($cmp_op) = ($req =~ /([<>=]+)/);
-            if($cmp_op) {
-                if($req =~ /[<>=]+$/) {
-                    log_debug("comparison operator spaced ($cmp_op)");
-                    ($want) = ($req =~ /([^<>=]+$)/);
-                    $want ||= shift @reqlist;
-                } else {
-                    $want = shift @reqlist;
-                }
-                push @$reqlet, ($cmp_op, $want);
-            } elsif ($reqlist[0] =~ /[<>=]+/) {
-                $req = shift @reqlist;
-                goto GT_PARSE_REQ;
-            }
-        }
-    }
-    #log_debug(@ret);
-    @ret;
-}
-sub parse_line {
-    my ($self,$line,$evals) = @_;
-    no strict 'vars';
-    $line =~ s/#[^#]+$//g; # strip comments
-    return unless $line;
-    my ($tok) = ($line =~ /([=:])/);
-    my ($field,$value) = split(/[=:]/, $line, 2);
-    return unless defined $value;
-    if($tok eq '=') {
-        $self->defined_variables->{$field} = $value;
-    }
-    #strip trailing/leading whitespace:
-    $field =~ s/(^\s+)|(\s+)$//msg;
-    #remove trailing/leading whitespace from value
-    $value =~ s/(^\s+)|(\s+$)//msg;
-    log_debugf("Field %s, Value %s", $field, $value);
-    $field = lc($field);
-    #perl variables can't have '.' in them:
-    $field =~ s/\./DOT/g;
-    #remove quotes from field names
-    $field =~ s/['"]//g;
-    # pkg-config escapes a '$' with a '$$'. This won't go in perl:
-    $value =~ s/[^\\]\$\$/\\\$/g;
-    $value =~ s/([@%&])/\$1/g;
-    # append our pseudo-package for persistence.
-    my $varclass = $self->varclass;
-    $value =~ s/(\$\{[^}]+\})/lc($1)/ge;
-    $value =~ s/\$\{/\$\{$varclass\::/g;
-    # preserve quoted space
-    $value = join ' ', map { s/(["'])/\\$1/g; "'$_'" } shellwords $value
-      if $value =~ /[\\"']/;
-    #quote the value string, unless quoted already
-    $value = "\"$value\"";
-    #get existent variables from our hash:
-    #$value =~ s/'/"/g; #allow for interpolation
-    $self->assign_var($field, $value);
-}
-sub parse_pcfile {
-    my ($self,$pcfile,$wantversion) = @_;
-    #log_warn("Requesting $pcfile");
-    open my $fh, "<", $pcfile or die "$pcfile: $!";
-    $self->prepare_vars();
-    my @lines = (<$fh>);
-    close($fh);
-    my $text = join("", @lines);
-    $text =~ s,\\[\r\n],,g;
-    @lines = split(/[\r\n]/, $text);
-    my @eval_strings;
-    #Fold lines:
-    my $pcfiledir = dirname $pcfile;
-    $pcfiledir =~ s{\\}{/}g;
-    foreach my $line ("pcfiledir=$pcfiledir", @lines) {
-        $self->parse_line($line, \@eval_strings);
-    }
-    #now that we have eval strings, evaluate them all within the same
-    #lexical scope:
-    $self->append_cflags(  $self->_pc_var('cflags') );
-    if($self->static) {
-        $self->append_cflags( $self->_pc_var('cflags.private') );
-    }
-    $self->append_ldflags( $self->_pc_var('libs') );
-    if($self->static) {
-        $self->append_ldflags( $self->_pc_var('libs.private') );
-    }
-    my @deps;
-    my @deps_dynamic = $self->get_requires( $self->_pc_var('requires'));
-    my @deps_static = $self->get_requires( $self->_pc_var('requires.private') );
-    @deps = @deps_dynamic;
-    if($self->static) {
-        push @deps, @deps_static;
-    }
-    if($self->recursion == 1 && (!$self->pkg_exists())) {
-        $self->pkg_version( $self->_pc_var('version') );
-        $self->pkg_url( $self->_pc_var('url') );
-        $self->pkg_description( $self->_pc_var('description') );
-        $self->pkg_exists(1);
-    }
-    unless ($self->no_recurse) {
-        foreach (@deps) {
-            my ($dep,$cmp_op,$version) = @$_;
-            $dep = "$dep $cmp_op $version" if defined $cmp_op;
-            my $other = PkgConfig->find($dep, %{ $self->original });
-            if($other->errmsg) {
-                $self->errmsg($other->errmsg);
-                last;
-            }
-            $self->append_cflags(  $other->get_cflags );
-            $self->append_ldflags( $other->get_ldflags );
-        }
-    }
-}
-################################################################################
-################################################################################
-### Locate and process a .pc file                                            ###
-################################################################################
-################################################################################
-sub find_pcfile {
-    my ($self,$libname,$version) = @_;
-    $self->recursion($self->recursion + 1);
-    my $pcfile = "$libname.pc";
-    my $found = 0;
-    my @found_paths = (grep {
-        -e File::Spec->catfile($_, $pcfile)
-        } @{$self->search_path});
-    if(!@found_paths) {
-        my @search_paths = @{$self->search_path};
-        $self->errmsg(
-            join("\n",
-                 "Can't find $pcfile in any of @search_paths",
-                 "use the PKG_CONFIG_PATH environment variable, or",
-                 "specify extra search paths via 'search_paths'",
-                 ""
-                )
-        ) unless $self->errmsg();
-        return;
-    }
-    $pcfile = File::Spec->catfile($found_paths[0], $pcfile);
-    $self->parse_pcfile($pcfile);
-    $self->recursion($self->recursion - 1);
-}
-################################################################################
-################################################################################
-### Public Getters                                                           ###
-################################################################################
-################################################################################
-sub _return_context (@) {
-    wantarray ? (@_) : join(' ', map { s/(\s|['"])/\\$1/g; $_ } @_)
-}
-sub get_cflags {
-    my $self = shift;
-    my @cflags = @{$self->cflags};
-    filter_omit(\@cflags, $self->exclude_cflags);
-    filter_dups(\@cflags);
-    _return_context @cflags;
-}
-sub get_ldflags {
-    my $self = shift;
-    my @ordered_libs;
-    my @lib_levels = sort keys %{$self->libs_deplist};
-    my @ret;
-    @ordered_libs = @{$self->libs_deplist}{@lib_levels};
-    foreach my $liblist (@ordered_libs) {
-        my $lcopy = [ @$liblist ];
-        filter_dups($lcopy);
-        filter_omit($lcopy, $self->exclude_ldflags);
-        push @ret, @$lcopy;
-    }
-    @ret = reverse @ret;
-    filter_dups(\@ret);
-    @ret = reverse(@ret);
-    _return_context @ret;
-}
-sub get_var {
-    my($self, $name) = @_;
-    $self->_pc_var($name);
-}
-sub get_list {
-    my $self = shift;
-    my @search_paths = @{$self->search_path};
-    my @rv = ();
-    $self->recursion(0);
-    for my $d (@search_paths) {
-        next unless -d $d;
-        for my $pc (bsd_glob("$d/*.pc")) {
-            if ($pc =~ m|/([^\\\/]+)\.pc$|) {
-                $self->parse_pcfile($pc);
-                push @rv, [$1, $self->_pc_var('name') . ' - ' . $self->_pc_var('description')];
-            }
-        }
-    }
-    @rv;
-}
-################################################################################
-################################################################################
-### Utility functions                                                        ###
-################################################################################
-################################################################################
-#split a list of tokens by spaces
-sub _split_flags {
-    my @flags = @_;
-    if(!@flags) {
-        return @flags;
-    }
-    if(@flags == 1) {
-        my $str = shift @flags;
-        return () if !$str;
-        #@flags = map { s/\\(\s)/$1/g; $_ } split(/(?<!\\)\s+/, $str);
-        @flags = shellwords $str;
-    }
-    @flags = grep $_, @flags;
-    @flags;
-}
-sub filter_dups {
-    my $array = shift;
-    my @ret;
-    my %seen_hash;
-    #@$array = reverse @$array;
-    foreach my $elem (@$array) {
-        if(exists $seen_hash{$elem}) {
-            next;
-        }
-        $seen_hash{$elem} = 1;
-        push @ret, $elem;
-    }
-    #print Dumper(\%seen_hash);
-    @$array = @ret;
-}
-sub filter_omit {
-    my ($have,$exclude) = @_;
-    my @ret;
-    #print Dumper($have);
-    foreach my $elem (@$have) {
-        #log_warn("Checking '$elem'");
-        if(grep { $_ eq $elem } @$exclude) {
-            #log_warn("Found illegal flag '$elem'");
-            next;
-        }
-        push @ret, $elem;
-    }
-    @$have = @ret;
-}
-sub version_2_array {
-    my $string = shift;
-    my @chunks = split(/\./, $string);
-    my @ret;
-    my $chunk;
-    while( ($chunk = pop @chunks)
-        && $chunk =~ /^\d+$/) {
-        push @ret, $chunk;
-    }
-    @ret;
-}
-sub version_check {
-    my ($want,$have) = @_;
-    my @a_want = version_2_array($want);
-    my @a_have = version_2_array($have);
-    my $max_elem = scalar @a_want > scalar @a_have
-        ? scalar @a_have
-        : scalar @a_want;
-    for(my $i = 0; $i < $max_elem; $i++) {
-        if($a_want[$i] > $a_have[$i]) {
-            return 0;
-        }
-    }
-    1;
-}
-if(caller) {
-    return 1;
-}
-package
-    PkgConfig::Version;
-use overload
-    '<=>' => sub { $_[0]->cmp($_[1]) },
-    '""'  => sub { $_[0]->as_string },
-    fallback => 1;
-sub new {
-    my($class, $value) = @_;
-    bless [split /\./, defined $value ? $value : ''], $class;
-}
-sub clone {
-    __PACKAGE__->new(shift->as_string);
-}
-sub as_string {
-    my($self) = @_;
-    join '.', @{ $self };
-}
-sub cmp {
-    my($self, $other) = @_;
-    no warnings 'uninitialized';
-    defined($self->[0]) || defined($other->[0]) ? ($self->[0] <=> $other->[0]) || &cmp([@{$self}[1..$#$self]], [@{$other}[1..$#$other]]) : 0;
-}
-################################################################################
-################################################################################
-################################################################################
-################################################################################
-### Script-Only stuff                                                        ###
-################################################################################
-################################################################################
-################################################################################
-################################################################################
-package PkgConfig::Script;
-use strict;
-use warnings;
-use Getopt::Long qw(:config no_ignore_case);
-use Pod::Usage;
-my $print_errors = 0;
-my @ARGV_PRESERVE = @ARGV;
-my @POD_USAGE_SECTIONS = (
-    "NAME",
-    'DESCRIPTION/SCRIPT OPTIONS/USAGE',
-    "DESCRIPTION/SCRIPT OPTIONS/ARGUMENTS|ENVIRONMENT",
-    "AUTHOR & COPYRIGHT"
-);
-my @POD_USAGE_OPTIONS = (
-    -verbose => 99,
-    -sections => \@POD_USAGE_SECTIONS
-);
-GetOptions(
-    'libs' => \my $PrintLibs,
-    'libs-only-L' => \my $PrintLibsOnlyL,
-    'libs-only-l' => \my $PrintLibsOnlyl,
-    'libs-only-other' => \my $PrintLibsOnlyOther,
-    'list-all' => \my $ListAll,
-    'static' => \my $UseStatic,
-    'cflags' => \my $PrintCflags,
-    'cflags-only-I' => \my $PrintCflagsOnlyI,
-    'cflags-only-other' => \my $PrintCflagsOnlyOther,
-    'exists' => \my $PrintExists,
-    'atleast-version=s' => \my $AtLeastVersion,
-    'atleast-pkgconfig-version=s' => \my $AtLeastPkgConfigVersion,
-    'exact-version=s'   => \my $ExactVersion,
-    'max-version=s'     => \my $MaxVersion,
-    'silence-errors' => \my $SilenceErrors,
-    'print-errors' => \my $PrintErrors,
-    'errors-to-stdout' => \my $ErrToStdOut,
-    'short-errors'     => \my $ShortErrors,
-    'define-variable=s', => \my %UserVariables,
-    'print-variables' => \my $PrintVariables,
-    'print-values'  => \my $PrintValues,
-    'variable=s',   => \my $OutputVariableValue,
-    'modversion'    => \my $PrintVersion,
-    'version',      => \my $PrintAPIversion,
-    'real-version' => \my $PrintRealVersion,
-    'debug'         => \my $Debug,
-    'with-path=s',    => \my @ExtraPaths,
-    'env-only',     => \my $EnvOnly,
-    'guess-paths',  => \my $GuessPaths,
-    'h|help|?'      => \my $WantHelp
-) or pod2usage(@POD_USAGE_OPTIONS);
-if($^O eq 'msys' && !$ENV{PKG_CONFIG_NO_OS_CUSTOMIZATION}) {
-    $UseStatic = 1;
-}
-if($WantHelp) {
-    pod2usage(@POD_USAGE_OPTIONS, -exitval => 0);
-}
-if($Debug) {
-    eval {
-    Log::Fu::set_log_level('PkgConfig', 'DEBUG');
-    };
-    $PkgConfig::UseDebugging = 1;
-}
-if($GuessPaths) {
-    PkgConfig->GuessPaths();
-}
-if($PrintAPIversion) {
-    print '0.', $compat_version, "\n";
-    exit(0);
-}
-if($AtLeastPkgConfigVersion) {
-    my($major,$minor,$patch) = split /\./, $AtLeastPkgConfigVersion;
-    exit 1 if $major > 0;
-    exit 1 if $minor > $compat_version;
-    exit 1 if $minor == $compat_version && $patch > 0;
-    exit 0;
-}
-if($PrintRealVersion) {
-    printf STDOUT ("ppkg-config - cruftless pkg-config\n" .
-            "Version: %s\n", $PkgConfig::VERSION);
-    exit(0);
-}
-if($PrintErrors) {
-    $print_errors = 1;
-}
-if($SilenceErrors) {
-    $print_errors = 0;
-}
-# This option takes precedence over all other options
-# be it:
-# --silence-errors
-# or
-# --print-errors
-if ($ErrToStdOut) {
- $print_errors = 2;
-}
-my $WantFlags = ($PrintCflags || $PrintLibs || $PrintLibsOnlyL || $PrintCflagsOnlyI || $PrintCflagsOnlyOther || $PrintLibsOnlyOther || $PrintLibsOnlyl || $PrintVersion);
-if($WantFlags) {
-    $print_errors = 1 unless $SilenceErrors;
-}
-my %pc_options;
-if($PrintExists || $AtLeastVersion || $ExactVersion || $MaxVersion || $PrintVersion) {
-    $pc_options{no_recurse} = 1;
-}
-$pc_options{static} = $UseStatic;
-$pc_options{search_path} = \@ExtraPaths;
-if($EnvOnly) {
-    delete $pc_options{search_path};
-    $pc_options{search_path_override} = [ @ExtraPaths, @ENV_SEARCH_PATH];
-}
-$pc_options{print_variables} = $PrintVariables;
-$pc_options{print_values} = $PrintValues;
-$pc_options{VARS} = \%UserVariables;
-if($ListAll) {
-    my $o = PkgConfig->find([], %pc_options);
-    my @list = $o->get_list();
-    # can't use List::Util::max as it wasn't core until Perl 5.8
-    my $max_length = 0;
-    foreach my $length (map { length $_->[0] } @list) {
-        $max_length = $length if $length > $max_length;
-    }
-    printf "%-${max_length}s %s\n", $_->[0], $_->[1] for @list;
-    exit(0);
-}
-my @FINDLIBS = @ARGV or die "Must specify at least one library";
-if($AtLeastVersion) {
-    @FINDLIBS = map { "$_ >= $AtLeastVersion" } @FINDLIBS;
-} elsif($MaxVersion) {
-    @FINDLIBS = map { "$_ <= $MaxVersion" } @FINDLIBS;
-} elsif($ExactVersion) {
-    @FINDLIBS = map { "$_ = $ExactVersion" } @FINDLIBS;
-}
-my $o = PkgConfig->find(\@FINDLIBS, %pc_options);
-if($o->errmsg) {
-    # --errors-to-stdout
-    if ($print_errors == 2) {
-        print STDOUT $o->errmsg;
-    # --print-errors
-    } elsif ($print_errors == 1) {
-        print STDERR $o->errmsg;
-    }
-    # --silence-errors
-    exit(1);
-}
-if($o->print_variables) {
-    while (my ($k,$v) = each %{$o->defined_variables}) {
-        print $k;
-        if($o->print_values) {
-            print "=$v";
-        } else {
-            print "\n";
-        }
-    }
-}
-if($OutputVariableValue) {
-    my $val = ($o->_pc_var($OutputVariableValue) or "");
-    print $val . "\n";
-}
-if(!$WantFlags) {
-    exit(0);
-}
-if($PrintVersion) {
-    print $o->pkg_version . "\n";
-    exit(0);
-}
-my @print_flags;
-if($PrintCflags) {
-    @print_flags = $o->get_cflags;
-}
-if($PrintCflagsOnlyI) {
-    @print_flags = grep /^-I/, $o->get_cflags;
-}
-if($PrintCflagsOnlyOther) {
-    @print_flags = grep /^-[^I]/, $o->get_cflags;
-}
-if($PrintLibs) {
-    @print_flags = $o->get_ldflags;
-}
-if ($PrintLibsOnlyOther) {
-    @print_flags = grep /^-[^LRl]/, $o->get_ldflags;
-}
-# handle --libs-only-L and --libs-only-l but watch the case when
-# we got 'ppkg-config --libs-only-L --libs-only-l foo' which must behave just like
-# 'ppkg-config --libs-only-l foo'
-if($PrintLibsOnlyl or ($PrintLibsOnlyl and $PrintLibsOnlyL)) {
-    @print_flags = grep /^-l/, $o->get_ldflags;
-} elsif ($PrintLibsOnlyL) {
-    @print_flags = grep /^-[LR]/, $o->get_ldflags;
-}
-print scalar PkgConfig::_return_context(@print_flags);
-print "\n";
-exit(0);
-__END__
-=head1 NAME
-PkgConfig - Pure-Perl Core-Only replacement for pkg-config
-=head1 SYNOPSIS
-=head2 As a replacement for C<pkg-config>
-    $ ppkg-config --libs --cflags --static gio-2.0
-    #outputs (lines artificially broken up for readability):
-    # -I/usr/include/glib-2.0 -I/usr/lib/glib-2.0/include
-    # -pthread -lgio-2.0 -lz -lresolv -lgobject-2.0
-    # -lgmodule-2.0 -ldl -lgthread-2.0 -pthread -lrt -lglib-2.0
-C<pkg-config.pl> can be used as an alias for C<ppkg-config> on platforms that
-support it.  It can also be installed as C<pkg-config> though this is not
-recommended if your system has a native C<pkg-config>.
-Compare to:
-    $ pkg-config --libs --cflags --static gio-2.0
-    #outputs ( "" ):
-    # -pthread -I/usr/include/glib-2.0 -I/usr/lib/glib-2.0/include
-    # -pthread -lgio-2.0 -lz -lresolv -lgobject-2.0 -lgmodule-2.0
-    # -ldl -lgthread-2.0 -lrt -lglib-2.0
-=head2 From another Perl module
-    use PkgConfig;
-    my $o = PkgConfig->find('gio');
-    if($o->errmsg) {
-        #handle error
-    } else {
-        my $prefix = $o->get_var('prefix');
-        my @cflags = $o->get_cflags;
-        my @ldflags = $o->get_ldflags;
-    }
-=head1 DESCRIPTION
-C<PkgConfig> provides a pure-perl, core-only replacement for the C<pkg-config>
-utility.
-This is not a description of the uses of C<pkg-config> but rather a description
-of the differences between the C version and the Perl one.
-While C<pkg-config> is a compiled binary linked with glib, the pure-perl version
-has no such requirement, and will run wherever Perl ( >= 5.6 ) does.
-The main supported options are the common C<--libs>, C<--cflags>,
-C<--static>, C<--exists> and C<--modversion>.
-=head2 SCRIPT OPTIONS
-=head3 USAGE
-    <packagename1 pkgname2..> [ --options ]
-=head3 ARGUMENTS
-By default, a library name must be supplied unless one of L<--version>,
-or L<--real-version> is specified.
-The output should normally be suitable for passing to your favorite compiler.
-=head4 --libs
-(Also) print linker flags. Dependencies are traverse in order. Top-level dependencies
-will appear earlier in the command line than bottom-level dependencies.
-=head4 --libs-only-L
-Prints -L/-R part of "--libs". It defines library search path but without libraries to link with.
-=head4 --libs-only-l
-Prints the -l part of "--libs".
-=head4 --libs-only-other
-Prints the part of "--libs" not covered by "--libs-only-L"
-and "--libs-only-l", such as "--pthread".
-=head4 --list-all
-List all know packages.
-=head4 --cflags
-(Also) print compiler and C preprocessor flags.
-=head4 --cflags-only-I
-Prints the -I part of "--cflags"
-=head4 --cflags-only-other
-Prints the parts of "--cflags" not covered by "--cflags-only-I".
-=head4 --modversion
-Print the version of a given package.
-=head4 --static
-Use extra dependencies and libraries if linking against a static version of the
-requested library
-=head4 --exists
-Return success (0) if the package exists in the search path.
-=head4 --with-path=PATH
-Prepend C<PATH> to the list of search paths containing C<.pc> files.
-This option can be specified multiple times with different paths, and they will
-all be added.
-=head4 --env-only
-Using this option, B<only> paths specified in C<PKG_CONFIG_PATH> are recognized
-and any hard-coded defaults are ignored.
-=head4 --guess-paths
-Invoke C<gcc> and C<ld> to determine default linker and include paths. Default
-paths will be excluded from explicit -L and -I flags.
-=head4 --define-variable=VARIABLE=VALUE
-Define a variable, overriding any such variable definition in the .pc file, and
-allowing your value to interpolate with subsequent uses.
-=head4 --variable=VARIABLE
-This returns the value of a variable defined in a package's .pc file.
-=head4 --print-variables
-Print all defined variables found in the .pc files.
-=head4 --version
-The target version of C<pkg-config> emulated by this script
-=head4 --real-version
-The actual version of this script
-=head4 --debug
-Print debugging information
-=head4 --silence-errors
-Turn off errors. This is the default for non-libs/cflag/modversion
-arguments
-=head4 --print-errors
-Print errors to STDERR and takes precedence over
-C<--silence-errors>
-=head4 --short-errors
-Ignored, but recognized for compatibility.
-=head4 --errors-to-stdout
-Print errors to STDOUT and takes precedence over
-C<--print-errors>
-=head3 ENVIRONMENT
-the C<PKG_CONFIG_PATH> and C<PKG_CONFIG_LIBDIR> variables are honored and used
-as a colon-delimited (semicolon-delimited on Windows) list of directories with
-contain C<.pc> files.
-Other environment variables recongized by both C<pkg-config> and L<PkgConfig>
-include:
-=over 4
-=item PKG_CONFIG_ALLOW_SYSTEM_CFLAGS
-=item PKG_CONFIG_ALLOW_SYSTEM_LIBS
-=back
-If L<Win32API::Registry> is installed, on Windows (but not Cygwin) L<PkgConfig>
-will also consult these registry keys.  The names are ignored, but the values
-are paths containing C<.pc> files.
-=over 4
-=item HKEY_CURRENT_USER\Software\pkgconfig\PKG_CONFIG_PATH
-=item HKEY_LOCAL_MACHINE\Software\pkgconfig\PKG_CONFIG_PATH
-=back
-Registry support should be considered somewhat experimental, subject to change
-in the future, though not without good reason.  The rationale for this caveat
-is that this feature is documented in several places, but I have yet to find
-a working version that implements this feature.
-=head2 MODULE OPTIONS
-=head4 I<< PkgConfig->find >>
-    my $result = PkgConfig->find($library, %options);
-Find a library and return a result object.
-C<$library> can be either a single name of a library, or a reference to an
-array of library names
-The options are in the form of hash keys and values, and the following are
-recognized:
-=over
-=item C<search_path>
-=item C<search_path_override>
-Prepend search paths in addition to the paths specified in C<$ENV{PKG_CONFIG_PATH}>
-The value is an array reference.
-the C<_override> variant ignores defaults (like C<PKG_CONFIG_PATH>).
-=item C<file_path>
-Specifies the full path of the of the .pc file that you wish to load.  It does
-not need to be in the search path (although any dependencies will need to be).
-Useful if you know the full path of the exact .pc file that you want.
-=item C<exclude_cflags>
-=item C<exclude_ldflags>
-=item C<exclude_cflags_override>
-=item C<exclude_ldflags_override>
-Some C<.pc> files specify default compiler and linker search paths, e.g.
-C<-I/usr/include -L/usr/lib>. Specifying them on the command line can be
-problematic as it drastically changes the search order.
-The above options will either append or replace the options which are excluded
-and filtered.
-The default excluded linker and compiler options can be obtained via
-C<@PkgConfig::DEFAULT_EXCLUDE_LFLAGS> and C<@PkgConfig::DEFAULT_EXCLUDE_CFLAGS>,
-respectively.
-=item C<static>
-Also specify static libraries.
-=item C<no_recurse>
-Do not recurse dependencies. This is useful for just doing version checks.
-=item C<VARS>
-Define a hashref of variables to override any variable definitions within
-the .pc files. This is equivalent to the C<--define-variable> command-line
-option.
-=back
-A C<PkgConfig> object is returned and may be queried about the results:
-=head4 I<< $o->errmsg >>
-An error message, if any. This is a string and indicates an error.
-=head4 I<< $o->pkg_exists >>
-Boolean value, true if the package exists.
-=head4 I<< $o->pkg_version >>
-The version of the package
-=head4 I<< $o->get_cflags >>
-=head4 I<< $o->get_ldflags >>
-Returns compiler and linker flags, respectively.
-In list context, these methods return a list with each argument split on
-unescaped spaces.
-In list context returns a list of compiler and linker flags, respectively.
-In scalar context returns a string of compiler and linker flags with spaces
-and quotes escaped correctly.
-=head4 I<< $o->get_var($name) >>
-Get the variable with the given name.
-=head4 I<< PkgConfig->Guess >>
-This is a class method, and will replace the hard-coded default linker and include
-paths with those discovered by invoking L<ld(1)> and L<cpp(1)>.
-Currently this only works with GCC-supplied C<ld> and GNU C<ld>.
-=head2 INSTALL
-The C<Makefile.PL> that comes with C<PkgConfig> can take one or more C<--script>
-options to change of the name of the script or scripts that are installed.
-=over 4
-=item --script ppkg-config
-This is the default and works on all platforms
-=item --script pkg-config.pl
-This is installed by default on all platforms except for Windows, where the .pl
-may confuse the shell and cause the script to be opened in a text editor.
-=item --script pkg-config
-This is the default name of the real C<pkg-config> and so you have to specifically
-enable it if you want it.
-=item --script none
-Don't install any scripts.
-=back
-Example, install all script names:
- % perl Makefile.PL --script ppkg-config --script pkg-config.pl --script pkg-config
-Example, don't install any scripts:
- % perl Makefile.PL --script none
-You can also set the environment variable PERL_PKG_CONFIG_SCRIPTS to the
-desired --script value (separating each script name with a comma C<,>) to
-ensure that upgrades of PkgConfig do the same.
-=head2 CAVEATS
-On Strawberry Perl C<ppkg-config> acts like Strawberry is the system.
-This means that
-=over 4
-=item
-The .pc files that are bundled with Strawberry are searched by default.
-=item
-The Strawberry include and lib directories are used to compute the
-exclusion lists.
-=back
-As of Strawberry 5.20.0.1 PkgConfig is bundled with Strawberry and
-C<pkg-config> is installed by default (in addition to C<ppkg-config>,
-though the C<ppkg-config> alias is NOT bundled with Strawberry itself).
-For details on how to patch the .pc files bundled with older Strawberries,
-see the C<README.win32> that comes with this Distribution.
-=head2 BUGS
-The order of the flags is not exactly matching to that of C<pkg-config>. From my
-own observation, it seems this module does a better job, but I might be wrong.
-Unlike C<pkg-config>, the scripts C<--exists> function will return nonzero if
-a package B<or> any of its dependencies are missing. This differs from the
-behavior of C<pkg-config> which will just check for the definition of the
-package itself (without dependencies).
-=head1 SEE ALSO
-=over 4
-=item L<pkg-config|http://www.freedesktop.org/wiki/Software/pkg-config>
-The original C implementation
-=item L<pkgconf|https://github.com/pkgconf/pkgconf>
-An alternative C implementation
-=item L<PkgConfig::LibPkgConf>
-Perl bindings for C<libpkgconf>, the same library that C<pkgconf> is built on.
-=item L<ExtUtils::PkgConfig>
-A wrapper around the C<pkg-config> binary that can be used in your C<Makefile.PL>
-or C<Build.PL>.
-=item L<http://www.openbsd.org/cgi-bin/cvsweb/src/usr.bin/pkg-config/>
-Another perl implementation of pkg-config
-=item L<pkg-config|https://github.com/ruby-gnome2/pkg-config>
-Pure Ruby implementation.
-=item L<pykg-config|https://pypi.python.org/pypi/pykg-config/1.2.0>
-A Python implementation.
-=back
-=head1 AUTHOR
-=over 4
-=item Original Author: M. Nunberg
-=item Current maintainer: Graham Ollis E<lt>plicease@cpan.orgE<gt>
-=back
-Other contributors include:
-=over 4
-=item Vladimir Timofeev (vovkasm)
-=item kmx
-=item Sanel Zukan
-=item Breno G. de Oliveira (garu)
-=item Gregor Herrmann
-=item Ilya Pavlov (ILUX, Ilya33)
-=item Shawn Laffan (SLAFFAN, shawnlaffan)
-=item Ari Jolma (AJOLMA)
-=back
-=head1 COPYRIGHT AND LICENSE
-Copyright (C) 2012 M. Nunberg
-This is free software; you can redistribute it and/or modify it under the same
-terms as the Perl 5 programming language system itself.
-=cut