From: Tels Date: Sat, 16 Jun 2007 14:33:47 +0000 (+0200) Subject: bignum 0.22 take 4 (hex()/oct() overloading) X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=commitdiff_plain;h=d1a15766ff5cdfaf84d91442a68bc2a05880bf12;p=p5sagit%2Fp5-mst-13.2.git bignum 0.22 take 4 (hex()/oct() overloading) Message-Id: <200706161433.47489@bloodgate.com> p4raw-id: //depot/perl@31403 --- diff --git a/lib/bigint.pm b/lib/bigint.pm index 26b8b2f..c64116a 100644 --- a/lib/bigint.pm +++ b/lib/bigint.pm @@ -117,12 +117,55 @@ sub in_effect $hinthash->{bigint}; } +############################################################################# +# the following two routines are for "use bigint qw/hex oct/;": + +sub _hex_global + { + my $i = $_[0]; + $i = '0x'.$i unless $i =~ /^0x/; + Math::BigInt->new($i); + } + +sub _oct_global + { + my $i = $_[0]; + return Math::BigInt->from_oct($i) if $i =~ /^0[0-7]/; + Math::BigInt->new($i); + } + +############################################################################# +# the following two routines are for Perl 5.9.4 or later and are lexical + +sub _hex + { + return CORE::hex($_[0]) unless in_effect(1); + my $i = $_[0]; + $i = '0x'.$i unless $i =~ /^0x/; + Math::BigInt->new($i); + } + +sub _oct + { + return CORE::oct($_[0]) unless in_effect(1); + my $i = $_[0]; + return Math::BigInt->from_oct($i) if $i =~ /^0[0-7]/; + Math::BigInt->new($i); + } + sub import { my $self = shift; $^H{bigint} = 1; # we are in effect + # for newer Perls always override hex() and oct() with a lexical version: + if ($] > 5.009004) + { + no warnings 'redefine'; + *CORE::GLOBAL::oct = \&_oct; + *CORE::GLOBAL::hex = \&_hex; + } # some defaults my $lib = ''; my $lib_kind = 'try'; @@ -162,6 +205,18 @@ sub import $trace = 1; splice @a, $j, 1; $j --; } + elsif ($_[$i] eq 'hex') + { + splice @a, $j, 1; $j --; + no warnings 'redefine'; + *CORE::GLOBAL::hex = \&_hex_global; + } + elsif ($_[$i] eq 'oct') + { + splice @a, $j, 1; $j --; + no warnings 'redefine'; + *CORE::GLOBAL::oct = \&_oct_global; + } else { die "unknown option $_[$i]"; } } my $class; @@ -236,12 +291,18 @@ bigint - Transparent BigInteger support for Perl print 2 ** 512,"\n"; # really is what you think it is print inf + 42,"\n"; # inf print NaN * 7,"\n"; # NaN + print hex("0x1234567890123490"),"\n"; # Perl v5.9.4 or later { no bigint; print 2 ** 256,"\n"; # a normal Perl scalar now } + # Note that this will be global: + use bigint qw/hex oct/; + print hex("0x1234567890123490"),"\n"; + print oct("01234567890123490"),"\n"; + =head1 DESCRIPTION All operators (including basic math operations) are overloaded. Integer @@ -272,9 +333,9 @@ some functions. C truncates these results to integer too: 2 # perl -Mbigint -wle 'print exp(1)' 2 - # perl -Mbigint -wle 'print exp(1)' + # perl -Minteger -wle 'print exp(1)' 2.71828182845905 - # perl -Mbigint -wle 'print exp(1) + 0' + # perl -Minteger -wle 'print exp(1) + 0' 2 In practice this makes seldom a difference as B of @@ -322,6 +383,18 @@ Note that setting precision and accurary at the same time is not possible. This enables a trace mode and is primarily for debugging bigint or Math::BigInt. +=item hex + +Override the build-in hex() method with a version that can handle big +integers. Note that under Perl v5.9.4 or ealier, this will be global +and cannot be disabled with "no bigint;". + +=item oct + +Override the build-in oct() method with a version that can handle big +integers. Note that under Perl v5.9.4 or ealier, this will be global +and cannot be disabled with "no bigint;". + =item l, lib, try or only Load a different math lib, see L. @@ -472,6 +545,41 @@ Using methods that do not modify, but testthe contents works: See the documentation about the copy constructor and C<=> in overload, as well as the documentation in BigInt for further details. +=head1 CAVAETS + +=over 2 + +=item in_effect() + +This method only works on Perl v5.9.4 or later. + +=item hex()/oct() + +C overrides these routines with versions that can also handle +big integer values. Under Perl prior to version v5.9.4, however, this +will not happen unless you specifically ask for it with the two +import tags "hex" and "oct" - and then it will be global and cannot be +disabled inside a scope with "no bigint": + + use bigint qw/hex oct/; + + print hex("0x1234567890123456"); + { + no bigint; + print hex("0x1234567890123456"); + } + +The second call to hex() will warn about a non-portable constant. + +Compare this to: + + use bigint; + + # will warn only under Perl older than v5.9.4 + print hex("0x1234567890123456"); + +=back + =head1 MODULES USED C is just a thin wrapper around various modules of the Math::BigInt diff --git a/lib/bignum.pm b/lib/bignum.pm index 3d79c52..4323356 100644 --- a/lib/bignum.pm +++ b/lib/bignum.pm @@ -3,15 +3,22 @@ use 5.006002; $VERSION = '0.22'; use Exporter; +@ISA = qw( bigint ); @EXPORT_OK = qw( ); @EXPORT = qw( inf NaN ); -@ISA = qw( Exporter ); use strict; use overload; +require bigint; # no "use" to avoid import being called ############################################################################## +BEGIN + { + *inf = \&bigint::inf; + *NaN = \&bigint::NaN; + } + # These are all alike, and thus faked by AUTOLOAD my @faked = qw/round_mode accuracy precision div_scale/; @@ -47,24 +54,6 @@ sub AUTOLOAD Carp::croak ("Can't call bignum\-\>$name, not a valid method"); } -sub upgrade - { - $Math::BigInt::upgrade; - } - -sub _binary_constant - { - # this takes a binary/hexadecimal/octal constant string and returns it - # as string suitable for new. Basically it converts octal to decimal, and - # passes every thing else unmodified back. - my $string = shift; - - return Math::BigInt->new($string) if $string =~ /^0[bx]/; - - # so it must be an octal constant - Math::BigInt->from_oct($string); - } - sub unimport { $^H{bignum} = undef; # no longer in effect @@ -78,12 +67,39 @@ sub in_effect $hinthash->{bignum}; } +############################################################################# +# the following two routines are for Perl 5.9.4 or later and are lexical + +sub _hex + { + return CORE::hex($_[0]) unless in_effect(1); + my $i = $_[0]; + $i = '0x'.$i unless $i =~ /^0x/; + Math::BigInt->new($i); + } + +sub _oct + { + return CORE::oct($_[0]) unless in_effect(1); + my $i = $_[0]; + return Math::BigInt->from_oct($i) if $i =~ /^0[0-7]/; + Math::BigInt->new($i); + } + sub import { my $self = shift; $^H{bignum} = 1; # we are in effect + # for newer Perls override hex() and oct() with a lexical version: + if ($] > 5.009003) + { + no warnings 'redefine'; + *CORE::GLOBAL::oct = \&_oct; + *CORE::GLOBAL::hex = \&_hex; + } + # some defaults my $lib = ''; my $lib_kind = 'try'; my $upgrade = 'Math::BigFloat'; @@ -139,6 +155,20 @@ sub import $trace = 1; splice @a, $j, 1; $j --; } + elsif ($_[$i] eq 'hex') + { + splice @a, $j, 1; $j --; + no warnings 'redefine'; + # override with a global version + *CORE::GLOBAL::hex = \&bigint::_hex_global; + } + elsif ($_[$i] eq 'oct') + { + splice @a, $j, 1; $j --; + no warnings 'redefine'; + # override with a global version + *CORE::GLOBAL::oct = \&bigint::_oct_global; + } else { die "unknown option $_[$i]"; } } my $class; @@ -193,7 +223,7 @@ sub import } # Take care of octal/hexadecimal constants - overload::constant binary => sub { _binary_constant(shift) }; + overload::constant binary => sub { bigint::_binary_constant(shift) }; # if another big* was already loaded: my ($package) = caller(); @@ -205,9 +235,6 @@ sub import } } -sub inf () { Math::BigInt->binf(); } -sub NaN () { Math::BigInt->bnan(); } - 1; __END__ @@ -230,6 +257,11 @@ bignum - Transparent BigNumber support for Perl print 2 ** 256,"\n"; # a normal Perl scalar now } + # for older Perls, note that this will be global: + use bignum qw/hex oct/; + print hex("0x1234567890123490"),"\n"; + print oct("01234567890123490"),"\n"; + =head1 DESCRIPTION All operators (including basic math operations) are overloaded. Integer and @@ -274,16 +306,16 @@ Since numbers are actually objects, you can call all the usual methods from BigInt/BigFloat on them. This even works to some extent on expressions: perl -Mbignum -le '$x = 1234; print $x->bdec()' - perl -Mbignum -le 'print 1234->binc();' - perl -Mbignum -le 'print 1234->binc->badd(6);' - perl -Mbignum -le 'print +(1234)->binc()' + perl -Mbignum -le 'print 1234->copy()->binc();' + perl -Mbignum -le 'print 1234->copy()->binc->badd(6);' + perl -Mbignum -le 'print +(1234)->copy()->binc()' (Note that print doesn't do what you expect if the expression starts with '(' hence the C<+>) You can even chain the operations together as usual: - perl -Mbignum -le 'print 1234->binc->badd(6);' + perl -Mbignum -le 'print 1234->copy()->binc->badd(6);' 1241 Under bignum (or bigint or bigrat), Perl will "upgrade" the numbers @@ -308,9 +340,7 @@ There is also C which gives you big rationals: 12381/10 The entire upgrading/downgrading is still experimental and might not work -as you expect or may even have bugs. - -You might get errors like this: +as you expect or may even have bugs. You might get errors like this: Can't use an undefined value as an ARRAY reference at /usr/local/lib/perl5/5.8.0/Math/BigInt/Calc.pm line 864 @@ -377,6 +407,18 @@ line. This means the following does not work: This will be hopefully fixed soon ;) +=item hex + +Override the build-in hex() method with a version that can handle big +integers. Note that under Perl older than v5.9.4, this will be global +and cannot be disabled with "no bigint;". + +=item oct + +Override the build-in oct() method with a version that can handle big +integers. Note that under Perl older than v5.9.4, this will be global +and cannot be disabled with "no bigint;". + =item v or version This prints out the name and version of all modules used and then exits. @@ -424,7 +466,7 @@ B the original and the copy being destroyed: $x = 9; $y = $x; print $x->bmul(2), " ", $y,"\n"; # prints 18 18 -Using methods that do not modify, but testthe contents works: +Using methods that do not modify, but test the contents works: $x = 9; $y = $x; $z = 9 if $x->is_zero(); # works fine @@ -515,6 +557,41 @@ numbers or as a result of 0/0. '+inf' and '-inf' represent plus respectively minus infinity. You will get '+inf' when dividing a positive number by 0, and '-inf' when dividing any negative number by 0. +=head1 CAVAETS + +=over 2 + +=item in_effect() + +This method only works on Perl v5.9.4 or later. + +=item hex()/oct() + +C overrides these routines with versions that can also handle +big integer values. Under Perl prior to version v5.9.4, however, this +will not happen unless you specifically ask for it with the two +import tags "hex" and "oct" - and then it will be global and cannot be +disabled inside a scope with "no bigint": + + use bigint qw/hex oct/; + + print hex("0x1234567890123456"); + { + no bigint; + print hex("0x1234567890123456"); + } + +The second call to hex() will warn about a non-portable constant. + +Compare this to: + + use bigint; + + # will warn only under older than v5.9.4 + print hex("0x1234567890123456"); + +=back + =head1 MODULES USED C is just a thin wrapper around various modules of the Math::BigInt diff --git a/lib/bignum/t/bigint.t b/lib/bignum/t/bigint.t index 03fb11b..baf76a3 100755 --- a/lib/bignum/t/bigint.t +++ b/lib/bignum/t/bigint.t @@ -10,10 +10,10 @@ BEGIN $| = 1; chdir 't' if -d 't'; unshift @INC, '../lib'; - plan tests => 36; + plan tests => 51; } -use bigint; +use bigint qw/hex oct/; ############################################################################### # _constant tests @@ -88,6 +88,29 @@ ok (bigint->round_mode('odd'),'odd'); ok (bigint->round_mode(),'odd'); ############################################################################### +# hex() and oct() + +my $c = 'Math::BigInt'; + +ok (ref(hex(1)), $c); +ok (ref(hex(0x1)), $c); +ok (ref(hex("af")), $c); +ok (hex("af"), Math::BigInt->new(0xaf)); +ok (ref(hex("0x1")), $c); + +ok (ref(oct("0x1")), $c); +ok (ref(oct("01")), $c); +ok (ref(oct("0b01")), $c); +ok (ref(oct("1")), $c); +ok (ref(oct(" 1")), $c); +ok (ref(oct(" 0x1")), $c); + +ok (ref(oct(0x1)), $c); +ok (ref(oct(01)), $c); +ok (ref(oct(0b01)), $c); +ok (ref(oct(1)), $c); + +############################################################################### ############################################################################### # Perl 5.005 does not like ok ($x,undef) diff --git a/lib/bignum/t/bignum.t b/lib/bignum/t/bignum.t index ee5b8d4..fe299a2 100755 --- a/lib/bignum/t/bignum.t +++ b/lib/bignum/t/bignum.t @@ -10,10 +10,10 @@ BEGIN $| = 1; chdir 't' if -d 't'; unshift @INC, '../lib'; - plan tests => 20; + plan tests => 35; } -use bignum; +use bignum qw/oct hex/; ############################################################################### # general tests @@ -59,6 +59,29 @@ ok (bignum->round_mode('odd'),'odd'); ok (bignum->round_mode(),'odd'); ############################################################################### +# hex() and oct() + +my $c = 'Math::BigInt'; + +ok (ref(hex(1)), $c); +ok (ref(hex(0x1)), $c); +ok (ref(hex("af")), $c); +ok (hex("af"), Math::BigInt->new(0xaf)); +ok (ref(hex("0x1")), $c); + +ok (ref(oct("0x1")), $c); +ok (ref(oct("01")), $c); +ok (ref(oct("0b01")), $c); +ok (ref(oct("1")), $c); +ok (ref(oct(" 1")), $c); +ok (ref(oct(" 0x1")), $c); + +ok (ref(oct(0x1)), $c); +ok (ref(oct(01)), $c); +ok (ref(oct(0b01)), $c); +ok (ref(oct(1)), $c); + +############################################################################### ############################################################################### # Perl 5.005 does not like ok ($x,undef) diff --git a/lib/bignum/t/bigrat.t b/lib/bignum/t/bigrat.t index c8162fc..972b83c 100755 --- a/lib/bignum/t/bigrat.t +++ b/lib/bignum/t/bigrat.t @@ -10,10 +10,10 @@ BEGIN $| = 1; chdir 't' if -d 't'; unshift @INC, '../lib'; - plan tests => 25; + plan tests => 40; } -use bigrat; +use bigrat qw/oct hex/; ############################################################################### # general tests @@ -63,6 +63,29 @@ ok (bigrat->round_mode('odd'),'odd'); ok (bigrat->round_mode(),'odd'); ############################################################################### +# hex() and oct() + +my $c = 'Math::BigInt'; + +ok (ref(hex(1)), $c); +ok (ref(hex(0x1)), $c); +ok (ref(hex("af")), $c); +ok (hex("af"), Math::BigInt->new(0xaf)); +ok (ref(hex("0x1")), $c); + +ok (ref(oct("0x1")), $c); +ok (ref(oct("01")), $c); +ok (ref(oct("0b01")), $c); +ok (ref(oct("1")), $c); +ok (ref(oct(" 1")), $c); +ok (ref(oct(" 0x1")), $c); + +ok (ref(oct(0x1)), $c); +ok (ref(oct(01)), $c); +ok (ref(oct(0b01)), $c); +ok (ref(oct(1)), $c); + +############################################################################### ############################################################################### # Perl 5.005 does not like ok ($x,undef) diff --git a/lib/bignum/t/in_effect.t b/lib/bignum/t/in_effect.t index d2545e4..b163f12 100644 --- a/lib/bignum/t/in_effect.t +++ b/lib/bignum/t/in_effect.t @@ -23,7 +23,7 @@ can_ok ('bignum', qw/in_effect/); can_ok ('bigrat', qw/in_effect/); SKIP: { - skip ('Need at least Perl v5.9.4', 3) unless $] > 5.009004; + skip ('Need at least Perl v5.9.4', 3) if $] < "5.009005"; is (bigint::in_effect(), 1, 'bigint in effect'); is (bignum::in_effect(), 1, 'bignum in effect'); diff --git a/lib/bignum/t/scope_f.t b/lib/bignum/t/scope_f.t index e2d4417..dd748e1 100644 --- a/lib/bignum/t/scope_f.t +++ b/lib/bignum/t/scope_f.t @@ -1,7 +1,7 @@ #!/usr/bin/perl -w ############################################################################### -# Test no bignum; +# Test "no bignum;" and overloading of hex()/oct() for newer Perls use Test::More; use strict; @@ -11,20 +11,31 @@ BEGIN $| = 1; chdir 't' if -d 't'; unshift @INC, '../lib'; - plan tests => 6; + plan tests => 10; } +# no :hex and :oct means these do not get overloaded for older Perls: use bignum; isnt (ref(1), '', 'is in effect'); isnt (ref(2.0), '', 'is in effect'); isnt (ref(0x20), '', 'is in effect'); +SKIP: { + skip ('Need at least Perl v5.9.4', 2) if $] < 5.009004; + + is (ref(hex(9)), 'Math::BigInt', 'hex is overloaded'); + is (ref(oct(07)), 'Math::BigInt', 'oct is overloaded'); + } + { no bignum; is (ref(1), '', 'is not in effect'); is (ref(2.0), '', 'is not in effect'); is (ref(0x20), '', 'is not in effect'); + + isnt (ref(hex(9)), 'Math::BigInt', 'hex is not overloaded'); + isnt (ref(oct(07)), 'Math::BigInt', 'oct is not overloaded'); } diff --git a/lib/bignum/t/scope_i.t b/lib/bignum/t/scope_i.t index d663401..4e2f1e6 100644 --- a/lib/bignum/t/scope_i.t +++ b/lib/bignum/t/scope_i.t @@ -1,7 +1,7 @@ #!/usr/bin/perl -w ############################################################################### -# Test no bigint; +# Test "no bigint;" and overloading of hex()/oct() for newer Perls use Test::More; use strict; @@ -11,20 +11,32 @@ BEGIN $| = 1; chdir 't' if -d 't'; unshift @INC, '../lib'; - plan tests => 6; + plan tests => 10; } +# no :hex and :oct means these do not get overloaded for older Perls: use bigint; isnt (ref(1), '', 'is in effect'); isnt (ref(2.0), '', 'is in effect'); isnt (ref(0x20), '', 'is in effect'); +SKIP: { + skip ('Need at least Perl v5.9.4', 2) if $] < "5.009004"; # quote due to "use bigint;" + + is (ref(hex(9)), 'Math::BigInt', 'hex is overloaded'); + is (ref(oct(07)), 'Math::BigInt', 'oct is overloaded'); + } + { no bigint; is (ref(1), '', 'is not in effect'); is (ref(2.0), '', 'is not in effect'); is (ref(0x20), '', 'is not in effect'); + + isnt (ref(hex(9)), 'Math::BigInt', 'hex is not overloaded'); + isnt (ref(oct(07)), 'Math::BigInt', 'oct is not overloaded'); + } diff --git a/lib/bignum/t/scope_r.t b/lib/bignum/t/scope_r.t index 8883988..784fe0e 100644 --- a/lib/bignum/t/scope_r.t +++ b/lib/bignum/t/scope_r.t @@ -1,7 +1,7 @@ #!/usr/bin/perl -w ############################################################################### -# Test no bigint; +# Test "no bigrat;" and overloading of hex()/oct() for newer Perls use Test::More; use strict; @@ -11,20 +11,31 @@ BEGIN $| = 1; chdir 't' if -d 't'; unshift @INC, '../lib'; - plan tests => 6; + plan tests => 10; } +# no :hex and :oct means these do not get overloaded for older Perls: use bigrat; isnt (ref(1), '', 'is in effect'); isnt (ref(2.0), '', 'is in effect'); isnt (ref(0x20), '', 'is in effect'); +SKIP: { + skip ('Need at least Perl v5.9.4', 2) if $] < 5.009004; + + is (ref(hex(9)), 'Math::BigInt', 'hex is overloaded'); + is (ref(oct(07)), 'Math::BigInt', 'oct is overloaded'); + } + { no bigrat; is (ref(1), '', 'is not in effect'); is (ref(2.0), '', 'is not in effect'); is (ref(0x20), '', 'is not in effect'); + + isnt (ref(hex(9)), 'Math::BigInt', 'hex is not overloaded'); + isnt (ref(oct(07)), 'Math::BigInt', 'oct is not overloaded'); } diff --git a/lib/bigrat.pm b/lib/bigrat.pm index 7888aa4..884e9da 100644 --- a/lib/bigrat.pm +++ b/lib/bigrat.pm @@ -3,15 +3,22 @@ use 5.006002; $VERSION = '0.22'; require Exporter; -@ISA = qw( Exporter ); +@ISA = qw( bigint ); @EXPORT_OK = qw( ); @EXPORT = qw( inf NaN ); use strict; use overload; +require bigint; # no "use" to avoid callind import ############################################################################## +BEGIN + { + *inf = \&bigint::inf; + *NaN = \&bigint::NaN; + } + # These are all alike, and thus faked by AUTOLOAD my @faked = qw/round_mode accuracy precision div_scale/; @@ -48,24 +55,6 @@ sub AUTOLOAD Carp::croak ("Can't call bigrat\-\>$name, not a valid method"); } -sub upgrade - { - $Math::BigInt::upgrade; - } - -sub _binary_constant - { - # this takes a binary/hexadecimal/octal constant string and returns it - # as string suitable for new. Basically it converts octal to decimal, and - # passes every thing else unmodified back. - my $string = shift; - - return Math::BigInt->new($string) if $string =~ /^0[bx]/; - - # so it must be an octal constant - Math::BigInt->from_oct($string); - } - sub unimport { $^H{bigrat} = undef; # no longer in effect @@ -79,6 +68,25 @@ sub in_effect $hinthash->{bigrat}; } +############################################################################# +# the following two routines are for Perl 5.9.4 or later and are lexical + +sub _hex + { + return CORE::hex($_[0]) unless in_effect(1); + my $i = $_[0]; + $i = '0x'.$i unless $i =~ /^0x/; + Math::BigInt->new($i); + } + +sub _oct + { + return CORE::oct($_[0]) unless in_effect(1); + my $i = $_[0]; + return Math::BigInt->from_oct($i) if $i =~ /^0[0-7]/; + Math::BigInt->new($i); + } + sub import { my $self = shift; @@ -87,6 +95,13 @@ sub import $^H{bigrat} = 1; # we are in effect + # for newer Perls always override hex() and oct() with a lexical version: + if ($] > 5.009004) + { + no warnings 'redefine'; + *CORE::GLOBAL::oct = \&_oct; + *CORE::GLOBAL::hex = \&_hex; + } # some defaults my $lib = ''; my $lib_kind = 'try'; my $upgrade = 'Math::BigFloat'; @@ -133,6 +148,18 @@ sub import $trace = 1; splice @a, $j, 1; $j --; } + elsif ($_[$i] eq 'hex') + { + splice @a, $j, 1; $j --; + no warnings 'redefine'; + *CORE::GLOBAL::hex = \&bigint::_hex_global; + } + elsif ($_[$i] eq 'oct') + { + splice @a, $j, 1; $j --; + no warnings 'redefine'; + *CORE::GLOBAL::oct = \&bigint::_oct_global; + } else { die ("unknown option $_[$i]"); @@ -184,7 +211,7 @@ sub import } # Take care of octal/hexadecimal constants - overload::constant binary => sub { _binary_constant(shift) }; + overload::constant binary => sub { bigint::_binary_constant(shift) }; # if another big* was already loaded: my ($package) = caller(); @@ -196,9 +223,6 @@ sub import } } -sub inf () { Math::BigInt->binf(); } -sub NaN () { Math::BigInt->bnan(); } - 1; __END__ @@ -219,6 +243,11 @@ bigrat - Transparent BigNumber/BigRational support for Perl print 1/3,"\n"; # 0.33333... } + # Note that this will make hex() and oct() be globally overriden: + use bigrat qw/hex oct/; + print hex("0x1234567890123490"),"\n"; + print oct("01234567890123490"),"\n"; + =head1 DESCRIPTION All operators (including basic math operations) are overloaded. Integer and @@ -406,6 +435,18 @@ line. This means the following does not work: This will be hopefully fixed soon ;) +=item hex + +Override the build-in hex() method with a version that can handle big +integers. Note that under Perl v5.9.4 or ealier, this will be global +and cannot be disabled with "no bigint;". + +=item oct + +Override the build-in oct() method with a version that can handle big +integers. Note that under Perl v5.9.4 or ealier, this will be global +and cannot be disabled with "no bigint;". + =item v or version This prints out the name and version of all modules used and then exits. @@ -414,6 +455,41 @@ This prints out the name and version of all modules used and then exits. =back +=head1 CAVAETS + +=over 2 + +=item in_effect() + +This method only works on Perl v5.9.4 or later. + +=item hex()/oct() + +C overrides these routines with versions that can also handle +big integer values. Under Perl prior to version v5.9.4, however, this +will not happen unless you specifically ask for it with the two +import tags "hex" and "oct" - and then it will be global and cannot be +disabled inside a scope with "no bigint": + + use bigint qw/hex oct/; + + print hex("0x1234567890123456"); + { + no bigint; + print hex("0x1234567890123456"); + } + +The second call to hex() will warn about a non-portable constant. + +Compare this to: + + use bigint; + + # will warn only under Perl older than v5.9.4 + print hex("0x1234567890123456"); + +=back + =head1 EXAMPLES perl -Mbigrat -le 'print sqrt(33)'