Use __COMPILER_CELL_SHIFT instead of cellbytes in a lot of places.

Author: Y_Less

YSI_Coding/y_inline/y_inline_impl2.inc

@@ -414,7 +414,7 @@ static stock Inline_FoundDescriptor(size, data[E_INLINE_DATA])
 		}
 		default:
 		{
-			data[E_INLINE_DATA_PARAMETERS][data[E_INLINE_DATA_PARAMETER_COUNT]++] = size * cellbytes;
+			data[E_INLINE_DATA_PARAMETERS][data[E_INLINE_DATA_PARAMETER_COUNT]++] = size << __COMPILER_CELL_SHIFT;
 			data[E_INLINE_DATA_STATE] |= 8;
 		}
 	}
@@ -1174,7 +1174,7 @@ static stock Callback_InlineByName(const name[], tag)
 					frm = ptr + AMX_Read(ret + cellbytes),
 					args = Inline_NumArgs(frm),
 					size = frm - ptr + 12 + args,
-					Alloc:closure = malloc(size / cellbytes + _:E_INLINE_CALL - 1);
+					Alloc:closure = malloc((size >>> __COMPILER_CELL_SHIFT) + (_:E_INLINE_CALL - 1));
 				if (!closure)
 					return 0;
 				mset(closure, _:E_INLINE_CALL_NULL, 0);
@@ -1676,7 +1676,7 @@ static stock Inline_GenerateLocalsStore(ctx[AsmContext], const parameters[], cou
 				@emit STACK            accumulate
 			accumulate = 0;
 			@emit POP.alt
-			@emit SREF.S.alt       count * cellbytes + 12
+			@emit SREF.S.alt       (count << __COMPILER_CELL_SHIFT) + 12
 		}
 		case 0:
 			accumulate += cellbytes;
@@ -1962,7 +1962,7 @@ stock Inline_UI_(const &header)
 		// storage.  The other option would be allocating it separately later
 		// when we determine it is needed, but that would be no faster in the
 		// common case, and slower in the uncommon case, so just do it together.
-		Alloc:closure = malloc(size / cellbytes + _:E_INLINE_CALL - 1);
+		Alloc:closure = malloc((size >>> __COMPILER_CELL_SHIFT) + (_:E_INLINE_CALL - 1));
 	P:5("Inline_UI_: %d %d %d %d %d", ptr, frm, size, _:closure, AMX_Read(header));
 	if (!closure)
 		return 0;

YSI_Coding/y_va/y_va_impl.inc

@@ -319,7 +319,7 @@ static stock YVA2_CodeGenDeepCleanup(ctx[AsmContext], depth, returningString)
 	if (returningString)
 		@emit POP.pri
 	// Remove all the temporary storage locations.
-	@emit STACK        depth * cellbytes
+	@emit STACK        (depth << __COMPILER_CELL_SHIFT)
 }
 
 static stock YVA2_CodeGenPushVariable(ctx[AsmContext], stack)
@@ -387,7 +387,7 @@ static stock YVA2_FoundCall(const m[CodeScanner])
 			new
 				dest = YSI_g_sContexts[pos][AsmContext_buffer];
 			// First, rewrite the `___` call-site to call `YVA2_DoPush` instead.
-			YVA2_CodeGenPushSite(YSI_g_sContexts[pos], hole, YSI_g_sSkips[pos], -YSI_g_sStacks[0] - pos * cellbytes), // YSI_g_sStacks[0]!!!
+			YVA2_CodeGenPushSite(YSI_g_sContexts[pos], hole, YSI_g_sSkips[pos], -YSI_g_sStacks[0] - (pos << __COMPILER_CELL_SHIFT)), // YSI_g_sStacks[0]!!!
 			// Shift the code up.
 			YVA2_CodeGenShiftCode(
 				dest + YSI_g_sContexts[pos][AsmContext_buffer_offset],
@@ -398,7 +398,7 @@ static stock YVA2_FoundCall(const m[CodeScanner])
 			YSI_g_sContexts[pos][AsmContext_buffer_offset] = (end - dest) - (YSI_g_sLength[pos] - codeLength + returningString) - 16;
 			if (len == 24)
 				YSI_g_sContexts[pos][AsmContext_buffer_offset] -= 8;
-			YVA2_CodeGenPushVariable(YSI_g_sContexts[pos], -YSI_g_sStacks[0] - pos * cellbytes);
+			YVA2_CodeGenPushVariable(YSI_g_sContexts[pos], -YSI_g_sStacks[0] - (pos << __COMPILER_CELL_SHIFT));
 			YSI_g_sContexts[pos][AsmContext_buffer_offset] += 8;
 			if (returningString == 12)
 				YSI_g_sContexts[pos][AsmContext_buffer_offset] += 8;

YSI_Core/y_core/y_compilerdata.inc

@@ -543,6 +543,23 @@ const __CompilerDefault:__COMPILER_DEFAULT = __CompilerDefault:0;
 	#error YSI assumes `charbits` is 8.
 #endif
 
+#define __COMPILER_CELL_BYTES cellbytes
+#define __COMPILER_CELL_BITS  cellbits
+#define __COMPILER_CHAR_BITS  charbits
+
+// How much to adjust a cellcount by to get a byte count.
+#if cellbits == 8
+	#define __COMPILER_CELL_SHIFT (0)
+#elseif cellbits == 16
+	#define __COMPILER_CELL_SHIFT (1)
+#elseif cellbits == 32
+	#define __COMPILER_CELL_SHIFT (2)
+#elseif cellbits == 64
+	#define __COMPILER_CELL_SHIFT (3)
+#else
+	#error Unknown cellbits size.
+#endif
+
 #define FUNCTION_LENGTH (__COMPILER_sNAMEMAX + 1)
 
 #if defined _INC_indirection

YSI_Core/y_core/y_debug_impl.inc

@@ -729,7 +729,7 @@ native Debug_PrintQ_PRINT(const str[], const expr[], &Debug_PrintQ_SIZEOF:size,
 static stock bool:Debug_IsStringLike(addr, len = 256)
 {
 	new i = 0;
-	len *= cellbytes;
+	len = len << __COMPILER_CELL_SHIFT;
 	for (i = 0; i != len; i += cellbytes)
 	{
 		new ch = AMX_Read(addr + i);

YSI_Core/y_core/y_scriptinit_impl.inc

@@ -418,7 +418,7 @@ stock Server_PrintIntroMessage(...)
 		// Header.
 		YSI_Print(YSI_gscSpacer);
 		// Body.
-		for (new i = 3 * cellbytes, j = 3 * cellbytes + numargs() * cellbytes, a = 0; i != j; i += cellbytes)
+		for (new i = 3 * cellbytes, j = (numargs() << __COMPILER_CELL_SHIFT) + (3 * cellbytes), a = 0; i != j; i += cellbytes)
 		{
 			#emit LCTRL          5
 			#emit LOAD.S.alt     i
@@ -466,7 +466,7 @@ stock Server_PrintIntroPart(...)
 			YSI_Print(YSI_gscSpacer);
 		}
 		// Body.
-		for (new i = 3 * cellbytes, j = 3 * cellbytes + numargs() * cellbytes, a = 0; i != j; i += cellbytes)
+		for (new i = 3 * cellbytes, j = 3 * cellbytes + (numargs() << __COMPILER_CELL_SHIFT), a = 0; i != j; i += cellbytes)
 		{
 			#emit LCTRL          5
 			#emit LOAD.S.alt     i

YSI_Core/y_core/y_utils_impl.inc

@@ -1257,7 +1257,7 @@ stock Base64Encode(dest[], const src[], num = sizeof (src), len = sizeof (dest),
 		sEncoding[65 char] = !"DCBAHGFELKJIPONMTSRQXWVUbaZYfedcjihgnmlkrqpovutszyxw32107654/+98",
 		//tmp,
 		ret = 0;
-	num *= cellbytes;
+	num = num << __COMPILER_CELL_SHIFT;
 	if (len <= ceildiv(num, 3))
 	{
 		// How many complete chunks can we fit in?
@@ -1449,9 +1449,9 @@ stock Base64Decode(dest[], const src[], len = sizeof (dest), offset = 0)
 		num = 0;
 	// Work out the final length.  Subtract some for incomplete bytes and
 	// insufficient destination data.
-	num = strlen(src);
-	len *= cellbytes;
-	blocks = num / cellbytes;
+	num = strlen(src),
+	len = len << __COMPILER_CELL_SHIFT,
+	blocks = num >>> __COMPILER_CELL_SHIFT;
 	if (src{num - 1}  == '=')
 	{
 		--blocks;
@@ -3022,7 +3022,7 @@ stock bool:Files_CopyRange(File:i, end, const string:dst[])
 	// Must start at the start...
 	new
 		File:o = fopen(dst, io_write),
-		count = min(YSI_UNSAFE_HUGE_LENGTH, end / cellbytes);
+		count = min(YSI_UNSAFE_HUGE_LENGTH, end >>> __COMPILER_CELL_SHIFT);
 	if (!o)
 	{
 		return false;

YSI_Data/y_jaggedarray/y_jaggedarray_impl.inc

@@ -407,7 +407,7 @@ stock bool:_Jagged_Move(array[][], size1, size2, ...)
 stock _Jagged_Empty(array[][], size1, size2)
 {
 	// The size of the main storage area, including the header.
-	size2 = (size1 + size1 * size2) * cellbytes;
+	size2 = (size1 * size2 + size1) << __COMPILER_CELL_SHIFT;
 	while (--size1)
 	{
 		#emit LOAD.S.pri array

YSI_Data/y_sortedarray/y_sortedarray_entry.inc

@@ -215,13 +215,13 @@ stock bool:_Sorted_Add(arr[], &size, value, max = sizeof (arr))
 	else if (arr[0] >= value)
 	{
 		// New smallest value.
-		memcpy(arr[1], arr[0], 0, size * cellbytes, max - 1);
+		memcpy(arr[1], arr[0], 0, size << __COMPILER_CELL_SHIFT, max - 1);
 		arr[0] = value;
 	}
 	else
 	{
 		new idx = _Sorted_FindInsert(arr, size, value);
-		memcpy(arr[idx + 1], arr[idx], 0, (size - idx) * cellbytes, max - idx - 1);
+		memcpy(arr[idx + 1], arr[idx], 0, (size - idx) << __COMPILER_CELL_SHIFT, max - idx - 1);
 		arr[idx] = value;
 	}
 	++size;
@@ -254,7 +254,7 @@ stock bool:_Sorted_Remove(arr[], &size, value)
 		return true;
 	}
 	// We are shrinking the array, so the destination size doesn't matter.
-	memcpy(arr[idx], arr[idx + 1], 0, (size - idx) * cellbytes, cellmax);
+	memcpy(arr[idx], arr[idx + 1], 0, (size - idx) << __COMPILER_CELL_SHIFT, cellmax);
 	return true;
 }
 #define Sorted_Remove SORTED_FUNC_N<Sorted_Remove>

YSI_Storage/y_bitmap/y_bitmap_read.inc

@@ -110,15 +110,15 @@ static stock bool:Bitmap_ReadHeader(File:bmp, &x, &y)
 native Bitmap_FBlockReadAddr(File:file, addr, size) = fblockread;
 native Bitmap_FBlockReadRef(File:file, &ref, size) = fblockread;
 
-#define BITMAP_TO_32(%0) ((%0) * cellbytes)
+#define BITMAP_TO_32(%0) ((%0) * 4)
 #define BITMAP_TO_24(%0) ((%0) * 3) // * 3 / BITMAP_TO_32(4), cancels.
 
 static stock bool:Bitmap_ReadBody(Bitmap:ctx, File:bmp)
 {
 	// Allocate the memory for the main input.  We don't need to use `CEILDIV`
 	// here because the BMP file format body is always an exact multiple of 4.
 	new
-		width = Bitmap_Width(ctx) * cellbytes,
+		width = Bitmap_Width(ctx) << __COMPILER_CELL_SHIFT,
 		size = ceildiv(width * 3, 4 * cellbytes),
 		Alloc:input = malloc(size);
 	if (!input)
@@ -129,7 +129,7 @@ static stock bool:Bitmap_ReadBody(Bitmap:ctx, File:bmp)
 
 	new
 		y = Bitmap_Height(ctx),
-		dest = _:ctx * cellbytes + y * width;
+		dest = (_:ctx << __COMPILER_CELL_SHIFT) + y * width;
 	#emit CONST.pri            YSI_gMallocMemory
 	#emit LOAD.S.alt           dest
 	#emit ADD

YSI_Storage/y_xml/y_xml_entry.inc

@@ -249,7 +249,7 @@ stock XML_Parse(XML:rule, const filename[])
 						// use this as a handy break point for long lines.
 						++pos;
 						lineOffset = sizeof (line) - 1 - pos;
-						memcpy(line, line[pos], 0, lineOffset * cellbytes);
+						memcpy(line, line[pos], 0, lineOffset << __COMPILER_CELL_SHIFT);
 						break;
 					}
 					++pos;