Ticket #326: optimise_unpack_uint.patch

chert_utils.h

@@ -109 +109 @@
     }
 }
 
+inline bool
+unpack_uint(const char ** src,
+            const char * src_end,
+            om_uint32 * resultptr)
+{
+    // Check byte is what it's meant to be
+    STATIC_ASSERT(sizeof(om_byte) == 1);
 
+    // Check om_uint32 is what it's meant to be
+    STATIC_ASSERT_UNSIGNED_TYPE(om_uint32);
+    STATIC_ASSERT(sizeof(om_uint32) == 4);
+
+    om_byte part;
+    om_uint32 result = 0;
+    if (src_end - *src >= 5 || (src_end - *src > 0 && !(src_end[-1] & 0x80))) {
+        // No need to check src_end again, can't run off end.
+        part = static_cast<om_byte>(**src);
+        result = (part & 0x7f);
+        if (part & 0x80) {
+            part = static_cast<om_byte>((*src)[1]);
+            result |= ((part & 0x7f) << 7);
+            if (part & 0x80) {
+                part = static_cast<om_byte>((*src)[2]);
+                result |= ((part & 0x7f) << 14);
+                if (part & 0x80) {
+                    part = static_cast<om_byte>((*src)[3]);
+                    result |= ((part & 0x7f) << 21);
+                    if (part & 0x80) {
+                        part = static_cast<om_byte>((*src)[4]);
+                        if (part & 0xf0) {
+                            *src += 5;
+                            goto overflow;
+                        }
+                        result |= ((part & 0x0f) << 28);
+                        *src += 5;
+                    } else {
+                        *src += 4;
+                    }
+                } else {
+                    *src += 3;
+                }
+            } else {
+                *src += 2;
+            }
+        } else {
+            (*src)++;
+        }
+        if (resultptr) *resultptr = result;
+        return true;
+    } else {
+        // Slow path - need to check end at each step.
+        // Should be rare for this to be called, though.
+
+        unsigned int shift = 0;
+
+        while (true) {
+            if ((*src) == src_end) {
+                *src = 0;
+                return false;
+            }
+
+            part = static_cast<om_byte>(**src);
+            (*src)++;
+
+            // if new byte might cause overflow, and it does
+            if (((shift > (sizeof(om_uint32) - 1) * 8 + 1) &&
+                 ((part & 0x7f) << (shift % 8)) >= 0x100) ||
+                (shift >= sizeof(om_uint32) * 8))  {
+                // Overflowed - move to end of this integer
+                while (true) {
+                    if ((part & 0x80) == 0) return false;
+                    if ((*src) == src_end) {
+                        *src = 0;
+                        return false;
+                    }
+                    part = static_cast<om_byte>(**src);
+                    (*src)++;
+                }
+            }
+
+            result += om_uint32(part & 0x7f) << shift;
+            shift += 7;
+
+            if ((part & 0x80) == 0) {
+                if (resultptr) *resultptr = result;
+                return true;
+            }
+        }
+    }
+
+overflow:
+    // Overflowed - move to end of this integer
+    while (true) {
+        if ((*src) == src_end) {
+            *src = 0;
+            return false;
+        }
+        part = static_cast<om_byte>(**src);
+        (*src)++;
+        if ((part & 0x80) == 0) return false;
+    }
+}
+
 /** Generates a packed representation of an integer.
  *
  *  @param value  The integer to represent.