GenerateHashValue should be usable outside CodeGeneratorJS.pm
authorabarth@webkit.org <abarth@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Tue, 19 Mar 2013 20:45:36 +0000 (20:45 +0000)
committerabarth@webkit.org <abarth@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Tue, 19 Mar 2013 20:45:36 +0000 (20:45 +0000)
https://bugs.webkit.org/show_bug.cgi?id=112736

Reviewed by Benjamin Poulain.

GenerateHashValue is not specific to CodeGeneratorJS.pm. Instead, the
function matches the StringHash used in WTF. This patch moves the
function into a separate Perl module so that it can be used by other
Perl scripts. For example, I plan to use this function to compute the
hash value for HTMLNames at compile time rather than at startup.

* bindings/scripts/CodeGeneratorJS.pm:
(GenerateHashTable):
* bindings/scripts/Hash.pm: Added.
(leftShift):
(GenerateHashValue):

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@146253 268f45cc-cd09-0410-ab3c-d52691b4dbfc

Source/WebCore/ChangeLog
Source/WebCore/bindings/scripts/CodeGeneratorJS.pm
Source/WebCore/bindings/scripts/Hasher.pm [new file with mode: 0644]

index 4dc145b..946f646 100644 (file)
@@ -1,3 +1,22 @@
+2013-03-19  Adam Barth  <abarth@webkit.org>
+
+        GenerateHashValue should be usable outside CodeGeneratorJS.pm
+        https://bugs.webkit.org/show_bug.cgi?id=112736
+
+        Reviewed by Benjamin Poulain.
+
+        GenerateHashValue is not specific to CodeGeneratorJS.pm. Instead, the
+        function matches the StringHash used in WTF. This patch moves the
+        function into a separate Perl module so that it can be used by other
+        Perl scripts. For example, I plan to use this function to compute the
+        hash value for HTMLNames at compile time rather than at startup.
+
+        * bindings/scripts/CodeGeneratorJS.pm:
+        (GenerateHashTable):
+        * bindings/scripts/Hash.pm: Added.
+        (leftShift):
+        (GenerateHashValue):
+
 2013-03-19  Dean Jackson  <dino@apple.com>
 
         Allow PlugIn Snapshotting to be tested
index cee9bdd..270d2bb 100644 (file)
@@ -28,8 +28,8 @@
 package CodeGeneratorJS;
 
 use strict;
-
 use constant FileNamePrefix => "JS";
+use Hasher;
 
 my $codeGenerator;
 
@@ -85,11 +85,6 @@ sub new
     return $reference;
 }
 
-sub leftShift($$) {
-    my ($value, $distance) = @_;
-    return (($value << $distance) & 0xFFFFFFFF);
-}
-
 sub GenerateInterface
 {
     my $object = shift;
@@ -3472,7 +3467,7 @@ sub GenerateHashTable
     my $i = 0;
     foreach (@{$keys}) {
         my $depth = 0;
-        my $h = $object->GenerateHashValue($_) % $numEntries;
+        my $h = Hasher::GenerateHashValue($_) % $numEntries;
 
         while (defined($table[$h])) {
             if (defined($links[$h])) {
@@ -3543,65 +3538,6 @@ sub GenerateHashTable
     push(@implContent, "static const HashTable $name = { $compactSize, $compactSizeMask, $nameEntries, 0 };\n");
 }
 
-# Paul Hsieh's SuperFastHash
-# http://www.azillionmonkeys.com/qed/hash.html
-sub GenerateHashValue
-{
-    my $object = shift;
-
-    my @chars = split(/ */, $_[0]);
-
-    # This hash is designed to work on 16-bit chunks at a time. But since the normal case
-    # (above) is to hash UTF-16 characters, we just treat the 8-bit chars as if they
-    # were 16-bit chunks, which should give matching results
-    
-    my $EXP2_32 = 4294967296;
-    
-    my $hash = 0x9e3779b9;
-    my $l    = scalar @chars; #I wish this was in Ruby --- Maks
-    my $rem  = $l & 1;
-    $l = $l >> 1;
-    
-    my $s = 0;
-    
-    # Main loop
-    for (; $l > 0; $l--) {
-        $hash   += ord($chars[$s]);
-        my $tmp = leftShift(ord($chars[$s+1]), 11) ^ $hash;
-        $hash   = (leftShift($hash, 16)% $EXP2_32) ^ $tmp;
-        $s += 2;
-        $hash += $hash >> 11;
-        $hash %= $EXP2_32;
-    }
-    
-    # Handle end case
-    if ($rem != 0) {
-        $hash += ord($chars[$s]);
-        $hash ^= (leftShift($hash, 11)% $EXP2_32);
-        $hash += $hash >> 17;
-    }
-    
-    # Force "avalanching" of final 127 bits
-    $hash ^= leftShift($hash, 3);
-    $hash += ($hash >> 5);
-    $hash = ($hash% $EXP2_32);
-    $hash ^= (leftShift($hash, 2)% $EXP2_32);
-    $hash += ($hash >> 15);
-    $hash = $hash% $EXP2_32;
-    $hash ^= (leftShift($hash, 10)% $EXP2_32);
-    
-    # Save 8 bits for StringImpl to use as flags.
-    $hash &= 0xffffff;
-    
-    # This avoids ever returning a hash code of 0, since that is used to
-    # signal "hash not computed yet". Setting the high bit maintains
-    # reasonable fidelity to a hash code of 0 because it is likely to yield
-    # exactly 0 when hash lookup masks out the high bits.
-    $hash = (0x80000000 >> 8) if ($hash == 0);
-    
-    return $hash;
-}
-
 sub WriteData
 {
     my $object = shift;
diff --git a/Source/WebCore/bindings/scripts/Hasher.pm b/Source/WebCore/bindings/scripts/Hasher.pm
new file mode 100644 (file)
index 0000000..cb0d193
--- /dev/null
@@ -0,0 +1,93 @@
+# Copyright (C) 2005, 2006, 2007, 2008 Nikolas Zimmermann <zimmermann@kde.org>
+# Copyright (C) 2006 Anders Carlsson <andersca@mac.com>
+# Copyright (C) 2006, 2007 Samuel Weinig <sam@webkit.org>
+# Copyright (C) 2006 Alexey Proskuryakov <ap@webkit.org>
+# Copyright (C) 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.
+# Copyright (C) 2009 Cameron McCormack <cam@mcc.id.au>
+# Copyright (C) Research In Motion Limited 2010. All rights reserved.
+# Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
+# Copyright (C) 2011 Patrick Gansterer <paroga@webkit.org>
+# Copyright (C) 2012 Ericsson AB. All rights reserved.
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Library General Public
+# License as published by the Free Software Foundation; either
+# version 2 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Library General Public License for more details.
+#
+# You should have received a copy of the GNU Library General Public License
+# along with this library; see the file COPYING.LIB.  If not, write to
+# the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+# Boston, MA 02110-1301, USA.
+
+package Hasher;
+
+use strict;
+
+sub leftShift($$) {
+    my ($value, $distance) = @_;
+    return (($value << $distance) & 0xFFFFFFFF);
+}
+
+# Paul Hsieh's SuperFastHash
+# http://www.azillionmonkeys.com/qed/hash.html
+sub GenerateHashValue
+{
+    my @chars = split(/ */, $_[0]);
+
+    # This hash is designed to work on 16-bit chunks at a time. But since the normal case
+    # (above) is to hash UTF-16 characters, we just treat the 8-bit chars as if they
+    # were 16-bit chunks, which should give matching results
+    
+    my $EXP2_32 = 4294967296;
+    
+    my $hash = 0x9e3779b9;
+    my $l    = scalar @chars; #I wish this was in Ruby --- Maks
+    my $rem  = $l & 1;
+    $l = $l >> 1;
+    
+    my $s = 0;
+    
+    # Main loop
+    for (; $l > 0; $l--) {
+        $hash   += ord($chars[$s]);
+        my $tmp = leftShift(ord($chars[$s+1]), 11) ^ $hash;
+        $hash   = (leftShift($hash, 16)% $EXP2_32) ^ $tmp;
+        $s += 2;
+        $hash += $hash >> 11;
+        $hash %= $EXP2_32;
+    }
+    
+    # Handle end case
+    if ($rem != 0) {
+        $hash += ord($chars[$s]);
+        $hash ^= (leftShift($hash, 11)% $EXP2_32);
+        $hash += $hash >> 17;
+    }
+    
+    # Force "avalanching" of final 127 bits
+    $hash ^= leftShift($hash, 3);
+    $hash += ($hash >> 5);
+    $hash = ($hash% $EXP2_32);
+    $hash ^= (leftShift($hash, 2)% $EXP2_32);
+    $hash += ($hash >> 15);
+    $hash = $hash% $EXP2_32;
+    $hash ^= (leftShift($hash, 10)% $EXP2_32);
+    
+    # Save 8 bits for StringImpl to use as flags.
+    $hash &= 0xffffff;
+    
+    # This avoids ever returning a hash code of 0, since that is used to
+    # signal "hash not computed yet". Setting the high bit maintains
+    # reasonable fidelity to a hash code of 0 because it is likely to yield
+    # exactly 0 when hash lookup masks out the high bits.
+    $hash = (0x80000000 >> 8) if ($hash == 0);
+    
+    return $hash;
+}
+
+1;