Add files using upload-large-folder tool

git/usr/share/perl5/core_perl/IO/Compress/Base.pm

@@ -0,0 +1,1057 @@
+
+package IO::Compress::Base ;
+
+require 5.006 ;
+
+use strict ;
+use warnings;
+
+use IO::Compress::Base::Common 2.213 ;
+
+use IO::File (); ;
+use Scalar::Util ();
+
+#use File::Glob;
+#require Exporter ;
+use Carp() ;
+use Symbol();
+#use bytes;
+
+our (@ISA, $VERSION);
+@ISA    = qw(IO::File Exporter);
+
+$VERSION = '2.213';
+
+#Can't locate object method "SWASHNEW" via package "utf8" (perhaps you forgot to load "utf8"?) at .../ext/Compress-Zlib/Gzip/blib/lib/Compress/Zlib/Common.pm line 16.
+
+sub saveStatus
+{
+    my $self   = shift ;
+    ${ *$self->{ErrorNo} } = shift() + 0 ;
+    ${ *$self->{Error} } = '' ;
+
+    return ${ *$self->{ErrorNo} } ;
+}
+
+
+sub saveErrorString
+{
+    my $self   = shift ;
+    my $retval = shift ;
+    ${ *$self->{Error} } = shift ;
+    ${ *$self->{ErrorNo} } = shift() + 0 if @_ ;
+
+    return $retval;
+}
+
+sub croakError
+{
+    my $self   = shift ;
+    $self->saveErrorString(0, $_[0]);
+    Carp::croak $_[0];
+}
+
+sub closeError
+{
+    my $self = shift ;
+    my $retval = shift ;
+
+    my $errno = *$self->{ErrorNo};
+    my $error = ${ *$self->{Error} };
+
+    $self->close();
+
+    *$self->{ErrorNo} = $errno ;
+    ${ *$self->{Error} } = $error ;
+
+    return $retval;
+}
+
+
+
+sub error
+{
+    my $self   = shift ;
+    return ${ *$self->{Error} } ;
+}
+
+sub errorNo
+{
+    my $self   = shift ;
+    return ${ *$self->{ErrorNo} } ;
+}
+
+
+sub writeAt
+{
+    my $self = shift ;
+    my $offset = shift;
+    my $data = shift;
+
+    if (defined *$self->{FH}) {
+        my $here = tell(*$self->{FH});
+        return $self->saveErrorString(undef, "Cannot seek to end of output filehandle: $!", $!)
+            if $here < 0 ;
+        seek(*$self->{FH}, $offset, IO::Handle::SEEK_SET)
+            or return $self->saveErrorString(undef, "Cannot seek to end of output filehandle: $!", $!) ;
+        defined *$self->{FH}->write($data, length $data)
+            or return $self->saveErrorString(undef, $!, $!) ;
+        seek(*$self->{FH}, $here, IO::Handle::SEEK_SET)
+            or return $self->saveErrorString(undef, "Cannot seek to end of output filehandle: $!", $!) ;
+    }
+    else {
+        substr(${ *$self->{Buffer} }, $offset, length($data)) = $data ;
+    }
+
+    return 1;
+}
+
+sub outputPayload
+{
+
+    my $self = shift ;
+    return $self->output(@_);
+}
+
+
+sub output
+{
+    my $self = shift ;
+    my $data = shift ;
+    my $last = shift ;
+
+    return 1
+        if length $data == 0 && ! $last ;
+
+    if ( *$self->{FilterContainer} ) {
+        *_ = \$data;
+        &{ *$self->{FilterContainer} }();
+    }
+
+    if (length $data) {
+        if ( defined *$self->{FH} ) {
+                defined *$self->{FH}->write( $data, length $data )
+                or return $self->saveErrorString(0, $!, $!);
+        }
+        else {
+                ${ *$self->{Buffer} } .= $data ;
+        }
+    }
+
+    return 1;
+}
+
+sub getOneShotParams
+{
+    return ( 'multistream' => [IO::Compress::Base::Common::Parse_boolean,   1],
+           );
+}
+
+our %PARAMS = (
+            # Generic Parameters
+            'autoclose' => [IO::Compress::Base::Common::Parse_boolean,   0],
+            'encode'    => [IO::Compress::Base::Common::Parse_any,       undef],
+            'strict'    => [IO::Compress::Base::Common::Parse_boolean,   1],
+            'append'    => [IO::Compress::Base::Common::Parse_boolean,   0],
+            'binmodein' => [IO::Compress::Base::Common::Parse_boolean,   0],
+
+            'filtercontainer' => [IO::Compress::Base::Common::Parse_code,  undef],
+        );
+
+sub checkParams
+{
+    my $self = shift ;
+    my $class = shift ;
+
+    my $got = shift || IO::Compress::Base::Parameters::new();
+
+    $got->parse(
+        {
+            %PARAMS,
+
+
+            $self->getExtraParams(),
+            *$self->{OneShot} ? $self->getOneShotParams()
+                              : (),
+        },
+        @_) or $self->croakError("${class}: " . $got->getError())  ;
+
+    return $got ;
+}
+
+sub _create
+{
+    my $obj = shift;
+    my $got = shift;
+
+    *$obj->{Closed} = 1 ;
+
+    my $class = ref $obj;
+    $obj->croakError("$class: Missing Output parameter")
+        if ! @_ && ! $got ;
+
+    my $outValue = shift ;
+    my $oneShot = 1 ;
+
+    if (! $got)
+    {
+        $oneShot = 0 ;
+        $got = $obj->checkParams($class, undef, @_)
+            or return undef ;
+    }
+
+    my $lax = ! $got->getValue('strict') ;
+
+    my $outType = IO::Compress::Base::Common::whatIsOutput($outValue);
+
+    $obj->ckOutputParam($class, $outValue)
+        or return undef ;
+
+    if ($outType eq 'buffer') {
+        *$obj->{Buffer} = $outValue;
+    }
+    else {
+        my $buff = "" ;
+        *$obj->{Buffer} = \$buff ;
+    }
+
+    # Merge implies Append
+    my $merge = $got->getValue('merge') ;
+    my $appendOutput = $got->getValue('append') || $merge ;
+    *$obj->{Append} = $appendOutput;
+    *$obj->{FilterContainer} = $got->getValue('filtercontainer') ;
+
+    if ($merge)
+    {
+        # Switch off Merge mode if output file/buffer is empty/doesn't exist
+        if (($outType eq 'buffer' && length $$outValue == 0 ) ||
+            ($outType ne 'buffer' && (! -e $outValue || (-w _ && -z _))) )
+          { $merge = 0 }
+    }
+
+    # If output is a file, check that it is writable
+    #no warnings;
+    #if ($outType eq 'filename' && -e $outValue && ! -w _)
+    #  { return $obj->saveErrorString(undef, "Output file '$outValue' is not writable" ) }
+
+    $obj->ckParams($got)
+        or $obj->croakError("${class}: " . $obj->error());
+
+    if ($got->getValue('encode')) {
+        my $want_encoding = $got->getValue('encode');
+        *$obj->{Encoding} = IO::Compress::Base::Common::getEncoding($obj, $class, $want_encoding);
+        my $x = *$obj->{Encoding};
+    }
+    else {
+        *$obj->{Encoding} = undef;
+    }
+
+    $obj->saveStatus(STATUS_OK) ;
+
+    my $status ;
+    if (! $merge)
+    {
+        *$obj->{Compress} = $obj->mkComp($got)
+            or return undef;
+
+        *$obj->{UnCompSize} = U64->new;
+        *$obj->{CompSize} = U64->new;
+
+        if ( $outType eq 'buffer') {
+            ${ *$obj->{Buffer} }  = ''
+                unless $appendOutput ;
+        }
+        else {
+            if ($outType eq 'handle') {
+                *$obj->{FH} = $outValue ;
+                setBinModeOutput(*$obj->{FH}) ;
+                #$outValue->flush() ;
+                *$obj->{Handle} = 1 ;
+                if ($appendOutput)
+                {
+                    seek(*$obj->{FH}, 0, IO::Handle::SEEK_END)
+                        or return $obj->saveErrorString(undef, "Cannot seek to end of output filehandle: $!", $!) ;
+
+                }
+            }
+            elsif ($outType eq 'filename') {
+                no warnings;
+                my $mode = '>' ;
+                $mode = '>>'
+                    if $appendOutput;
+                *$obj->{FH} = IO::File->new( "$mode $outValue" )
+                    or return $obj->saveErrorString(undef, "cannot open file '$outValue': $!", $!) ;
+                *$obj->{StdIO} = ($outValue eq '-');
+                setBinModeOutput(*$obj->{FH}) ;
+            }
+        }
+
+        *$obj->{Header} = $obj->mkHeader($got) ;
+        $obj->output( *$obj->{Header} )
+            or return undef;
+        $obj->beforePayload();
+    }
+    else
+    {
+        *$obj->{Compress} = $obj->createMerge($outValue, $outType)
+            or return undef;
+    }
+
+    *$obj->{Closed} = 0 ;
+    *$obj->{AutoClose} = $got->getValue('autoclose') ;
+    *$obj->{Output} = $outValue;
+    *$obj->{ClassName} = $class;
+    *$obj->{Got} = $got;
+    *$obj->{OneShot} = 0 ;
+
+    return $obj ;
+}
+
+sub ckOutputParam
+{
+    my $self = shift ;
+    my $from = shift ;
+    my $outType = IO::Compress::Base::Common::whatIsOutput($_[0]);
+
+    $self->croakError("$from: output parameter not a filename, filehandle or scalar ref")
+        if ! $outType ;
+
+    #$self->croakError("$from: output filename is undef or null string")
+        #if $outType eq 'filename' && (! defined $_[0] || $_[0] eq '')  ;
+
+    $self->croakError("$from: output buffer is read-only")
+        if $outType eq 'buffer' && Scalar::Util::readonly(${ $_[0] });
+
+    return 1;
+}
+
+
+sub _def
+{
+    my $obj = shift ;
+
+    my $class= (caller)[0] ;
+    my $name = (caller(1))[3] ;
+
+    $obj->croakError("$name: expected at least 1 parameters\n")
+        unless @_ >= 1 ;
+
+    my $input = shift ;
+    my $haveOut = @_ ;
+    my $output = shift ;
+
+    my $x = IO::Compress::Base::Validator->new($class, *$obj->{Error}, $name, $input, $output)
+        or return undef ;
+
+    push @_, $output if $haveOut && $x->{Hash};
+
+    *$obj->{OneShot} = 1 ;
+
+    my $got = $obj->checkParams($name, undef, @_)
+        or return undef ;
+
+    $x->{Got} = $got ;
+
+#    if ($x->{Hash})
+#    {
+#        while (my($k, $v) = each %$input)
+#        {
+#            $v = \$input->{$k}
+#                unless defined $v ;
+#
+#            $obj->_singleTarget($x, 1, $k, $v, @_)
+#                or return undef ;
+#        }
+#
+#        return keys %$input ;
+#    }
+
+    if ($x->{GlobMap})
+    {
+        $x->{oneInput} = 1 ;
+        foreach my $pair (@{ $x->{Pairs} })
+        {
+            my ($from, $to) = @$pair ;
+            $obj->_singleTarget($x, 1, $from, $to, @_)
+                or return undef ;
+        }
+
+        return scalar @{ $x->{Pairs} } ;
+    }
+
+    if (! $x->{oneOutput} )
+    {
+        my $inFile = ($x->{inType} eq 'filenames'
+                        || $x->{inType} eq 'filename');
+
+        $x->{inType} = $inFile ? 'filename' : 'buffer';
+
+        foreach my $in ($x->{oneInput} ? $input : @$input)
+        {
+            my $out ;
+            $x->{oneInput} = 1 ;
+
+            $obj->_singleTarget($x, $inFile, $in, \$out, @_)
+                or return undef ;
+
+            push @$output, \$out ;
+            #if ($x->{outType} eq 'array')
+            #  { push @$output, \$out }
+            #else
+            #  { $output->{$in} = \$out }
+        }
+
+        return 1 ;
+    }
+
+    # finally the 1 to 1 and n to 1
+    return $obj->_singleTarget($x, 1, $input, $output, @_);
+
+    Carp::croak "should not be here" ;
+}
+
+sub _singleTarget
+{
+    my $obj             = shift ;
+    my $x               = shift ;
+    my $inputIsFilename = shift;
+    my $input           = shift;
+
+    if ($x->{oneInput})
+    {
+        $obj->getFileInfo($x->{Got}, $input)
+            if isaScalar($input) || (isaFilename($input) and $inputIsFilename) ;
+
+        my $z = $obj->_create($x->{Got}, @_)
+            or return undef ;
+
+
+        defined $z->_wr2($input, $inputIsFilename)
+            or return $z->closeError(undef) ;
+
+        return $z->close() ;
+    }
+    else
+    {
+        my $afterFirst = 0 ;
+        my $inputIsFilename = ($x->{inType} ne 'array');
+        my $keep = $x->{Got}->clone();
+
+        #for my $element ( ($x->{inType} eq 'hash') ? keys %$input : @$input)
+        for my $element ( @$input)
+        {
+            my $isFilename = isaFilename($element);
+
+            if ( $afterFirst ++ )
+            {
+                defined addInterStream($obj, $element, $isFilename)
+                    or return $obj->closeError(undef) ;
+            }
+            else
+            {
+                $obj->getFileInfo($x->{Got}, $element)
+                    if isaScalar($element) || $isFilename;
+
+                $obj->_create($x->{Got}, @_)
+                    or return undef ;
+            }
+
+            defined $obj->_wr2($element, $isFilename)
+                or return $obj->closeError(undef) ;
+
+            *$obj->{Got} = $keep->clone();
+        }
+        return $obj->close() ;
+    }
+
+}
+
+sub _wr2
+{
+    my $self = shift ;
+
+    my $source = shift ;
+    my $inputIsFilename = shift;
+
+    my $input = $source ;
+    if (! $inputIsFilename)
+    {
+        $input = \$source
+            if ! ref $source;
+    }
+
+    if ( ref $input && ref $input eq 'SCALAR' )
+    {
+        return $self->syswrite($input, @_) ;
+    }
+
+    if ( ! ref $input  || isaFilehandle($input))
+    {
+        my $isFilehandle = isaFilehandle($input) ;
+
+        my $fh = $input ;
+
+        if ( ! $isFilehandle )
+        {
+            $fh = IO::File->new( "<$input" )
+                or return $self->saveErrorString(undef, "cannot open file '$input': $!", $!) ;
+        }
+        binmode $fh ;
+
+        my $status ;
+        my $buff ;
+        my $count = 0 ;
+        while ($status = read($fh, $buff, 16 * 1024)) {
+            $count += length $buff;
+            defined $self->syswrite($buff, @_)
+                or return undef ;
+        }
+
+        return $self->saveErrorString(undef, $!, $!)
+            if ! defined $status ;
+
+        if ( (!$isFilehandle || *$self->{AutoClose}) && $input ne '-')
+        {
+            $fh->close()
+                or return undef ;
+        }
+
+        return $count ;
+    }
+
+    Carp::croak "Should not be here";
+    return undef;
+}
+
+sub addInterStream
+{
+    my $self = shift ;
+    my $input = shift ;
+    my $inputIsFilename = shift ;
+
+    if (*$self->{Got}->getValue('multistream'))
+    {
+        $self->getFileInfo(*$self->{Got}, $input)
+            #if isaFilename($input) and $inputIsFilename ;
+            if isaScalar($input) || isaFilename($input) ;
+
+        # TODO -- newStream needs to allow gzip/zip header to be modified
+        return $self->newStream();
+    }
+    elsif (*$self->{Got}->getValue('autoflush'))
+    {
+        #return $self->flush(Z_FULL_FLUSH);
+    }
+
+    return 1 ;
+}
+
+sub getFileInfo
+{
+}
+
+sub TIEHANDLE
+{
+    return $_[0] if ref($_[0]);
+    die "OOPS\n" ;
+}
+
+sub UNTIE
+{
+    my $self = shift ;
+}
+
+sub DESTROY
+{
+    my $self = shift ;
+    local ($., $@, $!, $^E, $?);
+
+    $self->close() ;
+
+    # TODO - memory leak with 5.8.0 - this isn't called until
+    #        global destruction
+    #
+    %{ *$self } = () ;
+    undef $self ;
+}
+
+
+
+sub filterUncompressed
+{
+}
+
+sub syswrite
+{
+    my $self = shift ;
+
+    my $buffer ;
+    if (ref $_[0] ) {
+        $self->croakError( *$self->{ClassName} . "::write: not a scalar reference" )
+            unless ref $_[0] eq 'SCALAR' ;
+        $buffer = $_[0] ;
+    }
+    else {
+        $buffer = \$_[0] ;
+    }
+
+    if (@_ > 1) {
+        my $slen = defined $$buffer ? length($$buffer) : 0;
+        my $len = $slen;
+        my $offset = 0;
+        $len = $_[1] if $_[1] < $len;
+
+        if (@_ > 2) {
+            $offset = $_[2] || 0;
+            $self->croakError(*$self->{ClassName} . "::write: offset outside string")
+                if $offset > $slen;
+            if ($offset < 0) {
+                $offset += $slen;
+                $self->croakError( *$self->{ClassName} . "::write: offset outside string") if $offset < 0;
+            }
+            my $rem = $slen - $offset;
+            $len = $rem if $rem < $len;
+        }
+
+        $buffer = \substr($$buffer, $offset, $len) ;
+    }
+
+    return 0 if (! defined $$buffer || length $$buffer == 0) && ! *$self->{FlushPending};
+
+#    *$self->{Pending} .= $$buffer ;
+#
+#    return length $$buffer
+#        if (length *$self->{Pending} < 1024 * 16 && ! *$self->{FlushPending}) ;
+#
+#    $$buffer = *$self->{Pending} ;
+#    *$self->{Pending} = '';
+
+    if (*$self->{Encoding}) {
+        $$buffer = *$self->{Encoding}->encode($$buffer);
+    }
+    else {
+        $] >= 5.008 and ( utf8::downgrade($$buffer, 1)
+            or Carp::croak "Wide character in " .  *$self->{ClassName} . "::write:");
+    }
+
+    $self->filterUncompressed($buffer);
+
+    my $buffer_length = defined $$buffer ? length($$buffer) : 0 ;
+    *$self->{UnCompSize}->add($buffer_length) ;
+
+    my $outBuffer='';
+    my $status = *$self->{Compress}->compr($buffer, $outBuffer) ;
+
+    return $self->saveErrorString(undef, *$self->{Compress}{Error},
+                                         *$self->{Compress}{ErrorNo})
+        if $status == STATUS_ERROR;
+
+    *$self->{CompSize}->add(length $outBuffer) ;
+
+    $self->outputPayload($outBuffer)
+        or return undef;
+
+    return $buffer_length;
+}
+
+sub print
+{
+    my $self = shift;
+
+    #if (ref $self) {
+    #    $self = *$self{GLOB} ;
+    #}
+
+    if (defined $\) {
+        if (defined $,) {
+            defined $self->syswrite(join($,, @_) . $\);
+        } else {
+            defined $self->syswrite(join("", @_) . $\);
+        }
+    } else {
+        if (defined $,) {
+            defined $self->syswrite(join($,, @_));
+        } else {
+            defined $self->syswrite(join("", @_));
+        }
+    }
+}
+
+sub printf
+{
+    my $self = shift;
+    my $fmt = shift;
+    defined $self->syswrite(sprintf($fmt, @_));
+}
+
+sub _flushCompressed
+{
+    my $self = shift ;
+
+    my $outBuffer='';
+    my $status = *$self->{Compress}->flush($outBuffer, @_) ;
+    return $self->saveErrorString(0, *$self->{Compress}{Error},
+                                    *$self->{Compress}{ErrorNo})
+        if $status == STATUS_ERROR;
+
+    if ( defined *$self->{FH} ) {
+        *$self->{FH}->clearerr();
+    }
+
+    *$self->{CompSize}->add(length $outBuffer) ;
+
+    $self->outputPayload($outBuffer)
+        or return 0;
+    return 1;
+}
+
+sub flush
+{
+    my $self = shift ;
+
+    $self->_flushCompressed(@_)
+        or return 0;
+
+    if ( defined *$self->{FH} ) {
+        defined *$self->{FH}->flush()
+            or return $self->saveErrorString(0, $!, $!);
+    }
+
+    return 1;
+}
+
+sub beforePayload
+{
+}
+
+sub _newStream
+{
+    my $self = shift ;
+    my $got  = shift;
+
+    my $class = ref $self;
+
+    $self->_writeTrailer()
+        or return 0 ;
+
+    $self->ckParams($got)
+        or $self->croakError("newStream: $self->{Error}");
+
+    if ($got->getValue('encode')) {
+        my $want_encoding = $got->getValue('encode');
+        *$self->{Encoding} = IO::Compress::Base::Common::getEncoding($self, $class, $want_encoding);
+    }
+    else {
+        *$self->{Encoding} = undef;
+    }
+
+    *$self->{Compress} = $self->mkComp($got)
+        or return 0;
+
+    *$self->{Header} = $self->mkHeader($got) ;
+    $self->output(*$self->{Header} )
+        or return 0;
+
+    *$self->{UnCompSize}->reset();
+    *$self->{CompSize}->reset();
+
+    $self->beforePayload();
+
+    return 1 ;
+}
+
+sub newStream
+{
+    my $self = shift ;
+
+    my $got = $self->checkParams('newStream', *$self->{Got}, @_)
+        or return 0 ;
+
+    $self->_newStream($got);
+
+#    *$self->{Compress} = $self->mkComp($got)
+#        or return 0;
+#
+#    *$self->{Header} = $self->mkHeader($got) ;
+#    $self->output(*$self->{Header} )
+#        or return 0;
+#
+#    *$self->{UnCompSize}->reset();
+#    *$self->{CompSize}->reset();
+#
+#    $self->beforePayload();
+#
+#    return 1 ;
+}
+
+sub reset
+{
+    my $self = shift ;
+    return *$self->{Compress}->reset() ;
+}
+
+sub _writeTrailer
+{
+    my $self = shift ;
+
+    my $trailer = '';
+
+    my $status = *$self->{Compress}->close($trailer) ;
+
+    return $self->saveErrorString(0, *$self->{Compress}{Error}, *$self->{Compress}{ErrorNo})
+        if $status == STATUS_ERROR;
+
+    *$self->{CompSize}->add(length $trailer) ;
+
+    $trailer .= $self->mkTrailer();
+    defined $trailer
+      or return 0;
+    return $self->output($trailer);
+}
+
+sub _writeFinalTrailer
+{
+    my $self = shift ;
+
+    return $self->output($self->mkFinalTrailer());
+}
+
+sub close
+{
+    my $self = shift ;
+    return 1 if *$self->{Closed} || ! *$self->{Compress} ;
+    *$self->{Closed} = 1 ;
+
+    untie *$self
+        if $] >= 5.008 ;
+
+    *$self->{FlushPending} = 1 ;
+    $self->_writeTrailer()
+        or return 0 ;
+
+    $self->_writeFinalTrailer()
+        or return 0 ;
+
+    $self->output( "", 1 )
+        or return 0;
+
+    if (defined *$self->{FH}) {
+
+        if ((! *$self->{Handle} || *$self->{AutoClose}) && ! *$self->{StdIO}) {
+            $! = 0 ;
+            *$self->{FH}->close()
+                or return $self->saveErrorString(0, $!, $!);
+        }
+        delete *$self->{FH} ;
+        # This delete can set $! in older Perls, so reset the errno
+        $! = 0 ;
+    }
+
+    return 1;
+}
+
+
+#sub total_in
+#sub total_out
+#sub msg
+#
+#sub crc
+#{
+#    my $self = shift ;
+#    return *$self->{Compress}->crc32() ;
+#}
+#
+#sub msg
+#{
+#    my $self = shift ;
+#    return *$self->{Compress}->msg() ;
+#}
+#
+#sub dict_adler
+#{
+#    my $self = shift ;
+#    return *$self->{Compress}->dict_adler() ;
+#}
+#
+#sub get_Level
+#{
+#    my $self = shift ;
+#    return *$self->{Compress}->get_Level() ;
+#}
+#
+#sub get_Strategy
+#{
+#    my $self = shift ;
+#    return *$self->{Compress}->get_Strategy() ;
+#}
+
+
+sub tell
+{
+    my $self = shift ;
+
+    return *$self->{UnCompSize}->get32bit() ;
+}
+
+sub eof
+{
+    my $self = shift ;
+
+    return *$self->{Closed} ;
+}
+
+
+sub seek
+{
+    my $self     = shift ;
+    my $position = shift;
+    my $whence   = shift ;
+
+    my $here = $self->tell() ;
+    my $target = 0 ;
+
+    #use IO::Handle qw(SEEK_SET SEEK_CUR SEEK_END);
+    use IO::Handle ;
+
+    if ($whence == IO::Handle::SEEK_SET) {
+        $target = $position ;
+    }
+    elsif ($whence == IO::Handle::SEEK_CUR || $whence == IO::Handle::SEEK_END) {
+        $target = $here + $position ;
+    }
+    else {
+        $self->croakError(*$self->{ClassName} . "::seek: unknown value, $whence, for whence parameter");
+    }
+
+    # short circuit if seeking to current offset
+    return 1 if $target == $here ;
+
+    # Outlaw any attempt to seek backwards
+    $self->croakError(*$self->{ClassName} . "::seek: cannot seek backwards")
+        if $target < $here ;
+
+    # Walk the file to the new offset
+    my $offset = $target - $here ;
+
+    my $buffer ;
+    defined $self->syswrite("\x00" x $offset)
+        or return 0;
+
+    return 1 ;
+}
+
+sub binmode
+{
+    1;
+#    my $self     = shift ;
+#    return defined *$self->{FH}
+#            ? binmode *$self->{FH}
+#            : 1 ;
+}
+
+sub fileno
+{
+    my $self     = shift ;
+    return defined *$self->{FH}
+            ? *$self->{FH}->fileno()
+            : undef ;
+}
+
+sub opened
+{
+    my $self     = shift ;
+    return ! *$self->{Closed} ;
+}
+
+sub autoflush
+{
+    my $self     = shift ;
+    return defined *$self->{FH}
+            ? *$self->{FH}->autoflush(@_)
+            : undef ;
+}
+
+sub input_line_number
+{
+    return undef ;
+}
+
+
+sub _notAvailable
+{
+    my $name = shift ;
+    return sub { Carp::croak "$name Not Available: File opened only for output" ; } ;
+}
+
+{
+    no warnings 'once';
+
+    *read     = _notAvailable('read');
+    *READ     = _notAvailable('read');
+    *readline = _notAvailable('readline');
+    *READLINE = _notAvailable('readline');
+    *getc     = _notAvailable('getc');
+    *GETC     = _notAvailable('getc');
+
+    *FILENO   = \&fileno;
+    *PRINT    = \&print;
+    *PRINTF   = \&printf;
+    *WRITE    = \&syswrite;
+    *write    = \&syswrite;
+    *SEEK     = \&seek;
+    *TELL     = \&tell;
+    *EOF      = \&eof;
+    *CLOSE    = \&close;
+    *BINMODE  = \&binmode;
+}
+
+#*sysread  = \&_notAvailable;
+#*syswrite = \&_write;
+
+1;
+
+__END__
+
+=head1 NAME
+
+IO::Compress::Base - Base Class for IO::Compress modules
+
+=head1 SYNOPSIS
+
+    use IO::Compress::Base ;
+
+=head1 DESCRIPTION
+
+This module is not intended for direct use in application code. Its sole
+purpose is to be sub-classed by IO::Compress modules.
+
+=head1 SUPPORT
+
+General feedback/questions/bug reports should be sent to
+L<https://github.com/pmqs/IO-Compress/issues> (preferred) or
+L<https://rt.cpan.org/Public/Dist/Display.html?Name=IO-Compress>.
+
+=head1 SEE ALSO
+
+L<Compress::Zlib>, L<IO::Compress::Gzip>, L<IO::Uncompress::Gunzip>, L<IO::Compress::Deflate>, L<IO::Uncompress::Inflate>, L<IO::Compress::RawDeflate>, L<IO::Uncompress::RawInflate>, L<IO::Compress::Bzip2>, L<IO::Uncompress::Bunzip2>, L<IO::Compress::Lzma>, L<IO::Uncompress::UnLzma>, L<IO::Compress::Xz>, L<IO::Uncompress::UnXz>, L<IO::Compress::Lzip>, L<IO::Uncompress::UnLzip>, L<IO::Compress::Lzop>, L<IO::Uncompress::UnLzop>, L<IO::Compress::Lzf>, L<IO::Uncompress::UnLzf>, L<IO::Compress::Zstd>, L<IO::Uncompress::UnZstd>, L<IO::Uncompress::AnyInflate>, L<IO::Uncompress::AnyUncompress>
+
+L<IO::Compress::FAQ|IO::Compress::FAQ>
+
+L<File::GlobMapper|File::GlobMapper>, L<Archive::Zip|Archive::Zip>,
+L<Archive::Tar|Archive::Tar>,
+L<IO::Zlib|IO::Zlib>
+
+=head1 AUTHOR
+
+This module was written by Paul Marquess, C<pmqs@cpan.org>.
+
+=head1 MODIFICATION HISTORY
+
+See the Changes file.
+
+=head1 COPYRIGHT AND LICENSE
+
+Copyright (c) 2005-2024 Paul Marquess. All rights reserved.
+
+This program is free software; you can redistribute it and/or
+modify it under the same terms as Perl itself.

git/usr/share/perl5/core_perl/IO/Compress/Bzip2.pm

@@ -0,0 +1,884 @@
+package IO::Compress::Bzip2 ;
+
+use strict ;
+use warnings;
+use bytes;
+require Exporter ;
+
+use IO::Compress::Base 2.213 ;
+
+use IO::Compress::Base::Common  2.213 qw();
+use IO::Compress::Adapter::Bzip2 2.213 ;
+
+
+
+our ($VERSION, @ISA, @EXPORT_OK, %EXPORT_TAGS, $Bzip2Error);
+
+$VERSION = '2.213';
+$Bzip2Error = '';
+
+@ISA    = qw(IO::Compress::Base Exporter);
+@EXPORT_OK = qw( $Bzip2Error bzip2 ) ;
+%EXPORT_TAGS = %IO::Compress::Base::EXPORT_TAGS ;
+push @{ $EXPORT_TAGS{all} }, @EXPORT_OK ;
+Exporter::export_ok_tags('all');
+
+
+
+sub new
+{
+    my $class = shift ;
+
+    my $obj = IO::Compress::Base::Common::createSelfTiedObject($class, \$Bzip2Error);
+    return $obj->_create(undef, @_);
+}
+
+sub bzip2
+{
+    my $obj = IO::Compress::Base::Common::createSelfTiedObject(undef, \$Bzip2Error);
+    $obj->_def(@_);
+}
+
+
+sub mkHeader
+{
+    my $self = shift ;
+    return '';
+
+}
+
+sub getExtraParams
+{
+    my $self = shift ;
+
+    use IO::Compress::Base::Common  2.213 qw(:Parse);
+
+    return (
+            'blocksize100k' => [IO::Compress::Base::Common::Parse_unsigned,  1],
+            'workfactor'    => [IO::Compress::Base::Common::Parse_unsigned,  0],
+            'verbosity'     => [IO::Compress::Base::Common::Parse_boolean,   0],
+        );
+}
+
+
+
+sub ckParams
+{
+    my $self = shift ;
+    my $got = shift;
+
+    # check that BlockSize100K is a number between 1 & 9
+    if ($got->parsed('blocksize100k')) {
+        my $value = $got->getValue('blocksize100k');
+        return $self->saveErrorString(undef, "Parameter 'BlockSize100K' not between 1 and 9, got $value")
+            unless defined $value && $value >= 1 && $value <= 9;
+
+    }
+
+    # check that WorkFactor between 0 & 250
+    if ($got->parsed('workfactor')) {
+        my $value = $got->getValue('workfactor');
+        return $self->saveErrorString(undef, "Parameter 'WorkFactor' not between 0 and 250, got $value")
+            unless $value >= 0 && $value <= 250;
+    }
+
+    return 1 ;
+}
+
+
+sub mkComp
+{
+    my $self = shift ;
+    my $got = shift ;
+
+    my $BlockSize100K = $got->getValue('blocksize100k');
+    my $WorkFactor    = $got->getValue('workfactor');
+    my $Verbosity     = $got->getValue('verbosity');
+
+    my ($obj, $errstr, $errno) = IO::Compress::Adapter::Bzip2::mkCompObject(
+                                               $BlockSize100K, $WorkFactor,
+                                               $Verbosity);
+
+    return $self->saveErrorString(undef, $errstr, $errno)
+        if ! defined $obj;
+
+    return $obj;
+}
+
+
+sub mkTrailer
+{
+    my $self = shift ;
+    return '';
+}
+
+sub mkFinalTrailer
+{
+    return '';
+}
+
+#sub newHeader
+#{
+#    my $self = shift ;
+#    return '';
+#}
+
+sub getInverseClass
+{
+    return ('IO::Uncompress::Bunzip2');
+}
+
+sub getFileInfo
+{
+    my $self = shift ;
+    my $params = shift;
+    my $file = shift ;
+
+}
+
+1;
+
+__END__
+
+=head1 NAME
+
+IO::Compress::Bzip2 - Write bzip2 files/buffers
+
+=head1 SYNOPSIS
+
+    use IO::Compress::Bzip2 qw(bzip2 $Bzip2Error) ;
+
+    my $status = bzip2 $input => $output [,OPTS]
+        or die "bzip2 failed: $Bzip2Error\n";
+
+    my $z = IO::Compress::Bzip2->new( $output [,OPTS] )
+        or die "bzip2 failed: $Bzip2Error\n";
+
+    $z->print($string);
+    $z->printf($format, $string);
+    $z->write($string);
+    $z->syswrite($string [, $length, $offset]);
+    $z->flush();
+    $z->tell();
+    $z->eof();
+    $z->seek($position, $whence);
+    $z->binmode();
+    $z->fileno();
+    $z->opened();
+    $z->autoflush();
+    $z->input_line_number();
+    $z->newStream( [OPTS] );
+
+    $z->close() ;
+
+    $Bzip2Error ;
+
+    # IO::File mode
+
+    print $z $string;
+    printf $z $format, $string;
+    tell $z
+    eof $z
+    seek $z, $position, $whence
+    binmode $z
+    fileno $z
+    close $z ;
+
+=head1 DESCRIPTION
+
+This module provides a Perl interface that allows writing bzip2
+compressed data to files or buffer.
+
+For reading bzip2 files/buffers, see the companion module
+L<IO::Uncompress::Bunzip2|IO::Uncompress::Bunzip2>.
+
+=head1 Functional Interface
+
+A top-level function, C<bzip2>, is provided to carry out
+"one-shot" compression between buffers and/or files. For finer
+control over the compression process, see the L</"OO Interface">
+section.
+
+    use IO::Compress::Bzip2 qw(bzip2 $Bzip2Error) ;
+
+    bzip2 $input_filename_or_reference => $output_filename_or_reference [,OPTS]
+        or die "bzip2 failed: $Bzip2Error\n";
+
+The functional interface needs Perl5.005 or better.
+
+=head2 bzip2 $input_filename_or_reference => $output_filename_or_reference [, OPTS]
+
+C<bzip2> expects at least two parameters,
+C<$input_filename_or_reference> and C<$output_filename_or_reference>
+and zero or more optional parameters (see L</Optional Parameters>)
+
+=head3 The C<$input_filename_or_reference> parameter
+
+The parameter, C<$input_filename_or_reference>, is used to define the
+source of the uncompressed data.
+
+It can take one of the following forms:
+
+=over 5
+
+=item A filename
+
+If the C<$input_filename_or_reference> parameter is a simple scalar, it is
+assumed to be a filename. This file will be opened for reading and the
+input data will be read from it.
+
+=item A filehandle
+
+If the C<$input_filename_or_reference> parameter is a filehandle, the input
+data will be read from it.  The string '-' can be used as an alias for
+standard input.
+
+=item A scalar reference
+
+If C<$input_filename_or_reference> is a scalar reference, the input data
+will be read from C<$$input_filename_or_reference>.
+
+=item An array reference
+
+If C<$input_filename_or_reference> is an array reference, each element in
+the array must be a filename.
+
+The input data will be read from each file in turn.
+
+The complete array will be walked to ensure that it only
+contains valid filenames before any data is compressed.
+
+=item An Input FileGlob string
+
+If C<$input_filename_or_reference> is a string that is delimited by the
+characters "<" and ">" C<bzip2> will assume that it is an
+I<input fileglob string>. The input is the list of files that match the
+fileglob.
+
+See L<File::GlobMapper|File::GlobMapper> for more details.
+
+=back
+
+If the C<$input_filename_or_reference> parameter is any other type,
+C<undef> will be returned.
+
+=head3 The C<$output_filename_or_reference> parameter
+
+The parameter C<$output_filename_or_reference> is used to control the
+destination of the compressed data. This parameter can take one of
+these forms.
+
+=over 5
+
+=item A filename
+
+If the C<$output_filename_or_reference> parameter is a simple scalar, it is
+assumed to be a filename.  This file will be opened for writing and the
+compressed data will be written to it.
+
+=item A filehandle
+
+If the C<$output_filename_or_reference> parameter is a filehandle, the
+compressed data will be written to it.  The string '-' can be used as
+an alias for standard output.
+
+=item A scalar reference
+
+If C<$output_filename_or_reference> is a scalar reference, the
+compressed data will be stored in C<$$output_filename_or_reference>.
+
+=item An Array Reference
+
+If C<$output_filename_or_reference> is an array reference,
+the compressed data will be pushed onto the array.
+
+=item An Output FileGlob
+
+If C<$output_filename_or_reference> is a string that is delimited by the
+characters "<" and ">" C<bzip2> will assume that it is an
+I<output fileglob string>. The output is the list of files that match the
+fileglob.
+
+When C<$output_filename_or_reference> is an fileglob string,
+C<$input_filename_or_reference> must also be a fileglob string. Anything
+else is an error.
+
+See L<File::GlobMapper|File::GlobMapper> for more details.
+
+=back
+
+If the C<$output_filename_or_reference> parameter is any other type,
+C<undef> will be returned.
+
+=head2 Notes
+
+When C<$input_filename_or_reference> maps to multiple files/buffers and
+C<$output_filename_or_reference> is a single
+file/buffer the input files/buffers will be stored
+in C<$output_filename_or_reference> as a concatenated series of compressed data streams.
+
+=head2 Optional Parameters
+
+The optional parameters for the one-shot function C<bzip2>
+are (for the most part) identical to those used with the OO interface defined in the
+L</"Constructor Options"> section. The exceptions are listed below
+
+=over 5
+
+=item C<< AutoClose => 0|1 >>
+
+This option applies to any input or output data streams to
+C<bzip2> that are filehandles.
+
+If C<AutoClose> is specified, and the value is true, it will result in all
+input and/or output filehandles being closed once C<bzip2> has
+completed.
+
+This parameter defaults to 0.
+
+=item C<< BinModeIn => 0|1 >>
+
+This option is now a no-op. All files will be read in binmode.
+
+=item C<< Append => 0|1 >>
+
+The behaviour of this option is dependent on the type of output data
+stream.
+
+=over 5
+
+=item * A Buffer
+
+If C<Append> is enabled, all compressed data will be append to the end of
+the output buffer. Otherwise the output buffer will be cleared before any
+compressed data is written to it.
+
+=item * A Filename
+
+If C<Append> is enabled, the file will be opened in append mode. Otherwise
+the contents of the file, if any, will be truncated before any compressed
+data is written to it.
+
+=item * A Filehandle
+
+If C<Append> is enabled, the filehandle will be positioned to the end of
+the file via a call to C<seek> before any compressed data is
+written to it.  Otherwise the file pointer will not be moved.
+
+=back
+
+When C<Append> is specified, and set to true, it will I<append> all compressed
+data to the output data stream.
+
+So when the output is a filehandle it will carry out a seek to the eof
+before writing any compressed data. If the output is a filename, it will be opened for
+appending. If the output is a buffer, all compressed data will be
+appended to the existing buffer.
+
+Conversely when C<Append> is not specified, or it is present and is set to
+false, it will operate as follows.
+
+When the output is a filename, it will truncate the contents of the file
+before writing any compressed data. If the output is a filehandle
+its position will not be changed. If the output is a buffer, it will be
+wiped before any compressed data is output.
+
+Defaults to 0.
+
+=back
+
+=head2 Oneshot Examples
+
+Here are a few example that show the capabilities of the module.
+
+=head3 Streaming
+
+This very simple command line example demonstrates the streaming capabilities of the module.
+The code reads data from STDIN, compresses it, and writes the compressed data to STDOUT.
+
+    $ echo hello world | perl -MIO::Compress::Bzip2=bzip2 -e 'bzip2 \*STDIN => \*STDOUT' >output.bz2
+
+The special filename "-" can be used as a standin for both C<\*STDIN> and C<\*STDOUT>,
+so the above can be rewritten as
+
+    $ echo hello world | perl -MIO::Compress::Bzip2=bzip2 -e 'bzip2 "-" => "-"' >output.bz2
+
+=head3 Compressing a file from the filesystem
+
+To read the contents of the file C<file1.txt> and write the compressed
+data to the file C<file1.txt.bz2>.
+
+    use strict ;
+    use warnings ;
+    use IO::Compress::Bzip2 qw(bzip2 $Bzip2Error) ;
+
+    my $input = "file1.txt";
+    bzip2 $input => "$input.bz2"
+        or die "bzip2 failed: $Bzip2Error\n";
+
+=head3 Reading from a Filehandle and writing to an in-memory buffer
+
+To read from an existing Perl filehandle, C<$input>, and write the
+compressed data to a buffer, C<$buffer>.
+
+    use strict ;
+    use warnings ;
+    use IO::Compress::Bzip2 qw(bzip2 $Bzip2Error) ;
+    use IO::File ;
+
+    my $input = IO::File->new( "<file1.txt" )
+        or die "Cannot open 'file1.txt': $!\n" ;
+    my $buffer ;
+    bzip2 $input => \$buffer
+        or die "bzip2 failed: $Bzip2Error\n";
+
+=head3 Compressing multiple files
+
+To compress all files in the directory "/my/home" that match "*.txt"
+and store the compressed data in the same directory
+
+    use strict ;
+    use warnings ;
+    use IO::Compress::Bzip2 qw(bzip2 $Bzip2Error) ;
+
+    bzip2 '</my/home/*.txt>' => '<*.bz2>'
+        or die "bzip2 failed: $Bzip2Error\n";
+
+and if you want to compress each file one at a time, this will do the trick
+
+    use strict ;
+    use warnings ;
+    use IO::Compress::Bzip2 qw(bzip2 $Bzip2Error) ;
+
+    for my $input ( glob "/my/home/*.txt" )
+    {
+        my $output = "$input.bz2" ;
+        bzip2 $input => $output
+            or die "Error compressing '$input': $Bzip2Error\n";
+    }
+
+=head1 OO Interface
+
+=head2 Constructor
+
+The format of the constructor for C<IO::Compress::Bzip2> is shown below
+
+    my $z = IO::Compress::Bzip2->new( $output [,OPTS] )
+        or die "IO::Compress::Bzip2 failed: $Bzip2Error\n";
+
+The constructor takes one mandatory parameter, C<$output>, defined below and
+zero or more C<OPTS>, defined in L<Constructor Options>.
+
+It returns an C<IO::Compress::Bzip2> object on success and C<undef> on failure.
+The variable C<$Bzip2Error> will contain an error message on failure.
+
+If you are running Perl 5.005 or better the object, C<$z>, returned from
+IO::Compress::Bzip2 can be used exactly like an L<IO::File|IO::File> filehandle.
+This means that all normal output file operations can be carried out
+with C<$z>.
+For example, to write to a compressed file/buffer you can use either of
+these forms
+
+    $z->print("hello world\n");
+    print $z "hello world\n";
+
+Below is a simple exaple of using the OO interface to create an output file
+C<myfile.bz2> and write some data to it.
+
+    my $filename = "myfile.bz2";
+    my $z = IO::Compress::Bzip2->new($filename)
+        or die "IO::Compress::Bzip2 failed: $Bzip2Error\n";
+
+    $z->print("abcde");
+    $z->close();
+
+See the L</Examples> for more.
+
+The mandatory parameter C<$output> is used to control the destination
+of the compressed data. This parameter can take one of these forms.
+
+=over 5
+
+=item A filename
+
+If the C<$output> parameter is a simple scalar, it is assumed to be a
+filename. This file will be opened for writing and the compressed data
+will be written to it.
+
+=item A filehandle
+
+If the C<$output> parameter is a filehandle, the compressed data will be
+written to it.
+The string '-' can be used as an alias for standard output.
+
+=item A scalar reference
+
+If C<$output> is a scalar reference, the compressed data will be stored
+in C<$$output>.
+
+=back
+
+If the C<$output> parameter is any other type, C<IO::Compress::Bzip2>::new will
+return undef.
+
+=head2 Constructor Options
+
+C<OPTS> is any combination of zero or more the following options:
+
+=over 5
+
+=item C<< AutoClose => 0|1 >>
+
+This option is only valid when the C<$output> parameter is a filehandle. If
+specified, and the value is true, it will result in the C<$output> being
+closed once either the C<close> method is called or the C<IO::Compress::Bzip2>
+object is destroyed.
+
+This parameter defaults to 0.
+
+=item C<< Append => 0|1 >>
+
+Opens C<$output> in append mode.
+
+The behaviour of this option is dependent on the type of C<$output>.
+
+=over 5
+
+=item * A Buffer
+
+If C<$output> is a buffer and C<Append> is enabled, all compressed data
+will be append to the end of C<$output>. Otherwise C<$output> will be
+cleared before any data is written to it.
+
+=item * A Filename
+
+If C<$output> is a filename and C<Append> is enabled, the file will be
+opened in append mode. Otherwise the contents of the file, if any, will be
+truncated before any compressed data is written to it.
+
+=item * A Filehandle
+
+If C<$output> is a filehandle, the file pointer will be positioned to the
+end of the file via a call to C<seek> before any compressed data is written
+to it.  Otherwise the file pointer will not be moved.
+
+=back
+
+This parameter defaults to 0.
+
+=item C<< BlockSize100K => number >>
+
+Specify the number of 100K blocks bzip2 uses during compression.
+
+Valid values are from 1 to 9, where 9 is best compression.
+
+The default is 1.
+
+=item C<< WorkFactor => number >>
+
+Specifies how much effort bzip2 should take before resorting to a slower
+fallback compression algorithm.
+
+Valid values range from 0 to 250, where 0 means use the default value 30.
+
+The default is 0.
+
+=item C<< Strict => 0|1 >>
+
+This is a placeholder option.
+
+=back
+
+=head2 Examples
+
+=head3 Streaming
+
+This very simple command line example demonstrates the streaming capabilities
+of the module. The code reads data from STDIN or all the files given on the
+commandline, compresses it, and writes the compressed data to STDOUT.
+
+    use strict ;
+    use warnings ;
+    use IO::Compress::Bzip2 qw(bzip2 $Bzip2Error) ;
+
+    my $z = IO::Compress::Bzip2->new("-", Stream => 1)
+        or die "IO::Compress::Bzip2 failed: $Bzip2Error\n";
+
+    while (<>) {
+        $z->print("abcde");
+    }
+    $z->close();
+
+Note the use of C<"-"> to means C<STDOUT>. Alternatively you can use C<\*STDOUT>.
+
+=head3 Compressing a file from the filesystem
+
+To read the contents of the file C<file1.txt> and write the compressed
+data to the file C<file1.txt.bz2> there are a few options
+
+Start by creating the compression object and opening the input file
+
+    use strict ;
+    use warnings ;
+    use IO::Compress::Bzip2 qw(bzip2 $Bzip2Error) ;
+
+    my $input = "file1.txt";
+    my $z = IO::Compress::Bzip2->new("file1.txt.bz2")
+        or die "IO::Compress::Bzip2 failed: $Bzip2Error\n";
+
+    # open the input file
+    open my $fh, "<", "file1.txt"
+        or die "Cannot open file1.txt: $!\n";
+
+    # loop through the input file & write to the compressed file
+    while (<$fh>) {
+        $z->print($_);
+    }
+
+    # not forgetting to close the compressed file
+    $z->close();
+
+=head1 Methods
+
+=head2 print
+
+Usage is
+
+    $z->print($data)
+    print $z $data
+
+Compresses and outputs the contents of the C<$data> parameter. This
+has the same behaviour as the C<print> built-in.
+
+Returns true if successful.
+
+=head2 printf
+
+Usage is
+
+    $z->printf($format, $data)
+    printf $z $format, $data
+
+Compresses and outputs the contents of the C<$data> parameter.
+
+Returns true if successful.
+
+=head2 syswrite
+
+Usage is
+
+    $z->syswrite $data
+    $z->syswrite $data, $length
+    $z->syswrite $data, $length, $offset
+
+Compresses and outputs the contents of the C<$data> parameter.
+
+Returns the number of uncompressed bytes written, or C<undef> if
+unsuccessful.
+
+=head2 write
+
+Usage is
+
+    $z->write $data
+    $z->write $data, $length
+    $z->write $data, $length, $offset
+
+Compresses and outputs the contents of the C<$data> parameter.
+
+Returns the number of uncompressed bytes written, or C<undef> if
+unsuccessful.
+
+=head2 flush
+
+Usage is
+
+    $z->flush;
+
+Flushes any pending compressed data to the output file/buffer.
+
+TODO
+
+Returns true on success.
+
+=head2 tell
+
+Usage is
+
+    $z->tell()
+    tell $z
+
+Returns the uncompressed file offset.
+
+=head2 eof
+
+Usage is
+
+    $z->eof();
+    eof($z);
+
+Returns true if the C<close> method has been called.
+
+=head2 seek
+
+    $z->seek($position, $whence);
+    seek($z, $position, $whence);
+
+Provides a sub-set of the C<seek> functionality, with the restriction
+that it is only legal to seek forward in the output file/buffer.
+It is a fatal error to attempt to seek backward.
+
+Empty parts of the file/buffer will have NULL (0x00) bytes written to them.
+
+The C<$whence> parameter takes one the usual values, namely SEEK_SET,
+SEEK_CUR or SEEK_END.
+
+Returns 1 on success, 0 on failure.
+
+=head2 binmode
+
+Usage is
+
+    $z->binmode
+    binmode $z ;
+
+This is a noop provided for completeness.
+
+=head2 opened
+
+    $z->opened()
+
+Returns true if the object currently refers to a opened file/buffer.
+
+=head2 autoflush
+
+    my $prev = $z->autoflush()
+    my $prev = $z->autoflush(EXPR)
+
+If the C<$z> object is associated with a file or a filehandle, this method
+returns the current autoflush setting for the underlying filehandle. If
+C<EXPR> is present, and is non-zero, it will enable flushing after every
+write/print operation.
+
+If C<$z> is associated with a buffer, this method has no effect and always
+returns C<undef>.
+
+B<Note> that the special variable C<$|> B<cannot> be used to set or
+retrieve the autoflush setting.
+
+=head2 input_line_number
+
+    $z->input_line_number()
+    $z->input_line_number(EXPR)
+
+This method always returns C<undef> when compressing.
+
+=head2 fileno
+
+    $z->fileno()
+    fileno($z)
+
+If the C<$z> object is associated with a file or a filehandle, C<fileno>
+will return the underlying file descriptor. Once the C<close> method is
+called C<fileno> will return C<undef>.
+
+If the C<$z> object is associated with a buffer, this method will return
+C<undef>.
+
+=head2 close
+
+    $z->close() ;
+    close $z ;
+
+Flushes any pending compressed data and then closes the output file/buffer.
+
+For most versions of Perl this method will be automatically invoked if
+the IO::Compress::Bzip2 object is destroyed (either explicitly or by the
+variable with the reference to the object going out of scope). The
+exceptions are Perl versions 5.005 through 5.00504 and 5.8.0. In
+these cases, the C<close> method will be called automatically, but
+not until global destruction of all live objects when the program is
+terminating.
+
+Therefore, if you want your scripts to be able to run on all versions
+of Perl, you should call C<close> explicitly and not rely on automatic
+closing.
+
+Returns true on success, otherwise 0.
+
+If the C<AutoClose> option has been enabled when the IO::Compress::Bzip2
+object was created, and the object is associated with a file, the
+underlying file will also be closed.
+
+=head2 newStream([OPTS])
+
+Usage is
+
+    $z->newStream( [OPTS] )
+
+Closes the current compressed data stream and starts a new one.
+
+OPTS consists of any of the options that are available when creating
+the C<$z> object.
+
+See the L</"Constructor Options"> section for more details.
+
+=head1 Importing
+
+No symbolic constants are required by IO::Compress::Bzip2 at present.
+
+=over 5
+
+=item :all
+
+Imports C<bzip2> and C<$Bzip2Error>.
+Same as doing this
+
+    use IO::Compress::Bzip2 qw(bzip2 $Bzip2Error) ;
+
+=back
+
+=head1 EXAMPLES
+
+=head2 Apache::GZip Revisited
+
+See L<IO::Compress::FAQ|IO::Compress::FAQ/"Apache::GZip Revisited">
+
+=head2 Working with Net::FTP
+
+See L<IO::Compress::FAQ|IO::Compress::FAQ/"Compressed files and Net::FTP">
+
+=head1 SUPPORT
+
+General feedback/questions/bug reports should be sent to
+L<https://github.com/pmqs/IO-Compress/issues> (preferred) or
+L<https://rt.cpan.org/Public/Dist/Display.html?Name=IO-Compress>.
+
+=head1 SEE ALSO
+
+L<Compress::Zlib>, L<IO::Compress::Gzip>, L<IO::Uncompress::Gunzip>, L<IO::Compress::Deflate>, L<IO::Uncompress::Inflate>, L<IO::Compress::RawDeflate>, L<IO::Uncompress::RawInflate>, L<IO::Uncompress::Bunzip2>, L<IO::Compress::Lzma>, L<IO::Uncompress::UnLzma>, L<IO::Compress::Xz>, L<IO::Uncompress::UnXz>, L<IO::Compress::Lzip>, L<IO::Uncompress::UnLzip>, L<IO::Compress::Lzop>, L<IO::Uncompress::UnLzop>, L<IO::Compress::Lzf>, L<IO::Uncompress::UnLzf>, L<IO::Compress::Zstd>, L<IO::Uncompress::UnZstd>, L<IO::Uncompress::AnyInflate>, L<IO::Uncompress::AnyUncompress>
+
+L<IO::Compress::FAQ|IO::Compress::FAQ>
+
+L<File::GlobMapper|File::GlobMapper>, L<Archive::Zip|Archive::Zip>,
+L<Archive::Tar|Archive::Tar>,
+L<IO::Zlib|IO::Zlib>
+
+The primary site for the bzip2 program is L<https://sourceware.org/bzip2/>.
+
+See the module L<Compress::Bzip2|Compress::Bzip2>
+
+=head1 AUTHOR
+
+This module was written by Paul Marquess, C<pmqs@cpan.org>.
+
+=head1 MODIFICATION HISTORY
+
+See the Changes file.
+
+=head1 COPYRIGHT AND LICENSE
+
+Copyright (c) 2005-2024 Paul Marquess. All rights reserved.
+
+This program is free software; you can redistribute it and/or
+modify it under the same terms as Perl itself.

git/usr/share/perl5/core_perl/IO/Compress/Deflate.pm

@@ -0,0 +1,958 @@
+package IO::Compress::Deflate ;
+
+require 5.006 ;
+
+use strict ;
+use warnings;
+use bytes;
+
+require Exporter ;
+
+use IO::Compress::RawDeflate 2.213 ();
+use IO::Compress::Adapter::Deflate 2.213 ;
+
+use IO::Compress::Zlib::Constants 2.213 ;
+use IO::Compress::Base::Common  2.213 qw();
+
+
+our ($VERSION, @ISA, @EXPORT_OK, %EXPORT_TAGS, %DEFLATE_CONSTANTS, $DeflateError);
+
+$VERSION = '2.213';
+$DeflateError = '';
+
+@ISA    = qw(IO::Compress::RawDeflate Exporter);
+@EXPORT_OK = qw( $DeflateError deflate ) ;
+%EXPORT_TAGS = %IO::Compress::RawDeflate::DEFLATE_CONSTANTS ;
+
+push @{ $EXPORT_TAGS{all} }, @EXPORT_OK ;
+Exporter::export_ok_tags('all');
+
+
+sub new
+{
+    my $class = shift ;
+
+    my $obj = IO::Compress::Base::Common::createSelfTiedObject($class, \$DeflateError);
+    return $obj->_create(undef, @_);
+}
+
+sub deflate
+{
+    my $obj = IO::Compress::Base::Common::createSelfTiedObject(undef, \$DeflateError);
+    return $obj->_def(@_);
+}
+
+sub mkComp
+{
+    my $self = shift ;
+    my $got = shift ;
+
+    my ($obj, $errstr, $errno) = IO::Compress::Adapter::Deflate::mkCompObject1(
+                                                 $got->getValue('crc32'),
+                                                 $got->getValue('adler32'),
+                                                 $got->getValue('level'),
+                                                 $got->getValue('strategy')
+                                                 );
+
+   return $self->saveErrorString(undef, $errstr, $errno)
+       if ! defined $obj;
+
+   return $obj;
+}
+
+
+sub mkHeader
+{
+    my $self = shift ;
+    return '';
+}
+
+sub mkTrailer
+{
+    my $self = shift ;
+    return '';
+}
+
+sub mkFinalTrailer
+{
+    return '';
+}
+
+sub getExtraParams
+{
+    my $self = shift ;
+    return $self->getZlibParams(),
+}
+
+sub getInverseClass
+{
+    no warnings 'once';
+    return ('IO::Uncompress::Inflate',
+                \$IO::Uncompress::Inflate::InflateError);
+}
+
+sub getFileInfo
+{
+    my $self = shift ;
+    my $params = shift;
+    my $file = shift ;
+
+}
+
+
+
+1;
+
+__END__
+
+=head1 NAME
+
+IO::Compress::Deflate - Write RFC 1950 files/buffers
+
+=head1 SYNOPSIS
+
+    use IO::Compress::Deflate qw(deflate $DeflateError) ;
+
+    my $status = deflate $input => $output [,OPTS]
+        or die "deflate failed: $DeflateError\n";
+
+    my $z = IO::Compress::Deflate->new( $output [,OPTS] )
+        or die "deflate failed: $DeflateError\n";
+
+    $z->print($string);
+    $z->printf($format, $string);
+    $z->write($string);
+    $z->syswrite($string [, $length, $offset]);
+    $z->flush();
+    $z->tell();
+    $z->eof();
+    $z->seek($position, $whence);
+    $z->binmode();
+    $z->fileno();
+    $z->opened();
+    $z->autoflush();
+    $z->input_line_number();
+    $z->newStream( [OPTS] );
+
+    $z->deflateParams();
+
+    $z->close() ;
+
+    $DeflateError ;
+
+    # IO::File mode
+
+    print $z $string;
+    printf $z $format, $string;
+    tell $z
+    eof $z
+    seek $z, $position, $whence
+    binmode $z
+    fileno $z
+    close $z ;
+
+=head1 DESCRIPTION
+
+This module provides a Perl interface that allows writing compressed
+data to files or buffer as defined in RFC 1950.
+
+For reading RFC 1950 files/buffers, see the companion module
+L<IO::Uncompress::Inflate|IO::Uncompress::Inflate>.
+
+=head1 Functional Interface
+
+A top-level function, C<deflate>, is provided to carry out
+"one-shot" compression between buffers and/or files. For finer
+control over the compression process, see the L</"OO Interface">
+section.
+
+    use IO::Compress::Deflate qw(deflate $DeflateError) ;
+
+    deflate $input_filename_or_reference => $output_filename_or_reference [,OPTS]
+        or die "deflate failed: $DeflateError\n";
+
+The functional interface needs Perl5.005 or better.
+
+=head2 deflate $input_filename_or_reference => $output_filename_or_reference [, OPTS]
+
+C<deflate> expects at least two parameters,
+C<$input_filename_or_reference> and C<$output_filename_or_reference>
+and zero or more optional parameters (see L</Optional Parameters>)
+
+=head3 The C<$input_filename_or_reference> parameter
+
+The parameter, C<$input_filename_or_reference>, is used to define the
+source of the uncompressed data.
+
+It can take one of the following forms:
+
+=over 5
+
+=item A filename
+
+If the C<$input_filename_or_reference> parameter is a simple scalar, it is
+assumed to be a filename. This file will be opened for reading and the
+input data will be read from it.
+
+=item A filehandle
+
+If the C<$input_filename_or_reference> parameter is a filehandle, the input
+data will be read from it.  The string '-' can be used as an alias for
+standard input.
+
+=item A scalar reference
+
+If C<$input_filename_or_reference> is a scalar reference, the input data
+will be read from C<$$input_filename_or_reference>.
+
+=item An array reference
+
+If C<$input_filename_or_reference> is an array reference, each element in
+the array must be a filename.
+
+The input data will be read from each file in turn.
+
+The complete array will be walked to ensure that it only
+contains valid filenames before any data is compressed.
+
+=item An Input FileGlob string
+
+If C<$input_filename_or_reference> is a string that is delimited by the
+characters "<" and ">" C<deflate> will assume that it is an
+I<input fileglob string>. The input is the list of files that match the
+fileglob.
+
+See L<File::GlobMapper|File::GlobMapper> for more details.
+
+=back
+
+If the C<$input_filename_or_reference> parameter is any other type,
+C<undef> will be returned.
+
+=head3 The C<$output_filename_or_reference> parameter
+
+The parameter C<$output_filename_or_reference> is used to control the
+destination of the compressed data. This parameter can take one of
+these forms.
+
+=over 5
+
+=item A filename
+
+If the C<$output_filename_or_reference> parameter is a simple scalar, it is
+assumed to be a filename.  This file will be opened for writing and the
+compressed data will be written to it.
+
+=item A filehandle
+
+If the C<$output_filename_or_reference> parameter is a filehandle, the
+compressed data will be written to it.  The string '-' can be used as
+an alias for standard output.
+
+=item A scalar reference
+
+If C<$output_filename_or_reference> is a scalar reference, the
+compressed data will be stored in C<$$output_filename_or_reference>.
+
+=item An Array Reference
+
+If C<$output_filename_or_reference> is an array reference,
+the compressed data will be pushed onto the array.
+
+=item An Output FileGlob
+
+If C<$output_filename_or_reference> is a string that is delimited by the
+characters "<" and ">" C<deflate> will assume that it is an
+I<output fileglob string>. The output is the list of files that match the
+fileglob.
+
+When C<$output_filename_or_reference> is an fileglob string,
+C<$input_filename_or_reference> must also be a fileglob string. Anything
+else is an error.
+
+See L<File::GlobMapper|File::GlobMapper> for more details.
+
+=back
+
+If the C<$output_filename_or_reference> parameter is any other type,
+C<undef> will be returned.
+
+=head2 Notes
+
+When C<$input_filename_or_reference> maps to multiple files/buffers and
+C<$output_filename_or_reference> is a single
+file/buffer the input files/buffers will be stored
+in C<$output_filename_or_reference> as a concatenated series of compressed data streams.
+
+=head2 Optional Parameters
+
+The optional parameters for the one-shot function C<deflate>
+are (for the most part) identical to those used with the OO interface defined in the
+L</"Constructor Options"> section. The exceptions are listed below
+
+=over 5
+
+=item C<< AutoClose => 0|1 >>
+
+This option applies to any input or output data streams to
+C<deflate> that are filehandles.
+
+If C<AutoClose> is specified, and the value is true, it will result in all
+input and/or output filehandles being closed once C<deflate> has
+completed.
+
+This parameter defaults to 0.
+
+=item C<< BinModeIn => 0|1 >>
+
+This option is now a no-op. All files will be read in binmode.
+
+=item C<< Append => 0|1 >>
+
+The behaviour of this option is dependent on the type of output data
+stream.
+
+=over 5
+
+=item * A Buffer
+
+If C<Append> is enabled, all compressed data will be append to the end of
+the output buffer. Otherwise the output buffer will be cleared before any
+compressed data is written to it.
+
+=item * A Filename
+
+If C<Append> is enabled, the file will be opened in append mode. Otherwise
+the contents of the file, if any, will be truncated before any compressed
+data is written to it.
+
+=item * A Filehandle
+
+If C<Append> is enabled, the filehandle will be positioned to the end of
+the file via a call to C<seek> before any compressed data is
+written to it.  Otherwise the file pointer will not be moved.
+
+=back
+
+When C<Append> is specified, and set to true, it will I<append> all compressed
+data to the output data stream.
+
+So when the output is a filehandle it will carry out a seek to the eof
+before writing any compressed data. If the output is a filename, it will be opened for
+appending. If the output is a buffer, all compressed data will be
+appended to the existing buffer.
+
+Conversely when C<Append> is not specified, or it is present and is set to
+false, it will operate as follows.
+
+When the output is a filename, it will truncate the contents of the file
+before writing any compressed data. If the output is a filehandle
+its position will not be changed. If the output is a buffer, it will be
+wiped before any compressed data is output.
+
+Defaults to 0.
+
+=back
+
+=head2 Oneshot Examples
+
+Here are a few example that show the capabilities of the module.
+
+=head3 Streaming
+
+This very simple command line example demonstrates the streaming capabilities of the module.
+The code reads data from STDIN, compresses it, and writes the compressed data to STDOUT.
+
+    $ echo hello world | perl -MIO::Compress::Deflate=deflate -e 'deflate \*STDIN => \*STDOUT' >output.1950
+
+The special filename "-" can be used as a standin for both C<\*STDIN> and C<\*STDOUT>,
+so the above can be rewritten as
+
+    $ echo hello world | perl -MIO::Compress::Deflate=deflate -e 'deflate "-" => "-"' >output.1950
+
+=head3 Compressing a file from the filesystem
+
+To read the contents of the file C<file1.txt> and write the compressed
+data to the file C<file1.txt.1950>.
+
+    use strict ;
+    use warnings ;
+    use IO::Compress::Deflate qw(deflate $DeflateError) ;
+
+    my $input = "file1.txt";
+    deflate $input => "$input.1950"
+        or die "deflate failed: $DeflateError\n";
+
+=head3 Reading from a Filehandle and writing to an in-memory buffer
+
+To read from an existing Perl filehandle, C<$input>, and write the
+compressed data to a buffer, C<$buffer>.
+
+    use strict ;
+    use warnings ;
+    use IO::Compress::Deflate qw(deflate $DeflateError) ;
+    use IO::File ;
+
+    my $input = IO::File->new( "<file1.txt" )
+        or die "Cannot open 'file1.txt': $!\n" ;
+    my $buffer ;
+    deflate $input => \$buffer
+        or die "deflate failed: $DeflateError\n";
+
+=head3 Compressing multiple files
+
+To compress all files in the directory "/my/home" that match "*.txt"
+and store the compressed data in the same directory
+
+    use strict ;
+    use warnings ;
+    use IO::Compress::Deflate qw(deflate $DeflateError) ;
+
+    deflate '</my/home/*.txt>' => '<*.1950>'
+        or die "deflate failed: $DeflateError\n";
+
+and if you want to compress each file one at a time, this will do the trick
+
+    use strict ;
+    use warnings ;
+    use IO::Compress::Deflate qw(deflate $DeflateError) ;
+
+    for my $input ( glob "/my/home/*.txt" )
+    {
+        my $output = "$input.1950" ;
+        deflate $input => $output
+            or die "Error compressing '$input': $DeflateError\n";
+    }
+
+=head1 OO Interface
+
+=head2 Constructor
+
+The format of the constructor for C<IO::Compress::Deflate> is shown below
+
+    my $z = IO::Compress::Deflate->new( $output [,OPTS] )
+        or die "IO::Compress::Deflate failed: $DeflateError\n";
+
+The constructor takes one mandatory parameter, C<$output>, defined below and
+zero or more C<OPTS>, defined in L<Constructor Options>.
+
+It returns an C<IO::Compress::Deflate> object on success and C<undef> on failure.
+The variable C<$DeflateError> will contain an error message on failure.
+
+If you are running Perl 5.005 or better the object, C<$z>, returned from
+IO::Compress::Deflate can be used exactly like an L<IO::File|IO::File> filehandle.
+This means that all normal output file operations can be carried out
+with C<$z>.
+For example, to write to a compressed file/buffer you can use either of
+these forms
+
+    $z->print("hello world\n");
+    print $z "hello world\n";
+
+Below is a simple exaple of using the OO interface to create an output file
+C<myfile.1950> and write some data to it.
+
+    my $filename = "myfile.1950";
+    my $z = IO::Compress::Deflate->new($filename)
+        or die "IO::Compress::Deflate failed: $DeflateError\n";
+
+    $z->print("abcde");
+    $z->close();
+
+See the L</Examples> for more.
+
+The mandatory parameter C<$output> is used to control the destination
+of the compressed data. This parameter can take one of these forms.
+
+=over 5
+
+=item A filename
+
+If the C<$output> parameter is a simple scalar, it is assumed to be a
+filename. This file will be opened for writing and the compressed data
+will be written to it.
+
+=item A filehandle
+
+If the C<$output> parameter is a filehandle, the compressed data will be
+written to it.
+The string '-' can be used as an alias for standard output.
+
+=item A scalar reference
+
+If C<$output> is a scalar reference, the compressed data will be stored
+in C<$$output>.
+
+=back
+
+If the C<$output> parameter is any other type, C<IO::Compress::Deflate>::new will
+return undef.
+
+=head2 Constructor Options
+
+C<OPTS> is any combination of zero or more the following options:
+
+=over 5
+
+=item C<< AutoClose => 0|1 >>
+
+This option is only valid when the C<$output> parameter is a filehandle. If
+specified, and the value is true, it will result in the C<$output> being
+closed once either the C<close> method is called or the C<IO::Compress::Deflate>
+object is destroyed.
+
+This parameter defaults to 0.
+
+=item C<< Append => 0|1 >>
+
+Opens C<$output> in append mode.
+
+The behaviour of this option is dependent on the type of C<$output>.
+
+=over 5
+
+=item * A Buffer
+
+If C<$output> is a buffer and C<Append> is enabled, all compressed data
+will be append to the end of C<$output>. Otherwise C<$output> will be
+cleared before any data is written to it.
+
+=item * A Filename
+
+If C<$output> is a filename and C<Append> is enabled, the file will be
+opened in append mode. Otherwise the contents of the file, if any, will be
+truncated before any compressed data is written to it.
+
+=item * A Filehandle
+
+If C<$output> is a filehandle, the file pointer will be positioned to the
+end of the file via a call to C<seek> before any compressed data is written
+to it.  Otherwise the file pointer will not be moved.
+
+=back
+
+This parameter defaults to 0.
+
+=item C<< Merge => 0|1 >>
+
+This option is used to compress input data and append it to an existing
+compressed data stream in C<$output>. The end result is a single compressed
+data stream stored in C<$output>.
+
+It is a fatal error to attempt to use this option when C<$output> is not an
+RFC 1950 data stream.
+
+There are a number of other limitations with the C<Merge> option:
+
+=over 5
+
+=item 1
+
+This module needs to have been built with zlib 1.2.1 or better to work. A
+fatal error will be thrown if C<Merge> is used with an older version of
+zlib.
+
+=item 2
+
+If C<$output> is a file or a filehandle, it must be seekable.
+
+=back
+
+This parameter defaults to 0.
+
+=item -Level
+
+Defines the compression level used by zlib. The value should either be
+a number between 0 and 9 (0 means no compression and 9 is maximum
+compression), or one of the symbolic constants defined below.
+
+   Z_NO_COMPRESSION
+   Z_BEST_SPEED
+   Z_BEST_COMPRESSION
+   Z_DEFAULT_COMPRESSION
+
+The default is Z_DEFAULT_COMPRESSION.
+
+Note, these constants are not imported by C<IO::Compress::Deflate> by default.
+
+    use IO::Compress::Deflate qw(:strategy);
+    use IO::Compress::Deflate qw(:constants);
+    use IO::Compress::Deflate qw(:all);
+
+=item -Strategy
+
+Defines the strategy used to tune the compression. Use one of the symbolic
+constants defined below.
+
+   Z_FILTERED
+   Z_HUFFMAN_ONLY
+   Z_RLE
+   Z_FIXED
+   Z_DEFAULT_STRATEGY
+
+The default is Z_DEFAULT_STRATEGY.
+
+=item C<< Strict => 0|1 >>
+
+This is a placeholder option.
+
+=back
+
+=head2 Examples
+
+=head3 Streaming
+
+This very simple command line example demonstrates the streaming capabilities
+of the module. The code reads data from STDIN or all the files given on the
+commandline, compresses it, and writes the compressed data to STDOUT.
+
+    use strict ;
+    use warnings ;
+    use IO::Compress::Deflate qw(deflate $DeflateError) ;
+
+    my $z = IO::Compress::Deflate->new("-", Stream => 1)
+        or die "IO::Compress::Deflate failed: $DeflateError\n";
+
+    while (<>) {
+        $z->print("abcde");
+    }
+    $z->close();
+
+Note the use of C<"-"> to means C<STDOUT>. Alternatively you can use C<\*STDOUT>.
+
+=head3 Compressing a file from the filesystem
+
+To read the contents of the file C<file1.txt> and write the compressed
+data to the file C<file1.txt.1950> there are a few options
+
+Start by creating the compression object and opening the input file
+
+    use strict ;
+    use warnings ;
+    use IO::Compress::Deflate qw(deflate $DeflateError) ;
+
+    my $input = "file1.txt";
+    my $z = IO::Compress::Deflate->new("file1.txt.1950")
+        or die "IO::Compress::Deflate failed: $DeflateError\n";
+
+    # open the input file
+    open my $fh, "<", "file1.txt"
+        or die "Cannot open file1.txt: $!\n";
+
+    # loop through the input file & write to the compressed file
+    while (<$fh>) {
+        $z->print($_);
+    }
+
+    # not forgetting to close the compressed file
+    $z->close();
+
+=head1 Methods
+
+=head2 print
+
+Usage is
+
+    $z->print($data)
+    print $z $data
+
+Compresses and outputs the contents of the C<$data> parameter. This
+has the same behaviour as the C<print> built-in.
+
+Returns true if successful.
+
+=head2 printf
+
+Usage is
+
+    $z->printf($format, $data)
+    printf $z $format, $data
+
+Compresses and outputs the contents of the C<$data> parameter.
+
+Returns true if successful.
+
+=head2 syswrite
+
+Usage is
+
+    $z->syswrite $data
+    $z->syswrite $data, $length
+    $z->syswrite $data, $length, $offset
+
+Compresses and outputs the contents of the C<$data> parameter.
+
+Returns the number of uncompressed bytes written, or C<undef> if
+unsuccessful.
+
+=head2 write
+
+Usage is
+
+    $z->write $data
+    $z->write $data, $length
+    $z->write $data, $length, $offset
+
+Compresses and outputs the contents of the C<$data> parameter.
+
+Returns the number of uncompressed bytes written, or C<undef> if
+unsuccessful.
+
+=head2 flush
+
+Usage is
+
+    $z->flush;
+    $z->flush($flush_type);
+
+Flushes any pending compressed data to the output file/buffer.
+
+This method takes an optional parameter, C<$flush_type>, that controls
+how the flushing will be carried out. By default the C<$flush_type>
+used is C<Z_FINISH>. Other valid values for C<$flush_type> are
+C<Z_NO_FLUSH>, C<Z_SYNC_FLUSH>, C<Z_FULL_FLUSH> and C<Z_BLOCK>. It is
+strongly recommended that you only set the C<flush_type> parameter if
+you fully understand the implications of what it does - overuse of C<flush>
+can seriously degrade the level of compression achieved. See the C<zlib>
+documentation for details.
+
+Returns true on success.
+
+=head2 tell
+
+Usage is
+
+    $z->tell()
+    tell $z
+
+Returns the uncompressed file offset.
+
+=head2 eof
+
+Usage is
+
+    $z->eof();
+    eof($z);
+
+Returns true if the C<close> method has been called.
+
+=head2 seek
+
+    $z->seek($position, $whence);
+    seek($z, $position, $whence);
+
+Provides a sub-set of the C<seek> functionality, with the restriction
+that it is only legal to seek forward in the output file/buffer.
+It is a fatal error to attempt to seek backward.
+
+Empty parts of the file/buffer will have NULL (0x00) bytes written to them.
+
+The C<$whence> parameter takes one the usual values, namely SEEK_SET,
+SEEK_CUR or SEEK_END.
+
+Returns 1 on success, 0 on failure.
+
+=head2 binmode
+
+Usage is
+
+    $z->binmode
+    binmode $z ;
+
+This is a noop provided for completeness.
+
+=head2 opened
+
+    $z->opened()
+
+Returns true if the object currently refers to a opened file/buffer.
+
+=head2 autoflush
+
+    my $prev = $z->autoflush()
+    my $prev = $z->autoflush(EXPR)
+
+If the C<$z> object is associated with a file or a filehandle, this method
+returns the current autoflush setting for the underlying filehandle. If
+C<EXPR> is present, and is non-zero, it will enable flushing after every
+write/print operation.
+
+If C<$z> is associated with a buffer, this method has no effect and always
+returns C<undef>.
+
+B<Note> that the special variable C<$|> B<cannot> be used to set or
+retrieve the autoflush setting.
+
+=head2 input_line_number
+
+    $z->input_line_number()
+    $z->input_line_number(EXPR)
+
+This method always returns C<undef> when compressing.
+
+=head2 fileno
+
+    $z->fileno()
+    fileno($z)
+
+If the C<$z> object is associated with a file or a filehandle, C<fileno>
+will return the underlying file descriptor. Once the C<close> method is
+called C<fileno> will return C<undef>.
+
+If the C<$z> object is associated with a buffer, this method will return
+C<undef>.
+
+=head2 close
+
+    $z->close() ;
+    close $z ;
+
+Flushes any pending compressed data and then closes the output file/buffer.
+
+For most versions of Perl this method will be automatically invoked if
+the IO::Compress::Deflate object is destroyed (either explicitly or by the
+variable with the reference to the object going out of scope). The
+exceptions are Perl versions 5.005 through 5.00504 and 5.8.0. In
+these cases, the C<close> method will be called automatically, but
+not until global destruction of all live objects when the program is
+terminating.
+
+Therefore, if you want your scripts to be able to run on all versions
+of Perl, you should call C<close> explicitly and not rely on automatic
+closing.
+
+Returns true on success, otherwise 0.
+
+If the C<AutoClose> option has been enabled when the IO::Compress::Deflate
+object was created, and the object is associated with a file, the
+underlying file will also be closed.
+
+=head2 newStream([OPTS])
+
+Usage is
+
+    $z->newStream( [OPTS] )
+
+Closes the current compressed data stream and starts a new one.
+
+OPTS consists of any of the options that are available when creating
+the C<$z> object.
+
+See the L</"Constructor Options"> section for more details.
+
+=head2 deflateParams
+
+Usage is
+
+    $z->deflateParams
+
+TODO
+
+=head1 Importing
+
+A number of symbolic constants are required by some methods in
+C<IO::Compress::Deflate>. None are imported by default.
+
+=over 5
+
+=item :all
+
+Imports C<deflate>, C<$DeflateError> and all symbolic
+constants that can be used by C<IO::Compress::Deflate>. Same as doing this
+
+    use IO::Compress::Deflate qw(deflate $DeflateError :constants) ;
+
+=item :constants
+
+Import all symbolic constants. Same as doing this
+
+    use IO::Compress::Deflate qw(:flush :level :strategy) ;
+
+=item :flush
+
+These symbolic constants are used by the C<flush> method.
+
+    Z_NO_FLUSH
+    Z_PARTIAL_FLUSH
+    Z_SYNC_FLUSH
+    Z_FULL_FLUSH
+    Z_FINISH
+    Z_BLOCK
+
+=item :level
+
+These symbolic constants are used by the C<Level> option in the constructor.
+
+    Z_NO_COMPRESSION
+    Z_BEST_SPEED
+    Z_BEST_COMPRESSION
+    Z_DEFAULT_COMPRESSION
+
+=item :strategy
+
+These symbolic constants are used by the C<Strategy> option in the constructor.
+
+    Z_FILTERED
+    Z_HUFFMAN_ONLY
+    Z_RLE
+    Z_FIXED
+    Z_DEFAULT_STRATEGY
+
+=back
+
+=head1 EXAMPLES
+
+=head2 Apache::GZip Revisited
+
+See L<IO::Compress::FAQ|IO::Compress::FAQ/"Apache::GZip Revisited">
+
+=head2 Working with Net::FTP
+
+See L<IO::Compress::FAQ|IO::Compress::FAQ/"Compressed files and Net::FTP">
+
+=head1 SUPPORT
+
+General feedback/questions/bug reports should be sent to
+L<https://github.com/pmqs/IO-Compress/issues> (preferred) or
+L<https://rt.cpan.org/Public/Dist/Display.html?Name=IO-Compress>.
+
+=head1 SEE ALSO
+
+L<Compress::Zlib>, L<IO::Compress::Gzip>, L<IO::Uncompress::Gunzip>, L<IO::Uncompress::Inflate>, L<IO::Compress::RawDeflate>, L<IO::Uncompress::RawInflate>, L<IO::Compress::Bzip2>, L<IO::Uncompress::Bunzip2>, L<IO::Compress::Lzma>, L<IO::Uncompress::UnLzma>, L<IO::Compress::Xz>, L<IO::Uncompress::UnXz>, L<IO::Compress::Lzip>, L<IO::Uncompress::UnLzip>, L<IO::Compress::Lzop>, L<IO::Uncompress::UnLzop>, L<IO::Compress::Lzf>, L<IO::Uncompress::UnLzf>, L<IO::Compress::Zstd>, L<IO::Uncompress::UnZstd>, L<IO::Uncompress::AnyInflate>, L<IO::Uncompress::AnyUncompress>
+
+L<IO::Compress::FAQ|IO::Compress::FAQ>
+
+L<File::GlobMapper|File::GlobMapper>, L<Archive::Zip|Archive::Zip>,
+L<Archive::Tar|Archive::Tar>,
+L<IO::Zlib|IO::Zlib>
+
+For RFC 1950, 1951 and 1952 see
+L<https://datatracker.ietf.org/doc/html/rfc1950>,
+L<https://datatracker.ietf.org/doc/html/rfc1951> and
+L<https://datatracker.ietf.org/doc/html/rfc1952>
+
+The I<zlib> compression library was written by Jean-loup Gailly
+C<gzip@prep.ai.mit.edu> and Mark Adler C<madler@alumni.caltech.edu>.
+
+The primary site for the I<zlib> compression library is
+L<http://www.zlib.org>.
+
+The primary site for the I<zlib-ng> compression library is
+L<https://github.com/zlib-ng/zlib-ng>.
+
+The primary site for gzip is L<http://www.gzip.org>.
+
+=head1 AUTHOR
+
+This module was written by Paul Marquess, C<pmqs@cpan.org>.
+
+=head1 MODIFICATION HISTORY
+
+See the Changes file.
+
+=head1 COPYRIGHT AND LICENSE
+
+Copyright (c) 2005-2024 Paul Marquess. All rights reserved.
+
+This program is free software; you can redistribute it and/or
+modify it under the same terms as Perl itself.

git/usr/share/perl5/core_perl/IO/Compress/Gzip.pm

@@ -0,0 +1,1333 @@
+package IO::Compress::Gzip ;
+
+require 5.006 ;
+
+use strict ;
+use warnings;
+use bytes;
+
+require Exporter ;
+
+use IO::Compress::RawDeflate 2.213 () ;
+use IO::Compress::Adapter::Deflate 2.213 ;
+
+use IO::Compress::Base::Common  2.213 qw(:Status );
+use IO::Compress::Gzip::Constants 2.213 ;
+use IO::Compress::Zlib::Extra 2.213 ;
+
+BEGIN
+{
+    if (defined &utf8::downgrade )
+      { *noUTF8 = \&utf8::downgrade }
+    else
+      { *noUTF8 = sub {} }
+}
+
+our ($VERSION, @ISA, @EXPORT_OK, %EXPORT_TAGS, %DEFLATE_CONSTANTS, $GzipError);
+
+$VERSION = '2.213';
+$GzipError = '' ;
+
+@ISA    = qw(IO::Compress::RawDeflate Exporter);
+@EXPORT_OK = qw( $GzipError gzip ) ;
+%EXPORT_TAGS = %IO::Compress::RawDeflate::DEFLATE_CONSTANTS ;
+
+push @{ $EXPORT_TAGS{all} }, @EXPORT_OK ;
+Exporter::export_ok_tags('all');
+
+sub new
+{
+    my $class = shift ;
+
+    my $obj = IO::Compress::Base::Common::createSelfTiedObject($class, \$GzipError);
+
+    $obj->_create(undef, @_);
+}
+
+
+sub gzip
+{
+    my $obj = IO::Compress::Base::Common::createSelfTiedObject(undef, \$GzipError);
+    return $obj->_def(@_);
+}
+
+#sub newHeader
+#{
+#    my $self = shift ;
+#    #return GZIP_MINIMUM_HEADER ;
+#    return $self->mkHeader(*$self->{Got});
+#}
+
+sub getExtraParams
+{
+    my $self = shift ;
+
+    return (
+            # zlib behaviour
+            $self->getZlibParams(),
+
+            # Gzip header fields
+            'minimal'   => [IO::Compress::Base::Common::Parse_boolean,   0],
+            'comment'   => [IO::Compress::Base::Common::Parse_any,       undef],
+            'name'      => [IO::Compress::Base::Common::Parse_any,       undef],
+            'time'      => [IO::Compress::Base::Common::Parse_any,       undef],
+            'textflag'  => [IO::Compress::Base::Common::Parse_boolean,   0],
+            'headercrc' => [IO::Compress::Base::Common::Parse_boolean,   0],
+            'os_code'   => [IO::Compress::Base::Common::Parse_unsigned,  $Compress::Raw::Zlib::gzip_os_code],
+            'extrafield'=> [IO::Compress::Base::Common::Parse_any,       undef],
+            'extraflags'=> [IO::Compress::Base::Common::Parse_any,       undef],
+
+        );
+}
+
+
+sub ckParams
+{
+    my $self = shift ;
+    my $got = shift ;
+
+    # gzip always needs crc32
+    $got->setValue('crc32' => 1);
+
+    return 1
+        if $got->getValue('merge') ;
+
+    my $strict = $got->getValue('strict') ;
+
+
+    {
+        if (! $got->parsed('time') ) {
+            # Modification time defaults to now.
+            $got->setValue(time => time) ;
+        }
+
+        # Check that the Name & Comment don't have embedded NULLs
+        # Also check that they only contain ISO 8859-1 chars.
+        if ($got->parsed('name') && defined $got->getValue('name')) {
+            my $name = $got->getValue('name');
+
+            return $self->saveErrorString(undef, "Null Character found in Name",
+                                                Z_DATA_ERROR)
+                if $strict && $name =~ /\x00/ ;
+
+            return $self->saveErrorString(undef, "Non ISO 8859-1 Character found in Name",
+                                                Z_DATA_ERROR)
+                if $strict && $name =~ /$GZIP_FNAME_INVALID_CHAR_RE/o ;
+        }
+
+        if ($got->parsed('comment') && defined $got->getValue('comment')) {
+            my $comment = $got->getValue('comment');
+
+            return $self->saveErrorString(undef, "Null Character found in Comment",
+                                                Z_DATA_ERROR)
+                if $strict && $comment =~ /\x00/ ;
+
+            return $self->saveErrorString(undef, "Non ISO 8859-1 Character found in Comment",
+                                                Z_DATA_ERROR)
+                if $strict && $comment =~ /$GZIP_FCOMMENT_INVALID_CHAR_RE/o;
+        }
+
+        if ($got->parsed('os_code') ) {
+            my $value = $got->getValue('os_code');
+
+            return $self->saveErrorString(undef, "OS_Code must be between 0 and 255, got '$value'")
+                if $value < 0 || $value > 255 ;
+
+        }
+
+        # gzip only supports Deflate at present
+        $got->setValue('method' => Z_DEFLATED) ;
+
+        if ( ! $got->parsed('extraflags')) {
+            $got->setValue('extraflags' => 2)
+                if $got->getValue('level') == Z_BEST_COMPRESSION ;
+            $got->setValue('extraflags' => 4)
+                if $got->getValue('level') == Z_BEST_SPEED ;
+        }
+
+        my $data = $got->getValue('extrafield') ;
+        if (defined $data) {
+            my $bad = IO::Compress::Zlib::Extra::parseExtraField($data, $strict, 1) ;
+            return $self->saveErrorString(undef, "Error with ExtraField Parameter: $bad", Z_DATA_ERROR)
+                if $bad ;
+
+            $got->setValue('extrafield' => $data) ;
+        }
+    }
+
+    return 1;
+}
+
+sub mkTrailer
+{
+    my $self = shift ;
+    return pack("V V", *$self->{Compress}->crc32(),
+                       *$self->{UnCompSize}->get32bit());
+}
+
+sub getInverseClass
+{
+    no warnings 'once';
+    return ('IO::Uncompress::Gunzip',
+                \$IO::Uncompress::Gunzip::GunzipError);
+}
+
+sub getFileInfo
+{
+    my $self = shift ;
+    my $params = shift;
+    my $filename = shift ;
+
+    return if IO::Compress::Base::Common::isaScalar($filename);
+
+    my $defaultTime = (stat($filename))[9] ;
+
+    $params->setValue('name' => $filename)
+        if ! $params->parsed('name') ;
+
+    $params->setValue('time' => $defaultTime)
+        if ! $params->parsed('time') ;
+}
+
+
+sub mkHeader
+{
+    my $self = shift ;
+    my $param = shift ;
+
+    # short-circuit if a minimal header is requested.
+    return GZIP_MINIMUM_HEADER if $param->getValue('minimal') ;
+
+    # METHOD
+    my $method = $param->valueOrDefault('method', GZIP_CM_DEFLATED) ;
+
+    # FLAGS
+    my $flags       = GZIP_FLG_DEFAULT ;
+    $flags |= GZIP_FLG_FTEXT    if $param->getValue('textflag') ;
+    $flags |= GZIP_FLG_FHCRC    if $param->getValue('headercrc') ;
+    $flags |= GZIP_FLG_FEXTRA   if $param->wantValue('extrafield') ;
+    $flags |= GZIP_FLG_FNAME    if $param->wantValue('name') ;
+    $flags |= GZIP_FLG_FCOMMENT if $param->wantValue('comment') ;
+
+    # MTIME
+    my $time = $param->valueOrDefault('time', GZIP_MTIME_DEFAULT) ;
+
+    # EXTRA FLAGS
+    my $extra_flags = $param->valueOrDefault('extraflags', GZIP_XFL_DEFAULT);
+
+    # OS CODE
+    my $os_code = $param->valueOrDefault('os_code', GZIP_OS_DEFAULT) ;
+
+
+    my $out = pack("C4 V C C",
+            GZIP_ID1,   # ID1
+            GZIP_ID2,   # ID2
+            $method,    # Compression Method
+            $flags,     # Flags
+            $time,      # Modification Time
+            $extra_flags, # Extra Flags
+            $os_code,   # Operating System Code
+            ) ;
+
+    # EXTRA
+    if ($flags & GZIP_FLG_FEXTRA) {
+        my $extra = $param->getValue('extrafield') ;
+        $out .= pack("v", length $extra) . $extra ;
+    }
+
+    # NAME
+    if ($flags & GZIP_FLG_FNAME) {
+        my $name .= $param->getValue('name') ;
+        $name =~ s/\x00.*$//;
+        $out .= $name ;
+        # Terminate the filename with NULL unless it already is
+        $out .= GZIP_NULL_BYTE
+            if !length $name or
+               substr($name, 1, -1) ne GZIP_NULL_BYTE ;
+    }
+
+    # COMMENT
+    if ($flags & GZIP_FLG_FCOMMENT) {
+        my $comment .= $param->getValue('comment') ;
+        $comment =~ s/\x00.*$//;
+        $out .= $comment ;
+        # Terminate the comment with NULL unless it already is
+        $out .= GZIP_NULL_BYTE
+            if ! length $comment or
+               substr($comment, 1, -1) ne GZIP_NULL_BYTE;
+    }
+
+    # HEADER CRC
+    $out .= pack("v", Compress::Raw::Zlib::crc32($out) & 0x00FF )
+        if $param->getValue('headercrc') ;
+
+    noUTF8($out);
+
+    return $out ;
+}
+
+sub mkFinalTrailer
+{
+    return '';
+}
+
+1;
+
+__END__
+
+=head1 NAME
+
+IO::Compress::Gzip - Write RFC 1952 files/buffers
+
+=head1 SYNOPSIS
+
+    use IO::Compress::Gzip qw(gzip $GzipError) ;
+
+    my $status = gzip $input => $output [,OPTS]
+        or die "gzip failed: $GzipError\n";
+
+    my $z = IO::Compress::Gzip->new( $output [,OPTS] )
+        or die "gzip failed: $GzipError\n";
+
+    $z->print($string);
+    $z->printf($format, $string);
+    $z->write($string);
+    $z->syswrite($string [, $length, $offset]);
+    $z->flush();
+    $z->tell();
+    $z->eof();
+    $z->seek($position, $whence);
+    $z->binmode();
+    $z->fileno();
+    $z->opened();
+    $z->autoflush();
+    $z->input_line_number();
+    $z->newStream( [OPTS] );
+
+    $z->deflateParams();
+
+    $z->close() ;
+
+    $GzipError ;
+
+    # IO::File mode
+
+    print $z $string;
+    printf $z $format, $string;
+    tell $z
+    eof $z
+    seek $z, $position, $whence
+    binmode $z
+    fileno $z
+    close $z ;
+
+=head1 DESCRIPTION
+
+This module provides a Perl interface that allows writing compressed
+data to files or buffer as defined in RFC 1952.
+
+All the gzip headers defined in RFC 1952 can be created using
+this module.
+
+For reading RFC 1952 files/buffers, see the companion module
+L<IO::Uncompress::Gunzip|IO::Uncompress::Gunzip>.
+
+=head1 Functional Interface
+
+A top-level function, C<gzip>, is provided to carry out
+"one-shot" compression between buffers and/or files. For finer
+control over the compression process, see the L</"OO Interface">
+section.
+
+    use IO::Compress::Gzip qw(gzip $GzipError) ;
+
+    gzip $input_filename_or_reference => $output_filename_or_reference [,OPTS]
+        or die "gzip failed: $GzipError\n";
+
+The functional interface needs Perl5.005 or better.
+
+=head2 gzip $input_filename_or_reference => $output_filename_or_reference [, OPTS]
+
+C<gzip> expects at least two parameters,
+C<$input_filename_or_reference> and C<$output_filename_or_reference>
+and zero or more optional parameters (see L</Optional Parameters>)
+
+=head3 The C<$input_filename_or_reference> parameter
+
+The parameter, C<$input_filename_or_reference>, is used to define the
+source of the uncompressed data.
+
+It can take one of the following forms:
+
+=over 5
+
+=item A filename
+
+If the C<$input_filename_or_reference> parameter is a simple scalar, it is
+assumed to be a filename. This file will be opened for reading and the
+input data will be read from it.
+
+=item A filehandle
+
+If the C<$input_filename_or_reference> parameter is a filehandle, the input
+data will be read from it.  The string '-' can be used as an alias for
+standard input.
+
+=item A scalar reference
+
+If C<$input_filename_or_reference> is a scalar reference, the input data
+will be read from C<$$input_filename_or_reference>.
+
+=item An array reference
+
+If C<$input_filename_or_reference> is an array reference, each element in
+the array must be a filename.
+
+The input data will be read from each file in turn.
+
+The complete array will be walked to ensure that it only
+contains valid filenames before any data is compressed.
+
+=item An Input FileGlob string
+
+If C<$input_filename_or_reference> is a string that is delimited by the
+characters "<" and ">" C<gzip> will assume that it is an
+I<input fileglob string>. The input is the list of files that match the
+fileglob.
+
+See L<File::GlobMapper|File::GlobMapper> for more details.
+
+=back
+
+If the C<$input_filename_or_reference> parameter is any other type,
+C<undef> will be returned.
+
+In addition, if C<$input_filename_or_reference> is a simple filename,
+the default values for
+the C<Name> and C<Time> options will be sourced from that file.
+
+If you do not want to use these defaults they can be overridden by
+explicitly setting the C<Name> and C<Time> options or by setting the
+C<Minimal> parameter.
+
+=head3 The C<$output_filename_or_reference> parameter
+
+The parameter C<$output_filename_or_reference> is used to control the
+destination of the compressed data. This parameter can take one of
+these forms.
+
+=over 5
+
+=item A filename
+
+If the C<$output_filename_or_reference> parameter is a simple scalar, it is
+assumed to be a filename.  This file will be opened for writing and the
+compressed data will be written to it.
+
+=item A filehandle
+
+If the C<$output_filename_or_reference> parameter is a filehandle, the
+compressed data will be written to it.  The string '-' can be used as
+an alias for standard output.
+
+=item A scalar reference
+
+If C<$output_filename_or_reference> is a scalar reference, the
+compressed data will be stored in C<$$output_filename_or_reference>.
+
+=item An Array Reference
+
+If C<$output_filename_or_reference> is an array reference,
+the compressed data will be pushed onto the array.
+
+=item An Output FileGlob
+
+If C<$output_filename_or_reference> is a string that is delimited by the
+characters "<" and ">" C<gzip> will assume that it is an
+I<output fileglob string>. The output is the list of files that match the
+fileglob.
+
+When C<$output_filename_or_reference> is an fileglob string,
+C<$input_filename_or_reference> must also be a fileglob string. Anything
+else is an error.
+
+See L<File::GlobMapper|File::GlobMapper> for more details.
+
+=back
+
+If the C<$output_filename_or_reference> parameter is any other type,
+C<undef> will be returned.
+
+=head2 Notes
+
+When C<$input_filename_or_reference> maps to multiple files/buffers and
+C<$output_filename_or_reference> is a single
+file/buffer the input files/buffers will be stored
+in C<$output_filename_or_reference> as a concatenated series of compressed data streams.
+
+=head2 Optional Parameters
+
+The optional parameters for the one-shot function C<gzip>
+are (for the most part) identical to those used with the OO interface defined in the
+L</"Constructor Options"> section. The exceptions are listed below
+
+=over 5
+
+=item C<< AutoClose => 0|1 >>
+
+This option applies to any input or output data streams to
+C<gzip> that are filehandles.
+
+If C<AutoClose> is specified, and the value is true, it will result in all
+input and/or output filehandles being closed once C<gzip> has
+completed.
+
+This parameter defaults to 0.
+
+=item C<< BinModeIn => 0|1 >>
+
+This option is now a no-op. All files will be read in binmode.
+
+=item C<< Append => 0|1 >>
+
+The behaviour of this option is dependent on the type of output data
+stream.
+
+=over 5
+
+=item * A Buffer
+
+If C<Append> is enabled, all compressed data will be append to the end of
+the output buffer. Otherwise the output buffer will be cleared before any
+compressed data is written to it.
+
+=item * A Filename
+
+If C<Append> is enabled, the file will be opened in append mode. Otherwise
+the contents of the file, if any, will be truncated before any compressed
+data is written to it.
+
+=item * A Filehandle
+
+If C<Append> is enabled, the filehandle will be positioned to the end of
+the file via a call to C<seek> before any compressed data is
+written to it.  Otherwise the file pointer will not be moved.
+
+=back
+
+When C<Append> is specified, and set to true, it will I<append> all compressed
+data to the output data stream.
+
+So when the output is a filehandle it will carry out a seek to the eof
+before writing any compressed data. If the output is a filename, it will be opened for
+appending. If the output is a buffer, all compressed data will be
+appended to the existing buffer.
+
+Conversely when C<Append> is not specified, or it is present and is set to
+false, it will operate as follows.
+
+When the output is a filename, it will truncate the contents of the file
+before writing any compressed data. If the output is a filehandle
+its position will not be changed. If the output is a buffer, it will be
+wiped before any compressed data is output.
+
+Defaults to 0.
+
+=back
+
+=head2 Oneshot Examples
+
+Here are a few example that show the capabilities of the module.
+
+=head3 Streaming
+
+This very simple command line example demonstrates the streaming capabilities of the module.
+The code reads data from STDIN, compresses it, and writes the compressed data to STDOUT.
+
+    $ echo hello world | perl -MIO::Compress::Gzip=gzip -e 'gzip \*STDIN => \*STDOUT' >output.gz
+
+The special filename "-" can be used as a standin for both C<\*STDIN> and C<\*STDOUT>,
+so the above can be rewritten as
+
+    $ echo hello world | perl -MIO::Compress::Gzip=gzip -e 'gzip "-" => "-"' >output.gz
+
+=head3 Compressing a file from the filesystem
+
+To read the contents of the file C<file1.txt> and write the compressed
+data to the file C<file1.txt.gz>.
+
+    use strict ;
+    use warnings ;
+    use IO::Compress::Gzip qw(gzip $GzipError) ;
+
+    my $input = "file1.txt";
+    gzip $input => "$input.gz"
+        or die "gzip failed: $GzipError\n";
+
+=head3 Reading from a Filehandle and writing to an in-memory buffer
+
+To read from an existing Perl filehandle, C<$input>, and write the
+compressed data to a buffer, C<$buffer>.
+
+    use strict ;
+    use warnings ;
+    use IO::Compress::Gzip qw(gzip $GzipError) ;
+    use IO::File ;
+
+    my $input = IO::File->new( "<file1.txt" )
+        or die "Cannot open 'file1.txt': $!\n" ;
+    my $buffer ;
+    gzip $input => \$buffer
+        or die "gzip failed: $GzipError\n";
+
+=head3 Compressing multiple files
+
+To compress all files in the directory "/my/home" that match "*.txt"
+and store the compressed data in the same directory
+
+    use strict ;
+    use warnings ;
+    use IO::Compress::Gzip qw(gzip $GzipError) ;
+
+    gzip '</my/home/*.txt>' => '<*.gz>'
+        or die "gzip failed: $GzipError\n";
+
+and if you want to compress each file one at a time, this will do the trick
+
+    use strict ;
+    use warnings ;
+    use IO::Compress::Gzip qw(gzip $GzipError) ;
+
+    for my $input ( glob "/my/home/*.txt" )
+    {
+        my $output = "$input.gz" ;
+        gzip $input => $output
+            or die "Error compressing '$input': $GzipError\n";
+    }
+
+=head1 OO Interface
+
+=head2 Constructor
+
+The format of the constructor for C<IO::Compress::Gzip> is shown below
+
+    my $z = IO::Compress::Gzip->new( $output [,OPTS] )
+        or die "IO::Compress::Gzip failed: $GzipError\n";
+
+The constructor takes one mandatory parameter, C<$output>, defined below and
+zero or more C<OPTS>, defined in L<Constructor Options>.
+
+It returns an C<IO::Compress::Gzip> object on success and C<undef> on failure.
+The variable C<$GzipError> will contain an error message on failure.
+
+If you are running Perl 5.005 or better the object, C<$z>, returned from
+IO::Compress::Gzip can be used exactly like an L<IO::File|IO::File> filehandle.
+This means that all normal output file operations can be carried out
+with C<$z>.
+For example, to write to a compressed file/buffer you can use either of
+these forms
+
+    $z->print("hello world\n");
+    print $z "hello world\n";
+
+Below is a simple exaple of using the OO interface to create an output file
+C<myfile.gz> and write some data to it.
+
+    my $filename = "myfile.gz";
+    my $z = IO::Compress::Gzip->new($filename)
+        or die "IO::Compress::Gzip failed: $GzipError\n";
+
+    $z->print("abcde");
+    $z->close();
+
+See the L</Examples> for more.
+
+The mandatory parameter C<$output> is used to control the destination
+of the compressed data. This parameter can take one of these forms.
+
+=over 5
+
+=item A filename
+
+If the C<$output> parameter is a simple scalar, it is assumed to be a
+filename. This file will be opened for writing and the compressed data
+will be written to it.
+
+=item A filehandle
+
+If the C<$output> parameter is a filehandle, the compressed data will be
+written to it.
+The string '-' can be used as an alias for standard output.
+
+=item A scalar reference
+
+If C<$output> is a scalar reference, the compressed data will be stored
+in C<$$output>.
+
+=back
+
+If the C<$output> parameter is any other type, C<IO::Compress::Gzip>::new will
+return undef.
+
+=head2 Constructor Options
+
+C<OPTS> is any combination of zero or more the following options:
+
+=over 5
+
+=item C<< AutoClose => 0|1 >>
+
+This option is only valid when the C<$output> parameter is a filehandle. If
+specified, and the value is true, it will result in the C<$output> being
+closed once either the C<close> method is called or the C<IO::Compress::Gzip>
+object is destroyed.
+
+This parameter defaults to 0.
+
+=item C<< Append => 0|1 >>
+
+Opens C<$output> in append mode.
+
+The behaviour of this option is dependent on the type of C<$output>.
+
+=over 5
+
+=item * A Buffer
+
+If C<$output> is a buffer and C<Append> is enabled, all compressed data
+will be append to the end of C<$output>. Otherwise C<$output> will be
+cleared before any data is written to it.
+
+=item * A Filename
+
+If C<$output> is a filename and C<Append> is enabled, the file will be
+opened in append mode. Otherwise the contents of the file, if any, will be
+truncated before any compressed data is written to it.
+
+=item * A Filehandle
+
+If C<$output> is a filehandle, the file pointer will be positioned to the
+end of the file via a call to C<seek> before any compressed data is written
+to it.  Otherwise the file pointer will not be moved.
+
+=back
+
+This parameter defaults to 0.
+
+=item C<< Merge => 0|1 >>
+
+This option is used to compress input data and append it to an existing
+compressed data stream in C<$output>. The end result is a single compressed
+data stream stored in C<$output>.
+
+It is a fatal error to attempt to use this option when C<$output> is not an
+RFC 1952 data stream.
+
+There are a number of other limitations with the C<Merge> option:
+
+=over 5
+
+=item 1
+
+This module needs to have been built with zlib 1.2.1 or better to work. A
+fatal error will be thrown if C<Merge> is used with an older version of
+zlib.
+
+=item 2
+
+If C<$output> is a file or a filehandle, it must be seekable.
+
+=back
+
+This parameter defaults to 0.
+
+=item -Level
+
+Defines the compression level used by zlib. The value should either be
+a number between 0 and 9 (0 means no compression and 9 is maximum
+compression), or one of the symbolic constants defined below.
+
+   Z_NO_COMPRESSION
+   Z_BEST_SPEED
+   Z_BEST_COMPRESSION
+   Z_DEFAULT_COMPRESSION
+
+The default is Z_DEFAULT_COMPRESSION.
+
+Note, these constants are not imported by C<IO::Compress::Gzip> by default.
+
+    use IO::Compress::Gzip qw(:strategy);
+    use IO::Compress::Gzip qw(:constants);
+    use IO::Compress::Gzip qw(:all);
+
+=item -Strategy
+
+Defines the strategy used to tune the compression. Use one of the symbolic
+constants defined below.
+
+   Z_FILTERED
+   Z_HUFFMAN_ONLY
+   Z_RLE
+   Z_FIXED
+   Z_DEFAULT_STRATEGY
+
+The default is Z_DEFAULT_STRATEGY.
+
+=item C<< Minimal => 0|1 >>
+
+If specified, this option will force the creation of the smallest possible
+compliant gzip header (which is exactly 10 bytes long) as defined in
+RFC 1952.
+
+See the section titled "Compliance" in RFC 1952 for a definition
+of the values used for the fields in the gzip header.
+
+All other parameters that control the content of the gzip header will
+be ignored if this parameter is set to 1.
+
+This parameter defaults to 0.
+
+=item C<< Comment => $comment >>
+
+Stores the contents of C<$comment> in the COMMENT field in
+the gzip header.
+By default, no comment field is written to the gzip file.
+
+If the C<-Strict> option is enabled, the comment can only consist of ISO
+8859-1 characters plus line feed.
+
+If the C<-Strict> option is disabled, the comment field can contain any
+character except NULL. If any null characters are present, the field
+will be truncated at the first NULL.
+
+=item C<< Name => $string >>
+
+Stores the contents of C<$string> in the gzip NAME header field. If
+C<Name> is not specified, no gzip NAME field will be created.
+
+If the C<-Strict> option is enabled, C<$string> can only consist of ISO
+8859-1 characters.
+
+If C<-Strict> is disabled, then C<$string> can contain any character
+except NULL. If any null characters are present, the field will be
+truncated at the first NULL.
+
+=item C<< Time => $number >>
+
+Sets the MTIME field in the gzip header to $number.
+
+This field defaults to the time the C<IO::Compress::Gzip> object was created
+if this option is not specified.
+
+=item C<< TextFlag => 0|1 >>
+
+This parameter controls the setting of the FLG.FTEXT bit in the gzip
+header. It is used to signal that the data stored in the gzip file/buffer
+is probably text.
+
+The default is 0.
+
+=item C<< HeaderCRC => 0|1 >>
+
+When true this parameter will set the FLG.FHCRC bit to 1 in the gzip header
+and set the CRC16 header field to the CRC of the complete gzip header
+except the CRC16 field itself.
+
+B<Note> that gzip files created with the C<HeaderCRC> flag set to 1 cannot
+be read by most, if not all, of the standard gunzip utilities, most
+notably gzip version 1.2.4. You should therefore avoid using this option if
+you want to maximize the portability of your gzip files.
+
+This parameter defaults to 0.
+
+=item C<< OS_Code => $value >>
+
+Stores C<$value> in the gzip OS header field. A number between 0 and 255 is
+valid.
+
+If not specified, this parameter defaults to the OS code of the Operating
+System this module was built on. The value 3 is used as a catch-all for all
+Unix variants and unknown Operating Systems.
+
+=item C<< ExtraField => $data >>
+
+This parameter allows additional metadata to be stored in the ExtraField in
+the gzip header. An RFC 1952 compliant ExtraField consists of zero or more
+subfields. Each subfield consists of a two byte header followed by the
+subfield data.
+
+The list of subfields can be supplied in any of the following formats
+
+    -ExtraField => [$id1, $data1,
+                    $id2, $data2,
+                     ...
+                   ]
+    -ExtraField => [ [$id1 => $data1],
+                     [$id2 => $data2],
+                     ...
+                   ]
+    -ExtraField => { $id1 => $data1,
+                     $id2 => $data2,
+                     ...
+                   }
+
+Where C<$id1>, C<$id2> are two byte subfield ID's. The second byte of
+the ID cannot be 0, unless the C<Strict> option has been disabled.
+
+If you use the hash syntax, you have no control over the order in which
+the ExtraSubFields are stored, plus you cannot have SubFields with
+duplicate ID.
+
+Alternatively the list of subfields can by supplied as a scalar, thus
+
+    -ExtraField => $rawdata
+
+If you use the raw format, and the C<Strict> option is enabled,
+C<IO::Compress::Gzip> will check that C<$rawdata> consists of zero or more
+conformant sub-fields. When C<Strict> is disabled, C<$rawdata> can
+consist of any arbitrary byte stream.
+
+The maximum size of the Extra Field 65535 bytes.
+
+=item C<< ExtraFlags => $value >>
+
+Sets the XFL byte in the gzip header to C<$value>.
+
+If this option is not present, the value stored in XFL field will be
+determined by the setting of the C<Level> option.
+
+If C<< Level => Z_BEST_SPEED >> has been specified then XFL is set to 2.
+If C<< Level => Z_BEST_COMPRESSION >> has been specified then XFL is set to 4.
+Otherwise XFL is set to 0.
+
+=item C<< Strict => 0|1 >>
+
+C<Strict> will optionally police the values supplied with other options
+to ensure they are compliant with RFC1952.
+
+This option is enabled by default.
+
+If C<Strict> is enabled the following behaviour will be policed:
+
+=over 5
+
+=item *
+
+The value supplied with the C<Name> option can only contain ISO 8859-1
+characters.
+
+=item *
+
+The value supplied with the C<Comment> option can only contain ISO 8859-1
+characters plus line-feed.
+
+=item *
+
+The values supplied with the C<-Name> and C<-Comment> options cannot
+contain multiple embedded nulls.
+
+=item *
+
+If an C<ExtraField> option is specified and it is a simple scalar,
+it must conform to the sub-field structure as defined in RFC 1952.
+
+=item *
+
+If an C<ExtraField> option is specified the second byte of the ID will be
+checked in each subfield to ensure that it does not contain the reserved
+value 0x00.
+
+=back
+
+When C<Strict> is disabled the following behaviour will be policed:
+
+=over 5
+
+=item *
+
+The value supplied with C<-Name> option can contain
+any character except NULL.
+
+=item *
+
+The value supplied with C<-Comment> option can contain any character
+except NULL.
+
+=item *
+
+The values supplied with the C<-Name> and C<-Comment> options can contain
+multiple embedded nulls. The string written to the gzip header will
+consist of the characters up to, but not including, the first embedded
+NULL.
+
+=item *
+
+If an C<ExtraField> option is specified and it is a simple scalar, the
+structure will not be checked. The only error is if the length is too big.
+
+=item *
+
+The ID header in an C<ExtraField> sub-field can consist of any two bytes.
+
+=back
+
+=back
+
+=head2 Examples
+
+=head3 Streaming
+
+This very simple command line example demonstrates the streaming capabilities
+of the module. The code reads data from STDIN or all the files given on the
+commandline, compresses it, and writes the compressed data to STDOUT.
+
+    use strict ;
+    use warnings ;
+    use IO::Compress::Gzip qw(gzip $GzipError) ;
+
+    my $z = IO::Compress::Gzip->new("-", Stream => 1)
+        or die "IO::Compress::Gzip failed: $GzipError\n";
+
+    while (<>) {
+        $z->print("abcde");
+    }
+    $z->close();
+
+Note the use of C<"-"> to means C<STDOUT>. Alternatively you can use C<\*STDOUT>.
+
+=head3 Compressing a file from the filesystem
+
+To read the contents of the file C<file1.txt> and write the compressed
+data to the file C<file1.txt.gz> there are a few options
+
+Start by creating the compression object and opening the input file
+
+    use strict ;
+    use warnings ;
+    use IO::Compress::Gzip qw(gzip $GzipError) ;
+
+    my $input = "file1.txt";
+    my $z = IO::Compress::Gzip->new("file1.txt.gz")
+        or die "IO::Compress::Gzip failed: $GzipError\n";
+
+    # open the input file
+    open my $fh, "<", "file1.txt"
+        or die "Cannot open file1.txt: $!\n";
+
+    # loop through the input file & write to the compressed file
+    while (<$fh>) {
+        $z->print($_);
+    }
+
+    # not forgetting to close the compressed file
+    $z->close();
+
+=head1 Methods
+
+=head2 print
+
+Usage is
+
+    $z->print($data)
+    print $z $data
+
+Compresses and outputs the contents of the C<$data> parameter. This
+has the same behaviour as the C<print> built-in.
+
+Returns true if successful.
+
+=head2 printf
+
+Usage is
+
+    $z->printf($format, $data)
+    printf $z $format, $data
+
+Compresses and outputs the contents of the C<$data> parameter.
+
+Returns true if successful.
+
+=head2 syswrite
+
+Usage is
+
+    $z->syswrite $data
+    $z->syswrite $data, $length
+    $z->syswrite $data, $length, $offset
+
+Compresses and outputs the contents of the C<$data> parameter.
+
+Returns the number of uncompressed bytes written, or C<undef> if
+unsuccessful.
+
+=head2 write
+
+Usage is
+
+    $z->write $data
+    $z->write $data, $length
+    $z->write $data, $length, $offset
+
+Compresses and outputs the contents of the C<$data> parameter.
+
+Returns the number of uncompressed bytes written, or C<undef> if
+unsuccessful.
+
+=head2 flush
+
+Usage is
+
+    $z->flush;
+    $z->flush($flush_type);
+
+Flushes any pending compressed data to the output file/buffer.
+
+This method takes an optional parameter, C<$flush_type>, that controls
+how the flushing will be carried out. By default the C<$flush_type>
+used is C<Z_FINISH>. Other valid values for C<$flush_type> are
+C<Z_NO_FLUSH>, C<Z_SYNC_FLUSH>, C<Z_FULL_FLUSH> and C<Z_BLOCK>. It is
+strongly recommended that you only set the C<flush_type> parameter if
+you fully understand the implications of what it does - overuse of C<flush>
+can seriously degrade the level of compression achieved. See the C<zlib>
+documentation for details.
+
+Returns true on success.
+
+=head2 tell
+
+Usage is
+
+    $z->tell()
+    tell $z
+
+Returns the uncompressed file offset.
+
+=head2 eof
+
+Usage is
+
+    $z->eof();
+    eof($z);
+
+Returns true if the C<close> method has been called.
+
+=head2 seek
+
+    $z->seek($position, $whence);
+    seek($z, $position, $whence);
+
+Provides a sub-set of the C<seek> functionality, with the restriction
+that it is only legal to seek forward in the output file/buffer.
+It is a fatal error to attempt to seek backward.
+
+Empty parts of the file/buffer will have NULL (0x00) bytes written to them.
+
+The C<$whence> parameter takes one the usual values, namely SEEK_SET,
+SEEK_CUR or SEEK_END.
+
+Returns 1 on success, 0 on failure.
+
+=head2 binmode
+
+Usage is
+
+    $z->binmode
+    binmode $z ;
+
+This is a noop provided for completeness.
+
+=head2 opened
+
+    $z->opened()
+
+Returns true if the object currently refers to a opened file/buffer.
+
+=head2 autoflush
+
+    my $prev = $z->autoflush()
+    my $prev = $z->autoflush(EXPR)
+
+If the C<$z> object is associated with a file or a filehandle, this method
+returns the current autoflush setting for the underlying filehandle. If
+C<EXPR> is present, and is non-zero, it will enable flushing after every
+write/print operation.
+
+If C<$z> is associated with a buffer, this method has no effect and always
+returns C<undef>.
+
+B<Note> that the special variable C<$|> B<cannot> be used to set or
+retrieve the autoflush setting.
+
+=head2 input_line_number
+
+    $z->input_line_number()
+    $z->input_line_number(EXPR)
+
+This method always returns C<undef> when compressing.
+
+=head2 fileno
+
+    $z->fileno()
+    fileno($z)
+
+If the C<$z> object is associated with a file or a filehandle, C<fileno>
+will return the underlying file descriptor. Once the C<close> method is
+called C<fileno> will return C<undef>.
+
+If the C<$z> object is associated with a buffer, this method will return
+C<undef>.
+
+=head2 close
+
+    $z->close() ;
+    close $z ;
+
+Flushes any pending compressed data and then closes the output file/buffer.
+
+For most versions of Perl this method will be automatically invoked if
+the IO::Compress::Gzip object is destroyed (either explicitly or by the
+variable with the reference to the object going out of scope). The
+exceptions are Perl versions 5.005 through 5.00504 and 5.8.0. In
+these cases, the C<close> method will be called automatically, but
+not until global destruction of all live objects when the program is
+terminating.
+
+Therefore, if you want your scripts to be able to run on all versions
+of Perl, you should call C<close> explicitly and not rely on automatic
+closing.
+
+Returns true on success, otherwise 0.
+
+If the C<AutoClose> option has been enabled when the IO::Compress::Gzip
+object was created, and the object is associated with a file, the
+underlying file will also be closed.
+
+=head2 newStream([OPTS])
+
+Usage is
+
+    $z->newStream( [OPTS] )
+
+Closes the current compressed data stream and starts a new one.
+
+OPTS consists of any of the options that are available when creating
+the C<$z> object.
+
+See the L</"Constructor Options"> section for more details.
+
+=head2 deflateParams
+
+Usage is
+
+    $z->deflateParams
+
+TODO
+
+=head1 Importing
+
+A number of symbolic constants are required by some methods in
+C<IO::Compress::Gzip>. None are imported by default.
+
+=over 5
+
+=item :all
+
+Imports C<gzip>, C<$GzipError> and all symbolic
+constants that can be used by C<IO::Compress::Gzip>. Same as doing this
+
+    use IO::Compress::Gzip qw(gzip $GzipError :constants) ;
+
+=item :constants
+
+Import all symbolic constants. Same as doing this
+
+    use IO::Compress::Gzip qw(:flush :level :strategy) ;
+
+=item :flush
+
+These symbolic constants are used by the C<flush> method.
+
+    Z_NO_FLUSH
+    Z_PARTIAL_FLUSH
+    Z_SYNC_FLUSH
+    Z_FULL_FLUSH
+    Z_FINISH
+    Z_BLOCK
+
+=item :level
+
+These symbolic constants are used by the C<Level> option in the constructor.
+
+    Z_NO_COMPRESSION
+    Z_BEST_SPEED
+    Z_BEST_COMPRESSION
+    Z_DEFAULT_COMPRESSION
+
+=item :strategy
+
+These symbolic constants are used by the C<Strategy> option in the constructor.
+
+    Z_FILTERED
+    Z_HUFFMAN_ONLY
+    Z_RLE
+    Z_FIXED
+    Z_DEFAULT_STRATEGY
+
+=back
+
+=head1 EXAMPLES
+
+=head2 Apache::GZip Revisited
+
+See L<IO::Compress::FAQ|IO::Compress::FAQ/"Apache::GZip Revisited">
+
+=head2 Working with Net::FTP
+
+See L<IO::Compress::FAQ|IO::Compress::FAQ/"Compressed files and Net::FTP">
+
+=head1 SUPPORT
+
+General feedback/questions/bug reports should be sent to
+L<https://github.com/pmqs/IO-Copress/issues> (preferred) or
+L<https://rt.cpan.org/Public/Dist/Display.html?Name=IO-Copress>.
+
+=head1 SEE ALSO
+
+L<Compress::Zlib>, L<IO::Uncompress::Gunzip>, L<IO::Compress::Deflate>, L<IO::Uncompress::Inflate>, L<IO::Compress::RawDeflate>, L<IO::Uncompress::RawInflate>, L<IO::Compress::Bzip2>, L<IO::Uncompress::Bunzip2>, L<IO::Compress::Lzma>, L<IO::Uncompress::UnLzma>, L<IO::Compress::Xz>, L<IO::Uncompress::UnXz>, L<IO::Compress::Lzip>, L<IO::Uncompress::UnLzip>, L<IO::Compress::Lzop>, L<IO::Uncompress::UnLzop>, L<IO::Compress::Lzf>, L<IO::Uncompress::UnLzf>, L<IO::Compress::Zstd>, L<IO::Uncompress::UnZstd>, L<IO::Uncompress::AnyInflate>, L<IO::Uncompress::AnyUncompress>
+
+L<IO::Compress::FAQ|IO::Compress::FAQ>
+
+L<File::GlobMapper|File::GlobMapper>, L<Archive::Zip|Archive::Zip>,
+L<Archive::Tar|Archive::Tar>,
+L<IO::Zlib|IO::Zlib>
+
+For RFC 1950, 1951 and 1952 see
+L<https://datatracker.ietf.org/doc/html/rfc1950>,
+L<https://datatracker.ietf.org/doc/html/rfc1951> and
+L<https://datatracker.ietf.org/doc/html/rfc1952>
+
+The I<zlib> compression library was written by Jean-loup Gailly
+C<gzip@prep.ai.mit.edu> and Mark Adler C<madler@alumni.caltech.edu>.
+
+The primary site for the I<zlib> compression library is
+L<http://www.zlib.org>.
+
+The primary site for the I<zlib-ng> compression library is
+L<https://github.com/zlib-ng/zlib-ng>.
+
+The primary site for gzip is L<http://www.gzip.org>.
+
+=head1 AUTHOR
+
+This module was written by Paul Marquess, C<pmqs@cpan.org>.
+
+=head1 MODIFICATION HISTORY
+
+See the Changes file.
+
+=head1 COPYRIGHT AND LICENSE
+
+Copyright (c) 2005-2024 Paul Marquess. All rights reserved.
+
+This program is free software; you can redistribute it and/or
+modify it under the same terms as Perl itself.

git/usr/share/perl5/core_perl/IO/Compress/RawDeflate.pm

@@ -0,0 +1,1076 @@
+package IO::Compress::RawDeflate ;
+
+# create RFC1951
+#
+use strict ;
+use warnings;
+use bytes;
+
+use IO::Compress::Base 2.213 ;
+use IO::Compress::Base::Common  2.213 qw(:Status :Parse);
+use IO::Compress::Adapter::Deflate 2.213 ;
+use Compress::Raw::Zlib  2.213 qw(Z_DEFLATED Z_DEFAULT_COMPRESSION Z_DEFAULT_STRATEGY);
+
+require Exporter ;
+
+our ($VERSION, @ISA, @EXPORT_OK, %DEFLATE_CONSTANTS, %EXPORT_TAGS, $RawDeflateError);
+
+$VERSION = '2.213';
+$RawDeflateError = '';
+
+@ISA = qw(IO::Compress::Base Exporter);
+@EXPORT_OK = qw( $RawDeflateError rawdeflate ) ;
+push @EXPORT_OK, @IO::Compress::Adapter::Deflate::EXPORT_OK ;
+
+%EXPORT_TAGS = %IO::Compress::Adapter::Deflate::DEFLATE_CONSTANTS;
+
+
+{
+    my %seen;
+    foreach (keys %EXPORT_TAGS )
+    {
+        push @{$EXPORT_TAGS{constants}},
+                 grep { !$seen{$_}++ }
+                 @{ $EXPORT_TAGS{$_} }
+    }
+    $EXPORT_TAGS{all} = $EXPORT_TAGS{constants} ;
+}
+
+
+%DEFLATE_CONSTANTS = %EXPORT_TAGS;
+
+#push @{ $EXPORT_TAGS{all} }, @EXPORT_OK ;
+
+Exporter::export_ok_tags('all');
+
+
+
+sub new
+{
+    my $class = shift ;
+
+    my $obj = IO::Compress::Base::Common::createSelfTiedObject($class, \$RawDeflateError);
+
+    return $obj->_create(undef, @_);
+}
+
+sub rawdeflate
+{
+    my $obj = IO::Compress::Base::Common::createSelfTiedObject(undef, \$RawDeflateError);
+    return $obj->_def(@_);
+}
+
+sub ckParams
+{
+    my $self = shift ;
+    my $got = shift;
+
+    return 1 ;
+}
+
+sub mkComp
+{
+    my $self = shift ;
+    my $got = shift ;
+
+    my ($obj, $errstr, $errno) = IO::Compress::Adapter::Deflate::mkCompObject(
+                                                 $got->getValue('crc32'),
+                                                 $got->getValue('adler32'),
+                                                 $got->getValue('level'),
+                                                 $got->getValue('strategy')
+                                                 );
+
+   return $self->saveErrorString(undef, $errstr, $errno)
+       if ! defined $obj;
+
+   return $obj;
+}
+
+
+sub mkHeader
+{
+    my $self = shift ;
+    return '';
+}
+
+sub mkTrailer
+{
+    my $self = shift ;
+    return '';
+}
+
+sub mkFinalTrailer
+{
+    return '';
+}
+
+
+#sub newHeader
+#{
+#    my $self = shift ;
+#    return '';
+#}
+
+sub getExtraParams
+{
+    my $self = shift ;
+    return getZlibParams();
+}
+
+our %PARAMS = (
+            #'method'   => [IO::Compress::Base::Common::Parse_unsigned,  Z_DEFLATED],
+            'level'     => [IO::Compress::Base::Common::Parse_signed,    Z_DEFAULT_COMPRESSION],
+            'strategy'  => [IO::Compress::Base::Common::Parse_signed,    Z_DEFAULT_STRATEGY],
+
+            'crc32'     => [IO::Compress::Base::Common::Parse_boolean,   0],
+            'adler32'   => [IO::Compress::Base::Common::Parse_boolean,   0],
+            'merge'     => [IO::Compress::Base::Common::Parse_boolean,   0],
+        );
+
+sub getZlibParams
+{
+    return %PARAMS;
+}
+
+sub getInverseClass
+{
+    no warnings 'once';
+    return ('IO::Uncompress::RawInflate',
+                \$IO::Uncompress::RawInflate::RawInflateError);
+}
+
+sub getFileInfo
+{
+    my $self = shift ;
+    my $params = shift;
+    my $file = shift ;
+
+}
+
+use Fcntl qw(SEEK_SET);
+
+sub createMerge
+{
+    my $self = shift ;
+    my $outValue = shift ;
+    my $outType = shift ;
+
+    my ($invClass, $error_ref) = $self->getInverseClass();
+    eval "require $invClass"
+        or die "aaaahhhh" ;
+
+    my $inf = $invClass->new( $outValue,
+                             Transparent => 0,
+                             #Strict     => 1,
+                             AutoClose   => 0,
+                             Scan        => 1)
+       or return $self->saveErrorString(undef, "Cannot create InflateScan object: $$error_ref" ) ;
+
+    my $end_offset = 0;
+    $inf->scan()
+        or return $self->saveErrorString(undef, "Error Scanning: $$error_ref", $inf->errorNo) ;
+    $inf->zap($end_offset)
+        or return $self->saveErrorString(undef, "Error Zapping: $$error_ref", $inf->errorNo) ;
+
+    my $def = *$self->{Compress} = $inf->createDeflate();
+
+    *$self->{Header} = *$inf->{Info}{Header};
+    *$self->{UnCompSize} = *$inf->{UnCompSize}->clone();
+    *$self->{CompSize} = *$inf->{CompSize}->clone();
+    # TODO -- fix this
+    #*$self->{CompSize} = U64->new(0, *$self->{UnCompSize_32bit});
+
+
+    if ( $outType eq 'buffer')
+      { substr( ${ *$self->{Buffer} }, $end_offset) = '' }
+    elsif ($outType eq 'handle' || $outType eq 'filename') {
+        *$self->{FH} = *$inf->{FH} ;
+        delete *$inf->{FH};
+        *$self->{FH}->flush() ;
+        *$self->{Handle} = 1 if $outType eq 'handle';
+
+        #seek(*$self->{FH}, $end_offset, SEEK_SET)
+        *$self->{FH}->seek($end_offset, SEEK_SET)
+            or return $self->saveErrorString(undef, $!, $!) ;
+    }
+
+    return $def ;
+}
+
+#### zlib specific methods
+
+sub deflateParams
+{
+    my $self = shift ;
+
+    my $level = shift ;
+    my $strategy = shift ;
+
+    my $status = *$self->{Compress}->deflateParams(Level => $level, Strategy => $strategy) ;
+    return $self->saveErrorString(0, *$self->{Compress}{Error}, *$self->{Compress}{ErrorNo})
+        if $status == STATUS_ERROR;
+
+    return 1;
+}
+
+
+
+
+1;
+
+__END__
+
+=head1 NAME
+
+IO::Compress::RawDeflate - Write RFC 1951 files/buffers
+
+=head1 SYNOPSIS
+
+    use IO::Compress::RawDeflate qw(rawdeflate $RawDeflateError) ;
+
+    my $status = rawdeflate $input => $output [,OPTS]
+        or die "rawdeflate failed: $RawDeflateError\n";
+
+    my $z = IO::Compress::RawDeflate->new( $output [,OPTS] )
+        or die "rawdeflate failed: $RawDeflateError\n";
+
+    $z->print($string);
+    $z->printf($format, $string);
+    $z->write($string);
+    $z->syswrite($string [, $length, $offset]);
+    $z->flush();
+    $z->tell();
+    $z->eof();
+    $z->seek($position, $whence);
+    $z->binmode();
+    $z->fileno();
+    $z->opened();
+    $z->autoflush();
+    $z->input_line_number();
+    $z->newStream( [OPTS] );
+
+    $z->deflateParams();
+
+    $z->close() ;
+
+    $RawDeflateError ;
+
+    # IO::File mode
+
+    print $z $string;
+    printf $z $format, $string;
+    tell $z
+    eof $z
+    seek $z, $position, $whence
+    binmode $z
+    fileno $z
+    close $z ;
+
+=head1 DESCRIPTION
+
+This module provides a Perl interface that allows writing compressed
+data to files or buffer as defined in RFC 1951.
+
+Note that RFC 1951 data is not a good choice of compression format
+to use in isolation, especially if you want to auto-detect it.
+
+For reading RFC 1951 files/buffers, see the companion module
+L<IO::Uncompress::RawInflate|IO::Uncompress::RawInflate>.
+
+=head1 Functional Interface
+
+A top-level function, C<rawdeflate>, is provided to carry out
+"one-shot" compression between buffers and/or files. For finer
+control over the compression process, see the L</"OO Interface">
+section.
+
+    use IO::Compress::RawDeflate qw(rawdeflate $RawDeflateError) ;
+
+    rawdeflate $input_filename_or_reference => $output_filename_or_reference [,OPTS]
+        or die "rawdeflate failed: $RawDeflateError\n";
+
+The functional interface needs Perl5.005 or better.
+
+=head2 rawdeflate $input_filename_or_reference => $output_filename_or_reference [, OPTS]
+
+C<rawdeflate> expects at least two parameters,
+C<$input_filename_or_reference> and C<$output_filename_or_reference>
+and zero or more optional parameters (see L</Optional Parameters>)
+
+=head3 The C<$input_filename_or_reference> parameter
+
+The parameter, C<$input_filename_or_reference>, is used to define the
+source of the uncompressed data.
+
+It can take one of the following forms:
+
+=over 5
+
+=item A filename
+
+If the C<$input_filename_or_reference> parameter is a simple scalar, it is
+assumed to be a filename. This file will be opened for reading and the
+input data will be read from it.
+
+=item A filehandle
+
+If the C<$input_filename_or_reference> parameter is a filehandle, the input
+data will be read from it.  The string '-' can be used as an alias for
+standard input.
+
+=item A scalar reference
+
+If C<$input_filename_or_reference> is a scalar reference, the input data
+will be read from C<$$input_filename_or_reference>.
+
+=item An array reference
+
+If C<$input_filename_or_reference> is an array reference, each element in
+the array must be a filename.
+
+The input data will be read from each file in turn.
+
+The complete array will be walked to ensure that it only
+contains valid filenames before any data is compressed.
+
+=item An Input FileGlob string
+
+If C<$input_filename_or_reference> is a string that is delimited by the
+characters "<" and ">" C<rawdeflate> will assume that it is an
+I<input fileglob string>. The input is the list of files that match the
+fileglob.
+
+See L<File::GlobMapper|File::GlobMapper> for more details.
+
+=back
+
+If the C<$input_filename_or_reference> parameter is any other type,
+C<undef> will be returned.
+
+=head3 The C<$output_filename_or_reference> parameter
+
+The parameter C<$output_filename_or_reference> is used to control the
+destination of the compressed data. This parameter can take one of
+these forms.
+
+=over 5
+
+=item A filename
+
+If the C<$output_filename_or_reference> parameter is a simple scalar, it is
+assumed to be a filename.  This file will be opened for writing and the
+compressed data will be written to it.
+
+=item A filehandle
+
+If the C<$output_filename_or_reference> parameter is a filehandle, the
+compressed data will be written to it.  The string '-' can be used as
+an alias for standard output.
+
+=item A scalar reference
+
+If C<$output_filename_or_reference> is a scalar reference, the
+compressed data will be stored in C<$$output_filename_or_reference>.
+
+=item An Array Reference
+
+If C<$output_filename_or_reference> is an array reference,
+the compressed data will be pushed onto the array.
+
+=item An Output FileGlob
+
+If C<$output_filename_or_reference> is a string that is delimited by the
+characters "<" and ">" C<rawdeflate> will assume that it is an
+I<output fileglob string>. The output is the list of files that match the
+fileglob.
+
+When C<$output_filename_or_reference> is an fileglob string,
+C<$input_filename_or_reference> must also be a fileglob string. Anything
+else is an error.
+
+See L<File::GlobMapper|File::GlobMapper> for more details.
+
+=back
+
+If the C<$output_filename_or_reference> parameter is any other type,
+C<undef> will be returned.
+
+=head2 Notes
+
+When C<$input_filename_or_reference> maps to multiple files/buffers and
+C<$output_filename_or_reference> is a single
+file/buffer the input files/buffers will be stored
+in C<$output_filename_or_reference> as a concatenated series of compressed data streams.
+
+=head2 Optional Parameters
+
+The optional parameters for the one-shot function C<rawdeflate>
+are (for the most part) identical to those used with the OO interface defined in the
+L</"Constructor Options"> section. The exceptions are listed below
+
+=over 5
+
+=item C<< AutoClose => 0|1 >>
+
+This option applies to any input or output data streams to
+C<rawdeflate> that are filehandles.
+
+If C<AutoClose> is specified, and the value is true, it will result in all
+input and/or output filehandles being closed once C<rawdeflate> has
+completed.
+
+This parameter defaults to 0.
+
+=item C<< BinModeIn => 0|1 >>
+
+This option is now a no-op. All files will be read in binmode.
+
+=item C<< Append => 0|1 >>
+
+The behaviour of this option is dependent on the type of output data
+stream.
+
+=over 5
+
+=item * A Buffer
+
+If C<Append> is enabled, all compressed data will be append to the end of
+the output buffer. Otherwise the output buffer will be cleared before any
+compressed data is written to it.
+
+=item * A Filename
+
+If C<Append> is enabled, the file will be opened in append mode. Otherwise
+the contents of the file, if any, will be truncated before any compressed
+data is written to it.
+
+=item * A Filehandle
+
+If C<Append> is enabled, the filehandle will be positioned to the end of
+the file via a call to C<seek> before any compressed data is
+written to it.  Otherwise the file pointer will not be moved.
+
+=back
+
+When C<Append> is specified, and set to true, it will I<append> all compressed
+data to the output data stream.
+
+So when the output is a filehandle it will carry out a seek to the eof
+before writing any compressed data. If the output is a filename, it will be opened for
+appending. If the output is a buffer, all compressed data will be
+appended to the existing buffer.
+
+Conversely when C<Append> is not specified, or it is present and is set to
+false, it will operate as follows.
+
+When the output is a filename, it will truncate the contents of the file
+before writing any compressed data. If the output is a filehandle
+its position will not be changed. If the output is a buffer, it will be
+wiped before any compressed data is output.
+
+Defaults to 0.
+
+=back
+
+=head2 Oneshot Examples
+
+Here are a few example that show the capabilities of the module.
+
+=head3 Streaming
+
+This very simple command line example demonstrates the streaming capabilities of the module.
+The code reads data from STDIN, compresses it, and writes the compressed data to STDOUT.
+
+    $ echo hello world | perl -MIO::Compress::RawDeflate=rawdeflate -e 'rawdeflate \*STDIN => \*STDOUT' >output.1951
+
+The special filename "-" can be used as a standin for both C<\*STDIN> and C<\*STDOUT>,
+so the above can be rewritten as
+
+    $ echo hello world | perl -MIO::Compress::RawDeflate=rawdeflate -e 'rawdeflate "-" => "-"' >output.1951
+
+=head3 Compressing a file from the filesystem
+
+To read the contents of the file C<file1.txt> and write the compressed
+data to the file C<file1.txt.1951>.
+
+    use strict ;
+    use warnings ;
+    use IO::Compress::RawDeflate qw(rawdeflate $RawDeflateError) ;
+
+    my $input = "file1.txt";
+    rawdeflate $input => "$input.1951"
+        or die "rawdeflate failed: $RawDeflateError\n";
+
+=head3 Reading from a Filehandle and writing to an in-memory buffer
+
+To read from an existing Perl filehandle, C<$input>, and write the
+compressed data to a buffer, C<$buffer>.
+
+    use strict ;
+    use warnings ;
+    use IO::Compress::RawDeflate qw(rawdeflate $RawDeflateError) ;
+    use IO::File ;
+
+    my $input = IO::File->new( "<file1.txt" )
+        or die "Cannot open 'file1.txt': $!\n" ;
+    my $buffer ;
+    rawdeflate $input => \$buffer
+        or die "rawdeflate failed: $RawDeflateError\n";
+
+=head3 Compressing multiple files
+
+To compress all files in the directory "/my/home" that match "*.txt"
+and store the compressed data in the same directory
+
+    use strict ;
+    use warnings ;
+    use IO::Compress::RawDeflate qw(rawdeflate $RawDeflateError) ;
+
+    rawdeflate '</my/home/*.txt>' => '<*.1951>'
+        or die "rawdeflate failed: $RawDeflateError\n";
+
+and if you want to compress each file one at a time, this will do the trick
+
+    use strict ;
+    use warnings ;
+    use IO::Compress::RawDeflate qw(rawdeflate $RawDeflateError) ;
+
+    for my $input ( glob "/my/home/*.txt" )
+    {
+        my $output = "$input.1951" ;
+        rawdeflate $input => $output
+            or die "Error compressing '$input': $RawDeflateError\n";
+    }
+
+=head1 OO Interface
+
+=head2 Constructor
+
+The format of the constructor for C<IO::Compress::RawDeflate> is shown below
+
+    my $z = IO::Compress::RawDeflate->new( $output [,OPTS] )
+        or die "IO::Compress::RawDeflate failed: $RawDeflateError\n";
+
+The constructor takes one mandatory parameter, C<$output>, defined below and
+zero or more C<OPTS>, defined in L<Constructor Options>.
+
+It returns an C<IO::Compress::RawDeflate> object on success and C<undef> on failure.
+The variable C<$RawDeflateError> will contain an error message on failure.
+
+If you are running Perl 5.005 or better the object, C<$z>, returned from
+IO::Compress::RawDeflate can be used exactly like an L<IO::File|IO::File> filehandle.
+This means that all normal output file operations can be carried out
+with C<$z>.
+For example, to write to a compressed file/buffer you can use either of
+these forms
+
+    $z->print("hello world\n");
+    print $z "hello world\n";
+
+Below is a simple exaple of using the OO interface to create an output file
+C<myfile.1951> and write some data to it.
+
+    my $filename = "myfile.1951";
+    my $z = IO::Compress::RawDeflate->new($filename)
+        or die "IO::Compress::RawDeflate failed: $RawDeflateError\n";
+
+    $z->print("abcde");
+    $z->close();
+
+See the L</Examples> for more.
+
+The mandatory parameter C<$output> is used to control the destination
+of the compressed data. This parameter can take one of these forms.
+
+=over 5
+
+=item A filename
+
+If the C<$output> parameter is a simple scalar, it is assumed to be a
+filename. This file will be opened for writing and the compressed data
+will be written to it.
+
+=item A filehandle
+
+If the C<$output> parameter is a filehandle, the compressed data will be
+written to it.
+The string '-' can be used as an alias for standard output.
+
+=item A scalar reference
+
+If C<$output> is a scalar reference, the compressed data will be stored
+in C<$$output>.
+
+=back
+
+If the C<$output> parameter is any other type, C<IO::Compress::RawDeflate>::new will
+return undef.
+
+=head2 Constructor Options
+
+C<OPTS> is any combination of zero or more the following options:
+
+=over 5
+
+=item C<< AutoClose => 0|1 >>
+
+This option is only valid when the C<$output> parameter is a filehandle. If
+specified, and the value is true, it will result in the C<$output> being
+closed once either the C<close> method is called or the C<IO::Compress::RawDeflate>
+object is destroyed.
+
+This parameter defaults to 0.
+
+=item C<< Append => 0|1 >>
+
+Opens C<$output> in append mode.
+
+The behaviour of this option is dependent on the type of C<$output>.
+
+=over 5
+
+=item * A Buffer
+
+If C<$output> is a buffer and C<Append> is enabled, all compressed data
+will be append to the end of C<$output>. Otherwise C<$output> will be
+cleared before any data is written to it.
+
+=item * A Filename
+
+If C<$output> is a filename and C<Append> is enabled, the file will be
+opened in append mode. Otherwise the contents of the file, if any, will be
+truncated before any compressed data is written to it.
+
+=item * A Filehandle
+
+If C<$output> is a filehandle, the file pointer will be positioned to the
+end of the file via a call to C<seek> before any compressed data is written
+to it.  Otherwise the file pointer will not be moved.
+
+=back
+
+This parameter defaults to 0.
+
+=item C<< Merge => 0|1 >>
+
+This option is used to compress input data and append it to an existing
+compressed data stream in C<$output>. The end result is a single compressed
+data stream stored in C<$output>.
+
+It is a fatal error to attempt to use this option when C<$output> is not an
+RFC 1951 data stream.
+
+There are a number of other limitations with the C<Merge> option:
+
+=over 5
+
+=item 1
+
+This module needs to have been built with zlib 1.2.1 or better to work. A
+fatal error will be thrown if C<Merge> is used with an older version of
+zlib.
+
+=item 2
+
+If C<$output> is a file or a filehandle, it must be seekable.
+
+=back
+
+This parameter defaults to 0.
+
+=item -Level
+
+Defines the compression level used by zlib. The value should either be
+a number between 0 and 9 (0 means no compression and 9 is maximum
+compression), or one of the symbolic constants defined below.
+
+   Z_NO_COMPRESSION
+   Z_BEST_SPEED
+   Z_BEST_COMPRESSION
+   Z_DEFAULT_COMPRESSION
+
+The default is Z_DEFAULT_COMPRESSION.
+
+Note, these constants are not imported by C<IO::Compress::RawDeflate> by default.
+
+    use IO::Compress::RawDeflate qw(:strategy);
+    use IO::Compress::RawDeflate qw(:constants);
+    use IO::Compress::RawDeflate qw(:all);
+
+=item -Strategy
+
+Defines the strategy used to tune the compression. Use one of the symbolic
+constants defined below.
+
+   Z_FILTERED
+   Z_HUFFMAN_ONLY
+   Z_RLE
+   Z_FIXED
+   Z_DEFAULT_STRATEGY
+
+The default is Z_DEFAULT_STRATEGY.
+
+=item C<< Strict => 0|1 >>
+
+This is a placeholder option.
+
+=back
+
+=head2 Examples
+
+=head3 Streaming
+
+This very simple command line example demonstrates the streaming capabilities
+of the module. The code reads data from STDIN or all the files given on the
+commandline, compresses it, and writes the compressed data to STDOUT.
+
+    use strict ;
+    use warnings ;
+    use IO::Compress::RawDeflate qw(rawdeflate $RawDeflateError) ;
+
+    my $z = IO::Compress::RawDeflate->new("-", Stream => 1)
+        or die "IO::Compress::RawDeflate failed: $RawDeflateError\n";
+
+    while (<>) {
+        $z->print("abcde");
+    }
+    $z->close();
+
+Note the use of C<"-"> to means C<STDOUT>. Alternatively you can use C<\*STDOUT>.
+
+=head3 Compressing a file from the filesystem
+
+To read the contents of the file C<file1.txt> and write the compressed
+data to the file C<file1.txt.1951> there are a few options
+
+Start by creating the compression object and opening the input file
+
+    use strict ;
+    use warnings ;
+    use IO::Compress::RawDeflate qw(rawdeflate $RawDeflateError) ;
+
+    my $input = "file1.txt";
+    my $z = IO::Compress::RawDeflate->new("file1.txt.1951")
+        or die "IO::Compress::RawDeflate failed: $RawDeflateError\n";
+
+    # open the input file
+    open my $fh, "<", "file1.txt"
+        or die "Cannot open file1.txt: $!\n";
+
+    # loop through the input file & write to the compressed file
+    while (<$fh>) {
+        $z->print($_);
+    }
+
+    # not forgetting to close the compressed file
+    $z->close();
+
+=head1 Methods
+
+=head2 print
+
+Usage is
+
+    $z->print($data)
+    print $z $data
+
+Compresses and outputs the contents of the C<$data> parameter. This
+has the same behaviour as the C<print> built-in.
+
+Returns true if successful.
+
+=head2 printf
+
+Usage is
+
+    $z->printf($format, $data)
+    printf $z $format, $data
+
+Compresses and outputs the contents of the C<$data> parameter.
+
+Returns true if successful.
+
+=head2 syswrite
+
+Usage is
+
+    $z->syswrite $data
+    $z->syswrite $data, $length
+    $z->syswrite $data, $length, $offset
+
+Compresses and outputs the contents of the C<$data> parameter.
+
+Returns the number of uncompressed bytes written, or C<undef> if
+unsuccessful.
+
+=head2 write
+
+Usage is
+
+    $z->write $data
+    $z->write $data, $length
+    $z->write $data, $length, $offset
+
+Compresses and outputs the contents of the C<$data> parameter.
+
+Returns the number of uncompressed bytes written, or C<undef> if
+unsuccessful.
+
+=head2 flush
+
+Usage is
+
+    $z->flush;
+    $z->flush($flush_type);
+
+Flushes any pending compressed data to the output file/buffer.
+
+This method takes an optional parameter, C<$flush_type>, that controls
+how the flushing will be carried out. By default the C<$flush_type>
+used is C<Z_FINISH>. Other valid values for C<$flush_type> are
+C<Z_NO_FLUSH>, C<Z_SYNC_FLUSH>, C<Z_FULL_FLUSH> and C<Z_BLOCK>. It is
+strongly recommended that you only set the C<flush_type> parameter if
+you fully understand the implications of what it does - overuse of C<flush>
+can seriously degrade the level of compression achieved. See the C<zlib>
+documentation for details.
+
+Returns true on success.
+
+=head2 tell
+
+Usage is
+
+    $z->tell()
+    tell $z
+
+Returns the uncompressed file offset.
+
+=head2 eof
+
+Usage is
+
+    $z->eof();
+    eof($z);
+
+Returns true if the C<close> method has been called.
+
+=head2 seek
+
+    $z->seek($position, $whence);
+    seek($z, $position, $whence);
+
+Provides a sub-set of the C<seek> functionality, with the restriction
+that it is only legal to seek forward in the output file/buffer.
+It is a fatal error to attempt to seek backward.
+
+Empty parts of the file/buffer will have NULL (0x00) bytes written to them.
+
+The C<$whence> parameter takes one the usual values, namely SEEK_SET,
+SEEK_CUR or SEEK_END.
+
+Returns 1 on success, 0 on failure.
+
+=head2 binmode
+
+Usage is
+
+    $z->binmode
+    binmode $z ;
+
+This is a noop provided for completeness.
+
+=head2 opened
+
+    $z->opened()
+
+Returns true if the object currently refers to a opened file/buffer.
+
+=head2 autoflush
+
+    my $prev = $z->autoflush()
+    my $prev = $z->autoflush(EXPR)
+
+If the C<$z> object is associated with a file or a filehandle, this method
+returns the current autoflush setting for the underlying filehandle. If
+C<EXPR> is present, and is non-zero, it will enable flushing after every
+write/print operation.
+
+If C<$z> is associated with a buffer, this method has no effect and always
+returns C<undef>.
+
+B<Note> that the special variable C<$|> B<cannot> be used to set or
+retrieve the autoflush setting.
+
+=head2 input_line_number
+
+    $z->input_line_number()
+    $z->input_line_number(EXPR)
+
+This method always returns C<undef> when compressing.
+
+=head2 fileno
+
+    $z->fileno()
+    fileno($z)
+
+If the C<$z> object is associated with a file or a filehandle, C<fileno>
+will return the underlying file descriptor. Once the C<close> method is
+called C<fileno> will return C<undef>.
+
+If the C<$z> object is associated with a buffer, this method will return
+C<undef>.
+
+=head2 close
+
+    $z->close() ;
+    close $z ;
+
+Flushes any pending compressed data and then closes the output file/buffer.
+
+For most versions of Perl this method will be automatically invoked if
+the IO::Compress::RawDeflate object is destroyed (either explicitly or by the
+variable with the reference to the object going out of scope). The
+exceptions are Perl versions 5.005 through 5.00504 and 5.8.0. In
+these cases, the C<close> method will be called automatically, but
+not until global destruction of all live objects when the program is
+terminating.
+
+Therefore, if you want your scripts to be able to run on all versions
+of Perl, you should call C<close> explicitly and not rely on automatic
+closing.
+
+Returns true on success, otherwise 0.
+
+If the C<AutoClose> option has been enabled when the IO::Compress::RawDeflate
+object was created, and the object is associated with a file, the
+underlying file will also be closed.
+
+=head2 newStream([OPTS])
+
+Usage is
+
+    $z->newStream( [OPTS] )
+
+Closes the current compressed data stream and starts a new one.
+
+OPTS consists of any of the options that are available when creating
+the C<$z> object.
+
+See the L</"Constructor Options"> section for more details.
+
+=head2 deflateParams
+
+Usage is
+
+    $z->deflateParams
+
+TODO
+
+=head1 Importing
+
+A number of symbolic constants are required by some methods in
+C<IO::Compress::RawDeflate>. None are imported by default.
+
+=over 5
+
+=item :all
+
+Imports C<rawdeflate>, C<$RawDeflateError> and all symbolic
+constants that can be used by C<IO::Compress::RawDeflate>. Same as doing this
+
+    use IO::Compress::RawDeflate qw(rawdeflate $RawDeflateError :constants) ;
+
+=item :constants
+
+Import all symbolic constants. Same as doing this
+
+    use IO::Compress::RawDeflate qw(:flush :level :strategy) ;
+
+=item :flush
+
+These symbolic constants are used by the C<flush> method.
+
+    Z_NO_FLUSH
+    Z_PARTIAL_FLUSH
+    Z_SYNC_FLUSH
+    Z_FULL_FLUSH
+    Z_FINISH
+    Z_BLOCK
+
+=item :level
+
+These symbolic constants are used by the C<Level> option in the constructor.
+
+    Z_NO_COMPRESSION
+    Z_BEST_SPEED
+    Z_BEST_COMPRESSION
+    Z_DEFAULT_COMPRESSION
+
+=item :strategy
+
+These symbolic constants are used by the C<Strategy> option in the constructor.
+
+    Z_FILTERED
+    Z_HUFFMAN_ONLY
+    Z_RLE
+    Z_FIXED
+    Z_DEFAULT_STRATEGY
+
+=back
+
+=head1 EXAMPLES
+
+=head2 Apache::GZip Revisited
+
+See L<IO::Compress::FAQ|IO::Compress::FAQ/"Apache::GZip Revisited">
+
+=head2 Working with Net::FTP
+
+See L<IO::Compress::FAQ|IO::Compress::FAQ/"Compressed files and Net::FTP">
+
+=head1 SUPPORT
+
+General feedback/questions/bug reports should be sent to
+L<https://github.com/pmqs/IO-Compress/issues> (preferred) or
+L<https://rt.cpan.org/Public/Dist/Display.html?Name=IO-Compress>.
+
+=head1 SEE ALSO
+
+L<Compress::Zlib>, L<IO::Compress::Gzip>, L<IO::Uncompress::Gunzip>, L<IO::Compress::Deflate>, L<IO::Uncompress::Inflate>, L<IO::Uncompress::RawInflate>, L<IO::Compress::Bzip2>, L<IO::Uncompress::Bunzip2>, L<IO::Compress::Lzma>, L<IO::Uncompress::UnLzma>, L<IO::Compress::Xz>, L<IO::Uncompress::UnXz>, L<IO::Compress::Lzip>, L<IO::Uncompress::UnLzip>, L<IO::Compress::Lzop>, L<IO::Uncompress::UnLzop>, L<IO::Compress::Lzf>, L<IO::Uncompress::UnLzf>, L<IO::Compress::Zstd>, L<IO::Uncompress::UnZstd>, L<IO::Uncompress::AnyInflate>, L<IO::Uncompress::AnyUncompress>
+
+L<IO::Compress::FAQ|IO::Compress::FAQ>
+
+L<File::GlobMapper|File::GlobMapper>, L<Archive::Zip|Archive::Zip>,
+L<Archive::Tar|Archive::Tar>,
+L<IO::Zlib|IO::Zlib>
+
+For RFC 1950, 1951 and 1952 see
+L<https://datatracker.ietf.org/doc/html/rfc1950>,
+L<https://datatracker.ietf.org/doc/html/rfc1951> and
+L<https://datatracker.ietf.org/doc/html/rfc1952>
+
+The I<zlib> compression library was written by Jean-loup Gailly
+C<gzip@prep.ai.mit.edu> and Mark Adler C<madler@alumni.caltech.edu>.
+
+The primary site for the I<zlib> compression library is
+L<http://www.zlib.org>.
+
+The primary site for the I<zlib-ng> compression library is
+L<https://github.com/zlib-ng/zlib-ng>.
+
+The primary site for gzip is L<http://www.gzip.org>.
+
+=head1 AUTHOR
+
+This module was written by Paul Marquess, C<pmqs@cpan.org>.
+
+=head1 MODIFICATION HISTORY
+
+See the Changes file.
+
+=head1 COPYRIGHT AND LICENSE
+
+Copyright (c) 2005-2024 Paul Marquess. All rights reserved.
+
+This program is free software; you can redistribute it and/or
+modify it under the same terms as Perl itself.

git/usr/share/perl5/core_perl/JSON/PP/Boolean.pm

@@ -0,0 +1,43 @@
+package JSON::PP::Boolean;
+
+use strict;
+use warnings;
+use overload ();
+overload::unimport('overload', qw(0+ ++ -- fallback));
+overload::import('overload',
+    "0+"     => sub { ${$_[0]} },
+    "++"     => sub { $_[0] = ${$_[0]} + 1 },
+    "--"     => sub { $_[0] = ${$_[0]} - 1 },
+    fallback => 1,
+);
+
+our $VERSION = '4.16';
+
+1;
+
+__END__
+
+=head1 NAME
+
+JSON::PP::Boolean - dummy module providing JSON::PP::Boolean
+
+=head1 SYNOPSIS
+
+ # do not "use" yourself
+
+=head1 DESCRIPTION
+
+This module exists only to provide overload resolution for Storable and similar modules. See
+L<JSON::PP> for more info about this class.
+
+=head1 AUTHOR
+
+This idea is from L<JSON::XS::Boolean> written by Marc Lehmann <schmorp[at]schmorp.de>
+
+=head1 LICENSE
+
+This library is free software; you can redistribute it and/or modify
+it under the same terms as Perl itself.
+
+=cut
+

git/usr/share/perl5/core_perl/Math/BigFloat/Trace.pm

@@ -0,0 +1,76 @@
+# -*- mode: perl; -*-
+
+package Math::BigFloat::Trace;
+
+use strict;
+use warnings;
+
+use Exporter;
+use Math::BigFloat;
+
+our @ISA = qw(Exporter Math::BigFloat);
+
+our $VERSION = '0.67';
+
+use overload;                   # inherit overload from Math::BigFloat
+
+# Globals
+our $accuracy   = undef;
+our $precision  = undef;
+our $round_mode = 'even';
+our $div_scale  = 40;
+
+sub new {
+    my $proto = shift;
+    my $class = ref($proto) || $proto;
+
+    my $value = shift;
+
+    my $a = $accuracy;
+    $a = $_[0] if defined $_[0];
+
+    my $p = $precision;
+    $p = $_[1] if defined $_[1];
+
+    my $self = $class -> SUPER::new($value, $a, $p, $round_mode);
+
+    printf "Math::BigFloat new '%s' => '%s' (%s)\n",
+      $value, $self, ref($self);
+
+    return $self;
+}
+
+sub import {
+    my $class = shift;
+
+    printf "%s -> import(%s)\n", $class, join(", ", @_);
+
+    # we catch the constants, the rest goes to parent
+
+    my $constant = grep { $_ eq ':constant' } @_;
+    my @a = grep { $_ ne ':constant' } @_;
+
+    if ($constant) {
+        overload::constant
+
+            integer => sub {
+                $class -> new(shift);
+            },
+
+            float   => sub {
+                $class -> new(shift);
+            },
+
+            binary  => sub {
+                # E.g., a literal 0377 shall result in an object whose value
+                # is decimal 255, but new("0377") returns decimal 377.
+                return $class -> from_oct($_[0]) if $_[0] =~ /^0_*[0-7]/;
+                $class -> new(shift);
+            };
+    }
+
+    $class -> SUPER::import(@a);                # need it for subclasses
+    #$self -> export_to_level(1, $class, @_);    # need this ?
+}
+
+1;

git/usr/share/perl5/core_perl/Math/BigInt/Calc.pm

@@ -0,0 +1,2613 @@
+package Math::BigInt::Calc;
+
+use 5.006001;
+use strict;
+use warnings;
+
+use Carp qw< carp croak >;
+use Math::BigInt::Lib;
+
+our $VERSION = '2.005002';
+$VERSION =~ tr/_//d;
+
+our @ISA = ('Math::BigInt::Lib');
+
+# Package to store unsigned big integers in decimal and do math with them
+#
+# Internally the numbers are stored in an array with at least 1 element, no
+# leading zero parts (except the first) and in base 1eX where X is determined
+# automatically at loading time to be the maximum possible value
+#
+# todo:
+# - fully remove funky $# stuff in div() (maybe - that code scares me...)
+
+##############################################################################
+# global constants, flags and accessory
+
+# constants for easier life
+
+my $MAX_EXP_F;      # the maximum possible base 10 exponent with "no integer"
+my $MAX_EXP_I;      # the maximum possible base 10 exponent with "use integer"
+
+my $MAX_BITS;       # the maximum possible number of bits for $AND_BITS etc.
+
+my $BASE_LEN;       # the current base exponent in use
+my $USE_INT;        # whether "use integer" is used in the computations
+
+my $BASE;           # the current base, e.g., 10000 if $BASE_LEN is 5
+my $MAX_VAL;        # maximum value for an element, i.e., $BASE - 1
+
+my $AND_BITS;       # maximum value used in binary and, e.g., 0xffff
+my $OR_BITS;        # ditto for binary or
+my $XOR_BITS;       # ditto for binary xor
+
+my $AND_MASK;       # $AND_BITS + 1, e.g., 0x10000 if $AND_BITS is 0xffff
+my $OR_MASK;        # ditto for binary or
+my $XOR_MASK;       # ditto for binary xor
+
+sub config {
+    my $self = shift;
+
+    croak "Missing input argument" unless @_;
+
+    # Called as a getter.
+
+    if (@_ == 1) {
+        my $param = shift;
+        croak "Parameter name must be a non-empty string"
+          unless defined $param && length $param;
+        return $BASE_LEN if $param eq 'base_len';
+        return $USE_INT  if $param eq 'use_int';
+        croak "Unknown parameter '$param'";
+    }
+
+    # Called as a setter.
+
+    my $opts;
+    while (@_) {
+        my $param = shift;
+        croak "Parameter name must be a non-empty string"
+          unless defined $param && length $param;
+        croak "Missing value for parameter '$param'"
+          unless @_;
+        my $value = shift;
+
+        if ($param eq 'base_len' || $param eq 'use_int') {
+            $opts -> {$param} = $value;
+            next;
+        }
+
+        croak "Unknown parameter '$param'";
+    }
+
+    $BASE_LEN = $opts -> {base_len} if exists $opts -> {base_len};
+    $USE_INT  = $opts -> {use_int}  if exists $opts -> {use_int};
+    __PACKAGE__ -> _base_len($BASE_LEN, $USE_INT);
+
+    return $self;
+}
+
+sub _base_len {
+    #my $class = shift;                  # $class is not used
+    shift;
+
+    if (@_) {                           # if called as setter ...
+        my ($base_len, $use_int) = @_;
+
+        croak "The base length must be a positive integer"
+          unless defined($base_len) && $base_len == int($base_len)
+                 && $base_len > 0;
+
+        if ( $use_int && ($base_len > $MAX_EXP_I) ||
+            !$use_int && ($base_len > $MAX_EXP_F))
+        {
+            croak "The maximum base length (exponent) is $MAX_EXP_I with",
+              " 'use integer' and $MAX_EXP_F without 'use integer'. The",
+              " requested settings, a base length of $base_len ",
+              $use_int ? "with" : "without", " 'use integer', is invalid.";
+        }
+
+        $BASE_LEN = $base_len;
+        $BASE = 0 + ("1" . ("0" x $BASE_LEN));
+        $MAX_VAL = $BASE - 1;
+        $USE_INT = $use_int ? 1 : 0;
+
+        {
+            no warnings "redefine";
+            if ($use_int) {
+                *_mul = \&_mul_use_int;
+                *_div = \&_div_use_int;
+            } else {
+                *_mul = \&_mul_no_int;
+                *_div = \&_div_no_int;
+            }
+        }
+    }
+
+    # Find max bits. This is the largest power of two that is both no larger
+    # than $BASE and no larger than the maximum integer (i.e., ~0). We need
+    # this limitation because _and(), _or(), and _xor() only work on one
+    # element at a time.
+
+    my $umax = ~0;                      # largest unsigned integer
+    my $tmp  = $umax < $BASE ? $umax : $BASE;
+
+    $MAX_BITS = 0;
+    while ($tmp >>= 1) {
+        $MAX_BITS++;
+    }
+
+    # Limit to 32 bits for portability. Is this really necessary? XXX
+
+    $MAX_BITS = 32 if $MAX_BITS > 32;
+
+    # Find out how many bits _and, _or and _xor can take (old default = 16).
+    # Are these tests really necessary? Can't we just use $MAX_BITS? XXX
+
+    for ($AND_BITS = $MAX_BITS ; $AND_BITS > 0 ; $AND_BITS--) {
+        my $x = CORE::oct('0b' . '1' x $AND_BITS);
+        my $y = $x & $x;
+        my $z = 2 * (2 ** ($AND_BITS - 1)) + 1;
+        last unless $AND_BITS < $MAX_BITS && $x == $z && $y == $x;
+    }
+
+    for ($XOR_BITS = $MAX_BITS ; $XOR_BITS > 0 ; $XOR_BITS--) {
+        my $x = CORE::oct('0b' . '1' x $XOR_BITS);
+        my $y = $x ^ $x;
+        my $z = 2 * (2 ** ($XOR_BITS - 1)) + 1;
+        last unless $XOR_BITS < $MAX_BITS && $x == $z && $y == $x;
+    }
+
+    for ($OR_BITS = $MAX_BITS ; $OR_BITS > 0 ; $OR_BITS--) {
+        my $x = CORE::oct('0b' . '1' x $OR_BITS);
+        my $y = $x | $x;
+        my $z = 2 * (2 ** ($OR_BITS - 1)) + 1;
+        last unless $OR_BITS < $MAX_BITS && $x == $z && $y == $x;
+    }
+
+    $AND_MASK = __PACKAGE__->_new(( 2 ** $AND_BITS ));
+    $XOR_MASK = __PACKAGE__->_new(( 2 ** $XOR_BITS ));
+    $OR_MASK  = __PACKAGE__->_new(( 2 ** $OR_BITS  ));
+
+    return $BASE_LEN unless wantarray;
+    return ($BASE_LEN, $BASE, $AND_BITS, $XOR_BITS, $OR_BITS, $BASE_LEN, $MAX_VAL,
+            $MAX_BITS, $MAX_EXP_F, $MAX_EXP_I, $USE_INT);
+}
+
+sub _new {
+    # Given a string representing an integer, returns a reference to an array
+    # of integers, where each integer represents a chunk of the original input
+    # integer.
+
+    my ($class, $str) = @_;
+    #unless ($str =~ /^([1-9]\d*|0)\z/) {
+    #    croak("Invalid input string '$str'");
+    #}
+
+    my $input_len = length($str) - 1;
+
+    # Shortcut for small numbers.
+    return bless [ $str ], $class if $input_len < $BASE_LEN;
+
+    my $format = "a" . (($input_len % $BASE_LEN) + 1);
+    $format .= $] < 5.008 ? "a$BASE_LEN" x int($input_len / $BASE_LEN)
+                          : "(a$BASE_LEN)*";
+
+    my $self = [ reverse(map { 0 + $_ } unpack($format, $str)) ];
+    return bless $self, $class;
+}
+
+BEGIN {
+
+    # Compute $MAX_EXP_F, the maximum usable base 10 exponent.
+
+    # The largest element in base 10**$BASE_LEN is 10**$BASE_LEN-1. For instance,
+    # with $BASE_LEN = 5, the largest element is 99_999, and the largest carry is
+    #
+    #     int( 99_999 * 99_999 / 100_000 ) = 99_998
+    #
+    # so make sure that 99_999 * 99_999 + 99_998 is within the range of integers
+    # that can be represented accuratly.
+    #
+    # Note that on some systems with quadmath support, the following is within
+    # the range of numbers that can be represented exactly, but it still gives
+    # the incorrect value $r = 2 (even though POSIX::fmod($x, $y) gives the
+    # correct value of 1:
+    #
+    #     $x =  99999999999999999;
+    #     $y = 100000000000000000;
+    #     $r = $x * $x % $y;            # should be 1
+    #
+    # so also check for this.
+
+    for ($MAX_EXP_F = 1 ; ; $MAX_EXP_F++) {         # when $MAX_EXP_F = 5
+        my $MAX_EXP_FM1 = $MAX_EXP_F - 1;           #   = 4
+        my $bs = "1" . ("0" x $MAX_EXP_F);          #   = "100000"
+        my $xs = "9" x $MAX_EXP_F;                  #   =  "99999"
+        my $cs = ("9" x $MAX_EXP_FM1) . "8";        #   =  "99998"
+        my $ys = $cs . ("0" x $MAX_EXP_FM1) . "1";  #   = "9999800001"
+
+        # Compute and check the product.
+        my $yn = $xs * $xs;                         #   = 9999800001
+        last if $yn != $ys;
+
+        # Compute and check the remainder.
+        my $rn = $yn % $bs;                         #   = 1
+        last if $rn != 1;
+
+        # Compute and check the carry. The division here is exact.
+        my $cn = ($yn - $rn) / $bs;                 #   = 99998
+        last if $cn != $cs;
+
+        # Compute and check product plus carry.
+        my $zs = $cs . ("9" x $MAX_EXP_F);          #   = "9999899999"
+        my $zn = $yn + $cn;                         #   = 99998999999
+        last if $zn != $zs;
+        last if $zn - ($zn - 1) != 1;
+    }
+    $MAX_EXP_F--;                       # last test failed, so retract one step
+
+    # Compute $MAX_EXP_I, the maximum usable base 10 exponent within the range
+    # of what is available with "use integer". On older versions of Perl,
+    # integers are converted to floating point numbers, even though they are
+    # within the range of what can be represented as integers. For example, on
+    # some 64 bit Perls, 999999999 * 999999999 becomes 999999998000000000, not
+    # 999999998000000001, even though the latter is less than the maximum value
+    # for a 64 bit integer, 18446744073709551615.
+
+    my $umax = ~0;                      # largest unsigned integer
+    for ($MAX_EXP_I = int(0.5 * log($umax) / log(10));
+         $MAX_EXP_I > 0;
+         $MAX_EXP_I--)
+    {                                               # when $MAX_EXP_I = 5
+        my $MAX_EXP_IM1 = $MAX_EXP_I - 1;           #   = 4
+        my $bs = "1" . ("0" x $MAX_EXP_I);          #   = "100000"
+        my $xs = "9" x $MAX_EXP_I;                  #   =  "99999"
+        my $cs = ("9" x $MAX_EXP_IM1) . "8";        #   =  "99998"
+        my $ys = $cs . ("0" x $MAX_EXP_IM1) . "1";  #   = "9999800001"
+
+        # Compute and check the product.
+        my $yn = $xs * $xs;                         #   = 9999800001
+        next if $yn != $ys;
+
+        # Compute and check the remainder.
+        my $rn = $yn % $bs;                         #   = 1
+        next if $rn != 1;
+
+        # Compute and check the carry. The division here is exact.
+        my $cn = ($yn - $rn) / $bs;                 #   = 99998
+        next if $cn != $cs;
+
+        # Compute and check product plus carry.
+        my $zs = $cs . ("9" x $MAX_EXP_I);          #   = "9999899999"
+        my $zn = $yn + $cn;                         #   = 99998999999
+        next if $zn != $zs;
+        next if $zn - ($zn - 1) != 1;
+        last;
+    }
+
+    ($BASE_LEN, $USE_INT) = $MAX_EXP_F > $MAX_EXP_I
+                          ? ($MAX_EXP_F, 0) : ($MAX_EXP_I, 1);
+
+    __PACKAGE__ -> _base_len($BASE_LEN, $USE_INT);
+}
+
+###############################################################################
+
+sub _zero {
+    # create a zero
+    my $class = shift;
+    return bless [ 0 ], $class;
+}
+
+sub _one {
+    # create a one
+    my $class = shift;
+    return bless [ 1 ], $class;
+}
+
+sub _two {
+    # create a two
+    my $class = shift;
+    return bless [ 2 ], $class;
+}
+
+sub _ten {
+    # create a 10
+    my $class = shift;
+    my $self = $BASE_LEN == 1 ? [ 0, 1 ] : [ 10 ];
+    bless $self, $class;
+}
+
+sub _1ex {
+    # create a 1Ex
+    my $class = shift;
+
+    my $rem = $_[0] % $BASE_LEN;                # remainder
+    my $div = ($_[0] - $rem) / $BASE_LEN;       # parts
+
+    # With a $BASE_LEN of 6, 1e14 becomes
+    # [ 000000, 000000, 100 ] -> [ 0, 0, 100 ]
+    bless [ (0) x $div,  0 + ("1" . ("0" x $rem)) ], $class;
+}
+
+sub _copy {
+    # make a true copy
+    my $class = shift;
+    return bless [ @{ $_[0] } ], $class;
+}
+
+sub import {
+    my $self = shift;
+
+    my $opts;
+    my ($base_len, $use_int);
+    while (@_) {
+        my $param = shift;
+        croak "Parameter name must be a non-empty string"
+          unless defined $param && length $param;
+        croak "Missing value for parameter '$param'"
+          unless @_;
+        my $value = shift;
+
+        if ($param eq 'base_len' || $param eq 'use_int') {
+            $opts -> {$param} = $value;
+            next;
+        }
+
+        croak "Unknown parameter '$param'";
+    }
+
+    $base_len = exists $opts -> {base_len} ? $opts -> {base_len} : $BASE_LEN;
+    $use_int  = exists $opts -> {use_int}  ? $opts -> {use_int}  : $USE_INT;
+    __PACKAGE__ -> _base_len($base_len, $use_int);
+
+    return $self;
+}
+
+##############################################################################
+# convert back to string and number
+
+sub _str {
+    # Convert number from internal base 1eN format to string format. Internal
+    # format is always normalized, i.e., no leading zeros.
+
+    my $ary = $_[1];
+    my $idx = $#$ary;           # index of last element
+
+    if ($idx < 0) {             # should not happen
+        croak("$_[1] has no elements");
+    }
+
+    # Handle first one differently, since it should not have any leading zeros.
+    my $ret = int($ary->[$idx]);
+    if ($idx > 0) {
+        # Interestingly, the pre-padd method uses more time.
+        # The old grep variant takes longer (14 vs. 10 sec).
+        my $z = '0' x ($BASE_LEN - 1);
+        while (--$idx >= 0) {
+            $ret .= substr($z . $ary->[$idx], -$BASE_LEN);
+        }
+    }
+    $ret;
+}
+
+sub _num {
+    # Make a Perl scalar number (int/float) from a BigInt object.
+    my $x = $_[1];
+
+    return $x->[0] if @$x == 1;         # below $BASE
+
+    # Start with the most significant element and work towards the least
+    # significant element. Avoid multiplying "inf" (which happens if the number
+    # overflows) with "0" (if there are zero elements in $x) since this gives
+    # "nan" which propagates to the output.
+
+    my $num = 0;
+    for (my $i = $#$x ; $i >= 0 ; --$i) {
+        $num *= $BASE;
+        $num += $x -> [$i];
+    }
+    return $num;
+}
+
+##############################################################################
+# actual math code
+
+sub _add {
+    # (ref to int_num_array, ref to int_num_array)
+    #
+    # Routine to add two base 1eX numbers stolen from Knuth Vol 2 Algorithm A
+    # pg 231. There are separate routines to add and sub as per Knuth pg 233.
+    # This routine modifies array x, but not y.
+
+    my ($c, $x, $y) = @_;
+
+    # $x + 0 => $x
+
+    return $x if @$y == 1 && $y->[0] == 0;
+
+    # 0 + $y => $y->copy
+
+    if (@$x == 1 && $x->[0] == 0) {
+        @$x = @$y;
+        return $x;
+    }
+
+    # For each in Y, add Y to X and carry. If after that, something is left in
+    # X, foreach in X add carry to X and then return X, carry. Trades one
+    # "$j++" for having to shift arrays.
+
+    my $car = 0;
+    my $j = 0;
+    for my $i (@$y) {
+        $x->[$j] -= $BASE if $car = (($x->[$j] += $i + $car) >= $BASE) ? 1 : 0;
+        $j++;
+    }
+    while ($car != 0) {
+        $x->[$j] -= $BASE if $car = (($x->[$j] += $car) >= $BASE) ? 1 : 0;
+        $j++;
+    }
+    $x;
+}
+
+sub _inc {
+    # (ref to int_num_array, ref to int_num_array)
+    # Add 1 to $x, modify $x in place
+    my ($c, $x) = @_;
+
+    for my $i (@$x) {
+        return $x if ($i += 1) < $BASE; # early out
+        $i = 0;                         # overflow, next
+    }
+    push @$x, 1 if $x->[-1] == 0;       # last overflowed, so extend
+    $x;
+}
+
+sub _dec {
+    # (ref to int_num_array, ref to int_num_array)
+    # Sub 1 from $x, modify $x in place
+    my ($c, $x) = @_;
+
+    my $MAX = $BASE - 1;                # since MAX_VAL based on BASE
+    for my $i (@$x) {
+        last if ($i -= 1) >= 0;         # early out
+        $i = $MAX;                      # underflow, next
+    }
+    pop @$x if $x->[-1] == 0 && @$x > 1; # last underflowed (but leave 0)
+    $x;
+}
+
+sub _sub {
+    # (ref to int_num_array, ref to int_num_array, swap)
+    #
+    # Subtract base 1eX numbers -- stolen from Knuth Vol 2 pg 232, $x > $y
+    # subtract Y from X by modifying x in place
+    my ($c, $sx, $sy, $s) = @_;
+
+    my $car = 0;
+    my $j = 0;
+    if (!$s) {
+        for my $i (@$sx) {
+            last unless defined $sy->[$j] || $car;
+            $i += $BASE if $car = (($i -= ($sy->[$j] || 0) + $car) < 0);
+            $j++;
+        }
+        # might leave leading zeros, so fix that
+        return __strip_zeros($sx);
+    }
+    for my $i (@$sx) {
+        # We can't do an early out if $x < $y, since we need to copy the high
+        # chunks from $y. Found by Bob Mathews.
+        #last unless defined $sy->[$j] || $car;
+        $sy->[$j] += $BASE
+          if $car = ($sy->[$j] = $i - ($sy->[$j] || 0) - $car) < 0;
+        $j++;
+    }
+    # might leave leading zeros, so fix that
+    __strip_zeros($sy);
+}
+
+sub _mul_use_int {
+    # (ref to int_num_array, ref to int_num_array)
+    # multiply two numbers in internal representation
+    # modifies first arg, second need not be different from first
+    # works for 64 bit integer with "use integer"
+    my ($c, $xv, $yv) = @_;
+    use integer;
+
+    if (@$yv == 1) {
+        # shortcut for two very short numbers (improved by Nathan Zook) works
+        # also if xv and yv are the same reference, and handles also $x == 0
+        if (@$xv == 1) {
+            if (($xv->[0] *= $yv->[0]) >= $BASE) {
+                $xv->[0] =
+                  $xv->[0] - ($xv->[1] = $xv->[0] / $BASE) * $BASE;
+            }
+            return $xv;
+        }
+        # $x * 0 => 0
+        if ($yv->[0] == 0) {
+            @$xv = (0);
+            return $xv;
+        }
+
+        # multiply a large number a by a single element one, so speed up
+        my $y = $yv->[0];
+        my $car = 0;
+        foreach my $i (@$xv) {
+            #$i = $i * $y + $car; $car = $i / $BASE; $i -= $car * $BASE;
+            $i = $i * $y + $car;
+            $i -= ($car = $i / $BASE) * $BASE;
+        }
+        push @$xv, $car if $car != 0;
+        return $xv;
+    }
+
+    # shortcut for result $x == 0 => result = 0
+    return $xv if @$xv == 1 && $xv->[0] == 0;
+
+    # since multiplying $x with $x fails, make copy in this case
+    $yv = $c->_copy($xv) if $xv == $yv;         # same references?
+
+    my @prod = ();
+    my ($prod, $car, $cty);
+    for my $xi (@$xv) {
+        $car = 0;
+        $cty = 0;
+        # looping through this if $xi == 0 is silly - so optimize it away!
+        $xi = (shift(@prod) || 0), next if $xi == 0;
+        for my $yi (@$yv) {
+            $prod = $xi * $yi + ($prod[$cty] || 0) + $car;
+            $prod[$cty++] = $prod - ($car = $prod / $BASE) * $BASE;
+        }
+        $prod[$cty] += $car if $car;    # need really to check for 0?
+        $xi = shift(@prod) || 0;        # || 0 makes v5.005_3 happy
+    }
+    push @$xv, @prod;
+    $xv;
+}
+
+sub _mul_no_int {
+    # (ref to int_num_array, ref to int_num_array)
+    # multiply two numbers in internal representation
+    # modifies first arg, second need not be different from first
+    my ($c, $xv, $yv) = @_;
+
+    if (@$yv == 1) {
+        # shortcut for two very short numbers (improved by Nathan Zook) works
+        # also if xv and yv are the same reference, and handles also $x == 0
+        if (@$xv == 1) {
+            if (($xv->[0] *= $yv->[0]) >= $BASE) {
+                my $rem = $xv->[0] % $BASE;
+                $xv->[1] = ($xv->[0] - $rem) / $BASE;
+                $xv->[0] = $rem;
+            }
+            return $xv;
+        }
+        # $x * 0 => 0
+        if ($yv->[0] == 0) {
+            @$xv = (0);
+            return $xv;
+        }
+
+        # multiply a large number a by a single element one, so speed up
+        my $y = $yv->[0];
+        my $car = 0;
+        my $rem;
+        foreach my $i (@$xv) {
+            $i = $i * $y + $car;
+            $rem = $i % $BASE;
+            $car = ($i - $rem) / $BASE;
+            $i = $rem;
+        }
+        push @$xv, $car if $car != 0;
+        return $xv;
+    }
+
+    # shortcut for result $x == 0 => result = 0
+    return $xv if @$xv == 1 && $xv->[0] == 0;
+
+    # since multiplying $x with $x fails, make copy in this case
+    $yv = $c->_copy($xv) if $xv == $yv;         # same references?
+
+    my @prod = ();
+    my ($prod, $rem, $car, $cty);
+    for my $xi (@$xv) {
+        $car = 0;
+        $cty = 0;
+        # looping through this if $xi == 0 is silly - so optimize it away!
+        $xi = (shift(@prod) || 0), next if $xi == 0;
+        for my $yi (@$yv) {
+            $prod = $xi * $yi + ($prod[$cty] || 0) + $car;
+            $rem = $prod % $BASE;
+            $car = ($prod - $rem) / $BASE;
+            $prod[$cty++] = $rem;
+        }
+        $prod[$cty] += $car if $car;    # need really to check for 0?
+        $xi = shift(@prod) || 0;        # || 0 makes v5.005_3 happy
+    }
+    push @$xv, @prod;
+    $xv;
+}
+
+sub _div_use_int {
+    # ref to array, ref to array, modify first array and return remainder if
+    # in list context
+
+    # This version works on integers
+    use integer;
+
+    my ($c, $x, $yorg) = @_;
+
+    # the general div algorithm here is about O(N*N) and thus quite slow, so
+    # we first check for some special cases and use shortcuts to handle them.
+
+    # if both numbers have only one element:
+    if (@$x == 1 && @$yorg == 1) {
+        # shortcut, $yorg and $x are two small numbers
+        if (wantarray) {
+            my $rem = [ $x->[0] % $yorg->[0] ];
+            bless $rem, $c;
+            $x->[0] = $x->[0] / $yorg->[0];
+            return ($x, $rem);
+        } else {
+            $x->[0] = $x->[0] / $yorg->[0];
+            return $x;
+        }
+    }
+
+    # if x has more than one, but y has only one element:
+    if (@$yorg == 1) {
+        my $rem;
+        $rem = $c->_mod($c->_copy($x), $yorg) if wantarray;
+
+        # shortcut, $y is < $BASE
+        my $j = @$x;
+        my $r = 0;
+        my $y = $yorg->[0];
+        my $b;
+        while ($j-- > 0) {
+            $b = $r * $BASE + $x->[$j];
+            $r = $b % $y;
+            $x->[$j] = $b / $y;
+        }
+        pop(@$x) if @$x > 1 && $x->[-1] == 0;   # remove any trailing zero
+        return ($x, $rem) if wantarray;
+        return $x;
+    }
+
+    # now x and y have more than one element
+
+    # check whether y has more elements than x, if so, the result is 0
+    if (@$yorg > @$x) {
+        my $rem;
+        $rem = $c->_copy($x) if wantarray;      # make copy
+        @$x = 0;                                # set to 0
+        return ($x, $rem) if wantarray;         # including remainder?
+        return $x;                              # only x, which is [0] now
+    }
+
+    # check whether the numbers have the same number of elements, in that case
+    # the result will fit into one element and can be computed efficiently
+    if (@$yorg == @$x) {
+        my $cmp = 0;
+        for (my $j = $#$x ; $j >= 0 ; --$j) {
+            last if $cmp = $x->[$j] - $yorg->[$j];
+        }
+
+        if ($cmp == 0) {        # x = y
+            @$x = 1;
+            return $x, $c->_zero() if wantarray;
+            return $x;
+        }
+
+        if ($cmp < 0) {         # x < y
+            if (wantarray) {
+                my $rem = $c->_copy($x);
+                @$x = 0;
+                return $x, $rem;
+            }
+            @$x = 0;
+            return $x;
+        }
+    }
+
+    # all other cases:
+
+    my $y = $c->_copy($yorg);           # always make copy to preserve
+
+    my $tmp;
+    my $dd = $BASE / ($y->[-1] + 1);
+    if ($dd != 1) {
+        my $car = 0;
+        for my $xi (@$x) {
+            $xi = $xi * $dd + $car;
+            $xi -= ($car = $xi / $BASE) * $BASE;
+        }
+        push(@$x, $car);
+        $car = 0;
+        for my $yi (@$y) {
+            $yi = $yi * $dd + $car;
+            $yi -= ($car = $yi / $BASE) * $BASE;
+        }
+    } else {
+        push(@$x, 0);
+    }
+
+    # @q will accumulate the final result, $q contains the current computed
+    # part of the final result
+
+    my @q = ();
+    my ($v2, $v1) = @$y[-2, -1];
+    $v2 = 0 unless $v2;
+    while ($#$x > $#$y) {
+        my ($u2, $u1, $u0) = @$x[-3 .. -1];
+        $u2 = 0 unless $u2;
+        #warn "oups v1 is 0, u0: $u0 $y->[-2] $y->[-1] l ",scalar @$y,"\n"
+        # if $v1 == 0;
+        my $tmp = $u0 * $BASE + $u1;
+        my $rem = $tmp % $v1;
+        my $q = $u0 == $v1 ? $MAX_VAL : (($tmp - $rem) / $v1);
+        --$q while $v2 * $q > ($u0 * $BASE + $u1 - $q * $v1) * $BASE + $u2;
+        if ($q) {
+            my $prd;
+            my ($car, $bar) = (0, 0);
+            for (my $yi = 0, my $xi = $#$x - $#$y - 1; $yi <= $#$y; ++$yi, ++$xi) {
+                $prd = $q * $y->[$yi] + $car;
+                $prd -= ($car = int($prd / $BASE)) * $BASE;
+                $x->[$xi] += $BASE if $bar = (($x->[$xi] -= $prd + $bar) < 0);
+            }
+            if ($x->[-1] < $car + $bar) {
+                $car = 0;
+                --$q;
+                for (my $yi = 0, my $xi = $#$x - $#$y - 1; $yi <= $#$y; ++$yi, ++$xi) {
+                    $x->[$xi] -= $BASE
+                      if $car = (($x->[$xi] += $y->[$yi] + $car) >= $BASE);
+                }
+            }
+        }
+        pop(@$x);
+        unshift(@q, $q);
+    }
+
+    if (wantarray) {
+        my $d = bless [], $c;
+        if ($dd != 1) {
+            my $car = 0;
+            my $prd;
+            for my $xi (reverse @$x) {
+                $prd = $car * $BASE + $xi;
+                $car = $prd - ($tmp = $prd / $dd) * $dd;
+                unshift @$d, $tmp;
+            }
+        } else {
+            @$d = @$x;
+        }
+        @$x = @q;
+        __strip_zeros($x);
+        __strip_zeros($d);
+        return ($x, $d);
+    }
+    @$x = @q;
+    __strip_zeros($x);
+    $x;
+}
+
+sub _div_no_int {
+    # ref to array, ref to array, modify first array and return remainder if
+    # in list context
+
+    my ($c, $x, $yorg) = @_;
+
+    # the general div algorithm here is about O(N*N) and thus quite slow, so
+    # we first check for some special cases and use shortcuts to handle them.
+
+    # if both numbers have only one element:
+    if (@$x == 1 && @$yorg == 1) {
+        # shortcut, $yorg and $x are two small numbers
+        my $rem = [ $x->[0] % $yorg->[0] ];
+        bless $rem, $c;
+        $x->[0] = ($x->[0] - $rem->[0]) / $yorg->[0];
+        return ($x, $rem) if wantarray;
+        return $x;
+    }
+
+    # if x has more than one, but y has only one element:
+    if (@$yorg == 1) {
+        my $rem;
+        $rem = $c->_mod($c->_copy($x), $yorg) if wantarray;
+
+        # shortcut, $y is < $BASE
+        my $j = @$x;
+        my $r = 0;
+        my $y = $yorg->[0];
+        my $b;
+        while ($j-- > 0) {
+            $b = $r * $BASE + $x->[$j];
+            $r = $b % $y;
+            $x->[$j] = ($b - $r) / $y;
+        }
+        pop(@$x) if @$x > 1 && $x->[-1] == 0;   # remove any trailing zero
+        return ($x, $rem) if wantarray;
+        return $x;
+    }
+
+    # now x and y have more than one element
+
+    # check whether y has more elements than x, if so, the result is 0
+    if (@$yorg > @$x) {
+        my $rem;
+        $rem = $c->_copy($x) if wantarray;      # make copy
+        @$x = 0;                                # set to 0
+        return ($x, $rem) if wantarray;         # including remainder?
+        return $x;                              # only x, which is [0] now
+    }
+
+    # check whether the numbers have the same number of elements, in that case
+    # the result will fit into one element and can be computed efficiently
+    if (@$yorg == @$x) {
+        my $cmp = 0;
+        for (my $j = $#$x ; $j >= 0 ; --$j) {
+            last if $cmp = $x->[$j] - $yorg->[$j];
+        }
+
+        if ($cmp == 0) {        # x = y
+            @$x = 1;
+            return $x, $c->_zero() if wantarray;
+            return $x;
+        }
+
+        if ($cmp < 0) {         # x < y
+            if (wantarray) {
+                my $rem = $c->_copy($x);
+                @$x = 0;
+                return $x, $rem;
+            }
+            @$x = 0;
+            return $x;
+        }
+    }
+
+    # all other cases:
+
+    my $y = $c->_copy($yorg);           # always make copy to preserve
+
+    my $tmp = $y->[-1] + 1;
+    my $rem = $BASE % $tmp;
+    my $dd  = ($BASE - $rem) / $tmp;
+    if ($dd != 1) {
+        my $car = 0;
+        for my $xi (@$x) {
+            $xi = $xi * $dd + $car;
+            $rem = $xi % $BASE;
+            $car = ($xi - $rem) / $BASE;
+            $xi = $rem;
+        }
+        push(@$x, $car);
+        $car = 0;
+        for my $yi (@$y) {
+            $yi = $yi * $dd + $car;
+            $rem = $yi % $BASE;
+            $car = ($yi - $rem) / $BASE;
+            $yi = $rem;
+        }
+    } else {
+        push(@$x, 0);
+    }
+
+    # @q will accumulate the final result, $q contains the current computed
+    # part of the final result
+
+    my @q = ();
+    my ($v2, $v1) = @$y[-2, -1];
+    $v2 = 0 unless $v2;
+    while ($#$x > $#$y) {
+        my ($u2, $u1, $u0) = @$x[-3 .. -1];
+        $u2 = 0 unless $u2;
+        #warn "oups v1 is 0, u0: $u0 $y->[-2] $y->[-1] l ",scalar @$y,"\n"
+        # if $v1 == 0;
+        my $tmp = $u0 * $BASE + $u1;
+        my $rem = $tmp % $v1;
+        my $q = $u0 == $v1 ? $MAX_VAL : (($tmp - $rem) / $v1);
+        --$q while $v2 * $q > ($u0 * $BASE + $u1 - $q * $v1) * $BASE + $u2;
+        if ($q) {
+            my $prd;
+            my ($car, $bar) = (0, 0);
+            for (my $yi = 0, my $xi = $#$x - $#$y - 1; $yi <= $#$y; ++$yi, ++$xi) {
+                $prd = $q * $y->[$yi] + $car;
+                $rem = $prd % $BASE;
+                $car = ($prd - $rem) / $BASE;
+                $prd -= $car * $BASE;
+                $x->[$xi] += $BASE if $bar = (($x->[$xi] -= $prd + $bar) < 0);
+            }
+            if ($x->[-1] < $car + $bar) {
+                $car = 0;
+                --$q;
+                for (my $yi = 0, my $xi = $#$x - $#$y - 1; $yi <= $#$y; ++$yi, ++$xi) {
+                    $x->[$xi] -= $BASE
+                      if $car = (($x->[$xi] += $y->[$yi] + $car) >= $BASE);
+                }
+            }
+        }
+        pop(@$x);
+        unshift(@q, $q);
+    }
+
+    if (wantarray) {
+        my $d = bless [], $c;
+        if ($dd != 1) {
+            my $car = 0;
+            my ($prd, $rem);
+            for my $xi (reverse @$x) {
+                $prd = $car * $BASE + $xi;
+                $rem = $prd % $dd;
+                $tmp = ($prd - $rem) / $dd;
+                $car = $rem;
+                unshift @$d, $tmp;
+            }
+        } else {
+            @$d = @$x;
+        }
+        @$x = @q;
+        __strip_zeros($x);
+        __strip_zeros($d);
+        return ($x, $d);
+    }
+    @$x = @q;
+    __strip_zeros($x);
+    $x;
+}
+
+##############################################################################
+# testing
+
+sub _acmp {
+    # Internal absolute post-normalized compare (ignore signs)
+    # ref to array, ref to array, return <0, 0, >0
+    # Arrays must have at least one entry; this is not checked for.
+    my ($c, $cx, $cy) = @_;
+
+    # shortcut for short numbers
+    return (($cx->[0] <=> $cy->[0]) <=> 0)
+      if @$cx == 1 && @$cy == 1;
+
+    # fast comp based on number of array elements (aka pseudo-length)
+    my $lxy = (@$cx - @$cy)
+      # or length of first element if same number of elements (aka difference 0)
+      ||
+        # need int() here because sometimes the last element is '00018' vs '18'
+        (length(int($cx->[-1])) - length(int($cy->[-1])));
+
+    return -1 if $lxy < 0;      # already differs, ret
+    return  1 if $lxy > 0;      # ditto
+
+    # manual way (abort if unequal, good for early ne)
+    my $a;
+    my $j = @$cx;
+    while (--$j >= 0) {
+        last if $a = $cx->[$j] - $cy->[$j];
+    }
+    $a <=> 0;
+}
+
+sub _len {
+    # compute number of digits in base 10
+
+    # int() because add/sub sometimes leaves strings (like '00005') instead of
+    # '5' in this place, thus causing length() to report wrong length
+    my $cx = $_[1];
+
+    (@$cx - 1) * $BASE_LEN + length(int($cx->[-1]));
+}
+
+sub _digit {
+    # Return the nth digit. Zero is rightmost, so _digit(123, 0) gives 3.
+    # Negative values count from the left, so _digit(123, -1) gives 1.
+    my ($c, $x, $n) = @_;
+
+    my $len = _len('', $x);
+
+    $n += $len if $n < 0;               # -1 last, -2 second-to-last
+
+    # Math::BigInt::Calc returns 0 if N is out of range, but this is not done
+    # by the other backend libraries.
+
+    return "0" if $n < 0 || $n >= $len; # return 0 for digits out of range
+
+    my $elem = int($n / $BASE_LEN);     # index of array element
+    my $digit = $n % $BASE_LEN;         # index of digit within the element
+    substr("0" x $BASE_LEN . "$x->[$elem]", -1 - $digit, 1);
+}
+
+sub _zeros {
+    # Return number of trailing zeros in decimal.
+    # Check each array element for having 0 at end as long as elem == 0
+    # Upon finding a elem != 0, stop.
+
+    my $x = $_[1];
+
+    return 0 if @$x == 1 && $x->[0] == 0;
+
+    my $zeros = 0;
+    foreach my $elem (@$x) {
+        if ($elem != 0) {
+            $elem =~ /[^0](0*)\z/;
+            $zeros += length($1);       # count trailing zeros
+            last;                       # early out
+        }
+        $zeros += $BASE_LEN;
+    }
+    $zeros;
+}
+
+##############################################################################
+# _is_* routines
+
+sub _is_zero {
+    # return true if arg is zero
+    @{$_[1]} == 1 && $_[1]->[0] == 0 ? 1 : 0;
+}
+
+sub _is_even {
+    # return true if arg is even
+    $_[1]->[0] % 2 ? 0 : 1;
+}
+
+sub _is_odd {
+    # return true if arg is odd
+    $_[1]->[0] % 2 ? 1 : 0;
+}
+
+sub _is_one {
+    # return true if arg is one
+    @{$_[1]} == 1 && $_[1]->[0] == 1 ? 1 : 0;
+}
+
+sub _is_two {
+    # return true if arg is two
+    @{$_[1]} == 1 && $_[1]->[0] == 2 ? 1 : 0;
+}
+
+sub _is_ten {
+    # return true if arg is ten
+    if ($BASE_LEN == 1) {
+        @{$_[1]} == 2 && $_[1]->[0] == 0 && $_[1]->[1] == 1 ? 1 : 0;
+    } else {
+        @{$_[1]} == 1 && $_[1]->[0] == 10 ? 1 : 0;
+    }
+}
+
+sub __strip_zeros {
+    # Internal normalization function that strips leading zeros from the array.
+    # Args: ref to array
+    my $x = shift;
+
+    push @$x, 0 if @$x == 0;    # div might return empty results, so fix it
+    return $x if @$x == 1;      # early out
+
+    #print "strip: cnt $cnt i $i\n";
+    # '0', '3', '4', '0', '0',
+    #  0    1    2    3    4
+    # cnt = 5, i = 4
+    # i = 4
+    # i = 3
+    # => fcnt = cnt - i (5-2 => 3, cnt => 5-1 = 4, throw away from 4th pos)
+    # >= 1: skip first part (this can be zero)
+
+    my $i = $#$x;
+    while ($i > 0) {
+        last if $x->[$i] != 0;
+        $i--;
+    }
+    $i++;
+    splice(@$x, $i) if $i < @$x;
+    $x;
+}
+
+###############################################################################
+# check routine to test internal state for corruptions
+
+sub _check {
+    # used by the test suite
+    my ($class, $x) = @_;
+
+    my $msg = $class -> SUPER::_check($x);
+    return $msg if $msg;
+
+    my $n;
+    eval { $n = @$x };
+    return "Not an array reference" unless $@ eq '';
+
+    return "Reference to an empty array" unless $n > 0;
+
+    # The following fails with Math::BigInt::FastCalc because a
+    # Math::BigInt::FastCalc "object" is an unblessed array ref.
+    #
+    #return 0 unless ref($x) eq $class;
+
+    for (my $i = 0 ; $i <= $#$x ; ++ $i) {
+        my $e = $x -> [$i];
+
+        return "Element at index $i is undefined"
+          unless defined $e;
+
+        return "Element at index $i is a '" . ref($e) .
+          "', which is not a scalar"
+          unless ref($e) eq "";
+
+        # It would be better to use the regex /^([1-9]\d*|0)\z/, but that fails
+        # in Math::BigInt::FastCalc, because it sometimes creates array
+        # elements like "000000".
+        return "Element at index $i is '$e', which does not look like an" .
+          " normal integer" unless $e =~ /^\d+\z/;
+
+        return "Element at index $i is '$e', which is not smaller than" .
+          " the base '$BASE'" if $e >= $BASE;
+
+        return "Element at index $i (last element) is zero"
+          if $#$x > 0 && $i == $#$x && $e == 0;
+    }
+
+    return 0;
+}
+
+###############################################################################
+
+sub _mod {
+    # if possible, use mod shortcut
+    my ($c, $x, $yo) = @_;
+
+    # slow way since $y too big
+    if (@$yo > 1) {
+        my ($xo, $rem) = $c->_div($x, $yo);
+        @$x = @$rem;
+        return $x;
+    }
+
+    my $y = $yo->[0];
+
+    # if both are single element arrays
+    if (@$x == 1) {
+        $x->[0] %= $y;
+        return $x;
+    }
+
+    # if @$x has more than one element, but @$y is a single element
+    my $b = $BASE % $y;
+    if ($b == 0) {
+        # when BASE % Y == 0 then (B * BASE) % Y == 0
+        # (B * BASE) % $y + A % Y => A % Y
+        # so need to consider only last element: O(1)
+        $x->[0] %= $y;
+    } elsif ($b == 1) {
+        # else need to go through all elements in @$x: O(N), but loop is a bit
+        # simplified
+        my $r = 0;
+        foreach (@$x) {
+            $r = ($r + $_) % $y; # not much faster, but heh...
+            #$r += $_ % $y; $r %= $y;
+        }
+        $r = 0 if $r == $y;
+        $x->[0] = $r;
+    } else {
+        # else need to go through all elements in @$x: O(N)
+        my $r = 0;
+        my $bm = 1;
+        foreach (@$x) {
+            $r = ($_ * $bm + $r) % $y;
+            $bm = ($bm * $b) % $y;
+
+            #$r += ($_ % $y) * $bm;
+            #$bm *= $b;
+            #$bm %= $y;
+            #$r %= $y;
+        }
+        $r = 0 if $r == $y;
+        $x->[0] = $r;
+    }
+    @$x = $x->[0];              # keep one element of @$x
+    return $x;
+}
+
+##############################################################################
+# shifts
+
+sub _rsft {
+    my ($c, $x, $n, $b) = @_;
+    return $x if $c->_is_zero($x) || $c->_is_zero($n);
+
+    # For backwards compatibility, allow the base $b to be a scalar.
+
+    $b = $c->_new($b) unless ref $b;
+
+    if ($c -> _acmp($b, $c -> _ten())) {
+        return scalar $c->_div($x, $c->_pow($c->_copy($b), $n));
+    }
+
+    # shortcut (faster) for shifting by 10)
+    # multiples of $BASE_LEN
+    my $dst = 0;                # destination
+    my $src = $c->_num($n);     # as normal int
+    my $xlen = (@$x - 1) * $BASE_LEN + length(int($x->[-1]));
+    if ($src >= $xlen or ($src == $xlen and !defined $x->[1])) {
+        # 12345 67890 shifted right by more than 10 digits => 0
+        splice(@$x, 1);         # leave only one element
+        $x->[0] = 0;            # set to zero
+        return $x;
+    }
+    my $rem = $src % $BASE_LEN;   # remainder to shift
+    $src = int($src / $BASE_LEN); # source
+    if ($rem == 0) {
+        splice(@$x, 0, $src);   # even faster, 38.4 => 39.3
+    } else {
+        my $len = @$x - $src;   # elems to go
+        my $vd;
+        my $z = '0' x $BASE_LEN;
+        $x->[ @$x ] = 0;          # avoid || 0 test inside loop
+        while ($dst < $len) {
+            $vd = $z . $x->[$src];
+            $vd = substr($vd, -$BASE_LEN, $BASE_LEN - $rem);
+            $src++;
+            $vd = substr($z . $x->[$src], -$rem, $rem) . $vd;
+            $vd = substr($vd, -$BASE_LEN, $BASE_LEN) if length($vd) > $BASE_LEN;
+            $x->[$dst] = int($vd);
+            $dst++;
+        }
+        splice(@$x, $dst) if $dst > 0;       # kill left-over array elems
+        pop(@$x) if $x->[-1] == 0 && @$x > 1; # kill last element if 0
+    }                                        # else rem == 0
+    $x;
+}
+
+sub _lsft {
+    my ($c, $x, $n, $b) = @_;
+
+    return $x if $c->_is_zero($x) || $c->_is_zero($n);
+
+    # For backwards compatibility, allow the base $b to be a scalar.
+
+    $b = $c->_new($b) unless ref $b;
+
+    # If the base is a power of 10, use shifting, since the internal
+    # representation is in base 10eX.
+
+    my $bstr = $c->_str($b);
+    if ($bstr =~ /^1(0+)\z/) {
+
+        # Adjust $n so that we're shifting in base 10. Do this by multiplying
+        # $n by the base 10 logarithm of $b: $b ** $n = 10 ** (log10($b) * $n).
+
+        my $log10b = length($1);
+        $n = $c->_mul($c->_new($log10b), $n);
+        $n = $c->_num($n);              # shift-len as normal int
+
+        # $q is the number of places to shift the elements within the array,
+        # and $r is the number of places to shift the values within the
+        # elements.
+
+        my $r = $n % $BASE_LEN;
+        my $q = ($n - $r) / $BASE_LEN;
+
+        # If we must shift the values within the elements ...
+
+        if ($r) {
+            my $i = @$x;                # index
+            $x->[$i] = 0;               # initialize most significant element
+            my $z = '0' x $BASE_LEN;
+            my $vd;
+            while ($i >= 0) {
+                $vd = $x->[$i];
+                $vd = $z . $vd;
+                $vd = substr($vd, $r - $BASE_LEN, $BASE_LEN - $r);
+                $vd .= $i > 0 ? substr($z . $x->[$i - 1], -$BASE_LEN, $r)
+                              : '0' x $r;
+                $vd = substr($vd, -$BASE_LEN, $BASE_LEN) if length($vd) > $BASE_LEN;
+                $x->[$i] = int($vd);    # e.g., "0...048" -> 48 etc.
+                $i--;
+            }
+
+            pop(@$x) if $x->[-1] == 0;  # if most significant element is zero
+        }
+
+        # If we must shift the elements within the array ...
+
+        if ($q) {
+            unshift @$x, (0) x $q;
+        }
+
+    } else {
+        $x = $c->_mul($x, $c->_pow($b, $n));
+    }
+
+    return $x;
+}
+
+sub _pow {
+    # power of $x to $y
+    # ref to array, ref to array, return ref to array
+    my ($c, $cx, $cy) = @_;
+
+    if (@$cy == 1 && $cy->[0] == 0) {
+        splice(@$cx, 1);
+        $cx->[0] = 1;           # y == 0 => x => 1
+        return $cx;
+    }
+
+    if ((@$cx == 1 && $cx->[0] == 1) || #    x == 1
+        (@$cy == 1 && $cy->[0] == 1))   # or y == 1
+    {
+        return $cx;
+    }
+
+    if (@$cx == 1 && $cx->[0] == 0) {
+        splice (@$cx, 1);
+        $cx->[0] = 0;           # 0 ** y => 0 (if not y <= 0)
+        return $cx;
+    }
+
+    my $pow2 = $c->_one();
+
+    my $y_bin = $c->_as_bin($cy);
+    $y_bin =~ s/^0b//;
+    my $len = length($y_bin);
+    while (--$len > 0) {
+        $c->_mul($pow2, $cx) if substr($y_bin, $len, 1) eq '1'; # is odd?
+        $c->_mul($cx, $cx);
+    }
+
+    $c->_mul($cx, $pow2);
+    $cx;
+}
+
+sub _nok {
+    # Return binomial coefficient (n over k).
+    # Given refs to arrays, return ref to array.
+    # First input argument is modified.
+
+    my ($c, $n, $k) = @_;
+
+    # If k > n/2, or, equivalently, 2*k > n, compute nok(n, k) as
+    # nok(n, n-k), to minimize the number if iterations in the loop.
+
+    {
+        my $twok = $c->_mul($c->_two(), $c->_copy($k)); # 2 * k
+        if ($c->_acmp($twok, $n) > 0) {               # if 2*k > n
+            $k = $c->_sub($c->_copy($n), $k);         # k = n - k
+        }
+    }
+
+    # Example:
+    #
+    # / 7 \       7!       1*2*3*4 * 5*6*7   5 * 6 * 7       6   7
+    # |   | = --------- =  --------------- = --------- = 5 * - * -
+    # \ 3 /   (7-3)! 3!    1*2*3*4 * 1*2*3   1 * 2 * 3       2   3
+
+    if ($c->_is_zero($k)) {
+        @$n = 1;
+    } else {
+
+        # Make a copy of the original n, since we'll be modifying n in-place.
+
+        my $n_orig = $c->_copy($n);
+
+        # n = 5, f = 6, d = 2 (cf. example above)
+
+        $c->_sub($n, $k);
+        $c->_inc($n);
+
+        my $f = $c->_copy($n);
+        $c->_inc($f);
+
+        my $d = $c->_two();
+
+        # while f <= n (the original n, that is) ...
+
+        while ($c->_acmp($f, $n_orig) <= 0) {
+
+            # n = (n * f / d) == 5 * 6 / 2 (cf. example above)
+
+            $c->_mul($n, $f);
+            $c->_div($n, $d);
+
+            # f = 7, d = 3 (cf. example above)
+
+            $c->_inc($f);
+            $c->_inc($d);
+        }
+
+    }
+
+    return $n;
+}
+
+sub _fac {
+    # factorial of $x
+    # ref to array, return ref to array
+    my ($c, $cx) = @_;
+
+    # We cache the smallest values. Don't assume that a single element has a
+    # value larger than 9 or else it won't work with a $BASE_LEN of 1.
+
+    if (@$cx == 1) {
+        my @factorials =
+          (
+           '1',
+           '1',
+           '2',
+           '6',
+           '24',
+           '120',
+           '720',
+           '5040',
+           '40320',
+           '362880',
+          );
+        if ($cx->[0] <= $#factorials) {
+            my $tmp = $c -> _new($factorials[ $cx->[0] ]);
+            @$cx = @$tmp;
+            return $cx;
+        }
+    }
+
+    # The old code further below doesn't work for small values of $BASE_LEN.
+    # Alas, I have not been able to (or taken the time to) decipher it, so for
+    # the case when $BASE_LEN is small, we call the parent class. This code
+    # works in for every value of $x and $BASE_LEN. We could use this code for
+    # all cases, but it is a little slower than the code further below, so at
+    # least for now we keep the code below.
+
+    if ($BASE_LEN <= 2) {
+        my $tmp = $c -> SUPER::_fac($cx);
+        @$cx = @$tmp;
+        return $cx;
+    }
+
+    # This code does not work for small values of $BASE_LEN.
+
+    if ((@$cx == 1) &&          # we do this only if $x >= 12 and $x <= 7000
+        ($cx->[0] >= 12 && $cx->[0] < 7000)) {
+
+        # Calculate (k-j) * (k-j+1) ... k .. (k+j-1) * (k + j)
+        # See http://blogten.blogspot.com/2007/01/calculating-n.html
+        # The above series can be expressed as factors:
+        #   k * k - (j - i) * 2
+        # We cache k*k, and calculate (j * j) as the sum of the first j odd integers
+
+        # This will not work when N exceeds the storage of a Perl scalar, however,
+        # in this case the algorithm would be way too slow to terminate, anyway.
+
+        # As soon as the last element of $cx is 0, we split it up and remember
+        # how many zeors we got so far. The reason is that n! will accumulate
+        # zeros at the end rather fast.
+        my $zero_elements = 0;
+
+        # If n is even, set n = n -1
+        my $k = $c->_num($cx);
+        my $even = 1;
+        if (($k & 1) == 0) {
+            $even = $k;
+            $k --;
+        }
+        # set k to the center point
+        $k = ($k + 1) / 2;
+        #  print "k $k even: $even\n";
+        # now calculate k * k
+        my $k2 = $k * $k;
+        my $odd = 1;
+        my $sum = 1;
+        my $i = $k - 1;
+        # keep reference to x
+        my $new_x = $c->_new($k * $even);
+        @$cx = @$new_x;
+        if ($cx->[0] == 0) {
+            $zero_elements ++;
+            shift @$cx;
+        }
+        #  print STDERR "x = ", $c->_str($cx), "\n";
+        my $BASE2 = int(sqrt($BASE))-1;
+        my $j = 1;
+        while ($j <= $i) {
+            my $m = ($k2 - $sum);
+            $odd += 2;
+            $sum += $odd;
+            $j++;
+            while ($j <= $i && ($m < $BASE2) && (($k2 - $sum) < $BASE2)) {
+                $m *= ($k2 - $sum);
+                $odd += 2;
+                $sum += $odd;
+                $j++;
+                #      print STDERR "\n k2 $k2 m $m sum $sum odd $odd\n"; sleep(1);
+            }
+            if ($m < $BASE) {
+                $c->_mul($cx, [$m]);
+            } else {
+                $c->_mul($cx, $c->_new($m));
+            }
+            if ($cx->[0] == 0) {
+                $zero_elements ++;
+                shift @$cx;
+            }
+            #    print STDERR "Calculate $k2 - $sum = $m (x = ", $c->_str($cx), ")\n";
+        }
+        # multiply in the zeros again
+        unshift @$cx, (0) x $zero_elements;
+        return $cx;
+    }
+
+    # go forward until $base is exceeded limit is either $x steps (steps == 100
+    # means a result always too high) or $base.
+    my $steps = 100;
+    $steps = $cx->[0] if @$cx == 1;
+    my $r = 2;
+    my $cf = 3;
+    my $step = 2;
+    my $last = $r;
+    while ($r * $cf < $BASE && $step < $steps) {
+        $last = $r;
+        $r *= $cf++;
+        $step++;
+    }
+    if ((@$cx == 1) && $step == $cx->[0]) {
+        # completely done, so keep reference to $x and return
+        $cx->[0] = $r;
+        return $cx;
+    }
+
+    # now we must do the left over steps
+    my $n;                      # steps still to do
+    if (@$cx == 1) {
+        $n = $cx->[0];
+    } else {
+        $n = $c->_copy($cx);
+    }
+
+    # Set $cx to the last result below $BASE (but keep ref to $x)
+    $cx->[0] = $last;
+    splice (@$cx, 1);
+    # As soon as the last element of $cx is 0, we split it up and remember
+    # how many zeors we got so far. The reason is that n! will accumulate
+    # zeros at the end rather fast.
+    my $zero_elements = 0;
+
+    # do left-over steps fit into a scalar?
+    if (ref $n eq 'ARRAY') {
+        # No, so use slower inc() & cmp()
+        # ($n is at least $BASE here)
+        my $base_2 = int(sqrt($BASE)) - 1;
+        #print STDERR "base_2: $base_2\n";
+        while ($step < $base_2) {
+            if ($cx->[0] == 0) {
+                $zero_elements ++;
+                shift @$cx;
+            }
+            my $b = $step * ($step + 1);
+            $step += 2;
+            $c->_mul($cx, [$b]);
+        }
+        $step = [$step];
+        while ($c->_acmp($step, $n) <= 0) {
+            if ($cx->[0] == 0) {
+                $zero_elements ++;
+                shift @$cx;
+            }
+            $c->_mul($cx, $step);
+            $c->_inc($step);
+        }
+    } else {
+        # Yes, so we can speed it up slightly
+
+        #    print "# left over steps $n\n";
+
+        my $base_4 = int(sqrt(sqrt($BASE))) - 2;
+        #print STDERR "base_4: $base_4\n";
+        my $n4 = $n - 4;
+        while ($step < $n4 && $step < $base_4) {
+            if ($cx->[0] == 0) {
+                $zero_elements ++;
+                shift @$cx;
+            }
+            my $b = $step * ($step + 1);
+            $step += 2;
+            $b *= $step * ($step + 1);
+            $step += 2;
+            $c->_mul($cx, [$b]);
+        }
+        my $base_2 = int(sqrt($BASE)) - 1;
+        my $n2 = $n - 2;
+        #print STDERR "base_2: $base_2\n";
+        while ($step < $n2 && $step < $base_2) {
+            if ($cx->[0] == 0) {
+                $zero_elements ++;
+                shift @$cx;
+            }
+            my $b = $step * ($step + 1);
+            $step += 2;
+            $c->_mul($cx, [$b]);
+        }
+        # do what's left over
+        while ($step <= $n) {
+            $c->_mul($cx, [$step]);
+            $step++;
+            if ($cx->[0] == 0) {
+                $zero_elements ++;
+                shift @$cx;
+            }
+        }
+    }
+    # multiply in the zeros again
+    unshift @$cx, (0) x $zero_elements;
+    $cx;                        # return result
+}
+
+sub _log_int {
+    # calculate integer log of $x to base $base
+    # ref to array, ref to array - return ref to array
+    my ($c, $x, $base) = @_;
+
+    # X == 0 => NaN
+    return if @$x == 1 && $x->[0] == 0;
+
+    # BASE 0 or 1 => NaN
+    return if @$base == 1 && $base->[0] < 2;
+
+    # X == 1 => 0 (is exact)
+    if (@$x == 1 && $x->[0] == 1) {
+        @$x = 0;
+        return $x, 1;
+    }
+
+    my $cmp = $c->_acmp($x, $base);
+
+    # X == BASE => 1 (is exact)
+    if ($cmp == 0) {
+        @$x = 1;
+        return $x, 1;
+    }
+
+    # 1 < X < BASE => 0 (is truncated)
+    if ($cmp < 0) {
+        @$x = 0;
+        return $x, 0;
+    }
+
+    my $x_org = $c->_copy($x);  # preserve x
+
+    # Compute a guess for the result based on:
+    # $guess = int ( length_in_base_10(X) / ( log(base) / log(10) ) )
+    my $len = $c->_len($x_org);
+    my $log = log($base->[-1]) / log(10);
+
+    # for each additional element in $base, we add $BASE_LEN to the result,
+    # based on the observation that log($BASE, 10) is BASE_LEN and
+    # log(x*y) == log(x) + log(y):
+    $log += (@$base - 1) * $BASE_LEN;
+
+    # calculate now a guess based on the values obtained above:
+    my $res = $c->_new(int($len / $log));
+
+    @$x = @$res;
+    my $trial = $c->_pow($c->_copy($base), $x);
+    my $acmp = $c->_acmp($trial, $x_org);
+
+    # Did we get the exact result?
+
+    return $x, 1 if $acmp == 0;
+
+    # Too small?
+
+    while ($acmp < 0) {
+        $c->_mul($trial, $base);
+        $c->_inc($x);
+        $acmp = $c->_acmp($trial, $x_org);
+    }
+
+    # Too big?
+
+    while ($acmp > 0) {
+        $c->_div($trial, $base);
+        $c->_dec($x);
+        $acmp = $c->_acmp($trial, $x_org);
+    }
+
+    return $x, 1 if $acmp == 0;         # result is exact
+    return $x, 0;                       # result is too small
+}
+
+sub _ilog2 {
+    # calculate int(log2($x))
+
+    # There is virtually nothing to gain from computing this any differently
+    # than _log_int(), but it is important that we don't use the method
+    # inherited from the parent, because that method is very slow for backend
+    # libraries whose internal representation uses base 10.
+
+    my ($c, $x) = @_;
+    ($x, my $is_exact) = $c -> _log_int($x, $c -> _two());
+    return wantarray ? ($x, $is_exact) : $x;
+}
+
+sub _ilog10 {
+    # calculate int(log10($x))
+
+    my ($c, $x) = @_;
+
+    # X == 0 => NaN
+    return if @$x == 1 && $x->[0] == 0;
+
+    # X == 1 => 0 (is exact)
+    if (@$x == 1 && $x->[0] == 1) {
+        @$x = 0;
+        return wantarray ? ($x, 1) : $x;
+    }
+
+    my $x_orig = $c -> _copy($x);
+    my $nm1 = $c -> _len($x) - 1;
+
+    my $xtmp = $c -> _new($nm1);
+    @$x = @$xtmp;
+
+    return $x unless wantarray;
+
+    # See if the original $x is an exact power of 10, in which case all but the
+    # most significan chunks are 0, and the most significant chunk is a power
+    # of 10.
+
+    my $is_pow10 = 1;
+    for my $i (0 .. $#$x_orig - 1) {
+        last unless $is_pow10 = $x_orig->[$i] == 0;
+    }
+    $is_pow10 &&= $x_orig->[-1] == 10**int(0.5 + log($x_orig->[-1]) / log(10));
+
+    return wantarray ? ($x, 1) : $x if $is_pow10;
+    return wantarray ? ($x, 0) : $x;
+}
+
+sub _clog2 {
+    # calculate ceil(log2($x))
+
+    my ($c, $x) = @_;
+
+    # X == 0 => NaN
+
+    return if @$x == 1 && $x->[0] == 0;
+
+    # X == 1 => 0 (is exact)
+
+    if (@$x == 1 && $x->[0] == 1) {
+        @$x = 0;
+        return wantarray ? ($x, 1) : $x;
+    }
+
+    my $base = $c -> _two();
+    my $acmp = $c -> _acmp($x, $base);
+
+    # X == BASE => 1 (is exact)
+
+    if ($acmp == 0) {
+        @$x = 1;
+        return wantarray ? ($x, 1) : $x;
+    }
+
+    # 1 < X < BASE => 0 (is truncated)
+
+    if ($acmp < 0) {
+        @$x = 0;
+        return wantarray ? ($x, 0) : $x;
+    }
+
+    # Compute a guess for the result based on:
+    # $guess = int( length_in_base_10(X) / (log(base) / log(10)) )
+
+    my $len    = $c -> _len($x);
+    my $log    = log(2) / log(10);
+    my $guess  = $c -> _new(int($len / $log));
+    my $x_orig = $c -> _copy($x);
+    @$x = @$guess;
+
+    my $trial = $c -> _pow($c -> _copy($base), $x);
+    $acmp = $c -> _acmp($trial, $x_orig);
+
+    # Too big?
+
+    while ($acmp > 0) {
+        $c -> _div($trial, $base);
+        $c -> _dec($x);
+        $acmp = $c -> _acmp($trial, $x_orig);
+    }
+
+    # Too small?
+
+    while ($acmp < 0) {
+        $c -> _mul($trial, $base);
+        $c -> _inc($x);
+        $acmp = $c -> _acmp($trial, $x_orig);
+    }
+
+    return wantarray ? ($x, 1) : $x if $acmp == 0;      # result is exact
+    return wantarray ? ($x, 0) : $x;                    # result is too small
+}
+
+sub _clog10 {
+    # calculate ceil(log2($x))
+    my ($c, $x) = @_;
+
+    # X == 0 => NaN
+    return if @$x == 1 && $x->[0] == 0;
+
+    # X == 1 => 0 (is exact)
+    if (@$x == 1 && $x->[0] == 1) {
+        @$x = 0;
+        return wantarray ? ($x, 1) : $x;
+    }
+
+    # Get the number of base 10 digits. $n is the desired output, except when
+    # $x is an exact power of 10, in which case $n is 1 too big.
+
+    my $n = $c -> _len($x);
+
+    # See if $x is an exact power of 10, in which case all but the most
+    # significan chunks are 0, and the most significant chunk is a power of 10.
+
+    my $is_pow10 = 1;
+    for my $i (0 .. $#$x - 1) {
+        last unless $is_pow10 = $x->[$i] == 0;
+    }
+    $is_pow10 &&= $x->[-1] == 10**int(0.5 + log($x->[-1]) / log(10));
+
+    $n-- if $is_pow10;
+
+    my $xtmp = $c ->_new($n);
+    @$x = @$xtmp;
+
+    return wantarray ? ($x, 1) : $x if $is_pow10;       # result is exact
+    return wantarray ? ($x, 0) : $x;                    # result is too small
+}
+
+# for debugging:
+use constant DEBUG => 0;
+my $steps = 0;
+sub steps { $steps };
+
+sub _sqrt {
+    # square-root of $x in-place
+
+    my ($c, $x) = @_;
+
+    if (@$x == 1) {
+        # fits into one Perl scalar, so result can be computed directly
+        $x->[0] = int(sqrt($x->[0]));
+        return $x;
+    }
+
+    # Create an initial guess for the square root.
+
+    my $s;
+    if (@$x % 2) {
+        $s = [ (0) x ((@$x - 1) / 2), int(sqrt($x->[-1])) ];
+    } else {
+        $s = [ (0) x ((@$x - 2) / 2), int(sqrt($x->[-2] + $x->[-1] * $BASE)) ];
+    }
+
+    # Newton's method for the square root of y:
+    #
+    #                      x(n) * x(n) - y
+    #     x(n+1) = x(n) - -----------------
+    #                          2 * x(n)
+
+    my $cmp;
+    while (1) {
+        my $sq = $c -> _mul($c -> _copy($s), $s);
+        $cmp = $c -> _acmp($sq, $x);
+
+        # If x(n)*x(n) > y, compute
+        #
+        #                      x(n) * x(n) - y
+        #     x(n+1) = x(n) - -----------------
+        #                          2 * x(n)
+
+        if ($cmp > 0) {
+            my $num = $c -> _sub($c -> _copy($sq), $x);
+            my $den = $c -> _mul($c -> _two(), $s);
+            my $delta = $c -> _div($num, $den);
+            last if $c -> _is_zero($delta);
+            $s = $c -> _sub($s, $delta);
+        }
+
+        # If x(n)*x(n) < y, compute
+        #
+        #                      y - x(n) * x(n)
+        #     x(n+1) = x(n) + -----------------
+        #                          2 * x(n)
+
+        elsif ($cmp < 0) {
+            my $num = $c -> _sub($c -> _copy($x), $sq);
+            my $den = $c -> _mul($c -> _two(), $s);
+            my $delta = $c -> _div($num, $den);
+            last if $c -> _is_zero($delta);
+            $s = $c -> _add($s, $delta);
+        }
+
+        # If x(n)*x(n) = y, we have the exact result.
+
+        else {
+            last;
+        }
+    }
+
+    $s = $c -> _dec($s) if $cmp > 0;    # never overshoot
+    @$x = @$s;
+    return $x;
+}
+
+sub _root {
+    # Take n'th root of $x in place.
+
+    my ($c, $x, $n) = @_;
+
+    # Small numbers.
+
+    if (@$x == 1) {
+        return $x if $x -> [0] == 0 || $x -> [0] == 1;
+
+        if (@$n == 1) {
+            # Result can be computed directly. Adjust initial result for
+            # numerical errors, e.g., int(1000**(1/3)) is 2, not 3.
+            my $y = int($x->[0] ** (1 / $n->[0]));
+            my $yp1 = $y + 1;
+            $y = $yp1 if $yp1 ** $n->[0] == $x->[0];
+            $x->[0] = $y;
+            return $x;
+        }
+    }
+
+    # If x <= n, the result is always (truncated to) 1.
+
+    if ((@$x > 1 || $x -> [0] > 0) &&           # if x is non-zero ...
+        $c -> _acmp($x, $n) <= 0)               # ... and x <= n
+    {
+        my $one = $c -> _one();
+        @$x = @$one;
+        return $x;
+    }
+
+    # If $n is a power of two, take sqrt($x) repeatedly, e.g., root($x, 4) =
+    # sqrt(sqrt($x)), root($x, 8) = sqrt(sqrt(sqrt($x))).
+
+    my $b = $c -> _as_bin($n);
+    if ($b =~ /0b1(0+)$/) {
+        my $count = length($1);       # 0b100 => len('00') => 2
+        my $cnt = $count;             # counter for loop
+        unshift @$x, 0;               # add one element, together with one
+                                      #   more below in the loop this makes 2
+        while ($cnt-- > 0) {
+            # 'Inflate' $x by adding one element, basically computing
+            # $x * $BASE * $BASE. This gives us more $BASE_LEN digits for
+            # result since len(sqrt($X)) approx == len($x) / 2.
+            unshift @$x, 0;
+            # Calculate sqrt($x), $x is now one element to big, again. In the
+            # next round we make that two, again.
+            $c -> _sqrt($x);
+        }
+
+        # $x is now one element too big, so truncate result by removing it.
+        shift @$x;
+
+        return $x;
+    }
+
+    my $DEBUG = 0;
+
+    # Now the general case. This works by finding an initial guess. If this
+    # guess is incorrect, a relatively small delta is chosen. This delta is
+    # used to find a lower and upper limit for the correct value. The delta is
+    # doubled in each iteration. When a lower and upper limit is found,
+    # bisection is applied to narrow down the region until we have the correct
+    # value.
+
+    # Split x into mantissa and exponent in base 10, so that
+    #
+    #   x = xm * 10^xe, where 0 < xm < 1 and xe is an integer
+
+    my $x_str = $c -> _str($x);
+    my $xm    = "." . $x_str;
+    my $xe    = length($x_str);
+
+    # From this we compute the base 10 logarithm of x
+    #
+    #   log_10(x) = log_10(xm) + log_10(xe^10)
+    #             = log(xm)/log(10) + xe
+    #
+    # and then the base 10 logarithm of y, where y = x^(1/n)
+    #
+    #   log_10(y) = log_10(x)/n
+
+    my $log10x = log($xm) / log(10) + $xe;
+    my $log10y = $log10x / $c -> _num($n);
+
+    # And from this we compute ym and ye, the mantissa and exponent (in
+    # base 10) of y, where 1 < ym <= 10 and ye is an integer.
+
+    my $ye = int $log10y;
+    my $ym = 10 ** ($log10y - $ye);
+
+    # Finally, we scale the mantissa and exponent to incraese the integer
+    # part of ym, before building the string representing our guess of y.
+
+    if ($DEBUG) {
+        print "\n";
+        print "xm     = $xm\n";
+        print "xe     = $xe\n";
+        print "log10x = $log10x\n";
+        print "log10y = $log10y\n";
+        print "ym     = $ym\n";
+        print "ye     = $ye\n";
+        print "\n";
+    }
+
+    my $d = $ye < 15 ? $ye : 15;
+    $ym *= 10 ** $d;
+    $ye -= $d;
+
+    my $y_str = sprintf('%.0f', $ym) . "0" x $ye;
+    my $y = $c -> _new($y_str);
+
+    if ($DEBUG) {
+        print "ym     = $ym\n";
+        print "ye     = $ye\n";
+        print "\n";
+        print "y_str  = $y_str (initial guess)\n";
+        print "\n";
+    }
+
+    # See if our guess y is correct.
+
+    my $trial = $c -> _pow($c -> _copy($y), $n);
+    my $acmp  = $c -> _acmp($trial, $x);
+
+    if ($acmp == 0) {
+        @$x = @$y;
+        return $x;
+    }
+
+    # Find a lower and upper limit for the correct value of y. Start off with a
+    # delta value that is approximately the size of the accuracy of the guess.
+
+    my $lower;
+    my $upper;
+
+    my $delta = $c -> _new("1" . ("0" x $ye));
+    my $two   = $c -> _two();
+
+    if ($acmp < 0) {
+        $lower = $y;
+        while ($acmp < 0) {
+            $upper = $c -> _add($c -> _copy($lower), $delta);
+
+            if ($DEBUG) {
+                print "lower  = $lower\n";
+                print "upper  = $upper\n";
+                print "delta  = $delta\n";
+                print "\n";
+            }
+            $acmp  = $c -> _acmp($c -> _pow($c -> _copy($upper), $n), $x);
+            if ($acmp == 0) {
+                @$x = @$upper;
+                return $x;
+            }
+            $delta = $c -> _mul($delta, $two);
+        }
+    }
+
+    elsif ($acmp > 0) {
+        $upper = $y;
+        while ($acmp > 0) {
+            if ($c -> _acmp($upper, $delta) <= 0) {
+                $lower = $c -> _zero();
+                last;
+            }
+            $lower = $c -> _sub($c -> _copy($upper), $delta);
+
+            if ($DEBUG) {
+                print "lower  = $lower\n";
+                print "upper  = $upper\n";
+                print "delta  = $delta\n";
+                print "\n";
+            }
+            $acmp  = $c -> _acmp($c -> _pow($c -> _copy($lower), $n), $x);
+            if ($acmp == 0) {
+                @$x = @$lower;
+                return $x;
+            }
+            $delta = $c -> _mul($delta, $two);
+        }
+    }
+
+    # Use bisection to narrow down the interval.
+
+    my $one = $c -> _one();
+    {
+
+        $delta = $c -> _sub($c -> _copy($upper), $lower);
+        if ($c -> _acmp($delta, $one) <= 0) {
+            @$x = @$lower;
+            return $x;
+        }
+
+        if ($DEBUG) {
+            print "lower  = $lower\n";
+            print "upper  = $upper\n";
+            print "delta   = $delta\n";
+            print "\n";
+        }
+
+        $delta = $c -> _div($delta, $two);
+        my $middle = $c -> _add($c -> _copy($lower), $delta);
+
+        $acmp  = $c -> _acmp($c -> _pow($c -> _copy($middle), $n), $x);
+        if ($acmp < 0) {
+            $lower = $middle;
+        } elsif ($acmp > 0) {
+            $upper = $middle;
+        } else {
+            @$x = @$middle;
+            return $x;
+        }
+
+        redo;
+    }
+
+    $x;
+}
+
+##############################################################################
+# binary stuff
+
+sub _and {
+    my ($c, $x, $y) = @_;
+
+    # the shortcut makes equal, large numbers _really_ fast, and makes only a
+    # very small performance drop for small numbers (e.g. something with less
+    # than 32 bit) Since we optimize for large numbers, this is enabled.
+    return $x if $c->_acmp($x, $y) == 0; # shortcut
+
+    my $m = $c->_one();
+    my ($xr, $yr);
+    my $mask = $AND_MASK;
+
+    my $x1 = $c->_copy($x);
+    my $y1 = $c->_copy($y);
+    my $z  = $c->_zero();
+
+    use integer;
+    until ($c->_is_zero($x1) || $c->_is_zero($y1)) {
+        ($x1, $xr) = $c->_div($x1, $mask);
+        ($y1, $yr) = $c->_div($y1, $mask);
+
+        $c->_add($z, $c->_mul([ 0 + $xr->[0] & 0 + $yr->[0] ], $m));
+        $c->_mul($m, $mask);
+    }
+
+    @$x = @$z;
+    return $x;
+}
+
+sub _xor {
+    my ($c, $x, $y) = @_;
+
+    return $c->_zero() if $c->_acmp($x, $y) == 0; # shortcut (see -and)
+
+    my $m = $c->_one();
+    my ($xr, $yr);
+    my $mask = $XOR_MASK;
+
+    my $x1 = $c->_copy($x);
+    my $y1 = $c->_copy($y);      # make copy
+    my $z  = $c->_zero();
+
+    use integer;
+    until ($c->_is_zero($x1) || $c->_is_zero($y1)) {
+        ($x1, $xr) = $c->_div($x1, $mask);
+        ($y1, $yr) = $c->_div($y1, $mask);
+        # make ints() from $xr, $yr (see _and())
+        #$b = 1; $xrr = 0; foreach (@$xr) { $xrr += $_ * $b; $b *= $BASE; }
+        #$b = 1; $yrr = 0; foreach (@$yr) { $yrr += $_ * $b; $b *= $BASE; }
+        #$c->_add($x, $c->_mul($c->_new($xrr ^ $yrr)), $m) );
+
+        $c->_add($z, $c->_mul([ 0 + $xr->[0] ^ 0 + $yr->[0] ], $m));
+        $c->_mul($m, $mask);
+    }
+    # the loop stops when the shorter of the two numbers is exhausted
+    # the remainder of the longer one will survive bit-by-bit, so we simple
+    # multiply-add it in
+    $c->_add($z, $c->_mul($x1, $m) ) if !$c->_is_zero($x1);
+    $c->_add($z, $c->_mul($y1, $m) ) if !$c->_is_zero($y1);
+
+    @$x = @$z;
+    return $x;
+}
+
+sub _or {
+    my ($c, $x, $y) = @_;
+
+    return $x if $c->_acmp($x, $y) == 0; # shortcut (see _and)
+
+    my $m = $c->_one();
+    my ($xr, $yr);
+    my $mask = $OR_MASK;
+
+    my $x1 = $c->_copy($x);
+    my $y1 = $c->_copy($y);      # make copy
+    my $z  = $c->_zero();
+
+    use integer;
+    until ($c->_is_zero($x1) || $c->_is_zero($y1)) {
+        ($x1, $xr) = $c->_div($x1, $mask);
+        ($y1, $yr) = $c->_div($y1, $mask);
+        # make ints() from $xr, $yr (see _and())
+        #    $b = 1; $xrr = 0; foreach (@$xr) { $xrr += $_ * $b; $b *= $BASE; }
+        #    $b = 1; $yrr = 0; foreach (@$yr) { $yrr += $_ * $b; $b *= $BASE; }
+        #    $c->_add($x, $c->_mul(_new( $c, ($xrr | $yrr) ), $m) );
+        $c->_add($z, $c->_mul([ 0 + $xr->[0] | 0 + $yr->[0] ], $m));
+        $c->_mul($m, $mask);
+    }
+    # the loop stops when the shorter of the two numbers is exhausted
+    # the remainder of the longer one will survive bit-by-bit, so we simple
+    # multiply-add it in
+    $c->_add($z, $c->_mul($x1, $m) ) if !$c->_is_zero($x1);
+    $c->_add($z, $c->_mul($y1, $m) ) if !$c->_is_zero($y1);
+
+    @$x = @$z;
+    return $x;
+}
+
+sub _as_hex {
+    # convert a decimal number to hex (ref to array, return ref to string)
+    my ($c, $x) = @_;
+
+    return "0x0" if @$x == 1 && $x->[0] == 0;
+
+    my $x1 = $c->_copy($x);
+
+    my $x10000 = [ 0x10000 ];
+
+    my $es = '';
+    my $xr;
+    until (@$x1 == 1 && $x1->[0] == 0) {        # _is_zero()
+        ($x1, $xr) = $c->_div($x1, $x10000);
+        $es = sprintf('%04x', $xr->[0]) . $es;
+    }
+    #$es = reverse $es;
+    $es =~ s/^0*/0x/;
+    return $es;
+}
+
+sub _as_bin {
+    # convert a decimal number to bin (ref to array, return ref to string)
+    my ($c, $x) = @_;
+
+    return "0b0" if @$x == 1 && $x->[0] == 0;
+
+    my $x1 = $c->_copy($x);
+
+    my $x10000 = [ 0x10000 ];
+
+    my $es = '';
+    my $xr;
+
+    until (@$x1 == 1 && $x1->[0] == 0) {        # _is_zero()
+        ($x1, $xr) = $c->_div($x1, $x10000);
+        $es = sprintf('%016b', $xr->[0]) . $es;
+    }
+    $es =~ s/^0*/0b/;
+    return $es;
+}
+
+sub _as_oct {
+    # convert a decimal number to octal (ref to array, return ref to string)
+    my ($c, $x) = @_;
+
+    return "00" if @$x == 1 && $x->[0] == 0;
+
+    my $x1 = $c->_copy($x);
+
+    my $x1000 = [ 1 << 15 ];    # 15 bits = 32768 = 0100000
+
+    my $es = '';
+    my $xr;
+    until (@$x1 == 1 && $x1->[0] == 0) {        # _is_zero()
+        ($x1, $xr) = $c->_div($x1, $x1000);
+        $es = sprintf("%05o", $xr->[0]) . $es;
+    }
+    $es =~ s/^0*/0/;            # excactly one leading zero
+    return $es;
+}
+
+sub _from_oct {
+    # convert a octal number to decimal (string, return ref to array)
+    my ($c, $os) = @_;
+
+    my $m = $c->_new(1 << 30);          # 30 bits at a time (<32 bits!)
+    my $d = 10;                         # 10 octal digits at a time
+
+    my $mul = $c->_one();
+    my $x = $c->_zero();
+
+    my $len = int((length($os) - 1) / $d);      # $d digit parts, w/o the '0'
+    my $val;
+    my $i = -$d;
+    while ($len >= 0) {
+        $val = substr($os, $i, $d);             # get oct digits
+        $val = CORE::oct($val);
+        $i -= $d;
+        $len --;
+        my $adder = $c -> _new($val);
+        $c->_add($x, $c->_mul($adder, $mul)) if $val != 0;
+        $c->_mul($mul, $m) if $len >= 0;        # skip last mul
+    }
+    $x;
+}
+
+sub _from_hex {
+    # convert a hex number to decimal (string, return ref to array)
+    my ($c, $hs) = @_;
+
+    my $m = $c->_new(0x10000000);       # 28 bit at a time (<32 bit!)
+    my $d = 7;                          # 7 hexadecimal digits at a time
+    my $mul = $c->_one();
+    my $x = $c->_zero();
+
+    my $len = int((length($hs) - 2) / $d); # $d digit parts, w/o the '0x'
+    my $val;
+    my $i = -$d;
+    while ($len >= 0) {
+        $val = substr($hs, $i, $d);     # get hex digits
+        $val =~ s/^0x// if $len == 0; # for last part only because
+        $val = CORE::hex($val);       # hex does not like wrong chars
+        $i -= $d;
+        $len --;
+        my $adder = $c->_new($val);
+        # if the resulting number was to big to fit into one element, create a
+        # two-element version (bug found by Mark Lakata - Thanx!)
+        if (CORE::length($val) > $BASE_LEN) {
+            $adder = $c->_new($val);
+        }
+        $c->_add($x, $c->_mul($adder, $mul)) if $val != 0;
+        $c->_mul($mul, $m) if $len >= 0; # skip last mul
+    }
+    $x;
+}
+
+sub _from_bin {
+    # convert a hex number to decimal (string, return ref to array)
+    my ($c, $bs) = @_;
+
+    # instead of converting X (8) bit at a time, it is faster to "convert" the
+    # number to hex, and then call _from_hex.
+
+    my $hs = $bs;
+    $hs =~ s/^[+-]?0b//;                                # remove sign and 0b
+    my $l = length($hs);                                # bits
+    $hs = '0' x (8 - ($l % 8)) . $hs if ($l % 8) != 0;  # padd left side w/ 0
+    my $h = '0x' . unpack('H*', pack ('B*', $hs));      # repack as hex
+
+    $c->_from_hex($h);
+}
+
+##############################################################################
+# special modulus functions
+
+sub _modinv {
+
+    # modular multiplicative inverse
+    my ($c, $x, $y) = @_;
+
+    # modulo zero
+    if ($c->_is_zero($y)) {
+        return;
+    }
+
+    # modulo one
+    if ($c->_is_one($y)) {
+        return $c->_zero(), '+';
+    }
+
+    my $u = $c->_zero();
+    my $v = $c->_one();
+    my $a = $c->_copy($y);
+    my $b = $c->_copy($x);
+
+    # Euclid's Algorithm for bgcd(), only that we calc bgcd() ($a) and the result
+    # ($u) at the same time. See comments in BigInt for why this works.
+    my $q;
+    my $sign = 1;
+    {
+        ($a, $q, $b) = ($b, $c->_div($a, $b));          # step 1
+        last if $c->_is_zero($b);
+
+        my $t = $c->_add(                               # step 2:
+                         $c->_mul($c->_copy($v), $q),   #  t =   v * q
+                         $u);                           #      + u
+        $u = $v;                                        #  u = v
+        $v = $t;                                        #  v = t
+        $sign = -$sign;
+        redo;
+    }
+
+    # if the gcd is not 1, then return NaN
+    return unless $c->_is_one($a);
+
+    ($v, $sign == 1 ? '+' : '-');
+}
+
+sub _modpow {
+    # modulus of power ($x ** $y) % $z
+    my ($c, $num, $exp, $mod) = @_;
+
+    # a^b (mod 1) = 0 for all a and b
+    if ($c->_is_one($mod)) {
+        @$num = 0;
+        return $num;
+    }
+
+    # 0^a (mod m) = 0 if m != 0, a != 0
+    # 0^0 (mod m) = 1 if m != 0
+    if ($c->_is_zero($num)) {
+        if ($c->_is_zero($exp)) {
+            @$num = 1;
+        } else {
+            @$num = 0;
+        }
+        return $num;
+    }
+
+    # We could do the following, but it doesn't actually save any time. The
+    # _copy() is needed in case $num and $mod are the same object.
+    #$num = $c->_mod($c->_copy($num), $mod);
+
+    my $acc = $c->_copy($num);
+    my $t = $c->_one();
+
+    my $expbin = $c->_to_bin($exp);
+    my $len = length($expbin);
+    while ($len--) {
+        if (substr($expbin, $len, 1) eq '1') {  # if odd
+            $t = $c->_mul($t, $acc);
+            $t = $c->_mod($t, $mod);
+        }
+        $acc = $c->_mul($acc, $acc);
+        $acc = $c->_mod($acc, $mod);
+    }
+    @$num = @$t;
+    $num;
+}
+
+sub _gcd {
+    # Greatest common divisor.
+
+    my ($c, $x, $y) = @_;
+
+    # gcd(0, 0) = 0
+    # gcd(0, a) = a, if a != 0
+
+    if (@$x == 1 && $x->[0] == 0) {
+        if (@$y == 1 && $y->[0] == 0) {
+            @$x = 0;
+        } else {
+            @$x = @$y;
+        }
+        return $x;
+    }
+
+    # Until $y is zero ...
+
+    until (@$y == 1 && $y->[0] == 0) {
+
+        # Compute remainder.
+
+        $c->_mod($x, $y);
+
+        # Swap $x and $y.
+
+        my $tmp = $c->_copy($x);
+        @$x = @$y;
+        $y = $tmp;              # no deref here; that would modify input $y
+    }
+
+    return $x;
+}
+
+1;
+
+=pod
+
+=head1 NAME
+
+Math::BigInt::Calc - pure Perl module to support Math::BigInt
+
+=head1 SYNOPSIS
+
+    # to use it with Math::BigInt
+    use Math::BigInt lib => 'Calc';
+
+    # to use it with Math::BigFloat
+    use Math::BigFloat lib => 'Calc';
+
+    # to use it with Math::BigRat
+    use Math::BigRat lib => 'Calc';
+
+    # explicitly set base length and whether to "use integer"
+    use Math::BigInt::Calc base_len => 4, use_int => 1;
+    use Math::BigInt lib => 'Calc';
+
+=head1 DESCRIPTION
+
+Math::BigInt::Calc inherits from Math::BigInt::Lib.
+
+In this library, the numbers are represented interenally in base B = 10**N,
+where N is the largest possible integer that does not cause overflow in the
+intermediate computations. The base B elements are stored in an array, with the
+least significant element stored in array element zero. There are no leading
+zero elements, except a single zero element when the number is zero. For
+instance, if B = 10000, the number 1234567890 is represented internally as
+[7890, 3456, 12].
+
+=head1 OPTIONS
+
+When the module is loaded, it computes the maximum exponent, i.e., power of 10,
+that can be used with and without "use integer" in the computations. The default
+is to use this maximum exponent. If the combination of the 'base_len' value and
+the 'use_int' value exceeds the maximum value, an error is thrown.
+
+=over 4
+
+=item base_len
+
+The base length can be specified explicitly with the 'base_len' option. The
+value must be a positive integer.
+
+    use Math::BigInt::Calc base_len => 4;  # use 10000 as internal base
+
+=item use_int
+
+This option is used to specify whether "use integer" should be used in the
+internal computations. The value is interpreted as a boolean value, so use 0 or
+"" for false and anything else for true. If the 'base_len' is not specified
+together with 'use_int', the current value for the base length is used.
+
+    use Math::BigInt::Calc use_int => 1;   # use "use integer" internally
+
+=back
+
+=head1 METHODS
+
+This overview constains only the methods that are specific to
+C<Math::BigInt::Calc>. For the other methods, see L<Math::BigInt::Lib>.
+
+=over 4
+
+=item _base_len()
+
+Specify the desired base length and whether to enable "use integer" in the
+computations.
+
+    Math::BigInt::Calc -> _base_len($base_len, $use_int);
+
+Note that it is better to specify the base length and whether to use integers as
+options when the module is loaded, for example like this
+
+    use Math::BigInt::Calc base_len => 6, use_int => 1;
+
+=back
+
+=head1 SEE ALSO
+
+L<Math::BigInt::Lib> for a description of the API.
+
+Alternative libraries L<Math::BigInt::FastCalc>, L<Math::BigInt::GMP>,
+L<Math::BigInt::Pari>, L<Math::BigInt::GMPz>, and L<Math::BigInt::BitVect>.
+
+Some of the modules that use these libraries L<Math::BigInt>,
+L<Math::BigFloat>, and L<Math::BigRat>.
+
+=cut

git/usr/share/perl5/core_perl/Math/BigInt/Lib.pm

@@ -0,0 +1,2773 @@
+package Math::BigInt::Lib;
+
+use 5.006001;
+use strict;
+use warnings;
+
+our $VERSION = '2.005002';
+$VERSION =~ tr/_//d;
+
+use Carp;
+
+use overload
+
+  # overload key: with_assign
+
+  '+'    => sub {
+                my $class = ref $_[0];
+                my $x = $class -> _copy($_[0]);
+                my $y = ref($_[1]) ? $_[1] : $class -> _new($_[1]);
+                return $class -> _add($x, $y);
+            },
+
+  '-'    => sub {
+                my $class = ref $_[0];
+                my ($x, $y);
+                if ($_[2]) {            # if swapped
+                    $y = $_[0];
+                    $x = ref($_[1]) ? $_[1] : $class -> _new($_[1]);
+                } else {
+                    $x = $class -> _copy($_[0]);
+                    $y = ref($_[1]) ? $_[1] : $class -> _new($_[1]);
+                }
+                return $class -> _sub($x, $y);
+            },
+
+  '*'    => sub {
+                my $class = ref $_[0];
+                my $x = $class -> _copy($_[0]);
+                my $y = ref($_[1]) ? $_[1] : $class -> _new($_[1]);
+                return $class -> _mul($x, $y);
+            },
+
+  '/'    => sub {
+                my $class = ref $_[0];
+                my ($x, $y);
+                if ($_[2]) {            # if swapped
+                    $y = $_[0];
+                    $x = ref($_[1]) ? $_[1] : $class -> _new($_[1]);
+                } else {
+                    $x = $class -> _copy($_[0]);
+                    $y = ref($_[1]) ? $_[1] : $class -> _new($_[1]);
+                }
+                return $class -> _div($x, $y);
+            },
+
+  '%'    => sub {
+                my $class = ref $_[0];
+                my ($x, $y);
+                if ($_[2]) {            # if swapped
+                    $y = $_[0];
+                    $x = ref($_[1]) ? $_[1] : $class -> _new($_[1]);
+                } else {
+                    $x = $class -> _copy($_[0]);
+                    $y = ref($_[1]) ? $_[1] : $class -> _new($_[1]);
+                }
+                return $class -> _mod($x, $y);
+            },
+
+  '**'   => sub {
+                my $class = ref $_[0];
+                my ($x, $y);
+                if ($_[2]) {            # if swapped
+                    $y = $_[0];
+                    $x = ref($_[1]) ? $_[1] : $class -> _new($_[1]);
+                } else {
+                    $x = $class -> _copy($_[0]);
+                    $y = ref($_[1]) ? $_[1] : $class -> _new($_[1]);
+                }
+                return $class -> _pow($x, $y);
+            },
+
+  '<<'   => sub {
+                my $class = ref $_[0];
+                my ($x, $y);
+                if ($_[2]) {            # if swapped
+                    $y = $class -> _num($_[0]);
+                    $x = ref($_[1]) ? $_[1] : $class -> _new($_[1]);
+                } else {
+                    $x = $_[0];
+                    $y = ref($_[1]) ? $class -> _num($_[1]) : $_[1];
+                }
+                return $class -> _lsft($x, $y);
+            },
+
+  '>>'   => sub {
+                my $class = ref $_[0];
+                my ($x, $y);
+                if ($_[2]) {            # if swapped
+                    $y = $_[0];
+                    $x = ref($_[1]) ? $_[1] : $class -> _new($_[1]);
+                } else {
+                    $x = $class -> _copy($_[0]);
+                    $y = ref($_[1]) ? $_[1] : $class -> _new($_[1]);
+                }
+                return $class -> _rsft($x, $y);
+            },
+
+  # overload key: num_comparison
+
+  '<'    => sub {
+                my $class = ref $_[0];
+                my ($x, $y);
+                if ($_[2]) {            # if swapped
+                    $y = $_[0];
+                    $x = ref($_[1]) ? $_[1] : $class -> _new($_[1]);
+                } else {
+                    $x = $class -> _copy($_[0]);
+                    $y = ref($_[1]) ? $_[1] : $class -> _new($_[1]);
+                }
+                return $class -> _acmp($x, $y) < 0;
+            },
+
+  '<='   => sub {
+                my $class = ref $_[0];
+                my ($x, $y);
+                if ($_[2]) {            # if swapped
+                    $y = $_[0];
+                    $x = ref($_[1]) ? $_[1] : $class -> _new($_[1]);
+                } else {
+                    $x = $class -> _copy($_[0]);
+                    $y = ref($_[1]) ? $_[1] : $class -> _new($_[1]);
+                }
+                return $class -> _acmp($x, $y) <= 0;
+            },
+
+  '>'    => sub {
+                my $class = ref $_[0];
+                my ($x, $y);
+                if ($_[2]) {            # if swapped
+                    $y = $_[0];
+                    $x = ref($_[1]) ? $_[1] : $class -> _new($_[1]);
+                } else {
+                    $x = $class -> _copy($_[0]);
+                    $y = ref($_[1]) ? $_[1] : $class -> _new($_[1]);
+                }
+                return $class -> _acmp($x, $y) > 0;
+            },
+
+  '>='   => sub {
+                my $class = ref $_[0];
+                my ($x, $y);
+                if ($_[2]) {            # if swapped
+                    $y = $_[0];
+                    $x = ref($_[1]) ? $_[1] : $class -> _new($_[1]);
+                } else {
+                    $x = $class -> _copy($_[0]);
+                    $y = ref($_[1]) ? $_[1] : $class -> _new($_[1]);
+                }
+                return $class -> _acmp($x, $y) >= 0;
+          },
+
+  '=='   => sub {
+                my $class = ref $_[0];
+                my $x = $class -> _copy($_[0]);
+                my $y = ref($_[1]) ? $_[1] : $class -> _new($_[1]);
+                return $class -> _acmp($x, $y) == 0;
+            },
+
+  '!='   => sub {
+                my $class = ref $_[0];
+                my $x = $class -> _copy($_[0]);
+                my $y = ref($_[1]) ? $_[1] : $class -> _new($_[1]);
+                return $class -> _acmp($x, $y) != 0;
+            },
+
+  # overload key: 3way_comparison
+
+  '<=>'  => sub {
+                my $class = ref $_[0];
+                my ($x, $y);
+                if ($_[2]) {            # if swapped
+                    $y = $_[0];
+                    $x = ref($_[1]) ? $_[1] : $class -> _new($_[1]);
+                } else {
+                    $x = $class -> _copy($_[0]);
+                    $y = ref($_[1]) ? $_[1] : $class -> _new($_[1]);
+                }
+                return $class -> _acmp($x, $y);
+            },
+
+  # overload key: binary
+
+  '&'    => sub {
+                my $class = ref $_[0];
+                my ($x, $y);
+                if ($_[2]) {            # if swapped
+                    $y = $_[0];
+                    $x = ref($_[1]) ? $_[1] : $class -> _new($_[1]);
+                } else {
+                    $x = $class -> _copy($_[0]);
+                    $y = ref($_[1]) ? $_[1] : $class -> _new($_[1]);
+                }
+                return $class -> _and($x, $y);
+            },
+
+  '|'    => sub {
+                my $class = ref $_[0];
+                my ($x, $y);
+                if ($_[2]) {            # if swapped
+                    $y = $_[0];
+                    $x = ref($_[1]) ? $_[1] : $class -> _new($_[1]);
+                } else {
+                    $x = $class -> _copy($_[0]);
+                    $y = ref($_[1]) ? $_[1] : $class -> _new($_[1]);
+                }
+                return $class -> _or($x, $y);
+            },
+
+  '^'    => sub {
+                my $class = ref $_[0];
+                my ($x, $y);
+                if ($_[2]) {            # if swapped
+                    $y = $_[0];
+                    $x = ref($_[1]) ? $_[1] : $class -> _new($_[1]);
+                } else {
+                    $x = $class -> _copy($_[0]);
+                    $y = ref($_[1]) ? $_[1] : $class -> _new($_[1]);
+                }
+                return $class -> _xor($x, $y);
+            },
+
+  # overload key: func
+
+  'abs'  => sub { $_[0] },
+
+  'sqrt' => sub {
+                my $class = ref $_[0];
+                return $class -> _sqrt($class -> _copy($_[0]));
+            },
+
+  'int'  => sub { $_[0] },
+
+  # overload key: conversion
+
+  'bool' => sub { ref($_[0]) -> _is_zero($_[0]) ? '' : 1; },
+
+  '""'   => sub { ref($_[0]) -> _str($_[0]); },
+
+  '0+'   => sub { ref($_[0]) -> _num($_[0]); },
+
+  '='    => sub { ref($_[0]) -> _copy($_[0]); },
+
+  ;
+
+sub _new {
+    croak "@{[(caller 0)[3]]} method not implemented";
+}
+
+sub _zero {
+    my $class = shift;
+    return $class -> _new("0");
+}
+
+sub _one {
+    my $class = shift;
+    return $class -> _new("1");
+}
+
+sub _two {
+    my $class = shift;
+    return $class -> _new("2");
+
+}
+sub _ten {
+    my $class = shift;
+    return $class -> _new("10");
+}
+
+sub _1ex {
+    my ($class, $exp) = @_;
+    $exp = $class -> _num($exp) if ref($exp);
+    return $class -> _new("1" . ("0" x $exp));
+}
+
+sub _copy {
+    my ($class, $x) = @_;
+    return $class -> _new($class -> _str($x));
+}
+
+# catch and throw away
+sub import { }
+
+##############################################################################
+# convert back to string and number
+
+sub _str {
+    # Convert number from internal base 1eN format to string format. Internal
+    # format is always normalized, i.e., no leading zeros.
+    croak "@{[(caller 0)[3]]} method not implemented";
+}
+
+sub _num {
+    my ($class, $x) = @_;
+    0 + $class -> _str($x);
+}
+
+##############################################################################
+# actual math code
+
+sub _add {
+    croak "@{[(caller 0)[3]]} method not implemented";
+}
+
+sub _sub {
+    croak "@{[(caller 0)[3]]} method not implemented";
+}
+
+sub _mul {
+    my ($class, $x, $y) = @_;
+    my $sum = $class -> _zero();
+    my $i   = $class -> _zero();
+    while ($class -> _acmp($i, $y) < 0) {
+        $sum = $class -> _add($sum, $x);
+        $i   = $class -> _inc($i);
+    }
+    return $sum;
+}
+
+sub _div {
+    my ($class, $x, $y) = @_;
+
+    croak "@{[(caller 0)[3]]} requires non-zero divisor"
+      if $class -> _is_zero($y);
+
+    my $r = $class -> _copy($x);
+    my $q = $class -> _zero();
+    while ($class -> _acmp($r, $y) >= 0) {
+        $q = $class -> _inc($q);
+        $r = $class -> _sub($r, $y);
+    }
+
+    return $q, $r if wantarray;
+    return $q;
+}
+
+sub _inc {
+    my ($class, $x) = @_;
+    $class -> _add($x, $class -> _one());
+}
+
+sub _dec {
+    my ($class, $x) = @_;
+    $class -> _sub($x, $class -> _one());
+}
+
+# Signed addition. If the flag is false, $xa might be modified, but not $ya. If
+# the false is true, $ya might be modified, but not $xa.
+
+sub _sadd {
+    my $class = shift;
+    my ($xa, $xs, $ya, $ys, $flag) = @_;
+    my ($za, $zs);
+
+    # If the signs are equal we can add them (-5 + -3 => -(5 + 3) => -8)
+
+    if ($xs eq $ys) {
+        if ($flag) {
+            $za = $class -> _add($ya, $xa);
+        } else {
+            $za = $class -> _add($xa, $ya);
+        }
+        $zs = $class -> _is_zero($za) ? '+' : $xs;
+        return $za, $zs;
+    }
+
+    my $acmp = $class -> _acmp($xa, $ya);       # abs(x) = abs(y)
+
+    if ($acmp == 0) {                           # x = -y or -x = y
+        $za = $class -> _zero();
+        $zs = '+';
+        return $za, $zs;
+    }
+
+    if ($acmp > 0) {                            # abs(x) > abs(y)
+        $za = $class -> _sub($xa, $ya, $flag);
+        $zs = $xs;
+    } else {                                    # abs(x) < abs(y)
+        $za = $class -> _sub($ya, $xa, !$flag);
+        $zs = $ys;
+    }
+    return $za, $zs;
+}
+
+# Signed subtraction. If the flag is false, $xa might be modified, but not $ya.
+# If the false is true, $ya might be modified, but not $xa.
+
+sub _ssub {
+    my $class = shift;
+    my ($xa, $xs, $ya, $ys, $flag) = @_;
+
+    # Swap sign of second operand and let _sadd() do the job.
+    $ys = $ys eq '+' ? '-' : '+';
+    $class -> _sadd($xa, $xs, $ya, $ys, $flag);
+}
+
+##############################################################################
+# testing
+
+sub _acmp {
+    # Compare two (absolute) values. Return -1, 0, or 1.
+    my ($class, $x, $y) = @_;
+    my $xstr = $class -> _str($x);
+    my $ystr = $class -> _str($y);
+
+    length($xstr) <=> length($ystr) || $xstr cmp $ystr;
+}
+
+sub _scmp {
+    # Compare two signed values. Return -1, 0, or 1.
+    my ($class, $xa, $xs, $ya, $ys) = @_;
+    if ($xs eq '+') {
+        if ($ys eq '+') {
+            return $class -> _acmp($xa, $ya);
+        } else {
+            return 1;
+        }
+    } else {
+        if ($ys eq '+') {
+            return -1;
+        } else {
+            return $class -> _acmp($ya, $xa);
+        }
+    }
+}
+
+sub _len {
+    my ($class, $x) = @_;
+    CORE::length($class -> _str($x));
+}
+
+sub _alen {
+    my ($class, $x) = @_;
+    $class -> _len($x);
+}
+
+sub _digit {
+    my ($class, $x, $n) = @_;
+    substr($class ->_str($x), -($n+1), 1);
+}
+
+sub _digitsum {
+    my ($class, $x) = @_;
+
+    my $len = $class -> _len($x);
+    my $sum = $class -> _zero();
+    for (my $i = 0 ; $i < $len ; ++$i) {
+        my $digit = $class -> _digit($x, $i);
+        $digit = $class -> _new($digit);
+        $sum = $class -> _add($sum, $digit);
+    }
+
+    return $sum;
+}
+
+sub _zeros {
+    my ($class, $x) = @_;
+    my $str = $class -> _str($x);
+    $str =~ /[^0](0*)\z/ ? CORE::length($1) : 0;
+}
+
+##############################################################################
+# _is_* routines
+
+sub _is_zero {
+    # return true if arg is zero
+    my ($class, $x) = @_;
+    $class -> _str($x) == 0;
+}
+
+sub _is_even {
+    # return true if arg is even
+    my ($class, $x) = @_;
+    substr($class -> _str($x), -1, 1) % 2 == 0;
+}
+
+sub _is_odd {
+    # return true if arg is odd
+    my ($class, $x) = @_;
+    substr($class -> _str($x), -1, 1) % 2 != 0;
+}
+
+sub _is_one {
+    # return true if arg is one
+    my ($class, $x) = @_;
+    $class -> _str($x) == 1;
+}
+
+sub _is_two {
+    # return true if arg is two
+    my ($class, $x) = @_;
+    $class -> _str($x) == 2;
+}
+
+sub _is_ten {
+    # return true if arg is ten
+    my ($class, $x) = @_;
+    $class -> _str($x) == 10;
+}
+
+###############################################################################
+# check routine to test internal state for corruptions
+
+sub _check {
+    # used by the test suite
+    my ($class, $x) = @_;
+    return "Input is undefined" unless defined $x;
+    return "$x is not a reference" unless ref($x);
+    return 0;
+}
+
+###############################################################################
+
+sub _mod {
+    # modulus
+    my ($class, $x, $y) = @_;
+
+    croak "@{[(caller 0)[3]]} requires non-zero second operand"
+      if $class -> _is_zero($y);
+
+    if ($class -> can('_div')) {
+        $x = $class -> _copy($x);
+        my ($q, $r) = $class -> _div($x, $y);
+        return $r;
+    } else {
+        my $r = $class -> _copy($x);
+        while ($class -> _acmp($r, $y) >= 0) {
+            $r = $class -> _sub($r, $y);
+        }
+        return $r;
+    }
+}
+
+##############################################################################
+# shifts
+
+sub _rsft {
+    my ($class, $x, $n, $b) = @_;
+    $b = $class -> _new($b) unless ref $b;
+    return scalar $class -> _div($x, $class -> _pow($class -> _copy($b), $n));
+}
+
+sub _lsft {
+    my ($class, $x, $n, $b) = @_;
+    $b = $class -> _new($b) unless ref $b;
+    return $class -> _mul($x, $class -> _pow($class -> _copy($b), $n));
+}
+
+sub _pow {
+    # power of $x to $y
+    my ($class, $x, $y) = @_;
+
+    if ($class -> _is_zero($y)) {
+        return $class -> _one();        # y == 0 => x => 1
+    }
+
+    if (($class -> _is_one($x)) ||      #    x == 1
+        ($class -> _is_one($y)))        # or y == 1
+    {
+        return $x;
+    }
+
+    if ($class -> _is_zero($x)) {
+        return $class -> _zero();       # 0 ** y => 0 (if not y <= 0)
+    }
+
+    my $pow2 = $class -> _one();
+
+    my $y_bin = $class -> _as_bin($y);
+    $y_bin =~ s/^0b//;
+    my $len = length($y_bin);
+
+    while (--$len > 0) {
+        $pow2 = $class -> _mul($pow2, $x) if substr($y_bin, $len, 1) eq '1';
+        $x = $class -> _mul($x, $x);
+    }
+
+    $x = $class -> _mul($x, $pow2);
+    return $x;
+}
+
+sub _nok {
+    # Return binomial coefficient (n over k).
+    my ($class, $n, $k) = @_;
+
+    # If k > n/2, or, equivalently, 2*k > n, compute nok(n, k) as
+    # nok(n, n-k), to minimize the number if iterations in the loop.
+
+    {
+        my $twok = $class -> _mul($class -> _two(), $class -> _copy($k));
+        if ($class -> _acmp($twok, $n) > 0) {
+            $k = $class -> _sub($class -> _copy($n), $k);
+        }
+    }
+
+    # Example:
+    #
+    # / 7 \       7!       1*2*3*4 * 5*6*7   5 * 6 * 7
+    # |   | = --------- =  --------------- = --------- = ((5 * 6) / 2 * 7) / 3
+    # \ 3 /   (7-3)! 3!    1*2*3*4 * 1*2*3   1 * 2 * 3
+    #
+    # Equivalently, _nok(11, 5) is computed as
+    #
+    # (((((((7 * 8) / 2) * 9) / 3) * 10) / 4) * 11) / 5
+
+    if ($class -> _is_zero($k)) {
+        return $class -> _one();
+    }
+
+    # Make a copy of the original n, in case the subclass modifies n in-place.
+
+    my $n_orig = $class -> _copy($n);
+
+    # n = 5, f = 6, d = 2 (cf. example above)
+
+    $n = $class -> _sub($n, $k);
+    $n = $class -> _inc($n);
+
+    my $f = $class -> _copy($n);
+    $f = $class -> _inc($f);
+
+    my $d = $class -> _two();
+
+    # while f <= n (the original n, that is) ...
+
+    while ($class -> _acmp($f, $n_orig) <= 0) {
+        $n = $class -> _mul($n, $f);
+        $n = $class -> _div($n, $d);
+        $f = $class -> _inc($f);
+        $d = $class -> _inc($d);
+    }
+
+    return $n;
+}
+
+#sub _fac {
+#    # factorial
+#    my ($class, $x) = @_;
+#
+#    my $two = $class -> _two();
+#
+#    if ($class -> _acmp($x, $two) < 0) {
+#        return $class -> _one();
+#    }
+#
+#    my $i = $class -> _copy($x);
+#    while ($class -> _acmp($i, $two) > 0) {
+#        $i = $class -> _dec($i);
+#        $x = $class -> _mul($x, $i);
+#    }
+#
+#    return $x;
+#}
+
+sub _fac {
+    # factorial
+    my ($class, $x) = @_;
+
+    # This is an implementation of the split recursive algorithm. See
+    # http://www.luschny.de/math/factorial/csharp/FactorialSplit.cs.html
+
+    my $p   = $class -> _one();
+    my $r   = $class -> _one();
+    my $two = $class -> _two();
+
+    my ($log2n) = $class -> _log_int($class -> _copy($x), $two);
+    my $h     = $class -> _zero();
+    my $shift = $class -> _zero();
+    my $k     = $class -> _one();
+
+    while ($class -> _acmp($h, $x)) {
+        $shift = $class -> _add($shift, $h);
+        $h = $class -> _rsft($class -> _copy($x), $log2n, $two);
+        $log2n = $class -> _dec($log2n) if !$class -> _is_zero($log2n);
+        my $high = $class -> _copy($h);
+        $high = $class -> _dec($high) if $class -> _is_even($h);
+        while ($class -> _acmp($k, $high)) {
+            $k = $class -> _add($k, $two);
+            $p = $class -> _mul($p, $k);
+        }
+        $r = $class -> _mul($r, $p);
+    }
+    return $class -> _lsft($r, $shift, $two);
+}
+
+sub _dfac {
+    # double factorial
+    my ($class, $x) = @_;
+
+    my $two = $class -> _two();
+
+    if ($class -> _acmp($x, $two) < 0) {
+        return $class -> _one();
+    }
+
+    my $i = $class -> _copy($x);
+    while ($class -> _acmp($i, $two) > 0) {
+        $i = $class -> _sub($i, $two);
+        $x = $class -> _mul($x, $i);
+    }
+
+    return $x;
+}
+
+sub _log_int {
+    # calculate integer log of $x to base $base
+    # calculate integer log of $x to base $base
+    # ref to array, ref to array - return ref to array
+    my ($class, $x, $base) = @_;
+
+    # X == 0 => NaN
+    return if $class -> _is_zero($x);
+
+    $base = $class -> _new(2)     unless defined($base);
+    $base = $class -> _new($base) unless ref($base);
+
+    # BASE 0 or 1 => NaN
+    return if $class -> _is_zero($base) || $class -> _is_one($base);
+
+    # X == 1 => 0 (is exact)
+    if ($class -> _is_one($x)) {
+        return $class -> _zero(), 1 if wantarray;
+        return $class -> _zero();
+    }
+
+    my $cmp = $class -> _acmp($x, $base);
+
+    # X == BASE => 1 (is exact)
+    if ($cmp == 0) {
+        return $class -> _one(), 1 if wantarray;
+        return $class -> _one();
+    }
+
+    # 1 < X < BASE => 0 (is truncated)
+    if ($cmp < 0) {
+        return $class -> _zero(), 0 if wantarray;
+        return $class -> _zero();
+    }
+
+    my $y;
+
+    # log(x) / log(b) = log(xm * 10^xe) / log(bm * 10^be)
+    #                 = (log(xm) + xe*(log(10))) / (log(bm) + be*log(10))
+
+    {
+        my $x_str = $class -> _str($x);
+        my $b_str = $class -> _str($base);
+        my $xm    = "." . $x_str;
+        my $bm    = "." . $b_str;
+        my $xe    = length($x_str);
+        my $be    = length($b_str);
+        my $log10 = log(10);
+        my $guess = int((log($xm) + $xe * $log10) / (log($bm) + $be * $log10));
+        $y = $class -> _new($guess);
+    }
+
+    my $trial = $class -> _pow($class -> _copy($base), $y);
+    my $acmp  = $class -> _acmp($trial, $x);
+
+    # Too small?
+
+    while ($acmp < 0) {
+        $trial = $class -> _mul($trial, $base);
+        $y     = $class -> _inc($y);
+        $acmp  = $class -> _acmp($trial, $x);
+    }
+
+    # Too big?
+
+    while ($acmp > 0) {
+        $trial = $class -> _div($trial, $base);
+        $y     = $class -> _dec($y);
+        $acmp  = $class -> _acmp($trial, $x);
+    }
+
+    return wantarray ? ($y, 1) : $y if $acmp == 0;      # result is exact
+    return wantarray ? ($y, 0) : $y;                    # result is too small
+}
+
+sub _ilog2 {
+    my ($class, $x) = @_;
+
+    return if $class -> _is_zero($x);
+
+    my $str = $class -> _to_hex($x);
+
+    # First do the bits in all but the most significant hex digit.
+
+    my $y = $class -> _new(length($str) - 1);
+    $y = $class -> _mul($y, $class -> _new(4));
+
+    # Now add the number of bits in the most significant hex digit.
+
+    my $n = int log(hex(substr($str, 0, 1))) / log(2);
+    $y = $class -> _add($y, $class -> _new($n));
+    return $y unless wantarray;
+
+    my $pow2 = $class -> _lsft($class -> _one(), $y, 2);
+    my $is_exact = $class -> _acmp($x, $pow2) == 0 ? 1 : 0;
+    return $y, $is_exact;
+}
+
+sub _ilog10 {
+    my ($class, $x) = @_;
+
+    return if $class -> _is_zero($x);
+
+    my $str = $class -> _str($x);
+    my $len = length($str);
+    my $y = $class -> _new($len - 1);
+    return $y unless wantarray;
+
+    #my $pow10 = $class -> _1ex($y);
+    #my $is_exact = $class -> _acmp($x, $pow10) ? 1 : 0;
+
+    my $is_exact = $str =~ /^10*$/ ? 1 : 0;
+    return $y, $is_exact;
+}
+
+sub _clog2 {
+    my ($class, $x) = @_;
+
+    return if $class -> _is_zero($x);
+
+    my $str = $class -> _to_hex($x);
+
+    # First do the bits in all but the most significant hex digit.
+
+    my $y = $class -> _new(length($str) - 1);
+    $y = $class -> _mul($y, $class -> _new(4));
+
+    # Now add the number of bits in the most significant hex digit.
+
+    my $n = int log(hex(substr($str, 0, 1))) / log(2);
+    $y = $class -> _add($y, $class -> _new($n));
+
+    # $y is now 1 too small unless $y is an exact power of 2.
+
+    my $pow2 = $class -> _lsft($class -> _one(), $y, 2);
+    my $is_exact = $class -> _acmp($x, $pow2) == 0 ? 1 : 0;
+    $y = $class -> _inc($y) if $is_exact == 0;
+    return $y, $is_exact if wantarray;
+    return $y;
+}
+
+sub _clog10 {
+    my ($class, $x) = @_;
+
+    return if $class -> _is_zero($x);
+
+    my $str = $class -> _str($x);
+    my $len = length($str);
+
+    if ($str =~ /^10*$/) {
+        my $y = $class -> _new($len - 1);
+        return $y, 1 if wantarray;
+        return $y;
+    }
+
+    my $y = $class -> _new($len);
+    return $y, 0 if wantarray;
+    return $y;
+}
+
+sub _sqrt {
+    # square-root of $y in place
+    my ($class, $y) = @_;
+
+    return $y if $class -> _is_zero($y);
+
+    my $y_str = $class -> _str($y);
+    my $y_len = length($y_str);
+
+    # Compute the guess $x.
+
+    my $xm;
+    my $xe;
+    if ($y_len % 2 == 0) {
+        $xm = sqrt("." . $y_str);
+        $xe = $y_len / 2;
+        $xm = sprintf "%.0f", int($xm * 1e15);
+        $xe -= 15;
+    } else {
+        $xm = sqrt(".0" . $y_str);
+        $xe = ($y_len + 1) / 2;
+        $xm = sprintf "%.0f", int($xm * 1e16);
+        $xe -= 16;
+    }
+
+    my $x;
+    if ($xe < 0) {
+        $x = substr $xm, 0, length($xm) + $xe;
+    } else {
+        $x = $xm . ("0" x $xe);
+    }
+
+    $x = $class -> _new($x);
+
+    # Newton's method for computing square root of y
+    #
+    # x(i+1) = x(i) - f(x(i)) / f'(x(i))
+    #        = x(i) - (x(i)^2 - y) / (2 * x(i))     # use if x(i)^2 > y
+    #        = x(i) + (y - x(i)^2) / (2 * x(i))     # use if x(i)^2 < y
+
+    # Determine if x, our guess, is too small, correct, or too large.
+
+    my $xsq = $class -> _mul($class -> _copy($x), $x);          # x(i)^2
+    my $acmp = $class -> _acmp($xsq, $y);                       # x(i)^2 <=> y
+
+    # Only assign a value to this variable if we will be using it.
+
+    my $two;
+    $two = $class -> _two() if $acmp != 0;
+
+    # If x is too small, do one iteration of Newton's method. Since the
+    # function f(x) = x^2 - y is concave and monotonically increasing, the next
+    # guess for x will either be correct or too large.
+
+    if ($acmp < 0) {
+
+        # x(i+1) = x(i) + (y - x(i)^2) / (2 * x(i))
+
+        my $numer = $class -> _sub($class -> _copy($y), $xsq);  # y - x(i)^2
+        my $denom = $class -> _mul($class -> _copy($two), $x);  # 2 * x(i)
+        my $delta = $class -> _div($numer, $denom);
+
+        unless ($class -> _is_zero($delta)) {
+            $x    = $class -> _add($x, $delta);
+            $xsq  = $class -> _mul($class -> _copy($x), $x);    # x(i)^2
+            $acmp = $class -> _acmp($xsq, $y);                  # x(i)^2 <=> y
+        }
+    }
+
+    # If our guess for x is too large, apply Newton's method repeatedly until
+    # we either have got the correct value, or the delta is zero.
+
+    while ($acmp > 0) {
+
+        # x(i+1) = x(i) - (x(i)^2 - y) / (2 * x(i))
+
+        my $numer = $class -> _sub($xsq, $y);                   # x(i)^2 - y
+        my $denom = $class -> _mul($class -> _copy($two), $x);  # 2 * x(i)
+        my $delta = $class -> _div($numer, $denom);
+        last if $class -> _is_zero($delta);
+
+        $x    = $class -> _sub($x, $delta);
+        $xsq  = $class -> _mul($class -> _copy($x), $x);        # x(i)^2
+        $acmp = $class -> _acmp($xsq, $y);                      # x(i)^2 <=> y
+    }
+
+    # When the delta is zero, our value for x might still be too large. We
+    # require that the outout is either exact or too small (i.e., rounded down
+    # to the nearest integer), so do a final check.
+
+    while ($acmp > 0) {
+        $x    = $class -> _dec($x);
+        $xsq  = $class -> _mul($class -> _copy($x), $x);        # x(i)^2
+        $acmp = $class -> _acmp($xsq, $y);                      # x(i)^2 <=> y
+    }
+
+    return $x;
+}
+
+sub _root {
+    my ($class, $y, $n) = @_;
+
+    return $y if $class -> _is_zero($y) || $class -> _is_one($y) ||
+                 $class -> _is_one($n);
+
+    # If y <= n, the result is always (truncated to) 1.
+
+    return $class -> _one() if $class -> _acmp($y, $n) <= 0;
+
+    # Compute the initial guess x of y^(1/n). When n is large, Newton's method
+    # converges slowly if the "guess" (initial value) is poor, so we need a
+    # good guess. It the guess is too small, the next guess will be too large,
+    # and from then on all guesses are too large.
+
+    my $DEBUG = 0;
+
+    # Split y into mantissa and exponent in base 10, so that
+    #
+    #   y = xm * 10^xe, where 0 < xm < 1 and xe is an integer
+
+    my $y_str  = $class -> _str($y);
+    my $ym = "." . $y_str;
+    my $ye = length($y_str);
+
+    # From this compute the approximate base 10 logarithm of y
+    #
+    #   log_10(y) = log_10(ym) + log_10(ye^10)
+    #             = log(ym)/log(10) + ye
+
+    my $log10y = log($ym) / log(10) + $ye;
+
+    # And from this compute the approximate base 10 logarithm of x, where
+    # x = y^(1/n)
+    #
+    #   log_10(x) = log_10(y)/n
+
+    my $log10x = $log10y / $class -> _num($n);
+
+    # From this compute xm and xe, the mantissa and exponent (in base 10) of x,
+    # where 1 < xm <= 10 and xe is an integer.
+
+    my $xe = int $log10x;
+    my $xm = 10 ** ($log10x - $xe);
+
+    # Scale the mantissa and exponent to increase the integer part of ym, which
+    # gives us better accuracy.
+
+    if ($DEBUG) {
+        print "\n";
+        print "y_str  = $y_str\n";
+        print "ym     = $ym\n";
+        print "ye     = $ye\n";
+        print "log10y = $log10y\n";
+        print "log10x = $log10x\n";
+        print "xm     = $xm\n";
+        print "xe     = $xe\n";
+    }
+
+    my $d = $xe < 15 ? $xe : 15;
+    $xm *= 10 ** $d;
+    $xe -= $d;
+
+    if ($DEBUG) {
+        print "\n";
+        print "xm     = $xm\n";
+        print "xe     = $xe\n";
+    }
+
+    # If the mantissa is not an integer, round up to nearest integer, and then
+    # convert the number to a string. It is important to always round up due to
+    # how Newton's method behaves in this case. If the initial guess is too
+    # small, the next guess will be too large, after which every succeeding
+    # guess converges the correct value from above. Now, if the initial guess
+    # is too small and n is large, the next guess will be much too large and
+    # require a large number of iterations to get close to the solution.
+    # Because of this, we are likely to find the solution faster if we make
+    # sure the initial guess is not too small.
+
+    my $xm_int = int($xm);
+    my $x_str = sprintf '%.0f', $xm > $xm_int ? $xm_int + 1 : $xm_int;
+    $x_str .= "0" x $xe;
+
+    my $x = $class -> _new($x_str);
+
+    if ($DEBUG) {
+        print "xm     = $xm\n";
+        print "xe     = $xe\n";
+        print "\n";
+        print "x_str  = $x_str (initial guess)\n";
+        print "\n";
+    }
+
+    # Use Newton's method for computing n'th root of y.
+    #
+    # x(i+1) = x(i) - f(x(i)) / f'(x(i))
+    #        = x(i) - (x(i)^n - y) / (n * x(i)^(n-1))   # use if x(i)^n > y
+    #        = x(i) + (y - x(i)^n) / (n * x(i)^(n-1))   # use if x(i)^n < y
+
+    # Determine if x, our guess, is too small, correct, or too large. Rather
+    # than computing x(i)^n and x(i)^(n-1) directly, compute x(i)^(n-1) and
+    # then the same value multiplied by x.
+
+    my $nm1     = $class -> _dec($class -> _copy($n));           # n-1
+    my $xpownm1 = $class -> _pow($class -> _copy($x), $nm1);     # x(i)^(n-1)
+    my $xpown   = $class -> _mul($class -> _copy($xpownm1), $x); # x(i)^n
+    my $acmp    = $class -> _acmp($xpown, $y);                   # x(i)^n <=> y
+
+    if ($DEBUG) {
+        print "\n";
+        print "x      = ", $class -> _str($x), "\n";
+        print "x^n    = ", $class -> _str($xpown), "\n";
+        print "y      = ", $class -> _str($y), "\n";
+        print "acmp   = $acmp\n";
+    }
+
+    # If x is too small, do one iteration of Newton's method. Since the
+    # function f(x) = x^n - y is concave and monotonically increasing, the next
+    # guess for x will either be correct or too large.
+
+    if ($acmp < 0) {
+
+        # x(i+1) = x(i) + (y - x(i)^n) / (n * x(i)^(n-1))
+
+        my $numer = $class -> _sub($class -> _copy($y), $xpown);    # y - x(i)^n
+        my $denom = $class -> _mul($class -> _copy($n), $xpownm1);  # n * x(i)^(n-1)
+        my $delta = $class -> _div($numer, $denom);
+
+        if ($DEBUG) {
+            print "\n";
+            print "numer  = ", $class -> _str($numer), "\n";
+            print "denom  = ", $class -> _str($denom), "\n";
+            print "delta  = ", $class -> _str($delta), "\n";
+        }
+
+        unless ($class -> _is_zero($delta)) {
+            $x       = $class -> _add($x, $delta);
+            $xpownm1 = $class -> _pow($class -> _copy($x), $nm1);     # x(i)^(n-1)
+            $xpown   = $class -> _mul($class -> _copy($xpownm1), $x); # x(i)^n
+            $acmp    = $class -> _acmp($xpown, $y);                   # x(i)^n <=> y
+
+            if ($DEBUG) {
+                print "\n";
+                print "x      = ", $class -> _str($x), "\n";
+                print "x^n    = ", $class -> _str($xpown), "\n";
+                print "y      = ", $class -> _str($y), "\n";
+                print "acmp   = $acmp\n";
+            }
+        }
+    }
+
+    # If our guess for x is too large, apply Newton's method repeatedly until
+    # we either have got the correct value, or the delta is zero.
+
+    while ($acmp > 0) {
+
+        # x(i+1) = x(i) - (x(i)^n - y) / (n * x(i)^(n-1))
+
+        my $numer = $class -> _sub($class -> _copy($xpown), $y);    # x(i)^n - y
+        my $denom = $class -> _mul($class -> _copy($n), $xpownm1);  # n * x(i)^(n-1)
+
+        if ($DEBUG) {
+            print "numer  = ", $class -> _str($numer), "\n";
+            print "denom  = ", $class -> _str($denom), "\n";
+        }
+
+        my $delta = $class -> _div($numer, $denom);
+
+        if ($DEBUG) {
+            print "delta  = ", $class -> _str($delta), "\n";
+        }
+
+        last if $class -> _is_zero($delta);
+
+        $x       = $class -> _sub($x, $delta);
+        $xpownm1 = $class -> _pow($class -> _copy($x), $nm1);     # x(i)^(n-1)
+        $xpown   = $class -> _mul($class -> _copy($xpownm1), $x); # x(i)^n
+        $acmp    = $class -> _acmp($xpown, $y);                   # x(i)^n <=> y
+
+        if ($DEBUG) {
+            print "\n";
+            print "x      = ", $class -> _str($x), "\n";
+            print "x^n    = ", $class -> _str($xpown), "\n";
+            print "y      = ", $class -> _str($y), "\n";
+            print "acmp   = $acmp\n";
+        }
+    }
+
+    # When the delta is zero, our value for x might still be too large. We
+    # require that the outout is either exact or too small (i.e., rounded down
+    # to the nearest integer), so do a final check.
+
+    while ($acmp > 0) {
+        $x     = $class -> _dec($x);
+        $xpown = $class -> _pow($class -> _copy($x), $n);     # x(i)^n
+        $acmp  = $class -> _acmp($xpown, $y);                 # x(i)^n <=> y
+    }
+
+    return $x;
+}
+
+##############################################################################
+# binary stuff
+
+sub _and {
+    my ($class, $x, $y) = @_;
+
+    return $x if $class -> _acmp($x, $y) == 0;
+
+    my $m    = $class -> _one();
+    my $mask = $class -> _new("32768");
+
+    my ($xr, $yr);                # remainders after division
+
+    my $xc = $class -> _copy($x);
+    my $yc = $class -> _copy($y);
+    my $z  = $class -> _zero();
+
+    until ($class -> _is_zero($xc) || $class -> _is_zero($yc)) {
+        ($xc, $xr) = $class -> _div($xc, $mask);
+        ($yc, $yr) = $class -> _div($yc, $mask);
+        my $bits = $class -> _new($class -> _num($xr) & $class -> _num($yr));
+        $z = $class -> _add($z, $class -> _mul($bits, $m));
+        $m = $class -> _mul($m, $mask);
+    }
+
+    return $z;
+}
+
+sub _xor {
+    my ($class, $x, $y) = @_;
+
+    return $class -> _zero() if $class -> _acmp($x, $y) == 0;
+
+    my $m    = $class -> _one();
+    my $mask = $class -> _new("32768");
+
+    my ($xr, $yr);                # remainders after division
+
+    my $xc = $class -> _copy($x);
+    my $yc = $class -> _copy($y);
+    my $z  = $class -> _zero();
+
+    until ($class -> _is_zero($xc) || $class -> _is_zero($yc)) {
+        ($xc, $xr) = $class -> _div($xc, $mask);
+        ($yc, $yr) = $class -> _div($yc, $mask);
+        my $bits = $class -> _new($class -> _num($xr) ^ $class -> _num($yr));
+        $z = $class -> _add($z, $class -> _mul($bits, $m));
+        $m = $class -> _mul($m, $mask);
+    }
+
+    # The loop above stops when the smallest of the two numbers is exhausted.
+    # The remainder of the longer one will survive bit-by-bit, so we simple
+    # multiply-add it in.
+
+    $z = $class -> _add($z, $class -> _mul($xc, $m))
+      unless $class -> _is_zero($xc);
+    $z = $class -> _add($z, $class -> _mul($yc, $m))
+      unless $class -> _is_zero($yc);
+
+    return $z;
+}
+
+sub _or {
+    my ($class, $x, $y) = @_;
+
+    return $x if $class -> _acmp($x, $y) == 0; # shortcut (see _and)
+
+    my $m    = $class -> _one();
+    my $mask = $class -> _new("32768");
+
+    my ($xr, $yr);                # remainders after division
+
+    my $xc = $class -> _copy($x);
+    my $yc = $class -> _copy($y);
+    my $z  = $class -> _zero();
+
+    until ($class -> _is_zero($xc) || $class -> _is_zero($yc)) {
+        ($xc, $xr) = $class -> _div($xc, $mask);
+        ($yc, $yr) = $class -> _div($yc, $mask);
+        my $bits = $class -> _new($class -> _num($xr) | $class -> _num($yr));
+        $z = $class -> _add($z, $class -> _mul($bits, $m));
+        $m = $class -> _mul($m, $mask);
+    }
+
+    # The loop above stops when the smallest of the two numbers is exhausted.
+    # The remainder of the longer one will survive bit-by-bit, so we simple
+    # multiply-add it in.
+
+    $z = $class -> _add($z, $class -> _mul($xc, $m))
+      unless $class -> _is_zero($xc);
+    $z = $class -> _add($z, $class -> _mul($yc, $m))
+      unless $class -> _is_zero($yc);
+
+    return $z;
+}
+
+sub _sand {
+    my ($class, $x, $sx, $y, $sy) = @_;
+
+    return ($class -> _zero(), '+')
+      if $class -> _is_zero($x) || $class -> _is_zero($y);
+
+    my $sign = $sx eq '-' && $sy eq '-' ? '-' : '+';
+
+    my ($bx, $by);
+
+    if ($sx eq '-') {                   # if x is negative
+        # two's complement: inc (dec unsigned value) and flip all "bits" in $bx
+        $bx = $class -> _copy($x);
+        $bx = $class -> _dec($bx);
+        $bx = $class -> _as_hex($bx);
+        $bx =~ s/^-?0x//;
+        $bx =~ tr<0123456789abcdef>
+                <\x0f\x0e\x0d\x0c\x0b\x0a\x09\x08\x07\x06\x05\x04\x03\x02\x01\x00>;
+    } else {                            # if x is positive
+        $bx = $class -> _as_hex($x);    # get binary representation
+        $bx =~ s/^-?0x//;
+        $bx =~ tr<fedcba9876543210>
+                 <\x0f\x0e\x0d\x0c\x0b\x0a\x09\x08\x07\x06\x05\x04\x03\x02\x01\x00>;
+    }
+
+    if ($sy eq '-') {                   # if y is negative
+        # two's complement: inc (dec unsigned value) and flip all "bits" in $by
+        $by = $class -> _copy($y);
+        $by = $class -> _dec($by);
+        $by = $class -> _as_hex($by);
+        $by =~ s/^-?0x//;
+        $by =~ tr<0123456789abcdef>
+                <\x0f\x0e\x0d\x0c\x0b\x0a\x09\x08\x07\x06\x05\x04\x03\x02\x01\x00>;
+    } else {
+        $by = $class -> _as_hex($y);    # get binary representation
+        $by =~ s/^-?0x//;
+        $by =~ tr<fedcba9876543210>
+                <\x0f\x0e\x0d\x0c\x0b\x0a\x09\x08\x07\x06\x05\x04\x03\x02\x01\x00>;
+    }
+
+    # now we have bit-strings from X and Y, reverse them for padding
+    $bx = reverse $bx;
+    $by = reverse $by;
+
+    # padd the shorter string
+    my $xx = "\x00"; $xx = "\x0f" if $sx eq '-';
+    my $yy = "\x00"; $yy = "\x0f" if $sy eq '-';
+    my $diff = CORE::length($bx) - CORE::length($by);
+    if ($diff > 0) {
+        # if $yy eq "\x00", we can cut $bx, otherwise we need to padd $by
+        $by .= $yy x $diff;
+    } elsif ($diff < 0) {
+        # if $xx eq "\x00", we can cut $by, otherwise we need to padd $bx
+        $bx .= $xx x abs($diff);
+    }
+
+    # and the strings together
+    my $r = $bx & $by;
+
+    # and reverse the result again
+    $bx = reverse $r;
+
+    # One of $bx or $by was negative, so need to flip bits in the result. In both
+    # cases (one or two of them negative, or both positive) we need to get the
+    # characters back.
+    if ($sign eq '-') {
+        $bx =~ tr<\x0f\x0e\x0d\x0c\x0b\x0a\x09\x08\x07\x06\x05\x04\x03\x02\x01\x00>
+                 <0123456789abcdef>;
+    } else {
+        $bx =~ tr<\x0f\x0e\x0d\x0c\x0b\x0a\x09\x08\x07\x06\x05\x04\x03\x02\x01\x00>
+                 <fedcba9876543210>;
+    }
+
+    # leading zeros will be stripped by _from_hex()
+    $bx = '0x' . $bx;
+    $bx = $class -> _from_hex($bx);
+
+    $bx = $class -> _inc($bx) if $sign eq '-';
+
+    # avoid negative zero
+    $sign = '+' if $class -> _is_zero($bx);
+
+    return $bx, $sign;
+}
+
+sub _sxor {
+    my ($class, $x, $sx, $y, $sy) = @_;
+
+    return ($class -> _zero(), '+')
+      if $class -> _is_zero($x) && $class -> _is_zero($y);
+
+    my $sign = $sx ne $sy ? '-' : '+';
+
+    my ($bx, $by);
+
+    if ($sx eq '-') {                   # if x is negative
+        # two's complement: inc (dec unsigned value) and flip all "bits" in $bx
+        $bx = $class -> _copy($x);
+        $bx = $class -> _dec($bx);
+        $bx = $class -> _as_hex($bx);
+        $bx =~ s/^-?0x//;
+        $bx =~ tr<0123456789abcdef>
+                <\x0f\x0e\x0d\x0c\x0b\x0a\x09\x08\x07\x06\x05\x04\x03\x02\x01\x00>;
+    } else {                            # if x is positive
+        $bx = $class -> _as_hex($x);    # get binary representation
+        $bx =~ s/^-?0x//;
+        $bx =~ tr<fedcba9876543210>
+                 <\x0f\x0e\x0d\x0c\x0b\x0a\x09\x08\x07\x06\x05\x04\x03\x02\x01\x00>;
+    }
+
+    if ($sy eq '-') {                   # if y is negative
+        # two's complement: inc (dec unsigned value) and flip all "bits" in $by
+        $by = $class -> _copy($y);
+        $by = $class -> _dec($by);
+        $by = $class -> _as_hex($by);
+        $by =~ s/^-?0x//;
+        $by =~ tr<0123456789abcdef>
+                <\x0f\x0e\x0d\x0c\x0b\x0a\x09\x08\x07\x06\x05\x04\x03\x02\x01\x00>;
+    } else {
+        $by = $class -> _as_hex($y);    # get binary representation
+        $by =~ s/^-?0x//;
+        $by =~ tr<fedcba9876543210>
+                <\x0f\x0e\x0d\x0c\x0b\x0a\x09\x08\x07\x06\x05\x04\x03\x02\x01\x00>;
+    }
+
+    # now we have bit-strings from X and Y, reverse them for padding
+    $bx = reverse $bx;
+    $by = reverse $by;
+
+    # padd the shorter string
+    my $xx = "\x00"; $xx = "\x0f" if $sx eq '-';
+    my $yy = "\x00"; $yy = "\x0f" if $sy eq '-';
+    my $diff = CORE::length($bx) - CORE::length($by);
+    if ($diff > 0) {
+        # if $yy eq "\x00", we can cut $bx, otherwise we need to padd $by
+        $by .= $yy x $diff;
+    } elsif ($diff < 0) {
+        # if $xx eq "\x00", we can cut $by, otherwise we need to padd $bx
+        $bx .= $xx x abs($diff);
+    }
+
+    # xor the strings together
+    my $r = $bx ^ $by;
+
+    # and reverse the result again
+    $bx = reverse $r;
+
+    # One of $bx or $by was negative, so need to flip bits in the result. In both
+    # cases (one or two of them negative, or both positive) we need to get the
+    # characters back.
+    if ($sign eq '-') {
+        $bx =~ tr<\x0f\x0e\x0d\x0c\x0b\x0a\x09\x08\x07\x06\x05\x04\x03\x02\x01\x00>
+                 <0123456789abcdef>;
+    } else {
+        $bx =~ tr<\x0f\x0e\x0d\x0c\x0b\x0a\x09\x08\x07\x06\x05\x04\x03\x02\x01\x00>
+                 <fedcba9876543210>;
+    }
+
+    # leading zeros will be stripped by _from_hex()
+    $bx = '0x' . $bx;
+    $bx = $class -> _from_hex($bx);
+
+    $bx = $class -> _inc($bx) if $sign eq '-';
+
+    # avoid negative zero
+    $sign = '+' if $class -> _is_zero($bx);
+
+    return $bx, $sign;
+}
+
+sub _sor {
+    my ($class, $x, $sx, $y, $sy) = @_;
+
+    return ($class -> _zero(), '+')
+      if $class -> _is_zero($x) && $class -> _is_zero($y);
+
+    my $sign = $sx eq '-' || $sy eq '-' ? '-' : '+';
+
+    my ($bx, $by);
+
+    if ($sx eq '-') {                   # if x is negative
+        # two's complement: inc (dec unsigned value) and flip all "bits" in $bx
+        $bx = $class -> _copy($x);
+        $bx = $class -> _dec($bx);
+        $bx = $class -> _as_hex($bx);
+        $bx =~ s/^-?0x//;
+        $bx =~ tr<0123456789abcdef>
+                <\x0f\x0e\x0d\x0c\x0b\x0a\x09\x08\x07\x06\x05\x04\x03\x02\x01\x00>;
+    } else {                            # if x is positive
+        $bx = $class -> _as_hex($x);     # get binary representation
+        $bx =~ s/^-?0x//;
+        $bx =~ tr<fedcba9876543210>
+                 <\x0f\x0e\x0d\x0c\x0b\x0a\x09\x08\x07\x06\x05\x04\x03\x02\x01\x00>;
+    }
+
+    if ($sy eq '-') {                   # if y is negative
+        # two's complement: inc (dec unsigned value) and flip all "bits" in $by
+        $by = $class -> _copy($y);
+        $by = $class -> _dec($by);
+        $by = $class -> _as_hex($by);
+        $by =~ s/^-?0x//;
+        $by =~ tr<0123456789abcdef>
+                <\x0f\x0e\x0d\x0c\x0b\x0a\x09\x08\x07\x06\x05\x04\x03\x02\x01\x00>;
+    } else {
+        $by = $class -> _as_hex($y);     # get binary representation
+        $by =~ s/^-?0x//;
+        $by =~ tr<fedcba9876543210>
+                <\x0f\x0e\x0d\x0c\x0b\x0a\x09\x08\x07\x06\x05\x04\x03\x02\x01\x00>;
+    }
+
+    # now we have bit-strings from X and Y, reverse them for padding
+    $bx = reverse $bx;
+    $by = reverse $by;
+
+    # padd the shorter string
+    my $xx = "\x00"; $xx = "\x0f" if $sx eq '-';
+    my $yy = "\x00"; $yy = "\x0f" if $sy eq '-';
+    my $diff = CORE::length($bx) - CORE::length($by);
+    if ($diff > 0) {
+        # if $yy eq "\x00", we can cut $bx, otherwise we need to padd $by
+        $by .= $yy x $diff;
+    } elsif ($diff < 0) {
+        # if $xx eq "\x00", we can cut $by, otherwise we need to padd $bx
+        $bx .= $xx x abs($diff);
+    }
+
+    # or the strings together
+    my $r = $bx | $by;
+
+    # and reverse the result again
+    $bx = reverse $r;
+
+    # One of $bx or $by was negative, so need to flip bits in the result. In both
+    # cases (one or two of them negative, or both positive) we need to get the
+    # characters back.
+    if ($sign eq '-') {
+        $bx =~ tr<\x0f\x0e\x0d\x0c\x0b\x0a\x09\x08\x07\x06\x05\x04\x03\x02\x01\x00>
+                 <0123456789abcdef>;
+    } else {
+        $bx =~ tr<\x0f\x0e\x0d\x0c\x0b\x0a\x09\x08\x07\x06\x05\x04\x03\x02\x01\x00>
+                 <fedcba9876543210>;
+    }
+
+    # leading zeros will be stripped by _from_hex()
+    $bx = '0x' . $bx;
+    $bx = $class -> _from_hex($bx);
+
+    $bx = $class -> _inc($bx) if $sign eq '-';
+
+    # avoid negative zero
+    $sign = '+' if $class -> _is_zero($bx);
+
+    return $bx, $sign;
+}
+
+sub _to_bin {
+    # convert the number to a string of binary digits without prefix
+    my ($class, $x) = @_;
+    my $str    = '';
+    my $tmp    = $class -> _copy($x);
+    my $chunk = $class -> _new("16777216");     # 2^24 = 24 binary digits
+    my $rem;
+    until ($class -> _acmp($tmp, $chunk) < 0) {
+        ($tmp, $rem) = $class -> _div($tmp, $chunk);
+        $str = sprintf("%024b", $class -> _num($rem)) . $str;
+    }
+    unless ($class -> _is_zero($tmp)) {
+        $str = sprintf("%b", $class -> _num($tmp)) . $str;
+    }
+    return length($str) ? $str : '0';
+}
+
+sub _to_oct {
+    # convert the number to a string of octal digits without prefix
+    my ($class, $x) = @_;
+    my $str    = '';
+    my $tmp    = $class -> _copy($x);
+    my $chunk = $class -> _new("16777216");     # 2^24 = 8 octal digits
+    my $rem;
+    until ($class -> _acmp($tmp, $chunk) < 0) {
+        ($tmp, $rem) = $class -> _div($tmp, $chunk);
+        $str = sprintf("%08o", $class -> _num($rem)) . $str;
+    }
+    unless ($class -> _is_zero($tmp)) {
+        $str = sprintf("%o", $class -> _num($tmp)) . $str;
+    }
+    return length($str) ? $str : '0';
+}
+
+sub _to_hex {
+    # convert the number to a string of hexadecimal digits without prefix
+    my ($class, $x) = @_;
+    my $str    = '';
+    my $tmp    = $class -> _copy($x);
+    my $chunk = $class -> _new("16777216");     # 2^24 = 6 hexadecimal digits
+    my $rem;
+    until ($class -> _acmp($tmp, $chunk) < 0) {
+        ($tmp, $rem) = $class -> _div($tmp, $chunk);
+        $str = sprintf("%06x", $class -> _num($rem)) . $str;
+    }
+    unless ($class -> _is_zero($tmp)) {
+        $str = sprintf("%x", $class -> _num($tmp)) . $str;
+    }
+    return length($str) ? $str : '0';
+}
+
+sub _as_bin {
+    # convert the number to a string of binary digits with prefix
+    my ($class, $x) = @_;
+    return '0b' . $class -> _to_bin($x);
+}
+
+sub _as_oct {
+    # convert the number to a string of octal digits with prefix
+    my ($class, $x) = @_;
+    return '0' . $class -> _to_oct($x);         # yes, 0 becomes "00"
+}
+
+sub _as_hex {
+    # convert the number to a string of hexadecimal digits with prefix
+    my ($class, $x) = @_;
+    return '0x' . $class -> _to_hex($x);
+}
+
+sub _to_bytes {
+    # convert the number to a string of bytes
+    my ($class, $x) = @_;
+    my $str    = '';
+    my $tmp    = $class -> _copy($x);
+    my $chunk = $class -> _new("65536");
+    my $rem;
+    until ($class -> _is_zero($tmp)) {
+        ($tmp, $rem) = $class -> _div($tmp, $chunk);
+        $str = pack('n', $class -> _num($rem)) . $str;
+    }
+    $str =~ s/^\0+//;
+    return length($str) ? $str : "\x00";
+}
+
+*_as_bytes = \&_to_bytes;
+
+sub _to_base {
+    # convert the number to a string of digits in various bases
+    my $class = shift;
+    my $x     = shift;
+    my $base  = shift;
+    $base = $class -> _new($base) unless ref($base);
+
+    my $collseq;
+    if (@_) {
+        $collseq = shift;
+        croak "The collation sequence must be a non-empty string"
+          unless defined($collseq) && length($collseq);
+    } else {
+        if ($class -> _acmp($base, $class -> _new("94")) <= 0) {
+            $collseq = '0123456789'                     #  48 ..  57
+                     . 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'     #  65 ..  90
+                     . 'abcdefghijklmnopqrstuvwxyz'     #  97 .. 122
+                     . '!"#$%&\'()*+,-./'               #  33 ..  47
+                     . ':;<=>?@'                        #  58 ..  64
+                     . '[\\]^_`'                        #  91 ..  96
+                     . '{|}~';                          # 123 .. 126
+        } else {
+            croak "When base > 94, a collation sequence must be given";
+        }
+    }
+
+    my @collseq = split '', $collseq;
+
+    my $str   = '';
+    my $tmp   = $class -> _copy($x);
+    my $rem;
+    until ($class -> _is_zero($tmp)) {
+        ($tmp, $rem) = $class -> _div($tmp, $base);
+        my $num = $class -> _num($rem);
+        croak "no character to represent '$num' in collation sequence",
+          " (collation sequence is too short)" if $num > $#collseq;
+        my $chr = $collseq[$num];
+        $str = $chr . $str;
+    }
+    return $collseq[0] unless length $str;
+    return $str;
+}
+
+sub _to_base_num {
+    # Convert the number to an array of integers in any base.
+    my ($class, $x, $base) = @_;
+
+    # Make sure the base is an object and >= 2.
+    $base = $class -> _new($base) unless ref($base);
+    my $two = $class -> _two();
+    croak "base must be >= 2" unless $class -> _acmp($base, $two) >= 0;
+
+    my $out   = [];
+    my $xcopy = $class -> _copy($x);
+    my $rem;
+
+    # Do all except the last (most significant) element.
+    until ($class -> _acmp($xcopy, $base) < 0) {
+        ($xcopy, $rem) = $class -> _div($xcopy, $base);
+        unshift @$out, $rem;
+    }
+
+    # Do the last (most significant element).
+    unless ($class -> _is_zero($xcopy)) {
+        unshift @$out, $xcopy;
+    }
+
+    # $out is empty if $x is zero.
+    unshift @$out, $class -> _zero() unless @$out;
+
+    return $out;
+}
+
+sub _from_hex {
+    # Convert a string of hexadecimal digits to a number.
+
+    my ($class, $hex) = @_;
+    $hex =~ s/^0[xX]//;
+
+    # Find the largest number of hexadecimal digits that we can safely use with
+    # 32 bit integers. There are 4 bits pr hexadecimal digit, and we use only
+    # 31 bits to play safe. This gives us int(31 / 4) = 7.
+
+    my $len = length $hex;
+    my $rem = 1 + ($len - 1) % 7;
+
+    # Do the first chunk.
+
+    my $ret = $class -> _new(int hex substr $hex, 0, $rem);
+    return $ret if $rem == $len;
+
+    # Do the remaining chunks, if any.
+
+    my $shift = $class -> _new(1 << (4 * 7));
+    for (my $offset = $rem ; $offset < $len ; $offset += 7) {
+        my $part = int hex substr $hex, $offset, 7;
+        $ret = $class -> _mul($ret, $shift);
+        $ret = $class -> _add($ret, $class -> _new($part));
+    }
+
+    return $ret;
+}
+
+sub _from_oct {
+    # Convert a string of octal digits to a number.
+
+    my ($class, $oct) = @_;
+
+    # Find the largest number of octal digits that we can safely use with 32
+    # bit integers. There are 3 bits pr octal digit, and we use only 31 bits to
+    # play safe. This gives us int(31 / 3) = 10.
+
+    my $len = length $oct;
+    my $rem = 1 + ($len - 1) % 10;
+
+    # Do the first chunk.
+
+    my $ret = $class -> _new(int oct substr $oct, 0, $rem);
+    return $ret if $rem == $len;
+
+    # Do the remaining chunks, if any.
+
+    my $shift = $class -> _new(1 << (3 * 10));
+    for (my $offset = $rem ; $offset < $len ; $offset += 10) {
+        my $part = int oct substr $oct, $offset, 10;
+        $ret = $class -> _mul($ret, $shift);
+        $ret = $class -> _add($ret, $class -> _new($part));
+    }
+
+    return $ret;
+}
+
+sub _from_bin {
+    # Convert a string of binary digits to a number.
+
+    my ($class, $bin) = @_;
+    $bin =~ s/^0[bB]//;
+
+    # The largest number of binary digits that we can safely use with 32 bit
+    # integers is 31. We use only 31 bits to play safe.
+
+    my $len = length $bin;
+    my $rem = 1 + ($len - 1) % 31;
+
+    # Do the first chunk.
+
+    my $ret = $class -> _new(int oct '0b' . substr $bin, 0, $rem);
+    return $ret if $rem == $len;
+
+    # Do the remaining chunks, if any.
+
+    my $shift = $class -> _new(1 << 31);
+    for (my $offset = $rem ; $offset < $len ; $offset += 31) {
+        my $part = int oct '0b' . substr $bin, $offset, 31;
+        $ret = $class -> _mul($ret, $shift);
+        $ret = $class -> _add($ret, $class -> _new($part));
+    }
+
+    return $ret;
+}
+
+sub _from_bytes {
+    # convert string of bytes to a number
+    my ($class, $str) = @_;
+    my $x    = $class -> _zero();
+    my $base = $class -> _new("256");
+    my $n    = length($str);
+    for (my $i = 0 ; $i < $n ; ++$i) {
+        $x = $class -> _mul($x, $base);
+        my $byteval = $class -> _new(unpack 'C', substr($str, $i, 1));
+        $x = $class -> _add($x, $byteval);
+    }
+    return $x;
+}
+
+sub _from_base {
+    # convert a string to a decimal number
+    my $class = shift;
+    my $str   = shift;
+    my $base  = shift;
+    $base = $class -> _new($base) unless ref($base);
+
+    my $n = length($str);
+    my $x = $class -> _zero();
+
+    my $collseq;
+    if (@_) {
+        $collseq = shift();
+    } else {
+        if ($class -> _acmp($base, $class -> _new("36")) <= 0) {
+            $str = uc $str;
+            $collseq = '0123456789' . 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+        } elsif ($class -> _acmp($base, $class -> _new("94")) <= 0) {
+            $collseq = '0123456789'                     #  48 ..  57
+                     . 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'     #  65 ..  90
+                     . 'abcdefghijklmnopqrstuvwxyz'     #  97 .. 122
+                     . '!"#$%&\'()*+,-./'               #  33 ..  47
+                     . ':;<=>?@'                        #  58 ..  64
+                     . '[\\]^_`'                        #  91 ..  96
+                     . '{|}~';                          # 123 .. 126
+        } else {
+            croak "When base > 94, a collation sequence must be given";
+        }
+        $collseq = substr $collseq, 0, $class -> _num($base);
+    }
+
+    # Create a mapping from each character in the collation sequence to the
+    # corresponding integer. Check for duplicates in the collation sequence.
+
+    my @collseq = split '', $collseq;
+    my %collseq;
+    for my $num (0 .. $#collseq) {
+        my $chr = $collseq[$num];
+        die "duplicate character '$chr' in collation sequence"
+          if exists $collseq{$chr};
+        $collseq{$chr} = $num;
+    }
+
+    for (my $i = 0 ; $i < $n ; ++$i) {
+        my $chr = substr($str, $i, 1);
+        die "input character '$chr' does not exist in collation sequence"
+          unless exists $collseq{$chr};
+        $x = $class -> _mul($x, $base);
+        my $num = $class -> _new($collseq{$chr});
+        $x = $class -> _add($x, $num);
+    }
+
+    return $x;
+}
+
+sub _from_base_num {
+    # Convert an array in the given base to a number.
+    my ($class, $in, $base) = @_;
+
+    # Make sure the base is an object and >= 2.
+    $base = $class -> _new($base) unless ref($base);
+    my $two = $class -> _two();
+    croak "base must be >= 2" unless $class -> _acmp($base, $two) >= 0;
+
+    # @$in = map { ref($_) ? $_ : $class -> _new($_) } @$in;
+
+    my $ele = $in -> [0];
+
+    $ele = $class -> _new($ele) unless ref($ele);
+    my $x = $class -> _copy($ele);
+
+    for my $i (1 .. $#$in) {
+        $x = $class -> _mul($x, $base);
+        $ele = $in -> [$i];
+        $ele = $class -> _new($ele) unless ref($ele);
+        $x = $class -> _add($x, $ele);
+    }
+
+    return $x;
+}
+
+##############################################################################
+# special modulus functions
+
+sub _modinv {
+    # modular multiplicative inverse
+    my ($class, $x, $y) = @_;
+
+    # modulo zero
+    if ($class -> _is_zero($y)) {
+        return;
+    }
+
+    # modulo one
+    if ($class -> _is_one($y)) {
+        return ($class -> _zero(), '+');
+    }
+
+    my $u = $class -> _zero();
+    my $v = $class -> _one();
+    my $a = $class -> _copy($y);
+    my $b = $class -> _copy($x);
+
+    # Euclid's Algorithm for bgcd().
+
+    my $q;
+    my $sign = 1;
+    {
+        ($a, $q, $b) = ($b, $class -> _div($a, $b));
+        last if $class -> _is_zero($b);
+
+        my $vq = $class -> _mul($class -> _copy($v), $q);
+        my $t = $class -> _add($vq, $u);
+        $u = $v;
+        $v = $t;
+        $sign = -$sign;
+        redo;
+    }
+
+    # if the gcd is not 1, there exists no modular multiplicative inverse
+    return unless $class -> _is_one($a);
+
+    ($v, $sign == 1 ? '+' : '-');
+}
+
+sub _modpow {
+    # modulus of power ($x ** $y) % $z
+    my ($class, $num, $exp, $mod) = @_;
+
+    # a^b (mod 1) = 0 for all a and b
+    if ($class -> _is_one($mod)) {
+        return $class -> _zero();
+    }
+
+    # 0^a (mod m) = 0 if m != 0, a != 0
+    # 0^0 (mod m) = 1 if m != 0
+    if ($class -> _is_zero($num)) {
+        return $class -> _is_zero($exp) ? $class -> _one()
+                                        : $class -> _zero();
+    }
+
+    # We could do the following, but it doesn't actually save any time. The
+    # _copy() is needed in case $num and $mod are the same object.
+
+    $num = $class -> _mod($class -> _copy($num), $mod);
+
+    my $acc = $class -> _copy($num);
+    my $t   = $class -> _one();
+
+    my $expbin = $class -> _to_bin($exp);
+    my $len = length($expbin);
+
+    while ($len--) {
+        if (substr($expbin, $len, 1) eq '1') {  # if odd
+            $t = $class -> _mul($t, $acc);
+            $t = $class -> _mod($t, $mod);
+        }
+        $acc = $class -> _mul($acc, $acc);
+        $acc = $class -> _mod($acc, $mod);
+    }
+    return $t;
+}
+
+sub _gcd {
+    # Greatest common divisor.
+
+    my ($class, $x, $y) = @_;
+
+    # gcd(0, 0) = 0
+    # gcd(0, a) = a, if a != 0
+
+    if ($class -> _acmp($x, $y) == 0) {
+        return $class -> _copy($x);
+    }
+
+    if ($class -> _is_zero($x)) {
+        if ($class -> _is_zero($y)) {
+            return $class -> _zero();
+        } else {
+            return $class -> _copy($y);
+        }
+    } else {
+        if ($class -> _is_zero($y)) {
+            return $class -> _copy($x);
+        } else {
+
+            # Until $y is zero ...
+
+            $x = $class -> _copy($x);
+            until ($class -> _is_zero($y)) {
+
+                # Compute remainder.
+
+                $x = $class -> _mod($x, $y);
+
+                # Swap $x and $y.
+
+                my $tmp = $x;
+                $x = $class -> _copy($y);
+                $y = $tmp;
+            }
+
+            return $x;
+        }
+    }
+}
+
+sub _lcm {
+    # Least common multiple.
+
+    my ($class, $x, $y) = @_;
+
+    # lcm(0, x) = 0 for all x
+
+    return $class -> _zero()
+      if ($class -> _is_zero($x) ||
+          $class -> _is_zero($y));
+
+    my $gcd = $class -> _gcd($class -> _copy($x), $y);
+    $x = $class -> _div($x, $gcd);
+    $x = $class -> _mul($x, $y);
+    return $x;
+}
+
+sub _lucas {
+    my ($class, $n) = @_;
+
+    $n = $class -> _num($n) if ref $n;
+
+    # In list context, use lucas(n) = lucas(n-1) + lucas(n-2)
+
+    if (wantarray) {
+        my @y;
+
+        push @y, $class -> _two();
+        return @y if $n == 0;
+
+        push @y, $class -> _one();
+        return @y if $n == 1;
+
+        for (my $i = 2 ; $i <= $n ; ++ $i) {
+            $y[$i] = $class -> _add($class -> _copy($y[$i - 1]), $y[$i - 2]);
+        }
+
+        return @y;
+    }
+
+    # In scalar context use that lucas(n) = fib(n-1) + fib(n+1).
+    #
+    # Remember that _fib() behaves differently in scalar context and list
+    # context, so we must add scalar() to get the desired behaviour.
+
+    return $class -> _two() if $n == 0;
+
+    return $class -> _add(scalar($class -> _fib($n - 1)),
+                          scalar($class -> _fib($n + 1)));
+}
+
+sub _fib {
+    my ($class, $n) = @_;
+
+    $n = $class -> _num($n) if ref $n;
+
+    # In list context, use fib(n) = fib(n-1) + fib(n-2)
+
+    if (wantarray) {
+        my @y;
+
+        push @y, $class -> _zero();
+        return @y if $n == 0;
+
+        push @y, $class -> _one();
+        return @y if $n == 1;
+
+        for (my $i = 2 ; $i <= $n ; ++ $i) {
+            $y[$i] = $class -> _add($class -> _copy($y[$i - 1]), $y[$i - 2]);
+        }
+
+        return @y;
+    }
+
+    # In scalar context use a fast algorithm that is much faster than the
+    # recursive algorith used in list context.
+
+    my $cache = {};
+    my $two = $class -> _two();
+    my $fib;
+
+    $fib = sub {
+        my $n = shift;
+        return $class -> _zero() if $n <= 0;
+        return $class -> _one()  if $n <= 2;
+        return $cache -> {$n}    if exists $cache -> {$n};
+
+        my $k = int($n / 2);
+        my $a = $fib -> ($k + 1);
+        my $b = $fib -> ($k);
+        my $y;
+
+        if ($n % 2 == 1) {
+            # a*a + b*b
+            $y = $class -> _add($class -> _mul($class -> _copy($a), $a),
+                                $class -> _mul($class -> _copy($b), $b));
+        } else {
+            # (2*a - b)*b
+            $y = $class -> _mul($class -> _sub($class -> _mul(
+                   $class -> _copy($two), $a), $b), $b);
+        }
+
+        $cache -> {$n} = $y;
+        return $y;
+    };
+
+    return $fib -> ($n);
+}
+
+##############################################################################
+##############################################################################
+
+1;
+
+__END__
+
+=pod
+
+=head1 NAME
+
+Math::BigInt::Lib - virtual parent class for Math::BigInt libraries
+
+=head1 SYNOPSIS
+
+    # In the backend library for Math::BigInt et al.
+
+    package Math::BigInt::MyBackend;
+
+    use Math::BigInt::Lib;
+    our @ISA = qw< Math::BigInt::Lib >;
+
+    sub _new { ... }
+    sub _str { ... }
+    sub _add { ... }
+    str _sub { ... }
+    ...
+
+    # In your main program.
+
+    use Math::BigInt lib => 'MyBackend';
+
+=head1 DESCRIPTION
+
+This module provides support for big integer calculations. It is not intended
+to be used directly, but rather as a parent class for backend libraries used by
+Math::BigInt, Math::BigFloat, Math::BigRat, and related modules.
+
+Other backend libraries include Math::BigInt::Calc, Math::BigInt::FastCalc,
+Math::BigInt::GMP, and Math::BigInt::Pari.
+
+In order to allow for multiple big integer libraries, Math::BigInt was
+rewritten to use a plug-in library for core math routines. Any module which
+conforms to the API can be used by Math::BigInt by using this in your program:
+
+        use Math::BigInt lib => 'libname';
+
+'libname' is either the long name, like 'Math::BigInt::Pari', or only the short
+version, like 'Pari'.
+
+=head2 General Notes
+
+A library only needs to deal with unsigned big integers. Testing of input
+parameter validity is done by the caller, so there is no need to worry about
+underflow (e.g., in C<_sub()> and C<_dec()>) or about division by zero (e.g.,
+in C<_div()> and C<_mod()>)) or similar cases.
+
+Some libraries use methods that don't modify their argument, and some libraries
+don't even use objects, but rather unblessed references. Because of this,
+liberary methods are always called as class methods, not instance methods:
+
+    $x = Class -> method($x, $y);     # like this
+    $x = $x -> method($y);            # not like this ...
+    $x -> method($y);                 # ... or like this
+
+And with boolean methods
+
+    $bool = Class -> method($x, $y);  # like this
+    $bool = $x -> method($y);         # not like this
+
+Return values are always objects, strings, Perl scalars, or true/false for
+comparison routines.
+
+=head3 API version
+
+=over 4
+
+=item CLASS-E<gt>api_version()
+
+This method is no longer used and can be omitted. Methods that are not
+implemented by a subclass will be inherited from this class.
+
+=back
+
+=head3 Constructors
+
+The following methods are mandatory: _new(), _str(), _add(), and _sub().
+However, computations will be very slow without _mul() and _div().
+
+=over 4
+
+=item CLASS-E<gt>_new(STR)
+
+Convert a string representing an unsigned decimal number to an object
+representing the same number. The input is normalized, i.e., it matches
+C<^(0|[1-9]\d*)$>.
+
+=item CLASS-E<gt>_zero()
+
+Return an object representing the number zero.
+
+=item CLASS-E<gt>_one()
+
+Return an object representing the number one.
+
+=item CLASS-E<gt>_two()
+
+Return an object representing the number two.
+
+=item CLASS-E<gt>_ten()
+
+Return an object representing the number ten.
+
+=item CLASS-E<gt>_from_bin(STR)
+
+Return an object given a string representing a binary number. The input has a
+'0b' prefix and matches the regular expression C<^0[bB](0|1[01]*)$>.
+
+=item CLASS-E<gt>_from_oct(STR)
+
+Return an object given a string representing an octal number. The input has a
+'0' prefix and matches the regular expression C<^0[1-7]*$>.
+
+=item CLASS-E<gt>_from_hex(STR)
+
+Return an object given a string representing a hexadecimal number. The input
+has a '0x' prefix and matches the regular expression
+C<^0x(0|[1-9a-fA-F][\da-fA-F]*)$>.
+
+=item CLASS-E<gt>_from_bytes(STR)
+
+Returns an object given a byte string representing the number. The byte string
+is in big endian byte order, so the two-byte input string "\x01\x00" should
+give an output value representing the number 256.
+
+=item CLASS-E<gt>_from_base(STR, BASE, COLLSEQ)
+
+Returns an object given a string STR, a base BASE, and a collation sequence
+COLLSEQ. Each character in STR represents a numerical value identical to the
+character's position in COLLSEQ. All characters in STR must be present in
+COLLSEQ.
+
+If BASE is less than or equal to 94, and a collation sequence is not specified,
+the following default collation sequence is used. It contains of all the 94
+printable ASCII characters except space/blank:
+
+    0123456789                  # ASCII  48 to  57
+    ABCDEFGHIJKLMNOPQRSTUVWXYZ  # ASCII  65 to  90
+    abcdefghijklmnopqrstuvwxyz  # ASCII  97 to 122
+    !"#$%&'()*+,-./             # ASCII  33 to  47
+    :;<=>?@                     # ASCII  58 to  64
+    [\]^_`                      # ASCII  91 to  96
+    {|}~                        # ASCII 123 to 126
+
+If the default collation sequence is used, and the BASE is less than or equal
+to 36, the letter case in STR is ignored.
+
+For instance, with base 3 and collation sequence "-/|", the character "-"
+represents 0, "/" represents 1, and "|" represents 2. So if STR is "/|-", the
+output is 1 * 3**2 + 2 * 3**1 + 0 * 3**0 = 15.
+
+The following examples show standard binary, octal, decimal, and hexadecimal
+conversion. All examples return 250.
+
+    $x = $class -> _from_base("11111010", 2)
+    $x = $class -> _from_base("372", 8)
+    $x = $class -> _from_base("250", 10)
+    $x = $class -> _from_base("FA", 16)
+
+Some more examples, all returning 250:
+
+    $x = $class -> _from_base("100021", 3)
+    $x = $class -> _from_base("3322", 4)
+    $x = $class -> _from_base("2000", 5)
+    $x = $class -> _from_base("caaa", 5, "abcde")
+    $x = $class -> _from_base("42", 62)
+    $x = $class -> _from_base("2!", 94)
+
+=item CLASS-E<gt>_from_base_num(ARRAY, BASE)
+
+Returns an object given an array of values and a base. This method is
+equivalent to C<_from_base()>, but works on numbers in an array rather than
+characters in a string. Unlike C<_from_base()>, all input values may be
+arbitrarily large.
+
+    $x = $class -> _from_base_num([1, 1, 0, 1], 2)    # $x is 13
+    $x = $class -> _from_base_num([3, 125, 39], 128)  # $x is 65191
+
+=back
+
+=head3 Mathematical functions
+
+=over 4
+
+=item CLASS-E<gt>_add(OBJ1, OBJ2)
+
+Addition. Returns the result of adding OBJ2 to OBJ1.
+
+=item CLASS-E<gt>_mul(OBJ1, OBJ2)
+
+Multiplication. Returns the result of multiplying OBJ2 and OBJ1.
+
+=item CLASS-E<gt>_div(OBJ1, OBJ2)
+
+Division. In scalar context, returns the quotient after dividing OBJ1 by OBJ2
+and truncating the result to an integer. In list context, return the quotient
+and the remainder.
+
+=item CLASS-E<gt>_sub(OBJ1, OBJ2, FLAG)
+
+=item CLASS-E<gt>_sub(OBJ1, OBJ2)
+
+Subtraction. Returns the result of subtracting OBJ2 by OBJ1. If C<flag> is false
+or omitted, OBJ1 might be modified. If C<flag> is true, OBJ2 might be modified.
+
+=item CLASS-E<gt>_sadd(OBJ1, SIGN1, OBJ2, SIGN2)
+
+Signed addition. Returns the result of adding OBJ2 with sign SIGN2 to OBJ1 with
+sign SIGN1.
+
+    ($obj3, $sign3) = $class -> _sadd($obj1, $sign1, $obj2, $sign2);
+
+=item CLASS-E<gt>_ssub(OBJ1, SIGN1, OBJ2, SIGN2)
+
+Signed subtraction. Returns the result of subtracting OBJ2 with sign SIGN2 to
+OBJ1 with sign SIGN1.
+
+    ($obj3, $sign3) = $class -> _sadd($obj1, $sign1, $obj2, $sign2);
+
+=item CLASS-E<gt>_dec(OBJ)
+
+Returns the result after decrementing OBJ by one.
+
+=item CLASS-E<gt>_inc(OBJ)
+
+Returns the result after incrementing OBJ by one.
+
+=item CLASS-E<gt>_mod(OBJ1, OBJ2)
+
+Returns OBJ1 modulo OBJ2, i.e., the remainder after dividing OBJ1 by OBJ2.
+
+=item CLASS-E<gt>_sqrt(OBJ)
+
+Returns the square root of OBJ, truncated to an integer.
+
+=item CLASS-E<gt>_root(OBJ, N)
+
+Returns the Nth root of OBJ, truncated to an integer.
+
+=item CLASS-E<gt>_fac(OBJ)
+
+Returns the factorial of OBJ, i.e., the product of all positive integers up to
+and including OBJ.
+
+=item CLASS-E<gt>_dfac(OBJ)
+
+Returns the double factorial of OBJ. If OBJ is an even integer, returns the
+product of all positive, even integers up to and including OBJ, i.e.,
+2*4*6*...*OBJ. If OBJ is an odd integer, returns the product of all positive,
+odd integers, i.e., 1*3*5*...*OBJ.
+
+=item CLASS-E<gt>_pow(OBJ1, OBJ2)
+
+Returns OBJ1 raised to the power of OBJ2. By convention, 0**0 = 1.
+
+=item CLASS-E<gt>_modinv(OBJ1, OBJ2)
+
+Returns the modular multiplicative inverse, i.e., return OBJ3 so that
+
+    (OBJ3 * OBJ1) % OBJ2 = 1 % OBJ2
+
+The result is returned as two arguments. If the modular multiplicative inverse
+does not exist, both arguments are undefined. Otherwise, the arguments are a
+number (object) and its sign ("+" or "-").
+
+The output value, with its sign, must either be a positive value in the range
+1,2,...,OBJ2-1 or the same value subtracted OBJ2. For instance, if the input
+arguments are objects representing the numbers 7 and 5, the method must either
+return an object representing the number 3 and a "+" sign, since (3*7) % 5 = 1
+% 5, or an object representing the number 2 and a "-" sign, since (-2*7) % 5 = 1
+% 5.
+
+=item CLASS-E<gt>_modpow(OBJ1, OBJ2, OBJ3)
+
+Returns the modular exponentiation, i.e., (OBJ1 ** OBJ2) % OBJ3.
+
+=item CLASS-E<gt>_rsft(OBJ, N, B)
+
+Returns the result after shifting OBJ N digits to thee right in base B. This is
+equivalent to performing integer division by B**N and discarding the remainder,
+except that it might be much faster.
+
+For instance, if the object $obj represents the hexadecimal number 0xabcde,
+then C<_rsft($obj, 2, 16)> returns an object representing the number 0xabc. The
+"remainer", 0xde, is discarded and not returned.
+
+=item CLASS-E<gt>_lsft(OBJ, N, B)
+
+Returns the result after shifting OBJ N digits to the left in base B. This is
+equivalent to multiplying by B**N, except that it might be much faster.
+
+=item CLASS-E<gt>_log_int(OBJ, B)
+
+Returns the logarithm of OBJ to base BASE truncted to an integer. This method
+has two output arguments, the OBJECT and a STATUS. The STATUS is Perl scalar;
+it is 1 if OBJ is the exact result, 0 if the result was truncted to give OBJ,
+and undef if it is unknown whether OBJ is the exact result.
+
+=item CLASS-E<gt>_ilog2(OBJ)
+
+Returns the base 2 logarithm of OBJ rounded downwards to the nearest integer,
+i.e., C<int(log2(OBJ))>. In list context, this method returns two output
+arguments, the OBJECT and a STATUS. The STATUS is Perl scalar; it is 1 if OBJ
+is the exact result, 0 if the result was truncted to give OBJ, and undef if it
+is unknown whether OBJ is the exact result.
+
+This method is equivalent to the more general method _log_int() when it is used
+with base 2 argument, but _ilog2() method might be faster.
+
+=item CLASS-E<gt>_ilog10(OBJ)
+
+Returns the base 10 logarithm of OBJ rounded downwards to the nearest integer,
+i.e., C<int(log2(OBJ))>. In list context, this method returns two output
+arguments, the OBJECT and a STATUS. The STATUS is Perl scalar; it is 1 if OBJ
+is the exact result, 0 if the result was truncted to give OBJ, and undef if it
+is unknown whether OBJ is the exact result.
+
+This method is equivalent to the more general method _log_int() when it is used
+with base 10 argument, but _ilog10() method might be faster.
+
+Also, the output from _ilog10() is always 1 smaller than the output from
+_len().
+
+=item CLASS-E<gt>_clog2(OBJ)
+
+Returns the base 2 logarithm of OBJ rounded upwards to the nearest integer,
+i.e., C<ceil(log2(OBJ))>. In list context, this method returns two output
+arguments, the OBJECT and a STATUS. The STATUS is Perl scalar; it is 1 if OBJ
+is the exact result, 0 if the result was truncted to give OBJ, and undef if it
+is unknown whether OBJ is the exact result.
+
+=item CLASS-E<gt>_clog10(OBJ)
+
+Returns the base 10 logarithm of OBJ rounded upnwards to the nearest integer,
+i.e., C<ceil(log2(OBJ))>. In list context, this method returns two output
+arguments, the OBJECT and a STATUS. The STATUS is Perl scalar; it is 1 if OBJ
+is the exact result, 0 if the result was truncted to give OBJ, and undef if it
+is unknown whether OBJ is the exact result.
+
+=item CLASS-E<gt>_gcd(OBJ1, OBJ2)
+
+Returns the greatest common divisor of OBJ1 and OBJ2.
+
+=item CLASS-E<gt>_lcm(OBJ1, OBJ2)
+
+Return the least common multiple of OBJ1 and OBJ2.
+
+=item CLASS-E<gt>_fib(OBJ)
+
+In scalar context, returns the nth Fibonacci number: _fib(0) returns 0, _fib(1)
+returns 1, _fib(2) returns 1, _fib(3) returns 2 etc. In list context, returns
+the Fibonacci numbers from F(0) to F(n): 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, ...
+
+=item CLASS-E<gt>_lucas(OBJ)
+
+In scalar context, returns the nth Lucas number: _lucas(0) returns 2, _lucas(1)
+returns 1, _lucas(2) returns 3, etc. In list context, returns the Lucas numbers
+from L(0) to L(n): 2, 1, 3, 4, 7, 11, 18, 29,47, 76, ...
+
+=back
+
+=head3 Bitwise operators
+
+=over 4
+
+=item CLASS-E<gt>_and(OBJ1, OBJ2)
+
+Returns bitwise and.
+
+=item CLASS-E<gt>_or(OBJ1, OBJ2)
+
+Returns bitwise or.
+
+=item CLASS-E<gt>_xor(OBJ1, OBJ2)
+
+Returns bitwise exclusive or.
+
+=item CLASS-E<gt>_sand(OBJ1, OBJ2, SIGN1, SIGN2)
+
+Returns bitwise signed and.
+
+=item CLASS-E<gt>_sor(OBJ1, OBJ2, SIGN1, SIGN2)
+
+Returns bitwise signed or.
+
+=item CLASS-E<gt>_sxor(OBJ1, OBJ2, SIGN1, SIGN2)
+
+Returns bitwise signed exclusive or.
+
+=back
+
+=head3 Boolean operators
+
+=over 4
+
+=item CLASS-E<gt>_is_zero(OBJ)
+
+Returns a true value if OBJ is zero, and false value otherwise.
+
+=item CLASS-E<gt>_is_one(OBJ)
+
+Returns a true value if OBJ is one, and false value otherwise.
+
+=item CLASS-E<gt>_is_two(OBJ)
+
+Returns a true value if OBJ is two, and false value otherwise.
+
+=item CLASS-E<gt>_is_ten(OBJ)
+
+Returns a true value if OBJ is ten, and false value otherwise.
+
+=item CLASS-E<gt>_is_even(OBJ)
+
+Return a true value if OBJ is an even integer, and a false value otherwise.
+
+=item CLASS-E<gt>_is_odd(OBJ)
+
+Return a true value if OBJ is an even integer, and a false value otherwise.
+
+=item CLASS-E<gt>_acmp(OBJ1, OBJ2)
+
+Compare OBJ1 and OBJ2 and return -1, 0, or 1, if OBJ1 is numerically less than,
+equal to, or larger than OBJ2, respectively.
+
+=item CLASS-E<gt>_scmp(OBJ1, SIGN1, OBJ2, SIGN2)
+
+Compare OBJ1 and OBJ2 and return -1, 0, or 1, if OBJ1 is numerically less than,
+equal to, or larger than OBJ2, respectively.
+
+=back
+
+=head3 String conversion
+
+=over 4
+
+=item CLASS-E<gt>_str(OBJ)
+
+Returns a string representing OBJ in decimal notation. The returned string
+should have no leading zeros, i.e., it should match C<^(0|[1-9]\d*)$>.
+
+=item CLASS-E<gt>_to_bin(OBJ)
+
+Returns the binary string representation of OBJ.
+
+=item CLASS-E<gt>_to_oct(OBJ)
+
+Returns the octal string representation of the number.
+
+=item CLASS-E<gt>_to_hex(OBJ)
+
+Returns the hexadecimal string representation of the number.
+
+=item CLASS-E<gt>_to_bytes(OBJ)
+
+Returns a byte string representation of OBJ. The byte string is in big endian
+byte order, so if OBJ represents the number 256, the output should be the
+two-byte string "\x01\x00".
+
+=item CLASS-E<gt>_to_base(OBJ, BASE, COLLSEQ)
+
+Returns a string representation of OBJ in base BASE with collation sequence
+COLLSEQ.
+
+    $val = $class -> _new("210");
+    $str = $class -> _to_base($val, 10, "xyz")  # $str is "zyx"
+
+    $val = $class -> _new("32");
+    $str = $class -> _to_base($val, 2, "-|")  # $str is "|-----"
+
+See _from_base() for more information.
+
+=item CLASS-E<gt>_to_base_num(OBJ, BASE)
+
+Converts the given number to the given base. This method is equivalent to
+C<_to_base()>, but returns numbers in an array rather than characters in a
+string. In the output, the first element is the most significant. Unlike
+C<_to_base()>, all input values may be arbitrarily large.
+
+    $x = $class -> _to_base_num(13, 2)        # $x is [1, 1, 0, 1]
+    $x = $class -> _to_base_num(65191, 128)   # $x is [3, 125, 39]
+
+=item CLASS-E<gt>_as_bin(OBJ)
+
+Like C<_to_bin()> but with a '0b' prefix.
+
+=item CLASS-E<gt>_as_oct(OBJ)
+
+Like C<_to_oct()> but with a '0' prefix.
+
+=item CLASS-E<gt>_as_hex(OBJ)
+
+Like C<_to_hex()> but with a '0x' prefix.
+
+=item CLASS-E<gt>_as_bytes(OBJ)
+
+This is an alias to C<_to_bytes()>.
+
+=back
+
+=head3 Numeric conversion
+
+=over 4
+
+=item CLASS-E<gt>_num(OBJ)
+
+Returns a Perl scalar number representing the number OBJ as close as
+possible. Since Perl scalars have limited precision, the returned value might
+not be exactly the same as OBJ.
+
+=back
+
+=head3 Miscellaneous
+
+=over 4
+
+=item CLASS-E<gt>_copy(OBJ)
+
+Returns a true copy OBJ.
+
+=item CLASS-E<gt>_len(OBJ)
+
+Returns the number of the decimal digits in OBJ. The output is a Perl scalar.
+
+=item CLASS-E<gt>_zeros(OBJ)
+
+Returns the number of trailing decimal zeros. The output is a Perl scalar. The
+number zero has no trailing decimal zeros.
+
+=item CLASS-E<gt>_digit(OBJ, N)
+
+Returns the Nth digit in OBJ as a Perl scalar. N is a Perl scalar, where zero
+refers to the rightmost (least significant) digit, and negative values count
+from the left (most significant digit). If $obj represents the number 123, then
+
+    CLASS->_digit($obj,  0)     # returns 3
+    CLASS->_digit($obj,  1)     # returns 2
+    CLASS->_digit($obj,  2)     # returns 1
+    CLASS->_digit($obj, -1)     # returns 1
+
+=item CLASS-E<gt>_digitsum(OBJ)
+
+Returns the sum of the base 10 digits.
+
+=item CLASS-E<gt>_check(OBJ)
+
+Returns true if the object is invalid and false otherwise. Preferably, the true
+value is a string describing the problem with the object. This is a check
+routine to test the internal state of the object for corruption.
+
+=item CLASS-E<gt>_set(OBJ)
+
+xxx
+
+=back
+
+=head2 API version 2
+
+The following methods are required for an API version of 2 or greater.
+
+=head3 Constructors
+
+=over 4
+
+=item CLASS-E<gt>_1ex(N)
+
+Return an object representing the number 10**N where N E<gt>= 0 is a Perl
+scalar.
+
+=back
+
+=head3 Mathematical functions
+
+=over 4
+
+=item CLASS-E<gt>_nok(OBJ1, OBJ2)
+
+Return the binomial coefficient OBJ1 over OBJ1.
+
+=back
+
+=head3 Miscellaneous
+
+=over 4
+
+=item CLASS-E<gt>_alen(OBJ)
+
+Return the approximate number of decimal digits of the object. The output is a
+Perl scalar.
+
+=back
+
+=head1 WRAP YOUR OWN
+
+If you want to port your own favourite C library for big numbers to the
+Math::BigInt interface, you can take any of the already existing modules as a
+rough guideline. You should really wrap up the latest Math::BigInt and
+Math::BigFloat testsuites with your module, and replace in them any of the
+following:
+
+        use Math::BigInt;
+
+by this:
+
+        use Math::BigInt lib => 'yourlib';
+
+This way you ensure that your library really works 100% within Math::BigInt.
+
+=head1 BUGS
+
+Please report any bugs or feature requests to
+C<bug-math-bigint at rt.cpan.org>, or through the web interface at
+L<https://rt.cpan.org/Ticket/Create.html?Queue=Math-BigInt>
+(requires login).
+We will be notified, and then you'll automatically be notified of progress on
+your bug as I make changes.
+
+=head1 SUPPORT
+
+You can find documentation for this module with the perldoc command.
+
+    perldoc Math::BigInt::Calc
+
+You can also look for information at:
+
+=over 4
+
+=item * GitHub Source Repository
+
+L<https://github.com/pjacklam/p5-Math-BigInt>
+
+=item * RT: CPAN's request tracker
+
+L<https://rt.cpan.org/Public/Dist/Display.html?Name=Math-BigInt>
+
+=item * MetaCPAN
+
+L<https://metacpan.org/release/Math-BigInt>
+
+=item * CPAN Testers Matrix
+
+L<http://matrix.cpantesters.org/?dist=Math-BigInt>
+
+=back
+
+=head1 LICENSE
+
+This program is free software; you may redistribute it and/or modify it under
+the same terms as Perl itself.
+
+=head1 AUTHOR
+
+Peter John Acklam, E<lt>pjacklam@gmail.comE<gt>
+
+Code and documentation based on the Math::BigInt::Calc module by Tels
+E<lt>nospam-abuse@bloodgate.comE<gt>
+
+=head1 SEE ALSO
+
+L<Math::BigInt>, L<Math::BigInt::Calc>, L<Math::BigInt::GMP>,
+L<Math::BigInt::FastCalc> and L<Math::BigInt::Pari>.
+
+=cut

git/usr/share/perl5/core_perl/Math/BigInt/Trace.pm

@@ -0,0 +1,76 @@
+# -*- mode: perl; -*-
+
+package Math::BigInt::Trace;
+
+use strict;
+use warnings;
+
+use Exporter;
+use Math::BigInt;
+
+our @ISA = qw(Exporter Math::BigInt);
+
+our $VERSION = '0.67';
+
+use overload;                   # inherit overload from Math::BigInt
+
+# Globals
+our $accuracy   = undef;
+our $precision  = undef;
+our $round_mode = 'even';
+our $div_scale  = 40;
+
+sub new {
+    my $proto = shift;
+    my $class = ref($proto) || $proto;
+
+    my $value = shift;
+
+    my $a = $accuracy;
+    $a = $_[0] if defined $_[0];
+
+    my $p = $precision;
+    $p = $_[1] if defined $_[1];
+
+    my $self = $class -> SUPER::new($value, $a, $p, $round_mode);
+
+    printf "Math::BigInt new '%s' => '%s' (%s)\n",
+      $value, $self, ref($self);
+
+    return $self;
+}
+
+sub import {
+    my $class = shift;
+
+    printf "%s -> import(%s)\n", $class, join(", ", @_);
+
+    # we catch the constants, the rest goes to parent
+
+    my $constant = grep { $_ eq ':constant' } @_;
+    my @a = grep { $_ ne ':constant' } @_;
+
+    if ($constant) {
+        overload::constant
+
+            integer => sub {
+                $class -> new(shift);
+            },
+
+            float   => sub {
+                $class -> new(shift);
+            },
+
+            binary  => sub {
+                # E.g., a literal 0377 shall result in an object whose value
+                # is decimal 255, but new("0377") returns decimal 377.
+                return $class -> from_oct($_[0]) if $_[0] =~ /^0_*[0-7]/;
+                $class -> new(shift);
+            };
+    }
+
+    $class -> SUPER::import(@a);                # need it for subclasses
+    #$self -> export_to_level(1, $class, @_);    # need this ?
+}
+
+1;

git/usr/share/perl5/core_perl/Math/BigRat/Trace.pm

@@ -0,0 +1,76 @@
+# -*- mode: perl; -*-
+
+package Math::BigRat::Trace;
+
+use strict;
+use warnings;
+
+use Exporter;
+use Math::BigRat;
+
+our @ISA = qw(Exporter Math::BigRat);
+
+our $VERSION = '0.67';
+
+use overload;                   # inherit overload from Math::BigRat
+
+# Globals
+our $accuracy   = undef;
+our $precision  = undef;
+our $round_mode = 'even';
+our $div_scale  = 40;
+
+sub new {
+    my $proto = shift;
+    my $class = ref($proto) || $proto;
+
+    my $value = shift;
+
+    my $a = $accuracy;
+    $a = $_[0] if defined $_[0];
+
+    my $p = $precision;
+    $p = $_[1] if defined $_[1];
+
+    my $self = $class -> SUPER::new($value, $a, $p, $round_mode);
+
+    printf "Math::BigRat new '%s' => '%s' (%s)\n",
+      $value, $self, ref($self);
+
+    return $self;
+}
+
+sub import {
+    my $class = shift;
+
+    printf "%s -> import(%s)\n", $class, join(", ", @_);
+
+    # we catch the constants, the rest goes to parent
+
+    my $constant = grep { $_ eq ':constant' } @_;
+    my @a = grep { $_ ne ':constant' } @_;
+
+    if ($constant) {
+        overload::constant
+
+            integer => sub {
+                $class -> new(shift);
+            },
+
+            float   => sub {
+                $class -> new(shift);
+            },
+
+            binary  => sub {
+                # E.g., a literal 0377 shall result in an object whose value
+                # is decimal 255, but new("0377") returns decimal 377.
+                return $class -> from_oct($_[0]) if $_[0] =~ /^0_*[0-7]/;
+                $class -> new(shift);
+            };
+    }
+
+    $class -> SUPER::import(@a);                # need it for subclasses
+    #$self -> export_to_level(1, $class, @_);    # need this ?
+}
+
+1;

git/usr/share/perl5/core_perl/Module/CoreList/Utils.pm

@@ -0,0 +1,2388 @@
+package Module::CoreList::Utils;
+
+use strict;
+use warnings;
+use Module::CoreList;
+
+our $VERSION = '5.20260329_42';
+our %utilities;
+
+sub utilities {
+    my $perl = shift;
+    $perl = shift if eval { $perl->isa(__PACKAGE__) };
+    return unless $perl or exists $utilities{$perl};
+    return sort keys %{ $utilities{$perl} };
+}
+
+sub _released_order {   # Sort helper, to make '?' sort after everything else
+    (substr($Module::CoreList::released{$a}, 0, 1) eq "?")
+    ? ((substr($Module::CoreList::released{$b}, 0, 1) eq "?")
+        ? 0
+        : 1)
+    : ((substr($Module::CoreList::released{$b}, 0, 1) eq "?")
+        ? -1
+        : $Module::CoreList::released{$a} cmp $Module::CoreList::released{$b} )
+}
+
+sub first_release_raw {
+    my $util = shift;
+    $util = shift if eval { $util->isa(__PACKAGE__) };
+      #and scalar @_ and $_[0] =~ m#\A[a-zA-Z_][0-9a-zA-Z_]*(?:(::|')[0-9a-zA-Z_]+)*\z#;
+    my $version = shift;
+
+    my @perls = $version
+        ? grep { exists $utilities{$_}{ $util } &&
+                        $utilities{$_}{ $util } ge $version } keys %utilities
+        : grep { exists $utilities{$_}{ $util }             } keys %utilities;
+
+    return grep { exists $Module::CoreList::released{$_} } @perls;
+}
+
+sub first_release_by_date {
+    my @perls = &first_release_raw;
+    return unless @perls;
+    return (sort _released_order @perls)[0];
+}
+
+sub first_release {
+    my @perls = &first_release_raw;
+    return unless @perls;
+    return (sort { $a cmp $b } @perls)[0];
+}
+
+sub removed_from {
+  my @perls = &removed_raw;
+  return shift @perls;
+}
+
+sub removed_from_by_date {
+  my @perls = sort _released_order &removed_raw;
+  return shift @perls;
+}
+
+sub removed_raw {
+  my $util = shift;
+  $util = shift if eval { $util->isa(__PACKAGE__) };
+  return unless my @perls = sort { $a cmp $b } first_release_raw($util);
+  @perls = grep { exists $Module::CoreList::released{$_} } @perls;
+  my $last = pop @perls;
+  my @removed = grep { $_ > $last } sort { $a cmp $b } keys %utilities;
+  return @removed;
+}
+
+my %delta = (
+    5 => {
+        changed => {
+            'a2p'                   => '1',
+            'c2ph'                  => '1',
+            'cppstdin'              => '1',
+            'find2perl'             => '1',
+            'pstruct'               => '1',
+            's2p'                   => '1',
+        },
+        removed => {
+        }
+    },
+
+    5.001 => {
+        delta_from => 5,
+        changed => {
+            'h2xs'                  => '1',
+        },
+        removed => {
+        }
+    },
+
+    5.002 => {
+        delta_from => 5.001,
+        changed => {
+            'h2ph'                  => '1',
+            'perlbug'               => '1',
+            'perldoc'               => '1',
+            'pod2html'              => '1',
+            'pod2latex'             => '1',
+            'pod2man'               => '1',
+            'pod2text'              => '1',
+        },
+        removed => {
+        }
+    },
+
+    5.00307 => {
+        delta_from => 5.002,
+        changed => {
+            'pl2pm'                 => '1',
+        },
+        removed => {
+           'cppstdin'              => 1,
+           'pstruct'               => 1,
+        }
+    },
+
+    5.004 => {
+        delta_from => 5.00307,
+        changed => {
+            'splain'                => '1',
+        },
+        removed => {
+        }
+    },
+
+    5.005 => {
+        delta_from => 5.00405,
+        changed => {
+            'perlcc'                => '1',
+        },
+        removed => {
+        }
+    },
+
+    5.00503 => {
+        delta_from => 5.005,
+        changed => {
+        },
+        removed => {
+        }
+    },
+
+    5.00405 => {
+        delta_from => 5.004,
+        changed => {
+        },
+        removed => {
+        }
+    },
+
+    5.006 => {
+        delta_from => 5.00504,
+        changed => {
+            'dprofpp'               => '1',
+            'pod2usage'             => '1',
+            'podchecker'            => '1',
+            'podselect'             => '1',
+            'pstruct'               => '1',
+        },
+        removed => {
+        }
+    },
+
+    5.006001 => {
+        delta_from => 5.006,
+        changed => {
+        },
+        removed => {
+        }
+    },
+
+    5.007003 => {
+        delta_from => 5.006002,
+        changed => {
+            'libnetcfg'             => '1',
+            'perlivp'               => '1',
+            'psed'                  => '1',
+            'xsubpp'                => '1',
+        },
+        removed => {
+        }
+    },
+
+    5.008 => {
+        delta_from => 5.007003,
+        changed => {
+            'enc2xs'                => '1',
+            'piconv'                => '1',
+        },
+        removed => {
+        }
+    },
+
+    5.008001 => {
+        delta_from => 5.008,
+        changed => {
+            'cpan'                  => '1',
+        },
+        removed => {
+        }
+    },
+
+    5.009 => {
+        delta_from => 5.008009,
+        changed => {
+        },
+        removed => {
+           'corelist'              => 1,
+           'instmodsh'             => 1,
+           'prove'                 => 1,
+        }
+    },
+
+    5.008002 => {
+        delta_from => 5.008001,
+        changed => {
+        },
+        removed => {
+        }
+    },
+
+    5.006002 => {
+        delta_from => 5.006001,
+        changed => {
+        },
+        removed => {
+        }
+    },
+
+    5.008003 => {
+        delta_from => 5.008002,
+        changed => {
+            'instmodsh'             => '1',
+            'prove'                 => '1',
+        },
+        removed => {
+        }
+    },
+
+    5.00504 => {
+        delta_from => 5.00503,
+        changed => {
+        },
+        removed => {
+        }
+    },
+
+    5.009001 => {
+        delta_from => 5.009,
+        changed => {
+            'instmodsh'             => '1',
+            'prove'                 => '1',
+        },
+        removed => {
+        }
+    },
+
+    5.008004 => {
+        delta_from => 5.008003,
+        changed => {
+        },
+        removed => {
+        }
+    },
+
+    5.008005 => {
+        delta_from => 5.008004,
+        changed => {
+        },
+        removed => {
+        }
+    },
+
+    5.008006 => {
+        delta_from => 5.008005,
+        changed => {
+        },
+        removed => {
+        }
+    },
+
+    5.009002 => {
+        delta_from => 5.009001,
+        changed => {
+            'corelist'              => '1',
+        },
+        removed => {
+        }
+    },
+
+    5.008007 => {
+        delta_from => 5.008006,
+        changed => {
+        },
+        removed => {
+        }
+    },
+
+    5.009003 => {
+        delta_from => 5.009002,
+        changed => {
+            'ptar'                  => '1',
+            'ptardiff'              => '1',
+            'shasum'                => '1',
+        },
+        removed => {
+        }
+    },
+
+    5.008008 => {
+        delta_from => 5.008007,
+        changed => {
+        },
+        removed => {
+        }
+    },
+
+    5.009004 => {
+        delta_from => 5.009003,
+        changed => {
+            'config_data'           => '1',
+        },
+        removed => {
+        }
+    },
+
+    5.009005 => {
+        delta_from => 5.009004,
+        changed => {
+            'cpan2dist'             => '1',
+            'cpanp'                 => '1',
+            'cpanp-run-perl'        => '1',
+        },
+        removed => {
+           'perlcc'                => 1,
+        }
+    },
+
+    5.010000 => {
+        delta_from => 5.009005,
+        changed => {
+        },
+        removed => {
+        }
+    },
+
+    5.008009 => {
+        delta_from => 5.008008,
+        changed => {
+            'corelist'              => '1',
+        },
+        removed => {
+        }
+    },
+
+    5.010001 => {
+        delta_from => 5.010000,
+        changed => {
+        },
+        removed => {
+        }
+    },
+
+    5.011 => {
+        delta_from => 5.010001,
+        changed => {
+        },
+        removed => {
+        }
+    },
+
+    5.011001 => {
+        delta_from => 5.011,
+        changed => {
+        },
+        removed => {
+        }
+    },
+
+    5.011002 => {
+        delta_from => 5.011001,
+        changed => {
+            'perlthanks'            => '1',
+        },
+        removed => {
+        }
+    },
+
+    5.011003 => {
+        delta_from => 5.011002,
+        changed => {
+        },
+        removed => {
+        }
+    },
+
+    5.011004 => {
+        delta_from => 5.011003,
+        changed => {
+        },
+        removed => {
+        }
+    },
+
+    5.011005 => {
+        delta_from => 5.011004,
+        changed => {
+        },
+        removed => {
+        }
+    },
+
+    5.012 => {
+        delta_from => 5.011005,
+        changed => {
+        },
+        removed => {
+        }
+    },
+
+    5.013 => {
+        delta_from => 5.012005,
+        changed => {
+        },
+        removed => {
+        }
+    },
+
+    5.012001 => {
+        delta_from => 5.012,
+        changed => {
+        },
+        removed => {
+        }
+    },
+
+    5.013001 => {
+        delta_from => 5.013,
+        changed => {
+        },
+        removed => {
+        }
+    },
+
+    5.013002 => {
+        delta_from => 5.013001,
+        changed => {
+        },
+        removed => {
+        }
+    },
+
+    5.013003 => {
+        delta_from => 5.013002,
+        changed => {
+        },
+        removed => {
+        }
+    },
+
+    5.013004 => {
+        delta_from => 5.013003,
+        changed => {
+        },
+        removed => {
+        }
+    },
+
+    5.012002 => {
+        delta_from => 5.012001,
+        changed => {
+        },
+        removed => {
+        }
+    },
+
+    5.013005 => {
+        delta_from => 5.013004,
+        changed => {
+        },
+        removed => {
+        }
+    },
+
+    5.013006 => {
+        delta_from => 5.013005,
+        changed => {
+        },
+        removed => {
+        }
+    },
+
+    5.013007 => {
+        delta_from => 5.013006,
+        changed => {
+            'ptargrep'              => '1',
+        },
+        removed => {
+        }
+    },
+
+    5.013008 => {
+        delta_from => 5.013007,
+        changed => {
+        },
+        removed => {
+        }
+    },
+
+    5.013009 => {
+        delta_from => 5.013008,
+        changed => {
+            'json_pp'               => '1',
+        },
+        removed => {
+        }
+    },
+
+    5.012003 => {
+        delta_from => 5.012002,
+        changed => {
+        },
+        removed => {
+        }
+    },
+
+    5.013010 => {
+        delta_from => 5.013009,
+        changed => {
+        },
+        removed => {
+        }
+    },
+
+    5.013011 => {
+        delta_from => 5.013010,
+        changed => {
+        },
+        removed => {
+        }
+    },
+
+    5.014 => {
+        delta_from => 5.013011,
+        changed => {
+        },
+        removed => {
+        }
+    },
+
+    5.014001 => {
+        delta_from => 5.014,
+        changed => {
+        },
+        removed => {
+        }
+    },
+
+    5.015 => {
+        delta_from => 5.014004,
+        changed => {
+        },
+        removed => {
+           'dprofpp'               => 1,
+        }
+    },
+
+    5.012004 => {
+        delta_from => 5.012003,
+        changed => {
+        },
+        removed => {
+        }
+    },
+
+    5.015001 => {
+        delta_from => 5.015,
+        changed => {
+        },
+        removed => {
+        }
+    },
+
+    5.015002 => {
+        delta_from => 5.015001,
+        changed => {
+        },
+        removed => {
+        }
+    },
+
+    5.015003 => {
+        delta_from => 5.015002,
+        changed => {
+        },
+        removed => {
+        }
+    },
+
+    5.014002 => {
+        delta_from => 5.014001,
+        changed => {
+        },
+        removed => {
+        }
+    },
+
+    5.015004 => {
+        delta_from => 5.015003,
+        changed => {
+        },
+        removed => {
+        }
+    },
+
+    5.015005 => {
+        delta_from => 5.015004,
+        changed => {
+        },
+        removed => {
+        }
+    },
+
+    5.015006 => {
+        delta_from => 5.015005,
+        changed => {
+            'zipdetails'            => '1',
+        },
+        removed => {
+        }
+    },
+
+    5.015007 => {
+        delta_from => 5.015006,
+        changed => {
+        },
+        removed => {
+        }
+    },
+
+    5.015008 => {
+        delta_from => 5.015007,
+        changed => {
+        },
+        removed => {
+        }
+    },
+
+    5.015009 => {
+        delta_from => 5.015008,
+        changed => {
+        },
+        removed => {
+        }
+    },
+
+    5.016 => {
+        delta_from => 5.015009,
+        changed => {
+        },
+        removed => {
+        }
+    },
+
+    5.017 => {
+        delta_from => 5.016003,
+        changed => {
+        },
+        removed => {
+        }
+    },
+
+    5.017001 => {
+        delta_from => 5.017,
+        changed => {
+        },
+        removed => {
+        }
+    },
+
+    5.017002 => {
+        delta_from => 5.017001,
+        changed => {
+        },
+        removed => {
+        }
+    },
+
+    5.016001 => {
+        delta_from => 5.016,
+        changed => {
+        },
+        removed => {
+        }
+    },
+
+    5.017003 => {
+        delta_from => 5.017002,
+        changed => {
+        },
+        removed => {
+        }
+    },
+
+    5.017004 => {
+        delta_from => 5.017003,
+        changed => {
+        },
+        removed => {
+        }
+    },
+
+    5.014003 => {
+        delta_from => 5.014002,
+        changed => {
+        },
+        removed => {
+        }
+    },
+
+    5.017005 => {
+        delta_from => 5.017004,
+        changed => {
+        },
+        removed => {
+        }
+    },
+
+    5.016002 => {
+        delta_from => 5.016001,
+        changed => {
+        },
+        removed => {
+        }
+    },
+
+    5.012005 => {
+        delta_from => 5.012004,
+        changed => {
+        },
+        removed => {
+        }
+    },
+
+    5.017006 => {
+        delta_from => 5.017005,
+        changed => {
+        },
+        removed => {
+        }
+    },
+
+    5.017007 => {
+        delta_from => 5.017006,
+        changed => {
+        },
+        removed => {
+        }
+    },
+
+    5.017008 => {
+        delta_from => 5.017007,
+        changed => {
+        },
+        removed => {
+        }
+    },
+
+    5.017009 => {
+        delta_from => 5.017008,
+        changed => {
+        },
+        removed => {
+        }
+    },
+
+    5.014004 => {
+        delta_from => 5.014003,
+        changed => {
+        },
+        removed => {
+        }
+    },
+
+    5.016003 => {
+        delta_from => 5.016002,
+        changed => {
+        },
+        removed => {
+        }
+    },
+
+    5.017010 => {
+        delta_from => 5.017009,
+        changed => {
+        },
+        removed => {
+        }
+    },
+
+    5.017011 => {
+        delta_from => 5.017010,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.018000 => {
+        delta_from => 5.017011,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.018001 => {
+        delta_from => 5.018000,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.018002 => {
+        delta_from => 5.018001,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.018003 => {
+        delta_from => 5.018000,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.018004 => {
+        delta_from => 5.018000,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.019000 => {
+        delta_from => 5.018000,
+        changed => {
+        },
+        removed => {
+            'cpan2dist'             => '1',
+            'cpanp'                 => '1',
+            'cpanp-run-perl'        => '1',
+            'pod2latex'             => '1',
+        }
+    },
+    5.019001 => {
+        delta_from => 5.019000,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.019002 => {
+        delta_from => 5.019001,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.019003 => {
+        delta_from => 5.019002,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.019004 => {
+        delta_from => 5.019003,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.019005 => {
+        delta_from => 5.019004,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.019006 => {
+        delta_from => 5.019005,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.019007 => {
+        delta_from => 5.019006,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.019008 => {
+        delta_from => 5.019007,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.019009 => {
+        delta_from => 5.019008,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.019010 => {
+        delta_from => 5.019009,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.019011 => {
+        delta_from => 5.019010,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.020000 => {
+        delta_from => 5.019011,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.021000 => {
+        delta_from => 5.020000,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.021001 => {
+        delta_from => 5.021000,
+        changed => {
+        },
+        removed => {
+            'a2p'                   => 1,
+            'config_data'           => 1,
+            'find2perl'             => 1,
+            'psed'                  => 1,
+            's2p'                   => 1,
+        }
+    },
+    5.021002 => {
+        delta_from => 5.021001,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.021003 => {
+        delta_from => 5.021002,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.020001 => {
+        delta_from => 5.02,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.021004 => {
+        delta_from => 5.021003,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.021005 => {
+        delta_from => 5.021004,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.021006 => {
+        delta_from => 5.021005,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.021007 => {
+        delta_from => 5.021006,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.021008 => {
+        delta_from => 5.021007,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.020002 => {
+        delta_from => 5.020001,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.021009 => {
+        delta_from => 5.021008,
+        changed => {
+            'encguess'              => '1',
+        },
+        removed => {
+        }
+    },
+    5.021010 => {
+        delta_from => 5.021009,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.021011 => {
+        delta_from => 5.02101,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.022000 => {
+        delta_from => 5.021011,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.023000 => {
+        delta_from => 5.022000,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.023001 => {
+        delta_from => 5.023,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.023002 => {
+        delta_from => 5.023001,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.020003 => {
+        delta_from => 5.020002,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.023003 => {
+        delta_from => 5.023002,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.023004 => {
+        delta_from => 5.023003,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.023005 => {
+        delta_from => 5.023004,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.022001 => {
+        delta_from => 5.022,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.023006 => {
+        delta_from => 5.023005,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.023007 => {
+        delta_from => 5.023006,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.023008 => {
+        delta_from => 5.023007,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.023009 => {
+        delta_from => 5.023008,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.022002 => {
+        delta_from => 5.022001,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.024000 => {
+        delta_from => 5.023009,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.025000 => {
+        delta_from => 5.024000,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.025001 => {
+        delta_from => 5.025000,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.025002 => {
+        delta_from => 5.025001,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.025003 => {
+        delta_from => 5.025002,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.025004 => {
+        delta_from => 5.025003,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.025005 => {
+        delta_from => 5.025004,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.025006 => {
+        delta_from => 5.025005,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.025007 => {
+        delta_from => 5.025006,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.025008 => {
+        delta_from => 5.025007,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.022003 => {
+        delta_from => 5.022002,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.024001 => {
+        delta_from => 5.024000,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.025009 => {
+        delta_from => 5.025008,
+        changed => {
+        },
+        removed => {
+            'c2ph'                  => 1,
+            'pstruct'               => 1,
+        }
+    },
+    5.025010 => {
+        delta_from => 5.025009,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.025011 => {
+        delta_from => 5.025010,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.025012 => {
+        delta_from => 5.025011,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.026000 => {
+        delta_from => 5.025012,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.027000 => {
+        delta_from => 5.026000,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.027001 => {
+        delta_from => 5.027000,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.022004 => {
+        delta_from => 5.022003,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.024002 => {
+        delta_from => 5.024001,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.027002 => {
+        delta_from => 5.027001,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.027003 => {
+        delta_from => 5.027002,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.027004 => {
+        delta_from => 5.027003,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.024003 => {
+        delta_from => 5.024002,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.026001 => {
+        delta_from => 5.026000,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.027005 => {
+        delta_from => 5.027004,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.027006 => {
+        delta_from => 5.027005,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.027007 => {
+        delta_from => 5.027006,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.027008 => {
+        delta_from => 5.027007,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.027009 => {
+        delta_from => 5.027008,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.027010 => {
+        delta_from => 5.027009,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.024004 => {
+        delta_from => 5.024003,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.026002 => {
+        delta_from => 5.026001,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.027011 => {
+        delta_from => 5.027010,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.028000 => {
+        delta_from => 5.027011,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.029000 => {
+        delta_from => 5.028,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.029001 => {
+        delta_from => 5.029000,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.029002 => {
+        delta_from => 5.029001,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.029003 => {
+        delta_from => 5.029002,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.029004 => {
+        delta_from => 5.029003,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.029005 => {
+        delta_from => 5.029004,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.026003 => {
+        delta_from => 5.026002,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.028001 => {
+        delta_from => 5.028000,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.029006 => {
+        delta_from => 5.029005,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.029007 => {
+        delta_from => 5.029006,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.029008 => {
+        delta_from => 5.029007,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.029009 => {
+        delta_from => 5.029008,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.028002 => {
+        delta_from => 5.028001,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.029010 => {
+        delta_from => 5.029009,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.030000 => {
+        delta_from => 5.029010,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.031000 => {
+        delta_from => 5.03,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.031001 => {
+        delta_from => 5.031,
+        changed => {
+        },
+        removed => {
+            'podselect'             => 1,
+        }
+    },
+    5.031002 => {
+        delta_from => 5.031001,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.031003 => {
+        delta_from => 5.031002,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.031004 => {
+        delta_from => 5.031003,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.031005 => {
+        delta_from => 5.031004,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.030001 => {
+        delta_from => 5.03,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.031006 => {
+        delta_from => 5.031005,
+        changed => {
+            'streamzip'             => '1',
+        },
+        removed => {
+        }
+    },
+    5.031007 => {
+        delta_from => 5.031006,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.031008 => {
+        delta_from => 5.031007,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.031009 => {
+        delta_from => 5.031008,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.030002 => {
+        delta_from => 5.030001,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.031010 => {
+        delta_from => 5.031009,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.031011 => {
+        delta_from => 5.031010,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.028003 => {
+        delta_from => 5.028002,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.030003 => {
+        delta_from => 5.030002,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.032000 => {
+        delta_from => 5.031011,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.033000 => {
+        delta_from => 5.032,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.033001 => {
+        delta_from => 5.033000,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.033002 => {
+        delta_from => 5.033001,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.033003 => {
+        delta_from => 5.033002,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.033004 => {
+        delta_from => 5.033003,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.033005 => {
+        delta_from => 5.033004,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.033006 => {
+        delta_from => 5.033005,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.032001 => {
+        delta_from => 5.032000,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.033007 => {
+        delta_from => 5.033006,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.033008 => {
+        delta_from => 5.033007,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.033009 => {
+        delta_from => 5.033008,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.034000 => {
+        delta_from => 5.033009,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.035000 => {
+        delta_from => 5.034000,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.035001 => {
+        delta_from => 5.035,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.035002 => {
+        delta_from => 5.035001,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.035003 => {
+        delta_from => 5.035002,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.035004 => {
+        delta_from => 5.035003,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.035005 => {
+        delta_from => 5.035004,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.035006 => {
+        delta_from => 5.035005,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.035007 => {
+        delta_from => 5.035006,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.035008 => {
+        delta_from => 5.035007,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.035009 => {
+        delta_from => 5.035008,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.034001 => {
+        delta_from => 5.034000,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.035010 => {
+        delta_from => 5.035009,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.035011 => {
+        delta_from => 5.035010,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.036000 => {
+        delta_from => 5.035011,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.037000 => {
+        delta_from => 5.036000,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.037001 => {
+        delta_from => 5.037,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.037002 => {
+        delta_from => 5.037001,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.037003 => {
+        delta_from => 5.037002,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.037004 => {
+        delta_from => 5.037003,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.037005 => {
+        delta_from => 5.037004,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.037006 => {
+        delta_from => 5.037005,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.037007 => {
+        delta_from => 5.037006,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.037008 => {
+        delta_from => 5.037007,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.037009 => {
+        delta_from => 5.037008,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.037010 => {
+        delta_from => 5.037009,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.037011 => {
+        delta_from => 5.03701,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.036001 => {
+        delta_from => 5.036000,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.038000 => {
+        delta_from => 5.037011,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.039001 => {
+        delta_from => 5.038,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.039002 => {
+        delta_from => 5.039001,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.039003 => {
+        delta_from => 5.039002,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.039004 => {
+        delta_from => 5.039003,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.039005 => {
+        delta_from => 5.039004,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.034002 => {
+        delta_from => 5.034001,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.036002 => {
+        delta_from => 5.036001,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.038001 => {
+        delta_from => 5.038000,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.034003 => {
+        delta_from => 5.034002,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.036003 => {
+        delta_from => 5.036002,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.038002 => {
+        delta_from => 5.038001,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.039006 => {
+        delta_from => 5.039005,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.039007 => {
+        delta_from => 5.039006,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.039008 => {
+        delta_from => 5.039007,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.039009 => {
+        delta_from => 5.039008,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.039010 => {
+        delta_from => 5.039009,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.040000 => {
+        delta_from => 5.039010,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.041000 => {
+        delta_from => 5.040000,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.041001 => {
+        delta_from => 5.041000,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.041002 => {
+        delta_from => 5.041001,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.041003 => {
+        delta_from => 5.041002,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.041004 => {
+        delta_from => 5.041003,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.041005 => {
+        delta_from => 5.041004,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.041006 => {
+        delta_from => 5.041005,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.041007 => {
+        delta_from => 5.041006,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.038003 => {
+        delta_from => 5.038002,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.040001 => {
+        delta_from => 5.040000,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.041008 => {
+        delta_from => 5.041007,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.041009 => {
+        delta_from => 5.041008,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.041010 => {
+        delta_from => 5.041009,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.038004 => {
+        delta_from => 5.038003,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.040002 => {
+        delta_from => 5.040001,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.041011 => {
+        delta_from => 5.041010,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.041012 => {
+        delta_from => 5.041011,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.041013 => {
+        delta_from => 5.041012,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.042000 => {
+        delta_from => 5.041013,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.043000 => {
+        delta_from => 5.042000,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.043001 => {
+        delta_from => 5.043,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.038005 => {
+        delta_from => 5.038004,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.040003 => {
+        delta_from => 5.040002,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.043002 => {
+        delta_from => 5.043001,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.043003 => {
+        delta_from => 5.043002,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.043004 => {
+        delta_from => 5.043003,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.043005 => {
+        delta_from => 5.043004,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.043006 => {
+        delta_from => 5.043005,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.043007 => {
+        delta_from => 5.043006,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.043008 => {
+        delta_from => 5.043007,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.042001 => {
+        delta_from => 5.042000,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.043009 => {
+        delta_from => 5.043008,
+        changed => {
+        },
+        removed => {
+        }
+    },
+    5.042002 => {
+        delta_from => 5.042001,
+        changed => {
+        },
+        removed => {
+        }
+    },
+);
+
+%utilities = Module::CoreList::_undelta(\%delta);
+
+# Create aliases with trailing zeros for $] use
+
+$utilities{'5.000'} = $utilities{5};
+
+_create_aliases(\%utilities);
+
+sub _create_aliases {
+    my ($hash) = @_;
+
+    for my $version (keys %$hash) {
+        next unless $version >= 5.010;
+
+        my $padded = sprintf "%0.6f", $version;
+
+        # If the version in string form isn't the same as the numeric version,
+        # alias it.
+        if ($padded ne $version && $version == $padded) {
+            $hash->{$padded} = $hash->{$version};
+        }
+    }
+}
+
+'foo';
+
+=pod
+
+=head1 NAME
+
+Module::CoreList::Utils - what utilities shipped with versions of perl
+
+=head1 SYNOPSIS
+
+ use Module::CoreList::Utils;
+
+ print $Module::CoreList::Utils::utilities{5.009003}{ptar}; # prints 1
+
+ print Module::CoreList::Utils->first_release('corelist');
+ # prints 5.008009
+
+ print Module::CoreList::Utils->first_release_by_date('corelist');
+ # prints 5.009002
+
+=head1 DESCRIPTION
+
+Module::CoreList::Utils provides information on which core and dual-life utilities shipped
+with each version of L<perl>.
+
+It provides a number of mechanisms for querying this information.
+
+There is a functional programming API available for programmers to query
+information.
+
+Programmers may also query the contained hash structure to find relevant
+information.
+
+=head1 FUNCTIONS API
+
+These are the functions that are available, they may either be called as functions or class methods:
+
+  Module::CoreList::Utils::first_release('corelist'); # as a function
+
+  Module::CoreList::Utils->first_release('corelist'); # class method
+
+=over
+
+=item C<utilities>
+
+Requires a perl version as an argument, returns a list of utilities that shipped with
+that version of perl, or undef/empty list if that perl doesn't exist.
+
+=item C<first_release( UTILITY )>
+
+Requires a UTILITY name as an argument, returns the perl version when that utility first
+appeared in core as ordered by perl version number or undef ( in scalar context )
+or an empty list ( in list context ) if that utility is not in core.
+
+=item C<first_release_by_date( UTILITY )>
+
+Requires a UTILITY name as an argument, returns the perl version when that utility first
+appeared in core as ordered by release date or undef ( in scalar context )
+or an empty list ( in list context ) if that utility is not in core.
+
+=item C<removed_from( UTILITY )>
+
+Takes a UTILITY name as an argument, returns the first perl version where that utility
+was removed from core. Returns undef if the given utility was never in core or remains
+in core.
+
+=item C<removed_from_by_date( UTILITY )>
+
+Takes a UTILITY name as an argument, returns the first perl version by release date where that
+utility was removed from core. Returns undef if the given utility was never in core or remains
+in core.
+
+=back
+
+=head1 DATA STRUCTURES
+
+These are the hash data structures that are available:
+
+=over
+
+=item C<%Module::CoreList::Utils::utilities>
+
+A hash of hashes that is keyed on perl version as indicated
+in $].  The second level hash is utility / defined pairs.
+
+=back
+
+=head1 AUTHOR
+
+Chris C<BinGOs> Williams <chris@bingosnet.co.uk>
+
+Currently maintained by the perl 5 porters E<lt>perl5-porters@perl.orgE<gt>.
+
+This module is the result of archaeology undertaken during QA Hackathon
+in Lancaster, April 2013.
+
+=head1 LICENSE
+
+Copyright (C) 2013 Chris Williams.  All Rights Reserved.
+
+This module is free software; you can redistribute it and/or modify it
+under the same terms as Perl itself.
+
+=head1 SEE ALSO
+
+L<corelist>, L<Module::CoreList>, L<perl>, L<http://perlpunks.de/corelist>
+
+=cut

git/usr/share/perl5/core_perl/Module/Load/Conditional.pm

@@ -0,0 +1,624 @@
+package Module::Load::Conditional;
+
+use strict;
+
+use Module::Load qw/load autoload_remote/;
+use Params::Check                       qw[check];
+use Locale::Maketext::Simple Style  => 'gettext';
+
+use Carp        ();
+use File::Spec  ();
+use FileHandle  ();
+use version;
+
+use Module::Metadata ();
+
+use constant ON_VMS   => $^O eq 'VMS';
+use constant ON_WIN32 => $^O eq 'MSWin32' ? 1 : 0;
+use constant QUOTE    => do { ON_WIN32 ? q["] : q['] };
+
+BEGIN {
+    use vars        qw[ $VERSION @ISA $VERBOSE $CACHE @EXPORT_OK $DEPRECATED
+                        $FIND_VERSION $ERROR $CHECK_INC_HASH $FORCE_SAFE_INC ];
+    use Exporter;
+    @ISA            = qw[Exporter];
+    $VERSION        = '0.74';
+    $VERBOSE        = 0;
+    $DEPRECATED     = 0;
+    $FIND_VERSION   = 1;
+    $CHECK_INC_HASH = 0;
+    $FORCE_SAFE_INC = 0;
+    @EXPORT_OK      = qw[check_install can_load requires];
+}
+
+=pod
+
+=head1 NAME
+
+Module::Load::Conditional - Looking up module information / loading at runtime
+
+=head1 SYNOPSIS
+
+    use Module::Load::Conditional qw[can_load check_install requires];
+
+
+    my $use_list = {
+            CPANPLUS        => 0.05,
+            LWP             => 5.60,
+            'Test::More'    => undef,
+    };
+
+    print can_load( modules => $use_list )
+            ? 'all modules loaded successfully'
+            : 'failed to load required modules';
+
+
+    my $rv = check_install( module => 'LWP', version => 5.60 )
+                or print 'LWP is not installed!';
+
+    print 'LWP up to date' if $rv->{uptodate};
+    print "LWP version is $rv->{version}\n";
+    print "LWP is installed as file $rv->{file}\n";
+
+
+    print "LWP requires the following modules to be installed:\n";
+    print join "\n", requires('LWP');
+
+    ### allow M::L::C to peek in your %INC rather than just
+    ### scanning @INC
+    $Module::Load::Conditional::CHECK_INC_HASH = 1;
+
+    ### reset the 'can_load' cache
+    undef $Module::Load::Conditional::CACHE;
+
+    ### don't have Module::Load::Conditional issue warnings --
+    ### default is '1'
+    $Module::Load::Conditional::VERBOSE = 0;
+
+    ### The last error that happened during a call to 'can_load'
+    my $err = $Module::Load::Conditional::ERROR;
+
+
+=head1 DESCRIPTION
+
+Module::Load::Conditional provides simple ways to query and possibly load any of
+the modules you have installed on your system during runtime.
+
+It is able to load multiple modules at once or none at all if one of
+them was not able to load. It also takes care of any error checking
+and so forth.
+
+=head1 Methods
+
+=head2 $href = check_install( module => NAME [, version => VERSION, verbose => BOOL ] );
+
+C<check_install> allows you to verify if a certain module is installed
+or not. You may call it with the following arguments:
+
+=over 4
+
+=item module
+
+The name of the module you wish to verify -- this is a required key
+
+=item version
+
+The version this module needs to be -- this is optional
+
+=item verbose
+
+Whether or not to be verbose about what it is doing -- it will default
+to $Module::Load::Conditional::VERBOSE
+
+=back
+
+It will return undef if it was not able to find where the module was
+installed, or a hash reference with the following keys if it was able
+to find the file:
+
+=over 4
+
+=item file
+
+Full path to the file that contains the module
+
+=item dir
+
+Directory, or more exact the C<@INC> entry, where the module was
+loaded from.
+
+=item version
+
+The version number of the installed module - this will be C<undef> if
+the module had no (or unparsable) version number, or if the variable
+C<$Module::Load::Conditional::FIND_VERSION> was set to true.
+(See the C<GLOBAL VARIABLES> section below for details)
+
+=item uptodate
+
+A boolean value indicating whether or not the module was found to be
+at least the version you specified. If you did not specify a version,
+uptodate will always be true if the module was found.
+If no parsable version was found in the module, uptodate will also be
+true, since C<check_install> had no way to verify clearly.
+
+See also C<$Module::Load::Conditional::DEPRECATED>, which affects
+the outcome of this value.
+
+=back
+
+=cut
+
+### this checks if a certain module is installed already ###
+### if it returns true, the module in question is already installed
+### or we found the file, but couldn't open it, OR there was no version
+### to be found in the module
+### it will return 0 if the version in the module is LOWER then the one
+### we are looking for, or if we couldn't find the desired module to begin with
+### if the installed version is higher or equal to the one we want, it will return
+### a hashref with he module name and version in it.. so 'true' as well.
+sub check_install {
+    my %hash = @_;
+
+    my $tmpl = {
+            version => { default    => '0.0'    },
+            module  => { required   => 1        },
+            verbose => { default    => $VERBOSE },
+    };
+
+    my $args;
+    unless( $args = check( $tmpl, \%hash, $VERBOSE ) ) {
+        warn loc( q[A problem occurred checking arguments] ) if $VERBOSE;
+        return;
+    }
+
+    my $file     = File::Spec->catfile( split /::/, $args->{module} ) . '.pm';
+    my $file_inc = File::Spec::Unix->catfile(
+                        split /::/, $args->{module}
+                    ) . '.pm';
+
+    ### where we store the return value ###
+    my $href = {
+            file        => undef,
+            version     => undef,
+            uptodate    => undef,
+    };
+
+    my $filename;
+
+    ### check the inc hash if we're allowed to
+    if( $CHECK_INC_HASH ) {
+        $filename = $href->{'file'} =
+            $INC{ $file_inc } if defined $INC{ $file_inc };
+
+        ### find the version by inspecting the package
+        if( defined $filename && $FIND_VERSION ) {
+            no strict 'refs';
+            $href->{version} = ${ "$args->{module}"."::VERSION" };
+        }
+    }
+
+    ### we didn't find the filename yet by looking in %INC,
+    ### so scan the dirs
+    unless( $filename ) {
+
+        local @INC = @INC[0..$#INC-1] if $FORCE_SAFE_INC && $INC[-1] eq '.';
+
+        DIR: for my $dir ( @INC ) {
+
+            my $fh;
+
+            if ( ref $dir ) {
+                ### @INC hook -- we invoke it and get the filehandle back
+                ### this is actually documented behaviour as of 5.8 ;)
+
+                my $existed_in_inc = $INC{$file_inc};
+
+                if (UNIVERSAL::isa($dir, 'CODE')) {
+                    ($fh) = $dir->($dir, $file);
+
+                } elsif (UNIVERSAL::isa($dir, 'ARRAY')) {
+                    ($fh) = $dir->[0]->($dir, $file, @{$dir}{1..$#{$dir}})
+
+                } elsif (UNIVERSAL::can($dir, 'INC')) {
+                    ($fh) = $dir->INC($file);
+                }
+
+                if (!UNIVERSAL::isa($fh, 'GLOB')) {
+                    warn loc(q[Cannot open file '%1': %2], $file, $!)
+                            if $args->{verbose};
+                    next;
+                }
+
+                $filename = $INC{$file_inc} || $file;
+
+                delete $INC{$file_inc} if not $existed_in_inc;
+
+            } else {
+                $filename = File::Spec->catfile($dir, $file);
+                next unless -e $filename;
+
+                $fh = FileHandle->new();
+                if (!$fh->open($filename)) {
+                    warn loc(q[Cannot open file '%1': %2], $file, $!)
+                            if $args->{verbose};
+                    next;
+                }
+            }
+
+            ### store the directory we found the file in
+            $href->{dir} = $dir;
+
+            ### files need to be in unix format under vms,
+            ### or they might be loaded twice
+            $href->{file} = ON_VMS
+                ? VMS::Filespec::unixify( $filename )
+                : $filename;
+
+            ### if we don't need the version, we're done
+            last DIR unless $FIND_VERSION;
+
+            ### otherwise, the user wants us to find the version from files
+
+            {
+              local $SIG{__WARN__} = sub {};
+              my $ver = eval {
+                my $mod_info = Module::Metadata->new_from_handle( $fh, $filename );
+                $mod_info->version( $args->{module} );
+              };
+
+              if( defined $ver ) {
+                  $href->{version} = $ver;
+
+                  last DIR;
+              }
+            }
+        }
+    }
+
+    ### if we couldn't find the file, return undef ###
+    return unless defined $href->{file};
+
+    ### only complain if we're expected to find a version higher than 0.0 anyway
+    if( $FIND_VERSION and not defined $href->{version} ) {
+        {   ### don't warn about the 'not numeric' stuff ###
+            local $^W;
+
+            ### if we got here, we didn't find the version
+            warn loc(q[Could not check version on '%1'], $args->{module} )
+                    if $args->{verbose} and $args->{version} > 0;
+        }
+        $href->{uptodate} = 1;
+
+    } else {
+        ### don't warn about the 'not numeric' stuff ###
+        local $^W;
+
+        ### use qv(), as it will deal with developer release number
+        ### ie ones containing _ as well. This addresses bug report
+        ### #29348: Version compare logic doesn't handle alphas?
+        ###
+        ### Update from JPeacock: apparently qv() and version->new
+        ### are different things, and we *must* use version->new
+        ### here, or things like #30056 might start happening
+
+        ### We have to wrap this in an eval as version-0.82 raises
+        ### exceptions and not warnings now *sigh*
+
+        eval {
+
+          $href->{uptodate} =
+            version->new( $args->{version} ) <= version->new( $href->{version} )
+                ? 1
+                : 0;
+
+        };
+    }
+
+    if ( $DEPRECATED and "$]" >= 5.011 ) {
+        local @INC = @INC[0..$#INC-1] if $FORCE_SAFE_INC && $INC[-1] eq '.';
+        require Module::CoreList;
+        require Config;
+
+        no warnings 'once';
+        $href->{uptodate} = 0 if
+           exists $Module::CoreList::version{ 0+$] }{ $args->{module} } and
+           Module::CoreList::is_deprecated( $args->{module} ) and
+           $Config::Config{privlibexp} eq $href->{dir}
+           and $Config::Config{privlibexp} ne $Config::Config{sitelibexp};
+    }
+
+    return $href;
+}
+
+=head2 $bool = can_load( modules => { NAME => VERSION [,NAME => VERSION] }, [verbose => BOOL, nocache => BOOL, autoload => BOOL] )
+
+C<can_load> will take a list of modules, optionally with version
+numbers and determine if it is able to load them. If it can load *ALL*
+of them, it will. If one or more are unloadable, none will be loaded.
+
+This is particularly useful if you have More Than One Way (tm) to
+solve a problem in a program, and only wish to continue down a path
+if all modules could be loaded, and not load them if they couldn't.
+
+This function uses the C<load> function or the C<autoload_remote> function
+from Module::Load under the hood.
+
+C<can_load> takes the following arguments:
+
+=over 4
+
+=item modules
+
+This is a hashref of module/version pairs. The version indicates the
+minimum version to load. If no version is provided, any version is
+assumed to be good enough.
+
+=item verbose
+
+This controls whether warnings should be printed if a module failed
+to load.
+The default is to use the value of $Module::Load::Conditional::VERBOSE.
+
+=item nocache
+
+C<can_load> keeps its results in a cache, so it will not load the
+same module twice, nor will it attempt to load a module that has
+already failed to load before. By default, C<can_load> will check its
+cache, but you can override that by setting C<nocache> to true.
+
+=item autoload
+
+This controls whether imports the functions of a loaded modules to the caller package. The default is no importing any functions.
+
+See the C<autoload> function and the C<autoload_remote> function from L<Module::Load> for details.
+
+=cut
+
+sub can_load {
+    my %hash = @_;
+
+    my $tmpl = {
+        modules     => { default => {}, strict_type => 1 },
+        verbose     => { default => $VERBOSE },
+        nocache     => { default => 0 },
+        autoload    => { default => 0 },
+    };
+
+    my $args;
+
+    unless( $args = check( $tmpl, \%hash, $VERBOSE ) ) {
+        $ERROR = loc(q[Problem validating arguments!]);
+        warn $ERROR if $VERBOSE;
+        return;
+    }
+
+    ### layout of $CACHE:
+    ### $CACHE = {
+    ###     $ module => {
+    ###             usable  => BOOL,
+    ###             version => \d,
+    ###             file    => /path/to/file,
+    ###     },
+    ### };
+
+    $CACHE ||= {}; # in case it was undef'd
+
+    my $error;
+    BLOCK: {
+        my $href = $args->{modules};
+
+        my @load;
+        for my $mod ( keys %$href ) {
+
+            next if $CACHE->{$mod}->{usable} && !$args->{nocache};
+
+            ### else, check if the hash key is defined already,
+            ### meaning $mod => 0,
+            ### indicating UNSUCCESSFUL prior attempt of usage
+
+            ### use qv(), as it will deal with developer release number
+            ### ie ones containing _ as well. This addresses bug report
+            ### #29348: Version compare logic doesn't handle alphas?
+            ###
+            ### Update from JPeacock: apparently qv() and version->new
+            ### are different things, and we *must* use version->new
+            ### here, or things like #30056 might start happening
+            if (    !$args->{nocache}
+                    && defined $CACHE->{$mod}->{usable}
+                    && (version->new( $CACHE->{$mod}->{version}||0 )
+                        >= version->new( $href->{$mod} ) )
+            ) {
+                $error = loc( q[Already tried to use '%1', which was unsuccessful], $mod);
+                last BLOCK;
+            }
+
+            my $mod_data = check_install(
+                                    module  => $mod,
+                                    version => $href->{$mod}
+                                );
+
+            if( !$mod_data or !defined $mod_data->{file} ) {
+                $error = loc(q[Could not find or check module '%1'], $mod);
+                $CACHE->{$mod}->{usable} = 0;
+                last BLOCK;
+            }
+
+            map {
+                $CACHE->{$mod}->{$_} = $mod_data->{$_}
+            } qw[version file uptodate];
+
+            push @load, $mod;
+        }
+
+        for my $mod ( @load ) {
+
+            if ( $CACHE->{$mod}->{uptodate} ) {
+
+                local @INC = @INC[0..$#INC-1] if $FORCE_SAFE_INC && $INC[-1] eq '.';
+
+                if ( $args->{autoload} ) {
+                    my $who = (caller())[0];
+                    eval { autoload_remote $who, $mod };
+                } else {
+                    eval { load $mod };
+                }
+
+                ### in case anything goes wrong, log the error, the fact
+                ### we tried to use this module and return 0;
+                if( $@ ) {
+                    $error = $@;
+                    $CACHE->{$mod}->{usable} = 0;
+                    last BLOCK;
+                } else {
+                    $CACHE->{$mod}->{usable} = 1;
+                }
+
+            ### module not found in @INC, store the result in
+            ### $CACHE and return 0
+            } else {
+
+                $error = loc(q[Module '%1' is not uptodate!], $mod);
+                $CACHE->{$mod}->{usable} = 0;
+                last BLOCK;
+            }
+        }
+
+    } # BLOCK
+
+    if( defined $error ) {
+        $ERROR = $error;
+        Carp::carp( loc(q|%1 [THIS MAY BE A PROBLEM!]|,$error) ) if $args->{verbose};
+        return;
+    } else {
+        return 1;
+    }
+}
+
+=back
+
+=head2 @list = requires( MODULE );
+
+C<requires> can tell you what other modules a particular module
+requires. This is particularly useful when you're intending to write
+a module for public release and are listing its prerequisites.
+
+C<requires> takes but one argument: the name of a module.
+It will then first check if it can actually load this module, and
+return undef if it can't.
+Otherwise, it will return a list of modules and pragmas that would
+have been loaded on the module's behalf.
+
+Note: The list C<require> returns has originated from your current
+perl and your current install.
+
+=cut
+
+sub requires {
+    my $who = shift;
+
+    unless( check_install( module => $who ) ) {
+        warn loc(q[You do not have module '%1' installed], $who) if $VERBOSE;
+        return undef;
+    }
+
+    local @INC = @INC[0..$#INC-1] if $FORCE_SAFE_INC && $INC[-1] eq '.';
+
+    my $lib = join " ", map { qq["-I$_"] } @INC;
+    my $oneliner = 'print(join(qq[\n],map{qq[BONG=$_]}keys(%INC)),qq[\n])';
+    my $cmd = join '', qq["$^X" $lib -M$who -e], QUOTE, $oneliner, QUOTE;
+
+    return  sort
+                grep { !/^$who$/  }
+                map  { chomp; s|/|::|g; $_ }
+                grep { s|\.pm$||i; }
+                map  { s!^BONG\=!!; $_ }
+                grep { m!^BONG\=! }
+            `$cmd`;
+}
+
+1;
+
+__END__
+
+=head1 Global Variables
+
+The behaviour of Module::Load::Conditional can be altered by changing the
+following global variables:
+
+=head2 $Module::Load::Conditional::VERBOSE
+
+This controls whether Module::Load::Conditional will issue warnings and
+explanations as to why certain things may have failed. If you set it
+to 0, Module::Load::Conditional will not output any warnings.
+The default is 0;
+
+=head2 $Module::Load::Conditional::FIND_VERSION
+
+This controls whether Module::Load::Conditional will try to parse
+(and eval) the version from the module you're trying to load.
+
+If you don't wish to do this, set this variable to C<false>. Understand
+then that version comparisons are not possible, and Module::Load::Conditional
+can not tell you what module version you have installed.
+This may be desirable from a security or performance point of view.
+Note that C<$FIND_VERSION> code runs safely under C<taint mode>.
+
+The default is 1;
+
+=head2 $Module::Load::Conditional::CHECK_INC_HASH
+
+This controls whether C<Module::Load::Conditional> checks your
+C<%INC> hash to see if a module is available. By default, only
+C<@INC> is scanned to see if a module is physically on your
+filesystem, or available via an C<@INC-hook>. Setting this variable
+to C<true> will trust any entries in C<%INC> and return them for
+you.
+
+The default is 0;
+
+=head2 $Module::Load::Conditional::FORCE_SAFE_INC
+
+This controls whether C<Module::Load::Conditional> sanitises C<@INC>
+by removing "C<.>". The current default setting is C<0>, but this
+may change in a future release.
+
+=head2 $Module::Load::Conditional::CACHE
+
+This holds the cache of the C<can_load> function. If you explicitly
+want to remove the current cache, you can set this variable to
+C<undef>
+
+=head2 $Module::Load::Conditional::ERROR
+
+This holds a string of the last error that happened during a call to
+C<can_load>. It is useful to inspect this when C<can_load> returns
+C<undef>.
+
+=head2 $Module::Load::Conditional::DEPRECATED
+
+This controls whether C<Module::Load::Conditional> checks if
+a dual-life core module has been deprecated. If this is set to
+true C<check_install> will return false to C<uptodate>, if
+a dual-life module is found to be loaded from C<$Config{privlibexp}>
+
+The default is 0;
+
+=head1 See Also
+
+C<Module::Load>
+
+=head1 BUG REPORTS
+
+Please report bugs or other issues to E<lt>bug-module-load-conditional@rt.cpan.orgE<gt>.
+
+=head1 AUTHOR
+
+This module by Jos Boumans E<lt>kane@cpan.orgE<gt>.
+
+=head1 COPYRIGHT
+
+This library is free software; you may redistribute and/or modify it
+under the same terms as Perl itself.
+
+=cut

git/usr/share/perl5/core_perl/Net/FTP/A.pm

@@ -0,0 +1,115 @@
+## 
+## Package to read/write on ASCII data connections
+##
+
+package Net::FTP::A;
+
+use 5.008001;
+
+use strict;
+use warnings;
+
+use Carp;
+use Net::FTP::dataconn;
+
+our @ISA     = qw(Net::FTP::dataconn);
+our $VERSION = "3.15";
+
+our $buf;
+
+sub read {
+  my $data = shift;
+  local *buf = \$_[0];
+  shift;
+  my $size = shift || croak 'read($buf,$size,[$offset])';
+  my $timeout = @_ ? shift: $data->timeout;
+
+  if (length(${*$data}) < $size && !${*$data}{'net_ftp_eof'}) {
+    my $blksize = ${*$data}{'net_ftp_blksize'};
+    $blksize = $size if $size > $blksize;
+
+    my $l = 0;
+    my $n;
+
+  READ:
+    {
+      my $readbuf = defined(${*$data}{'net_ftp_cr'}) ? "\015" : '';
+
+      $data->can_read($timeout)
+        or croak "Timeout";
+
+      if ($n = sysread($data, $readbuf, $blksize, length $readbuf)) {
+        ${*$data}{'net_ftp_bytesread'} += $n;
+        ${*$data}{'net_ftp_cr'} =
+          substr($readbuf, -1) eq "\015"
+          ? chop($readbuf)
+          : undef;
+      }
+      else {
+        return
+          unless defined $n;
+
+        ${*$data}{'net_ftp_eof'} = 1;
+      }
+
+      $readbuf =~ s/\015\012/\n/sgo;
+      ${*$data} .= $readbuf;
+
+      unless (length(${*$data})) {
+
+        redo READ
+          if ($n > 0);
+
+        $size = length(${*$data})
+          if ($n == 0);
+      }
+    }
+  }
+
+  $buf = substr(${*$data}, 0, $size);
+  substr(${*$data}, 0, $size) = '';
+
+  length $buf;
+}
+
+
+sub write {
+  my $data = shift;
+  local *buf = \$_[0];
+  shift;
+  my $size = shift || croak 'write($buf,$size,[$timeout])';
+  my $timeout = @_ ? shift: $data->timeout;
+
+  my $nr = (my $tmp = substr($buf, 0, $size)) =~ tr/\r\n/\015\012/;
+  $tmp =~ s/(?<!\015)\012/\015\012/sg if $nr;
+  $tmp =~ s/^\015// if ${*$data}{'net_ftp_outcr'};
+  ${*$data}{'net_ftp_outcr'} = substr($tmp, -1) eq "\015";
+
+  # If the remote server has closed the connection we will be signal'd
+  # when we write. This can happen if the disk on the remote server fills up
+
+  local $SIG{PIPE} = 'IGNORE'
+    unless ($SIG{PIPE} || '') eq 'IGNORE'
+    or $^O eq 'MacOS';
+
+  my $len   = length($tmp);
+  my $off   = 0;
+  my $wrote = 0;
+
+  my $blksize = ${*$data}{'net_ftp_blksize'};
+
+  while ($len) {
+    $data->can_write($timeout)
+      or croak "Timeout";
+
+    $off += $wrote;
+    $wrote = syswrite($data, substr($tmp, $off), $len > $blksize ? $blksize : $len);
+    return
+      unless defined($wrote);
+    $len -= $wrote;
+  }
+
+  $size;
+}
+
+1;

git/usr/share/perl5/core_perl/Net/FTP/E.pm

@@ -0,0 +1,13 @@
+package Net::FTP::E;
+
+use 5.008001;
+
+use strict;
+use warnings;
+
+use Net::FTP::I;
+
+our @ISA = qw(Net::FTP::I);
+our $VERSION = "3.15";
+
+1;

git/usr/share/perl5/core_perl/Net/FTP/I.pm

@@ -0,0 +1,84 @@
+## 
+## Package to read/write on BINARY data connections
+##
+
+package Net::FTP::I;
+
+use 5.008001;
+
+use strict;
+use warnings;
+
+use Carp;
+use Net::FTP::dataconn;
+
+our @ISA     = qw(Net::FTP::dataconn);
+our $VERSION = "3.15";
+
+our $buf;
+
+sub read {
+  my $data = shift;
+  local *buf = \$_[0];
+  shift;
+  my $size = shift || croak 'read($buf,$size,[$timeout])';
+  my $timeout = @_ ? shift: $data->timeout;
+
+  my $n;
+
+  if ($size > length ${*$data} and !${*$data}{'net_ftp_eof'}) {
+    $data->can_read($timeout)
+      or croak "Timeout";
+
+    my $blksize = ${*$data}{'net_ftp_blksize'};
+    $blksize = $size if $size > $blksize;
+
+    unless ($n = sysread($data, ${*$data}, $blksize, length ${*$data})) {
+      return unless defined $n;
+      ${*$data}{'net_ftp_eof'} = 1;
+    }
+  }
+
+  $buf = substr(${*$data}, 0, $size);
+
+  $n = length($buf);
+
+  substr(${*$data}, 0, $n) = '';
+
+  ${*$data}{'net_ftp_bytesread'} += $n;
+
+  $n;
+}
+
+
+sub write {
+  my $data = shift;
+  local *buf = \$_[0];
+  shift;
+  my $size = shift || croak 'write($buf,$size,[$timeout])';
+  my $timeout = @_ ? shift: $data->timeout;
+
+  # If the remote server has closed the connection we will be signal'd
+  # when we write. This can happen if the disk on the remote server fills up
+
+  local $SIG{PIPE} = 'IGNORE'
+    unless ($SIG{PIPE} || '') eq 'IGNORE'
+    or $^O eq 'MacOS';
+  my $sent = $size;
+  my $off  = 0;
+
+  my $blksize = ${*$data}{'net_ftp_blksize'};
+  while ($sent > 0) {
+    $data->can_write($timeout)
+      or croak "Timeout";
+
+    my $n = syswrite($data, $buf, $sent > $blksize ? $blksize : $sent, $off);
+    return unless defined($n);
+    $sent -= $n;
+    $off += $n;
+  }
+
+  $size;
+}
+
+1;

git/usr/share/perl5/core_perl/Net/FTP/L.pm

@@ -0,0 +1,13 @@
+package Net::FTP::L;
+
+use 5.008001;
+
+use strict;
+use warnings;
+
+use Net::FTP::I;
+
+our @ISA = qw(Net::FTP::I);
+our $VERSION = "3.15";
+
+1;

git/usr/share/perl5/core_perl/Net/FTP/dataconn.pm

@@ -0,0 +1,237 @@
+##
+## Generic data connection package
+##
+
+package Net::FTP::dataconn;
+
+use 5.008001;
+
+use strict;
+use warnings;
+
+use Carp;
+use Errno;
+use Net::Cmd;
+
+our $VERSION = '3.15';
+
+$Net::FTP::IOCLASS or die "please load Net::FTP before Net::FTP::dataconn";
+our @ISA = $Net::FTP::IOCLASS;
+
+sub reading {
+  my $data = shift;
+  ${*$data}{'net_ftp_bytesread'} = 0;
+}
+
+
+sub abort {
+  my $data = shift;
+  my $ftp  = ${*$data}{'net_ftp_cmd'};
+
+  # no need to abort if we have finished the xfer
+  return $data->close
+    if ${*$data}{'net_ftp_eof'};
+
+  # for some reason if we continuously open RETR connections and not
+  # read a single byte, then abort them after a while the server will
+  # close our connection, this prevents the unexpected EOF on the
+  # command channel -- GMB
+  if (exists ${*$data}{'net_ftp_bytesread'}
+    && (${*$data}{'net_ftp_bytesread'} == 0))
+  {
+    my $buf     = "";
+    my $timeout = $data->timeout;
+    $data->can_read($timeout) && sysread($data, $buf, 1);
+  }
+
+  ${*$data}{'net_ftp_eof'} = 1;    # fake
+
+  $ftp->abort;                     # this will close me
+}
+
+
+sub _close {
+  my $data = shift;
+  my $ftp  = ${*$data}{'net_ftp_cmd'};
+
+  $data->SUPER::close();
+
+  delete ${*$ftp}{'net_ftp_dataconn'}
+    if defined $ftp
+    && exists ${*$ftp}{'net_ftp_dataconn'}
+    && $data == ${*$ftp}{'net_ftp_dataconn'};
+}
+
+
+sub close {
+  my $data = shift;
+  my $ftp  = ${*$data}{'net_ftp_cmd'};
+
+  if (exists ${*$data}{'net_ftp_bytesread'} && !${*$data}{'net_ftp_eof'}) {
+    my $junk;
+    eval { local($SIG{__DIE__}); $data->read($junk, 1, 0) };
+    return $data->abort unless ${*$data}{'net_ftp_eof'};
+  }
+
+  $data->_close;
+
+  return unless defined $ftp;
+
+  $ftp->response() == CMD_OK
+    && $ftp->message =~ /unique file name:\s*(\S*)\s*\)/
+    && (${*$ftp}{'net_ftp_unique'} = $1);
+
+  $ftp->status == CMD_OK;
+}
+
+
+sub _select {
+  my ($data, $timeout, $do_read) = @_;
+  my ($rin, $rout, $win, $wout, $tout, $nfound);
+
+  vec($rin = '', fileno($data), 1) = 1;
+
+  ($win, $rin) = ($rin, $win) unless $do_read;
+
+  while (1) {
+    $nfound = select($rout = $rin, $wout = $win, undef, $tout = $timeout);
+
+    last if $nfound >= 0;
+
+    croak "select: $!"
+      unless $!{EINTR};
+  }
+
+  $nfound;
+}
+
+
+sub can_read {
+  _select(@_[0, 1], 1);
+}
+
+
+sub can_write {
+  _select(@_[0, 1], 0);
+}
+
+
+sub cmd {
+  my $ftp = shift;
+
+  ${*$ftp}{'net_ftp_cmd'};
+}
+
+
+sub bytes_read {
+  my $ftp = shift;
+
+  ${*$ftp}{'net_ftp_bytesread'} || 0;
+}
+
+1;
+
+__END__
+
+=head1 NAME
+
+Net::FTP::dataconn - FTP Client data connection class
+
+=head1 SYNOPSIS
+
+    # Perform IO operations on an FTP client data connection object:
+
+    $num_bytes_read = $obj->read($buffer, $size);
+    $num_bytes_read = $obj->read($buffer, $size, $timeout);
+
+    $num_bytes_written = $obj->write($buffer, $size);
+    $num_bytes_written = $obj->write($buffer, $size, $timeout);
+
+    $num_bytes_read_so_far = $obj->bytes_read();
+
+    $obj->abort();
+
+    $closed_successfully = $obj->close();
+
+=head1 DESCRIPTION
+
+Some of the methods defined in C<Net::FTP> return an object which will
+be derived from this class. The dataconn class itself is derived from
+the C<IO::Socket::INET> class, so any normal IO operations can be performed.
+However the following methods are defined in the dataconn class and IO should
+be performed using these.
+
+=over 4
+
+=item C<read($buffer, $size[, $timeout])>
+
+Read C<$size> bytes of data from the server and place it into C<$buffer>, also
+performing any <CRLF> translation necessary. C<$timeout> is optional, if not
+given, the timeout value from the command connection will be used.
+
+Returns the number of bytes read before any <CRLF> translation.
+
+=item C<write($buffer, $size[, $timeout])>
+
+Write C<$size> bytes of data from C<$buffer> to the server, also
+performing any <CRLF> translation necessary. C<$timeout> is optional, if not
+given, the timeout value from the command connection will be used.
+
+Returns the number of bytes written before any <CRLF> translation.
+
+=item C<bytes_read()>
+
+Returns the number of bytes read so far.
+
+=item C<abort()>
+
+Abort the current data transfer.
+
+=item C<close()>
+
+Close the data connection and get a response from the FTP server. Returns
+I<true> if the connection was closed successfully and the first digit of
+the response from the server was a '2'.
+
+=back
+
+=head1 EXPORTS
+
+I<None>.
+
+=head1 KNOWN BUGS
+
+I<None>.
+
+=head1 AUTHOR
+
+Graham Barr E<lt>L<gbarr@pobox.com|mailto:gbarr@pobox.com>E<gt>.
+
+Steve Hay E<lt>L<shay@cpan.org|mailto:shay@cpan.org>E<gt> is now maintaining
+libnet as of version 1.22_02.
+
+=head1 COPYRIGHT
+
+Copyright (C) 1997-2010 Graham Barr.  All rights reserved.
+
+Copyright (C) 2013-2014, 2020 Steve Hay.  All rights reserved.
+
+=head1 LICENCE
+
+This module is free software; you can redistribute it and/or modify it under the
+same terms as Perl itself, i.e. under the terms of either the GNU General Public
+License or the Artistic License, as specified in the F<LICENCE> file.
+
+=head1 VERSION
+
+Version 3.15
+
+=head1 DATE
+
+20 March 2023
+
+=head1 HISTORY
+
+See the F<Changes> file.
+
+=cut

git/usr/share/perl5/core_perl/Parse/CPAN/Meta.pm

@@ -0,0 +1,370 @@
+use 5.008001;
+use strict;
+use warnings;
+package Parse::CPAN::Meta;
+# ABSTRACT: Parse META.yml and META.json CPAN metadata files
+
+our $VERSION = '2.150010';
+
+use Exporter;
+use Carp 'croak';
+
+our @ISA = qw/Exporter/;
+our @EXPORT_OK = qw/Load LoadFile/;
+
+sub load_file {
+  my ($class, $filename) = @_;
+
+  my $meta = _slurp($filename);
+
+  if ($filename =~ /\.ya?ml$/) {
+    return $class->load_yaml_string($meta);
+  }
+  elsif ($filename =~ /\.json$/) {
+    return $class->load_json_string($meta);
+  }
+  else {
+    $class->load_string($meta); # try to detect yaml/json
+  }
+}
+
+sub load_string {
+  my ($class, $string) = @_;
+  if ( $string =~ /^---/ ) { # looks like YAML
+    return $class->load_yaml_string($string);
+  }
+  elsif ( $string =~ /^\s*\{/ ) { # looks like JSON
+    return $class->load_json_string($string);
+  }
+  else { # maybe doc-marker-free YAML
+    return $class->load_yaml_string($string);
+  }
+}
+
+sub load_yaml_string {
+  my ($class, $string) = @_;
+  my $backend = $class->yaml_backend();
+  my $data = eval { no strict 'refs'; &{"$backend\::Load"}($string) };
+  croak $@ if $@;
+  return $data || {}; # in case document was valid but empty
+}
+
+sub load_json_string {
+  my ($class, $string) = @_;
+  require Encode;
+  # load_json_string takes characters, decode_json expects bytes
+  my $encoded = Encode::encode('UTF-8', $string, Encode::PERLQQ());
+  my $data = eval { $class->json_decoder()->can('decode_json')->($encoded) };
+  croak $@ if $@;
+  return $data || {};
+}
+
+sub yaml_backend {
+  if ($ENV{PERL_CORE} or not defined $ENV{PERL_YAML_BACKEND} ) {
+    _can_load( 'CPAN::Meta::YAML', 0.011 )
+      or croak "CPAN::Meta::YAML 0.011 is not available\n";
+    return "CPAN::Meta::YAML";
+  }
+  else {
+    my $backend = $ENV{PERL_YAML_BACKEND};
+    _can_load( $backend )
+      or croak "Could not load PERL_YAML_BACKEND '$backend'\n";
+    $backend->can("Load")
+      or croak "PERL_YAML_BACKEND '$backend' does not implement Load()\n";
+    return $backend;
+  }
+}
+
+sub json_decoder {
+  if ($ENV{PERL_CORE}) {
+    _can_load( 'JSON::PP' => 2.27300 )
+      or croak "JSON::PP 2.27300 is not available\n";
+    return 'JSON::PP';
+  }
+  if (my $decoder = $ENV{CPAN_META_JSON_DECODER}) {
+    _can_load( $decoder )
+      or croak "Could not load CPAN_META_JSON_DECODER '$decoder'\n";
+    $decoder->can('decode_json')
+      or croak "No decode_json sub provided by CPAN_META_JSON_DECODER '$decoder'\n";
+    return $decoder;
+  }
+  return $_[0]->json_backend;
+}
+
+sub json_backend {
+  if ($ENV{PERL_CORE}) {
+    _can_load( 'JSON::PP' => 2.27300 )
+      or croak "JSON::PP 2.27300 is not available\n";
+    return 'JSON::PP';
+  }
+  if (my $backend = $ENV{CPAN_META_JSON_BACKEND}) {
+    _can_load( $backend )
+      or croak "Could not load CPAN_META_JSON_BACKEND '$backend'\n";
+    $backend->can('new')
+      or croak "No constructor provided by CPAN_META_JSON_BACKEND '$backend'\n";
+    return $backend;
+  }
+  if (! $ENV{PERL_JSON_BACKEND} or $ENV{PERL_JSON_BACKEND} eq 'JSON::PP') {
+    _can_load( 'JSON::PP' => 2.27300 )
+      or croak "JSON::PP 2.27300 is not available\n";
+    return 'JSON::PP';
+  }
+  else {
+    _can_load( 'JSON' => 2.5 )
+      or croak  "JSON 2.5 is required for " .
+                "\$ENV{PERL_JSON_BACKEND} = '$ENV{PERL_JSON_BACKEND}'\n";
+    return "JSON";
+  }
+}
+
+sub _slurp {
+  require Encode;
+  open my $fh, "<:raw", "$_[0]" ## no critic
+    or die "can't open $_[0] for reading: $!";
+  my $content = do { local $/; <$fh> };
+  $content = Encode::decode('UTF-8', $content, Encode::PERLQQ());
+  return $content;
+}
+
+sub _can_load {
+  my ($module, $version) = @_;
+  (my $file = $module) =~ s{::}{/}g;
+  $file .= ".pm";
+  return 1 if $INC{$file};
+  return 0 if exists $INC{$file}; # prior load failed
+  eval { require $file; 1 }
+    or return 0;
+  if ( defined $version ) {
+    eval { $module->VERSION($version); 1 }
+      or return 0;
+  }
+  return 1;
+}
+
+# Kept for backwards compatibility only
+# Create an object from a file
+sub LoadFile ($) { ## no critic
+  return Load(_slurp(shift));
+}
+
+# Parse a document from a string.
+sub Load ($) { ## no critic
+  require CPAN::Meta::YAML;
+  my $object = eval { CPAN::Meta::YAML::Load(shift) };
+  croak $@ if $@;
+  return $object;
+}
+
+1;
+
+__END__
+
+=pod
+
+=encoding UTF-8
+
+=head1 NAME
+
+Parse::CPAN::Meta - Parse META.yml and META.json CPAN metadata files
+
+=head1 VERSION
+
+version 2.150010
+
+=head1 SYNOPSIS
+
+    #############################################
+    # In your file
+
+    ---
+    name: My-Distribution
+    version: 1.23
+    resources:
+      homepage: "http://example.com/dist/My-Distribution"
+
+
+    #############################################
+    # In your program
+
+    use Parse::CPAN::Meta;
+
+    my $distmeta = Parse::CPAN::Meta->load_file('META.yml');
+
+    # Reading properties
+    my $name     = $distmeta->{name};
+    my $version  = $distmeta->{version};
+    my $homepage = $distmeta->{resources}{homepage};
+
+=head1 DESCRIPTION
+
+B<Parse::CPAN::Meta> is a parser for F<META.json> and F<META.yml> files, using
+L<JSON::PP> and/or L<CPAN::Meta::YAML>.
+
+B<Parse::CPAN::Meta> provides three methods: C<load_file>, C<load_json_string>,
+and C<load_yaml_string>.  These will read and deserialize CPAN metafiles, and
+are described below in detail.
+
+B<Parse::CPAN::Meta> provides a legacy API of only two functions,
+based on the YAML functions of the same name. Wherever possible,
+identical calling semantics are used.  These may only be used with YAML sources.
+
+All error reporting is done with exceptions (die'ing).
+
+Note that META files are expected to be in UTF-8 encoding, only.  When
+converted string data, it must first be decoded from UTF-8.
+
+=begin Pod::Coverage
+
+
+
+
+=end Pod::Coverage
+
+=head1 METHODS
+
+=head2 load_file
+
+  my $metadata_structure = Parse::CPAN::Meta->load_file('META.json');
+
+  my $metadata_structure = Parse::CPAN::Meta->load_file('META.yml');
+
+This method will read the named file and deserialize it to a data structure,
+determining whether it should be JSON or YAML based on the filename.
+The file will be read using the ":utf8" IO layer.
+
+=head2 load_yaml_string
+
+  my $metadata_structure = Parse::CPAN::Meta->load_yaml_string($yaml_string);
+
+This method deserializes the given string of YAML and returns the first
+document in it.  (CPAN metadata files should always have only one document.)
+If the source was UTF-8 encoded, the string must be decoded before calling
+C<load_yaml_string>.
+
+=head2 load_json_string
+
+  my $metadata_structure = Parse::CPAN::Meta->load_json_string($json_string);
+
+This method deserializes the given string of JSON and the result.
+If the source was UTF-8 encoded, the string must be decoded before calling
+C<load_json_string>.
+
+=head2 load_string
+
+  my $metadata_structure = Parse::CPAN::Meta->load_string($some_string);
+
+If you don't know whether a string contains YAML or JSON data, this method
+will use some heuristics and guess.  If it can't tell, it assumes YAML.
+
+=head2 yaml_backend
+
+  my $backend = Parse::CPAN::Meta->yaml_backend;
+
+Returns the module name of the YAML serializer. See L</ENVIRONMENT>
+for details.
+
+=head2 json_backend
+
+  my $backend = Parse::CPAN::Meta->json_backend;
+
+Returns the module name of the JSON serializer.  If C<CPAN_META_JSON_BACKEND>
+is set, this will be whatever that's set to.  If not, this will either
+be L<JSON::PP> or L<JSON>.  If C<PERL_JSON_BACKEND> is set,
+this will return L<JSON> as further delegation is handled by
+the L<JSON> module.  See L</ENVIRONMENT> for details.
+
+=head2 json_decoder
+
+  my $decoder = Parse::CPAN::Meta->json_decoder;
+
+Returns the module name of the JSON decoder.  Unlike L</json_backend>, this
+is not necessarily a full L<JSON>-style module, but only something that will
+provide a C<decode_json> subroutine.  If C<CPAN_META_JSON_DECODER> is set,
+this will be whatever that's set to.  If not, this will be whatever has
+been selected as L</json_backend>.  See L</ENVIRONMENT> for more notes.
+
+=head1 FUNCTIONS
+
+For maintenance clarity, no functions are exported by default.  These functions
+are available for backwards compatibility only and are best avoided in favor of
+C<load_file>.
+
+=head2 Load
+
+  my @yaml = Parse::CPAN::Meta::Load( $string );
+
+Parses a string containing a valid YAML stream into a list of Perl data
+structures.
+
+=head2 LoadFile
+
+  my @yaml = Parse::CPAN::Meta::LoadFile( 'META.yml' );
+
+Reads the YAML stream from a file instead of a string.
+
+=head1 ENVIRONMENT
+
+=head2 CPAN_META_JSON_DECODER
+
+By default, L<JSON::PP> will be used for deserializing JSON data.  If the
+C<CPAN_META_JSON_DECODER> environment variable exists, this is expected to
+be the name of a loadable module that provides a C<decode_json> subroutine,
+which will then be used for deserialization.  Relying only on the existence
+of said subroutine allows for maximum compatibility, since this API is
+provided by all of L<JSON::PP>, L<JSON::XS>, L<Cpanel::JSON::XS>,
+L<JSON::MaybeXS>, L<JSON::Tiny>, and L<Mojo::JSON>.
+
+=head2 CPAN_META_JSON_BACKEND
+
+By default, L<JSON::PP> will be used for deserializing JSON data.  If the
+C<CPAN_META_JSON_BACKEND> environment variable exists, this is expected to
+be the name of a loadable module that provides the L<JSON> API, since
+downstream code expects to be able to call C<new> on this class.  As such,
+while L<JSON::PP>, L<JSON::XS>, L<Cpanel::JSON::XS> and L<JSON::MaybeXS> will
+work for this, to use L<Mojo::JSON> or L<JSON::Tiny> for decoding requires
+setting L</CPAN_META_JSON_DECODER>.
+
+=head2 PERL_JSON_BACKEND
+
+If the C<CPAN_META_JSON_BACKEND> environment variable does not exist, and if
+C<PERL_JSON_BACKEND> environment variable exists, is true and is not
+"JSON::PP", then the L<JSON> module (version 2.5 or greater) will be loaded and
+used to interpret C<PERL_JSON_BACKEND>.  If L<JSON> is not installed or is too
+old, an exception will be thrown.  Note that at the time of writing, the only
+useful values are 1, which will tell L<JSON> to guess, or L<JSON::XS> - if
+you want to use a newer JSON module, see L</CPAN_META_JSON_BACKEND>.
+
+=head2 PERL_YAML_BACKEND
+
+By default, L<CPAN::Meta::YAML> will be used for deserializing YAML data. If
+the C<PERL_YAML_BACKEND> environment variable is defined, then it is interpreted
+as a module to use for deserialization.  The given module must be installed,
+must load correctly and must implement the C<Load()> function or an exception
+will be thrown.
+
+=head1 AUTHORS
+
+=over 4
+
+=item *
+
+David Golden <dagolden@cpan.org>
+
+=item *
+
+Ricardo Signes <rjbs@cpan.org>
+
+=item *
+
+Adam Kennedy <adamk@cpan.org>
+
+=back
+
+=head1 COPYRIGHT AND LICENSE
+
+This software is copyright (c) 2010 by David Golden, Ricardo Signes, Adam Kennedy and Contributors.
+
+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

git/usr/share/perl5/core_perl/PerlIO/via/QuotedPrint.pm

@@ -0,0 +1,176 @@
+# Copyright (C) 2002-2004, 2012 Elizabeth Mattijsen.  All rights reserved.
+# Copyright (C) 2015 Steve Hay.  All rights reserved.
+
+# This module is free software; you can redistribute it and/or modify it under
+# the same terms as Perl itself, i.e. under the terms of either the GNU General
+# Public License or the Artistic License, as specified in the F<LICENCE> file.
+
+package PerlIO::via::QuotedPrint;
+
+use 5.008001;
+
+# be as strict as possible
+use strict;
+
+our $VERSION = '0.10';
+
+# modules that we need
+use MIME::QuotedPrint (); # no need to pollute this namespace
+
+# satisfy -require-
+1;
+
+#-------------------------------------------------------------------------------
+#
+# Standard Perl features
+#
+#-------------------------------------------------------------------------------
+#  IN: 1 class to bless with
+#      2 mode string (ignored)
+#      3 file handle of PerlIO layer below (ignored)
+# OUT: 1 blessed object
+
+sub PUSHED { bless \*PUSHED,$_[0] } #PUSHED
+
+#-------------------------------------------------------------------------------
+#  IN: 1 instantiated object (ignored)
+#      2 handle to read from
+# OUT: 1 decoded string
+
+sub FILL {
+
+    # decode and return
+    my $line= readline( $_[1] );
+    return ( defined $line )
+      ? MIME::QuotedPrint::decode_qp($line)
+      : undef;
+} #FILL
+
+#-------------------------------------------------------------------------------
+#  IN: 1 instantiated object (ignored)
+#      2 buffer to be written
+#      3 handle to write to
+# OUT: 1 number of bytes written
+
+sub WRITE {
+
+    # encode and write to handle: indicate result
+    return ( print { $_[2] } MIME::QuotedPrint::encode_qp( $_[1] ) )
+      ? length( $_[1] )
+      : -1;
+} #WRITE
+
+#-------------------------------------------------------------------------------
+
+__END__
+
+=head1 NAME
+
+PerlIO::via::QuotedPrint - PerlIO layer for quoted-printable strings
+
+=head1 SYNOPSIS
+
+    use PerlIO::via::QuotedPrint;
+
+    open(my $in, '<:via(QuotedPrint)', 'file.qp') or
+        die "Can't open file.qp for reading: $!\n";
+
+    open(my $out, '>:via(QuotedPrint)', 'file.qp') or
+        die "Can't open file.qp for writing: $!\n";
+
+=head1 DESCRIPTION
+
+This module implements a PerlIO layer that works on files encoded in the
+quoted-printable format.  It will decode from quoted-printable while reading
+from a handle, and it will encode as quoted-printable while writing to a handle.
+
+=head1 EXPORTS
+
+I<None>.
+
+=head1 KNOWN BUGS
+
+I<None>.
+
+=head1 FEEDBACK
+
+Patches, bug reports, suggestions or any other feedback is welcome.
+
+Patches can be sent as GitHub pull requests at
+L<https://github.com/steve-m-hay/PerlIO-via-QuotedPrint/pulls>.
+
+Bug reports and suggestions can be made on the CPAN Request Tracker at
+L<https://rt.cpan.org/Public/Bug/Report.html?Queue=PerlIO-via-QuotedPrint>.
+
+Currently active requests on the CPAN Request Tracker can be viewed at
+L<https://rt.cpan.org/Public/Dist/Display.html?Status=Active;Queue=PerlIO-via-QuotedPrint>.
+
+Please test this distribution.  See CPAN Testers Reports at
+L<https://www.cpantesters.org/> for details of how to get involved.
+
+Previous test results on CPAN Testers Reports can be viewed at
+L<https://www.cpantesters.org/distro/P/PerlIO-via-QuotedPrint.html>.
+
+Please rate this distribution on CPAN Ratings at
+L<https://cpanratings.perl.org/rate/?distribution=PerlIO-via-QuotedPrint>.
+
+=head1 SEE ALSO
+
+L<PerlIO::via>,
+L<MIME::QuotedPrint>.
+
+=head1 ACKNOWLEDGEMENTS
+
+Based on an example in the standard library module MIME::QuotedPrint in Perl
+(version 5.8.0).
+
+=head1 AVAILABILITY
+
+The latest version of this module is available from CPAN (see
+L<perlmodlib/"CPAN"> for details) at
+
+L<https://metacpan.org/release/PerlIO-via-QuotedPrint> or
+
+L<https://www.cpan.org/authors/id/S/SH/SHAY/> or
+
+L<https://www.cpan.org/modules/by-module/PerlIO/>.
+
+The latest source code is available from GitHub at
+L<https://github.com/steve-m-hay/PerlIO-via-QuotedPrint>.
+
+=head1 INSTALLATION
+
+See the F<INSTALL> file.
+
+=head1 AUTHOR
+
+Elizabeth Mattijsen E<lt>L<liz@dijkmat.nl|mailto:liz@dijkmat.nl>E<gt>.
+
+Steve Hay E<lt>L<shay@cpan.org|mailto:shay@cpan.org>E<gt> is now maintaining
+PerlIO::via::QuotedPrint as of version 0.08.
+
+=head1 COPYRIGHT
+
+Copyright (C) 2002-2004, 2012 Elizabeth Mattijsen.  All rights reserved.
+
+Copyright (C) 2015, 2020 Steve Hay.  All rights reserved.
+
+=head1 LICENCE
+
+This module is free software; you can redistribute it and/or modify it under
+the same terms as Perl itself, i.e. under the terms of either the GNU General
+Public License or the Artistic License, as specified in the F<LICENCE> file.
+
+=head1 VERSION
+
+Version 0.10
+
+=head1 DATE
+
+22 May 2022
+
+=head1 HISTORY
+
+See the F<Changes> file.
+
+=cut

git/usr/share/perl5/core_perl/Term/Table/Cell.pm

@@ -0,0 +1,147 @@
+package Term::Table::Cell;
+use strict;
+use warnings;
+
+our $VERSION = '0.024';
+
+use Term::Table::LineBreak();
+use Term::Table::Util qw/uni_length/;
+
+use List::Util qw/sum/;
+
+use Term::Table::HashBase qw/value border_left border_right _break _widths border_color value_color reset_color/;
+
+my %CHAR_MAP = (
+    # Special case, \n should render as \n, but also actually do the newline thing
+    "\n" => "\\n\n",
+
+    "\a" => '\\a',
+    "\b" => '\\b',
+    "\e" => '\\e',
+    "\f" => '\\f',
+    "\r" => '\\r',
+    "\t" => '\\t',
+    " "  => ' ',
+);
+
+sub init {
+    my $self = shift;
+
+    # Stringify
+    $self->{+VALUE} = defined $self->{+VALUE} ? "$self->{+VALUE}" : '';
+}
+
+sub char_id {
+    my $class = shift;
+    my ($char) = @_;
+    return "\\N{U+" . sprintf("\%X", utf8::native_to_unicode(ord($char))) . "}";
+}
+
+sub show_char {
+    my $class = shift;
+    my ($char, %props) = @_;
+    return $char if $props{no_newline} && $char eq "\n";
+    return $CHAR_MAP{$char} || $class->char_id($char);
+}
+
+sub sanitize {
+    my $self = shift;
+    $self->{+VALUE} =~ s/([\s\t\p{Zl}\p{C}\p{Zp}])/$self->show_char($1)/ge; # All whitespace except normal space
+}
+
+sub mark_tail {
+    my $self = shift;
+    $self->{+VALUE} =~ s/([\s\t\p{Zl}\p{C}\p{Zp}])$/$1 eq ' ' ? $self->char_id($1) : $self->show_char($1, no_newline => 1)/se;
+}
+
+sub value_width {
+    my $self = shift;
+
+    my $w = $self->{+_WIDTHS} ||= {};
+    return $w->{value} if defined $w->{value};
+
+    my @parts = split /(\n)/, $self->{+VALUE};
+
+    my $max = 0;
+    while (@parts) {
+        my $text = shift @parts;
+        my $sep  = shift @parts || '';
+        my $len = uni_length("$text");
+        $max = $len if $len > $max;
+    }
+
+    return $w->{value} = $max;
+}
+
+sub border_left_width {
+    my $self = shift;
+    $self->{+_WIDTHS}->{left} ||= uni_length($self->{+BORDER_LEFT} || '');
+}
+
+sub border_right_width {
+    my $self = shift;
+    $self->{+_WIDTHS}->{right} ||= uni_length($self->{+BORDER_RIGHT} || '');
+}
+
+sub width {
+    my $self = shift;
+    $self->{+_WIDTHS}->{all} ||= sum(map { $self->$_ } qw/value_width border_left_width border_right_width/);
+}
+
+sub break {
+    my $self = shift;
+    $self->{+_BREAK} ||= Term::Table::LineBreak->new(string => $self->{+VALUE});
+}
+
+sub reset {
+    my $self = shift;
+    delete $self->{+_BREAK};
+}
+
+1;
+
+__END__
+
+=pod
+
+=encoding UTF-8
+
+=head1 NAME
+
+Term::Table::Cell - Representation of a cell in a table.
+
+=head1 DESCRIPTION
+
+This package is used to represent a cell in a table.
+
+=head1 SOURCE
+
+The source code repository for Term-Table can be found at
+F<http://github.com/exodist/Term-Table/>.
+
+=head1 MAINTAINERS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 COPYRIGHT
+
+Copyright 2016 Chad Granum E<lt>exodist@cpan.orgE<gt>.
+
+This program is free software; you can redistribute it and/or
+modify it under the same terms as Perl itself.
+
+See F<http://dev.perl.org/licenses/>
+
+=cut

git/usr/share/perl5/core_perl/Term/Table/CellStack.pm

@@ -0,0 +1,130 @@
+package Term::Table::CellStack;
+use strict;
+use warnings;
+
+our $VERSION = '0.024';
+
+use Term::Table::HashBase qw/-cells -idx/;
+
+use List::Util qw/max/;
+
+sub init {
+    my $self = shift;
+    $self->{+CELLS} ||= [];
+}
+
+sub add_cell {
+    my $self = shift;
+    push @{$self->{+CELLS}} => @_;
+}
+
+sub add_cells {
+    my $self = shift;
+    push @{$self->{+CELLS}} => @_;
+}
+
+sub sanitize {
+    my $self = shift;
+    $_->sanitize(@_) for @{$self->{+CELLS}};
+}
+
+sub mark_tail {
+    my $self = shift;
+    $_->mark_tail(@_) for @{$self->{+CELLS}};
+}
+
+my @proxy = qw{
+    border_left border_right border_color value_color reset_color
+    border_left_width border_right_width
+};
+
+for my $meth (@proxy) {
+    no strict 'refs';
+    *$meth = sub {
+        my $self = shift;
+        $self->{+CELLS}->[$self->{+IDX}]->$meth;
+    };
+}
+
+for my $meth (qw{value_width width}) {
+    no strict 'refs';
+    *$meth = sub {
+        my $self = shift;
+        return max(map { $_->$meth } @{$self->{+CELLS}});
+    };
+}
+
+sub next {
+    my $self = shift;
+    my ($cw) = @_;
+
+    while ($self->{+IDX} < @{$self->{+CELLS}}) {
+        my $cell = $self->{+CELLS}->[$self->{+IDX}];
+
+        my $lw = $cell->border_left_width;
+        my $rw = $cell->border_right_width;
+        my $vw = $cw - $lw - $rw;
+        my $it = $cell->break->next($vw);
+
+        return ($it, $vw) if $it;
+        $self->{+IDX}++;
+    }
+
+    return;
+}
+
+sub break { $_[0] }
+
+sub reset {
+    my $self = shift;
+    $self->{+IDX} = 0;
+    $_->reset for @{$self->{+CELLS}};
+}
+
+1;
+
+__END__
+
+=pod
+
+=encoding UTF-8
+
+=head1 NAME
+
+Term::Table::CellStack - Combine several cells into one (vertical)
+
+=head1 DESCRIPTION
+
+This package is used to represent a merged-cell in a table (vertical).
+
+=head1 SOURCE
+
+The source code repository for Term-Table can be found at
+F<http://github.com/exodist/Term-Table/>.
+
+=head1 MAINTAINERS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 COPYRIGHT
+
+Copyright 2016 Chad Granum E<lt>exodist@cpan.orgE<gt>.
+
+This program is free software; you can redistribute it and/or
+modify it under the same terms as Perl itself.
+
+See F<http://dev.perl.org/licenses/>
+
+=cut

git/usr/share/perl5/core_perl/Term/Table/HashBase.pm

@@ -0,0 +1,473 @@
+package Term::Table::HashBase;
+use strict;
+use warnings;
+
+our $VERSION = '0.024';
+
+#################################################################
+#                                                               #
+#  This is a generated file! Do not modify this file directly!  #
+#  Use hashbase_inc.pl script to regenerate this file.          #
+#  The script is part of the Object::HashBase distribution.     #
+#  Note: You can modify the version number above this comment   #
+#  if needed, that is fine.                                     #
+#                                                               #
+#################################################################
+
+{
+    no warnings 'once';
+    $Term::Table::HashBase::HB_VERSION = '0.008';
+    *Term::Table::HashBase::ATTR_SUBS = \%Object::HashBase::ATTR_SUBS;
+    *Term::Table::HashBase::ATTR_LIST = \%Object::HashBase::ATTR_LIST;
+    *Term::Table::HashBase::VERSION   = \%Object::HashBase::VERSION;
+    *Term::Table::HashBase::CAN_CACHE = \%Object::HashBase::CAN_CACHE;
+}
+
+
+require Carp;
+{
+    no warnings 'once';
+    $Carp::Internal{+__PACKAGE__} = 1;
+}
+
+BEGIN {
+    # these are not strictly equivalent, but for out use we don't care
+    # about order
+    *_isa = ($] >= 5.010 && require mro) ? \&mro::get_linear_isa : sub {
+        no strict 'refs';
+        my @packages = ($_[0]);
+        my %seen;
+        for my $package (@packages) {
+            push @packages, grep !$seen{$_}++, @{"$package\::ISA"};
+        }
+        return \@packages;
+    }
+}
+
+my %SPEC = (
+    '^' => {reader => 1, writer => 0, dep_writer => 1, read_only => 0, strip => 1},
+    '-' => {reader => 1, writer => 0, dep_writer => 0, read_only => 1, strip => 1},
+    '>' => {reader => 0, writer => 1, dep_writer => 0, read_only => 0, strip => 1},
+    '<' => {reader => 1, writer => 0, dep_writer => 0, read_only => 0, strip => 1},
+    '+' => {reader => 0, writer => 0, dep_writer => 0, read_only => 0, strip => 1},
+);
+
+sub import {
+    my $class = shift;
+    my $into  = caller;
+
+    # Make sure we list the OLDEST version used to create this class.
+    my $ver = $Term::Table::HashBase::HB_VERSION || $Term::Table::HashBase::VERSION;
+    $Term::Table::HashBase::VERSION{$into} = $ver if !$Term::Table::HashBase::VERSION{$into} || $Term::Table::HashBase::VERSION{$into} > $ver;
+
+    my $isa = _isa($into);
+    my $attr_list = $Term::Table::HashBase::ATTR_LIST{$into} ||= [];
+    my $attr_subs = $Term::Table::HashBase::ATTR_SUBS{$into} ||= {};
+
+    my %subs = (
+        ($into->can('new') ? () : (new => \&_new)),
+        (map %{$Term::Table::HashBase::ATTR_SUBS{$_} || {}}, @{$isa}[1 .. $#$isa]),
+        (
+            map {
+                my $p = substr($_, 0, 1);
+                my $x = $_;
+
+                my $spec = $SPEC{$p} || {reader => 1, writer => 1};
+
+                substr($x, 0, 1) = '' if $spec->{strip};
+                push @$attr_list => $x;
+                my ($sub, $attr) = (uc $x, $x);
+
+                $attr_subs->{$sub} = sub() { $attr };
+                my %out = ($sub => $attr_subs->{$sub});
+
+                $out{$attr}       = sub { $_[0]->{$attr} }                                                  if $spec->{reader};
+                $out{"set_$attr"} = sub { $_[0]->{$attr} = $_[1] }                                          if $spec->{writer};
+                $out{"set_$attr"} = sub { Carp::croak("'$attr' is read-only") }                             if $spec->{read_only};
+                $out{"set_$attr"} = sub { Carp::carp("set_$attr() is deprecated"); $_[0]->{$attr} = $_[1] } if $spec->{dep_writer};
+
+                %out;
+            } @_
+        ),
+    );
+
+    no strict 'refs';
+    *{"$into\::$_"} = $subs{$_} for keys %subs;
+}
+
+sub attr_list {
+    my $class = shift;
+
+    my $isa = _isa($class);
+
+    my %seen;
+    my @list = grep { !$seen{$_}++ } map {
+        my @out;
+
+        if (0.004 > ($Term::Table::HashBase::VERSION{$_} || 0)) {
+            Carp::carp("$_ uses an inlined version of Term::Table::HashBase too old to support attr_list()");
+        }
+        else {
+            my $list = $Term::Table::HashBase::ATTR_LIST{$_};
+            @out = $list ? @$list : ()
+        }
+
+        @out;
+    } reverse @$isa;
+
+    return @list;
+}
+
+sub _new {
+    my $class = shift;
+
+    my $self;
+
+    if (@_ == 1) {
+        my $arg = shift;
+        my $type = ref($arg);
+
+        if ($type eq 'HASH') {
+            $self = bless({%$arg}, $class)
+        }
+        else {
+            Carp::croak("Not sure what to do with '$type' in $class constructor")
+                unless $type eq 'ARRAY';
+
+            my %proto;
+            my @attributes = attr_list($class);
+            while (@$arg) {
+                my $val = shift @$arg;
+                my $key = shift @attributes or Carp::croak("Too many arguments for $class constructor");
+                $proto{$key} = $val;
+            }
+
+            $self = bless(\%proto, $class);
+        }
+    }
+    else {
+        $self = bless({@_}, $class);
+    }
+
+    $Term::Table::HashBase::CAN_CACHE{$class} = $self->can('init')
+        unless exists $Term::Table::HashBase::CAN_CACHE{$class};
+
+    $self->init if $Term::Table::HashBase::CAN_CACHE{$class};
+
+    $self;
+}
+
+1;
+
+__END__
+
+=pod
+
+=encoding UTF-8
+
+=head1 NAME
+
+Term::Table::HashBase - Build hash based classes.
+
+=head1 SYNOPSIS
+
+A class:
+
+    package My::Class;
+    use strict;
+    use warnings;
+
+    # Generate 3 accessors
+    use Term::Table::HashBase qw/foo -bar ^baz <bat >ban +boo/;
+
+    # Chance to initialize defaults
+    sub init {
+        my $self = shift;    # No other args
+        $self->{+FOO} ||= "foo";
+        $self->{+BAR} ||= "bar";
+        $self->{+BAZ} ||= "baz";
+        $self->{+BAT} ||= "bat";
+        $self->{+BAN} ||= "ban";
+        $self->{+BOO} ||= "boo";
+    }
+
+    sub print {
+        print join ", " => map { $self->{$_} } FOO, BAR, BAZ, BAT, BAN, BOO;
+    }
+
+Subclass it
+
+    package My::Subclass;
+    use strict;
+    use warnings;
+
+    # Note, you should subclass before loading HashBase.
+    use base 'My::Class';
+    use Term::Table::HashBase qw/bub/;
+
+    sub init {
+        my $self = shift;
+
+        # We get the constants from the base class for free.
+        $self->{+FOO} ||= 'SubFoo';
+        $self->{+BUB} ||= 'bub';
+
+        $self->SUPER::init();
+    }
+
+use it:
+
+    package main;
+    use strict;
+    use warnings;
+    use My::Class;
+
+    # These are all functionally identical
+    my $one   = My::Class->new(foo => 'MyFoo', bar => 'MyBar');
+    my $two   = My::Class->new({foo => 'MyFoo', bar => 'MyBar'});
+    my $three = My::Class->new(['MyFoo', 'MyBar']);
+
+    # Readers!
+    my $foo = $one->foo;    # 'MyFoo'
+    my $bar = $one->bar;    # 'MyBar'
+    my $baz = $one->baz;    # Defaulted to: 'baz'
+    my $bat = $one->bat;    # Defaulted to: 'bat'
+    # '>ban' means setter only, no reader
+    # '+boo' means no setter or reader, just the BOO constant
+
+    # Setters!
+    $one->set_foo('A Foo');
+
+    #'-bar' means read-only, so the setter will throw an exception (but is defined).
+    $one->set_bar('A bar');
+
+    # '^baz' means deprecated setter, this will warn about the setter being
+    # deprecated.
+    $one->set_baz('A Baz');
+
+    # '<bat' means no setter defined at all
+    # '+boo' means no setter or reader, just the BOO constant
+
+    $one->{+FOO} = 'xxx';
+
+=head1 DESCRIPTION
+
+This package is used to generate classes based on hashrefs. Using this class
+will give you a C<new()> method, as well as generating accessors you request.
+Generated accessors will be getters, C<set_ACCESSOR> setters will also be
+generated for you. You also get constants for each accessor (all caps) which
+return the key into the hash for that accessor. Single inheritance is also
+supported.
+
+=head1 THIS IS A BUNDLED COPY OF HASHBASE
+
+This is a bundled copy of L<Object::HashBase>. This file was generated using
+the
+C</home/exodist/perl5/perlbrew/perls/main/bin/hashbase_inc.pl>
+script.
+
+=head1 METHODS
+
+=head2 PROVIDED BY HASH BASE
+
+=over 4
+
+=item $it = $class->new(%PAIRS)
+
+=item $it = $class->new(\%PAIRS)
+
+=item $it = $class->new(\@ORDERED_VALUES)
+
+Create a new instance.
+
+HashBase will not export C<new()> if there is already a C<new()> method in your
+packages inheritance chain.
+
+B<If you do not want this method you can define your own> you just have to
+declare it before loading L<Term::Table::HashBase>.
+
+    package My::Package;
+
+    # predeclare new() so that HashBase does not give us one.
+    sub new;
+
+    use Term::Table::HashBase qw/foo bar baz/;
+
+    # Now we define our own new method.
+    sub new { ... }
+
+This makes it so that HashBase sees that you have your own C<new()> method.
+Alternatively you can define the method before loading HashBase instead of just
+declaring it, but that scatters your use statements.
+
+The most common way to create an object is to pass in key/value pairs where
+each key is an attribute and each value is what you want assigned to that
+attribute. No checking is done to verify the attributes or values are valid,
+you may do that in C<init()> if desired.
+
+If you would like, you can pass in a hashref instead of pairs. When you do so
+the hashref will be copied, and the copy will be returned blessed as an object.
+There is no way to ask HashBase to bless a specific hashref.
+
+In some cases an object may only have 1 or 2 attributes, in which case a
+hashref may be too verbose for your liking. In these cases you can pass in an
+arrayref with only values. The values will be assigned to attributes in the
+order the attributes were listed. When there is inheritance involved the
+attributes from parent classes will come before subclasses.
+
+=back
+
+=head2 HOOKS
+
+=over 4
+
+=item $self->init()
+
+This gives you the chance to set some default values to your fields. The only
+argument is C<$self> with its indexes already set from the constructor.
+
+B<Note:> Term::Table::HashBase checks for an init using C<< $class->can('init') >>
+during construction. It DOES NOT call C<can()> on the created object. Also note
+that the result of the check is cached, it is only ever checked once, the first
+time an instance of your class is created. This means that adding an C<init()>
+method AFTER the first construction will result in it being ignored.
+
+=back
+
+=head1 ACCESSORS
+
+=head2 READ/WRITE
+
+To generate accessors you list them when using the module:
+
+    use Term::Table::HashBase qw/foo/;
+
+This will generate the following subs in your namespace:
+
+=over 4
+
+=item foo()
+
+Getter, used to get the value of the C<foo> field.
+
+=item set_foo()
+
+Setter, used to set the value of the C<foo> field.
+
+=item FOO()
+
+Constant, returns the field C<foo>'s key into the class hashref. Subclasses will
+also get this function as a constant, not simply a method, that means it is
+copied into the subclass namespace.
+
+The main reason for using these constants is to help avoid spelling mistakes
+and similar typos. It will not help you if you forget to prefix the '+' though.
+
+=back
+
+=head2 READ ONLY
+
+    use Term::Table::HashBase qw/-foo/;
+
+=over 4
+
+=item set_foo()
+
+Throws an exception telling you the attribute is read-only. This is exported to
+override any active setters for the attribute in a parent class.
+
+=back
+
+=head2 DEPRECATED SETTER
+
+    use Term::Table::HashBase qw/^foo/;
+
+=over 4
+
+=item set_foo()
+
+This will set the value, but it will also warn you that the method is
+deprecated.
+
+=back
+
+=head2 NO SETTER
+
+    use Term::Table::HashBase qw/<foo/;
+
+Only gives you a reader, no C<set_foo> method is defined at all.
+
+=head2 NO READER
+
+    use Term::Table::HashBase qw/>foo/;
+
+Only gives you a write (C<set_foo>), no C<foo> method is defined at all.
+
+=head2 CONSTANT ONLY
+
+    use Term::Table::HashBase qw/+foo/;
+
+This does not create any methods for you, it just adds the C<FOO> constant.
+
+=head1 SUBCLASSING
+
+You can subclass an existing HashBase class.
+
+    use base 'Another::HashBase::Class';
+    use Term::Table::HashBase qw/foo bar baz/;
+
+The base class is added to C<@ISA> for you, and all constants from base classes
+are added to subclasses automatically.
+
+=head1 GETTING A LIST OF ATTRIBUTES FOR A CLASS
+
+Term::Table::HashBase provides a function for retrieving a list of attributes for an
+Term::Table::HashBase class.
+
+=over 4
+
+=item @list = Term::Table::HashBase::attr_list($class)
+
+=item @list = $class->Term::Table::HashBase::attr_list()
+
+Either form above will work. This will return a list of attributes defined on
+the object. This list is returned in the attribute definition order, parent
+class attributes are listed before subclass attributes. Duplicate attributes
+will be removed before the list is returned.
+
+B<Note:> This list is used in the C<< $class->new(\@ARRAY) >> constructor to
+determine the attribute to which each value will be paired.
+
+=back
+
+=head1 SOURCE
+
+The source code repository for HashBase can be found at
+F<http://github.com/Test-More/HashBase/>.
+
+=head1 MAINTAINERS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 COPYRIGHT
+
+Copyright 2017 Chad Granum E<lt>exodist@cpan.orgE<gt>.
+
+This program is free software; you can redistribute it and/or
+modify it under the same terms as Perl itself.
+
+See F<http://dev.perl.org/licenses/>
+
+=cut

git/usr/share/perl5/core_perl/Term/Table/LineBreak.pm

@@ -0,0 +1,144 @@
+package Term::Table::LineBreak;
+use strict;
+use warnings;
+
+our $VERSION = '0.024';
+
+use Carp qw/croak/;
+use Scalar::Util qw/blessed/;
+use Term::Table::Util qw/uni_length/;
+
+use Term::Table::HashBase qw/string gcstring _len _parts idx/;
+
+sub init {
+    my $self = shift;
+
+    croak "string is a required attribute"
+        unless defined $self->{+STRING};
+}
+
+sub columns { uni_length($_[0]->{+STRING}) }
+
+sub break {
+    my $self = shift;
+    my ($len) = @_;
+
+    $self->{+_LEN} = $len;
+
+    $self->{+IDX} = 0;
+    my $str = $self->{+STRING} . ""; # Force stringification
+
+    my @parts;
+    my @chars = split //, $str;
+    while (@chars) {
+        my $size = 0;
+        my $part = '';
+        until ($size == $len) {
+            my $char = shift @chars;
+            $char = '' unless defined $char;
+
+            my $l = uni_length("$char");
+            last unless $l;
+
+            last if $char eq "\n";
+
+            if ($size + $l > $len) {
+                unshift @chars => $char;
+                last;
+            }
+
+            $size += $l;
+            $part .= $char;
+        }
+
+        # If we stopped just before a newline, grab it
+        shift @chars if $size == $len && @chars && $chars[0] eq "\n";
+
+        until ($size == $len) {
+            $part .= ' ';
+            $size += 1;
+        }
+        push @parts => $part;
+    }
+
+    $self->{+_PARTS} = \@parts;
+}
+
+sub next {
+    my $self = shift;
+
+    if (@_) {
+        my ($len) = @_;
+        $self->break($len) if !$self->{+_LEN} || $self->{+_LEN} != $len;
+    }
+    else {
+        croak "String has not yet been broken"
+            unless $self->{+_PARTS};
+    }
+
+    my $idx   = $self->{+IDX}++;
+    my $parts = $self->{+_PARTS};
+
+    return undef if $idx >= @$parts;
+    return $parts->[$idx];
+}
+
+1;
+
+__END__
+
+=pod
+
+=encoding UTF-8
+
+=head1 NAME
+
+Term::Table::LineBreak - Break up lines for use in tables.
+
+=head1 DESCRIPTION
+
+This is meant for internal use. This package takes long lines of text and
+splits them so that they fit in table rows.
+
+=head1 SYNOPSIS
+
+    use Term::Table::LineBreak;
+
+    my $lb = Term::Table::LineBreak->new(string => $STRING);
+
+    $lb->break($SIZE);
+    while (my $part = $lb->next) {
+        ...
+    }
+
+=head1 SOURCE
+
+The source code repository for Term-Table can be found at
+F<http://github.com/exodist/Term-Table/>.
+
+=head1 MAINTAINERS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 COPYRIGHT
+
+Copyright 2016 Chad Granum E<lt>exodist@cpan.orgE<gt>.
+
+This program is free software; you can redistribute it and/or
+modify it under the same terms as Perl itself.
+
+See F<http://dev.perl.org/licenses/>
+
+=cut

git/usr/share/perl5/core_perl/Term/Table/Spacer.pm

@@ -0,0 +1,15 @@
+package Term::Table::Spacer;
+use strict;
+use warnings;
+
+our $VERSION = '0.024';
+
+sub new { bless {}, $_[0] }
+
+sub width { 1 }
+
+sub sanitize  { }
+sub mark_tail { }
+sub reset     { }
+
+1;

git/usr/share/perl5/core_perl/Term/Table/Util.pm

@@ -0,0 +1,200 @@
+package Term::Table::Util;
+use strict;
+use warnings;
+
+use Config qw/%Config/;
+
+our $VERSION = '0.024';
+
+use base 'Exporter';
+our @EXPORT_OK = qw/term_size USE_GCS USE_TERM_READKEY USE_TERM_SIZE_ANY uni_length/;
+
+sub DEFAULT_SIZE() { 80 }
+
+my $IO;
+BEGIN {
+    open($IO, '>&', *STDOUT) or die "Could not clone STDOUT";
+}
+
+sub try(&) {
+    my $code = shift;
+    local ($@, $?, $!);
+    my $ok = eval { $code->(); 1 };
+    my $err = $@;
+    return ($ok, $err);
+}
+
+my ($tsa) = try { require Term::Size::Any; Term::Size::Any->import('chars') };
+my ($trk) = try { require Term::ReadKey };
+$trk &&= Term::ReadKey->can('GetTerminalSize');
+
+if (!-t $IO) {
+    *USE_TERM_READKEY  = sub() { 0 };
+    *USE_TERM_SIZE_ANY = sub() { 0 };
+    *term_size         = sub {
+        return $ENV{TABLE_TERM_SIZE} if $ENV{TABLE_TERM_SIZE};
+        return DEFAULT_SIZE;
+    };
+}
+elsif ($tsa) {
+    *USE_TERM_READKEY  = sub() { 0 };
+    *USE_TERM_SIZE_ANY = sub() { 1 };
+    *_term_size        = sub {
+        my $size = chars($IO);
+        return DEFAULT_SIZE if !$size;
+        return DEFAULT_SIZE if $size < DEFAULT_SIZE;
+        return $size;
+    };
+}
+elsif ($trk) {
+    *USE_TERM_READKEY  = sub() { 1 };
+    *USE_TERM_SIZE_ANY = sub() { 0 };
+    *_term_size        = sub {
+        my $total;
+        try {
+            my @warnings;
+            {
+                local $SIG{__WARN__} = sub { push @warnings => @_ };
+                ($total) = Term::ReadKey::GetTerminalSize($IO);
+            }
+            @warnings = grep { $_ !~ m/Unable to get Terminal Size/ } @warnings;
+            warn @warnings if @warnings;
+        };
+        return DEFAULT_SIZE if !$total;
+        return DEFAULT_SIZE if $total < DEFAULT_SIZE;
+        return $total;
+    };
+}
+else {
+    *USE_TERM_READKEY  = sub() { 0 };
+    *USE_TERM_SIZE_ANY = sub() { 0 };
+    *term_size         = sub {
+        return $ENV{TABLE_TERM_SIZE} if $ENV{TABLE_TERM_SIZE};
+        return DEFAULT_SIZE;
+    };
+}
+
+if (USE_TERM_READKEY() || USE_TERM_SIZE_ANY()) {
+    if (index($Config{sig_name}, 'WINCH') >= 0) {
+        my $changed = 0;
+        my $polled = -1;
+        $SIG{WINCH} = sub { $changed++ };
+
+        my $size;
+        *term_size = sub {
+            return $ENV{TABLE_TERM_SIZE} if $ENV{TABLE_TERM_SIZE};
+
+            unless ($changed == $polled) {
+                $polled = $changed;
+                $size = _term_size();
+            }
+
+            return $size;
+        }
+    }
+    else {
+        *term_size = sub {
+            return $ENV{TABLE_TERM_SIZE} if $ENV{TABLE_TERM_SIZE};
+            _term_size();
+        };
+    }
+}
+
+my ($gcs, $err) = try { require Unicode::GCString };
+
+if ($gcs) {
+    *USE_GCS    = sub() { 1 };
+    *uni_length = sub   { Unicode::GCString->new($_[0])->columns };
+}
+else {
+    *USE_GCS    = sub() { 0 };
+    *uni_length = sub   { length($_[0]) };
+}
+
+1;
+
+__END__
+
+=pod
+
+=encoding UTF-8
+
+=head1 NAME
+
+Term::Table::Util - Utilities for Term::Table.
+
+=head1 DESCRIPTION
+
+This package exports some tools used by Term::Table.
+
+=head1 EXPORTS
+
+=head2 CONSTANTS
+
+=over 4
+
+=item $bool = USE_GCS
+
+True if L<Unicode::GCString> is installed.
+
+=item $bool = USE_TERM_READKEY
+
+True if L<Term::ReadKey> is installed.
+
+=back
+
+=head2 UTILITIES
+
+=over 4
+
+=item $width = term_size()
+
+Get the width of the terminal.
+
+If the C<$TABLE_TERM_SIZE> environment variable is set then that value will be
+returned.
+
+This will default to 80 if there is no good way to get the size, or if the size
+is unreasonably small.
+
+If L<Term::ReadKey> is installed it will be used.
+
+=item $width = uni_length($string)
+
+Get the width (in columns) of the specified string. When L<Unicode::GCString>
+is installed this will work on unicode strings, otherwise it will just use
+C<length($string)>.
+
+=back
+
+=head1 SOURCE
+
+The source code repository for Term-Table can be found at
+F<http://github.com/exodist/Term-Table/>.
+
+=head1 MAINTAINERS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 COPYRIGHT
+
+Copyright 2016 Chad Granum E<lt>exodist@cpan.orgE<gt>.
+
+This program is free software; you can redistribute it and/or
+modify it under the same terms as Perl itself.
+
+See F<http://dev.perl.org/licenses/>
+
+=cut

git/usr/share/perl5/core_perl/Test/Builder/Formatter.pm

@@ -0,0 +1,107 @@
+package Test::Builder::Formatter;
+use strict;
+use warnings;
+
+our $VERSION = '1.302210';
+
+BEGIN { require Test2::Formatter::TAP; our @ISA = qw(Test2::Formatter::TAP) }
+
+use Test2::Util::HashBase qw/no_header no_diag/;
+
+BEGIN {
+    *OUT_STD = Test2::Formatter::TAP->can('OUT_STD');
+    *OUT_ERR = Test2::Formatter::TAP->can('OUT_ERR');
+
+    my $todo = OUT_ERR() + 1;
+    *OUT_TODO = sub() { $todo };
+}
+
+sub init {
+    my $self = shift;
+    $self->SUPER::init(@_);
+    $self->{+HANDLES}->[OUT_TODO] = $self->{+HANDLES}->[OUT_STD];
+}
+
+sub plan_tap {
+    my ($self, $f) = @_;
+
+    return if $self->{+NO_HEADER};
+    return $self->SUPER::plan_tap($f);
+}
+
+sub debug_tap {
+    my ($self, $f, $num) = @_;
+    return if $self->{+NO_DIAG};
+    my @out = $self->SUPER::debug_tap($f, $num);
+    $self->redirect(\@out) if @out && ref $f->{about} && defined $f->{about}->{package}
+        && $f->{about}->{package} eq 'Test::Builder::TodoDiag';
+    return @out;
+}
+
+sub info_tap {
+    my ($self, $f) = @_;
+    return if $self->{+NO_DIAG};
+    my @out = $self->SUPER::info_tap($f);
+    $self->redirect(\@out) if @out && ref $f->{about} && defined $f->{about}->{package}
+        && $f->{about}->{package} eq 'Test::Builder::TodoDiag';
+    return @out;
+}
+
+sub redirect {
+    my ($self, $out) = @_;
+    $_->[0] = OUT_TODO for @$out;
+}
+
+sub no_subtest_space { 1 }
+
+1;
+
+__END__
+
+=pod
+
+=encoding UTF-8
+
+=head1 NAME
+
+Test::Builder::Formatter - Test::Builder subclass of Test2::Formatter::TAP
+
+=head1 DESCRIPTION
+
+This is what takes events and turns them into TAP.
+
+=head1 SYNOPSIS
+
+    use Test::Builder; # Loads Test::Builder::Formatter for you
+
+=head1 SOURCE
+
+The source code repository for Test2 can be found at
+L<https://github.com/Test-More/test-more/>.
+
+=head1 MAINTAINERS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 COPYRIGHT
+
+Copyright Chad Granum E<lt>exodist@cpan.orgE<gt>.
+
+This program is free software; you can redistribute it and/or
+modify it under the same terms as Perl itself.
+
+See L<https://dev.perl.org/licenses/>
+
+=cut

git/usr/share/perl5/core_perl/Test/Builder/Module.pm

@@ -0,0 +1,182 @@
+package Test::Builder::Module;
+
+use strict;
+
+use Test::Builder;
+
+require Exporter;
+our @ISA = qw(Exporter);
+
+our $VERSION = '1.302210';
+
+
+=head1 NAME
+
+Test::Builder::Module - Base class for test modules
+
+=head1 SYNOPSIS
+
+  # Emulates Test::Simple
+  package Your::Module;
+
+  my $CLASS = __PACKAGE__;
+
+  use parent 'Test::Builder::Module';
+  @EXPORT = qw(ok);
+
+  sub ok ($;$) {
+      my $tb = $CLASS->builder;
+      return $tb->ok(@_);
+  }
+  
+  1;
+
+
+=head1 DESCRIPTION
+
+This is a superclass for L<Test::Builder>-based modules.  It provides a
+handful of common functionality and a method of getting at the underlying
+L<Test::Builder> object.
+
+
+=head2 Importing
+
+Test::Builder::Module is a subclass of L<Exporter> which means your
+module is also a subclass of Exporter.  @EXPORT, @EXPORT_OK, etc...
+all act normally.
+
+A few methods are provided to do the C<< use Your::Module tests => 23 >> part
+for you.
+
+=head3 import
+
+Test::Builder::Module provides an C<import()> method which acts in the
+same basic way as L<Test::More>'s, setting the plan and controlling
+exporting of functions and variables.  This allows your module to set
+the plan independent of L<Test::More>.
+
+All arguments passed to C<import()> are passed onto 
+C<< Your::Module->builder->plan() >> with the exception of 
+C<< import =>[qw(things to import)] >>.
+
+    use Your::Module import => [qw(this that)], tests => 23;
+
+says to import the functions C<this()> and C<that()> as well as set the plan
+to be 23 tests.
+
+C<import()> also sets the C<exported_to()> attribute of your builder to be
+the caller of the C<import()> function.
+
+Additional behaviors can be added to your C<import()> method by overriding
+C<import_extra()>.
+
+=cut
+
+sub import {
+    my($class) = shift;
+
+    Test2::API::test2_load() unless Test2::API::test2_in_preload();
+
+    # Don't run all this when loading ourself.
+    return 1 if $class eq 'Test::Builder::Module';
+
+    my $test = $class->builder;
+
+    my $caller = caller;
+
+    $test->exported_to($caller);
+
+    $class->import_extra( \@_ );
+    my(@imports) = $class->_strip_imports( \@_ );
+
+    $test->plan(@_);
+
+    local $Exporter::ExportLevel = $Exporter::ExportLevel + 1;
+    $class->Exporter::import(@imports);
+}
+
+sub _strip_imports {
+    my $class = shift;
+    my $list  = shift;
+
+    my @imports = ();
+    my @other   = ();
+    my $idx     = 0;
+    while( $idx <= $#{$list} ) {
+        my $item = $list->[$idx];
+
+        if( defined $item and $item eq 'import' ) {
+            push @imports, @{ $list->[ $idx + 1 ] };
+            $idx++;
+        }
+        else {
+            push @other, $item;
+        }
+
+        $idx++;
+    }
+
+    @$list = @other;
+
+    return @imports;
+}
+
+=head3 import_extra
+
+    Your::Module->import_extra(\@import_args);
+
+C<import_extra()> is called by C<import()>.  It provides an opportunity for you
+to add behaviors to your module based on its import list.
+
+Any extra arguments which shouldn't be passed on to C<plan()> should be
+stripped off by this method.
+
+See L<Test::More> for an example of its use.
+
+B<NOTE> This mechanism is I<VERY ALPHA AND LIKELY TO CHANGE> as it
+feels like a bit of an ugly hack in its current form.
+
+=cut
+
+sub import_extra { }
+
+=head2 Builder
+
+Test::Builder::Module provides some methods of getting at the underlying
+Test::Builder object.
+
+=head3 builder
+
+  my $builder = Your::Class->builder;
+
+This method returns the L<Test::Builder> object associated with Your::Class.
+It is not a constructor so you can call it as often as you like.
+
+This is the preferred way to get the L<Test::Builder> object.  You should
+I<not> get it via C<< Test::Builder->new >> as was previously
+recommended.
+
+The object returned by C<builder()> may change at runtime so you should
+call C<builder()> inside each function rather than store it in a global.
+
+  sub ok {
+      my $builder = Your::Class->builder;
+
+      return $builder->ok(@_);
+  }
+
+
+=cut
+
+sub builder {
+    return Test::Builder->new;
+}
+
+=head1 SEE ALSO
+
+L<< Test2::Manual::Tooling::TestBuilder >> describes the improved
+options for writing testing modules provided by L<< Test2 >>.
+
+=cut
+
+1;

git/usr/share/perl5/core_perl/Test/Builder/Tester.pm

@@ -0,0 +1,675 @@
+package Test::Builder::Tester;
+
+use strict;
+our $VERSION = '1.302210';
+
+use Test::Builder;
+use Symbol;
+use Carp;
+
+=head1 NAME
+
+Test::Builder::Tester - test testsuites that have been built with
+Test::Builder
+
+=head1 SYNOPSIS
+
+    use Test::Builder::Tester tests => 1;
+    use Test::More;
+
+    test_out("not ok 1 - foo");
+    test_fail(+1);
+    fail("foo");
+    test_test("fail works");
+
+=head1 DESCRIPTION
+
+A module that helps you test testing modules that are built with
+L<Test::Builder>.
+
+The testing system is designed to be used by performing a three step
+process for each test you wish to test.  This process starts with using
+C<test_out> and C<test_err> in advance to declare what the testsuite you
+are testing will output with L<Test::Builder> to stdout and stderr.
+
+You then can run the test(s) from your test suite that call
+L<Test::Builder>.  At this point the output of L<Test::Builder> is
+safely captured by L<Test::Builder::Tester> rather than being
+interpreted as real test output.
+
+The final stage is to call C<test_test> that will simply compare what you
+predeclared to what L<Test::Builder> actually outputted, and report the
+results back with a "ok" or "not ok" (with debugging) to the normal
+output.
+
+=cut
+
+####
+# set up testing
+####
+
+my $t = Test::Builder->new;
+
+###
+# make us an exporter
+###
+
+use Exporter;
+our @ISA = qw(Exporter);
+
+our @EXPORT = qw(test_out test_err test_fail test_diag test_test line_num);
+
+sub import {
+    my $class = shift;
+    my(@plan) = @_;
+
+    my $caller = caller;
+
+    $t->exported_to($caller);
+    $t->plan(@plan);
+
+    my @imports = ();
+    foreach my $idx ( 0 .. $#plan ) {
+        if( $plan[$idx] eq 'import' ) {
+            @imports = @{ $plan[ $idx + 1 ] };
+            last;
+        }
+    }
+
+    __PACKAGE__->export_to_level( 1, __PACKAGE__, @imports );
+}
+
+###
+# set up file handles
+###
+
+# create some private file handles
+my $output_handle = gensym;
+my $error_handle  = gensym;
+
+# and tie them to this package
+my $out = tie *$output_handle, "Test::Builder::Tester::Tie", "STDOUT";
+my $err = tie *$error_handle,  "Test::Builder::Tester::Tie", "STDERR";
+
+####
+# exported functions
+####
+
+# for remembering that we're testing and where we're testing at
+my $testing = 0;
+my $testing_num;
+my $original_is_passing;
+
+# remembering where the file handles were originally connected
+my $original_output_handle;
+my $original_failure_handle;
+my $original_todo_handle;
+my $original_formatter;
+
+my $original_harness_env;
+
+# function that starts testing and redirects the filehandles for now
+sub _start_testing {
+    # Hack for things that conditioned on Test-Stream being loaded
+    $INC{'Test/Stream.pm'} ||= 'fake' if $INC{'Test/Moose/More.pm'};
+    # even if we're running under Test::Harness pretend we're not
+    # for now.  This needed so Test::Builder doesn't add extra spaces
+    $original_harness_env = $ENV{HARNESS_ACTIVE} || 0;
+    $ENV{HARNESS_ACTIVE} = 0;
+
+    my $hub = $t->{Hub} || ($t->{Stack} ? $t->{Stack}->top : Test2::API::test2_stack->top);
+    $original_formatter = $hub->format;
+    unless ($original_formatter && $original_formatter->isa('Test::Builder::Formatter')) {
+        my $fmt = Test::Builder::Formatter->new;
+        $hub->format($fmt);
+    }
+
+    # remember what the handles were set to
+    $original_output_handle  = $t->output();
+    $original_failure_handle = $t->failure_output();
+    $original_todo_handle    = $t->todo_output();
+
+    # switch out to our own handles
+    $t->output($output_handle);
+    $t->failure_output($error_handle);
+    $t->todo_output($output_handle);
+
+    # clear the expected list
+    $out->reset();
+    $err->reset();
+
+    # remember that we're testing
+    $testing     = 1;
+    $testing_num = $t->current_test;
+    $t->current_test(0);
+    $original_is_passing  = $t->is_passing;
+    $t->is_passing(1);
+
+    # look, we shouldn't do the ending stuff
+    $t->no_ending(1);
+}
+
+=head2 Functions
+
+These are the six methods that are exported as default.
+
+=over 4
+
+=item test_out
+
+=item test_err
+
+Procedures for predeclaring the output that your test suite is
+expected to produce until C<test_test> is called.  These procedures
+automatically assume that each line terminates with "\n".  So
+
+   test_out("ok 1","ok 2");
+
+is the same as
+
+   test_out("ok 1\nok 2");
+
+which is even the same as
+
+   test_out("ok 1");
+   test_out("ok 2");
+
+Once C<test_out> or C<test_err> (or C<test_fail> or C<test_diag>) have
+been called, all further output from L<Test::Builder> will be
+captured by L<Test::Builder::Tester>.  This means that you will not
+be able perform further tests to the normal output in the normal way
+until you call C<test_test> (well, unless you manually meddle with the
+output filehandles)
+
+=cut
+
+sub test_out {
+    # do we need to do any setup?
+    _start_testing() unless $testing;
+
+    $out->expect(@_);
+}
+
+sub test_err {
+    # do we need to do any setup?
+    _start_testing() unless $testing;
+
+    $err->expect(@_);
+}
+
+=item test_fail
+
+Because the standard failure message that L<Test::Builder> produces
+whenever a test fails will be a common occurrence in your test error
+output, and because it has changed between Test::Builder versions, rather
+than forcing you to call C<test_err> with the string all the time like
+so
+
+    test_err("# Failed test ($0 at line ".line_num(+1).")");
+
+C<test_fail> exists as a convenience function that can be called
+instead.  It takes one argument, the offset from the current line that
+the line that causes the fail is on.
+
+    test_fail(+1);
+
+This means that the example in the synopsis could be rewritten
+more simply as:
+
+   test_out("not ok 1 - foo");
+   test_fail(+1);
+   fail("foo");
+   test_test("fail works");
+
+=cut
+
+sub test_fail {
+    # do we need to do any setup?
+    _start_testing() unless $testing;
+
+    # work out what line we should be on
+    my( $package, $filename, $line ) = caller;
+    $line = $line + ( shift() || 0 );    # prevent warnings
+
+    # expect that on stderr
+    $err->expect("#     Failed test ($filename at line $line)");
+}
+
+=item test_diag
+
+As most of the remaining expected output to the error stream will be
+created by L<Test::Builder>'s C<diag> function, L<Test::Builder::Tester>
+provides a convenience function C<test_diag> that you can use instead of
+C<test_err>.
+
+The C<test_diag> function prepends comment hashes and spacing to the
+start and newlines to the end of the expected output passed to it and
+adds it to the list of expected error output.  So, instead of writing
+
+   test_err("# Couldn't open file");
+
+you can write
+
+   test_diag("Couldn't open file");
+
+Remember that L<Test::Builder>'s diag function will not add newlines to
+the end of output and test_diag will. So to check
+
+   Test::Builder->new->diag("foo\n","bar\n");
+
+You would do
+
+  test_diag("foo","bar")
+
+without the newlines.
+
+=cut
+
+sub test_diag {
+    # do we need to do any setup?
+    _start_testing() unless $testing;
+
+    # expect the same thing, but prepended with "#     "
+    local $_;
+    $err->expect( map { "# $_" } @_ );
+}
+
+=item test_test
+
+Actually performs the output check testing the tests, comparing the
+data (with C<eq>) that we have captured from L<Test::Builder> against
+what was declared with C<test_out> and C<test_err>.
+
+This takes name/value pairs that affect how the test is run.
+
+=over
+
+=item title (synonym 'name', 'label')
+
+The name of the test that will be displayed after the C<ok> or C<not
+ok>.
+
+=item skip_out
+
+Setting this to a true value will cause the test to ignore if the
+output sent by the test to the output stream does not match that
+declared with C<test_out>.
+
+=item skip_err
+
+Setting this to a true value will cause the test to ignore if the
+output sent by the test to the error stream does not match that
+declared with C<test_err>.
+
+=back
+
+As a convenience, if only one argument is passed then this argument
+is assumed to be the name of the test (as in the above examples.)
+
+Once C<test_test> has been run test output will be redirected back to
+the original filehandles that L<Test::Builder> was connected to
+(probably STDOUT and STDERR,) meaning any further tests you run
+will function normally and cause success/errors for L<Test::Harness>.
+
+=cut
+
+sub test_test {
+    # END the hack
+    delete $INC{'Test/Stream.pm'} if $INC{'Test/Stream.pm'} && $INC{'Test/Stream.pm'} eq 'fake';
+    # decode the arguments as described in the pod
+    my $mess;
+    my %args;
+    if( @_ == 1 ) {
+        $mess = shift
+    }
+    else {
+        %args = @_;
+        $mess = $args{name} if exists( $args{name} );
+        $mess = $args{title} if exists( $args{title} );
+        $mess = $args{label} if exists( $args{label} );
+    }
+
+    # er, are we testing?
+    croak "Not testing.  You must declare output with a test function first."
+      unless $testing;
+
+
+    my $hub = $t->{Hub} || Test2::API::test2_stack->top;
+    $hub->format($original_formatter);
+
+    # okay, reconnect the test suite back to the saved handles
+    $t->output($original_output_handle);
+    $t->failure_output($original_failure_handle);
+    $t->todo_output($original_todo_handle);
+
+    # restore the test no, etc, back to the original point
+    $t->current_test($testing_num);
+    $testing = 0;
+    $t->is_passing($original_is_passing);
+
+    # re-enable the original setting of the harness
+    $ENV{HARNESS_ACTIVE} = $original_harness_env;
+
+    # check the output we've stashed
+    unless( $t->ok( ( $args{skip_out} || $out->check ) &&
+                    ( $args{skip_err} || $err->check ), $mess ) 
+    )
+    {
+        # print out the diagnostic information about why this
+        # test failed
+
+        local $_;
+
+        $t->diag( map { "$_\n" } $out->complaint )
+          unless $args{skip_out} || $out->check;
+
+        $t->diag( map { "$_\n" } $err->complaint )
+          unless $args{skip_err} || $err->check;
+    }
+}
+
+=item line_num
+
+A utility function that returns the line number that the function was
+called on.  You can pass it an offset which will be added to the
+result.  This is very useful for working out the correct text of
+diagnostic functions that contain line numbers.
+
+Essentially this is the same as the C<__LINE__> macro, but the
+C<line_num(+3)> idiom is arguably nicer.
+
+=cut
+
+sub line_num {
+    my( $package, $filename, $line ) = caller;
+    return $line + ( shift() || 0 );    # prevent warnings
+}
+
+=back
+
+In addition to the six exported functions there exists one
+function that can only be accessed with a fully qualified function
+call.
+
+=over 4
+
+=item color
+
+When C<test_test> is called and the output that your tests generate
+does not match that which you declared, C<test_test> will print out
+debug information showing the two conflicting versions.  As this
+output itself is debug information it can be confusing which part of
+the output is from C<test_test> and which was the original output from
+your original tests.  Also, it may be hard to spot things like
+extraneous whitespace at the end of lines that may cause your test to
+fail even though the output looks similar.
+
+To assist you C<test_test> can colour the background of the debug
+information to disambiguate the different types of output. The debug
+output will have its background coloured green and red.  The green
+part represents the text which is the same between the executed and
+actual output, the red shows which part differs.
+
+The C<color> function determines if colouring should occur or not.
+Passing it a true or false value will enable or disable colouring
+respectively, and the function called with no argument will return the
+current setting.
+
+To enable colouring from the command line, you can use the
+L<Text::Builder::Tester::Color> module like so:
+
+   perl -Mlib=Text::Builder::Tester::Color test.t
+
+Or by including the L<Test::Builder::Tester::Color> module directly in
+the PERL5LIB.
+
+=cut
+
+my $color;
+
+sub color {
+    $color = shift if @_;
+    $color;
+}
+
+=back
+
+=head1 BUGS
+
+Test::Builder::Tester does not handle plans well. It has never done anything
+special with plans. This means that plans from outside Test::Builder::Tester
+will affect Test::Builder::Tester, worse plans when using Test::Builder::Tester
+will affect overall testing. At this point there are no plans to fix this bug
+as people have come to depend on it, and Test::Builder::Tester is now
+discouraged in favor of C<Test2::API::intercept()>. See
+L<https://github.com/Test-More/test-more/issues/667>
+
+Calls C<< Test::Builder->no_ending >> turning off the ending tests.
+This is needed as otherwise it will trip out because we've run more
+tests than we strictly should have and it'll register any failures we
+had that we were testing for as real failures.
+
+The color function doesn't work unless L<Term::ANSIColor> is
+compatible with your terminal. Additionally, L<Win32::Console::ANSI>
+must be installed on windows platforms for color output.
+
+Bugs (and requests for new features) can be reported to the author
+though GitHub:
+L<https://github.com/Test-More/test-more/issues>
+
+=head1 AUTHOR
+
+Copyright Mark Fowler E<lt>mark@twoshortplanks.comE<gt> 2002, 2004.
+
+Some code taken from L<Test::More> and L<Test::Catch>, written by
+Michael G Schwern E<lt>schwern@pobox.comE<gt>.  Hence, those parts
+Copyright Micheal G Schwern 2001.  Used and distributed with
+permission.
+
+This program is free software; you can redistribute it
+and/or modify it under the same terms as Perl itself.
+
+=head1 MAINTAINERS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 NOTES
+
+Thanks to Richard Clamp E<lt>richardc@unixbeard.netE<gt> for letting
+me use his testing system to try this module out on.
+
+=head1 SEE ALSO
+
+L<Test::Builder>, L<Test::Builder::Tester::Color>, L<Test::More>.
+
+=cut
+
+1;
+
+####################################################################
+# Helper class that is used to remember expected and received data
+
+package Test::Builder::Tester::Tie;
+
+##
+# add line(s) to be expected
+
+sub expect {
+    my $self = shift;
+
+    my @checks = @_;
+    foreach my $check (@checks) {
+        $check = $self->_account_for_subtest($check);
+        $check = $self->_translate_Failed_check($check);
+        push @{ $self->{wanted} }, ref $check ? $check : "$check\n";
+    }
+}
+
+sub _account_for_subtest {
+    my( $self, $check ) = @_;
+
+    my $hub = $t->{Stack}->top;
+    my $nesting = $hub->isa('Test2::Hub::Subtest') ? $hub->nested : 0;
+    return ref($check) ? $check : ('    ' x $nesting) . $check;
+}
+
+sub _translate_Failed_check {
+    my( $self, $check ) = @_;
+
+    if( $check =~ /\A(.*)#     (Failed .*test) \((.*?) at line (\d+)\)\Z(?!\n)/ ) {
+        $check = "/\Q$1\E#\\s+\Q$2\E.*?\\n?.*?\Qat $3\E line \Q$4\E.*\\n?/";
+    }
+
+    return $check;
+}
+
+##
+# return true iff the expected data matches the got data
+
+sub check {
+    my $self = shift;
+
+    # turn off warnings as these might be undef
+    local $^W = 0;
+
+    my @checks = @{ $self->{wanted} };
+    my $got    = $self->{got};
+    foreach my $check (@checks) {
+        $check = "\Q$check\E" unless( $check =~ s,^/(.*)/$,$1, or ref $check );
+        return 0 unless $got =~ s/^$check//;
+    }
+
+    return length $got == 0;
+}
+
+##
+# a complaint message about the inputs not matching (to be
+# used for debugging messages)
+
+sub complaint {
+    my $self   = shift;
+    my $type   = $self->type;
+    my $got    = $self->got;
+    my $wanted = join '', @{ $self->wanted };
+
+    # are we running in colour mode?
+    if(Test::Builder::Tester::color) {
+        # get color
+        eval { require Term::ANSIColor };
+        unless($@) {
+            eval { require Win32::Console::ANSI } if 'MSWin32' eq $^O;  # support color on windows platforms
+
+            # colours
+
+            my $green = Term::ANSIColor::color("black") . Term::ANSIColor::color("on_green");
+            my $red   = Term::ANSIColor::color("black") . Term::ANSIColor::color("on_red");
+            my $reset = Term::ANSIColor::color("reset");
+
+            # work out where the two strings start to differ
+            my $char = 0;
+            $char++ while substr( $got, $char, 1 ) eq substr( $wanted, $char, 1 );
+
+            # get the start string and the two end strings
+            my $start = $green . substr( $wanted, 0, $char );
+            my $gotend    = $red . substr( $got,    $char ) . $reset;
+            my $wantedend = $red . substr( $wanted, $char ) . $reset;
+
+            # make the start turn green on and off
+            $start =~ s/\n/$reset\n$green/g;
+
+            # make the ends turn red on and off
+            $gotend    =~ s/\n/$reset\n$red/g;
+            $wantedend =~ s/\n/$reset\n$red/g;
+
+            # rebuild the strings
+            $got    = $start . $gotend;
+            $wanted = $start . $wantedend;
+        }
+    }
+
+    my @got = split "\n", $got;
+    my @wanted = split "\n", $wanted;
+
+    $got = "";
+    $wanted = "";
+
+    while (@got || @wanted) {
+        my $g = shift @got    || "";
+        my $w = shift @wanted || "";
+        if ($g ne $w) {
+            if($g =~ s/(\s+)$/    |> /g) {
+                $g .= ($_ eq ' ' ? '_' : '\t') for split '', $1;
+            }
+            if($w =~ s/(\s+)$/    |> /g) {
+                $w .= ($_ eq ' ' ? '_' : '\t') for split '', $1;
+            }
+            $g = "> $g";
+            $w = "> $w";
+        }
+        else {
+            $g = "  $g";
+            $w = "  $w";
+        }
+        $got = $got ? "$got\n$g" : $g;
+        $wanted = $wanted ? "$wanted\n$w" : $w;
+    }
+
+    return "$type is:\n" . "$got\nnot:\n$wanted\nas expected";
+}
+
+##
+# forget all expected and got data
+
+sub reset {
+    my $self = shift;
+    %$self = (
+        type   => $self->{type},
+        got    => '',
+        wanted => [],
+    );
+}
+
+sub got {
+    my $self = shift;
+    return $self->{got};
+}
+
+sub wanted {
+    my $self = shift;
+    return $self->{wanted};
+}
+
+sub type {
+    my $self = shift;
+    return $self->{type};
+}
+
+###
+# tie interface
+###
+
+sub PRINT {
+    my $self = shift;
+    $self->{got} .= join '', @_;
+}
+
+sub TIEHANDLE {
+    my( $class, $type ) = @_;
+
+    my $self = bless { type => $type }, $class;
+
+    $self->reset;
+
+    return $self;
+}
+
+sub READ     { }
+sub READLINE { }
+sub GETC     { }
+sub FILENO   { }
+
+1;

git/usr/share/perl5/core_perl/Test/Builder/Tester/Color.pm

@@ -0,0 +1,51 @@
+package Test::Builder::Tester::Color;
+
+use strict;
+our $VERSION = '1.302210';
+
+require Test::Builder::Tester;
+
+
+=head1 NAME
+
+Test::Builder::Tester::Color - turn on colour in Test::Builder::Tester
+
+=head1 SYNOPSIS
+
+   When running a test script
+
+     perl -MTest::Builder::Tester::Color test.t
+
+=head1 DESCRIPTION
+
+Importing this module causes the subroutine color in Test::Builder::Tester
+to be called with a true value causing colour highlighting to be turned
+on in debug output.
+
+The sole purpose of this module is to enable colour highlighting
+from the command line.
+
+=cut
+
+sub import {
+    Test::Builder::Tester::color(1);
+}
+
+=head1 AUTHOR
+
+Copyright Mark Fowler E<lt>mark@twoshortplanks.comE<gt> 2002.
+
+This program is free software; you can redistribute it
+and/or modify it under the same terms as Perl itself.
+
+=head1 BUGS
+
+This module will have no effect unless Term::ANSIColor is installed.
+
+=head1 SEE ALSO
+
+L<Test::Builder::Tester>, L<Term::ANSIColor>
+
+=cut
+
+1;

git/usr/share/perl5/core_perl/Test/Builder/TodoDiag.pm

@@ -0,0 +1,68 @@
+package Test::Builder::TodoDiag;
+use strict;
+use warnings;
+
+our $VERSION = '1.302210';
+
+BEGIN { require Test2::Event::Diag; our @ISA = qw(Test2::Event::Diag) }
+
+sub diagnostics { 0 }
+
+sub facet_data {
+    my $self = shift;
+    my $out = $self->SUPER::facet_data();
+    $out->{info}->[0]->{debug} = 0;
+    return $out;
+}
+
+1;
+
+__END__
+
+=pod
+
+=encoding UTF-8
+
+=head1 NAME
+
+Test::Builder::TodoDiag - Test::Builder subclass of Test2::Event::Diag
+
+=head1 DESCRIPTION
+
+This is used to encapsulate diag messages created inside TODO.
+
+=head1 SYNOPSIS
+
+You do not need to use this directly.
+
+=head1 SOURCE
+
+The source code repository for Test2 can be found at
+L<https://github.com/Test-More/test-more/>.
+
+=head1 MAINTAINERS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 COPYRIGHT
+
+Copyright Chad Granum E<lt>exodist@cpan.orgE<gt>.
+
+This program is free software; you can redistribute it and/or
+modify it under the same terms as Perl itself.
+
+See L<https://dev.perl.org/licenses/>
+
+=cut

git/usr/share/perl5/core_perl/Test/Tester/Capture.pm

@@ -0,0 +1,240 @@
+use strict;
+
+package Test::Tester::Capture;
+
+our $VERSION = '1.302210';
+
+
+use Test::Builder;
+
+our @ISA = qw( Test::Builder );
+
+# Make Test::Tester::Capture thread-safe for ithreads.
+BEGIN {
+	use Config;
+	*share = sub { 0 };
+	*lock  = sub { 0 };
+}
+
+my $Curr_Test = 0;      share($Curr_Test);
+my @Test_Results = ();  share(@Test_Results);
+my $Prem_Diag = {diag => ""};	 share($Curr_Test);
+
+sub new
+{
+  # Test::Tester::Capgture::new used to just return __PACKAGE__
+  # because Test::Builder::new enforced its singleton nature by
+  # return __PACKAGE__. That has since changed, Test::Builder::new now
+  # returns a blessed has and around version 0.78, Test::Builder::todo
+  # started wanting to modify $self. To cope with this, we now return
+  # a blessed hash. This is a short-term hack, the correct thing to do
+  # is to detect which style of Test::Builder we're dealing with and
+  # act appropriately.
+
+  my $class = shift;
+  return bless {}, $class;
+}
+
+sub ok {
+	my($self, $test, $name) = @_;
+
+	my $ctx = $self->ctx;
+
+	# $test might contain an object which we don't want to accidentally
+	# store, so we turn it into a boolean.
+	$test = $test ? 1 : 0;
+
+	lock $Curr_Test;
+	$Curr_Test++;
+
+	my($pack, $file, $line) = $self->caller;
+
+	my $todo = $self->todo();
+
+	my $result = {};
+	share($result);
+
+	unless( $test ) {
+		@$result{ 'ok', 'actual_ok' } = ( ( $todo ? 1 : 0 ), 0 );
+	}
+	else {
+		@$result{ 'ok', 'actual_ok' } = ( 1, $test );
+	}
+
+	if( defined $name ) {
+		$name =~ s|#|\\#|g;	 # # in a name can confuse Test::Harness.
+		$result->{name} = $name;
+	}
+	else {
+		$result->{name} = '';
+	}
+
+	if( $todo ) {
+		my $what_todo = $todo;
+		$result->{reason} = $what_todo;
+		$result->{type}   = 'todo';
+	}
+	else {
+		$result->{reason} = '';
+		$result->{type}   = '';
+	}
+
+	$Test_Results[$Curr_Test-1] = $result;
+
+	unless( $test ) {
+		my $msg = $todo ? "Failed (TODO)" : "Failed";
+		$result->{fail_diag} = ("	$msg test ($file at line $line)\n");
+	} 
+
+	$result->{diag} = "";
+	$result->{_level} = $Test::Builder::Level;
+	$result->{_depth} = Test::Tester::find_run_tests();
+
+	$ctx->release;
+
+	return $test ? 1 : 0;
+}
+
+sub skip {
+	my($self, $why) = @_;
+	$why ||= '';
+
+	my $ctx = $self->ctx;
+
+	lock($Curr_Test);
+	$Curr_Test++;
+
+	my %result;
+	share(%result);
+	%result = (
+		'ok'	  => 1,
+		actual_ok => 1,
+		name	  => '',
+		type	  => 'skip',
+		reason	=> $why,
+		diag    => "",
+		_level   => $Test::Builder::Level,
+		_depth => Test::Tester::find_run_tests(),
+	);
+	$Test_Results[$Curr_Test-1] = \%result;
+
+	$ctx->release;
+	return 1;
+}
+
+sub todo_skip {
+	my($self, $why) = @_;
+	$why ||= '';
+
+	my $ctx = $self->ctx;
+
+	lock($Curr_Test);
+	$Curr_Test++;
+
+	my %result;
+	share(%result);
+	%result = (
+		'ok'	  => 1,
+		actual_ok => 0,
+		name	  => '',
+		type	  => 'todo_skip',
+		reason	=> $why,
+		diag    => "",
+		_level   => $Test::Builder::Level,
+		_depth => Test::Tester::find_run_tests(),
+	);
+
+	$Test_Results[$Curr_Test-1] = \%result;
+
+	$ctx->release;
+	return 1;
+}
+
+sub diag {
+	my($self, @msgs) = @_;
+	return unless @msgs;
+
+	# Prevent printing headers when compiling (i.e. -c)
+	return if $^C;
+
+	my $ctx = $self->ctx;
+
+	# Escape each line with a #.
+	foreach (@msgs) {
+		$_ = 'undef' unless defined;
+	}
+
+	push @msgs, "\n" unless $msgs[-1] =~ /\n\Z/;
+
+	my $result = $Curr_Test ? $Test_Results[$Curr_Test - 1] : $Prem_Diag;
+
+	$result->{diag} .= join("", @msgs);
+
+	$ctx->release;
+	return 0;
+}
+
+sub details {
+	return @Test_Results;
+}
+
+
+# Stub. Feel free to send me a patch to implement this.
+sub note {
+}
+
+sub explain {
+	return Test::Builder::explain(@_);
+}
+
+sub premature
+{
+	return $Prem_Diag->{diag};
+}
+
+sub current_test
+{
+	if (@_ > 1)
+	{
+		die "Don't try to change the test number!";
+	}
+	else
+	{
+		return $Curr_Test;
+	}
+}
+
+sub reset
+{
+	$Curr_Test = 0;
+	@Test_Results = ();
+	$Prem_Diag = {diag => ""};
+}
+
+1;
+
+__END__
+
+=head1 NAME
+
+Test::Tester::Capture - Help testing test modules built with Test::Builder
+
+=head1 DESCRIPTION
+
+This is a subclass of Test::Builder that overrides many of the methods so
+that they don't output anything. It also keeps track of its own set of test
+results so that you can use Test::Builder based modules to perform tests on
+other Test::Builder based modules.
+
+=head1 AUTHOR
+
+Most of the code here was lifted straight from Test::Builder and then had
+chunks removed by Fergal Daly <fergal@esatclear.ie>.
+
+=head1 LICENSE
+
+Under the same license as Perl itself
+
+See L<https://dev.perl.org/licenses/>
+
+=cut

git/usr/share/perl5/core_perl/Test/Tester/CaptureRunner.pm

@@ -0,0 +1,79 @@
+# $Header: /home/fergal/my/cvs/Test-Tester/lib/Test/Tester/CaptureRunner.pm,v 1.3 2003/03/05 01:07:55 fergal Exp $
+use strict;
+
+package Test::Tester::CaptureRunner;
+
+our $VERSION = '1.302210';
+
+
+use Test::Tester::Capture;
+require Exporter;
+
+sub new
+{
+	my $pkg = shift;
+	my $self = bless {}, $pkg;
+	return $self;
+}
+
+sub run_tests
+{
+	my $self = shift;
+
+	my $test = shift;
+
+	capture()->reset;
+
+	$self->{StartLevel} = $Test::Builder::Level;
+	&$test();
+}
+
+sub get_results
+{
+	my $self = shift;
+	my @results = capture()->details;
+
+	my $start = $self->{StartLevel};
+	foreach my $res (@results)
+	{
+		next if defined $res->{depth};
+		my $depth = $res->{_depth} - $res->{_level} - $start - 3;
+#		print "my $depth = $res->{_depth} - $res->{_level} - $start - 1\n";
+		$res->{depth} = $depth;
+	}
+
+	return @results;
+}
+
+sub get_premature
+{
+	return capture()->premature;
+}
+
+sub capture
+{
+	return Test::Tester::Capture->new;
+}
+
+__END__
+
+=head1 NAME
+
+Test::Tester::CaptureRunner - Help testing test modules built with Test::Builder
+
+=head1 DESCRIPTION
+
+This stuff if needed to allow me to play with other ways of monitoring the
+test results.
+
+=head1 AUTHOR
+
+Copyright 2003 by Fergal Daly <fergal@esatclear.ie>.
+
+=head1 LICENSE
+
+Under the same license as Perl itself
+
+See L<https://dev.perl.org/licenses/>
+
+=cut

git/usr/share/perl5/core_perl/Test/Tester/Delegate.pm

@@ -0,0 +1,43 @@
+use strict;
+use warnings;
+
+package Test::Tester::Delegate;
+
+our $VERSION = '1.302210';
+
+use Scalar::Util();
+
+sub new
+{
+	my $pkg = shift;
+
+	my $obj = shift;
+	my $self = bless {}, $pkg;
+
+	return $self;
+}
+
+sub AUTOLOAD
+{
+	my ($sub) = our $AUTOLOAD =~ /.*::(.*?)$/;
+
+	return if $sub eq "DESTROY";
+
+	my $obj = $_[0]->{Object};
+
+	my $ref = $obj->can($sub);
+	shift(@_);
+	unshift(@_, $obj);
+	goto &$ref;
+}
+
+sub can {
+	my $this = shift;
+	my ($sub) = @_;
+
+	return $this->{Object}->can($sub) if Scalar::Util::blessed($this);
+
+	return $this->SUPER::can(@_);
+}
+
+1;

git/usr/share/perl5/core_perl/Test/use/ok.pm

@@ -0,0 +1,64 @@
+package Test::use::ok;
+use 5.005;
+
+our $VERSION = '1.302210';
+
+
+__END__
+
+=head1 NAME
+
+Test::use::ok - Alternative to Test::More::use_ok
+
+=head1 SYNOPSIS
+
+    use ok 'Some::Module';
+
+=head1 DESCRIPTION
+
+According to the B<Test::More> documentation, it is recommended to run
+C<use_ok()> inside a C<BEGIN> block, so functions are exported at
+compile-time and prototypes are properly honored.
+
+That is, instead of writing this:
+
+    use_ok( 'Some::Module' );
+    use_ok( 'Other::Module' );
+
+One should write this:
+
+    BEGIN { use_ok( 'Some::Module' ); }
+    BEGIN { use_ok( 'Other::Module' ); }
+
+However, people often either forget to add C<BEGIN>, or mistakenly group
+C<use_ok> with other tests in a single C<BEGIN> block, which can create subtle
+differences in execution order.
+
+With this module, simply change all C<use_ok> in test scripts to C<use ok>,
+and they will be executed at C<BEGIN> time.  The explicit space after C<use>
+makes it clear that this is a single compile-time action.
+
+=head1 SEE ALSO
+
+L<Test::More>
+
+=head1 MAINTAINER
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=encoding utf8
+
+=head1 CC0 1.0 Universal
+
+To the extent possible under law, 唐鳳 has waived all copyright and related
+or neighboring rights to L<Test::use::ok>.
+
+This work is published from Taiwan.
+
+L<https://creativecommons.org/publicdomain/zero/1.0/>
+
+=cut

git/usr/share/perl5/core_perl/Test2/API/Breakage.pm

@@ -0,0 +1,180 @@
+package Test2::API::Breakage;
+use strict;
+use warnings;
+
+our $VERSION = '1.302210';
+
+
+use Test2::Util qw/pkg_to_file/;
+
+our @EXPORT_OK = qw{
+    upgrade_suggested
+    upgrade_required
+    known_broken
+};
+BEGIN { require Exporter; our @ISA = qw(Exporter) }
+
+sub upgrade_suggested {
+    return (
+        'Test::Exception'    => '0.42',
+        'Test::FITesque'     => '0.04',
+        'Test::Module::Used' => '0.2.5',
+        'Test::Moose::More'  => '0.025',
+    );
+}
+
+sub upgrade_required {
+    return (
+        'Test::Builder::Clutch'   => '0.07',
+        'Test::Dist::VersionSync' => '1.1.4',
+        'Test::Modern'            => '0.012',
+        'Test::SharedFork'        => '0.34',
+        'Test::Alien'             => '0.04',
+        'Test::UseAllModules'     => '0.14',
+        'Test::More::Prefix'      => '0.005',
+
+        'Test2::Tools::EventDumper' => 0.000007,
+        'Test2::Harness'            => 0.000013,
+
+        'Test::DBIx::Class::Schema'    => '1.0.9',
+        'Test::Clustericious::Cluster' => '0.30',
+    );
+}
+
+sub known_broken {
+    return (
+        'Net::BitTorrent'       => '0.052',
+        'Test::Able'            => '0.11',
+        'Test::Aggregate'       => '0.373',
+        'Test::Flatten'         => '0.11',
+        'Test::Group'           => '0.20',
+        'Test::ParallelSubtest' => '0.05',
+        'Test::Pretty'          => '0.32',
+        'Test::Wrapper'         => '0.3.0',
+
+        'Log::Dispatch::Config::TestLog' => '0.02',
+    );
+}
+
+# Not reportable:
+# Device::Chip => 0.07   - Tests will not pass, but not broken if already installed, also no fixed version we can upgrade to.
+
+sub report {
+    my $class = shift;
+    my ($require) = @_;
+
+    my %suggest  = __PACKAGE__->upgrade_suggested();
+    my %required = __PACKAGE__->upgrade_required();
+    my %broken   = __PACKAGE__->known_broken();
+
+    my @warn;
+    for my $mod (keys %suggest) {
+        my $file = pkg_to_file($mod);
+        next unless $INC{$file} || ($require && eval { require $file; 1 });
+        my $want = $suggest{$mod};
+        next if eval { $mod->VERSION($want); 1 };
+        my $error = $@;
+        chomp $error;
+        push @warn => " * Module '$mod' is outdated, we recommend updating above $want. error was: '$error'; INC is $INC{$file}";
+    }
+
+    for my $mod (keys %required) {
+        my $file = pkg_to_file($mod);
+        next unless $INC{$file} || ($require && eval { require $file; 1 });
+        my $want = $required{$mod};
+        next if eval { $mod->VERSION($want); 1 };
+        push @warn => " * Module '$mod' is outdated and known to be broken, please update to $want or higher.";
+    }
+
+    for my $mod (keys %broken) {
+        my $file = pkg_to_file($mod);
+        next unless $INC{$file} || ($require && eval { require $file; 1 });
+        my $tested = $broken{$mod};
+        push @warn => " * Module '$mod' is known to be broken in version $tested and below, newer versions have not been tested. You have: " . $mod->VERSION;
+    }
+
+    return @warn;
+}
+
+1;
+
+__END__
+
+
+=pod
+
+=encoding UTF-8
+
+=head1 NAME
+
+Test2::API::Breakage - What breaks at what version
+
+=head1 DESCRIPTION
+
+This module provides lists of modules that are broken, or have been broken in
+the past, when upgrading L<Test::Builder> to use L<Test2>.
+
+=head1 FUNCTIONS
+
+These can be imported, or called as methods on the class.
+
+=over 4
+
+=item %mod_ver = upgrade_suggested()
+
+=item %mod_ver = Test2::API::Breakage->upgrade_suggested()
+
+This returns key/value pairs. The key is the module name, the value is the
+version number. If the installed version of the module is at or below the
+specified one then an upgrade would be a good idea, but not strictly necessary.
+
+=item %mod_ver = upgrade_required()
+
+=item %mod_ver = Test2::API::Breakage->upgrade_required()
+
+This returns key/value pairs. The key is the module name, the value is the
+version number. If the installed version of the module is at or below the
+specified one then an upgrade is required for the module to work properly.
+
+=item %mod_ver = known_broken()
+
+=item %mod_ver = Test2::API::Breakage->known_broken()
+
+This returns key/value pairs. The key is the module name, the value is the
+version number. If the installed version of the module is at or below the
+specified one then the module will not work. A newer version may work, but is
+not tested or verified.
+
+=back
+
+=head1 SOURCE
+
+The source code repository for Test2 can be found at
+L<https://github.com/Test-More/test-more/>.
+
+=head1 MAINTAINERS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 COPYRIGHT
+
+Copyright Chad Granum E<lt>exodist@cpan.orgE<gt>.
+
+This program is free software; you can redistribute it and/or
+modify it under the same terms as Perl itself.
+
+See L<https://dev.perl.org/licenses/>
+
+=cut

git/usr/share/perl5/core_perl/Test2/API/Context.pm

@@ -0,0 +1,1036 @@
+package Test2::API::Context;
+use strict;
+use warnings;
+
+our $VERSION = '1.302210';
+
+
+use Carp qw/confess croak/;
+use Scalar::Util qw/weaken blessed/;
+use Test2::Util qw/get_tid try pkg_to_file get_tid/;
+
+use Test2::EventFacet::Trace();
+use Test2::API();
+
+# Preload some key event types
+my %LOADED = (
+    map {
+        my $pkg  = "Test2::Event::$_";
+        my $file = "Test2/Event/$_.pm";
+        require $file unless $INC{$file};
+        ( $pkg => $pkg, $_ => $pkg )
+    } qw/Ok Diag Note Plan Bail Exception Waiting Skip Subtest Pass Fail V2/
+);
+
+use Test2::Util::ExternalMeta qw/meta get_meta set_meta delete_meta/;
+use Test2::Util::HashBase qw{
+    stack hub trace _on_release _depth _is_canon _is_spawn _aborted
+    errno eval_error child_error thrown _failed _start_fail_count
+};
+
+# Private, not package vars
+# It is safe to cache these.
+my $ON_RELEASE = Test2::API::_context_release_callbacks_ref();
+my $CONTEXTS   = Test2::API::_contexts_ref();
+
+sub init {
+    my $self = shift;
+
+    confess "The 'trace' attribute is required"
+        unless $self->{+TRACE};
+
+    confess "The 'hub' attribute is required"
+        unless $self->{+HUB};
+
+    $self->{+_START_FAIL_COUNT} = $self->{+HUB}->{failed} || 0;
+
+    $self->{+_DEPTH} = 0 unless defined $self->{+_DEPTH};
+
+    $self->{+ERRNO}       = $! unless exists $self->{+ERRNO};
+    $self->{+EVAL_ERROR}  = $@ unless exists $self->{+EVAL_ERROR};
+    $self->{+CHILD_ERROR} = $? unless exists $self->{+CHILD_ERROR};
+}
+
+sub snapshot { bless {%{$_[0]}, _is_canon => undef, _is_spawn => undef, _aborted => undef}, __PACKAGE__ }
+
+sub restore_error_vars {
+    my $self = shift;
+    ($!, $@, $?) = @$self{+ERRNO, +EVAL_ERROR, +CHILD_ERROR};
+}
+
+sub DESTROY {
+    return unless $_[0]->{+_IS_CANON} || $_[0]->{+_IS_SPAWN};
+    return if $_[0]->{+_ABORTED} && ${$_[0]->{+_ABORTED}};
+    my ($self) = @_;
+
+    my $hub = $self->{+HUB};
+    my $hid = $hub->{hid};
+
+    $self->{+_FAILED} = ($hub->{failed} || 0) - $self->{+_START_FAIL_COUNT};
+
+    # Do not show the warning if it looks like an exception has been thrown, or
+    # if the context is not local to this process or thread.
+    {
+        # Sometimes $@ is uninitialized, not a problem in this case so do not
+        # show the warning about using eq.
+        no warnings 'uninitialized';
+        if($self->{+EVAL_ERROR} eq $@ && $hub->is_local) {
+            require Carp;
+            my $mess = Carp::longmess("Context destroyed");
+            my $frame = $self->{+_IS_SPAWN} || $self->{+TRACE}->frame;
+            warn <<"            EOT";
+A context appears to have been destroyed without first calling release().
+Based on \$@ it does not look like an exception was thrown (this is not always
+a reliable test)
+
+This is a problem because the global error variables (\$!, \$@, and \$?) will
+not be restored. In addition some release callbacks will not work properly from
+inside a DESTROY method.
+
+Here are the context creation details, just in case a tool forgot to call
+release():
+  File: $frame->[1]
+  Line: $frame->[2]
+  Tool: $frame->[3]
+
+Here is a trace to the code that caused the context to be destroyed, this could
+be an exit(), a goto, or simply the end of a scope:
+$mess
+
+Cleaning up the CONTEXT stack...
+            EOT
+        }
+    }
+
+    return if $self->{+_IS_SPAWN};
+
+    # Remove the key itself to avoid a slow memory leak
+    delete $CONTEXTS->{$hid};
+    $self->{+_IS_CANON} = undef;
+
+    if (my $cbk = $self->{+_ON_RELEASE}) {
+        $_->($self) for reverse @$cbk;
+    }
+    if (my $hcbk = $hub->{_context_release}) {
+        $_->($self) for reverse @$hcbk;
+    }
+    $_->($self) for reverse @$ON_RELEASE;
+
+    if (my @diags = Test2::API::test2_clear_pending_diags()) {
+        if ($self->{+_FAILED} || ${$self->{+_ABORTED}}) {
+            $self->diag($_) for @diags;
+        }
+    }
+}
+
+# release exists to implement behaviors like die-on-fail. In die-on-fail you
+# want to die after a failure, but only after diagnostics have been reported.
+# The ideal time for the die to happen is when the context is released.
+# Unfortunately die does not work in a DESTROY block.
+sub release {
+    my ($self) = @_;
+
+    ($!, $@, $?) = @$self{+ERRNO, +EVAL_ERROR, +CHILD_ERROR} and return if $self->{+THROWN};
+
+    ($!, $@, $?) = @$self{+ERRNO, +EVAL_ERROR, +CHILD_ERROR} and return $self->{+_IS_SPAWN} = undef
+        if $self->{+_IS_SPAWN};
+
+    croak "release() should not be called on context that is neither canon nor a child"
+        unless $self->{+_IS_CANON};
+
+    my $hub = $self->{+HUB};
+    my $hid = $hub->{hid};
+
+    $self->{+_FAILED} = ($hub->{failed} || 0) - $self->{+_START_FAIL_COUNT};
+
+    croak "context thinks it is canon, but it is not"
+        unless $CONTEXTS->{$hid} && $CONTEXTS->{$hid} == $self;
+
+    # Remove the key itself to avoid a slow memory leak
+    $self->{+_IS_CANON} = undef;
+    delete $CONTEXTS->{$hid};
+
+    if (my $cbk = $self->{+_ON_RELEASE}) {
+        $_->($self) for reverse @$cbk;
+    }
+    if (my $hcbk = $hub->{_context_release}) {
+        $_->($self) for reverse @$hcbk;
+    }
+    $_->($self) for reverse @$ON_RELEASE;
+
+    if (my @diags = Test2::API::test2_clear_pending_diags()) {
+        if ($self->{+_FAILED} || ${$self->{+_ABORTED}}) {
+            $self->diag($_) for @diags;
+        }
+    }
+
+    # Do this last so that nothing else changes them.
+    # If one of the hooks dies then these do not get restored, this is
+    # intentional
+    ($!, $@, $?) = @$self{+ERRNO, +EVAL_ERROR, +CHILD_ERROR};
+
+    return;
+}
+
+sub do_in_context {
+    my $self = shift;
+    my ($sub, @args) = @_;
+
+    # We need to update the pid/tid and error vars.
+    my $clone = $self->snapshot;
+    @$clone{+ERRNO, +EVAL_ERROR, +CHILD_ERROR} = ($!, $@, $?);
+    $clone->{+TRACE} = $clone->{+TRACE}->snapshot(pid => $$, tid => get_tid());
+
+    my $hub = $clone->{+HUB};
+    my $hid = $hub->hid;
+
+    my $old = $CONTEXTS->{$hid};
+
+    $clone->{+_IS_CANON} = 1;
+    $CONTEXTS->{$hid} = $clone;
+    weaken($CONTEXTS->{$hid});
+    my ($ok, $err) = &try($sub, @args);
+    my ($rok, $rerr) = try { $clone->release };
+    delete $clone->{+_IS_CANON};
+
+    if ($old) {
+        $CONTEXTS->{$hid} = $old;
+        weaken($CONTEXTS->{$hid});
+    }
+    else {
+        delete $CONTEXTS->{$hid};
+    }
+
+    die $err  unless $ok;
+    die $rerr unless $rok;
+}
+
+sub done_testing {
+    my $self = shift;
+    $self->hub->finalize($self->trace, 1);
+    return;
+}
+
+sub throw {
+    my ($self, $msg) = @_;
+    $self->{+THROWN} = 1;
+    ${$self->{+_ABORTED}}++ if $self->{+_ABORTED};
+    $self->release if $self->{+_IS_CANON} || $self->{+_IS_SPAWN};
+    $self->trace->throw($msg);
+}
+
+sub alert {
+    my ($self, $msg) = @_;
+    $self->trace->alert($msg);
+}
+
+sub send_ev2_and_release {
+    my $self = shift;
+    my $out  = $self->send_ev2(@_);
+    $self->release;
+    return $out;
+}
+
+sub send_ev2 {
+    my $self = shift;
+
+    my $e;
+    {
+        local $Carp::CarpLevel = $Carp::CarpLevel + 1;
+        $e = Test2::Event::V2->new(
+            trace => $self->{+TRACE}->snapshot,
+            @_,
+        );
+    }
+
+    if ($self->{+_ABORTED}) {
+        my $f = $e->facet_data;
+        ${$self->{+_ABORTED}}++ if $f->{control}->{halt} || defined($f->{control}->{terminate}) || defined($e->terminate);
+    }
+    $self->{+HUB}->send($e);
+}
+
+sub build_ev2 {
+    my $self = shift;
+
+    local $Carp::CarpLevel = $Carp::CarpLevel + 1;
+    Test2::Event::V2->new(
+        trace => $self->{+TRACE}->snapshot,
+        @_,
+    );
+}
+
+sub send_event_and_release {
+    my $self = shift;
+    my $out = $self->send_event(@_);
+    $self->release;
+    return $out;
+}
+
+sub send_event {
+    my $self  = shift;
+    my $event = shift;
+    my %args  = @_;
+
+    my $pkg = $LOADED{$event} || $self->_parse_event($event);
+
+    my $e;
+    {
+        local $Carp::CarpLevel = $Carp::CarpLevel + 1;
+        $e = $pkg->new(
+            trace => $self->{+TRACE}->snapshot,
+            %args,
+        );
+    }
+
+    if ($self->{+_ABORTED}) {
+        my $f = $e->facet_data;
+        ${$self->{+_ABORTED}}++ if $f->{control}->{halt} || defined($f->{control}->{terminate}) || defined($e->terminate);
+    }
+    $self->{+HUB}->send($e);
+}
+
+sub build_event {
+    my $self  = shift;
+    my $event = shift;
+    my %args  = @_;
+
+    my $pkg = $LOADED{$event} || $self->_parse_event($event);
+
+    local $Carp::CarpLevel = $Carp::CarpLevel + 1;
+    $pkg->new(
+        trace => $self->{+TRACE}->snapshot,
+        %args,
+    );
+}
+
+sub pass {
+    my $self = shift;
+    my ($name) = @_;
+
+    my $e = bless(
+        {
+            trace => bless({%{$self->{+TRACE}}}, 'Test2::EventFacet::Trace'),
+            name  => $name,
+        },
+        "Test2::Event::Pass"
+    );
+
+    $self->{+HUB}->send($e);
+    return $e;
+}
+
+sub pass_and_release {
+    my $self = shift;
+    my ($name) = @_;
+
+    my $e = bless(
+        {
+            trace => bless({%{$self->{+TRACE}}}, 'Test2::EventFacet::Trace'),
+            name  => $name,
+        },
+        "Test2::Event::Pass"
+    );
+
+    $self->{+HUB}->send($e);
+    $self->release;
+    return 1;
+}
+
+sub fail {
+    my $self = shift;
+    my ($name, @diag) = @_;
+
+    my $e = bless(
+        {
+            trace => bless({%{$self->{+TRACE}}}, 'Test2::EventFacet::Trace'),
+            name  => $name,
+        },
+        "Test2::Event::Fail"
+    );
+
+    for my $msg (@diag) {
+        if (ref($msg) eq 'Test2::EventFacet::Info::Table') {
+            $e->add_info({tag => 'DIAG', debug => 1, $msg->info_args});
+        }
+        else {
+            $e->add_info({tag => 'DIAG', debug => 1, details => $msg});
+        }
+    }
+
+    $self->{+HUB}->send($e);
+    return $e;
+}
+
+sub fail_and_release {
+    my $self = shift;
+    my ($name, @diag) = @_;
+
+    my $e = bless(
+        {
+            trace => bless({%{$self->{+TRACE}}}, 'Test2::EventFacet::Trace'),
+            name  => $name,
+        },
+        "Test2::Event::Fail"
+    );
+
+    for my $msg (@diag) {
+        if (ref($msg) eq 'Test2::EventFacet::Info::Table') {
+            $e->add_info({tag => 'DIAG', debug => 1, $msg->info_args});
+        }
+        else {
+            $e->add_info({tag => 'DIAG', debug => 1, details => $msg});
+        }
+    }
+
+    $self->{+HUB}->send($e);
+    $self->release;
+    return 0;
+}
+
+sub ok {
+    my $self = shift;
+    my ($pass, $name, $on_fail) = @_;
+
+    my $hub = $self->{+HUB};
+
+    my $e = bless {
+        trace => bless( {%{$self->{+TRACE}}}, 'Test2::EventFacet::Trace'),
+        pass  => $pass,
+        name  => $name,
+    }, 'Test2::Event::Ok';
+    $e->init;
+
+    $hub->send($e);
+    return $e if $pass;
+
+    $self->failure_diag($e);
+
+    if ($on_fail && @$on_fail) {
+        $self->diag($_) for @$on_fail;
+    }
+
+    return $e;
+}
+
+sub failure_diag {
+    my $self = shift;
+    my ($e) = @_;
+
+    # Figure out the debug info, this is typically the file name and line
+    # number, but can also be a custom message. If no trace object is provided
+    # then we have nothing useful to display.
+    my $name  = $e->name;
+    my $trace = $e->trace;
+    my $debug = $trace ? $trace->debug : "[No trace info available]";
+
+    # Create the initial diagnostics. If the test has a name we put the debug
+    # info on a second line, this behavior is inherited from Test::Builder.
+    my $msg = defined($name)
+        ? qq[Failed test '$name'\n$debug.\n]
+        : qq[Failed test $debug.\n];
+
+    $self->diag($msg);
+}
+
+sub skip {
+    my $self = shift;
+    my ($name, $reason, @extra) = @_;
+    $self->send_event(
+        'Skip',
+        name => $name,
+        reason => $reason,
+        pass => 1,
+        @extra,
+    );
+}
+
+sub note {
+    my $self = shift;
+    my ($message) = @_;
+    $self->send_event('Note', message => $message);
+}
+
+sub diag {
+    my $self = shift;
+    my ($message) = @_;
+    $self->send_event(
+        'Diag',
+        message => $message,
+    );
+}
+
+sub plan {
+    my ($self, $max, $directive, $reason) = @_;
+    $self->send_event('Plan', max => $max, directive => $directive, reason => $reason);
+}
+
+sub bail {
+    my ($self, $reason) = @_;
+    $self->send_event('Bail', reason => $reason);
+}
+
+sub _parse_event {
+    my $self = shift;
+    my $event = shift;
+
+    my $pkg;
+    if ($event =~ m/^\+(.*)/) {
+        $pkg = $1;
+    }
+    else {
+        $pkg = "Test2::Event::$event";
+    }
+
+    unless ($LOADED{$pkg}) {
+        my $file = pkg_to_file($pkg);
+        my ($ok, $err) = try { require $file };
+        $self->throw("Could not load event module '$pkg': $err")
+            unless $ok;
+
+        $LOADED{$pkg} = $pkg;
+    }
+
+    confess "'$pkg' is not a subclass of 'Test2::Event'"
+        unless $pkg->isa('Test2::Event');
+
+    $LOADED{$event} = $pkg;
+
+    return $pkg;
+}
+
+1;
+
+__END__
+
+=pod
+
+=encoding UTF-8
+
+=head1 NAME
+
+Test2::API::Context - Object to represent a testing context.
+
+=head1 DESCRIPTION
+
+The context object is the primary interface for authors of testing tools
+written with L<Test2>. The context object represents the context in
+which a test takes place (File and Line Number), and provides a quick way to
+generate events from that context. The context object also takes care of
+sending events to the correct L<Test2::Hub> instance.
+
+=head1 SYNOPSIS
+
+In general you will not be creating contexts directly. To obtain a context you
+should always use C<context()> which is exported by the L<Test2::API> module.
+
+    use Test2::API qw/context/;
+
+    sub my_ok {
+        my ($bool, $name) = @_;
+        my $ctx = context();
+
+        if ($bool) {
+            $ctx->pass($name);
+        }
+        else {
+            $ctx->fail($name);
+        }
+
+        $ctx->release; # You MUST do this!
+        return $bool;
+    }
+
+Context objects make it easy to wrap other tools that also use context. Once
+you grab a context, any tool you call before releasing your context will
+inherit it:
+
+    sub wrapper {
+        my ($bool, $name) = @_;
+        my $ctx = context();
+        $ctx->diag("wrapping my_ok");
+
+        my $out = my_ok($bool, $name);
+        $ctx->release; # You MUST do this!
+        return $out;
+    }
+
+=head1 CRITICAL DETAILS
+
+=over 4
+
+=item you MUST always use the context() sub from Test2::API
+
+Creating your own context via C<< Test2::API::Context->new() >> will almost never
+produce a desirable result. Use C<context()> which is exported by L<Test2::API>.
+
+There are a handful of cases where a tool author may want to create a new
+context by hand, which is why the C<new> method exists. Unless you really know
+what you are doing you should avoid this.
+
+=item You MUST always release the context when done with it
+
+Releasing the context tells the system you are done with it. This gives it a
+chance to run any necessary callbacks or cleanup tasks. If you forget to
+release the context it will try to detect the problem and warn you about it.
+
+=item You MUST NOT pass context objects around
+
+When you obtain a context object it is made specifically for your tool and any
+tools nested within. If you pass a context around you run the risk of polluting
+other tools with incorrect context information.
+
+If you are certain that you want a different tool to use the same context you
+may pass it a snapshot. C<< $ctx->snapshot >> will give you a shallow clone of
+the context that is safe to pass around or store.
+
+=item You MUST NOT store or cache a context for later
+
+As long as a context exists for a given hub, all tools that try to get a
+context will get the existing instance. If you try to store the context you
+will pollute other tools with incorrect context information.
+
+If you are certain that you want to save the context for later, you can use a
+snapshot. C<< $ctx->snapshot >> will give you a shallow clone of the context
+that is safe to pass around or store.
+
+C<context()> has some mechanisms to protect you if you do cause a context to
+persist beyond the scope in which it was obtained. In practice you should not
+rely on these protections, and they are fairly noisy with warnings.
+
+=item You SHOULD obtain your context as soon as possible in a given tool
+
+You never know what tools you call from within your own tool will need a
+context. Obtaining the context early ensures that nested tools can find the
+context you want them to find.
+
+=back
+
+=head1 METHODS
+
+=over 4
+
+=item $ctx->done_testing;
+
+Note that testing is finished. If no plan has been set this will generate a
+Plan event.
+
+=item $clone = $ctx->snapshot()
+
+This will return a shallow clone of the context. The shallow clone is safe to
+store for later.
+
+=item $ctx->release()
+
+This will release the context. This runs cleanup tasks, and several important
+hooks. It will also restore C<$!>, C<$?>, and C<$@> to what they were when the
+context was created.
+
+B<Note:> If a context is acquired more than once an internal refcount is kept.
+C<release()> decrements the ref count, none of the other actions of
+C<release()> will occur unless the refcount hits 0. This means only the last
+call to C<release()> will reset C<$?>, C<$!>, C<$@>, and run the cleanup tasks.
+
+=item $ctx->throw($message)
+
+This will throw an exception reporting to the file and line number of the
+context. This will also release the context for you.
+
+=item $ctx->alert($message)
+
+This will issue a warning from the file and line number of the context.
+
+=item $stack = $ctx->stack()
+
+This will return the L<Test2::API::Stack> instance the context used to find
+the current hub.
+
+=item $hub = $ctx->hub()
+
+This will return the L<Test2::Hub> instance the context recognizes as the
+current one to which all events should be sent.
+
+=item $dbg = $ctx->trace()
+
+This will return the L<Test2::EventFacet::Trace> instance used by the context.
+
+=item $ctx->do_in_context(\&code, @args);
+
+Sometimes you have a context that is not current, and you want things to use it
+as the current one. In these cases you can call
+C<< $ctx->do_in_context(sub { ... }) >>. The codeblock will be run, and
+anything inside of it that looks for a context will find the one on which the
+method was called.
+
+This B<DOES NOT> affect context on other hubs, only the hub used by the context
+will be affected.
+
+    my $ctx = ...;
+    $ctx->do_in_context(sub {
+        my $ctx = context(); # returns the $ctx the sub is called on
+    });
+
+B<Note:> The context will actually be cloned, the clone will be used instead of
+the original. This allows the thread id, process id, and error variables to be correct without
+modifying the original context.
+
+=item $ctx->restore_error_vars()
+
+This will set C<$!>, C<$?>, and C<$@> to what they were when the context was
+created. There is no localization or anything done here, calling this method
+will actually set these vars.
+
+=item $! = $ctx->errno()
+
+The (numeric) value of C<$!> when the context was created.
+
+=item $? = $ctx->child_error()
+
+The value of C<$?> when the context was created.
+
+=item $@ = $ctx->eval_error()
+
+The value of C<$@> when the context was created.
+
+=back
+
+=head2 EVENT PRODUCTION METHODS
+
+B<Which one do I use?>
+
+The C<pass*> and C<fail*> are optimal if they meet your situation, using one of
+them will always be the most optimal. That said they are optimal by eliminating
+many features.
+
+Method such as C<ok>, and C<note> are shortcuts for generating common 1-task
+events based on the old API, however they are forward compatible, and easy to
+use. If these meet your needs then go ahead and use them, but please check back
+often for alternatives that may be added.
+
+If you want to generate new style events, events that do many things at once,
+then you want the C<*ev2*> methods. These let you directly specify which facets
+you wish to use.
+
+=over 4
+
+=item $event = $ctx->pass()
+
+=item $event = $ctx->pass($name)
+
+This will send and return an L<Test2::Event::Pass> event. You may optionally
+provide a C<$name> for the assertion.
+
+The L<Test2::Event::Pass> is a specially crafted and optimized event, using
+this will help the performance of passing tests.
+
+=item $true = $ctx->pass_and_release()
+
+=item $true = $ctx->pass_and_release($name)
+
+This is a combination of C<pass()> and C<release()>. You can use this if you do
+not plan to do anything with the context after sending the event. This helps
+write more clear and compact code.
+
+    sub shorthand {
+        my ($bool, $name) = @_;
+        my $ctx = context();
+        return $ctx->pass_and_release($name) if $bool;
+
+        ... Handle a failure ...
+    }
+
+    sub longform {
+        my ($bool, $name) = @_;
+        my $ctx = context();
+
+        if ($bool) {
+            $ctx->pass($name);
+            $ctx->release;
+            return 1;
+        }
+
+        ... Handle a failure ...
+    }
+
+=item my $event = $ctx->fail()
+
+=item my $event = $ctx->fail($name)
+
+=item my $event = $ctx->fail($name, @diagnostics)
+
+This lets you send an L<Test2::Event::Fail> event. You may optionally provide a
+C<$name> and C<@diagnostics> messages.
+
+Diagnostics messages can be simple strings, data structures, or instances of
+L<Test2::EventFacet::Info::Table> (which are converted inline into the
+L<Test2::EventFacet::Info> structure).
+
+=item my $false = $ctx->fail_and_release()
+
+=item my $false = $ctx->fail_and_release($name)
+
+=item my $false = $ctx->fail_and_release($name, @diagnostics)
+
+This is a combination of C<fail()> and C<release()>. This can be used to write
+clearer and shorter code.
+
+    sub shorthand {
+        my ($bool, $name) = @_;
+        my $ctx = context();
+        return $ctx->fail_and_release($name) unless $bool;
+
+        ... Handle a success ...
+    }
+
+    sub longform {
+        my ($bool, $name) = @_;
+        my $ctx = context();
+
+        unless ($bool) {
+            $ctx->pass($name);
+            $ctx->release;
+            return 1;
+        }
+
+        ... Handle a success ...
+    }
+
+
+=item $event = $ctx->ok($bool, $name)
+
+=item $event = $ctx->ok($bool, $name, \@on_fail)
+
+B<NOTE:> Use of this method is discouraged in favor of C<pass()> and C<fail()>
+which produce L<Test2::Event::Pass> and L<Test2::Event::Fail> events. These
+newer event types are faster and less crufty.
+
+This will create an L<Test2::Event::Ok> object for you. If C<$bool> is false
+then an L<Test2::Event::Diag> event will be sent as well with details about the
+failure. If you do not want automatic diagnostics you should use the
+C<send_event()> method directly.
+
+The third argument C<\@on_fail>) is an optional set of diagnostics to be sent in
+the event of a test failure. Unlike with C<fail()> these diagnostics must be
+plain strings, data structures are not supported.
+
+=item $event = $ctx->note($message)
+
+Send an L<Test2::Event::Note>. This event prints a message to STDOUT.
+
+=item $event = $ctx->diag($message)
+
+Send an L<Test2::Event::Diag>. This event prints a message to STDERR.
+
+=item $event = $ctx->plan($max)
+
+=item $event = $ctx->plan(0, 'SKIP', $reason)
+
+This can be used to send an L<Test2::Event::Plan> event. This event
+usually takes either a number of tests you expect to run. Optionally you can
+set the expected count to 0 and give the 'SKIP' directive with a reason to
+cause all tests to be skipped.
+
+=item $event = $ctx->skip($name, $reason);
+
+Send an L<Test2::Event::Skip> event.
+
+=item $event = $ctx->bail($reason)
+
+This sends an L<Test2::Event::Bail> event. This event will completely
+terminate all testing.
+
+=item $event = $ctx->send_ev2(%facets)
+
+This lets you build and send a V2 event directly from facets. The event is
+returned after it is sent.
+
+This example sends a single assertion, a note (comment for stdout in
+Test::Builder talk) and sets the plan to 1.
+
+    my $event = $ctx->send_event(
+        plan   => {count => 1},
+        assert => {pass  => 1, details => "A passing assert"},
+        info => [{tag => 'NOTE', details => "This is a note"}],
+    );
+
+=item $event = $ctx->build_e2(%facets)
+
+This is the same as C<send_ev2()>, except it builds and returns the event
+without sending it.
+
+=item $event = $ctx->send_ev2_and_release($Type, %parameters)
+
+This is a combination of C<send_ev2()> and C<release()>.
+
+    sub shorthand {
+        my $ctx = context();
+        return $ctx->send_ev2_and_release(assert => {pass => 1, details => 'foo'});
+    }
+
+    sub longform {
+        my $ctx = context();
+        my $event = $ctx->send_ev2(assert => {pass => 1, details => 'foo'});
+        $ctx->release;
+        return $event;
+    }
+
+=item $event = $ctx->send_event($Type, %parameters)
+
+B<It is better to use send_ev2() in new code.>
+
+This lets you build and send an event of any type. The C<$Type> argument should
+be the event package name with C<Test2::Event::> left off, or a fully
+qualified package name prefixed with a '+'. The event is returned after it is
+sent.
+
+    my $event = $ctx->send_event('Ok', ...);
+
+or
+
+    my $event = $ctx->send_event('+Test2::Event::Ok', ...);
+
+=item $event = $ctx->build_event($Type, %parameters)
+
+B<It is better to use build_ev2() in new code.>
+
+This is the same as C<send_event()>, except it builds and returns the event
+without sending it.
+
+=item $event = $ctx->send_event_and_release($Type, %parameters)
+
+B<It is better to use send_ev2_and_release() in new code.>
+
+This is a combination of C<send_event()> and C<release()>.
+
+    sub shorthand {
+        my $ctx = context();
+        return $ctx->send_event_and_release(Pass => { name => 'foo' });
+    }
+
+    sub longform {
+        my $ctx = context();
+        my $event = $ctx->send_event(Pass => { name => 'foo' });
+        $ctx->release;
+        return $event;
+    }
+
+=back
+
+=head1 HOOKS
+
+There are 2 types of hooks, init hooks, and release hooks. As the names
+suggest, these hooks are triggered when contexts are created or released.
+
+=head2 INIT HOOKS
+
+These are called whenever a context is initialized. That means when a new
+instance is created. These hooks are B<NOT> called every time something
+requests a context, just when a new one is created.
+
+=head3 GLOBAL
+
+This is how you add a global init callback. Global callbacks happen for every
+context for any hub or stack.
+
+    Test2::API::test2_add_callback_context_init(sub {
+        my $ctx = shift;
+        ...
+    });
+
+=head3 PER HUB
+
+This is how you add an init callback for all contexts created for a given hub.
+These callbacks will not run for other hubs.
+
+    $hub->add_context_init(sub {
+        my $ctx = shift;
+        ...
+    });
+
+=head3 PER CONTEXT
+
+This is how you specify an init hook that will only run if your call to
+C<context()> generates a new context. The callback will be ignored if
+C<context()> is returning an existing context.
+
+    my $ctx = context(on_init => sub {
+        my $ctx = shift;
+        ...
+    });
+
+=head2 RELEASE HOOKS
+
+These are called whenever a context is released. That means when the last
+reference to the instance is about to be destroyed. These hooks are B<NOT>
+called every time C<< $ctx->release >> is called.
+
+=head3 GLOBAL
+
+This is how you add a global release callback. Global callbacks happen for every
+context for any hub or stack.
+
+    Test2::API::test2_add_callback_context_release(sub {
+        my $ctx = shift;
+        ...
+    });
+
+=head3 PER HUB
+
+This is how you add a release callback for all contexts created for a given
+hub. These callbacks will not run for other hubs.
+
+    $hub->add_context_release(sub {
+        my $ctx = shift;
+        ...
+    });
+
+=head3 PER CONTEXT
+
+This is how you add release callbacks directly to a context. The callback will
+B<ALWAYS> be added to the context that gets returned, it does not matter if a
+new one is generated, or if an existing one is returned.
+
+    my $ctx = context(on_release => sub {
+        my $ctx = shift;
+        ...
+    });
+
+=head1 THIRD PARTY META-DATA
+
+This object consumes L<Test2::Util::ExternalMeta> which provides a consistent
+way for you to attach meta-data to instances of this class. This is useful for
+tools, plugins, and other extensions.
+
+=head1 SOURCE
+
+The source code repository for Test2 can be found at
+L<https://github.com/Test-More/test-more/>.
+
+=head1 MAINTAINERS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=item Kent Fredric E<lt>kentnl@cpan.orgE<gt>
+
+=back
+
+=head1 COPYRIGHT
+
+Copyright Chad Granum E<lt>exodist@cpan.orgE<gt>.
+
+This program is free software; you can redistribute it and/or
+modify it under the same terms as Perl itself.
+
+See L<https://dev.perl.org/licenses/>
+
+=cut

git/usr/share/perl5/core_perl/Test2/API/Instance.pm

@@ -0,0 +1,830 @@
+package Test2::API::Instance;
+use strict;
+use warnings;
+
+our $VERSION = '1.302210';
+
+our @CARP_NOT = qw/Test2::API Test2::API::Instance Test2::IPC::Driver Test2::Formatter/;
+use Carp qw/confess carp/;
+use Scalar::Util qw/reftype/;
+
+use Test2::Util qw/get_tid USE_THREADS CAN_FORK pkg_to_file try/;
+
+use Test2::EventFacet::Trace();
+use Test2::API::Stack();
+
+use Test2::Util::HashBase qw{
+    _pid _tid
+    no_wait
+    finalized loaded
+    ipc stack formatter
+    contexts
+
+    add_uuid_via
+
+    -preload
+
+    ipc_disabled
+    ipc_polling
+    ipc_drivers
+    ipc_timeout
+    formatters
+
+    exit_callbacks
+    post_load_callbacks
+    context_acquire_callbacks
+    context_init_callbacks
+    context_release_callbacks
+    pre_subtest_callbacks
+
+    trace_stamps
+};
+
+sub DEFAULT_IPC_TIMEOUT() { 30 }
+
+sub test2_enable_trace_stamps { $_[0]->{+TRACE_STAMPS} = 1 }
+sub test2_disable_trace_stamps { $_[0]->{+TRACE_STAMPS} = 0 }
+sub test2_trace_stamps_enabled { $_[0]->{+TRACE_STAMPS} }
+
+sub pid { $_[0]->{+_PID} }
+sub tid { $_[0]->{+_TID} }
+
+# Wrap around the getters that should call _finalize.
+BEGIN {
+    for my $finalizer (IPC, FORMATTER) {
+        my $orig = __PACKAGE__->can($finalizer);
+        my $new  = sub {
+            my $self = shift;
+            $self->_finalize unless $self->{+FINALIZED};
+            $self->$orig;
+        };
+
+        no strict 'refs';
+        no warnings 'redefine';
+        *{$finalizer} = $new;
+    }
+}
+
+sub has_ipc { !!$_[0]->{+IPC} }
+
+sub import {
+    my $class = shift;
+    return unless @_;
+    my ($ref) = @_;
+    $$ref = $class->new;
+}
+
+sub init { $_[0]->reset }
+
+sub start_preload {
+    my $self = shift;
+
+    confess "preload cannot be started, Test2::API has already been initialized"
+        if $self->{+FINALIZED} || $self->{+LOADED};
+
+    return $self->{+PRELOAD} = 1;
+}
+
+sub stop_preload {
+    my $self = shift;
+
+    return 0 unless $self->{+PRELOAD};
+    $self->{+PRELOAD} = 0;
+
+    $self->post_preload_reset();
+
+    return 1;
+}
+
+sub post_preload_reset {
+    my $self = shift;
+
+    delete $self->{+_PID};
+    delete $self->{+_TID};
+
+    $self->{+ADD_UUID_VIA} = undef unless exists $self->{+ADD_UUID_VIA};
+
+    $self->{+CONTEXTS} = {};
+
+    $self->{+FORMATTERS} = [];
+
+    $self->{+FINALIZED} = undef;
+    $self->{+IPC}       = undef;
+    $self->{+IPC_DISABLED} = $ENV{T2_NO_IPC} ? 1 : 0;
+
+    $self->{+IPC_TIMEOUT} = DEFAULT_IPC_TIMEOUT() unless defined $self->{+IPC_TIMEOUT};
+
+    $self->{+LOADED} = 0;
+
+    $self->{+STACK} ||= Test2::API::Stack->new;
+}
+
+sub reset {
+    my $self = shift;
+
+    delete $self->{+_PID};
+    delete $self->{+_TID};
+
+    $self->{+TRACE_STAMPS} = $ENV{T2_TRACE_STAMPS} || 0;
+
+    $self->{+ADD_UUID_VIA} = undef;
+
+    $self->{+CONTEXTS} = {};
+
+    $self->{+IPC_DRIVERS} = [];
+    $self->{+IPC_POLLING} = undef;
+
+    $self->{+FORMATTERS} = [];
+    $self->{+FORMATTER}  = undef;
+
+    $self->{+FINALIZED}    = undef;
+    $self->{+IPC}          = undef;
+    $self->{+IPC_DISABLED} = $ENV{T2_NO_IPC} ? 1 : 0;
+
+    $self->{+IPC_TIMEOUT} = DEFAULT_IPC_TIMEOUT() unless defined $self->{+IPC_TIMEOUT};
+
+    $self->{+NO_WAIT} = 0;
+    $self->{+LOADED}  = 0;
+
+    $self->{+EXIT_CALLBACKS}            = [];
+    $self->{+POST_LOAD_CALLBACKS}       = [];
+    $self->{+CONTEXT_ACQUIRE_CALLBACKS} = [];
+    $self->{+CONTEXT_INIT_CALLBACKS}    = [];
+    $self->{+CONTEXT_RELEASE_CALLBACKS} = [];
+    $self->{+PRE_SUBTEST_CALLBACKS}     = [];
+
+    $self->{+STACK} = Test2::API::Stack->new;
+}
+
+sub _finalize {
+    my $self = shift;
+    my ($caller) = @_;
+    $caller ||= [caller(1)];
+
+    confess "Attempt to initialize Test2::API during preload"
+        if $self->{+PRELOAD};
+
+    $self->{+FINALIZED} = $caller;
+
+    $self->{+_PID} = $$        unless defined $self->{+_PID};
+    $self->{+_TID} = get_tid() unless defined $self->{+_TID};
+
+    unless ($self->{+FORMATTER}) {
+        my ($formatter, $source);
+        if ($ENV{T2_FORMATTER}) {
+            $source = "set by the 'T2_FORMATTER' environment variable";
+
+            if ($ENV{T2_FORMATTER} =~ m/^(\+)?(.*)$/) {
+                $formatter = $1 ? $2 : "Test2::Formatter::$2"
+            }
+            else {
+                $formatter = '';
+            }
+        }
+        elsif (@{$self->{+FORMATTERS}}) {
+            ($formatter) = @{$self->{+FORMATTERS}};
+            $source = "Most recently added";
+        }
+        else {
+            $formatter = 'Test2::Formatter::TAP';
+            $source    = 'default formatter';
+        }
+
+        unless (ref($formatter) || $formatter->can('write')) {
+            my $file = pkg_to_file($formatter);
+            my ($ok, $err) = try { require $file };
+            unless ($ok) {
+                my $line   = "* COULD NOT LOAD FORMATTER '$formatter' ($source) *";
+                my $border = '*' x length($line);
+                die "\n\n  $border\n  $line\n  $border\n\n$err";
+            }
+        }
+
+        $self->{+FORMATTER} = $formatter;
+    }
+
+    # Turn on IPC if threads are on, drivers are registered, or the Test2::IPC
+    # module is loaded.
+    return if $self->{+IPC_DISABLED};
+    return unless USE_THREADS || $INC{'Test2/IPC.pm'} || @{$self->{+IPC_DRIVERS}};
+
+    # Turn on polling by default, people expect it.
+    $self->enable_ipc_polling;
+
+    unless (@{$self->{+IPC_DRIVERS}}) {
+        my ($ok, $error) = try { require Test2::IPC::Driver::Files };
+        die $error unless $ok;
+        push @{$self->{+IPC_DRIVERS}} => 'Test2::IPC::Driver::Files';
+    }
+
+    for my $driver (@{$self->{+IPC_DRIVERS}}) {
+        next unless $driver->can('is_viable') && $driver->is_viable;
+        $self->{+IPC} = $driver->new or next;
+        return;
+    }
+
+    die "IPC has been requested, but no viable drivers were found. Aborting...\n";
+}
+
+sub formatter_set { $_[0]->{+FORMATTER} ? 1 : 0 }
+
+sub add_formatter {
+    my $self = shift;
+    my ($formatter) = @_;
+    unshift @{$self->{+FORMATTERS}} => $formatter;
+
+    return unless $self->{+FINALIZED};
+
+    # Why is the @CARP_NOT entry not enough?
+    local %Carp::Internal = %Carp::Internal;
+    $Carp::Internal{'Test2::Formatter'} = 1;
+
+    carp "Formatter $formatter loaded too late to be used as the global formatter";
+}
+
+sub add_context_acquire_callback {
+    my $self =  shift;
+    my ($code) = @_;
+
+    my $rtype = reftype($code) || "";
+
+    confess "Context-acquire callbacks must be coderefs"
+        unless $code && $rtype eq 'CODE';
+
+    push @{$self->{+CONTEXT_ACQUIRE_CALLBACKS}} => $code;
+}
+
+sub add_context_init_callback {
+    my $self =  shift;
+    my ($code) = @_;
+
+    my $rtype = reftype($code) || "";
+
+    confess "Context-init callbacks must be coderefs"
+        unless $code && $rtype eq 'CODE';
+
+    push @{$self->{+CONTEXT_INIT_CALLBACKS}} => $code;
+}
+
+sub add_context_release_callback {
+    my $self =  shift;
+    my ($code) = @_;
+
+    my $rtype = reftype($code) || "";
+
+    confess "Context-release callbacks must be coderefs"
+        unless $code && $rtype eq 'CODE';
+
+    push @{$self->{+CONTEXT_RELEASE_CALLBACKS}} => $code;
+}
+
+sub add_post_load_callback {
+    my $self = shift;
+    my ($code) = @_;
+
+    my $rtype = reftype($code) || "";
+
+    confess "Post-load callbacks must be coderefs"
+        unless $code && $rtype eq 'CODE';
+
+    push @{$self->{+POST_LOAD_CALLBACKS}} => $code;
+    $code->() if $self->{+LOADED};
+}
+
+sub add_pre_subtest_callback {
+    my $self =  shift;
+    my ($code) = @_;
+
+    my $rtype = reftype($code) || "";
+
+    confess "Pre-subtest callbacks must be coderefs"
+        unless $code && $rtype eq 'CODE';
+
+    push @{$self->{+PRE_SUBTEST_CALLBACKS}} => $code;
+}
+
+sub load {
+    my $self = shift;
+    unless ($self->{+LOADED}) {
+        confess "Attempt to initialize Test2::API during preload"
+            if $self->{+PRELOAD};
+
+        $self->{+_PID} = $$        unless defined $self->{+_PID};
+        $self->{+_TID} = get_tid() unless defined $self->{+_TID};
+
+        # This is for https://github.com/Test-More/test-more/issues/16
+        # and https://rt.perl.org/Public/Bug/Display.html?id=127774
+        # END blocks run in reverse order. This insures the END block is loaded
+        # as late as possible. It will not solve all cases, but it helps.
+        eval "END { Test2::API::test2_set_is_end() }; 1" or die $@;
+
+        $self->{+LOADED} = 1;
+        $_->() for @{$self->{+POST_LOAD_CALLBACKS}};
+    }
+    return $self->{+LOADED};
+}
+
+sub add_exit_callback {
+    my $self = shift;
+    my ($code) = @_;
+    my $rtype = reftype($code) || "";
+
+    confess "End callbacks must be coderefs"
+        unless $code && $rtype eq 'CODE';
+
+    push @{$self->{+EXIT_CALLBACKS}} => $code;
+}
+
+sub ipc_disable {
+    my $self = shift;
+
+    confess "Attempt to disable IPC after it has been initialized"
+        if $self->{+IPC};
+
+    $self->{+IPC_DISABLED} = 1;
+}
+
+sub add_ipc_driver {
+    my $self = shift;
+    my ($driver) = @_;
+    unshift @{$self->{+IPC_DRIVERS}} => $driver;
+
+    return unless $self->{+FINALIZED};
+
+    # Why is the @CARP_NOT entry not enough?
+    local %Carp::Internal = %Carp::Internal;
+    $Carp::Internal{'Test2::IPC::Driver'} = 1;
+
+    carp "IPC driver $driver loaded too late to be used as the global ipc driver";
+}
+
+sub enable_ipc_polling {
+    my $self = shift;
+
+    $self->{+_PID} = $$        unless defined $self->{+_PID};
+    $self->{+_TID} = get_tid() unless defined $self->{+_TID};
+
+    $self->add_context_init_callback(
+        # This is called every time a context is created, it needs to be fast.
+        # $_[0] is a context object
+        sub {
+            return unless $self->{+IPC_POLLING};
+            return unless $self->{+IPC};
+            return unless $self->{+IPC}->pending();
+            return $_[0]->{hub}->cull;
+        }
+    ) unless defined $self->ipc_polling;
+
+    $self->set_ipc_polling(1);
+}
+
+sub get_ipc_pending {
+    my $self = shift;
+    return -1 unless $self->{+IPC};
+    $self->{+IPC}->pending();
+}
+
+sub _check_pid {
+    my $self = shift;
+    my ($pid) = @_;
+    return kill(0, $pid);
+}
+
+sub set_ipc_pending {
+    my $self = shift;
+    return unless $self->{+IPC};
+    my ($val) = @_;
+
+    confess "value is required for set_ipc_pending"
+        unless $val;
+
+    $self->{+IPC}->set_pending($val);
+}
+
+sub disable_ipc_polling {
+    my $self = shift;
+    return unless defined $self->{+IPC_POLLING};
+    $self->{+IPC_POLLING} = 0;
+}
+
+sub _ipc_wait {
+    my ($timeout) = @_;
+    my $fail = 0;
+
+    $timeout = DEFAULT_IPC_TIMEOUT() unless defined $timeout;
+
+    my $ok = eval {
+        if (CAN_FORK) {
+            local $SIG{ALRM} = sub { die "Timeout waiting on child processes" };
+            alarm $timeout;
+
+            while (1) {
+                my $pid = CORE::wait();
+                my $err = $?;
+                last if $pid == -1;
+                next unless $err;
+                $fail++;
+
+                my $sig = $err & 127;
+                my $exit = $err >> 8;
+                warn "Process $pid did not exit cleanly (wstat: $err, exit: $exit, sig: $sig)\n";
+            }
+
+            alarm 0;
+        }
+
+        if (USE_THREADS) {
+            my $start = time;
+
+            while (1) {
+                last unless threads->list();
+                die "Timeout waiting on child thread" if time - $start >= $timeout;
+                sleep 1;
+                for my $t (threads->list) {
+                    # threads older than 1.34 do not have this :-(
+                    next if $t->can('is_joinable') && !$t->is_joinable;
+                    $t->join;
+                    # In older threads we cannot check if a thread had an error unless
+                    # we control it and its return.
+                    my $err = $t->can('error') ? $t->error : undef;
+                    next unless $err;
+                    my $tid = $t->tid();
+                    $fail++;
+                    chomp($err);
+                    warn "Thread $tid did not end cleanly: $err\n";
+                }
+            }
+        }
+
+        1;
+    };
+    my $error = $@;
+
+    return 0 if $ok && !$fail;
+    warn $error unless $ok;
+    return 255;
+}
+
+sub set_exit {
+    my $self = shift;
+
+    return if $self->{+PRELOAD};
+
+    my $exit     = $?;
+    my $new_exit = $exit;
+
+    if ($INC{'Test/Builder.pm'} && $Test::Builder::VERSION ne $Test2::API::VERSION) {
+        print STDERR <<"        EOT";
+
+********************************************************************************
+*                                                                              *
+*            Test::Builder -- Test2::API version mismatch detected             *
+*                                                                              *
+********************************************************************************
+   Test2::API Version: $Test2::API::VERSION
+Test::Builder Version: $Test::Builder::VERSION
+
+This is not a supported configuration, you will have problems.
+
+        EOT
+    }
+
+    for my $ctx (values %{$self->{+CONTEXTS}}) {
+        next unless $ctx;
+
+        next if $ctx->_aborted && ${$ctx->_aborted};
+
+        # Only worry about contexts in this PID
+        my $trace = $ctx->trace || next;
+        next unless $trace->pid && $trace->pid == $$;
+
+        # Do not worry about contexts that have no hub
+        my $hub = $ctx->hub  || next;
+
+        # Do not worry if the state came to a sudden end.
+        next if $hub->bailed_out;
+        next if defined $hub->skip_reason;
+
+        # now we worry
+        $trace->alert("context object was never released! This means a testing tool is behaving very badly");
+
+        $exit     = 255;
+        $new_exit = 255;
+    }
+
+    if (!defined($self->{+_PID}) or !defined($self->{+_TID}) or $self->{+_PID} != $$ or $self->{+_TID} != get_tid()) {
+        $? = $exit;
+        return;
+    }
+
+    my @hubs = $self->{+STACK} ? $self->{+STACK}->all : ();
+
+    if (@hubs and $self->{+IPC} and !$self->{+NO_WAIT}) {
+        local $?;
+        my %seen;
+        for my $hub (reverse @hubs) {
+            my $ipc = $hub->ipc or next;
+            next if $seen{$ipc}++;
+            $ipc->waiting();
+        }
+
+        my $ipc_exit = _ipc_wait($self->{+IPC_TIMEOUT});
+        $new_exit ||= $ipc_exit;
+    }
+
+    # None of this is necessary if we never got a root hub
+    if(my $root = shift @hubs) {
+        my $trace = Test2::EventFacet::Trace->new(
+            frame  => [__PACKAGE__, __FILE__, 0, __PACKAGE__ . '::END'],
+            detail => __PACKAGE__ . ' END Block finalization',
+        );
+        my $ctx = Test2::API::Context->new(
+            trace => $trace,
+            hub   => $root,
+        );
+
+        if (@hubs) {
+            $ctx->diag("Test ended with extra hubs on the stack!");
+            $new_exit  = 255;
+        }
+
+        unless ($root->no_ending) {
+            local $?;
+            $root->finalize($trace) unless $root->ended;
+            $_->($ctx, $exit, \$new_exit) for @{$self->{+EXIT_CALLBACKS}};
+            $new_exit ||= $root->failed;
+            $new_exit ||= 255 unless $root->is_passing;
+        }
+    }
+
+    $new_exit = 255 if $new_exit > 255;
+
+    if ($new_exit && eval { require Test2::API::Breakage; 1 }) {
+        my @warn = Test2::API::Breakage->report();
+
+        if (@warn) {
+            print STDERR "\nYou have loaded versions of test modules known to have problems with Test2.\nThis could explain some test failures.\n";
+            print STDERR "$_\n" for @warn;
+            print STDERR "\n";
+        }
+    }
+
+    $? = $new_exit;
+}
+
+1;
+
+__END__
+
+=pod
+
+=encoding UTF-8
+
+=head1 NAME
+
+Test2::API::Instance - Object used by Test2::API under the hood
+
+=head1 DESCRIPTION
+
+This object encapsulates the global shared state tracked by
+L<Test2>. A single global instance of this package is stored (and
+obscured) by the L<Test2::API> package.
+
+There is no reason to directly use this package. This package is documented for
+completeness. This package can change, or go away completely at any time.
+Directly using, or monkeypatching this package is not supported in any way
+shape or form.
+
+=head1 SYNOPSIS
+
+    use Test2::API::Instance;
+
+    my $obj = Test2::API::Instance->new;
+
+=over 4
+
+=item $pid = $obj->pid
+
+PID of this instance.
+
+=item $obj->tid
+
+Thread ID of this instance.
+
+=item $obj->reset()
+
+Reset the object to defaults.
+
+=item $obj->load()
+
+Set the internal state to loaded, and run and stored post-load callbacks.
+
+=item $bool = $obj->loaded
+
+Check if the state is set to loaded.
+
+=item $arrayref = $obj->post_load_callbacks
+
+Get the post-load callbacks.
+
+=item $obj->add_post_load_callback(sub { ... })
+
+Add a post-load callback. If C<load()> has already been called then the callback will
+be immediately executed. If C<load()> has not been called then the callback will be
+stored and executed later when C<load()> is called.
+
+=item $hashref = $obj->contexts()
+
+Get a hashref of all active contexts keyed by hub id.
+
+=item $arrayref = $obj->context_acquire_callbacks
+
+Get all context acquire callbacks.
+
+=item $arrayref = $obj->context_init_callbacks
+
+Get all context init callbacks.
+
+=item $arrayref = $obj->context_release_callbacks
+
+Get all context release callbacks.
+
+=item $arrayref = $obj->pre_subtest_callbacks
+
+Get all pre-subtest callbacks.
+
+=item $obj->add_context_init_callback(sub { ... })
+
+Add a context init callback. Subs are called every time a context is created. Subs
+get the newly created context as their only argument.
+
+=item $obj->add_context_release_callback(sub { ... })
+
+Add a context release callback. Subs are called every time a context is released. Subs
+get the released context as their only argument. These callbacks should not
+call release on the context.
+
+=item $obj->add_pre_subtest_callback(sub { ... })
+
+Add a pre-subtest callback. Subs are called every time a subtest is
+going to be run. Subs get the subtest name, coderef, and any
+arguments.
+
+=item $obj->set_exit()
+
+This is intended to be called in an C<END { ... }> block. This will look at
+test state and set $?. This will also call any end callbacks, and wait on child
+processes/threads.
+
+=item $obj->set_ipc_pending($val)
+
+Tell other processes and threads there is a pending event. C<$val> should be a
+unique value no other thread/process will generate.
+
+B<Note:> This will also make the current process see a pending event.
+
+=item $pending = $obj->get_ipc_pending()
+
+This returns -1 if it is not possible to know.
+
+This returns 0 if there are no pending events.
+
+This returns 1 if there are pending events.
+
+=item $timeout = $obj->ipc_timeout;
+
+=item $obj->set_ipc_timeout($timeout);
+
+How long to wait for child processes and threads before aborting.
+
+=item $drivers = $obj->ipc_drivers
+
+Get the list of IPC drivers.
+
+=item $obj->add_ipc_driver($DRIVER_CLASS)
+
+Add an IPC driver to the list. The most recently added IPC driver will become
+the global one during initialization. If a driver is added after initialization
+has occurred a warning will be generated:
+
+    "IPC driver $driver loaded too late to be used as the global ipc driver"
+
+=item $bool = $obj->ipc_polling
+
+Check if polling is enabled.
+
+=item $obj->enable_ipc_polling
+
+Turn on polling. This will cull events from other processes and threads every
+time a context is created.
+
+=item $obj->disable_ipc_polling
+
+Turn off IPC polling.
+
+=item $bool = $obj->no_wait
+
+=item $bool = $obj->set_no_wait($bool)
+
+Get/Set no_wait. This option is used to turn off process/thread waiting at exit.
+
+=item $arrayref = $obj->exit_callbacks
+
+Get the exit callbacks.
+
+=item $obj->add_exit_callback(sub { ... })
+
+Add an exit callback. This callback will be called by C<set_exit()>.
+
+=item $bool = $obj->finalized
+
+Check if the object is finalized. Finalization happens when either C<ipc()>,
+C<stack()>, or C<format()> are called on the object. Once finalization happens
+these fields are considered unchangeable (not enforced here, enforced by
+L<Test2>).
+
+=item $ipc = $obj->ipc
+
+Get the one true IPC instance.
+
+=item $obj->ipc_disable
+
+Turn IPC off
+
+=item $bool = $obj->ipc_disabled
+
+Check if IPC is disabled
+
+=item $stack = $obj->stack
+
+Get the one true hub stack.
+
+=item $formatter = $obj->formatter
+
+Get the global formatter. By default this is the C<'Test2::Formatter::TAP'>
+package. This could be any package that implements the C<write()> method. This
+can also be an instantiated object.
+
+=item $bool = $obj->formatter_set()
+
+Check if a formatter has been set.
+
+=item $obj->add_formatter($class)
+
+=item $obj->add_formatter($obj)
+
+Add a formatter. The most recently added formatter will become the global one
+during initialization. If a formatter is added after initialization has occurred
+a warning will be generated:
+
+    "Formatter $formatter loaded too late to be used as the global formatter"
+
+=item $obj->set_add_uuid_via(sub { ... })
+
+=item $sub = $obj->add_uuid_via()
+
+This allows you to provide a UUID generator. If provided UUIDs will be attached
+to all events, hubs, and contexts. This is useful for storing, tracking, and
+linking these objects.
+
+The sub you provide should always return a unique identifier. Most things will
+expect a proper UUID string, however nothing in Test2::API enforces this.
+
+The sub will receive exactly 1 argument, the type of thing being tagged
+'context', 'hub', or 'event'. In the future additional things may be tagged, in
+which case new strings will be passed in. These are purely informative, you can
+(and usually should) ignore them.
+
+=back
+
+=head1 SOURCE
+
+The source code repository for Test2 can be found at
+L<https://github.com/Test-More/test-more/>.
+
+=head1 MAINTAINERS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 COPYRIGHT
+
+Copyright Chad Granum E<lt>exodist@cpan.orgE<gt>.
+
+This program is free software; you can redistribute it and/or
+modify it under the same terms as Perl itself.
+
+See L<https://dev.perl.org/licenses/>
+
+=cut

git/usr/share/perl5/core_perl/Test2/API/InterceptResult.pm

@@ -0,0 +1,634 @@
+package Test2::API::InterceptResult;
+use strict;
+use warnings;
+
+our $VERSION = '1.302210';
+
+use Scalar::Util qw/blessed/;
+use Test2::Util  qw/pkg_to_file/;
+use Storable     qw/dclone/;
+use Carp         qw/croak/;
+
+use Test2::API::InterceptResult::Squasher;
+use Test2::API::InterceptResult::Event;
+use Test2::API::InterceptResult::Hub;
+
+sub new {
+    croak "Called a method that creates a new instance in void context" unless defined wantarray;
+    my $class = shift;
+    bless([@_], $class);
+}
+
+sub new_from_ref {
+    croak "Called a method that creates a new instance in void context" unless defined wantarray;
+    bless($_[1], $_[0]);
+}
+
+sub clone { blessed($_[0])->new(@{dclone($_[0])}) }
+
+sub event_list { @{$_[0]} }
+
+sub _upgrade {
+    my $self = shift;
+    my ($event, %params) = @_;
+
+    my $blessed = blessed($event);
+
+    my $upgrade_class = $params{upgrade_class} ||= 'Test2::API::InterceptResult::Event';
+
+    return $event if $blessed && $event->isa($upgrade_class) && !$params{_upgrade_clone};
+
+    my $fd = dclone($blessed ? $event->facet_data : $event);
+
+    my $class = $params{result_class} ||= blessed($self);
+
+    if (my $parent = $fd->{parent}) {
+        $parent->{children} = $class->new_from_ref($parent->{children} || [])->upgrade(%params);
+    }
+
+    my $uc_file = pkg_to_file($upgrade_class);
+    require($uc_file) unless $INC{$uc_file};
+    return $upgrade_class->new(facet_data => $fd, result_class => $class);
+}
+
+sub hub {
+    my $self = shift;
+
+    my $hub = Test2::API::InterceptResult::Hub->new();
+    $hub->process($_) for @$self;
+    $hub->set_ended(1);
+
+    return $hub;
+}
+
+sub state {
+    my $self = shift;
+    my %params = @_;
+
+    my $hub = $self->hub;
+
+    my $out = {
+        map {($_ => scalar $hub->$_)} qw/count failed is_passing plan bailed_out skip_reason/
+    };
+
+    $out->{bailed_out} = $self->_upgrade($out->{bailed_out}, %params)->bailout_reason || 1
+        if $out->{bailed_out};
+
+    $out->{follows_plan} = $hub->check_plan;
+
+    return $out;
+}
+
+sub upgrade {
+    my $self = shift;
+    my %params = @_;
+
+    my @out = map { $self->_upgrade($_, %params, _upgrade_clone => 1) } @$self;
+
+    return blessed($self)->new_from_ref(\@out)
+        unless $params{in_place};
+
+    @$self = @out;
+    return $self;
+}
+
+sub squash_info {
+    my $self = shift;
+    my %params = @_;
+
+    my @out;
+
+    {
+        my $squasher = Test2::API::InterceptResult::Squasher->new(events => \@out);
+        # Clone to make sure we do not indirectly modify an existing one if it
+        # is already upgraded
+        $squasher->process($self->_upgrade($_, %params)->clone) for @$self;
+        $squasher->flush_down();
+    }
+
+    return blessed($self)->new_from_ref(\@out)
+        unless $params{in_place};
+
+    @$self = @out;
+    return $self;
+}
+
+sub asserts        { shift->grep(has_assert     => @_) }
+sub subtests       { shift->grep(has_subtest    => @_) }
+sub diags          { shift->grep(has_diags      => @_) }
+sub notes          { shift->grep(has_notes      => @_) }
+sub errors         { shift->grep(has_errors     => @_) }
+sub plans          { shift->grep(has_plan       => @_) }
+sub causes_fail    { shift->grep(causes_fail    => @_) }
+sub causes_failure { shift->grep(causes_failure => @_) }
+
+sub flatten         { shift->map(flatten        => @_) }
+sub briefs          { shift->map(brief          => @_) }
+sub summaries       { shift->map(summary        => @_) }
+sub subtest_results { shift->map(subtest_result => @_) }
+sub diag_messages   { shift->map(diag_messages  => @_) }
+sub note_messages   { shift->map(note_messages  => @_) }
+sub error_messages  { shift->map(error_messages => @_) }
+
+no warnings 'once';
+
+*map = sub {
+    my $self = shift;
+    my ($call, %params) = @_;
+
+    my $args = $params{args} ||= [];
+
+    return [map { local $_ = $self->_upgrade($_, %params); $_->$call(@$args) } @$self];
+};
+
+*grep = sub {
+    my $self = shift;
+    my ($call, %params) = @_;
+
+    my $args = $params{args} ||= [];
+
+    my @out = grep { local $_ = $self->_upgrade($_, %params); $_->$call(@$args) } @$self;
+
+    return blessed($self)->new_from_ref(\@out)
+        unless $params{in_place};
+
+    @$self = @out;
+    return $self;
+};
+
+1;
+
+__END__
+
+=pod
+
+=encoding UTF-8
+
+=head1 NAME
+
+Test2::API::InterceptResult - Representation of a list of events.
+
+=head1 DESCRIPTION
+
+This class represents a list of events, normally obtained using C<intercept()>
+from L<Test2::API>.
+
+This class is intended for people who with to verify the results of test tools
+they write.
+
+This class provides methods to normalize, summarize, or map the list of events.
+The output of these operations makes verifying your testing tools and the
+events they generate significantly easier. In most cases this spares you from
+needing a deep understanding of the event/facet model.
+
+=head1 SYNOPSIS
+
+Usually you get an instance of this class when you use C<intercept()> from
+L<Test2::API>.
+
+    use Test2::V0;
+    use Test2::API qw/intercept/;
+
+    my $events = intercept {
+        ok(1, "pass");
+        ok(0, "fail");
+        todo "broken" => sub { ok(0, "fixme") };
+        plan 3;
+    };
+
+    # This is typically the most useful construct
+    # squash_info() merges assertions and diagnostics that are associated
+    #   (and returns a new instance with the modifications)
+    # flatten() condenses the facet data into the key details for each event
+    #   (and returns those structures in an arrayref)
+    is(
+        $events->squash_info->flatten(),
+        [
+            {
+                causes_failure => 0,
+
+                name => 'pass',
+                pass => 1,
+
+                trace_file => 'xxx.t',
+                trace_line => 5,
+            },
+            {
+                causes_failure => 1,
+
+                name => 'fail',
+                pass => 0,
+
+                trace_file => 'xxx.t',
+                trace_line => 6,
+
+                # There can be more than one diagnostics message so this is
+                # always an array when present.
+                diag => ["Failed test 'fail'\nat xxx.t line 6."],
+            },
+            {
+                causes_failure => 0,
+
+                name => 'fixme',
+                pass => 0,
+
+                trace_file => 'xxx.t',
+                trace_line => 7,
+
+                # There can be more than one diagnostics message or todo
+                # reason, so these are always an array when present.
+                todo => ['broken'],
+
+                # Diag message was turned into a note since the assertion was
+                # TODO
+                note => ["Failed test 'fixme'\nat xxx.t line 7."],
+            },
+            {
+                causes_failure => 0,
+
+                plan => 3,
+
+                trace_file => 'xxx.t',
+                trace_line => 8,
+            },
+        ],
+        "Flattened events look like we expect"
+    );
+
+See L<Test2::API::InterceptResult::Event> for a full description of what
+C<flatten()> provides for each event.
+
+=head1 METHODS
+
+Please note that no methods modify the original instance unless asked to do so.
+
+=head2 CONSTRUCTION
+
+=over 4
+
+=item $events = Test2::API::InterceptResult->new(@EVENTS)
+
+=item $events = Test2::API::InterceptResult->new_from_ref(\@EVENTS)
+
+These create a new instance of Test2::API::InterceptResult from the given
+events.
+
+In the first form a new blessed arrayref is returned. In the 'new_from_ref'
+form the reference you pass in is directly blessed.
+
+Both of these will throw an exception if called in void context. This is mainly
+important for the 'filtering' methods listed below which normally return a new
+instance, they throw an exception in such cases as it probably means someone
+meant to filter the original in place.
+
+=item $clone = $events->clone()
+
+Make a clone of the original events. Note that this is a deep copy, the entire
+structure is duplicated. This uses C<dclone> from L<Storable> to achieve the
+deep clone.
+
+=back
+
+=head2 NORMALIZATION
+
+=over 4
+
+=item @events = $events->event_list
+
+This returns all the events in list-form.
+
+=item $hub = $events->hub
+
+This returns a new L<Test2::Hub> instance that has processed all the events
+contained in the instance. This gives you a simple way to inspect the state
+changes your events cause.
+
+=item $state = $events->state
+
+This returns a summary of the state of a hub after processing all the events.
+
+    {
+        count        => 2,      # Number of assertions made
+        failed       => 1,      # Number of test failures seen
+        is_passing   => 0,      # Boolean, true if the test would be passing
+                                # after the events are processed.
+
+        plan         => 2,      # Plan, either a number, undef, 'SKIP', or 'NO PLAN'
+        follows_plan => 1,      # True if there is a plan and it was followed.
+                                # False if the plan and assertions did not
+                                # match, undef if no plan was present in the
+                                # event list.
+
+        bailed_out   => undef,  # undef unless there was a bail-out in the
+                                # events in which case this will be a string
+                                # explaining why there was a bailout, if no
+                                # reason was given this will simply be set to
+                                # true (1).
+
+        skip_reason  => undef,  # If there was a skip_all this will give the
+                                # reason.
+    }
+
+
+=item $new = $events->upgrade
+
+=item $events->upgrade(in_place => $BOOL)
+
+B<Note:> This normally returns a new instance, leaving the original unchanged.
+If you call it in void context it will throw an exception. If you want to
+modify the original you must pass in the C<< in_place => 1 >> option. You may
+call this in void context when you ask to modify it in place. The in-place form
+returns the instance that was modified so you can chain methods.
+
+This will create a clone of the list where all events have been converted into
+L<Test2::API::InterceptResult::Event> instances. This is extremely helpful as
+L<Test2::API::InterceptResult::Event> provide a much better interface for
+working with events. This allows you to avoid thinking about legacy event
+types.
+
+This also means your tests against the list are not fragile if the tool
+you are testing randomly changes what type of events it generates (IE Changing
+from L<Test2::Event::Ok> to L<Test2::Event::Pass>, both make assertions and
+both will normalize to identical (or close enough)
+L<Test2::API::InterceptResult::Event> instances.
+
+Really you almost always want this, the only reason it is not done
+automatically is to make sure the C<intercept()> tool is backwards compatible.
+
+=item $new = $events->squash_info
+
+=item $events->squash_info(in_place => $BOOL)
+
+B<Note:> This normally returns a new instance, leaving the original unchanged.
+If you call it in void context it will throw an exception. If you want to
+modify the original you must pass in the C<< in_place => 1 >> option. You may
+call this in void context when you ask to modify it in place. The in-place form
+returns the instance that was modified so you can chain methods.
+
+B<Note:> All events in the new or modified instance will be converted to
+L<Test2::API::InterceptResult::Event> instances. There is no way to avoid this,
+the squash operation requires the upgraded event class.
+
+L<Test::More> and many other legacy tools would send notes, diags, and
+assertions as separate events. A subtest in L<Test::More> would send a note
+with the subtest name, the subtest assertion, and finally a diagnostics event
+if the subtest failed. This method will normalize things by squashing the note
+and diag into the same event as the subtest (This is different from putting
+them into the subtest, which is not what happens).
+
+=back
+
+=head2 FILTERING
+
+B<Note:> These normally return new instances, leaving the originals unchanged.
+If you call them in void context they will throw exceptions. If you want to
+modify the originals you must pass in the C<< in_place => 1 >> option. You may
+call these in void context when you ask to modify them in place. The in-place
+forms return the instance that was modified so you can chain methods.
+
+=head3 %PARAMS
+
+These all accept the same 2 optional parameters:
+
+=over 4
+
+=item in_place => $BOOL
+
+When true the method will modify the instance in place instead of returning a
+new instance.
+
+=item args => \@ARGS
+
+If you wish to pass parameters into the event method being used for filtering,
+you may do so here.
+
+=back
+
+=head3 METHODS
+
+=over 4
+
+=item $events->grep($CALL, %PARAMS)
+
+This is essentially:
+
+    Test2::API::InterceptResult->new(
+        grep { $_->$CALL( @{$PARAMS{args}} ) } $self->event_list,
+    );
+
+B<Note:> that $CALL is called on an upgraded version of the event, though
+the events returned will be the original ones, not the upgraded ones.
+
+$CALL may be either the name of a method on
+L<Test2::API::InterceptResult::Event>, or a coderef.
+
+=item $events->asserts(%PARAMS)
+
+This is essentially:
+
+    $events->grep(has_assert => @{$PARAMS{args}})
+
+It returns a new instance containing only the events that made assertions.
+
+=item $events->subtests(%PARAMS)
+
+This is essentially:
+
+    $events->grep(has_subtest => @{$PARAMS{args}})
+
+It returns a new instance containing only the events that have subtests.
+
+=item $events->diags(%PARAMS)
+
+This is essentially:
+
+    $events->grep(has_diags => @{$PARAMS{args}})
+
+It returns a new instance containing only the events that have diags.
+
+=item $events->notes(%PARAMS)
+
+This is essentially:
+
+    $events->grep(has_notes => @{$PARAMS{args}})
+
+It returns a new instance containing only the events that have notes.
+
+=item $events->errors(%PARAMS)
+
+B<Note:> Errors are NOT failing assertions. Failing assertions are a different
+thing.
+
+This is essentially:
+
+    $events->grep(has_errors => @{$PARAMS{args}})
+
+It returns a new instance containing only the events that have errors.
+
+=item $events->plans(%PARAMS)
+
+This is essentially:
+
+    $events->grep(has_plan => @{$PARAMS{args}})
+
+It returns a new instance containing only the events that set the plan.
+
+=item $events->causes_fail(%PARAMS)
+
+=item $events->causes_failure(%PARAMS)
+
+These are essentially:
+
+    $events->grep(causes_fail    => @{$PARAMS{args}})
+    $events->grep(causes_failure => @{$PARAMS{args}})
+
+B<Note:> C<causes_fail()> and C<causes_failure()> are both aliases for
+eachother in events, so these methods are effectively aliases here as well.
+
+It returns a new instance containing only the events that cause failure.
+
+=back
+
+=head2 MAPPING
+
+These methods B<ALWAYS> return an arrayref.
+
+B<Note:> No methods on L<Test2::API::InterceptResult::Event> alter the event in
+any way.
+
+B<Important Notes about Events>:
+
+L<Test2::API::InterceptResult::Event> was tailor-made to be used in
+event-lists. Most methods that are not applicable to a given event will return
+an empty list, so you normally do not need to worry about unwanted C<undef>
+values or exceptions being thrown. Mapping over event methods is an intended
+use, so it works well to produce lists.
+
+B<Exceptions to the rule:>
+
+Some methods such as C<causes_fail> always return a boolean true or false for
+all events. Any method prefixed with C<the_> conveys the intent that the event
+should have exactly 1 of something, so those will throw an exception when that
+condition is not true.
+
+=over 4
+
+=item $arrayref = $events->map($CALL, %PARAMS)
+
+This is essentially:
+
+    [ map { $_->$CALL(@{ $PARAMS{args} }) } $events->upgrade->event_list ];
+
+$CALL may be either the name of a method on
+L<Test2::API::InterceptResult::Event>, or a coderef.
+
+=item $arrayref = $events->flatten(%PARAMS)
+
+This is essentially:
+
+    [ map { $_->flatten(@{ $PARAMS{args} }) } $events->upgrade->event_list ];
+
+It returns a new list of flattened structures.
+
+See L<Test2::API::InterceptResult::Event> for details on what C<flatten()>
+returns.
+
+=item $arrayref = $events->briefs(%PARAMS)
+
+This is essentially:
+
+    [ map { $_->briefs(@{ $PARAMS{args} }) } $events->upgrade->event_list ];
+
+It returns a new list of event briefs.
+
+See L<Test2::API::InterceptResult::Event> for details on what C<brief()>
+returns.
+
+=item $arrayref = $events->summaries(%PARAMS)
+
+This is essentially:
+
+    [ map { $_->summaries(@{ $PARAMS{args} }) } $events->upgrade->event_list ];
+
+It returns a new list of event summaries.
+
+See L<Test2::API::InterceptResult::Event> for details on what C<summary()>
+returns.
+
+=item $arrayref = $events->subtest_results(%PARAMS)
+
+This is essentially:
+
+    [ map { $_->subtest_result(@{ $PARAMS{args} }) } $events->upgrade->event_list ];
+
+It returns a new list of event summaries.
+
+See L<Test2::API::InterceptResult::Event> for details on what
+C<subtest_result()> returns.
+
+=item $arrayref = $events->diag_messages(%PARAMS)
+
+This is essentially:
+
+    [ map { $_->diag_messages(@{ $PARAMS{args} }) } $events->upgrade->event_list ];
+
+It returns a new list of diagnostic messages (strings).
+
+See L<Test2::API::InterceptResult::Event> for details on what
+C<diag_messages()> returns.
+
+=item $arrayref = $events->note_messages(%PARAMS)
+
+This is essentially:
+
+    [ map { $_->note_messages(@{ $PARAMS{args} }) } $events->upgrade->event_list ];
+
+It returns a new list of notification messages (strings).
+
+See L<Test2::API::InterceptResult::Event> for details on what
+C<note_messages()> returns.
+
+=item $arrayref = $events->error_messages(%PARAMS)
+
+This is essentially:
+
+    [ map { $_->error_messages(@{ $PARAMS{args} }) } $events->upgrade->event_list ];
+
+It returns a new list of error messages (strings).
+
+See L<Test2::API::InterceptResult::Event> for details on what
+C<error_messages()> returns.
+
+=back
+
+=head1 SOURCE
+
+The source code repository for Test2 can be found at
+L<https://github.com/Test-More/test-more/>.
+
+=head1 MAINTAINERS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 COPYRIGHT
+
+Copyright Chad Granum E<lt>exodist@cpan.orgE<gt>.
+
+This program is free software; you can redistribute it and/or
+modify it under the same terms as Perl itself.
+
+See L<https://dev.perl.org/licenses/>
+
+=cut

git/usr/share/perl5/core_perl/Test2/API/InterceptResult/Event.pm

@@ -0,0 +1,1088 @@
+package Test2::API::InterceptResult::Event;
+use strict;
+use warnings;
+
+our $VERSION = '1.302210';
+
+use List::Util   qw/first/;
+use Test2::Util  qw/pkg_to_file/;
+use Scalar::Util qw/reftype blessed/;
+
+use Storable qw/dclone/;
+use Carp     qw/confess croak/;
+
+use Test2::API::InterceptResult::Facet;
+use Test2::API::InterceptResult::Hub;
+
+use Test2::Util::HashBase qw{
+    +causes_failure
+    <facet_data
+    <result_class
+};
+
+my %FACETS;
+BEGIN {
+    local $@;
+    local *plugins;
+    if (eval { require Module::Pluggable; 1 }) {
+        Module::Pluggable->import(
+            # We will replace the sub later
+            require          => 1,
+            on_require_error => sub { 1 },
+            search_path      => ['Test2::EventFacet'],
+            max_depth        => 3,
+            min_depth        => 3,
+        );
+
+        for my $facet_type (__PACKAGE__->plugins) {
+            my ($key, $list);
+            eval {
+                $key  = $facet_type->facet_key;
+                $list = $facet_type->is_list;
+            };
+            next unless $key && defined($list);
+
+            $FACETS{$key} = {list => $list, class => $facet_type, loaded => 1};
+        }
+    }
+
+    $FACETS{__GENERIC__} = {class => 'Test2::API::InterceptResult::Facet', loaded => 1};
+}
+
+sub facet_map { \%FACETS }
+
+sub facet_info {
+    my $facet = pop;
+
+    return $FACETS{$facet} if exists $FACETS{$facet};
+
+    my $mname = ucfirst(lc($facet));
+    $mname =~ s/s$//;
+
+    for my $name ($mname, "${mname}s") {
+        my $file  = "Test2/EventFacet/$name.pm";
+        my $class = "Test2::EventFacet::$name";
+
+        local $@;
+        my $ok = eval {
+            require $file;
+
+            my $key = $class->facet_key;
+            my $list = $class->is_list;
+
+            $FACETS{$key} = {list => $list, class => $class, loaded => 1};
+            $FACETS{$facet} = $FACETS{$key} if $facet ne $key;
+
+            1;
+        };
+
+        return $FACETS{$facet} if $ok && $FACETS{$facet};
+    }
+
+    return $FACETS{$facet} = $FACETS{__GENERIC__};
+}
+
+sub init {
+    my $self = shift;
+
+    my $rc = $self->{+RESULT_CLASS} ||= 'Test2::API::InterceptResult';
+    my $rc_file = pkg_to_file($rc);
+    require($rc_file) unless $INC{$rc_file};
+
+    my $fd = $self->{+FACET_DATA} ||= {};
+
+    for my $facet (keys %$fd) {
+        my $finfo = $self->facet_info($facet);
+        my $is_list = $finfo->{list};
+        next unless defined $is_list;
+
+        my $type = reftype($fd->{$facet});
+
+        if ($is_list) {
+            confess "Facet '$facet' is a list facet, but got '$type' instead of an arrayref"
+                unless $type eq 'ARRAY';
+
+            for my $item (@{$fd->{$facet}}) {
+                my $itype = reftype($item);
+                next if $itype eq 'HASH';
+
+                confess "Got item type '$itype' in list-facet '$facet', all items must be hashrefs";
+            }
+        }
+        else {
+            confess "Facet '$facet' is an only-one facet, but got '$type' instead of a hashref"
+                unless $type eq 'HASH';
+        }
+    }
+}
+
+sub clone {
+    my $self = shift;
+    my $class = blessed($self);
+
+    my %data = %$self;
+
+    $data{+FACET_DATA} = dclone($data{+FACET_DATA});
+
+    return bless(\%data, $class);
+}
+
+sub _facet_class {
+    my $self = shift;
+    my ($name) = @_;
+
+    my $spec  = $self->facet_info($name);
+    my $class = $spec->{class};
+    unless ($spec->{loaded}) {
+        my $file = pkg_to_file($class);
+        require $file unless $INC{$file};
+        $spec->{loaded} = 1;
+    }
+
+    return $class;
+}
+
+sub the_facet {
+    my $self = shift;
+    my ($name) = @_;
+
+    return undef unless defined $self->{+FACET_DATA}->{$name};
+
+    my $data = $self->{+FACET_DATA}->{$name};
+
+    my $type = reftype($data) or confess "Facet '$name' has a value that is not a reference, this should not happen";
+
+    return $self->_facet_class($name)->new(%{dclone($data)})
+        if $type eq 'HASH';
+
+    if ($type eq 'ARRAY') {
+        return undef unless @$data;
+        croak "'the_facet' called for facet '$name', but '$name' has '" . @$data . "' items" if @$data != 1;
+        return $self->_facet_class($name)->new(%{dclone($data->[0])});
+    }
+
+    die "Invalid facet data type: $type";
+}
+
+sub facet {
+    my $self = shift;
+    my ($name) = @_;
+
+    return () unless exists $self->{+FACET_DATA}->{$name};
+
+    my $data = $self->{+FACET_DATA}->{$name};
+
+    my $type = reftype($data) or confess "Facet '$name' has a value that is not a reference, this should not happen";
+
+    my @out;
+    @out = ($data)  if $type eq 'HASH';
+    @out = (@$data) if $type eq 'ARRAY';
+
+    my $class = $self->_facet_class($name);
+
+    return map { $class->new(%{dclone($_)}) } @out;
+}
+
+sub causes_failure {
+    my $self = shift;
+
+    return $self->{+CAUSES_FAILURE}
+        if exists $self->{+CAUSES_FAILURE};
+
+    my $hub = Test2::API::InterceptResult::Hub->new();
+    $hub->process($self);
+
+    return $self->{+CAUSES_FAILURE} = ($hub->is_passing ? 0 : 1);
+}
+
+sub causes_fail { shift->causes_failure }
+
+sub trace         { $_[0]->facet('trace') }
+sub the_trace     { $_[0]->the_facet('trace') }
+sub frame         { my $t = $_[0]->the_trace or return undef; $t->{frame}   || undef }
+sub trace_details { my $t = $_[0]->the_trace or return undef; $t->{details} || undef }
+sub trace_stamp   { my $f = $_[0]->the_trace or return undef; $f->{stamp}   || undef }
+sub trace_package { my $f = $_[0]->frame     or return undef; $f->[0]       || undef }
+sub trace_file    { my $f = $_[0]->frame     or return undef; $f->[1]       || undef }
+sub trace_line    { my $f = $_[0]->frame     or return undef; $f->[2]       || undef }
+sub trace_subname { my $f = $_[0]->frame     or return undef; $f->[3]       || undef }
+sub trace_tool    { my $f = $_[0]->frame     or return undef; $f->[3]       || undef }
+
+sub trace_signature { my $t = $_[0]->the_trace or return undef; Test2::EventFacet::Trace::signature($t) || undef }
+
+sub brief {
+    my $self = shift;
+
+    my @try = qw{
+        bailout_brief
+        error_brief
+        assert_brief
+        plan_brief
+    };
+
+    for my $meth (@try) {
+        my $got = $self->$meth or next;
+        return $got;
+    }
+
+    return;
+}
+
+sub flatten {
+    my $self = shift;
+    my %params = @_;
+
+    my $todo = {%{$self->{+FACET_DATA}}};
+    delete $todo->{hubs};
+    delete $todo->{meta};
+    delete $todo->{trace};
+
+    my $out = $self->summary;
+    delete $out->{brief};
+    delete $out->{facets};
+    delete $out->{trace_tool};
+    delete $out->{trace_details} unless defined($out->{trace_details});
+
+    for my $tagged (grep { my $finfo = $self->facet_info($_); $finfo->{list} && $finfo->{class}->can('tag') } keys %FACETS, keys %$todo) {
+        my $set = delete $todo->{$tagged} or next;
+
+        my $fd = $self->{+FACET_DATA};
+        my $has_assert = $self->has_assert;
+        my $has_parent = $self->has_subtest;
+        my $has_fatal_error = $self->has_errors && grep { $_->{fail} } $self->errors;
+
+        next if $tagged eq 'amnesty' && !($has_assert || $has_parent || $has_fatal_error);
+
+        for my $item (@$set) {
+            push @{$out->{lc($item->{tag})}} => $item->{fail} ? "FATAL: $item->{details}" : $item->{details};
+        }
+    }
+
+    if (my $assert = delete $todo->{assert}) {
+        $out->{pass} = $assert->{pass};
+        $out->{name} = $assert->{details};
+    }
+
+    if (my $parent = delete $todo->{parent}) {
+        delete $out->{subtest}->{bailed_out}  unless defined $out->{subtest}->{bailed_out};
+        delete $out->{subtest}->{skip_reason} unless defined $out->{subtest}->{skip_reason};
+
+        if (my $res = $self->subtest_result) {
+            my $state = $res->state;
+            delete $state->{$_} for grep { !defined($state->{$_}) } keys %$state;
+            $out->{subtest} = $state;
+            $out->{subevents} = $res->flatten(%params)
+                if $params{include_subevents};
+        }
+    }
+
+    if (my $control = delete $todo->{control}) {
+        if ($control->{halt}) {
+            $out->{bailed_out} = $control->{details} || 1;
+        }
+        elsif(defined $control->{details}) {
+            $out->{control} = $control->{details};
+        }
+    }
+
+    if (my $plan = delete $todo->{plan}) {
+        $out->{plan} = $self->plan_brief;
+        $out->{plan} =~ s/^PLAN\s*//;
+    }
+
+    for my $other (keys %$todo) {
+        my $data = $todo->{$other} or next;
+
+        if (reftype($data) eq 'ARRAY') {
+            if (!$out->{$other} || reftype($out->{$other}) eq 'ARRAY') {
+                for my $item (@$data) {
+                    push @{$out->{$other}} => $item->{details} if defined $item->{details};
+                }
+            }
+        }
+        else {
+            $out->{$other} = $data->{details} if defined($data->{details}) && !defined($out->{$other});
+        }
+    }
+
+    if (my $fields = $params{fields}) {
+        $out = { map {exists($out->{$_}) ? ($_ => $out->{$_}) : ()} @$fields };
+    }
+
+    if (my $remove = $params{remove}) {
+        delete $out->{$_} for @$remove;
+    }
+
+    return $out;
+}
+
+sub summary {
+    my $self = shift;
+    my %params = @_;
+
+    my $out = {
+        brief => $self->brief || '',
+
+        causes_failure => $self->causes_failure,
+
+        trace_line    => $self->trace_line,
+        trace_file    => $self->trace_file,
+        trace_tool    => $self->trace_subname,
+        trace_details => $self->trace_details,
+
+        facets => [ sort keys(%{$self->{+FACET_DATA}}) ],
+    };
+
+    if (my $fields = $params{fields}) {
+        $out = { map {exists($out->{$_}) ? ($_ => $out->{$_}) : ()} @$fields };
+    }
+
+    if (my $remove = $params{remove}) {
+        delete $out->{$_} for @$remove;
+    }
+
+    return $out;
+}
+
+sub has_assert { $_[0]->{+FACET_DATA}->{assert} ? 1 : 0 }
+sub the_assert { $_[0]->the_facet('assert') }
+sub assert     { $_[0]->facet('assert') }
+
+sub assert_brief {
+    my $self = shift;
+
+    my $fd = $self->{+FACET_DATA};
+    my $as = $fd->{assert} or return;
+    my $am = $fd->{amnesty};
+
+    my $out = $as->{pass} ? "PASS" : "FAIL";
+    $out .= " with amnesty" if $am;
+    return $out;
+}
+
+sub has_subtest { $_[0]->{+FACET_DATA}->{parent} ? 1 : 0 }
+sub the_subtest { $_[0]->the_facet('parent') }
+sub subtest     { $_[0]->facet('parent') }
+
+sub subtest_result {
+    my $self = shift;
+
+    my $parent = $self->{+FACET_DATA}->{parent} or return;
+    my $children = $parent->{children} || [];
+
+    $children = $self->{+RESULT_CLASS}->new(@$children)->upgrade
+        unless blessed($children) && $children->isa($self->{+RESULT_CLASS});
+
+    return $children;
+}
+
+sub has_bailout { $_[0]->bailout ? 1 : 0 }
+sub the_bailout { my ($b) = $_[0]->bailout; $b }
+
+sub bailout {
+    my $self = shift;
+    my $control = $self->{+FACET_DATA}->{control} or return;
+    return $control if $control->{halt};
+    return;
+}
+
+sub bailout_brief {
+    my $self = shift;
+    my $bo = $self->bailout or return;
+
+    my $reason = $bo->{details} or return "BAILED OUT";
+    return "BAILED OUT: $reason";
+}
+
+sub bailout_reason {
+    my $self = shift;
+    my $bo = $self->bailout or return;
+    return $bo->{details} || '';
+}
+
+sub has_plan { $_[0]->{+FACET_DATA}->{plan} ? 1 : 0 }
+sub the_plan { $_[0]->the_facet('plan') }
+sub plan     { $_[0]->facet('plan') }
+
+sub plan_brief {
+    my $self = shift;
+
+    my $plan = $self->{+FACET_DATA}->{plan} or return;
+
+    my $base = $self->_plan_brief($plan);
+
+    my $reason = $plan->{details} or return $base;
+    return "$base: $reason";
+}
+
+sub _plan_brief {
+    my $self = shift;
+    my ($plan) = @_;
+
+    return 'NO PLAN' if $plan->{none};
+    return "SKIP ALL" if $plan->{skip} || !$plan->{count};
+    return "PLAN $plan->{count}";
+}
+
+sub has_amnesty     { $_[0]->{+FACET_DATA}->{amnesty} ? 1 : 0 }
+sub the_amnesty     { $_[0]->the_facet('amnesty') }
+sub amnesty         { $_[0]->facet('amnesty') }
+sub amnesty_reasons { map { $_->{details} } $_[0]->amnesty }
+
+sub has_todos    { &first(sub { uc($_->{tag}) eq 'TODO' }, $_[0]->amnesty) ? 1 : 0 }
+sub todos        {       grep { uc($_->{tag}) eq 'TODO' }  $_[0]->amnesty          }
+sub todo_reasons {       map  { $_->{details} || 'TODO' }  $_[0]->todos            }
+
+sub has_skips    { &first(sub { uc($_->{tag}) eq 'SKIP' }, $_[0]->amnesty) ? 1 : 0 }
+sub skips        {       grep { uc($_->{tag}) eq 'SKIP' }  $_[0]->amnesty          }
+sub skip_reasons {       map  { $_->{details} || 'SKIP' }  $_[0]->skips            }
+
+my %TODO_OR_SKIP = (SKIP => 1, TODO => 1);
+sub has_other_amnesty     { &first( sub { !$TODO_OR_SKIP{uc($_->{tag})}            }, $_[0]->amnesty) ? 1 : 0 }
+sub other_amnesty         {        grep { !$TODO_OR_SKIP{uc($_->{tag})}            }  $_[0]->amnesty          }
+sub other_amnesty_reasons {        map  { $_->{details} ||  $_->{tag} || 'AMNESTY' }  $_[0]->other_amnesty    }
+
+sub has_errors     { $_[0]->{+FACET_DATA}->{errors} ? 1 : 0 }
+sub the_errors     { $_[0]->the_facet('errors') }
+sub errors         { $_[0]->facet('errors') }
+sub error_messages { map { $_->{details} || $_->{tag} || 'ERROR' } $_[0]->errors }
+
+sub error_brief {
+    my $self = shift;
+
+    my $errors = $self->{+FACET_DATA}->{errors} or return;
+
+    my $base = @$errors > 1 ? "ERRORS" : "ERROR";
+
+    return $base unless @$errors;
+
+    my ($msg, @extra) = split /[\n\r]+/, $errors->[0]->{details};
+
+    my $out = "$base: $msg";
+
+    $out .= " [...]" if @extra || @$errors > 1;
+
+    return $out;
+}
+
+sub has_info      { $_[0]->{+FACET_DATA}->{info} ? 1 : 0 }
+sub the_info      { $_[0]->the_facet('info') }
+sub info          { $_[0]->facet('info') }
+sub info_messages { map { $_->{details} } $_[0]->info }
+
+sub has_diags { &first(sub { uc($_->{tag}) eq 'DIAG' }, $_[0]->info) ? 1 : 0 }
+sub diags         {   grep { uc($_->{tag}) eq 'DIAG' }  $_[0]->info          }
+sub diag_messages {   map  { $_->{details} || 'DIAG' }  $_[0]->diags         }
+
+sub has_notes { &first(sub { uc($_->{tag}) eq 'NOTE' }, $_[0]->info) ? 1 : 0 }
+sub notes         {   grep { uc($_->{tag}) eq 'NOTE' }  $_[0]->info          }
+sub note_messages {   map  { $_->{details} || 'NOTE' }  $_[0]->notes         }
+
+my %NOTE_OR_DIAG = (NOTE => 1, DIAG => 1);
+sub has_other_info { &first(sub { !$NOTE_OR_DIAG{uc($_->{tag})}         }, $_[0]->info) ? 1 : 0 }
+sub other_info          {  grep { !$NOTE_OR_DIAG{uc($_->{tag})}         }  $_[0]->info          }
+sub other_info_messages {  map  { $_->{details} ||  $_->{tag} || 'INFO' }  $_[0]->other_info    }
+
+1;
+
+__END__
+
+=pod
+
+=encoding UTF-8
+
+=head1 NAME
+
+Test2::API::InterceptResult::Event - Representation of an event for use in
+testing other test tools.
+
+=head1 DESCRIPTION
+
+C<intercept { ... }> from L<Test2::API> returns an instance of
+L<Test2::API::InterceptResult> which is a blessed arrayref of
+L<Test2::API::InterceptResult::Event> objects.
+
+This POD documents the methods of these events, which are mainly provided for
+you to use when testing your test tools.
+
+=head1 SYNOPSIS
+
+    use Test2::V0;
+    use Test2::API qw/intercept/;
+
+    my $events = intercept {
+        ok(1, "A passing assertion");
+        plan(1);
+    };
+
+    # This will convert all events into instances of
+    # Test2::API::InterceptResult::Event. Until we do this they are the
+    # original Test::Event::* instances
+    $events->upgrade(in_place => 1);
+
+    # Now we can get individual events in this form
+    my $assert = $events->[0];
+    my $plan   = $events->[1];
+
+    # Or we can operate on all events at once:
+    my $flattened = $events->flatten;
+    is(
+        $flattened,
+        [
+          {
+            causes_failure => 0,
+
+            name => 'A passing assertion',
+            pass => 1,
+
+            trace_file => 'xxx.t',
+            trace_line => 5,
+          },
+          {
+            causes_failure => 0,
+
+            plan => 1,
+
+            trace_file => 'xxx.t',
+            trace_line => 6,
+          },
+        ],
+        "Flattened both events and returned an arrayref of the results
+    );
+
+=head1 METHODS
+
+=head2 !!! IMPORTANT NOTES ON DESIGN !!!
+
+Please pay attention to what these return, many return a scalar when
+applicable or an empty list when not (as opposed to undef). Many also always
+return a list of 0 or more items. Some always return a scalar. Note that none
+of the methods care about context, their behavior is consistent regardless of
+scalar, list, or void context.
+
+This was done because this class was specifically designed to be used in a list
+and generate more lists in bulk operations. Sometimes in a map you want nothing
+to show up for the event, and you do not want an undef in its place. In general
+single event instances are not going to be used alone, though that is allowed.
+
+As a general rule any method prefixed with C<the_> implies the event should
+have exactly 1 of the specified item, and and exception will be thrown if there
+are 0, or more than 1 of the item.
+
+=head2 ATTRIBUTES
+
+=over 4
+
+=item $hashref = $event->facet_data
+
+This will return the facet data hashref, which is all Test2 cares about for any
+given event.
+
+=item $class = $event->result_class
+
+This is normally L<Test2::API::InterceptResult>. This is set at construction so
+that subtest results can be turned into instances of it on demand.
+
+=back
+
+=head2 DUPLICATION
+
+=over 4
+
+=item $copy = $event->clone
+
+Create a deep copy of the event. Modifying either event will not affect the
+other.
+
+=back
+
+=head2 CONDENSED MULTI-FACET DATA
+
+=over 4
+
+=item $bool = $event->causes_failure
+
+=item $bool = $event->causes_fail
+
+These are both aliases of the same functionality.
+
+This will always return either a true value, or a false value. This never
+returns a list.
+
+This method may be relatively slow (still super fast) because it determines
+pass or fail by creating an instance of L<Test2::Hub> and asking it to process
+the event, and then asks the hub for its pass/fail state. This is slower than
+building in logic to do the check, but it is more reliable as it will always
+tell you what the hub thinks, so the logic will never be out of date relative
+to the Test2 logic that actually cares.
+
+=item STRING_OR_EMPTY_LIST = $event->brief
+
+Not all events have a brief, some events are not rendered by the formatter,
+others have no "brief" data worth seeing. When this is the case an empty list
+is returned. This is done intentionally so it can be used in a map operation
+without having C<undef> being included in the result.
+
+When a brief can be generated it is always a single 1-line string, and is
+returned as-is, not in a list.
+
+Possible briefs:
+
+    # From control facets
+    "BAILED OUT"
+    "BAILED OUT: $why"
+
+    # From error facets
+    "ERROR"
+    "ERROR: $message"
+    "ERROR: $partial_message [...]"
+    "ERRORS: $first_error_message [...]"
+
+    # From assert facets
+    "PASS"
+    "FAIL"
+    "PASS with amnesty"
+    "FAIL with amnesty"
+
+    # From plan facets
+    "PLAN $count"
+    "NO PLAN"
+    "SKIP ALL"
+    "SKIP ALL: $why"
+
+Note that only the first applicable brief is returned. This is essentially a
+poor-mans TAP that only includes facets that could (but not necessarily do)
+cause a failure.
+
+=item $hashref = $event->flatten
+
+=item $hashref = $event->flatten(include_subevents => 1)
+
+This ALWAYS returns a hashref. This puts all the most useful data for the most
+interesting facets into a single hashref for easy validation.
+
+If there are no meaningful facets this will return an empty hashref.
+
+If given the 'include_subevents' parameter it will also include subtest data:
+
+Here is a list of EVERY possible field. If a field is not applicable it will
+not be present.
+
+=over 4
+
+=item always present
+
+        causes_failure => 1,    # Always present
+
+=item Present if the event has a trace facet
+
+        trace_line    => 42,
+        trace_file    => 'Foo/Bar.pm',
+        trace_details => 'Extra trace details',    # usually not present
+
+=item If an assertion is present
+
+        pass => 0,
+        name => "1 + 1 = 2, so math works",
+
+=item If a plan is present:
+
+        plan => $count_or_SKIP_ALL_or_NO_PLAN,
+
+=item If amnesty facets are present
+
+You get an array for each type that is present.
+
+        todo => [    # Yes you could be under multiple todos, this will list them all.
+            "I will fix this later",
+            "I promise to fix these",
+        ],
+
+        skip => ["This will format the main drive, do not run"],
+
+        ... => ["Other amnesty"]
+
+=item If Info (note/diag) facets are present
+
+You get an arrayref for any that are present, the key is not defined if they are not present.
+
+        diag => [
+            "Test failed at Foo/Bar.pm line 42",
+            "You forgot to tie your boots",
+        ],
+
+        note => ["Your boots are red"],
+
+        ...  => ["Other info"],
+
+=item If error facets are present
+
+Always an arrayref
+
+        error => [
+            "non fatal error (does not cause test failure, just an FYI",
+            "FATAL: This is a fatal error (causes failure)",
+        ],
+
+        # Errors can have alternative tags, but in practice are always 'error',
+        # listing this for completeness.
+        ... => [ ... ]
+
+=item Present if the event is a subtest
+
+        subtest => {
+            count      => 2,    # Number of assertions made
+            failed     => 1,    # Number of test failures seen
+            is_passing => 0,    # Boolean, true if the test would be passing
+                                # after the events are processed.
+
+            plan         => 2,  # Plan, either a number, undef, 'SKIP', or 'NO PLAN'
+            follows_plan => 1,  # True if there is a plan and it was followed.
+                                # False if the plan and assertions did not
+                                # match, undef if no plan was present in the
+                                # event list.
+
+            bailed_out => "foo",    # if there was a bail-out in the
+                                    # events in this will be a string explaining
+                                    # why there was a bailout, if no reason was
+                                    # given this will simply be set to true (1).
+
+            skip_reason => "foo",   # If there was a skip_all this will give the
+                                    # reason.
+        },
+
+if C<< (include_subtest => 1) >> was provided as a parameter then the following
+will be included. This is the result of turning all subtest child events into
+an L<Test2::API::InterceptResult> instance and calling the C<flatten> method on
+it.
+
+        subevents => Test2::API::InterceptResult->new(@child_events)->flatten(...),
+
+=item If a bail-out is being requested
+
+If no reason was given this will be set to 1.
+
+        bailed_out => "reason",
+
+=back
+
+=item $hashref = $event->summary()
+
+This returns a limited summary. See C<flatten()>, which is usually a better
+option.
+
+    {
+        brief => $event->brief || '',
+
+        causes_failure => $event->causes_failure,
+
+        trace_line    => $event->trace_line,
+        trace_file    => $event->trace_file,
+        trace_tool    => $event->trace_subname,
+        trace_details => $event->trace_details,
+
+        facets => [ sort keys(%{$event->{+FACET_DATA}}) ],
+    }
+
+=back
+
+=head2 DIRECT ARBITRARY FACET ACCESS
+
+=over 4
+
+=item @list_of_facets = $event->facet($name)
+
+This always returns a list of 0 or more items. This fetches the facet instances
+from the event. For facets like 'assert' this will always return 0 or 1
+item. For events like 'info' (diags, notes) this will return 0 or more
+instances, once for each instance of the facet.
+
+These will be blessed into the proper L<Test2::EventFacet> subclass. If no
+subclass can be found it will be blessed as an
+L<Test2::API::InterceptResult::Facet> generic facet class.
+
+=item $undef_or_facet = $event->the_facet($name)
+
+If you know you will have exactly 1 instance of a facet you can call this.
+
+If you are correct and there is exactly one instance of the facet it will
+always return the hashref.
+
+If there are 0 instances of the facet this will return undef, not an empty
+list.
+
+If there are more than 1 instance this will throw an exception because your
+assumption was incorrect.
+
+=back
+
+=head2 TRACE FACET
+
+=over 4
+
+=item @list_of_facets = $event->trace
+
+TODO
+
+=item $undef_or_hashref = $event->the_trace
+
+This returns the trace hashref, or undef if it is not present.
+
+=item $undef_or_arrayref = $event->frame
+
+If a trace is present, and has a caller frame, this will be an arrayref:
+
+    [$package, $file, $line, $subname]
+
+If the trace is not present, or has no caller frame this will return undef.
+
+=item $undef_or_string = $event->trace_details
+
+This is usually undef, but occasionally has a string that overrides the
+file/line number debugging a trace usually provides on test failure.
+
+=item $undef_or_string = $event->trace_package
+
+Same as C<(caller())[0]>, the first element of the trace frame.
+
+Will be undef if not present.
+
+=item $undef_or_string = $event->trace_file
+
+Same as C<(caller())[1]>, the second element of the trace frame.
+
+Will be undef if not present.
+
+=item $undef_or_integer = $event->trace_line
+
+Same as C<(caller())[2]>, the third element of the trace frame.
+
+Will be undef if not present.
+
+=item $undef_or_string = $event->trace_subname
+
+=item $undef_or_string = $event->trace_tool
+
+Aliases for the same thing
+
+Same as C<(caller($level))[4]>, the fourth element of the trace frame.
+
+Will be undef if not present.
+
+=item $undef_or_string = $event->trace_signature
+
+A string that is a unique signature for the trace. If a single context
+generates multiple events they will all have the same signature. This can be
+used to tie assertions and diagnostics sent as separate events together after
+the fact.
+
+=back
+
+=head2 ASSERT FACET
+
+=over 4
+
+=item $bool = $event->has_assert
+
+Returns true if the event has an assert facet, false if it does not.
+
+=item $undef_or_hashref = $event->the_assert
+
+Returns the assert facet if present, undef if it is not.
+
+=item @list_of_facets = $event->assert
+
+TODO
+
+=item EMPTY_LIST_OR_STRING = $event->assert_brief
+
+Returns a string giving a brief of the assertion if an assertion is present.
+Returns an empty list if no assertion is present.
+
+=back
+
+=head2 SUBTESTS (PARENT FACET)
+
+=over 4
+
+=item $bool = $event->has_subtest
+
+True if a subetest is present in this event.
+
+=item $undef_or_hashref = $event->the_subtest
+
+Get the one subtest if present, otherwise undef.
+
+=item @list_of_facets = $event->subtest
+
+TODO
+
+=item EMPTY_LIST_OR_OBJECT = $event->subtest_result
+
+Returns an empty list if there is no subtest.
+
+Get an instance of L<Test2::API::InterceptResult> representing the subtest.
+
+=back
+
+=head2 CONTROL FACET (BAILOUT, ENCODING)
+
+=over 4
+
+=item $bool = $event->has_bailout
+
+True if there was a bailout
+
+=item $undef_hashref = $event->the_bailout
+
+Return the control facet if it requested a bailout.
+
+=item EMPTY_LIST_OR_HASHREF = $event->bailout
+
+Get a list of 0 or 1 hashrefs. The hashref will be the control facet if a
+bail-out was requested.
+
+=item EMPTY_LIST_OR_STRING = $event->bailout_brief
+
+Get the brief of the bailout if present.
+
+=item EMPTY_LIST_OR_STRING = $event->bailout_reason
+
+Get the reason for the bailout, an empty string if no reason was provided, or
+an empty list if there was no bailout.
+
+=back
+
+=head2 PLAN FACET
+
+TODO
+
+=over 4
+
+=item $bool = $event->has_plan
+
+=item $undef_or_hashref = $event->the_plan
+
+=item @list_if_hashrefs = $event->plan
+
+=item EMPTY_LIST_OR_STRING $event->plan_brief
+
+=back
+
+=head2 AMNESTY FACET (TODO AND SKIP)
+
+TODO
+
+=over 4
+
+=item $event->has_amnesty
+
+=item $event->the_amnesty
+
+=item $event->amnesty
+
+=item $event->amnesty_reasons
+
+=item $event->has_todos
+
+=item $event->todos
+
+=item $event->todo_reasons
+
+=item $event->has_skips
+
+=item $event->skips
+
+=item $event->skip_reasons
+
+=item $event->has_other_amnesty
+
+=item $event->other_amnesty
+
+=item $event->other_amnesty_reasons
+
+=back
+
+=head2 ERROR FACET (CAPTURED EXCEPTIONS)
+
+TODO
+
+=over 4
+
+=item $event->has_errors
+
+=item $event->the_errors
+
+=item $event->errors
+
+=item $event->error_messages
+
+=item $event->error_brief
+
+=back
+
+=head2 INFO FACET (DIAG, NOTE)
+
+TODO
+
+=over 4
+
+=item $event->has_info
+
+=item $event->the_info
+
+=item $event->info
+
+=item $event->info_messages
+
+=item $event->has_diags
+
+=item $event->diags
+
+=item $event->diag_messages
+
+=item $event->has_notes
+
+=item $event->notes
+
+=item $event->note_messages
+
+=item $event->has_other_info
+
+=item $event->other_info
+
+=item $event->other_info_messages
+
+=back
+
+=head1 SOURCE
+
+The source code repository for Test2 can be found at
+L<https://github.com/Test-More/test-more/>.
+
+=head1 MAINTAINERS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 COPYRIGHT
+
+Copyright Chad Granum E<lt>exodist@cpan.orgE<gt>.
+
+This program is free software; you can redistribute it and/or
+modify it under the same terms as Perl itself.
+
+See L<https://dev.perl.org/licenses/>
+
+=cut

git/usr/share/perl5/core_perl/Test2/API/InterceptResult/Facet.pm

@@ -0,0 +1,25 @@
+package Test2::API::InterceptResult::Facet;
+use strict;
+use warnings;
+
+our $VERSION = '1.302210';
+
+BEGIN {
+    require Test2::EventFacet;
+    our @ISA = ('Test2::EventFacet');
+}
+
+our $AUTOLOAD;
+sub AUTOLOAD {
+    my $self = shift;
+
+    my $name = $AUTOLOAD;
+    $name =~ s/^.*:://g;
+
+    return undef unless exists $self->{$name};
+    return $self->{$name};
+}
+
+sub DESTROY {}
+
+1;

git/usr/share/perl5/core_perl/Test2/API/InterceptResult/Hub.pm

@@ -0,0 +1,66 @@
+package Test2::API::InterceptResult::Hub;
+use strict;
+use warnings;
+
+our $VERSION = '1.302210';
+
+BEGIN { require Test2::Hub; our @ISA = qw(Test2::Hub) }
+use Test2::Util::HashBase;
+
+sub init {
+    my $self = shift;
+    $self->SUPER::init();
+    $self->{+NESTED} = 0;
+}
+
+sub inherit {
+    my $self = shift;
+
+    $self->{+NESTED} = 0;
+}
+
+sub terminate { }
+
+1;
+
+__END__
+
+=pod
+
+=encoding UTF-8
+
+=head1 NAME
+
+Test2::API::InterceptResult::Hub - Hub used by InterceptResult.
+
+=head1 SOURCE
+
+The source code repository for Test2 can be found at
+L<https://github.com/Test-More/test-more/>.
+
+=head1 MAINTAINERS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 COPYRIGHT
+
+Copyright Chad Granum E<lt>exodist@cpan.orgE<gt>.
+
+This program is free software; you can redistribute it and/or
+modify it under the same terms as Perl itself.
+
+See L<https://dev.perl.org/licenses/>
+
+=cut

git/usr/share/perl5/core_perl/Test2/API/InterceptResult/Squasher.pm

@@ -0,0 +1,196 @@
+package Test2::API::InterceptResult::Squasher;
+use strict;
+use warnings;
+
+our $VERSION = '1.302210';
+
+use Carp qw/croak/;
+use List::Util qw/first/;
+
+use Test2::Util::HashBase qw{
+    <events
+
+    +down_sig +down_buffer
+
+    +up_into +up_sig +up_clear
+};
+
+sub init {
+    my $self = shift;
+
+    croak "'events' is a required attribute"  unless $self->{+EVENTS};
+}
+
+sub can_squash {
+    my $self = shift;
+    my ($event) = @_;
+
+    # No info, no squash
+    return unless $event->has_info;
+
+    # Do not merge up if one of these is true
+    return if first { $event->$_ } 'causes_fail', 'has_assert', 'has_bailout', 'has_errors', 'has_plan', 'has_subtest';
+
+    # Signature if we can squash
+    return $event->trace_signature;
+}
+
+sub process {
+    my $self = shift;
+    my ($event) = @_;
+
+    return if $self->squash_up($event);
+    return if $self->squash_down($event);
+
+    $self->flush_down($event);
+
+    push @{$self->{+EVENTS}} => $event;
+
+    return;
+}
+
+sub squash_down {
+    my $self = shift;
+    my ($event) = @_;
+
+    my $sig = $self->can_squash($event)
+        or return;
+
+    $self->flush_down()
+        if $self->{+DOWN_SIG} && $self->{+DOWN_SIG} ne $sig;
+
+    $self->{+DOWN_SIG} ||= $sig;
+    push @{$self->{+DOWN_BUFFER}} => $event;
+
+    return 1;
+}
+
+sub flush_down {
+    my $self = shift;
+    my ($into) = @_;
+
+    my $sig    = delete $self->{+DOWN_SIG};
+    my $buffer = delete $self->{+DOWN_BUFFER};
+
+    return unless $buffer && @$buffer;
+
+    my $fsig = $into ? $into->trace_signature : undef;
+
+    if ($fsig && $fsig eq $sig) {
+        $self->squash($into, @$buffer);
+    }
+    else {
+        push @{$self->{+EVENTS}} => @$buffer if $buffer;
+    }
+}
+
+sub clear_up {
+    my $self = shift;
+
+    return unless $self->{+UP_CLEAR};
+
+    delete $self->{+UP_INTO};
+    delete $self->{+UP_SIG};
+    delete $self->{+UP_CLEAR};
+}
+
+sub squash_up {
+    my $self = shift;
+    my ($event) = @_;
+    no warnings 'uninitialized';
+
+    $self->clear_up;
+
+    if ($event->has_assert) {
+        if(my $sig = $event->trace_signature) {
+            $self->{+UP_INTO}  = $event;
+            $self->{+UP_SIG}   = $sig;
+            $self->{+UP_CLEAR} = 0;
+        }
+        else {
+            $self->{+UP_CLEAR} = 1;
+            $self->clear_up;
+        }
+
+        return;
+    }
+
+    my $into = $self->{+UP_INTO} or return;
+
+    # Next iteration should clear unless something below changes that
+    $self->{+UP_CLEAR} = 1;
+
+    # Only merge into matching trace signatres
+    my $sig = $self->can_squash($event);
+    return unless $sig eq $self->{+UP_SIG};
+
+    # OK Merge! Do not clear merge in case the return event is also a matching sig diag-only
+    $self->{+UP_CLEAR} = 0;
+
+    $self->squash($into, $event);
+
+    return 1;
+}
+
+sub squash {
+    my $self = shift;
+    my ($into, @from) = @_;
+    push @{$into->facet_data->{info}} => $_->info for @from;
+}
+
+sub DESTROY {
+    my $self = shift;
+
+    return unless $self->{+EVENTS};
+    $self->flush_down();
+    return;
+}
+
+1;
+
+__END__
+
+=pod
+
+=encoding UTF-8
+
+=head1 NAME
+
+Test2::API::InterceptResult::Squasher - Encapsulation of the algorithm that
+squashes diags into assertions.
+
+=head1 DESCRIPTION
+
+Internal use only, please ignore.
+
+=head1 SOURCE
+
+The source code repository for Test2 can be found at
+L<https://github.com/Test-More/test-more/>.
+
+=head1 MAINTAINERS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 COPYRIGHT
+
+Copyright Chad Granum E<lt>exodist@cpan.orgE<gt>.
+
+This program is free software; you can redistribute it and/or
+modify it under the same terms as Perl itself.
+
+See L<https://dev.perl.org/licenses/>
+
+=cut

git/usr/share/perl5/core_perl/Test2/API/Stack.pm

@@ -0,0 +1,226 @@
+package Test2::API::Stack;
+use strict;
+use warnings;
+
+our $VERSION = '1.302210';
+
+
+use Test2::Hub();
+
+use Carp qw/confess/;
+
+sub new {
+    my $class = shift;
+    return bless [], $class;
+}
+
+sub new_hub {
+    my $self = shift;
+    my %params = @_;
+
+    my $class = delete $params{class} || 'Test2::Hub';
+
+    my $hub = $class->new(%params);
+
+    if (@$self) {
+        $hub->inherit($self->[-1], %params);
+    }
+    else {
+        require Test2::API;
+        $hub->format(Test2::API::test2_formatter()->new_root)
+            unless $hub->format || exists($params{formatter});
+
+        my $ipc = Test2::API::test2_ipc();
+        if ($ipc && !$hub->ipc && !exists($params{ipc})) {
+            $hub->set_ipc($ipc);
+            $ipc->add_hub($hub->hid);
+        }
+    }
+
+    push @$self => $hub;
+
+    $hub;
+}
+
+sub top {
+    my $self = shift;
+    return $self->new_hub unless @$self;
+    return $self->[-1];
+}
+
+sub peek {
+    my $self = shift;
+    return @$self ? $self->[-1] : undef;
+}
+
+sub cull {
+    my $self = shift;
+    $_->cull for reverse @$self;
+}
+
+sub all {
+    my $self = shift;
+    return @$self;
+}
+
+sub root {
+    my $self = shift;
+    return unless @$self;
+    return $self->[0];
+}
+
+sub clear {
+    my $self = shift;
+    @$self = ();
+}
+
+# Do these last without keywords in order to prevent them from getting used
+# when we want the real push/pop.
+
+{
+    no warnings 'once';
+
+    *push = sub {
+        my $self = shift;
+        my ($hub) = @_;
+        $hub->inherit($self->[-1]) if @$self;
+        push @$self => $hub;
+    };
+
+    *pop = sub {
+        my $self = shift;
+        my ($hub) = @_;
+        confess "No hubs on the stack"
+            unless @$self;
+        confess "You cannot pop the root hub"
+            if 1 == @$self;
+        confess "Hub stack mismatch, attempted to pop incorrect hub"
+            unless $self->[-1] == $hub;
+        pop @$self;
+    };
+}
+
+1;
+
+__END__
+
+=pod
+
+=encoding UTF-8
+
+=head1 NAME
+
+Test2::API::Stack - Object to manage a stack of L<Test2::Hub>
+instances.
+
+=head1 ***INTERNALS NOTE***
+
+B<The internals of this package are subject to change at any time!> The public
+methods provided will not change in backwards incompatible ways, but the
+underlying implementation details might. B<Do not break encapsulation here!>
+
+=head1 DESCRIPTION
+
+This module is used to represent and manage a stack of L<Test2::Hub>
+objects. Hubs are usually in a stack so that you can push a new hub into place
+that can intercept and handle events differently than the primary hub.
+
+=head1 SYNOPSIS
+
+    my $stack = Test2::API::Stack->new;
+    my $hub = $stack->top;
+
+=head1 METHODS
+
+=over 4
+
+=item $stack = Test2::API::Stack->new()
+
+This will create a new empty stack instance. All arguments are ignored.
+
+=item $hub = $stack->new_hub()
+
+=item $hub = $stack->new_hub(%params)
+
+=item $hub = $stack->new_hub(%params, class => $class)
+
+This will generate a new hub and push it to the top of the stack. Optionally
+you can provide arguments that will be passed into the constructor for the
+L<Test2::Hub> object.
+
+If you specify the C<< 'class' => $class >> argument, the new hub will be an
+instance of the specified class.
+
+Unless your parameters specify C<'formatter'> or C<'ipc'> arguments, the
+formatter and IPC instance will be inherited from the current top hub. You can
+set the parameters to C<undef> to avoid having a formatter or IPC instance.
+
+If there is no top hub, and you do not ask to leave IPC and formatter undef,
+then a new formatter will be created, and the IPC instance from
+L<Test2::API> will be used.
+
+=item $hub = $stack->top()
+
+This will return the top hub from the stack. If there is no top hub yet this
+will create it.
+
+=item $hub = $stack->peek()
+
+This will return the top hub from the stack. If there is no top hub yet this
+will return undef.
+
+=item $stack->cull
+
+This will call C<< $hub->cull >> on all hubs in the stack.
+
+=item @hubs = $stack->all
+
+This will return all the hubs in the stack as a list.
+
+=item $stack->clear
+
+This will completely remove all hubs from the stack. Normally you do not want
+to do this, but there are a few valid reasons for it.
+
+=item $stack->push($hub)
+
+This will push the new hub onto the stack.
+
+=item $stack->pop($hub)
+
+This will pop a hub from the stack, if the hub at the top of the stack does not
+match the hub you expect (passed in as an argument) it will throw an exception.
+
+=back
+
+=head1 SOURCE
+
+The source code repository for Test2 can be found at
+L<https://github.com/Test-More/test-more/>.
+
+=head1 MAINTAINERS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 COPYRIGHT
+
+Copyright Chad Granum E<lt>exodist@cpan.orgE<gt>.
+
+This program is free software; you can redistribute it and/or
+modify it under the same terms as Perl itself.
+
+See L<https://dev.perl.org/licenses/>
+
+=cut

git/usr/share/perl5/core_perl/Test2/AsyncSubtest/Event/Attach.pm

@@ -0,0 +1,90 @@
+package Test2::AsyncSubtest::Event::Attach;
+use strict;
+use warnings;
+
+our $VERSION = '1.302210';
+
+use base 'Test2::Event';
+use Test2::Util::HashBase qw/id/;
+
+sub no_display { 1 }
+
+sub callback {
+    my $self = shift;
+    my ($hub) = @_;
+
+    my $id = $self->{+ID};
+    my $ids = $hub->ast_ids;
+
+    unless (defined $ids->{$id}) {
+        require Test2::Event::Exception;
+        my $trace = $self->trace;
+        $hub->send(
+            Test2::Event::Exception->new(
+                trace => $trace,
+                error => "Invalid AsyncSubtest attach ID: $id at " . $trace->debug . "\n",
+            )
+        );
+        return;
+    }
+
+    if ($ids->{$id}++) {
+        require Test2::Event::Exception;
+        my $trace = $self->trace;
+        $hub->send(
+            Test2::Event::Exception->new(
+                trace => $trace,
+                error => "AsyncSubtest ID $id already attached at " . $trace->debug . "\n",
+            )
+        );
+        return;
+    }
+}
+
+1;
+
+__END__
+
+=pod
+
+=encoding UTF-8
+
+=head1 NAME
+
+Test2::AsyncSubtest::Event::Attach - Event to attach a subtest to the parent.
+
+=head1 DESCRIPTION
+
+Used internally by L<Test2::AsyncSubtest>. No user serviceable parts inside.
+
+=head1 SOURCE
+
+The source code repository for Test2-AsyncSubtest can be found at
+F<https://github.com/Test-More/test-more/>.
+
+=head1 MAINTAINERS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 COPYRIGHT
+
+Copyright Chad Granum E<lt>exodist7@gmail.comE<gt>.
+
+This program is free software; you can redistribute it and/or
+modify it under the same terms as Perl itself.
+
+See F<http://dev.perl.org/licenses/>
+
+=cut

git/usr/share/perl5/core_perl/Test2/AsyncSubtest/Event/Detach.pm

@@ -0,0 +1,90 @@
+package Test2::AsyncSubtest::Event::Detach;
+use strict;
+use warnings;
+
+our $VERSION = '1.302210';
+
+use base 'Test2::Event';
+use Test2::Util::HashBase qw/id/;
+
+sub no_display { 1 }
+
+sub callback {
+    my $self = shift;
+    my ($hub) = @_;
+
+    my $id = $self->{+ID};
+    my $ids = $hub->ast_ids;
+
+    unless (defined $ids->{$id}) {
+        require Test2::Event::Exception;
+        my $trace = $self->trace;
+        $hub->send(
+            Test2::Event::Exception->new(
+                trace => $trace,
+                error => "Invalid AsyncSubtest detach ID: $id at " . $trace->debug . "\n",
+            )
+        );
+        return;
+    }
+
+    unless (delete $ids->{$id}) {
+        require Test2::Event::Exception;
+        my $trace = $self->trace;
+        $hub->send(
+            Test2::Event::Exception->new(
+                trace => $trace,
+                error => "AsyncSubtest ID $id is not attached at " . $trace->debug . "\n",
+            )
+        );
+        return;
+    }
+}
+
+1;
+
+__END__
+
+=pod
+
+=encoding UTF-8
+
+=head1 NAME
+
+Test2::AsyncSubtest::Event::Detach - Event to detach a subtest from the parent.
+
+=head1 DESCRIPTION
+
+Used internally by L<Test2::AsyncSubtest>. No user serviceable parts inside.
+
+=head1 SOURCE
+
+The source code repository for Test2-AsyncSubtest can be found at
+F<https://github.com/Test-More/test-more/>.
+
+=head1 MAINTAINERS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 COPYRIGHT
+
+Copyright Chad Granum E<lt>exodist7@gmail.comE<gt>.
+
+This program is free software; you can redistribute it and/or
+modify it under the same terms as Perl itself.
+
+See F<http://dev.perl.org/licenses/>
+
+=cut

git/usr/share/perl5/core_perl/Test2/AsyncSubtest/Formatter.pm

@@ -0,0 +1,9 @@
+package Test2::AsyncSubtest::Formatter;
+use strict;
+use warnings;
+
+our $VERSION = '1.302210';
+
+die "Should not load this anymore";
+
+1;

git/usr/share/perl5/core_perl/Test2/AsyncSubtest/Hub.pm

@@ -0,0 +1,119 @@
+package Test2::AsyncSubtest::Hub;
+use strict;
+use warnings;
+
+our $VERSION = '1.302210';
+
+use base 'Test2::Hub::Subtest';
+use Test2::Util::HashBase qw/ast_ids ast/;
+use Test2::Util qw/get_tid/;
+
+sub init {
+    my $self = shift;
+
+    $self->SUPER::init();
+
+    if (my $format = $self->format) {
+        my $hide = $format->can('hide_buffered') ? $format->hide_buffered : 1;
+        $self->format(undef) if $hide;
+    }
+}
+
+sub inherit {
+    my $self = shift;
+    my ($from, %params) = @_;
+
+    if (my $ls = $from->{+_LISTENERS}) {
+        push @{$self->{+_LISTENERS}} => grep { $_->{inherit} } @$ls;
+    }
+
+    if (my $pfs = $from->{+_PRE_FILTERS}) {
+        push @{$self->{+_PRE_FILTERS}} => grep { $_->{inherit} } @$pfs;
+    }
+
+    if (my $fs = $from->{+_FILTERS}) {
+        push @{$self->{+_FILTERS}} => grep { $_->{inherit} } @$fs;
+    }
+}
+
+sub send {
+    my $self = shift;
+    my ($e) = @_;
+
+    if (my $ast = $self->ast) {
+        if ($$ != $ast->pid || get_tid != $ast->tid) {
+            if (my $plan = $e->facet_data->{plan}) {
+                unless ($plan->{skip}) {
+                    my $trace = $e->facet_data->{trace};
+                    bless($trace, 'Test2::EventFacet::Trace');
+                    $trace->alert("A plan should not be set inside an async-subtest (did you call done_testing()?)");
+                    return;
+                }
+            }
+        }
+    }
+
+    return $self->SUPER::send($e);
+}
+
+1;
+
+__END__
+
+=pod
+
+=encoding UTF-8
+
+=head1 NAME
+
+Test2::AsyncSubtest::Hub - Hub used by async subtests.
+
+=head1 DESCRIPTION
+
+This is a subclass of L<Test2::Hub::Subtest> used for async subtests.
+
+=head1 SYNOPSIS
+
+You should not use this directly.
+
+=head1 METHODS
+
+=over 4
+
+=item $ast = $hub->ast
+
+Get the L<Test2::AsyncSubtest> object to which this hub is bound.
+
+=back
+
+=head1 SOURCE
+
+The source code repository for Test2-AsyncSubtest can be found at
+F<https://github.com/Test-More/test-more/>.
+
+=head1 MAINTAINERS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 COPYRIGHT
+
+Copyright Chad Granum E<lt>exodist7@gmail.comE<gt>.
+
+This program is free software; you can redistribute it and/or
+modify it under the same terms as Perl itself.
+
+See F<http://dev.perl.org/licenses/>
+
+=cut

git/usr/share/perl5/core_perl/Test2/Bundle/Extended.pm

@@ -0,0 +1,487 @@
+package Test2::Bundle::Extended;
+use strict;
+use warnings;
+
+use Test2::V0;
+
+our $VERSION = '1.302210';
+
+BEGIN {
+    push @Test2::Bundle::Extended::ISA => 'Test2::V0';
+    no warnings 'once';
+    *EXPORT = \@Test2::V0::EXPORT;
+}
+
+our %EXPORT_TAGS = (
+    'v1' => \@Test2::Bundle::Extended::EXPORT,
+);
+
+1;
+
+__END__
+
+=pod
+
+=encoding UTF-8
+
+=head1 NAME
+
+Test2::Bundle::Extended - Old name for Test2::V0
+
+=head1 *** DEPRECATED ***
+
+This bundle has been renamed to L<Test2::V0>, in which the C<':v1'> tag has
+been removed as unnecessary.
+
+=head1 DESCRIPTION
+
+This is the big-daddy bundle. This bundle includes nearly every tool, and
+several plugins, that the Test2 author uses. This bundle is used
+extensively to test L<Test2::Suite> itself.
+
+=head1 SYNOPSIS
+
+    use Test2::Bundle::Extended ':v1';
+
+    ok(1, "pass");
+
+    ...
+
+    done_testing;
+
+=head1 RESOLVING CONFLICTS WITH MOOSE
+
+    use Test2::Bundle::Extended '!meta';
+
+L<Moose> and L<Test2::Bundle::Extended> both export very different C<meta()>
+subs. Adding C<'!meta'> to the import args will prevent the sub from being
+imported. This bundle also exports the sub under the name C<meta_check()> so
+you can use that spelling as an alternative.
+
+=head2 TAGS
+
+=over 4
+
+=item :v1
+
+=item :DEFAULT
+
+The following are all identical:
+
+    use Test2::Bundle::Extended;
+
+    use Test2::Bundle::Extended ':v1';
+
+    use Test2::Bundle::Extended ':DEFAULT';
+
+=back
+
+=head2 RENAMING ON IMPORT
+
+    use Test2::Bundle::Extended ':v1', '!ok', ok => {-as => 'my_ok'};
+
+This bundle uses L<Importer> for exporting, as such you can use any arguments
+it accepts.
+
+Explanation:
+
+=over 4
+
+=item ':v1'
+
+Use the default tag, all default exports.
+
+=item '!ok'
+
+Do not export C<ok()>
+
+=item ok => {-as => 'my_ok'}
+
+Actually, go ahead and import C<ok()> but under the name C<my_ok()>.
+
+=back
+
+If you did not add the C<'!ok'> argument then you would have both C<ok()> and
+C<my_ok()>
+
+=head1 PRAGMAS
+
+All of these can be disabled via individual import arguments, or by the
+C<-no_pragmas> argument.
+
+    use Test2::Bundle::Extended -no_pragmas => 1;
+
+=head2 STRICT
+
+L<strict> is turned on for you. You can disable this with the C<-no_strict> or
+C<-no_pragmas> import arguments:
+
+    use Test2::Bundle::Extended -no_strict => 1;
+
+=head2 WARNINGS
+
+L<warnings> are turned on for you. You can disable this with the
+C<-no_warnings> or C<-no_pragmas> import arguments:
+
+    use Test2::Bundle::Extended -no_warnings => 1;
+
+=head2 UTF8
+
+This is actually done via the L<Test2::Plugin::UTF8> plugin, see the
+L</PLUGINS> section for details.
+
+B<Note:> C<< -no_pragmas => 1 >> will turn off the entire plugin.
+
+=head1 PLUGINS
+
+=head2 SRAND
+
+See L<Test2::Plugin::SRand>.
+
+This will set the random seed to today's date. You can provide an alternate seed
+with the C<-srand> import option:
+
+    use Test2::Bundle::Extended -srand => 1234;
+
+=head2 UTF8
+
+See L<Test2::Plugin::UTF8>.
+
+This will set the file, and all output handles (including formatter handles), to
+utf8. This will turn on the utf8 pragma for the current scope.
+
+This can be disabled using the C<< -no_utf8 => 1 >> or C<< -no_pragmas => 1 >>
+import arguments.
+
+    use Test2::Bundle::Extended -no_utf8 => 1;
+
+=head2 EXIT SUMMARY
+
+See L<Test2::Plugin::ExitSummary>.
+
+This plugin has no configuration.
+
+=head1 API FUNCTIONS
+
+See L<Test2::API> for these
+
+=over 4
+
+=item $ctx = context()
+
+=item $events = intercept { ... }
+
+=back
+
+=head1 TOOLS
+
+=head2 TARGET
+
+See L<Test2::Tools::Target>.
+
+You can specify a target class with the C<-target> import argument. If you do
+not provide a target then C<$CLASS> and C<CLASS()> will not be imported.
+
+    use Test2::Bundle::Extended -target => 'My::Class';
+
+    print $CLASS;  # My::Class
+    print CLASS(); # My::Class
+
+Or you can specify names:
+
+    use Test2::Bundle::Extended -target => { pkg => 'Some::Package' };
+
+    pkg()->xxx; # Call 'xxx' on Some::Package
+    $pkg->xxx;  # Same
+
+=over 4
+
+=item $CLASS
+
+Package variable that contains the target class name.
+
+=item $class = CLASS()
+
+Constant function that returns the target class name.
+
+=back
+
+=head2 DEFER
+
+See L<Test2::Tools::Defer>.
+
+=over 4
+
+=item def $func => @args;
+
+=item do_def()
+
+=back
+
+=head2 BASIC
+
+See L<Test2::Tools::Basic>.
+
+=over 4
+
+=item ok($bool, $name)
+
+=item pass($name)
+
+=item fail($name)
+
+=item diag($message)
+
+=item note($message)
+
+=item $todo = todo($reason)
+
+=item todo $reason => sub { ... }
+
+=item skip($reason, $count)
+
+=item plan($count)
+
+=item skip_all($reason)
+
+=item done_testing()
+
+=item bail_out($reason)
+
+=back
+
+=head2 COMPARE
+
+See L<Test2::Tools::Compare>.
+
+=over 4
+
+=item is($got, $want, $name)
+
+=item isnt($got, $do_not_want, $name)
+
+=item like($got, qr/match/, $name)
+
+=item unlike($got, qr/mismatch/, $name)
+
+=item $check = match(qr/pattern/)
+
+=item $check = mismatch(qr/pattern/)
+
+=item $check = validator(sub { return $bool })
+
+=item $check = hash { ... }
+
+=item $check = array { ... }
+
+=item $check = bag { ... }
+
+=item $check = object { ... }
+
+=item $check = meta { ... }
+
+=item $check = number($num)
+
+=item $check = string($str)
+
+=item $check = check_isa($class_name)
+
+=item $check = in_set(@things)
+
+=item $check = not_in_set(@things)
+
+=item $check = check_set(@things)
+
+=item $check = item($thing)
+
+=item $check = item($idx => $thing)
+
+=item $check = field($name => $val)
+
+=item $check = call($method => $expect)
+
+=item $check = call_list($method => $expect)
+
+=item $check = call_hash($method => $expect)
+
+=item $check = prop($name => $expect)
+
+=item $check = check($thing)
+
+=item $check = T()
+
+=item $check = F()
+
+=item $check = D()
+
+=item $check = DF()
+
+=item $check = E()
+
+=item $check = DNE()
+
+=item $check = FDNE()
+
+=item $check = U()
+
+=item $check = L()
+
+=item $check = exact_ref($ref)
+
+=item end()
+
+=item etc()
+
+=item filter_items { grep { ... } @_ }
+
+=item $check = event $type => ...
+
+=item @checks = fail_events $type => ...
+
+=back
+
+=head2 CLASSIC COMPARE
+
+See L<Test2::Tools::ClassicCompare>.
+
+=over 4
+
+=item cmp_ok($got, $op, $want, $name)
+
+=back
+
+=head2 SUBTEST
+
+See L<Test2::Tools::Subtest>.
+
+=over 4
+
+=item subtest $name => sub { ... }
+
+(Note: This is called C<subtest_buffered()> in the Tools module.)
+
+=back
+
+=head2 CLASS
+
+See L<Test2::Tools::Class>.
+
+=over 4
+
+=item can_ok($thing, @methods)
+
+=item isa_ok($thing, @classes)
+
+=item DOES_ok($thing, @roles)
+
+=back
+
+=head2 ENCODING
+
+See L<Test2::Tools::Encoding>.
+
+=over 4
+
+=item set_encoding($encoding)
+
+=back
+
+=head2 EXPORTS
+
+See L<Test2::Tools::Exports>.
+
+=over 4
+
+=item imported_ok('function', '$scalar', ...)
+
+=item not_imported_ok('function', '$scalar', ...)
+
+=back
+
+=head2 REF
+
+See L<Test2::Tools::Ref>.
+
+=over 4
+
+=item ref_ok($ref, $type)
+
+=item ref_is($got, $want)
+
+=item ref_is_not($got, $do_not_want)
+
+=back
+
+=head2 MOCK
+
+See L<Test2::Tools::Mock>.
+
+=over 4
+
+=item $control = mock ...
+
+=item $bool = mocked($thing)
+
+=back
+
+=head2 EXCEPTION
+
+See L<Test2::Tools::Exception>.
+
+=over 4
+
+=item $exception = dies { ... }
+
+=item $bool = lives { ... }
+
+=item $bool = try_ok { ... }
+
+=back
+
+=head2 WARNINGS
+
+See L<Test2::Tools::Warnings>.
+
+=over 4
+
+=item $count = warns { ... }
+
+=item $warning = warning { ... }
+
+=item $warnings_ref = warnings { ... }
+
+=item $bool = no_warnings { ... }
+
+=back
+
+=head1 SOURCE
+
+The source code repository for Test2-Suite can be found at
+F<https://github.com/Test-More/test-more/>.
+
+=head1 MAINTAINERS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 COPYRIGHT
+
+Copyright Chad Granum E<lt>exodist@cpan.orgE<gt>.
+
+This program is free software; you can redistribute it and/or
+modify it under the same terms as Perl itself.
+
+See F<http://dev.perl.org/licenses/>
+
+=cut

git/usr/share/perl5/core_perl/Test2/Bundle/More.pm

@@ -0,0 +1,241 @@
+package Test2::Bundle::More;
+use strict;
+use warnings;
+
+our $VERSION = '1.302210';
+
+use Test2::Plugin::ExitSummary;
+
+use Test2::Tools::Basic qw{
+    ok pass fail skip todo diag note
+    plan skip_all done_testing bail_out
+};
+
+use Test2::Tools::ClassicCompare qw{
+    is is_deeply isnt like unlike cmp_ok
+};
+
+use Test2::Tools::Class qw/can_ok isa_ok/;
+use Test2::Tools::Subtest qw/subtest_streamed/;
+
+BEGIN {
+    *BAIL_OUT = \&bail_out;
+    *subtest  = \&subtest_streamed;
+}
+
+our @EXPORT = qw{
+    ok pass fail skip todo diag note
+    plan skip_all done_testing BAIL_OUT
+
+    is isnt like unlike is_deeply cmp_ok
+
+    isa_ok can_ok
+
+    subtest
+};
+use base 'Exporter';
+
+1;
+
+__END__
+
+=pod
+
+=encoding UTF-8
+
+=head1 NAME
+
+Test2::Bundle::More - ALMOST a drop-in replacement for Test::More.
+
+=head1 DESCRIPTION
+
+This bundle is intended to be a (mostly) drop-in replacement for
+L<Test::More>. See L<"KEY DIFFERENCES FROM Test::More"> for details.
+
+=head1 SYNOPSIS
+
+    use Test2::Bundle::More;
+
+    ok(1, "pass");
+
+    ...
+
+    done_testing;
+
+=head1 PLUGINS
+
+This loads L<Test2::Plugin::ExitSummary>.
+
+=head1 TOOLS
+
+These are from L<Test2::Tools::Basic>. See L<Test2::Tools::Basic> for details.
+
+=over 4
+
+=item ok($bool, $name)
+
+=item pass($name)
+
+=item fail($name)
+
+=item skip($why, $count)
+
+=item $todo = todo($why)
+
+=item diag($message)
+
+=item note($message)
+
+=item plan($count)
+
+=item skip_all($why)
+
+=item done_testing()
+
+=item BAIL_OUT($why)
+
+=back
+
+These are from L<Test2::Tools::ClassicCompare>. See
+L<Test2::Tools::ClassicCompare> for details.
+
+=over 4
+
+=item is($got, $want, $name)
+
+=item isnt($got, $donotwant, $name)
+
+=item like($got, qr/match/, $name)
+
+=item unlike($got, qr/mismatch/, $name)
+
+=item is_deeply($got, $want, "Deep compare")
+
+=item cmp_ok($got, $op, $want, $name)
+
+=back
+
+These are from L<Test2::Tools::Class>. See L<Test2::Tools::Class> for details.
+
+=over 4
+
+=item isa_ok($thing, @classes)
+
+=item can_ok($thing, @subs)
+
+=back
+
+This is from L<Test2::Tools::Subtest>. It is called C<subtest_streamed()> in
+that package.
+
+=over 4
+
+=item subtest $name => sub { ... }
+
+=back
+
+=head1 KEY DIFFERENCES FROM Test::More
+
+=over 4
+
+=item You cannot plan at import.
+
+THIS WILL B<NOT> WORK:
+
+    use Test2::Bundle::More tests => 5;
+
+Instead you must plan in a separate statement:
+
+    use Test2::Bundle::More;
+    plan 5;
+
+=item You have three subs imported for use in planning
+
+Use C<plan($count)>, C<skip_all($reason)>, or C<done_testing()> for your
+planning.
+
+=item isa_ok accepts different arguments
+
+C<isa_ok> in Test::More was:
+
+    isa_ok($thing, $isa, $alt_thing_name);
+
+This was very inconsistent with tools like C<can_ok($thing, @subs)>.
+
+In Test2::Bundle::More, C<isa_ok()> takes a C<$thing> and a list of C<@isa>.
+
+    isa_ok($thing, $class1, $class2, ...);
+
+=back
+
+=head2 THESE FUNCTIONS AND VARIABLES HAVE BEEN REMOVED
+
+=over 4
+
+=item $TODO
+
+See C<todo()>.
+
+=item use_ok()
+
+=item require_ok()
+
+These are not necessary. Use C<use> and C<require> directly. If there is an
+error loading the module the test will catch the error and fail.
+
+=item todo_skip()
+
+Not necessary.
+
+=item eq_array()
+
+=item eq_hash()
+
+=item eq_set()
+
+Discouraged in Test::More.
+
+=item explain()
+
+This started a fight between Test developers, who may now each write their own
+implementations in L<Test2>. (See explain in L<Test::Most> vs L<Test::More>.
+Hint: Test::Most wrote it first, then Test::More added it, but broke
+compatibility).
+
+=item new_ok()
+
+Not necessary.
+
+=back
+
+=head1 SOURCE
+
+The source code repository for Test2-Suite can be found at
+F<https://github.com/Test-More/test-more/>.
+
+=head1 MAINTAINERS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 COPYRIGHT
+
+Copyright Chad Granum E<lt>exodist@cpan.orgE<gt>.
+
+This program is free software; you can redistribute it and/or
+modify it under the same terms as Perl itself.
+
+See F<http://dev.perl.org/licenses/>
+
+=cut