Re: [PATCH] cflags.SH: rethink of the gcc -std=c89 and -pedantic

[p5sagit/p5-mst-13.2.git] / lib / overload.pm

diff --git a/lib/overload.pm b/lib/overload.pm
index fb1a0d1..690be22 100644 (file)
--- a/lib/overload.pm
+++ b/lib/overload.pm
@@ -1,8 +1,6 @@
 package overload;
 
-our $VERSION = '1.00';
-
-$overload::hint_bits = 0x20000;
+our $VERSION = '1.04';
 
 sub nil {}
 
@@ -84,18 +82,17 @@ sub Method {
 sub AddrRef {
   my $package = ref $_[0];
   return "$_[0]" unless $package;
-  bless $_[0], overload::Fake; # Non-overloaded package
-  my $str = "$_[0]";
-  bless $_[0], $package;       # Back
-  $package . substr $str, index $str, '=';
-}
 
-sub StrVal {
-  (ref $_[0] && OverloadedStringify($_[0]) or ref($_[0]) eq 'Regexp') ?
-    (AddrRef(shift)) :
-    "$_[0]";
+       require Scalar::Util;
+       my $class = Scalar::Util::blessed($_[0]);
+       my $class_prefix = defined($class) ? "$class=" : "";
+       my $type = Scalar::Util::reftype($_[0]);
+       my $addr = Scalar::Util::refaddr($_[0]);
+       return sprintf("$class_prefix$type(0x%x)", $addr);
 }
 
+*StrVal = *AddrRef;
+
 sub mycan {                            # Real can would leave stubs.
   my ($package, $meth) = @_;
   return \*{$package . "::$meth"} if defined &{$package . "::$meth"};
@@ -108,11 +105,11 @@ sub mycan {                               # Real can would leave stubs.
 }
 
 %constants = (
-             'integer'   =>  0x1000,
-             'float'     =>  0x2000,
-             'binary'    =>  0x4000,
-             'q'         =>  0x8000,
-             'qr'        => 0x10000,
+             'integer'   =>  0x1000, # HINT_NEW_INTEGER
+             'float'     =>  0x2000, # HINT_NEW_FLOAT
+             'binary'    =>  0x4000, # HINT_NEW_BINARY
+             'q'         =>  0x8000, # HINT_NEW_STRING
+             'qr'        => 0x10000, # HINT_NEW_RE
             );
 
 %ops = ( with_assign     => "+ - * / % ** << >> x .",
@@ -150,7 +147,7 @@ sub constant {
     }
     else {
         $^H{$_[0]} = $_[1];
-        $^H |= $constants{$_[0]} | $overload::hint_bits;
+        $^H |= $constants{$_[0]};
     }
     shift, shift;
   }
@@ -171,7 +168,7 @@ __END__
 
 =head1 NAME
 
-overload - Package for overloading perl operations
+overload - Package for overloading Perl operations
 
 =head1 SYNOPSIS
 
@@ -423,7 +420,7 @@ The dereference operators must be specified explicitly they will not be passed t
 
 =item * I<Special>
 
-    "nomethod", "fallback", "=",
+    "nomethod", "fallback", "=", "~~",
 
 see L<SPECIAL SYMBOLS FOR C<use overload>>.
 
@@ -543,6 +540,11 @@ C<"nomethod"> value, and if this is missing, raises an exception.
 B<Note.> C<"fallback"> inheritance via @ISA is not carved in stone
 yet, see L<"Inheritance and overloading">.
 
+=head2 Smart Match
+
+The key C<"~~"> allows you to override the smart matching used by
+the switch construct. See L<feature>.
+
 =head2 Copy Constructor
 
 The value for C<"="> is a reference to a function with three
@@ -664,6 +666,23 @@ value is a scalar and not a reference.
 
 =back
 
+=head1 Minimal set of overloaded operations
+
+Since some operations can be automatically generated from others, there is
+a minimal set of operations that need to be overloaded in order to have
+the complete set of overloaded operations at one's disposal.
+Of course, the autogenerated operations may not do exactly what the user
+expects. See L<MAGIC AUTOGENERATION> above. The minimal set is:
+
+    + - * / % ** << >> x
+    <=> cmp
+    & | ^ ~
+    atan2 cos sin exp log sqrt int
+
+Additionally, you need to define at least one of string, boolean or
+numeric conversions because any one can be used to emulate the others.
+The string conversion can also be used to emulate concatenation.
+
 =head1 Losing overloading
 
 The restriction for the comparison operation is that even if, for example,
@@ -701,7 +720,10 @@ Package C<overload.pm> provides the following public functions:
 
 =item overload::StrVal(arg)
 
-Gives string value of C<arg> as in absence of stringify overloading.
+Gives string value of C<arg> as in absence of stringify overloading. If you
+are using this to get the address of a reference (useful for checking if two
+references point to the same thing) then you may be better off using
+C<Scalar::Util::refaddr()>, which is faster.
 
 =item overload::Overloaded(arg)
 
@@ -715,12 +737,12 @@ Returns C<undef> or a reference to the method that implements C<op>.
 
 =head1 Overloading constants
 
-For some application Perl parser mangles constants too much.  It is possible
-to hook into this process via overload::constant() and overload::remove_constant()
-functions.
+For some applications, the Perl parser mangles constants too much.
+It is possible to hook into this process via C<overload::constant()>
+and C<overload::remove_constant()> functions.
 
 These functions take a hash as an argument.  The recognized keys of this hash
-are
+are:
 
 =over 8
 
@@ -776,9 +798,6 @@ From these methods they may be called as
          overload::constant integer => sub {Math::BigInt->new(shift)};
        }
 
-B<BUGS> Currently overloaded-ness of constants does not propagate
-into C<eval '...'>.
-
 =head1 IMPLEMENTATION
 
 What follows is subject to change RSN.
@@ -922,10 +941,7 @@ numeric value.)  This prints:
 =head2 Two-face references
 
 Suppose you want to create an object which is accessible as both an
-array reference and a hash reference, similar to the
-L<pseudo-hash|perlref/"Pseudo-hashes: Using an array as a hash">
-builtin Perl type.  Let's make it better than a pseudo-hash by
-allowing index 0 to be treated as a normal element.
+array reference and a hash reference.
 
   package two_refs;
   use overload '%{}' => \&gethash, '@{}' => sub { $ {shift()} };
@@ -1087,7 +1103,7 @@ The value of $side is
 
 Note that while we obtained this value using a nice little script,
 there is no simple way to I<use> this value.  In fact this value may
-be inspected in debugger (see L<perldebug>), but ony if
+be inspected in debugger (see L<perldebug>), but only if
 C<bareStringify> B<O>ption is set, and not via C<p> command.
 
 If one attempts to print this value, then the overloaded operator