javonet-ruby-sdk 2.5.16 → 2.5.18

data/lib/javonet-ruby-sdk/Binaries/Perl/Linux/X64/deps/lib/perl5/x86_64-linux-gnu-thread-multi/Scalar/List/Utils.pm

@@ -0,0 +1,43 @@
+package Scalar::List::Utils;
+use strict;
+use warnings;
+
+our $VERSION    = "1.69";
+$VERSION =~ tr/_//d;
+
+1;
+
+__END__
+
+=head1 NAME
+
+Scalar::List::Utils - A distribution of general-utility subroutines
+
+=head1 SYNOPSIS
+
+    use Scalar::Util qw(blessed);
+    use List::Util qw(any);
+
+=head1 DESCRIPTION
+
+C<Scalar::List::Utils> does nothing on its own. It is packaged with several
+useful modules.
+
+=head1 MODULES
+
+=head2 L<List::Util>
+
+L<List::Util> contains a selection of useful subroutines for operating on lists
+of values.
+
+=head2 L<Scalar::Util>
+
+L<Scalar::Util> contains a selection of useful subroutines for interrogating
+or manipulating scalar values.
+
+=head2 L<Sub::Util>
+
+L<Sub::Util> contains a selection of useful subroutines for interrogating
+or manipulating subroutine references.
+
+=cut

data/lib/javonet-ruby-sdk/Binaries/Perl/Linux/X64/deps/lib/perl5/x86_64-linux-gnu-thread-multi/Scalar/Util.pm

@@ -0,0 +1,380 @@
+# Copyright (c) 1997-2007 Graham Barr <gbarr@pobox.com>. All rights reserved.
+# This program is free software; you can redistribute it and/or
+# modify it under the same terms as Perl itself.
+#
+# Maintained since 2013 by Paul Evans <leonerd@leonerd.org.uk>
+
+package Scalar::Util;
+
+use strict;
+use warnings;
+require Exporter;
+
+our @ISA       = qw(Exporter);
+our @EXPORT_OK = qw(
+  blessed refaddr reftype weaken unweaken isweak
+
+  dualvar isdual isvstring looks_like_number openhandle readonly set_prototype
+  tainted
+);
+our $VERSION    = "1.69";
+$VERSION =~ tr/_//d;
+
+require List::Util; # List::Util loads the XS
+List::Util->VERSION( $VERSION ); # Ensure we got the right XS version (RT#100863)
+
+if( $] >= 5.040 ) {
+  # On Perl 5.40 and above, these builtins are stable, so we can use them
+  # instead of our own XS implementation
+
+  # Using this instead of a globref means we don't create an empty
+  # "builtins::" glob on older perls
+  no strict 'refs';
+  my $builtins = \%{"builtin::"};
+
+  *$_ = \&{ $builtins->{$_} } for (qw( blessed refaddr reftype weaken unweaken ));
+  *isweak = \&{ $builtins->{is_weak} };  # renamed
+}
+
+# set_prototype has been moved to Sub::Util with a different interface
+sub set_prototype(&$)
+{
+  my ( $code, $proto ) = @_;
+  return Sub::Util::set_prototype( $proto, $code );
+}
+
+1;
+
+__END__
+
+=head1 NAME
+
+Scalar::Util - A selection of general-utility scalar subroutines
+
+=head1 SYNOPSIS
+
+    use Scalar::Util qw(blessed dualvar isdual readonly refaddr reftype
+                        tainted weaken isweak isvstring looks_like_number
+                        set_prototype);
+                        # and other useful utils appearing below
+
+=head1 DESCRIPTION
+
+C<Scalar::Util> contains a selection of subroutines that people have expressed
+would be nice to have in the perl core, but the usage would not really be high
+enough to warrant the use of a keyword, and the size would be so small that 
+being individual extensions would be wasteful.
+
+By default C<Scalar::Util> does not export any subroutines.
+
+=head2 Core Perl C<builtin> Functions
+
+Many functions in this module have served as the inspiration for a new
+experimental facility in recent versions of Perl. From various development
+versions, starting at 5.35.7, equivalent functions to many of these utilities
+are available in the C<builtin::> package.
+
+    use Scalar::Util qw(blessed);
+
+    $class = blessed $obj;
+
+    $class = builtin::blessed $obj;  # equivalent
+
+For more information, see the documentation on L<builtin>.
+
+=cut
+
+=head1 FUNCTIONS FOR REFERENCES
+
+The following functions all perform some useful activity on reference values.
+
+=head2 blessed
+
+    my $pkg = blessed( $ref );
+
+If C<$ref> is a blessed reference, the name of the package that it is blessed
+into is returned. Otherwise C<undef> is returned.
+
+    $scalar = "foo";
+    $class  = blessed $scalar;           # undef
+
+    $ref    = [];
+    $class  = blessed $ref;              # undef
+
+    $obj    = bless [], "Foo";
+    $class  = blessed $obj;              # "Foo"
+
+Take care when using this function simply as a truth test (such as in
+C<if(blessed $ref)...>) because the package name C<"0"> is defined yet false.
+
+I<Since Perl version 5.35.7> an equivalent function is available as
+C<builtin::blessed>.
+
+=head2 refaddr
+
+    my $addr = refaddr( $ref );
+
+If C<$ref> is reference, the internal memory address of the referenced value is
+returned as a plain integer. Otherwise C<undef> is returned.
+
+    $addr = refaddr "string";           # undef
+    $addr = refaddr \$var;              # eg 12345678
+    $addr = refaddr [];                 # eg 23456784
+
+    $obj  = bless {}, "Foo";
+    $addr = refaddr $obj;               # eg 88123488
+
+I<Since Perl version 5.35.7> an equivalent function is available as
+C<builtin::refaddr>.
+
+=head2 reftype
+
+    my $type = reftype( $ref );
+
+If C<$ref> is a reference, the basic Perl type of the variable referenced is
+returned as a plain string (such as C<ARRAY> or C<HASH>). Otherwise C<undef>
+is returned.
+
+    $type = reftype "string";           # undef
+    $type = reftype \$var;              # SCALAR
+    $type = reftype [];                 # ARRAY
+
+    $obj  = bless {}, "Foo";
+    $type = reftype $obj;               # HASH
+
+Note that for internal reasons, all precompiled regexps (C<qr/.../>) are
+blessed references; thus C<ref()> returns the package name string C<"Regexp">
+on these but C<reftype()> will return the underlying C structure type of
+C<"REGEXP"> in all capitals.
+
+I<Since Perl version 5.35.7> an equivalent function is available as
+C<builtin::reftype>.
+
+=head2 weaken
+
+    weaken( $ref );
+
+The lvalue C<$ref> will be turned into a weak reference. This means that it
+will not hold a reference count on the object it references. Also, when the
+reference count on that object reaches zero, the reference will be set to
+undef. This function mutates the lvalue passed as its argument and returns no
+value.
+
+This is useful for keeping copies of references, but you don't want to prevent
+the object being DESTROY-ed at its usual time.
+
+    {
+      my $var;
+      $ref = \$var;
+      weaken($ref);                     # Make $ref a weak reference
+    }
+    # $ref is now undef
+
+Note that if you take a copy of a scalar with a weakened reference, the copy
+will be a strong reference.
+
+    my $var;
+    my $foo = \$var;
+    weaken($foo);                       # Make $foo a weak reference
+    my $bar = $foo;                     # $bar is now a strong reference
+
+This may be less obvious in other situations, such as C<grep()>, for instance
+when grepping through a list of weakened references to objects that may have
+been destroyed already:
+
+    @object = grep { defined } @object;
+
+This will indeed remove all references to destroyed objects, but the remaining
+references to objects will be strong, causing the remaining objects to never be
+destroyed because there is now always a strong reference to them in the @object
+array.
+
+I<Since Perl version 5.35.7> an equivalent function is available as
+C<builtin::weaken>.
+
+=head2 unweaken
+
+    unweaken( $ref );
+
+I<Since version 1.36.>
+
+The lvalue C<REF> will be turned from a weak reference back into a normal
+(strong) reference again. This function mutates the lvalue passed as its
+argument and returns no value. This undoes the action performed by
+L</weaken>.
+
+This function is slightly neater and more convenient than the
+otherwise-equivalent code
+
+    my $tmp = $REF;
+    undef $REF;
+    $REF = $tmp;
+
+(because in particular, simply assigning a weak reference back to itself does
+not work to unweaken it; C<$REF = $REF> does not work).
+
+I<Since Perl version 5.35.7> an equivalent function is available as
+C<builtin::unweaken>.
+
+=head2 isweak
+
+    my $weak = isweak( $ref );
+
+Returns true if C<$ref> is a weak reference.
+
+    $ref  = \$foo;
+    $weak = isweak($ref);               # false
+    weaken($ref);
+    $weak = isweak($ref);               # true
+
+B<NOTE>: Copying a weak reference creates a normal, strong, reference.
+
+    $copy = $ref;
+    $weak = isweak($copy);              # false
+
+I<Since Perl version 5.35.7> an equivalent function is available as
+C<builtin::is_weak>.
+
+=head1 OTHER FUNCTIONS
+
+=head2 dualvar
+
+    my $var = dualvar( $num, $string );
+
+Returns a scalar that has the value C<$num> in a numeric context and the value
+C<$string> in a string context.
+
+    $foo = dualvar 10, "Hello";
+    $num = $foo + 2;                    # 12
+    $str = $foo . " world";             # Hello world
+
+=head2 isdual
+
+    my $dual = isdual( $var );
+
+I<Since version 1.26.>
+
+If C<$var> is a scalar that has both numeric and string values, the result is
+true.
+
+    $foo = dualvar 86, "Nix";
+    $dual = isdual($foo);               # true
+
+Note that a scalar can be made to have both string and numeric content through
+standard operations:
+
+    $foo = "10";
+    $dual = isdual($foo);               # false
+    $bar = $foo + 0;
+    $dual = isdual($foo);               # true
+
+The C<$!> variable is commonly dual-valued, though it is also magical in other
+ways:
+
+    $! = 1;
+    $dual = isdual($!);                 # true
+    print("$!\n");                      # "Operation not permitted"
+
+B<CAUTION>: This function is not as useful as it may seem. Dualvars are not a
+distinct concept in Perl, but a standard internal construct of all scalar
+values. Almost any value could be considered as a dualvar by this function
+through the course of normal operations.
+
+=head2 isvstring
+
+    my $vstring = isvstring( $var );
+
+If C<$var> is a scalar which was coded as a vstring, the result is true.
+
+    $vs   = v49.46.48;
+    $fmt  = isvstring($vs) ? "%vd" : "%s"; #true
+    printf($fmt,$vs);
+
+=head2 looks_like_number
+
+    my $isnum = looks_like_number( $var );
+
+Returns true if perl thinks C<$var> is a number. See
+L<perlapi/looks_like_number>.
+
+=head2 openhandle
+
+    my $fh = openhandle( $fh );
+
+Returns C<$fh> itself, if C<$fh> may be used as a filehandle and is open, or if
+it is a tied handle. Otherwise C<undef> is returned.
+
+    $fh = openhandle(*STDIN);           # \*STDIN
+    $fh = openhandle(\*STDIN);          # \*STDIN
+    $fh = openhandle(*NOTOPEN);         # undef
+    $fh = openhandle("scalar");         # undef
+
+=head2 readonly
+
+    my $ro = readonly( $var );
+
+Returns true if C<$var> is readonly.
+
+    sub foo { readonly($_[0]) }
+
+    $readonly = foo($bar);              # false
+    $readonly = foo(0);                 # true
+
+=head2 set_prototype
+
+    my $code = set_prototype( $code, $prototype );
+
+Sets the prototype of the function given by the C<$code> reference, or deletes
+it if C<$prototype> is C<undef>. Returns the C<$code> reference itself.
+
+    set_prototype \&foo, '$$';
+
+=head2 tainted
+
+    my $t = tainted( $var );
+
+Return true if C<$var> is tainted.
+
+    $taint = tainted("constant");       # false
+    $taint = tainted($ENV{PWD});        # true if running under -T
+
+=head1 DIAGNOSTICS
+
+Module use may give one of the following errors during import.
+
+=over
+
+=item Vstrings are not implemented in this version of perl
+
+The version of perl that you are using does not implement Vstrings, to use
+L</isvstring> you will need to use a newer release of perl.
+
+=back
+
+=head1 KNOWN BUGS
+
+There is a bug in perl5.6.0 with UV's that are >= 1<<31. This will
+show up as tests 8 and 9 of dualvar.t failing
+
+=head1 SEE ALSO
+
+L<List::Util>
+
+=head1 COPYRIGHT
+
+Copyright (c) 1997-2007 Graham Barr <gbarr@pobox.com>. All rights reserved.
+This program is free software; you can redistribute it and/or modify it
+under the same terms as Perl itself.
+
+Additionally L</weaken> and L</isweak> which are
+
+Copyright (c) 1999 Tuomas J. Lukka <lukka@iki.fi>. All rights reserved.
+This program is free software; you can redistribute it and/or modify it
+under the same terms as perl itself.
+
+Copyright (C) 2004, 2008  Matthijs van Duin.  All rights reserved.
+Copyright (C) 2014 cPanel Inc.  All rights reserved.
+This program is free software; you can redistribute it and/or modify
+it under the same terms as Perl itself.
+
+=cut

data/lib/javonet-ruby-sdk/Binaries/Perl/Linux/X64/deps/lib/perl5/x86_64-linux-gnu-thread-multi/Sub/Util.pm

@@ -0,0 +1,153 @@
+# Copyright (c) 2014 Paul Evans <leonerd@leonerd.org.uk>. All rights reserved.
+# This program is free software; you can redistribute it and/or
+# modify it under the same terms as Perl itself.
+
+package Sub::Util;
+
+use strict;
+use warnings;
+
+require Exporter;
+
+our @ISA = qw( Exporter );
+our @EXPORT_OK = qw(
+  prototype set_prototype
+  subname set_subname
+);
+
+our $VERSION    = "1.69";
+$VERSION =~ tr/_//d;
+
+require List::Util; # as it has the XS
+List::Util->VERSION( $VERSION ); # Ensure we got the right XS version (RT#100863)
+
+=head1 NAME
+
+Sub::Util - A selection of utility subroutines for subs and CODE references
+
+=head1 SYNOPSIS
+
+    use Sub::Util qw( prototype set_prototype subname set_subname );
+
+=head1 DESCRIPTION
+
+C<Sub::Util> contains a selection of utility subroutines that are useful for
+operating on subs and CODE references.
+
+The rationale for inclusion in this module is that the function performs some
+work for which an XS implementation is essential because it cannot be
+implemented in Pure Perl, and which is sufficiently-widely used across CPAN
+that its popularity warrants inclusion in a core module, which this is.
+
+=cut
+
+=head1 FUNCTIONS
+
+=cut
+
+=head2 prototype
+
+    my $proto = prototype( $code )
+
+I<Since version 1.40.>
+
+Returns the prototype of the given C<$code> reference, if it has one, as a
+string. This is the same as the C<CORE::prototype> operator; it is included
+here simply for symmetry and completeness with the other functions.
+
+=cut
+
+sub prototype
+{
+  my ( $code ) = @_;
+  return CORE::prototype( $code );
+}
+
+=head2 set_prototype
+
+    my $code = set_prototype $prototype, $code;
+
+I<Since version 1.40.>
+
+Sets the prototype of the function given by the C<$code> reference, or deletes
+it if C<$prototype> is C<undef>. Returns the C<$code> reference itself.
+
+I<Caution>: This function takes arguments in a different order to the previous
+copy of the code from C<Scalar::Util>. This is to match the order of
+C<set_subname>, and other potential additions in this file. This order has
+been chosen as it allows a neat and simple chaining of other
+C<Sub::Util::set_*> functions as might become available, such as:
+
+ my $code =
+    set_subname   name_here =>
+    set_prototype '&@'      =>
+    set_attribute ':lvalue' =>
+       sub { ...... };
+
+=cut
+
+=head2 subname
+
+    my $name = subname( $code )
+
+I<Since version 1.40.>
+
+Returns the name of the given C<$code> reference, if it has one. Normal named
+subs will give a fully-qualified name consisting of the package and the
+localname separated by C<::>. Anonymous code references will give C<__ANON__>
+as the localname. If the package the code was compiled in has been deleted
+(e.g. using C<delete_package> from L<Symbol>), C<__ANON__> will be returned as
+the package name. If a name has been set using L</set_subname>, this name will be
+returned instead.
+
+This function was inspired by C<sub_fullname> from L<Sub::Identify>. The
+remaining functions that C<Sub::Identify> implements can easily be emulated
+using regexp operations, such as
+
+ sub get_code_info { return (subname $_[0]) =~ m/^(.+)::(.*?)$/ }
+ sub sub_name      { return (get_code_info $_[0])[0] }
+ sub stash_name    { return (get_code_info $_[0])[1] }
+
+I<Users of Sub::Name beware>: This function is B<not> the same as
+C<Sub::Name::subname>; it returns the existing name of the sub rather than
+changing it. To set or change a name, see instead L</set_subname>.
+
+=cut
+
+=head2 set_subname
+
+    my $code = set_subname $name, $code;
+
+I<Since version 1.40.>
+
+Sets the name of the function given by the C<$code> reference. Returns the
+C<$code> reference itself. If the C<$name> is unqualified, the package of the
+caller is used to qualify it.
+
+This is useful for applying names to anonymous CODE references so that stack
+traces and similar situations, to give a useful name rather than having the
+default of C<__ANON__>. Note that this name is only used for this situation;
+the C<set_subname> will not install it into the symbol table; you will have to
+do that yourself if required.
+
+However, since the name is not used by perl except as the return value of
+C<caller>, for stack traces or similar, there is no actual requirement that
+the name be syntactically valid as a perl function name. This could be used to
+attach extra information that could be useful in debugging stack traces.
+
+This function was copied from C<Sub::Name::subname> and renamed to the naming
+convention of this module.
+
+=cut
+
+=head1 AUTHOR
+
+The general structure of this module was written by Paul Evans
+<leonerd@leonerd.org.uk>.
+
+The XS implementation of L</set_subname> was copied from L<Sub::Name> by
+Matthijs van Duin <xmath@cpan.org>
+
+=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 38
-#define FFI_PL_PERL_VERSION_PATCH 2
+#define FFI_PL_PERL_VERSION_MINOR 34
+#define FFI_PL_PERL_VERSION_PATCH 0
 #define FFI_PL_VERSION_MAJOR 2
 #define FFI_PL_VERSION_MINOR 10
 #define FFI_PL_VERSION_PATCH 0