src/usr.bin/pkg-config/pkg-config - diff

Return to pkg-config CVS log

Up to [local] / src / usr.bin / pkg-config

Diff for /src/usr.bin/pkg-config/pkg-config between version 1.95 and 1.96

version 1.95, 2020/09/15 07:18:45

version 1.96, 2023/06/08 08:55:27

Line 16

# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF

# OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

use strict;

use v5.36;

use warnings;

use Config;

use Getopt::Long;

use File::Basename;

use File::stat;

use OpenBSD::PkgConfig;

use constant {

ONLY_I => 1,

ONLY_l => 2,

ONLY_L => 4,

ONLY_OTHER => 8

};

my @PKGPATH = qw(/usr/lib/pkgconfig

/usr/local/lib/pkgconfig

/usr/local/share/pkgconfig

Line 70

Line 76

if ($logfile) {

open my $L, ">>" , $logfile or die;

print $L beautify_list($0, @ARGV), "\n";

say $L beautify_list($0, @ARGV);

close $L;

}

Line 87

Line 93

'help' => \&help, #does not return

'usage' => \&help, #does not return

'list-all' => \$mode{list},

'version' => sub { print "$version\n" ; exit(0);} ,

'version' => sub { say $version ; exit(0);} ,

'errors-to-stdout' => sub { $mode{estdout} = 1},

'print-errors' => sub { $mode{printerr} = 1},

'silence-errors' => sub { $mode{printerr} = 0},

Line 97

Line 103

'print-requires' => \$mode{printrequires},

'print-requires-private' => \$mode{printrequiresprivate},

'cflags' => sub { $mode{cflags} = 3},

'cflags' => sub { $mode{cflags} = ONLY_I|ONLY_OTHER},

'cflags-only-I' => sub { $mode{cflags} |= 1},

'cflags-only-I' => sub { $mode{cflags} |= ONLY_I},

'cflags-only-other' => sub { $mode{cflags} |= 2},

'cflags-only-other' => sub { $mode{cflags} |= ONLY_OTHER},

'libs' => sub { $mode{libs} = 7},

'libs' => sub { $mode{libs} = ONLY_L|ONLY_l|ONLY_OTHER},

'libs-only-l' => sub { $mode{libs} |= 1},

'libs-only-l' => sub { $mode{libs} |= ONLY_l},

'libs-only-L' => sub { $mode{libs} |= 2},

'libs-only-L' => sub { $mode{libs} |= ONLY_L},

'libs-only-other' => sub { $mode{libs} |= 4},

'libs-only-other' => sub { $mode{libs} |= ONLY_OTHER},

'exists' => sub { $mode{exists} = 1} ,

'validate' => sub { $mode{validate} = 1},

'static' => sub { $mode{static} = 1},

Line 164

Line 170

# When we got here we're supposed to have had at least one

# package as argument.

if (!@ARGV){

if (!@ARGV) {

say_error("No package name(s) specified.");

exit 1;

}

# Return the next module from @ARGV, if it turns out to be a comma separated

# module list, take the first one and put the rest back to the front.

sub get_next_module

sub get_next_module()

{

my $module = shift @ARGV;

my $m;

if ($module =~ m/,/) {

my @ms = split(/,/, $module);

$m = shift @ms;

unshift(@ARGV, @ms) if (scalar(@ms) > 0);

unshift(@ARGV, @ms) if @ms != 0;

} else {

return $module;

}

return $m;

}

while (@ARGV){

while (@ARGV) {

my $p = get_next_module();

my $op = undef;

my $v = undef;

Line 267

Line 273

if ($mode{cflags} || $mode{libs} || $mode{variable}) {

push @vlist, do_cflags($dep_cfg_list) if $mode{cflags};

push @vlist, do_libs($dep_cfg_list) if $mode{libs};

print join(' ', @vlist), "\n" if $rc == 0;

say join(' ', @vlist) if $rc == 0;

}

exit $rc;

###########################################################################

sub handle_config

sub handle_config($p, $op, $v, $list)

{

my ($p, $op, $v, $list) = @_;

my $cfg = cache_find_config($p);

unshift @$list, $p if defined $cfg;

Line 294

Line 299

}

my $get_props = sub {

my $get_props = sub($property) {

my $property = shift;

my $pkg;

# See if there's anything in the environment that we need to

Line 316

Line 320

my $deps = $cfg->get_property($property, $variables);

return unless defined $deps;

for my $dep (@$deps) {

if ($dep =~ m/^(.*?)\s*([<=>]+)\s*([\d\.]+|[\d\.]+[\w]*[\d]+)$/) {

if ($dep =~ m/^(.*?)\s*([<=>]+)\s*([\d\.]+|[\d\.]+\w*\d+)$/) {

handle_config($1, $2, $3, $list);

} else {

handle_config($dep, undef, undef, $list);

Line 339

Line 343

# look for the .pc file in each of the PKGPATH elements. Return the path or

# undef if it's not there

sub pathresolve

sub pathresolve($p)

{

my ($p) = @_;

if ($allow_uninstalled && $p !~ m/\-uninstalled$/) {

for my $d (@PKGPATH) {

my $f = "$d/$p-uninstalled.pc";

Line 362

Line 364

return undef;

}

sub get_config

sub get_config($f)

{

my ($f) = @_;

my $cfg;

eval {

$cfg = OpenBSD::PkgConfig->read_file($f);

};

if (!$@) {

return validate_config($f, $cfg);

Line 378

return undef;

}

sub cache_find_config

sub cache_find_config($name)

{

my $name = shift;

say_debug("processing $name");

if (exists $configs{$name}) {

Line 392

Line 390

}

# Required elements for a valid .pc file: Name, Description, Version

sub validate_config

sub validate_config($f, $cfg)

{

my ($f, $cfg) = @_;

my @required_elems = ('Name', 'Description', 'Version');

# Check if we're dealing with an empty file, but don't error out just

Line 417

Line 414

# pkg-config won't install a pkg-config.pc file itself, but it may be

# listed as a dependency in other files. so prime the cache with self.

sub setup_self

sub setup_self()

{

my $pkg_pc = OpenBSD::PkgConfig->new;

$pkg_pc->add_property('Version', $version);

Line 427

Line 424

$configs{'pkg-config'} = $pkg_pc;

}

sub find_config

sub find_config($p)

{

my ($p) = @_;

# Differentiate between getting a full path and just the module name.

my $f = ($p =~ m/\.pc$/ ? $p : pathresolve($p));

Line 441

Line 436

return undef;

}

sub stringize

sub stringize($list, $sep = ',')

{

my $list = shift;

my $sep = shift || ',';

if (defined $list) {

return join($sep, @$list)

} else {

Line 454

Line 446

}

#if the variable option is set, pull out the named variable

sub do_variable

sub do_variable($p, $v)

{

my ($p, $v) = @_;

my $cfg = cache_find_config($p);

if (defined $cfg) {

Line 472

Line 462

#if the modversion or print-provides options are set,

#pull out the compiler flags

sub do_modversion

sub do_modversion($p)

{

my ($p) = @_;

my $cfg = cache_find_config($p);

if (defined $cfg) {

my $value = $cfg->get_property('Version', $variables);

if (defined $value) {

if (defined($mode{printprovides})){

print "$p = " . stringize($value) . "\n";

say "$p = " , stringize($value);

return undef;

} else {

print stringize($value), "\n";

say stringize($value);

return undef;

}

Line 494

Line 482

}

#if the cflags option is set, pull out the compiler flags

sub do_cflags

sub do_cflags($list)

{

my $list = shift;

my $cflags = [];

for my $pkg (@$list) {

my $l = $configs{$pkg}->get_property('Cflags', $variables);

PATH: for my $path (@$l) {

for my $sys_path (@sys_includes) {

next PATH if ($path =~ /${sys_path}\/*$/);

next PATH if $path =~ /\Q${sys_path}\E\/*$/;

}

push(@$cflags, $path);

}

my $a = OpenBSD::PkgConfig->compress($cflags,

sub {

sub($r) {

local $_ = shift;

if (($mode{cflags} & ONLY_I) && $r =~ /^-I/ ||

if (($mode{cflags} & 1) && /^-I/ ||

($mode{cflags} & ONLY_OTHER) && $r !~ /^-I/) {

($mode{cflags} & 2) && !/^-I/) {

return 1;

} else {

return 0;

}

});

if (defined($a) && defined($variables->{pc_sysrootdir})){

if (defined($variables->{pc_sysrootdir})){

$a =~ s/[\w]?-I/$&$variables->{pc_sysrootdir}/g;

}

Line 527

Line 512

}

#if the lib option is set, pull out the linker flags

sub do_libs

sub do_libs($list)

{

my $list = shift;

my $libs = [];

# In static mode, we have to make sure we discover the libs in dependency

Line 556

Line 539

# Get the linker path directives (-L) and store it in $a.

# $b will be the actual libraries.

my $a = OpenBSD::PkgConfig->compress($libs,

my $r = OpenBSD::PkgConfig->compress_list($libs,

sub {

sub($r) {

local $_ = shift;

if (($mode{libs} & ONLY_L) && $r =~ /^-L/ ||

if (($mode{libs} & 2) && /^-L/ ||

($mode{libs} & ONLY_OTHER) && $r !~ /^-[lL]/) {

($mode{libs} & 4) && !/^-[lL]/) {

return 1;

} else {

return 0;

Line 568

Line 550

});

if (defined($variables->{pc_sysrootdir})){

$a =~ s/[\w]?-[lL]/$&$variables->{pc_sysrootdir}/g;

for my $i (@$r) {

$i =~ s/[\w]?-[lL]/$&$variables->{pc_sysrootdir}/;

}

if ($mode{libs} & 1) {

if ($mode{libs} & ONLY_l) {

my $b = OpenBSD::PkgConfig->rcompress($libs,

push(@$r, OpenBSD::PkgConfig->rcompress($libs,

sub { shift =~ m/^-l/; });

sub($l) { $l =~ m/^-l/; }));

return ($a, $b);

} else {

return $a;

}

return @$r;

}

#list all packages

sub do_list

sub do_list()

{

my ($p, $x, $y, @files, $fname, $name);

my $error = 0;

for my $p (@PKGPATH) {

Line 616

Line 599

return $error;

}

sub help

sub help(@)

{

print <<EOF

Usage: $0 [options]

Line 655

Line 638

}

# do we meet/beat the version the caller requested?

sub self_version

sub self_version($v)

{

my ($v) = @_;

my (@a, @b);

@a = split(/\./, $v);

Line 670

Line 652

}

sub compare

sub parse_suffix($s)

{

my ($a, $b) = @_;

my @l = ();

my ($full_a, $full_b) = ($a, $b);

my $full = $s;

my (@suffix_a, @suffix_b);

return 0 if ($a eq $b);

# is there a valid non-numeric suffix to deal with later?

# accepted are (in order): a(lpha) < b(eta) < rc < ' '.

# suffix[0] is the 'alpha' part, suffix[1] is the '1' part in 'alpha1'.

if ($a =~ s/(rc|beta|b|alpha|a)(\d+)$//) {

if ($s =~ s/(rc|beta|b|alpha|a)(\d+)$//) {

say_debug("valid suffix $1$2 found in $a$1$2.");

@l = ($1, $2);

$suffix_a[0] = $1;

$suffix_a[1] = $2;

}

# also deal with -stable extension

if ($b =~ s/(rc|beta|b|alpha|a)(\d+)$//) {

elsif ($s =~ s/(\-stable)$//) {

say_debug("valid suffix $1$2 found in $b$1$2.");

@l = ($1);

$suffix_b[0] = $1;

$suffix_b[1] = $2;

}

# The above are standard suffixes; deal with single alphabetical

# suffixes too, e.g. 1.0.1h

if ($a =~ s/([a-zA-Z]){1}$//) {

elsif ($s =~ s/([a-zA-Z]){1}$//) {

say_debug("valid suffix $1 found in $a$1.");

@l = ($1);

$suffix_a[0] = $1;

}

if ($b =~ s/([a-zA-Z]){1}$//) {

if (@l) {

say_debug("valid suffix $1 found in $b$1.");

say_debug("valid suffix @l found in $full.");

$suffix_b[0] = $1;

}

return ($s, @l);

}

sub compare($full_a, $full_b)

{

return 0 if $full_a eq $full_b;

my ($a, @suffix_a) = parse_suffix($full_a);

my ($b, @suffix_b) = parse_suffix($full_b);

my @a = split(/\./, $a);

my @b = split(/\./, $b);

Line 723

Line 704

# directly compare suffixes, provided both suffixes

# are present.

if (@suffix_a && @suffix_b) {

my $first_char = sub {

my $first_char = sub($s) {

return substr(shift, 0, 1);

return substr($s, 0, 1);

};

# suffixes are equal, compare on numeric

Line 769

Line 750

}

# simple numeric comparison, with optional equality test.

sub compare_numeric

sub compare_numeric($x, $y, $eq)

{

my ($x, $y, $eq) = @_;

return 1 if $x > $y;

return -1 if $x < $y;

return 0 if (($x == $y) and ($eq == 1));

Line 780

Line 759

}

# got a package meeting the requested specific version?

sub versionmatch

sub versionmatch($cfg, $op, $want)

{

my ($cfg, $op, $want) = @_;

# can't possibly match if we can't find the file

return 0 if !defined $cfg;

Line 802

Line 779

elsif ($op eq '<=') { return $value <= 0; }

}

sub mismatch

sub mismatch($p, $cfg, $op, $v)

{

my ($p, $cfg, $op, $v) = @_;

my $name = stringize($cfg->get_property('Name'), ' ');

my $version = stringize($cfg->get_property('Version'));

my $url = stringize($cfg->get_property('URL'));

Line 813

Line 789

say_warning("You may find new versions of $name at $url") if $url;

}

sub simplify_and_reverse

sub simplify_and_reverse($reqlist)

{

my $reqlist = shift;

my $dejavu = {};

my $result = [];

Line 829

Line 804

}

# retrieve and print Requires(.private)

sub print_requires

sub print_requires($p)

{

my ($p) = @_;

my $cfg = cache_find_config($p);

if (defined($cfg)) {

Line 848

Line 821

}

if (defined($value)) {

print "$_\n" for @$value;

say $_ for @$value;

return undef;

}

Line 856

Line 829

$rc = 1;

}

sub beautify_list

sub beautify_list(@p)

{

return join(' ', map {"[$_]"} @_);

return join(' ', map {"[$_]"} @p);

}

sub say_debug

sub say_debug($msg)

{

say_msg(shift) if $mode{debug};

say_msg($msg) if $mode{debug};

}

sub say_error

sub say_error($msg)

{

say_msg(shift) if $mode{printerr}

say_msg($msg) if $mode{printerr}

}

sub say_warning

sub say_warning($msg)

{

say_msg(shift);

say_msg($msg);

}

sub say_msg

sub say_msg($str)

{

my $str = shift;

# If --errors-to-stdout was given, close STDERR (to be safe),

# then dup the output to STDOUT and delete the key from %mode so we

# won't keep checking it. STDERR stays dup'ed.

Line 889

Line 860

delete($mode{estdout});

}

print STDERR $str, "\n";

say STDERR $str;

}