Change mktables to use pack 'J', $addr; to key its inside-out objects.
authorNicholas Clark <nick@ccl4.org>
Thu, 26 Aug 2010 13:19:42 +0000 (15:19 +0200)
committerNicholas Clark <nick@ccl4.org>
Thu, 26 Aug 2010 14:23:02 +0000 (16:23 +0200)
Using pack 'J', $addr; instead of 0 + $addr; reduces run time by about 1%,
according to my benchmarking.

lib/unicore/mktables

index f744583..9b958ef 100644 (file)
@@ -9,11 +9,12 @@
 # 5.8: needs pack "U".  But almost all occurrences of objaddr have been
 # removed in favor of using 'no overloading'.  You also would have to go
 # through and replace occurrences like:
-#       my $addr; { no overloading; $addr = 0+$self; }
+#       my $addr; { no overloading; $addr = pack 'J', $self; }
 # with
 #       my $addr = main::objaddr $self;
 # (or reverse commit 9b01bafde4b022706c3d6f947a0963f821b2e50b
-# that instituted this change.)
+# that instituted the change to main::objaddr, and subsequent commits that
+# changed 0+$self to pack 'J', $self.)
 
 require 5.010_001;
 use strict;
@@ -1234,7 +1235,7 @@ sub objaddr($) {
     no overloading; # If overloaded, numifying below won't work.
 
     # Numifying a ref gives its address.
-    return 0+$_[0];
+    return pack 'J', $_[0];
 }
 
 # Commented code below should work on Perl 5.8.
@@ -1259,7 +1260,7 @@ sub objaddr($) {
 #    bless $_[0], 'main::Fake';
 #
 #    # Numifying a ref gives its address.
-#    my $addr = 0+$_[0];
+#    my $addr = pack 'J', $_[0];
 #
 #    # Return to original class
 #    bless $_[0], $pkg;
@@ -1449,7 +1450,7 @@ package main;
             # Use typeglob to give the anonymous subroutine the name we want
             *$destroy_name = sub {
                 my $self = shift;
-                my $addr; { no overloading; $addr = 0+$self; }
+                my $addr; { no overloading; $addr = pack 'J', $self; }
 
                 $self->$destroy_callback if $destroy_callback;
                 foreach my $field (keys %{$package_fields{$package}}) {
@@ -1548,7 +1549,7 @@ package main;
                     return Carp::carp_too_few_args(\@_, 2) if main::DEBUG && @_ < 2;
                     my $self = shift;
                     my $value = shift;
-                    my $addr; { no overloading; $addr = 0+$self; }
+                    my $addr; { no overloading; $addr = pack 'J', $self; }
                     Carp::carp_extra_args(\@_) if main::DEBUG && @_;
                     if (ref $value) {
                         return if grep { $value == $_ } @{$field->{$addr}};
@@ -1582,7 +1583,7 @@ package main;
                     *$subname = sub {
                         use strict "refs";
                         Carp::carp_extra_args(\@_) if main::DEBUG && @_ > 1;
-                        my $addr; { no overloading; $addr = 0+$_[0]; }
+                        my $addr; { no overloading; $addr = pack 'J', $_[0]; }
                         if (ref $field->{$addr} ne 'ARRAY') {
                             my $type = ref $field->{$addr};
                             $type = 'scalar' unless $type;
@@ -1605,7 +1606,7 @@ package main;
                         use strict "refs";
                         Carp::carp_extra_args(\@_) if main::DEBUG && @_ > 1;
                         no overloading;
-                        return $field->{0+$_[0]};
+                        return $field->{pack 'J', $_[0]};
                     }
                 }
             }
@@ -1620,7 +1621,7 @@ package main;
                     }
                     # $self is $_[0]; $value is $_[1]
                     no overloading;
-                    $field->{0+$_[0]} = $_[1];
+                    $field->{pack 'J', $_[0]} = $_[1];
                     return;
                 }
             }
@@ -1780,7 +1781,7 @@ sub trace { return main::trace(@_); }
         my $class = shift;
 
         my $self = bless \do{ my $anonymous_scalar }, $class;
-        my $addr; { no overloading; $addr = 0+$self; }
+        my $addr; { no overloading; $addr = pack 'J', $self; }
 
         # Set defaults
         $handler{$addr} = \&main::process_generic_property_file;
@@ -1871,7 +1872,7 @@ sub trace { return main::trace(@_); }
         my $self = shift;
         Carp::carp_extra_args(\@_) if main::DEBUG && @_;
 
-        my $addr; { no overloading; $addr = 0+$self; }
+        my $addr; { no overloading; $addr = pack 'J', $self; }
 
         my $file = $file{$addr};
 
@@ -2041,7 +2042,7 @@ END
         my $self = shift;
         Carp::carp_extra_args(\@_) if main::DEBUG && @_;
 
-        my $addr; { no overloading; $addr = 0+$self; }
+        my $addr; { no overloading; $addr = pack 'J', $self; }
 
         # Here the file is open (or if the handle is not a ref, is an open
         # 'virtual' file).  Get the next line; any inserted lines get priority
@@ -2186,7 +2187,7 @@ END
 #        # an each_line_handler() on the line.
 #
 #        my $self = shift;
-#        my $addr; { no overloading; $addr = 0+$self; }
+#        my $addr; { no overloading; $addr = pack 'J', $self; }
 #
 #        foreach my $inserted_ref (@{$added_lines{$addr}}) {
 #            my ($adjusted, $line) = @{$inserted_ref};
@@ -2228,7 +2229,7 @@ END
         # indicate that this line hasn't been adjusted, and needs to be
         # processed.
         no overloading;
-        push @{$added_lines{0+$self}}, map { [ 0, $_ ] } @_;
+        push @{$added_lines{pack 'J', $self}}, map { [ 0, $_ ] } @_;
         return;
     }
 
@@ -2252,7 +2253,7 @@ END
         # Each inserted line is an array, with the first element being 1 to
         # indicate that this line has been adjusted
         no overloading;
-        push @{$added_lines{0+$self}}, map { [ 1, $_ ] } @_;
+        push @{$added_lines{pack 'J', $self}}, map { [ 1, $_ ] } @_;
         return;
     }
 
@@ -2265,7 +2266,7 @@ END
         my $self = shift;
         Carp::carp_extra_args(\@_) if main::DEBUG && @_;
 
-        my $addr; { no overloading; $addr = 0+$self; }
+        my $addr; { no overloading; $addr = pack 'J', $self; }
 
         # If not accepting a list return, just return the first one.
         return shift @{$missings{$addr}} unless wantarray;
@@ -2279,7 +2280,7 @@ END
         # Add a property field to $_, if this file requires it.
 
         my $self = shift;
-        my $addr; { no overloading; $addr = 0+$self; }
+        my $addr; { no overloading; $addr = pack 'J', $self; }
         my $property = $property{$addr};
         Carp::carp_extra_args(\@_) if main::DEBUG && @_;
 
@@ -2298,7 +2299,7 @@ END
         my $message = shift;
         Carp::carp_extra_args(\@_) if main::DEBUG && @_;
 
-        my $addr; { no overloading; $addr = 0+$self; }
+        my $addr; { no overloading; $addr = pack 'J', $self; }
 
         $message = 'Unexpected line' unless $message;
 
@@ -2363,7 +2364,7 @@ package Multi_Default;
         my $class = shift;
 
         my $self = bless \do{my $anonymous_scalar}, $class;
-        my $addr; { no overloading; $addr = 0+$self; }
+        my $addr; { no overloading; $addr = pack 'J', $self; }
 
         while (@_ > 1) {
             my $default = shift;
@@ -2381,7 +2382,7 @@ package Multi_Default;
         my $self = shift;
         Carp::carp_extra_args(\@_) if main::DEBUG && @_;
 
-        my $addr; { no overloading; $addr = 0+$self; }
+        my $addr; { no overloading; $addr = pack 'J', $self; }
 
         return each %{$class_defaults{$addr}};
     }
@@ -2428,7 +2429,7 @@ package Alias;
         my $class = shift;
 
         my $self = bless \do { my $anonymous_scalar }, $class;
-        my $addr; { no overloading; $addr = 0+$self; }
+        my $addr; { no overloading; $addr = pack 'J', $self; }
 
         $name{$addr} = shift;
         $loose_match{$addr} = shift;
@@ -2490,7 +2491,7 @@ sub trace { return main::trace(@_); }
         my $class = shift;
 
         my $self = bless \do { my $anonymous_scalar }, $class;
-        my $addr; { no overloading; $addr = 0+$self; }
+        my $addr; { no overloading; $addr = pack 'J', $self; }
 
         $start{$addr} = shift;
         $end{$addr} = shift;
@@ -2520,7 +2521,7 @@ sub trace { return main::trace(@_); }
 
     sub _operator_stringify {
         my $self = shift;
-        my $addr; { no overloading; $addr = 0+$self; }
+        my $addr; { no overloading; $addr = pack 'J', $self; }
 
         # Output it like '0041..0065 (value)'
         my $return = sprintf("%04X", $start{$addr})
@@ -2543,7 +2544,7 @@ sub trace { return main::trace(@_); }
         my $self = shift;
         Carp::carp_extra_args(\@_) if main::DEBUG && @_;
 
-        my $addr; { no overloading; $addr = 0+$self; }
+        my $addr; { no overloading; $addr = pack 'J', $self; }
 
         return $standard_form{$addr} if defined $standard_form{$addr};
         return $value{$addr};
@@ -2556,7 +2557,7 @@ sub trace { return main::trace(@_); }
         my $indent = shift;
         Carp::carp_extra_args(\@_) if main::DEBUG && @_;
 
-        my $addr; { no overloading; $addr = 0+$self; }
+        my $addr; { no overloading; $addr = pack 'J', $self; }
 
         my $return = $indent
                     . sprintf("%04X", $start{$addr})
@@ -2638,7 +2639,7 @@ sub trace { return main::trace(@_); }
         return _union($class, $initialize, %args) if defined $initialize;
 
         $self = bless \do { my $anonymous_scalar }, $class;
-        my $addr; { no overloading; $addr = 0+$self; }
+        my $addr; { no overloading; $addr = pack 'J', $self; }
 
         # Optional parent object, only for debug info.
         $owner_name_of{$addr} = delete $args{'Owner'};
@@ -2670,7 +2671,7 @@ sub trace { return main::trace(@_); }
 
     sub _operator_stringify {
         my $self = shift;
-        my $addr; { no overloading; $addr = 0+$self; }
+        my $addr; { no overloading; $addr = pack 'J', $self; }
 
         return "Range_List attached to '$owner_name_of{$addr}'"
                                                 if $owner_name_of{$addr};
@@ -2729,7 +2730,7 @@ sub trace { return main::trace(@_); }
                 my $message = "";
                 if (defined $self) {
                     no overloading;
-                    $message .= $owner_name_of{0+$self};
+                    $message .= $owner_name_of{pack 'J', $self};
                 }
                 Carp::my_carp_bug($message .= "Undefined argument to _union.  No union done.");
                 return;
@@ -2751,7 +2752,7 @@ sub trace { return main::trace(@_); }
                 my $message = "";
                 if (defined $self) {
                     no overloading;
-                    $message .= $owner_name_of{0+$self};
+                    $message .= $owner_name_of{pack 'J', $self};
                 }
                 Carp::my_carp_bug($message . "Cannot take the union of a $type.  No union done.");
                 return;
@@ -2792,7 +2793,7 @@ sub trace { return main::trace(@_); }
         Carp::carp_extra_args(\@_) if main::DEBUG && @_;
 
         no overloading;
-        return scalar @{$ranges{0+$self}};
+        return scalar @{$ranges{pack 'J', $self}};
     }
 
     sub min {
@@ -2805,7 +2806,7 @@ sub trace { return main::trace(@_); }
         my $self = shift;
         Carp::carp_extra_args(\@_) if main::DEBUG && @_;
 
-        my $addr; { no overloading; $addr = 0+$self; }
+        my $addr; { no overloading; $addr = pack 'J', $self; }
 
         # If the range list is empty, return a large value that isn't adjacent
         # to any that could be in the range list, for simpler tests
@@ -2830,7 +2831,7 @@ sub trace { return main::trace(@_); }
         # So is in the table if and only iff it is at least the start position
         # of range $i.
         no overloading;
-        return 0 if $ranges{0+$self}->[$i]->start > $codepoint;
+        return 0 if $ranges{pack 'J', $self}->[$i]->start > $codepoint;
         return $i + 1;
     }
 
@@ -2846,7 +2847,7 @@ sub trace { return main::trace(@_); }
 
         # contains() returns 1 beyond where we should look
         no overloading;
-        return $ranges{0+$self}->[$i-1]->value;
+        return $ranges{pack 'J', $self}->[$i-1]->value;
     }
 
     sub _search_ranges {
@@ -2860,7 +2861,7 @@ sub trace { return main::trace(@_); }
         my $code_point = shift;
         Carp::carp_extra_args(\@_) if main::DEBUG && @_;
 
-        my $addr; { no overloading; $addr = 0+$self; }
+        my $addr; { no overloading; $addr = pack 'J', $self; }
 
         return if $code_point > $max{$addr};
         my $r = $ranges{$addr};                # The current list of ranges
@@ -3034,7 +3035,7 @@ sub trace { return main::trace(@_); }
 
         Carp::carp_extra_args(\%args) if main::DEBUG && %args;
 
-        my $addr; { no overloading; $addr = 0+$self; }
+        my $addr; { no overloading; $addr = pack 'J', $self; }
 
         if ($operation ne '+' && $operation ne '-') {
             Carp::my_carp_bug("$owner_name_of{$addr}First parameter to _add_delete must be '+' or '-'.  No action taken.");
@@ -3619,7 +3620,7 @@ sub trace { return main::trace(@_); }
         Carp::carp_extra_args(\@_) if main::DEBUG && @_;
 
         no overloading;
-        undef $each_range_iterator{0+$self};
+        undef $each_range_iterator{pack 'J', $self};
         return;
     }
 
@@ -3630,7 +3631,7 @@ sub trace { return main::trace(@_); }
         my $self = shift;
         Carp::carp_extra_args(\@_) if main::DEBUG && @_;
 
-        my $addr; { no overloading; $addr = 0+$self; }
+        my $addr; { no overloading; $addr = pack 'J', $self; }
 
         return if $self->is_empty;
 
@@ -3647,7 +3648,7 @@ sub trace { return main::trace(@_); }
         my $self = shift;
         Carp::carp_extra_args(\@_) if main::DEBUG && @_;
 
-        my $addr; { no overloading; $addr = 0+$self; }
+        my $addr; { no overloading; $addr = pack 'J', $self; }
 
         my $count = 0;
         foreach my $range (@{$ranges{$addr}}) {
@@ -3671,7 +3672,7 @@ sub trace { return main::trace(@_); }
         Carp::carp_extra_args(\@_) if main::DEBUG && @_;
 
         no overloading;
-        return scalar @{$ranges{0+$self}} == 0;
+        return scalar @{$ranges{pack 'J', $self}} == 0;
     }
 
     sub hash {
@@ -3682,7 +3683,7 @@ sub trace { return main::trace(@_); }
         my $self = shift;
         Carp::carp_extra_args(\@_) if main::DEBUG && @_;
 
-        my $addr; { no overloading; $addr = 0+$self; }
+        my $addr; { no overloading; $addr = pack 'J', $self; }
 
         # These are quickly computable.  Return looks like 'min..max;count'
         return $self->min . "..$max{$addr};" . scalar @{$ranges{$addr}};
@@ -3990,7 +3991,7 @@ sub trace { return main::trace(@_); }
         my $self = shift;
         Carp::carp_extra_args(\@_) if main::DEBUG && @_;
 
-        my $addr; { no overloading; $addr = 0+$self; }
+        my $addr; { no overloading; $addr = pack 'J', $self; }
 
         # On first pass, don't choose less desirable code points; if no good
         # one is found, repeat, allowing a less desirable one to be selected.
@@ -4182,7 +4183,7 @@ sub trace { return main::trace(@_); }
         my $class = shift;
 
         my $self = bless \do { my $anonymous_scalar }, $class;
-        my $addr; { no overloading; $addr = 0+$self; }
+        my $addr; { no overloading; $addr = pack 'J', $self; }
 
         my %args = @_;
 
@@ -4336,7 +4337,7 @@ sub trace { return main::trace(@_); }
         # Returns the array of ranges associated with this table.
 
         no overloading;
-        return $range_list{0+shift}->ranges;
+        return $range_list{pack 'J', shift}->ranges;
     }
 
     sub add_alias {
@@ -4372,7 +4373,7 @@ sub trace { return main::trace(@_); }
         # release
         $name = ucfirst($name) unless $name =~ /^k[A-Z]/;
 
-        my $addr; { no overloading; $addr = 0+$self; }
+        my $addr; { no overloading; $addr = pack 'J', $self; }
 
         # Figure out if should be loosely matched if not already specified.
         if (! defined $loose_match) {
@@ -4434,7 +4435,7 @@ sub trace { return main::trace(@_); }
         # This name may be shorter than any existing ones, so clear the cache
         # of the shortest, so will have to be recalculated.
         no overloading;
-        undef $short_name{0+$self};
+        undef $short_name{pack 'J', $self};
         return;
     }
 
@@ -4457,7 +4458,7 @@ sub trace { return main::trace(@_); }
         my $nominal_length_ptr = shift;
         Carp::carp_extra_args(\@_) if main::DEBUG && @_;
 
-        my $addr; { no overloading; $addr = 0+$self; }
+        my $addr; { no overloading; $addr = pack 'J', $self; }
 
         # For efficiency, don't recalculate, but this means that adding new
         # aliases could change what the shortest is, so the code that does
@@ -4533,7 +4534,7 @@ sub trace { return main::trace(@_); }
         Carp::carp_extra_args(\@_) if main::DEBUG && @_;
 
         no overloading;
-        push @{$description{0+$self}}, $description;
+        push @{$description{pack 'J', $self}}, $description;
 
         return;
     }
@@ -4546,7 +4547,7 @@ sub trace { return main::trace(@_); }
         Carp::carp_extra_args(\@_) if main::DEBUG && @_;
 
         no overloading;
-        push @{$note{0+$self}}, $note;
+        push @{$note{pack 'J', $self}}, $note;
 
         return;
     }
@@ -4560,7 +4561,7 @@ sub trace { return main::trace(@_); }
         chomp $comment;
 
         no overloading;
-        push @{$comment{0+$self}}, $comment;
+        push @{$comment{pack 'J', $self}}, $comment;
 
         return;
     }
@@ -4573,7 +4574,7 @@ sub trace { return main::trace(@_); }
         my $self = shift;
         Carp::carp_extra_args(\@_) if main::DEBUG && @_;
 
-        my $addr; { no overloading; $addr = 0+$self; }
+        my $addr; { no overloading; $addr = pack 'J', $self; }
         my @list = @{$comment{$addr}};
         return @list if wantarray;
         my $return = "";
@@ -4591,7 +4592,7 @@ sub trace { return main::trace(@_); }
         # initialization for range lists.
 
         my $self = shift;
-        my $addr; { no overloading; $addr = 0+$self; }
+        my $addr; { no overloading; $addr = pack 'J', $self; }
         my $initialization = shift;
         Carp::carp_extra_args(\@_) if main::DEBUG && @_;
 
@@ -4615,7 +4616,7 @@ sub trace { return main::trace(@_); }
         $return .= $DEVELOPMENT_ONLY if $compare_versions;
         $return .= $HEADER;
         no overloading;
-        $return .= $INTERNAL_ONLY if $internal_only{0+$self};
+        $return .= $INTERNAL_ONLY if $internal_only{pack 'J', $self};
         return $return;
     }
 
@@ -4630,7 +4631,7 @@ sub trace { return main::trace(@_); }
                                      # the range
         Carp::carp_extra_args(\@_) if main::DEBUG && @_;
 
-        my $addr; { no overloading; $addr = 0+$self; }
+        my $addr; { no overloading; $addr = pack 'J', $self; }
 
         # Start with the header
         my @OUT = $self->header;
@@ -4727,7 +4728,7 @@ sub trace { return main::trace(@_); }
         my $info = shift;   # Any message associated with it.
         Carp::carp_extra_args(\@_) if main::DEBUG && @_;
 
-        my $addr; { no overloading; $addr = 0+$self; }
+        my $addr; { no overloading; $addr = pack 'J', $self; }
 
         $status{$addr} = $status;
         $status_info{$addr} = $info;
@@ -4742,7 +4743,7 @@ sub trace { return main::trace(@_); }
         my $self = shift;
         Carp::carp_extra_args(\@_) if main::DEBUG && @_;
 
-        my $addr; { no overloading; $addr = 0+$self; }
+        my $addr; { no overloading; $addr = pack 'J', $self; }
 
         $locked{$addr} = "";
 
@@ -4770,7 +4771,7 @@ sub trace { return main::trace(@_); }
         my $self = shift;
         Carp::carp_extra_args(\@_) if main::DEBUG && @_;
 
-        my $addr; { no overloading; $addr = 0+$self; }
+        my $addr; { no overloading; $addr = pack 'J', $self; }
 
         return 0 if ! $locked{$addr};
         Carp::my_carp_bug("Can't modify a locked table. Stack trace of locking:\n$locked{$addr}\n\n");
@@ -4782,7 +4783,7 @@ sub trace { return main::trace(@_); }
         # Rest of parameters passed on
 
         no overloading;
-        @{$file_path{0+$self}} = @_;
+        @{$file_path{pack 'J', $self}} = @_;
         return
     }
 
@@ -4806,7 +4807,7 @@ sub trace { return main::trace(@_); }
             use strict "refs";
             my $self = shift;
             no overloading;
-            return $range_list{0+$self}->$sub(@_);
+            return $range_list{pack 'J', $self}->$sub(@_);
         }
     }
 
@@ -4822,7 +4823,7 @@ sub trace { return main::trace(@_); }
 
             return if $self->carp_if_locked;
             no overloading;
-            return $range_list{0+$self}->$sub(@_);
+            return $range_list{pack 'J', $self}->$sub(@_);
         }
     }
 
@@ -4928,7 +4929,7 @@ sub trace { return main::trace(@_); }
                                     _Range_List => $range_list,
                                     %args);
 
-        my $addr; { no overloading; $addr = 0+$self; }
+        my $addr; { no overloading; $addr = pack 'J', $self; }
 
         $anomalous_entries{$addr} = [];
         $core_access{$addr} = $core_access;
@@ -4980,7 +4981,7 @@ sub trace { return main::trace(@_); }
         # Can't change the table if locked.
         return if $self->carp_if_locked;
 
-        my $addr; { no overloading; $addr = 0+$self; }
+        my $addr; { no overloading; $addr = pack 'J', $self; }
 
         $has_specials{$addr} = 1 if $type;
 
@@ -4998,7 +4999,7 @@ sub trace { return main::trace(@_); }
         my $self = shift;
         Carp::carp_extra_args(\@_) if main::DEBUG && @_;
 
-        my $addr; { no overloading; $addr = 0+$self; }
+        my $addr; { no overloading; $addr = pack 'J', $self; }
 
         return "" unless @{$anomalous_entries{$addr}};
         return join("\n", @{$anomalous_entries{$addr}}) . "\n";
@@ -5025,8 +5026,8 @@ sub trace { return main::trace(@_); }
             return;
         }
 
-        my $addr; { no overloading; $addr = 0+$self; }
-        my $other_addr; { no overloading; $other_addr = 0+$other; }
+        my $addr; { no overloading; $addr = pack 'J', $self; }
+        my $other_addr; { no overloading; $other_addr = pack 'J', $other; }
 
         local $to_trace = 0 if main::DEBUG;
 
@@ -5059,7 +5060,7 @@ sub trace { return main::trace(@_); }
         my $map = shift;
         Carp::carp_extra_args(\@_) if main::DEBUG && @_;
 
-        my $addr; { no overloading; $addr = 0+$self; }
+        my $addr; { no overloading; $addr = pack 'J', $self; }
 
         # Convert the input to the standard equivalent, if any (won't have any
         # for $STRING properties)
@@ -5104,7 +5105,7 @@ sub trace { return main::trace(@_); }
         my $self = shift;
         Carp::carp_extra_args(\@_) if main::DEBUG && @_;
 
-        my $addr; { no overloading; $addr = 0+$self; }
+        my $addr; { no overloading; $addr = pack 'J', $self; }
 
         # If overridden, use that
         return $to_output_map{$addr} if defined $to_output_map{$addr};
@@ -5149,7 +5150,7 @@ sub trace { return main::trace(@_); }
         # No sense generating a comment if aren't going to write it out.
         return if ! $self->to_output_map;
 
-        my $addr; { no overloading; $addr = 0+$self; }
+        my $addr; { no overloading; $addr = pack 'J', $self; }
 
         my $property = $self->property;
 
@@ -5321,7 +5322,7 @@ END
         my $self = shift;
         Carp::carp_extra_args(\@_) if main::DEBUG && @_;
 
-        my $addr; { no overloading; $addr = 0+$self; }
+        my $addr; { no overloading; $addr = pack 'J', $self; }
 
         my $name = $self->property->swash_name;
 
@@ -5766,7 +5767,7 @@ END
         my $self = shift;
         Carp::carp_extra_args(\@_) if main::DEBUG && @_;
 
-        my $addr; { no overloading; $addr = 0+$self; }
+        my $addr; { no overloading; $addr = pack 'J', $self; }
 
         return $self->SUPER::write(
             ($self->property == $block)
@@ -5913,7 +5914,7 @@ sub trace { return main::trace(@_); }
                                       _Property => $property,
                                       _Range_List => $range_list,
                                       );
-        my $addr; { no overloading; $addr = 0+$self; }
+        my $addr; { no overloading; $addr = pack 'J', $self; }
 
         $conflicting{$addr} = [ ];
         $equivalents{$addr} = [ ];
@@ -5954,7 +5955,7 @@ sub trace { return main::trace(@_); }
 
                         return if $self->carp_if_locked;
 
-                        my $addr; { no overloading; $addr = 0+$self; }
+                        my $addr; { no overloading; $addr = pack 'J', $self; }
 
                         if (ref $other) {
 
@@ -6021,7 +6022,7 @@ sub trace { return main::trace(@_); }
                                         # be an optional parameter.
         Carp::carp_extra_args(\@_) if main::DEBUG && @_;
 
-        my $addr; { no overloading; $addr = 0+$self; }
+        my $addr; { no overloading; $addr = pack 'J', $self; }
 
         # Check if the conflicting name is exactly the same as any existing
         # alias in this table (as long as there is a real object there to
@@ -6069,7 +6070,7 @@ sub trace { return main::trace(@_); }
 
         # Two tables are equivalent if they have the same leader.
         no overloading;
-        return $leader{0+$self} == $leader{0+$other};
+        return $leader{pack 'J', $self} == $leader{pack 'J', $other};
         return;
     }
 
@@ -6143,7 +6144,7 @@ sub trace { return main::trace(@_); }
         my $are_equivalent = $self->is_equivalent_to($other);
         return if ! defined $are_equivalent || $are_equivalent;
 
-        my $addr; { no overloading; $addr = 0+$self; }
+        my $addr; { no overloading; $addr = pack 'J', $self; }
         my $current_leader = ($related) ? $parent{$addr} : $leader{$addr};
 
         if ($related &&
@@ -6154,8 +6155,8 @@ sub trace { return main::trace(@_); }
             $related = 0;
         }
 
-        my $leader; { no overloading; $leader = 0+$current_leader; }
-        my $other_addr; { no overloading; $other_addr = 0+$other; }
+        my $leader; { no overloading; $leader = pack 'J', $current_leader; }
+        my $other_addr; { no overloading; $other_addr = pack 'J', $other; }
 
         # Any tables that are equivalent to or children of this table must now
         # instead be equivalent to or (children) to the new leader (parent),
@@ -6170,7 +6171,7 @@ sub trace { return main::trace(@_); }
             next if $table == $other;
             trace "setting $other to be the leader of $table, status=$status" if main::DEBUG && $to_trace;
 
-            my $table_addr; { no overloading; $table_addr = 0+$table; }
+            my $table_addr; { no overloading; $table_addr = pack 'J', $table; }
             $leader{$table_addr} = $other;
             $matches_all{$table_addr} = $matches_all;
             $self->_set_range_list($other->_range_list);
@@ -6224,7 +6225,7 @@ sub trace { return main::trace(@_); }
                               # an equivalent group
         Carp::carp_extra_args(\@_) if main::DEBUG && @_;
 
-        my $addr; { no overloading; $addr = 0+$leader; }
+        my $addr; { no overloading; $addr = pack 'J', $leader; }
 
         if ($leader{$addr} != $leader) {
             Carp::my_carp_bug(<<END
@@ -6279,7 +6280,7 @@ END
                 && $parent == $property->table('N')
                 && defined (my $yes = $property->table('Y')))
             {
-                my $yes_addr; { no overloading; $yes_addr = 0+$yes; }
+                my $yes_addr; { no overloading; $yes_addr = pack 'J', $yes; }
                 @yes_perl_synonyms
                     = grep { $_->property == $perl }
                                     main::uniques($yes,
@@ -6295,12 +6296,12 @@ END
             my @conflicting;        # Will hold the table conflicts.
 
             # Look at the parent, any yes synonyms, and all the children
-            my $parent_addr; { no overloading; $parent_addr = 0+$parent; }
+            my $parent_addr; { no overloading; $parent_addr = pack 'J', $parent; }
             for my $table ($parent,
                            @yes_perl_synonyms,
                            @{$children{$parent_addr}})
             {
-                my $table_addr; { no overloading; $table_addr = 0+$table; }
+                my $table_addr; { no overloading; $table_addr = pack 'J', $table; }
                 my $table_property = $table->property;
 
                 # Tables are separated by a blank line to create a grouping.
@@ -6717,7 +6718,7 @@ sub trace { return main::trace(@_) if main::DEBUG && $to_trace }
         my %args = @_;
 
         $self = bless \do { my $anonymous_scalar }, $class;
-        my $addr; { no overloading; $addr = 0+$self; }
+        my $addr; { no overloading; $addr = pack 'J', $self; }
 
         $directory{$addr} = delete $args{'Directory'};
         $file{$addr} = delete $args{'File'};
@@ -6778,7 +6779,7 @@ sub trace { return main::trace(@_) if main::DEBUG && $to_trace }
         }
         else {
             no overloading;
-            $map{0+$self}->delete_range($other, $other);
+            $map{pack 'J', $self}->delete_range($other, $other);
         }
         return $self;
     }
@@ -6791,7 +6792,7 @@ sub trace { return main::trace(@_) if main::DEBUG && $to_trace }
         my $name = shift;
         my %args = @_;
 
-        my $addr; { no overloading; $addr = 0+$self; }
+        my $addr; { no overloading; $addr = pack 'J', $self; }
 
         my $table = $table_ref{$addr}{$name};
         my $standard_name = main::standardize($name);
@@ -6859,7 +6860,7 @@ sub trace { return main::trace(@_) if main::DEBUG && $to_trace }
         my $name = shift;
         Carp::carp_extra_args(\@_) if main::DEBUG && @_;
 
-        my $addr; { no overloading; $addr = 0+$self; }
+        my $addr; { no overloading; $addr = pack 'J', $self; }
 
         return $table_ref{$addr}{$name} if defined $table_ref{$addr}{$name};
 
@@ -6878,7 +6879,7 @@ sub trace { return main::trace(@_) if main::DEBUG && $to_trace }
         # property
 
         no overloading;
-        return main::uniques(values %{$table_ref{0+shift}});
+        return main::uniques(values %{$table_ref{pack 'J', shift}});
     }
 
     sub directory {
@@ -6887,7 +6888,7 @@ sub trace { return main::trace(@_) if main::DEBUG && $to_trace }
         # priority;  'undef' is returned if the type isn't defined;
         # or $map_directory for everything else.
 
-        my $addr; { no overloading; $addr = 0+shift; }
+        my $addr; { no overloading; $addr = pack 'J', shift; }
 
         return $directory{$addr} if defined $directory{$addr};
         return undef if $type{$addr} == $UNKNOWN;
@@ -6908,7 +6909,7 @@ sub trace { return main::trace(@_) if main::DEBUG && $to_trace }
         my $self = shift;
         Carp::carp_extra_args(\@_) if main::DEBUG && @_;
 
-        my $addr; { no overloading; $addr = 0+$self; }
+        my $addr; { no overloading; $addr = pack 'J', $self; }
 
         return $file{$addr} if defined $file{$addr};
         return $map{$addr}->external_name;
@@ -6924,7 +6925,7 @@ sub trace { return main::trace(@_) if main::DEBUG && $to_trace }
         # The whole point of this pseudo property is match tables.
         return 1 if $self == $perl;
 
-        my $addr; { no overloading; $addr = 0+$self; }
+        my $addr; { no overloading; $addr = pack 'J', $self; }
 
         # Don't generate tables of code points that match the property values
         # of a string property.  Such a list would most likely have many
@@ -6959,7 +6960,7 @@ sub trace { return main::trace(@_) if main::DEBUG && $to_trace }
         }
 
         no overloading;
-        return $map{0+$self}->map_add_or_replace_non_nulls($map{0+$other});
+        return $map{pack 'J', $self}->map_add_or_replace_non_nulls($map{pack 'J', $other});
     }
 
     sub set_type {
@@ -6978,7 +6979,7 @@ sub trace { return main::trace(@_) if main::DEBUG && $to_trace }
             return;
         }
 
-        { no overloading; $type{0+$self} = $type; }
+        { no overloading; $type{pack 'J', $self} = $type; }
         return if $type != $BINARY;
 
         my $yes = $self->table('Y');
@@ -7008,7 +7009,7 @@ sub trace { return main::trace(@_) if main::DEBUG && $to_trace }
         my $map = shift;    # What the range maps to.
         # Rest of parameters passed on.
 
-        my $addr; { no overloading; $addr = 0+$self; }
+        my $addr; { no overloading; $addr = pack 'J', $self; }
 
         # If haven't the type of the property, gather information to figure it
         # out.
@@ -7060,7 +7061,7 @@ sub trace { return main::trace(@_) if main::DEBUG && $to_trace }
         my $self = shift;
         Carp::carp_extra_args(\@_) if main::DEBUG && @_;
 
-        my $addr; { no overloading; $addr = 0+$self; }
+        my $addr; { no overloading; $addr = pack 'J', $self; }
 
         my $type = $type{$addr};
 
@@ -7170,7 +7171,7 @@ sub trace { return main::trace(@_) if main::DEBUG && $to_trace }
             use strict "refs";
             my $self = shift;
             no overloading;
-            return $map{0+$self}->$sub(@_);
+            return $map{pack 'J', $self}->$sub(@_);
         }
     }
 
@@ -7575,7 +7576,7 @@ sub standardize ($) {
         else {
 
             # Keep track of cycles in the input, and refuse to infinitely loop
-            my $addr; { no overloading; $addr = 0+$item; }
+            my $addr; { no overloading; $addr = pack 'J', $item; }
             if (defined $already_output{$addr}) {
                 return "${indent}ALREADY OUTPUT: $item\n";
             }
@@ -7696,7 +7697,7 @@ sub dump_inside_out {
     my $fields_ref = shift;
     Carp::carp_extra_args(\@_) if main::DEBUG && @_;
 
-    my $addr; { no overloading; $addr = 0+$object; }
+    my $addr; { no overloading; $addr = pack 'J', $object; }
 
     my %hash;
     foreach my $key (keys %$fields_ref) {
@@ -7724,7 +7725,7 @@ sub _operator_dot {
         }
         else {
             my $ref = ref $$which;
-            my $addr; { no overloading; $addr = 0+$$which; }
+            my $addr; { no overloading; $addr = pack 'J', $$which; }
             $$which = "$ref ($addr)";
         }
     }
@@ -8704,7 +8705,7 @@ END
                     $file->carp_bad_line("Unexpected property '$property_name'.  Skipped");
                     next LINE;
                 }
-                { no overloading; $property_addr = 0+$property_object; }
+                { no overloading; $property_addr = pack 'J', $property_object; }
 
                 # Defer changing names until have a line that is acceptable
                 # (the 'next' statement above means is unacceptable)
@@ -8756,7 +8757,7 @@ END
                                             if $file->has_missings_defaults;
                     foreach my $default_ref (@missings_list) {
                         my $default = $default_ref->[0];
-                        my $addr; { no overloading; $addr = 0+property_ref($default_ref->[1]); }
+                        my $addr; { no overloading; $addr = pack 'J', property_ref($default_ref->[1]); }
 
                         # For string properties, the default is just what the
                         # file says, but non-string properties should already