Long overdue varint32 rework

Author: dcodeIO

dist/ByteBufferAB.js

@@ -312,6 +312,22 @@
     ByteBuffer.isByteBuffer = function(bb) {
         return (bb && bb["__isByteBuffer__"]) === true;
     };
+    // TODO
+
+    /**
+     * Registers an additional string encoding.
+     * @param {string} name Short name of the encoding (i.e. "utf8")
+     * @param {function(!ByteBuffer, string, number)} fromString A function capable of decoding a string using this encoding
+     *  to a ByteBuffer
+     * @param {function(!ByteBuffer, number, number)} toString A function capable of encoding a string using this encoding
+     *  from a ByteBuffer
+     */
+    ByteBuffer.registerEncoding = function(name, fromString, toString) {
+        ByteBuffer.ENCODINGS[name] = {
+            fromString: fromString,
+            toString: toString
+        };
+    };
     /**
      * Gets the backing buffer type.
      * @returns {Function} `Buffer` under node.js, `ArrayBuffer` in the browser (classes)
@@ -1526,46 +1542,22 @@
         if (offset > capacity10)
             this.resize((capacity10 *= 2) > offset ? capacity10 : offset);
         offset -= size;
-        // ref: http://code.google.com/searchframe#WTeibokF6gE/trunk/src/google/protobuf/io/coded_stream.cc
-        this.view[offset] = b = value | 0x80;
         value >>>= 0;
-        if (value >= 1 << 7) {
-            b = (value >> 7) | 0x80;
-            this.view[offset+1] = b;
-            if (value >= 1 << 14) {
-                b = (value >> 14) | 0x80;
-                this.view[offset+2] = b;
-                if (value >= 1 << 21) {
-                    b = (value >> 21) | 0x80;
-                    this.view[offset+3] = b;
-                    if (value >= 1 << 28) {
-                        this.view[offset+4] = (value >> 28) & 0x0F;
-                        size = 5;
-                    } else {
-                        this.view[offset+3] = b & 0x7F;
-                        size = 4;
-                    }
-                } else {
-                    this.view[offset+2] = b & 0x7F;
-                    size = 3;
-                }
-            } else {
-                this.view[offset+1] = b & 0x7F;
-                size = 2;
-            }
-        } else {
-            this.view[offset] = b & 0x7F;
-            size = 1;
+        while (value >= 0x80) {
+            b = (value & 0x7f) | 0x80;
+            this.view[offset++] = b;
+            value >>>= 7;
         }
+        this.view[offset++] = value;
         if (relative) {
-            this.offset += size;
+            this.offset = offset;
             return this;
         }
         return size;
     };
 
     /**
-     * Writes a zig-zag encoded 32bit base 128 variable-length integer.
+     * Writes a zig-zag encoded (signed) 32bit base 128 variable-length integer.
      * @param {number} value Value to write
      * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by the number of bytes
      *  written if omitted.
@@ -1596,36 +1588,33 @@
             if (offset < 0 || offset + 1 > this.buffer.byteLength)
                 throw RangeError("Illegal offset: 0 <= "+offset+" (+"+1+") <= "+this.buffer.byteLength);
         }
-        // ref: src/google/protobuf/io/coded_stream.cc
-        var size = 0,
+        var c = 0,
             value = 0 >>> 0,
-            temp,
-            ioffset;
+            b;
         do {
-            ioffset = offset+size;
-            if (!this.noAssert && ioffset > this.limit) {
+            if (!this.noAssert && offset > this.limit) {
                 var err = Error("Truncated");
                 err['truncated'] = true;
                 throw err;
             }
-            temp = this.view[ioffset];
-            if (size < 5)
-                value |= ((temp&0x7F)<<(7*size)) >>> 0;
-            ++size;
-        } while ((temp & 0x80) === 0x80);
-        value = value | 0; // Make sure to discard the higher order bits
+            b = this.view[offset++];
+            if (c < 5)
+                value |= (b & 0x7f)<<(7*c);
+            ++c;
+        } while ((b & 0x80) !== 0);
+        value |= 0;
         if (relative) {
-            this.offset += size;
+            this.offset = offset;
             return value;
         }
         return {
             "value": value,
-            "length": size
+            "length": c
         };
     };
 
     /**
-     * Reads a zig-zag encoded 32bit base 128 variable-length integer.
+     * Reads a zig-zag encoded (signed) 32bit base 128 variable-length integer.
      * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by the number of bytes
      *  written if omitted.
      * @returns {number|!{value: number, length: number}} The value read if offset is omitted, else the value read
@@ -1717,6 +1706,9 @@
             return value.shiftRightUnsigned(1).xor(value.and(Long.ONE).toSigned().negate()).toSigned();
         };
 
+        var Long0x80 = Long.fromNumber(0x80),
+            Long0x7f = Long.fromNumber(0x7f);
+
         /**
          * Writes a 64bit base 128 variable-length integer.
          * @param {number|Long} value Value to write