FEAT: added support for EncodedU32 in BINARY's read and write

EncodedU32 is used in Adobe's SWF files. It defines an 32-bit unsigned integer as a sequence of 1 to 5 bytes. The most significant bit of a byte indicates if the next byte is also part of the value. The byte are ordered low to high.

Author: Oldes

src/core/u-bincode.c

@@ -114,6 +114,17 @@ system/standard/bincode: make object! [
 ]
 
 ***********************************************************************/
+
+static REBCNT EncodedU32_Size(u32 value) {
+	REBCNT count = 0;
+	if (value == 0) return 1;
+	else while (value > 0) {
+		value = value >> 7;
+		count++;
+	}
+	return count;
+}
+
 /***********************************************************************
 **
 */	REBNATIVE(binary)
@@ -153,7 +164,8 @@ system/standard/bincode: make object! [
 	REBYTE *cp, *bp, *ep;
 	REBCNT n, count, index, tail, tail_new;
 	i32 i, len;
-	//u64 u;
+	u64 u;
+	u32 ulong;
 
 	REBVAL *value, *next;
 	REBVAL *data;
@@ -408,6 +420,14 @@ system/standard/bincode: make object! [
 							continue;
 						}
 						goto error;
+
+					case SYM_ENCODEDU32:
+						if (IS_INTEGER(next)) {
+							count += EncodedU32_Size(VAL_INT64(next));
+							continue;
+						}
+						goto error;
+						
 					case SYM_UNIXTIME_NOW:
 					case SYM_UNIXTIME_NOW_LE:
 						value--; //there is no argument so no next
@@ -654,6 +674,22 @@ system/standard/bincode: make object! [
 						cp = BIN_DATA(bin) + VAL_INDEX(buffer_write);
 						n = 0;
 						break;
+
+					case SYM_ENCODEDU32:
+						ASSERT_U32_RANGE(next);
+						ulong = (u32)VAL_INT64(next);
+						if (ulong == 0) {
+							n = 1;
+							cp[0] = 0;
+						} else {
+							n = EncodedU32_Size(VAL_INT64(next));
+							for (u = 0; u < n-1; u++) {
+								cp[u] = (char)(128 + ((ulong >> (u * 7)) & 127));
+							}
+							cp[n-1] = (char)((ulong >> ((n-1) * 7)) & 255);
+						}
+						break;
+
 					case SYM_UNIXTIME_NOW:
 						value--; // no args
 						n = 4;
@@ -879,6 +915,38 @@ system/standard/bincode: make object! [
 							}
 							n++;
 							break;
+						case SYM_ENCODEDU32:
+							ASSERT_READ_SIZE(value, cp, ep, 1);
+							u = (u64)cp[0];
+							if (!(u & 0x00000080)) {
+								n = 1;
+								goto setEnU32Result;
+							}
+							ASSERT_READ_SIZE(value, cp, ep, 2);
+							u = (u & 0x0000007f) | cp[1] << 7;
+							if (!(u & 0x00004000)) {
+								n = 2;
+								goto setEnU32Result;
+							}
+							ASSERT_READ_SIZE(value, cp, ep, 3);
+							u = (u & 0x00003fff) | cp[2] << 14;
+							if (!(u & 0x00200000)) {
+								n = 3;
+								goto setEnU32Result;
+							}
+							ASSERT_READ_SIZE(value, cp, ep, 4);
+							u = (u & 0x001fffff) | cp[3] << 21;
+							if (!(u & 0x10000000)) {
+								n = 4;
+								goto setEnU32Result;
+							}
+							ASSERT_READ_SIZE(value, cp, ep, 5);
+							u = (u & 0x0fffffff) | cp[4] << 28;
+							n = 5;
+						setEnU32Result:
+							VAL_SET(temp, REB_INTEGER);
+							VAL_UNT64(temp) = u & 0xffffffff; // limits result to 32 bit unsigned integer!
+							break;
 						case SYM_UB:
 							next = ++value;
 							if (IS_GET_WORD(next)) next = Get_Var(next);

src/tests/units/bincode-test.r3

@@ -230,6 +230,20 @@ is-protected-error?: func[code][
 		b: binary 2#{01011011 10110011 11111111}
 		--assert [2 -2 3 -3 255] = binary/read b [SB 3 SB 3 UB 2 SB 4 ALIGN UI8]
 
+	--test-- "BinCode - EncodedU32"
+		b: binary/init none 16
+		binary/write b [
+			EncodedU32 0
+			EncodedU32 1
+			EncodedU32 128
+			EncodedU32 129
+			EncodedU32 130
+			EncodedU32 2214768806
+		]
+		--assert b/buffer = #{0001800181018201A6E18AA008}
+		--assert [0 1 128 129 130 2214768806] = binary/read b [
+			EncodedU32 EncodedU32 EncodedU32 EncodedU32 EncodedU32 EncodedU32]
+
 ===end-group===