File Coverage

blib/lib/Math/Int64.pm

Criterion	Covered	Total	%
statement	40	43	93.0
branch	6	8	75.0
condition	5	9	55.5
subroutine	11	11	100.0
pod			n/a
total	62	71	87.3

package Math::Int64;

use strict;
use warnings;

BEGIN {
our $VERSION = '0.54';
require XSLoader;
XSLoader::load('Math::Int64', $VERSION);
}

use warnings::register;

use constant MAX_INT64  => string_to_int64 ( '0x7fff_ffff_ffff_ffff');
use constant MIN_INT64  => string_to_int64 ('-0x8000_0000_0000_0000');
use constant MAX_UINT64 => string_to_uint64( '0xffff_ffff_ffff_ffff');

require Exporter;
our @ISA = qw(Exporter);
our @EXPORT_OK = qw(int64
                    int64_to_number
                    net_to_int64 int64_to_net
                    native_to_int64 int64_to_native
                    string_to_int64 hex_to_int64
                    BER_to_int64 int64_to_BER
                    int64_to_string int64_to_hex
                    int64_rand
                    int64_srand
                    uint64
                    uint64_to_number
                    net_to_uint64 uint64_to_net
                    native_to_uint64 uint64_to_native
                    string_to_uint64 hex_to_uint64
                    BER_to_uint64 uint64_to_BER
                    uint64_to_string uint64_to_hex
                    uint64_rand
                    BER_length
                    MAX_INT64 MIN_INT64 MAX_UINT64
                  );

my %available_pragmas = map { $_ => 1 } qw(native_if_available
                                           die_on_overflow);

sub import {
    my $pkg = shift;
    my (%pragmas, @subs, %native);
    for (@_) {
        if ($_ =~ /^:(.*)/ and $available_pragmas{$1}) {
            $pragmas{$1} = 1
        }
        else {
            push @subs, $_;
        }
    }

    if ($pragmas{die_on_overflow}) {
        require Math::Int64::die_on_overflow;
        Math::Int64::die_on_overflow->import;
    }

    if ($pragmas{native_if_available}) {
        require Math::Int64::native_if_available;
        Math::Int64::native_if_available->import;
    }

    Math::Int64->export_to_level(1, $pkg, @subs);
}

sub _check_pragma_compatibility {
    if ($^H{'Math::Int64::native_if_available'} and
        $^H{'Math::Int64::die_on_overflow'} and
        warnings::enabled()) {
        warnings::warn("Math::Int64::die_on_overflow pragma is useless when Math::Int64::native_if_available is also active");
    }
    1;
}

use overload ( '+' => \&_add,
               '+=' => \&_add,
               '-' => \&_sub,
               '-=' => \&_sub,
               '*' => \&_mul,
               '*=' => \&_mul,
               '**' => \&_pow,
               '**=' => \&_pow,
               '/' => \&_div,
               '/=' => \&_div,
               '%' => \&_rest,
               '%=' => \&_rest,
               'neg' => \&_neg,
               '++' => \&_inc,
               '--' => \&_dec,
               '!' => \&_not,
               '~' => \&_bnot,
               '&' => \&_and,
               '|' => \&_or,
               '^' => \&_xor,
               '<<' => \&_left,
               '>>' => \&_right,
               '<=>' => \&_spaceship,
               '>' => \&_gtn,
               '<' => \&_ltn,
               '>=' => \&_gen,
               '<=' => \&_len,
               '==' => \&_eqn,
               '!=' => \&_nen,
               'bool' => \&_bool,
               '0+' => \&_number,
               '""' => \&_string,
               '=' => \&_clone,
               fallback => 1 );

package # hide from PAUSE since it also has its own .pm file
    Math::UInt64;
use overload ( '+' => \&_add,
               '+=' => \&_add,
               '-' => \&_sub,
               '-=' => \&_sub,
               '*' => \&_mul,
               '*=' => \&_mul,
               '**' => \&_pow,
               '**=' => \&_pow,
               '/' => \&_div,
               '/=' => \&_div,
               '%' => \&_rest,
               '%=' => \&_rest,
               'neg' => \&_neg,
               '++' => \&_inc,
               '--' => \&_dec,
               '!' => \&_not,
               '~' => \&_bnot,
               '&' => \&_and,
               '|' => \&_or,
               '^' => \&_xor,
               '<<' => \&_left,
               '>>' => \&_right,
               '<=>' => \&_spaceship,
               '>' => \&_gtn,
               '<' => \&_ltn,
               '>=' => \&_gen,
               '<=' => \&_len,
               '==' => \&_eqn,
               '!=' => \&_nen,
               'bool' => \&_bool,
               '0+' => \&_number,
               '""' => \&_string,
               '=' => \&_clone,
               fallback => 1 );

1;

# ABSTRACT: Manipulate 64 bits integers in Perl

__END__