javonet-ruby-sdk 2.5.14 → 2.5.16

data/lib/javonet-ruby-sdk/Binaries/Perl/Linux/X64/deps/lib/perl5/Module/Runtime.pm

@@ -1,3 +1,191 @@
+package Module::Runtime;
+
+# Don't "use 5.006" here, because Perl 5.15.6 will load feature.pm if
+# the version check is done that way.
+BEGIN { require 5.006; }
+# Don't "use warnings" here, to avoid dependencies.  Do standardise the
+# warning status by lexical override; unfortunately the only safe bitset
+# to build in is the empty set, equivalent to "no warnings".
+BEGIN { ${^WARNING_BITS} = ""; }
+# Don't "use strict" here, to avoid dependencies.
+
+our $VERSION = '0.018';
+
+# Don't use Exporter here, to avoid dependencies.
+our @EXPORT_OK = qw(
+    $module_name_rx is_module_name is_valid_module_name check_module_name
+    module_notional_filename require_module
+    use_module use_package_optimistically
+    $top_module_spec_rx $sub_module_spec_rx
+    is_module_spec is_valid_module_spec check_module_spec
+    compose_module_name
+);
+my %export_ok = map { ($_ => undef) } @EXPORT_OK;
+sub import {
+    my $me = shift;
+    my $callpkg = caller;
+    my $errs = "";
+    foreach(@_) {
+        if(exists $export_ok{$_}) {
+            # We would need to do "no strict 'refs'" here
+            # if we had enabled strict at file scope.
+            if(/\A\$(.*)\z/s) {
+                *{$callpkg."::".$1} = \$$1;
+            } else {
+                *{$callpkg."::".$_} = \&$_;
+            }
+        } else {
+            $errs .= "\"$_\" is not exported by the $me module\n";
+        }
+    }
+    if($errs ne "") {
+        die sprintf "%sCan't continue after import errors at %s line %u.\n",
+            $errs, (caller)[1,2];
+    }
+}
+
+# Logic duplicated from Params::Classify.  Duplicating it here avoids
+# an extensive and potentially circular dependency graph.
+sub _is_string($) {
+    my($arg) = @_;
+    return defined($arg) && ref(\$arg) eq "SCALAR";
+}
+
+our $module_name_rx = qr{[A-Z_a-z][0-9A-Z_a-z]*(?:::[0-9A-Z_a-z]+)*};
+
+my $qual_module_spec_rx =
+    qr{(?:/|::)[A-Z_a-z][0-9A-Z_a-z]*(?:(?:/|::)[0-9A-Z_a-z]+)*};
+
+my $unqual_top_module_spec_rx =
+    qr{[A-Z_a-z][0-9A-Z_a-z]*(?:(?:/|::)[0-9A-Z_a-z]+)*};
+
+our $top_module_spec_rx = qr{$qual_module_spec_rx|$unqual_top_module_spec_rx};
+
+my $unqual_sub_module_spec_rx = qr{[0-9A-Z_a-z]+(?:(?:/|::)[0-9A-Z_a-z]+)*};
+
+our $sub_module_spec_rx = qr{$qual_module_spec_rx|$unqual_sub_module_spec_rx};
+
+sub is_module_name($) { _is_string($_[0]) && $_[0] =~ /\A$module_name_rx\z/o }
+
+*is_valid_module_name = \&is_module_name;
+
+sub check_module_name($) {
+    unless(&is_module_name) {
+        die +(_is_string($_[0]) ? "`$_[0]'" : "argument").
+            " is not a module name\n";
+    }
+}
+
+sub module_notional_filename($) {
+    &check_module_name;
+    my($name) = @_;
+    $name =~ s{::}{/}g;
+    return $name.".pm";
+}
+
+# Don't "use constant" here, to avoid dependencies.
+BEGIN {
+    ## no critic (ValuesAndExpressions::ProhibitMismatchedOperators)
+    *_WORK_AROUND_HINT_LEAKAGE =
+        "$]" < 5.011 && !("$]" >= 5.009004 && "$]" < 5.010001)
+            ? sub(){1} : sub(){0};
+    *_WORK_AROUND_BROKEN_MODULE_STATE = "$]" < 5.009 ? sub(){1} : sub(){0};
+}
+
+BEGIN {
+    if(_WORK_AROUND_BROKEN_MODULE_STATE) {
+        eval <<'END_CODE' or die $@; ## no critic (BuiltinFunctions::ProhibitStringyEval)
+            sub Module::Runtime::__GUARD__::DESTROY {
+                delete $INC{$_[0]->[0]} if @{$_[0]};
+            }
+            1;
+END_CODE
+    }
+}
+
+sub require_module($) {
+    # Localise %^H to work around [perl #68590], where the bug exists
+    # and this is a satisfactory workaround.  The bug consists of
+    # %^H state leaking into each required module, polluting the
+    # module's lexical state.
+    local %^H if _WORK_AROUND_HINT_LEAKAGE;
+    if(_WORK_AROUND_BROKEN_MODULE_STATE) {
+        my $notional_filename = &module_notional_filename;
+        my $guard = bless([ $notional_filename ],
+            "Module::Runtime::__GUARD__");
+        my $result = CORE::require($notional_filename);
+        pop @$guard;
+        return $result;
+    } else {
+        return scalar(CORE::require(&module_notional_filename));
+    }
+}
+
+sub use_module($;$) {
+    my($name, $version) = @_;
+    require_module($name);
+    $name->VERSION($version) if @_ >= 2;
+    return $name;
+}
+
+my $FILE = __FILE__;
+sub use_package_optimistically($;$) {
+    my($name, $version) = @_;
+    my $fn = module_notional_filename($name);
+    eval {
+        local $SIG{__DIE__};
+        require_module($name);
+        1;
+    } or do {
+        die $@ if (
+            $@ !~ /\ACan't locate \Q$fn\E .+ at \Q$FILE\E line/s ||
+            $@ =~ /^Compilation\ failed\ in\ require\ at\ \Q$FILE\E\ line/xm
+        );
+    };
+    $name->VERSION($version) if @_ >= 2;
+    return $name;
+}
+
+sub is_module_spec($$) {
+    my($prefix, $spec) = @_;
+    return _is_string($spec) && (
+        $prefix ? $spec =~ /\A$sub_module_spec_rx\z/o
+                : $spec =~ /\A$top_module_spec_rx\z/o
+    );
+}
+
+*is_valid_module_spec = \&is_module_spec;
+
+sub check_module_spec($$) {
+    unless(&is_module_spec) {
+        die +(_is_string($_[1]) ? "`$_[1]'" : "argument").
+            " is not a module specification\n";
+    }
+}
+
+sub compose_module_name($$) {
+    my($prefix, $spec) = @_;
+    check_module_name($prefix) if defined $prefix;
+    &check_module_spec;
+    if($spec =~ s{\A(?:/|::)}{}) {
+        # OK
+    } else {
+        $spec = $prefix."::".$spec if defined $prefix;
+    }
+    $spec =~ s{/}{::}g;
+    return $spec;
+}
+
+1;
+
+__END__
+
+=pod
+
+=encoding UTF-8
+
+=for :stopwords Andrew Main (Zefram) Main, Graham Knop
+
 =head1 NAME
 
 Module::Runtime - runtime module handling
@@ -5,8 +193,8 @@ Module::Runtime - runtime module handling
 =head1 SYNOPSIS
 
     use Module::Runtime qw(
-	$module_name_rx is_module_name check_module_name
-	module_notional_filename require_module);
+        $module_name_rx is_module_name check_module_name
+        module_notional_filename require_module);
 
     if($module_name =~ /\A$module_name_rx\z/o) { ...
     if(is_module_name($module_name)) { ...
@@ -21,9 +209,9 @@ Module::Runtime - runtime module handling
     $widget = use_package_optimistically("Local::Widget")->new;
 
     use Module::Runtime qw(
-	$top_module_spec_rx $sub_module_spec_rx
-	is_module_spec check_module_spec
-	compose_module_name);
+        $top_module_spec_rx $sub_module_spec_rx
+        is_module_spec check_module_spec
+        compose_module_name);
 
     if($spec =~ /\A$top_module_spec_rx\z/o) { ...
     if($spec =~ /\A$sub_module_spec_rx\z/o) { ...
@@ -56,7 +244,7 @@ pure Perl.
 
 The usable module name syntax has not changed from Perl 5.000 up to
 Perl 5.19.8.  The syntax is composed entirely of ASCII characters.
-From Perl 5.6 onwards there has been some attempt to allow the use of
+From Perl 5.6 onward there has been some attempt to allow the use of
 non-ASCII Unicode characters in Perl source, but it was fundamentally
 broken (like the entirety of Perl 5.6's Unicode handling) and remained
 pretty much entirely unusable until it got some attention in the Perl
@@ -104,61 +292,6 @@ Perl 5.11.2, and is fixed in Perl 5.11.3.  The workaround means that
 a module loaded via this module will always see the correct context.
 Modules loaded in other ways remain vulnerable.
 
-=cut
-
-package Module::Runtime;
-
-# Don't "use 5.006" here, because Perl 5.15.6 will load feature.pm if
-# the version check is done that way.
-BEGIN { require 5.006; }
-# Don't "use warnings" here, to avoid dependencies.  Do standardise the
-# warning status by lexical override; unfortunately the only safe bitset
-# to build in is the empty set, equivalent to "no warnings".
-BEGIN { ${^WARNING_BITS} = ""; }
-# Don't "use strict" here, to avoid dependencies.
-
-our $VERSION = "0.016";
-
-# Don't use Exporter here, to avoid dependencies.
-our @EXPORT_OK = qw(
-	$module_name_rx is_module_name is_valid_module_name check_module_name
-	module_notional_filename require_module
-	use_module use_package_optimistically
-	$top_module_spec_rx $sub_module_spec_rx
-	is_module_spec is_valid_module_spec check_module_spec
-	compose_module_name
-);
-my %export_ok = map { ($_ => undef) } @EXPORT_OK;
-sub import {
-	my $me = shift;
-	my $callpkg = caller(0);
-	my $errs = "";
-	foreach(@_) {
-		if(exists $export_ok{$_}) {
-			# We would need to do "no strict 'refs'" here
-			# if we had enabled strict at file scope.
-			if(/\A\$(.*)\z/s) {
-				*{$callpkg."::".$1} = \$$1;
-			} else {
-				*{$callpkg."::".$_} = \&$_;
-			}
-		} else {
-			$errs .= "\"$_\" is not exported by the $me module\n";
-		}
-	}
-	if($errs ne "") {
-		die "${errs}Can't continue after import errors ".
-			"at @{[(caller(0))[1]]} line @{[(caller(0))[2]]}.\n";
-	}
-}
-
-# Logic duplicated from Params::Classify.  Duplicating it here avoids
-# an extensive and potentially circular dependency graph.
-sub _is_string($) {
-	my($arg) = @_;
-	return defined($arg) && ref(\$arg) eq "SCALAR";
-}
-
 =head1 REGULAR EXPRESSIONS
 
 These regular expressions do not include any anchors, so to check
@@ -171,36 +304,18 @@ anchors yourself.
 
 Matches a valid Perl module name in bareword syntax.
 
-=cut
-
-our $module_name_rx = qr/[A-Z_a-z][0-9A-Z_a-z]*(?:::[0-9A-Z_a-z]+)*/;
-
 =item $top_module_spec_rx
 
-Matches a module specification for use with L</compose_module_name>,
+Matches a module specification for use with
+L<"compose_module_name"|/compose_module_name(PREFIX, SPEC)>.
 where no prefix is being used.
 
-=cut
-
-my $qual_module_spec_rx =
-	qr#(?:/|::)[A-Z_a-z][0-9A-Z_a-z]*(?:(?:/|::)[0-9A-Z_a-z]+)*#;
-
-my $unqual_top_module_spec_rx =
-	qr#[A-Z_a-z][0-9A-Z_a-z]*(?:(?:/|::)[0-9A-Z_a-z]+)*#;
-
-our $top_module_spec_rx = qr/$qual_module_spec_rx|$unqual_top_module_spec_rx/o;
-
 =item $sub_module_spec_rx
 
-Matches a module specification for use with L</compose_module_name>,
+Matches a module specification for use with
+L<"compose_module_name"|/compose_module_name(PREFIX, SPEC)>,
 where a prefix is being used.
 
-=cut
-
-my $unqual_sub_module_spec_rx = qr#[0-9A-Z_a-z]+(?:(?:/|::)[0-9A-Z_a-z]+)*#;
-
-our $sub_module_spec_rx = qr/$qual_module_spec_rx|$unqual_sub_module_spec_rx/o;
-
 =back
 
 =head1 FUNCTIONS
@@ -214,17 +329,9 @@ our $sub_module_spec_rx = qr/$qual_module_spec_rx|$unqual_sub_module_spec_rx/o;
 Returns a truth value indicating whether I<ARG> is a plain string
 satisfying Perl module name syntax as described for L</$module_name_rx>.
 
-=cut
-
-sub is_module_name($) { _is_string($_[0]) && $_[0] =~ /\A$module_name_rx\z/o }
-
 =item is_valid_module_name(ARG)
 
-Deprecated alias for L</is_module_name>.
-
-=cut
-
-*is_valid_module_name = \&is_module_name;
+Deprecated alias for L<"is_module_name"|/is_module_name(ARG)>.
 
 =item check_module_name(ARG)
 
@@ -232,15 +339,6 @@ Check whether I<ARG> is a plain string
 satisfying Perl module name syntax as described for L</$module_name_rx>.
 Return normally if it is, or C<die> if it is not.
 
-=cut
-
-sub check_module_name($) {
-	unless(&is_module_name) {
-		die +(_is_string($_[0]) ? "`$_[0]'" : "argument").
-			" is not a module name\n";
-	}
-}
-
 =item module_notional_filename(NAME)
 
 Generates a notional relative filename for a module, which is used in
@@ -255,15 +353,6 @@ and a C<.pm> suffix.  This kind of filename can be used as an argument to
 C<require>, and is the key that appears in C<%INC> to identify a module,
 regardless of actual local filename syntax.
 
-=cut
-
-sub module_notional_filename($) {
-	&check_module_name;
-	my($name) = @_;
-	$name =~ s!::!/!g;
-	return $name.".pm";
-}
-
 =item require_module(NAME)
 
 This is essentially the bareword form of C<require>, in runtime form.
@@ -280,41 +369,6 @@ The return value is as for C<require>.  That is, it is the value returned
 by the module itself if the module is loaded anew, or C<1> if the module
 was already loaded.
 
-=cut
-
-# Don't "use constant" here, to avoid dependencies.
-BEGIN {
-	*_WORK_AROUND_HINT_LEAKAGE =
-		"$]" < 5.011 && !("$]" >= 5.009004 && "$]" < 5.010001)
-			? sub(){1} : sub(){0};
-	*_WORK_AROUND_BROKEN_MODULE_STATE = "$]" < 5.009 ? sub(){1} : sub(){0};
-}
-
-BEGIN { if(_WORK_AROUND_BROKEN_MODULE_STATE) { eval q{
-	sub Module::Runtime::__GUARD__::DESTROY {
-		delete $INC{$_[0]->[0]} if @{$_[0]};
-	}
-	1;
-}; die $@ if $@ ne ""; } }
-
-sub require_module($) {
-	# Localise %^H to work around [perl #68590], where the bug exists
-	# and this is a satisfactory workaround.  The bug consists of
-	# %^H state leaking into each required module, polluting the
-	# module's lexical state.
-	local %^H if _WORK_AROUND_HINT_LEAKAGE;
-	if(_WORK_AROUND_BROKEN_MODULE_STATE) {
-		my $notional_filename = &module_notional_filename;
-		my $guard = bless([ $notional_filename ],
-				"Module::Runtime::__GUARD__");
-		my $result = CORE::require($notional_filename);
-		pop @$guard;
-		return $result;
-	} else {
-		return scalar(CORE::require(&module_notional_filename));
-	}
-}
-
 =back
 
 =head2 Structured module use
@@ -334,22 +388,14 @@ ensure that the version loaded is at least the version required.  This is
 the same functionality provided by the I<VERSION> parameter of C<use>.
 
 On success, the name of the module is returned.  This is unlike
-L</require_module>, and is done so that the entire call to L</use_module>
-can be used as a class name to call a constructor, as in the example in
-the synopsis.
-
-=cut
-
-sub use_module($;$) {
-	my($name, $version) = @_;
-	require_module($name);
-	$name->VERSION($version) if @_ >= 2;
-	return $name;
-}
+L<"require_module"|/require_module(NAME)>, and is done so that the entire call
+to L<"use_module"|/use_module(NAME[, VERSION])> can be used as a class name to
+call a constructor, as in the example in the synopsis.
 
 =item use_package_optimistically(NAME[, VERSION])
 
-This is an analogue of L</use_module> for the situation where there is
+This is an analogue of L<"use_module"|/use_module(NAME[, VERSION])> for
+the situation where there is
 uncertainty as to whether a package/class is defined in its own module
 or by some other means.  It attempts to arrange for the named package to
 be available, either by loading a module or by doing nothing and hoping.
@@ -357,7 +403,7 @@ be available, either by loading a module or by doing nothing and hoping.
 An attempt is made to load the named module (as if by the bareword form
 of C<require>).  If the module cannot be found then it is assumed that
 the package was actually already loaded by other means, and no error
-is signalled.  That's the optimistic bit.
+is signaled.  That's the optimistic bit.
 
 I<Warning:> this optional module loading is liable to cause unreliable
 behaviour, including security problems.  It interacts especially badly
@@ -381,21 +427,7 @@ If a I<VERSION> is specified, the C<VERSION> method of the loaded package is
 called with the specified I<VERSION> as an argument.  This normally serves
 to ensure that the version loaded is at least the version required.
 On success, the name of the package is returned.  These aspects of the
-function work just like L</use_module>.
-
-=cut
-
-sub use_package_optimistically($;$) {
-	my($name, $version) = @_;
-	my $fn = module_notional_filename($name);
-	eval { local $SIG{__DIE__}; require_module($name); };
-	die $@ if $@ ne "" &&
-		($@ !~ /\ACan't locate \Q$fn\E .+ at \Q@{[__FILE__]}\E line/s ||
-		 $@ =~ /^Compilation\ failed\ in\ require
-			 \ at\ \Q@{[__FILE__]}\E\ line/xm);
-	$name->VERSION($version) if @_ >= 2;
-	return $name;
-}
+function work just like L<"use_module"|/use_module(NAME[, VERSION])>.
 
 =back
 
@@ -406,42 +438,22 @@ sub use_package_optimistically($;$) {
 =item is_module_spec(PREFIX, SPEC)
 
 Returns a truth value indicating
-whether I<SPEC> is valid input for L</compose_module_name>.
+whether I<SPEC> is valid input for
+L<"compose_module_name"|/compose_module_name(PREFIX, SPEC)>.
 See below for what that entails.  Whether a I<PREFIX> is supplied affects
 the validity of I<SPEC>, but the exact value of the prefix is unimportant,
 so this function treats I<PREFIX> as a truth value.
 
-=cut
-
-sub is_module_spec($$) {
-	my($prefix, $spec) = @_;
-	return _is_string($spec) &&
-		$spec =~ ($prefix ? qr/\A$sub_module_spec_rx\z/o :
-				    qr/\A$top_module_spec_rx\z/o);
-}
-
 =item is_valid_module_spec(PREFIX, SPEC)
 
-Deprecated alias for L</is_module_spec>.
-
-=cut
-
-*is_valid_module_spec = \&is_module_spec;
+Deprecated alias for L<"is_module_spec"|/is_module_spec(PREFIX, SPEC)>.
 
 =item check_module_spec(PREFIX, SPEC)
 
-Check whether I<SPEC> is valid input for L</compose_module_name>.
+Check whether I<SPEC> is valid input for
+L<"compose_module_name"|/compose_module_name(PREFIX, SPEC)>.
 Return normally if it is, or C<die> if it is not.
 
-=cut
-
-sub check_module_spec($$) {
-	unless(&is_module_spec) {
-		die +(_is_string($_[1]) ? "`$_[1]'" : "argument").
-			" is not a module specification\n";
-	}
-}
-
 =item compose_module_name(PREFIX, SPEC)
 
 This function is intended to make it more convenient for a user to specify
@@ -461,40 +473,33 @@ name in standard form, and it is prefixed to the user-specified name.
 The user can inhibit the prefix addition by starting I<SPEC> with a
 separator (either C</> or C<::>).
 
-=cut
-
-sub compose_module_name($$) {
-	my($prefix, $spec) = @_;
-	check_module_name($prefix) if defined $prefix;
-	&check_module_spec;
-	if($spec =~ s#\A(?:/|::)##) {
-		# OK
-	} else {
-		$spec = $prefix."::".$spec if defined $prefix;
-	}
-	$spec =~ s#/#::#g;
-	return $spec;
-}
-
 =back
 
 =head1 BUGS
 
 On Perl versions 5.7.2 to 5.8.8, if C<require> is overridden by the
 C<CORE::GLOBAL> mechanism, it is likely to break the heuristics used by
-L</use_package_optimistically>, making it signal an error for a missing
+L<"use_package_optimistically"|/use_package_optimistically(NAME[, VERSION])>,
+making it signal an error for a missing
 module rather than assume that it was already loaded.  From Perl 5.8.9
-onwards, and on 5.7.1 and earlier, this module can avoid being confused
+onward, and on 5.7.1 and earlier, this module can avoid being confused
 by such an override.  On the affected versions, a C<require> override
 might be installed by L<Lexical::SealRequireHints>, if something requires
 its bugfix but for some reason its XS implementation isn't available.
 
 =head1 SEE ALSO
 
-L<Lexical::SealRequireHints>,
-L<base>,
-L<perlfunc/require>,
-L<perlfunc/use>
+=over 4
+
+=item * L<Lexical::SealRequireHints>
+
+=item * L<base>
+
+=item * L<perlfunc/require>
+
+=item * L<perlfunc/use>
+
+=back
 
 =head1 AUTHOR
 
@@ -505,11 +510,11 @@ Andrew Main (Zefram) <zefram@fysh.org>
 Copyright (C) 2004, 2006, 2007, 2009, 2010, 2011, 2012, 2014, 2017
 Andrew Main (Zefram) <zefram@fysh.org>
 
+Copyright (C) 2025 Graham Knop <haarg@haarg.org>
+
 =head1 LICENSE
 
 This module is free software; you can redistribute it and/or modify it
 under the same terms as Perl itself.
 
 =cut
-
-1;

data/lib/javonet-ruby-sdk/Binaries/Perl/Linux/X64/deps/lib/perl5/x86_64-linux-gnu-thread-multi/auto/share/dist/FFI-Platypus/include/ffi_platypus_config.h

@@ -3,8 +3,8 @@
 
 #define PERL_OS_LINUX 1
 #define FFI_PL_PERL_VERSION_MAJOR 5
-#define FFI_PL_PERL_VERSION_MINOR 30
-#define FFI_PL_PERL_VERSION_PATCH 0
+#define FFI_PL_PERL_VERSION_MINOR 38
+#define FFI_PL_PERL_VERSION_PATCH 2
 #define FFI_PL_VERSION_MAJOR 2
 #define FFI_PL_VERSION_MINOR 10
 #define FFI_PL_VERSION_PATCH 0