strlib.inc

#if defined STRLIB_INC
	#endinput
#endif
#define STRLIB_INC
#include <a_samp>
#if !defined STRLIB_BUFFER_SIZE
	#define STRLIB_BUFFER_SIZE  2048
#endif
#if !defined STRLIB_RETURN_SIZE
	#define STRLIB_RETURN_SIZE  128
#endif
#if !defined STRLIB_USE_FORMATEX
	#if defined __fmt_funcinc
		#if !defined FormatSpecifier
			#error Please include formatex before strlib.
		#endif
		#define STRLIB_USE_FORMATEX  true
	#else
		#define STRLIB_USE_FORMATEX  false
	#endif
#endif
enum trim_edges {
	trim_left  = 1,
	trim_right = 2,
	trim_both = trim_left | trim_right
};
enum string_edges {
	edge_left  = 1,
	edge_right = 2,
	edge_both = edge_left | edge_right
};
forward sprintf(const fmat[], {Float, _}:...);
forward strgetfirstc(const string[]);
forward strgetc(const string[], index);
forward strsize(const string[]);
forward bool:isempty(const string[]);
forward bool:isequal(const str1[], const str2[], bool:ignorecase = false);
forward strdistance(const str1[], const str2[], bool:ignorecase = false);
forward strexplode(output[][], const input[], const delimiter[] = !",", limit = cellmax, bool:trim = true, bool:ignorecase = false, size1 = sizeof(output), size2 = sizeof(output[]));
forward strimplode(const glue[], output[], maxlength = sizeof(output), ...);
forward strreplace(string[], const search[], const replacement[], bool:ignorecase = false, pos = 0, limit = -1, maxlength = sizeof(string));
forward strtrim(string[], const chars[] = !"", string_edges:edge = edge_both);
forward strpad(string[], length, const substr[] = !" ", string_edges:edge = edge_both, bool:trim_first = true, const trim_chars[] = !"", maxlength = sizeof(string), const input[] = !"");
forward strwrap(const left[], string[], const right[], maxlength = sizeof(string));
forward strcount(const string[], const sub[], bool:ignorecase = false, bool:count_overlapped = false);
forward bool:strfromliteral(output[], const input[], &pos = 0, maxlength = sizeof(output));
forward strtoliteral(output[], const input[], maxlength = sizeof(output), bool:paranoid = true);
forward strfrombin(output[], const input[], inputlength = sizeof(input), maxlength = sizeof(output));
forward strtobin(output[], const input[], maxlength = sizeof(output));
forward strcatmid(dest[], const source[], start = 0, end = -1, maxlength = sizeof(dest));
forward utf8encode(dest[], const source[], maxlength = sizeof(dest));
forward utf8decode(dest[], const source[], maxlength = sizeof(dest));
forward strurldecode(output[], const input[], maxlength = sizeof(output));
forward strurlencode(output[], const input[], maxlength = sizeof(output), bool:pack = false);
forward ret_strcatmid(const string[], const source[], start = 0, end = -1);
forward ret_strfrombin(const input[], inputlength = sizeof(input));
forward ret_strimplode(const glue[], ...);
forward ret_strreplace(const string[], const search[], const replacement[], bool:ignorecase = false, pos = 0, limit = -1);
forward ret_strfromliteral(const input[], &pos = 0);
forward ret_strtoliteral(const input[], bool:paranoid = true);
forward ret_strtrim(const string[], const chars[] = !"", string_edges:edge = edge_both);
forward ret_strpad(const string[], length, const substr[] = !" ", string_edges:edge = edge_both, bool:trim_first = true, const trim_chars[] = !"");
forward ret_strwrap(const left[], const string[], const right[]);
forward ret_strurldecode(const input[]);
forward ret_strurlencode(const input[], bool:pack = false);
forward ret_utf8encode(const input[]);
forward ret_utf8decode(const input[]);
forward ret_strpack(const source[]);
forward ret_strunpack(const source[]);
forward ret_strcat(const string1[], const string2[]);
forward ret_strmid(const source[], start, end);
forward ret_strins(const string[], const substr[], pos, maxlength = sizeof(string));
forward ret_strdel(const string[], start, end);
forward ret_valstr(value, bool:pack = false);
forward ret_GetPlayerName(playerid, bool:pack = false);
stock
	g_StrlibBuffer[2048]
;
forward _strlib_funcinc();
public _strlib_funcinc() {
	new temp[1];
	format(!temp, 0, !temp);
	strcat(temp, temp);
	strpack(temp, temp);
	strunpack(temp, temp);
}
static stock RedirectArgument(arg, ...) {
	#emit LOAD.S.pri  0
	#emit ADD.C       12
	#emit LOAD.S.alt  arg
	#emit SHL.C.alt   2
	#emit ADD
	#emit MOVE.alt
	#emit LOAD.S.pri  16
	#emit STOR.I
}
static stock CopyArgumentToHeap(arg, bool:pack = false, const argptr[] = "") {
	new arg_address, address;
	#emit LOAD.S.pri  0
	#emit ADD.C       12
	#emit LOAD.S.alt  arg
	#emit SHL.C.alt   2
	#emit ADD
	#emit LOAD.I
	#emit STOR.S.pri  arg_address
	#emit STOR.S.pri  argptr
	if (pack) {
		new bytes = ((strlen(argptr) + 1 + 3) / 4) * 4;
		#emit LCTRL       2
		#emit STOR.S.pri  address
		#emit LOAD.S.alt  bytes
		#emit ADD
		#emit SCTRL       2
		#emit LOAD.S.pri  bytes
		#emit SHR.C.pri   2
		#emit PUSH.pri
		#emit PUSH.S      arg_address
		#emit PUSH.S      address
		#emit PUSH.C      12
		#emit SYSREQ.C    strpack
		#emit STACK       16
	} else {
		new bytes = (strlen(argptr) + 1) * 4;
		#emit LCTRL       2
		#emit STOR.S.pri  address
		#emit LOAD.S.alt  bytes
		#emit ADD
		#emit SCTRL       2
		#emit LOAD.S.pri  bytes
		#emit SHR.C.pri   2
		#emit PUSH.pri
		#emit PUSH.S      arg_address
		#emit PUSH.S      address
		#emit PUSH.C      12
		#emit SYSREQ.C    strunpack
		#emit STACK       16
	}
	#emit LOAD.S.pri  0
	#emit ADD.C       12
	#emit LOAD.S.alt  arg
	#emit SHL.C.alt   2
	#emit ADD
	#emit MOVE.alt
	#emit LOAD.S.pri  address
	#emit STOR.I
	return address;
}
static stock RestoreHeapToAddress(address) {
	#emit LOAD.S.pri  address
	#emit SCTRL       2
}
static stock IsOverlapping(const str1[], size1 = sizeof(str1), const str2[], size2 = sizeof(str2)) {
	new addr1, addr2;
	if (size1 == -1) {
		size1 = strsize(str1);
	} else {
		size1 *= 4;
	}
	if (size2 == -1) {
		size2 = strsize(str2);
	} else {
		size2 *= 4;
	}
	#emit LOAD.S.pri  str1
	#emit STOR.S.pri  addr1
	#emit LOAD.S.pri  str2
	#emit STOR.S.pri  addr2
	return (addr1 < addr2 + size2) && (addr2 < addr1 + size1);
}
#if !defined ispacked
    #define ispacked(%1) \
        ((%1)[0] > 255)
#endif
stock strgetfirstc(const string[]) {
	return ispacked(string) ? string{0} : string[0];
}
stock strgetc(const string[], index) {
	if (index < 0)
		return '\0';
	new len = strlen(string);
	if (index >= len)
		return '\0';
	return ispacked(string) ? string{index} : string[index];
}
stock strsize(const string[]) {
	new len = strlen(string);
	if (ispacked(string))
		return len + 1;
	return (len + 1) * 4;
}
stock bool:isempty(const string[]) {
	if (ispacked(string))
		return string{0} == '\0';
	else
		return string[0] == '\0';
}
stock bool:isequal(const str1[], const str2[], bool:ignorecase = false) {
    new
        c1 = (str1[0] > 255) ? str1{0} : str1[0],
        c2 = (str2[0] > 255) ? str2{0} : str2[0]
    ;
    if (!c1 != !c2)
        return false;
    return !strcmp(str1, str2, ignorecase);
}
stock strdistance(const str1[], const str2[], bool:ignorecase = false) {
	if(isequal(str1, str2, ignorecase))
		return 0;
	static data[128][128];
	new bool:pack1 = ispacked(str1),
		bool:pack2 = ispacked(str2);
	new size1 = strlen(str1),
		size2 = strlen(str2);
	if (size1 == 0)
		return size2;
	if (size2 == 0)
		return size1;
	for (new i; i <= size1; i++)
		data[i][0] = i;
	for (new j; j <= size2; j++)
		data[0][j] = j;
	for (new j = 1; j <= size2; j++) {
		for (new i = 1; i <= size1; i++) {
			new char1 = pack1 ? str1{i - 1} : str1[i - 1],
				char2 = pack2 ? str2{j - 1} : str2[j - 1];
			if(ignorecase) {
				if (65 <= char1 <= 90)
					char1 += 32;
				if (65 <= char2 <= 90)
					char2 += 32;
			}
			if (char1 == char2)
				data[i][j] = data[i - 1][j - 1];
			else {
				new l1 = data[i - 1][j] + 1,
				l2 = data[i][j - 1] + 1,
				l3 = data[i - 1][j - 1] + 1;
				l2 = (l1 > l2 ? l2 : l1);
				data[i][j] = (l3 > l2 ? l2 : l3);
			}
		}
	}
	return data[size1][size2];
}
stock strimplode(const glue[], output[], maxlength = sizeof(output), ...) {
	new args = numargs();
	output[0] = '\0';
	for (new arg = 3; arg < args; arg++) {
		if (arg != 3)
			strcat(output, glue, maxlength);
		{
			#emit LCTRL       5
			#emit ADD.C       12
			#emit LOAD.S.alt  arg
			#emit SHL.C.alt   2
			#emit ADD
			#emit LOAD.I
			#emit PUSH.S      maxlength
			#emit PUSH.pri
			#emit PUSH.S      output
			#emit PUSH.C      12
			#emit SYSREQ.C    strcat
			#emit STACK       16
		}
	}
}
stock strexplode(output[][], const input[], const delimiter[] = !",", limit = cellmax, bool:trim = true, bool:ignorecase = false, size1 = sizeof(output), size2 = sizeof(output[])) {
	if (!size1 || !size2) {
		printf("(strexplode) ERROR: size1 = %d, size2 = %d. Can't be 0.", size1, size2);
		return 0;
	}
	if (isempty(delimiter)) {
		print(!"(strexplode) ERROR: delimiter is empty.");
		return 0;
	}
	if (trim) {
		new i = -1;
		if (ispacked(input)) {
			while (input{++i}) {
				if (input{i} > ' ') {
					i = -1;
					break;
				}
			}
		} else {
			while (input[++i]) {
				if (input[i] > ' ') {
					i = -1;
					break;
				}
			}
		}
		if (i != -1)
			return 0;
	} else if (isempty(input)) {
		return 0;
	}
	if (limit == 0) {
		return 0;
	} else if (limit == cellmax) {
		limit = 0;
	}
	new
		     pos = 0,
		     next,
		bool:packed = ispacked(input),
		     dlen = strlen(delimiter),
		     count = 0,
		     end
	;
	while (pos != -1) {
		++count;
		if (limit > 0 && count >= limit) {
			next = -1;
		} else {
			next = strfind(input, delimiter, ignorecase, pos);
		}
		end = (next == -1) ? cellmax : next;
		if (trim) {
			if (end == cellmax)
				end = strlen(input);
			if (packed) {
				while (0 < input{pos} <= ' ') pos++;
				while (end > 0 && input{end - 1} <= ' ') end--;
			} else {
				while (0 < input[pos] <= ' ') pos++;
				while (end > 0 && input[end - 1] <= ' ') end--;
			}
		}
		strmid(output[count - 1], input, pos, end, size2);
		if (count >= size1 || next == -1 || (limit < 0 && count >= -limit))
			break;
		pos = next + dlen;
	}
	return count;
}
stock strreplace(string[], const search[], const replacement[], bool:ignorecase = false, pos = 0, limit = -1, maxlength = sizeof(string)) {
    if (limit == 0)
        return 0;
    new
             sublen = strlen(search),
             replen = strlen(replacement),
        bool:packed = ispacked(string),
             maxlen = maxlength,
             len = strlen(string),
             count = 0
    ;
    if (packed)
        maxlen *= 4;
    if (!sublen)
        return 0;
    while (-1 != (pos = strfind(string, search, ignorecase, pos))) {
        strdel(string, pos, pos + sublen);
        len -= sublen;
        if (replen && len + replen < maxlen) {
            strins(string, replacement, pos, maxlength);
            pos += replen;
            len += replen;
        }
        if (limit != -1 && ++count >= limit)
            break;
    }
    return count;
}
stock strtrim(string[], const chars[] = !"", string_edges:edge = edge_both) {
	new bool:packed = ispacked(string);
	if (!strgetfirstc(chars)) {
		if (edge & edge_left) {
			new i = 0;
			if (packed)
				while (0 < string{i} <= ' ') i++;
			else
				while (0 < string[i] <= ' ') i++;
			if (i) {
				strdel(string, 0, i);
			}
		}
		if (edge & edge_right) {
			new i = strlen(string);
			if (i) {
				if (packed) {
					while (--i && 0 < string{i} <= ' ') {}
					string{i + 1} = '\0';
				} else {
					while (--i && 0 < string[i] <= ' ') {}
					string[i + 1] = '\0';
				}
			}
		}
	} else {
		if (edge & edge_left) {
			new i = 0, sub[2];
			if (packed) {
				while ((sub[0] = string{i})) {
					if (strfind(chars, sub) == -1)
						break;
					i++;
				}
				if (i) {
					strdel(string, 0, i);
				}
			} else {
				while ((sub[0] = string[i])) {
					if (strfind(chars, sub) == -1)
						break;
					i++;
				}
				if (i) strdel(string, 0, i);
			}
		}
		if (edge & edge_right) {
			new i = strlen(string), sub[2];
			if (i >= 0) {
				if (packed) {
					while (i--) {
						sub[0] = string{i};
						if (strfind(chars, sub) == -1)
							break;
					}
					string{i + 1} = '\0';
				} else {
					while (i--) {
						sub[0] = string[i];
						if (strfind(chars, sub) == -1)
							break;
					}
					string[i + 1] = '\0';
				}
			}
		}
	}
}
stock strpad(string[], length, const substr[] = !" ", string_edges:edge = edge_both, bool:trim_first = true, const trim_chars[] = !"", maxlength = sizeof(string), const input[] = !"") {
	if (trim_first) {
		strtrim(string, trim_chars, edge);
	}
	new
		     heap,
		     length_left = 0,
		     length_right = 0,
		     len = strlen(string),
		     sublen = strlen(substr),
		bool:packed,
		bool:subpacked = ispacked(substr)
	;
	if (len > length)
		return;
	else
		length -= len;
	#emit LOAD.S.pri  string
	#emit STOR.S.pri  input
	heap = CopyArgumentToHeap(7);
	string[0] = '\0';
	len = 0;
	switch (edge) {
		case edge_left:
			length_left = length;
		case edge_right:
			length_right = length;
		default:
			length_left = length / 2, length_right = length - length_left;
	}
	if (length_left) {
		while (len < length_left) {
			if (subpacked)
				strcat(string, substr, length_left * 4);
			else
				strcat(string, substr, length_left + 1);
			len += sublen;
		}
		if (subpacked)
			string{length_left} = 0;
	}
	strcat(string, input, maxlength);
	if (length_right) {
		len = strlen(string);
		length_right += len;
		packed = ispacked(string);
		while (len < length_right) {
			if (packed)
				strcat(string, substr, length_right / 4 + 1);
			else
				strcat(string, substr, length_right + 1);
			len += sublen;
		}
		if (packed)
			string{length_right + 1} = 0;
	}
	RestoreHeapToAddress(heap);
}
stock strwrap(const left[], string[], const right[], maxlength = sizeof(string)) {
	strins(string, left, 0, maxlength);
	strcat(string, right, maxlength);
}
stock strcount(const string[], const sub[], bool:ignorecase = false, bool:count_overlapped = false) {
	new
		increment = count_overlapped ? 1 : strlen(sub),
		pos = -increment,
		count = 0
	;
	while (-1 != (pos = strfind(string, sub, ignorecase, pos + increment)))
		count++;
	return count;
}
stock bool:strfromliteral(output[], const input[], &pos = 0, maxlength = sizeof(output)) {
	new
		     length = strlen(input),
			 c,
			 outlen = 0,
		     heap = 0
	;
	if (!length)
		return true;
	if (IsOverlapping(output, maxlength, input, -1))
		heap = CopyArgumentToHeap(1);
	output[0] = '\0';
	if (input[0] == '"')
		pos++;
	for (;; pos++) {
		if (outlen >= maxlength - 1 || pos >= length)
			break;
		c = input[pos];
		switch (c) {
			case '"': break;
			case '\\': {}
			default: {
				output[outlen++] = c;
				continue;
			}
		}
		if (pos == length - 1)
			goto return_false;
		c = input[++pos];
		switch (c) {
			case '"',
			    '\'',
			    '\\',
			     '%': output[outlen++] = c;
			case 'a': output[outlen++] = '\a';
			case 'b': output[outlen++] = '\b';
			case 'e': output[outlen++] = '\e';
			case 'f': output[outlen++] = '\f';
			case 'r': output[outlen++] = '\r';
			case 'n': output[outlen++] = '\n';
			case 't': output[outlen++] = '\t';
			case 'v': output[outlen++] = '\v';
			case 'x': {
				new val = 0;
				if (c == length - 1)
					goto return_false;
				while ((c = input[pos + 1])) {
					if ('a' <= c <= 'f' || 'A' <= c <= 'F') {
						val = (val << 4) + (tolower(c) - 'a' + 10);
					} else if ('0' <= c <= '9') {
						val = (val << 4) + (c - '0');
					} else {
						break;
					}
					pos++;
				}
				if (c == ';')
					pos++;
				output[outlen++] = val;
			}
			case '0' .. '9': {
				new val = 0;
				while ((c = input[pos])) {
					if ('0' <= c <= '9') {
						val = val * 10 + (c - '0');
					} else {
						break;
					}
					pos++;
				}
				if (c != ';') pos--;
				output[outlen++] = val;
			}
			default: {
				goto return_false;
			}
		}
	}
	output[outlen] = '\0';
	pos++;
	new bool:ret = true;
	#pragma unused ret
	goto return_true;
return_false:
	ret = false;
return_true:
	if (heap)
		RestoreHeapToAddress(heap);
	return ret;
}
stock strtoliteral(output[], const input[], maxlength = sizeof(output), bool:paranoid = true) {
	new i, c, outlen, heap = 0;
	if (IsOverlapping(output, maxlength, input, -1))
		heap = CopyArgumentToHeap(1);
	output[outlen++] = '"';
	for (i = 0; (c = input[i]); i++) {
		if (maxlength - outlen <= 3) {
			outlen = min(outlen, maxlength - 2);
			break;
		}
		switch (c) {
			case ' ', '!', '#' .. '[', ']', '^' .. '~':
				output[outlen++] = c;
			case  '"': strunpack(output[outlen], !"\\\"", 3), outlen += 2;
			case '\a': strunpack(output[outlen], !"\\a" , 3), outlen += 2;
			case '\b': strunpack(output[outlen], !"\\b" , 3), outlen += 2;
			case '\e': strunpack(output[outlen], !"\\e" , 3), outlen += 2;
			case '\f': strunpack(output[outlen], !"\\f" , 3), outlen += 2;
			case '\r': strunpack(output[outlen], !"\\r" , 3), outlen += 2;
			case '\n': strunpack(output[outlen], !"\\n" , 3), outlen += 2;
			case '\t': strunpack(output[outlen], !"\\t" , 3), outlen += 2;
			case '\v': strunpack(output[outlen], !"\\v" , 3), outlen += 2;
			case '\\': strunpack(output[outlen], !"\\\\" , 3), outlen += 2;
			default: {
				if (!paranoid && 0x80 <= c <= 0xFF) {
					output[outlen++] = c;
					continue;
				}
				if (maxlength - outlen <= 8)
					break;
				format(output[outlen], 7, "\\x%03x;", c);
				outlen += 6;
			}
		}
	}
	output[outlen++] = '"';
	output[outlen] = '\0';
	if (heap)
		RestoreHeapToAddress(heap);
}
stock strfrombin(output[], const input[], inputlength = sizeof(input), maxlength = sizeof(output)) {
	static const hex_chars[] = "0123456789ABCDEF";
	new outlen = 0, heap = 0;
	if (IsOverlapping(output, maxlength, input, -1))
		heap = CopyArgumentToHeap(1);
	for (new i = 0; i < inputlength; i++) {
		if (maxlength - outlen <= 7) {
			outlen = min(outlen, maxlength - 1);
			break;
		}
		new input_cell = input[i];
		output[outlen++] = hex_chars[(input_cell             ) >>> 28];
		output[outlen++] = hex_chars[(input_cell & 0x0F000000) >>> 24];
		output[outlen++] = hex_chars[(input_cell & 0x00F00000) >>> 20];
		output[outlen++] = hex_chars[(input_cell & 0x000F0000) >>> 16];
		output[outlen++] = hex_chars[(input_cell & 0x0000F000) >>> 12];
		output[outlen++] = hex_chars[(input_cell & 0x00000F00) >>>  8];
		output[outlen++] = hex_chars[(input_cell & 0x000000F0) >>>  4];
		output[outlen++] = hex_chars[(input_cell & 0x0000000F)       ];
	}
	output[outlen] = '\0';
	if (heap)
		RestoreHeapToAddress(heap);
}
stock strtobin(output[], const input[], maxlength = sizeof(output)) {
	new len = strlen(input), outlen = 0, heap = 0;
	if (IsOverlapping(output, maxlength, input, -1))
		heap = CopyArgumentToHeap(1);
	for (new i = 0; i < len;) {
		if (outlen >= maxlength || i > len - 8) {
			break;
		}
		new c, out = 0;
		#define ADD_OUT(%1) \
			c = input[i++]; out |= (('a' <= c <= 'f' || 'A' <= c <= 'F') ? (tolower(c) - 'a' + 10) : (c - '0')) << %1
		ADD_OUT(28);
		ADD_OUT(24);
		ADD_OUT(20);
		ADD_OUT(16);
		ADD_OUT(12);
		ADD_OUT(8);
		ADD_OUT(4);
		ADD_OUT(0);
		#undef ADD_OUT
		output[outlen++] = out;
	}
	if (heap)
		RestoreHeapToAddress(heap);
	return outlen;
}
stock strurlencode(output[], const input[], maxlength = sizeof(output), bool:pack = false) {
	static const hex_chars[] = "0123456789ABCDEF";
	new
		     len = strlen(input),
		bool:packed = ispacked(input),
		     outlen = 0,
		     heap = 0
	;
	if (IsOverlapping(output, maxlength, input, -1))
		heap = CopyArgumentToHeap(1, packed);
	if (pack)
		maxlength *= 4;
	for (new i = 0; i < len; i++) {
		if (maxlength - outlen <= 1)
			break;
		new c = packed ? input{i} : input[i];
		switch (c) {
			case 'a' .. 'z', 'A' .. 'Z', '0' .. '9', '_': {
				if (pack)
					output{outlen++} = c;
				else
					output[outlen++] = c;
			}
			case ' ': {
				if (pack)
					output{outlen++} = '+';
				else
					output[outlen++] = '+';
			}
			default: {
				if (maxlength - outlen <= 3)
					break;
				if (pack) {
					output{outlen++} = '%';
					output{outlen++} = hex_chars[(c & 0xF0) >>> 4];
					output{outlen++} = hex_chars[c & 0x0F];
				} else {
					output[outlen++] = '%';
					output[outlen++] = hex_chars[(c & 0xF0) >>> 4];
					output[outlen++] = hex_chars[c & 0x0F];
				}
			}
		}
	}
	if (pack)
		output{outlen} = '\0';
	else
		output[outlen] = '\0';
	if (heap)
		RestoreHeapToAddress(heap);
}
stock strurldecode(output[], const input[], maxlength = sizeof(output)) {
	new prev_pos = 0, pos = 0, inputlen = strlen(input), len, heap = 0;
	if (IsOverlapping(output, maxlength, input, -1))
		heap = CopyArgumentToHeap(1);
	output[0] = '\0';
	while (-1 != (pos = strfind(input, "%", _, pos))) {
		static str[2];
		new c;
		if (prev_pos != pos) {
			len = strlen(output);
			strcatmid(output, input, prev_pos, pos, maxlength);
			strreplace(output, "+", " ", _, len, _, maxlength);
		}
		if (inputlen < pos + 3)
			goto func_end;
		str[0] = 0;
		c = input[pos + 1]; str[0] |= (('a' <= c <= 'f' || 'A' <= c <= 'F') ? (tolower(c) - 'a' + 10) : (c - '0')) << 4;
		c = input[pos + 2]; str[0] |= (('a' <= c <= 'f' || 'A' <= c <= 'F') ? (tolower(c) - 'a' + 10) : (c - '0'));
		strcat(output, str, maxlength);
		prev_pos = (pos += 3);
	}
	len = strlen(output);
	strcatmid(output, input, prev_pos, _, maxlength);
	strreplace(output, "+", " ", _, len, _, maxlength);
func_end:
	if (heap)
		RestoreHeapToAddress(heap);
}
stock strcatmid(dest[], const source[], start = 0, end = -1, maxlength = sizeof(dest)) {
	new heap = 0;
	if (IsOverlapping(dest, maxlength, source, -1))
		heap = CopyArgumentToHeap(1);
	if (start == 0 && end == -1) {
		strcat(dest, source, maxlength);
	} else {
		if (end == -1)
			end = strlen(source);
		if (ispacked(dest)) {
			new len = strlen(dest);
			if (ispacked(source)) {
				strunpack(g_StrlibBuffer, source);
				strcat(dest, g_StrlibBuffer[start], min(maxlength, (len + end - start) / 4 + 1));
			} else {
				strcat(dest, source[start], min(maxlength, (len + end - start) / 4 + 1));
			}
			dest{len + end - start} = '\0';
		} else {
			if (ispacked(source)) {
				strunpack(g_StrlibBuffer, source);
				strcat(dest, g_StrlibBuffer[start], min(maxlength, strlen(dest) + end - start + 1));
			} else {
				strcat(dest, source[start], min(maxlength, strlen(dest) + end - start + 1));
			}
		}
	}
	if (heap)
		RestoreHeapToAddress(heap);
}
stock utf8encode(dest[], const source[], maxlength = sizeof(dest)) {
	new heap = 0;
	if (IsOverlapping(dest, maxlength, source, -1)) {
		heap = CopyArgumentToHeap(1);
	}
	new len = strlen(source);
	new packed = ispacked(source);
	dest[0] = '\0';
	new idx = 0;
	for (new i = 0; i < len; i++) {
		new c = packed ? source{i} : source[i];
		if (c >= 0x80) {
			if (c > 0x4000000) {
				dest[idx++] = 0b11111100 | ((c >>> 30) & 0b00000001);
				dest[idx++] = 0b10000000 | ((c >>> 24) & 0b00111111);
				dest[idx++] = 0b10000000 | ((c >>> 18) & 0b00111111);
				dest[idx++] = 0b10000000 | ((c >>> 12) & 0b00111111);
				dest[idx++] = 0b10000000 | ((c >>> 6) & 0b00111111);
				dest[idx++] = 0b10000000 | (c & 0b00111111);
			} else if (c > 0x200000) {
				dest[idx++] = 0b11111000 | ((c >>> 24) & 0b00000011);
				dest[idx++] = 0b10000000 | ((c >>> 18) & 0b00111111);
				dest[idx++] = 0b10000000 | ((c >>> 12) & 0b00111111);
				dest[idx++] = 0b10000000 | ((c >>> 6) & 0b00111111);
				dest[idx++] = 0b10000000 | (c & 0b00111111);
			} else if (c > 0x10000) {
				dest[idx++] = 0b11110000 | ((c >>> 18) & 0b00000111);
				dest[idx++] = 0b10000000 | ((c >>> 12) & 0b00111111);
				dest[idx++] = 0b10000000 | ((c >>> 6) & 0b00111111);
				dest[idx++] = 0b10000000 | (c & 0b00111111);
			} else if (c > 0x800) {
				dest[idx++] = 0b11100000 | ((c >>> 12) & 0b00001111);
				dest[idx++] = 0b10000000 | ((c >>> 6) & 0b00111111);
				dest[idx++] = 0b10000000 | (c & 0b00111111);
			} else {
				dest[idx++] = 0b11000000 | ((c >>> 6) & 0b00011111);
				dest[idx++] = 0b10000000 | (c & 0b00111111);
			}
		} else if (c > 0) {
			dest[idx++] = c;
		}
	}
	dest[idx] = '\0';
	if (heap) {
		RestoreHeapToAddress(heap);
	}
}
stock utf8decode(dest[], const source[], maxlength = sizeof(dest)) {
	new heap = 0;
	if (IsOverlapping(dest, maxlength, source, -1)) {
		heap = CopyArgumentToHeap(1);
	}
	new len = strlen(source);
	dest[0] = '\0';
	new idx = 0;
	for (new i = 0; i < len; i++) {
		new c = source[i];
		if (c & 0b10000000) {
			if (c & 0b11100000 == 0b11000000) {
				if (i + 1 >= len) continue;
				dest[idx++] = (c & 0b00011111) << 6 | (source[++i] & 0b00111111);
			} else if (c & 0b11110000 == 0b11100000) {
				if (i + 2 >= len) continue;
				dest[idx++] = (c & 0b00001111) << 12 |
				              (source[++i] & 0b00111111) << 6 |
				              (source[++i] & 0b00111111);
			} else if (c & 0b11111000 == 0b11110000) {
				if (i + 3 >= len) continue;
				dest[idx++] = (c & 0b00000111) << 18 |
				              (source[++i] & 0b00111111) << 12 |
				              (source[++i] & 0b00111111) << 6 |
				              (source[++i] & 0b00111111);
			} else if (c & 0b11111100 == 0b11111000) {
				if (i + 4 >= len) continue;
				dest[idx++] = (c & 0b00000011) << 24 |
				              (source[++i] & 0b00111111) << 18 |
				              (source[++i] & 0b00111111) << 12 |
				              (source[++i] & 0b00111111) << 6 |
				              (source[++i] & 0b00111111);
			} else if (c & 0b11111110 == 0b11111100) {
				if (i + 5 >= len) continue;
				dest[idx++] = (c & 0b00000001) << 30 |
				              (source[++i] & 0b00111111) << 24 |
				              (source[++i] & 0b00111111) << 18 |
				              (source[++i] & 0b00111111) << 12 |
				              (source[++i] & 0b00111111) << 6 |
				              (source[++i] & 0b00111111);
			}
		} else {
			dest[idx++] = c;
		}
	}
	dest[idx] = 0;
	if (heap) {
		RestoreHeapToAddress(heap);
	}
}
stock ret_strcatmid(const string[], const source[], start = 0, end = -1) {
	new output[STRLIB_RETURN_SIZE];
	strcat(output, string);
	strcatmid(output, source, start, end);
	return output;
}
stock ret_strfrombin(const input[], inputlength = sizeof(input)) {
	new output[STRLIB_RETURN_SIZE];
	strfrombin(output, input, inputlength);
	return output;
}
stock ret_strimplode(const glue[], ...) {
	new output[STRLIB_RETURN_SIZE];
	const maxlength = sizeof(output);
	new args = numargs();
	for (new arg = 1; arg < args; arg++) {
		if (arg != 1)
			strcat(output, glue, maxlength);
		{
			#emit LCTRL       5
			#emit ADD.C       12
			#emit LOAD.S.alt  arg
			#emit SHL.C.alt   2
			#emit ADD
			#emit LOAD.I
			#emit PUSH.C      maxlength
			#emit PUSH.pri
			#emit PUSH.ADR    output
			#emit PUSH.C      12
			#emit SYSREQ.C    strcat
			#emit STACK       16
		}
	}
	#emit LOAD.S.pri  8
	#emit ADD.C       12
	#emit MOVE.alt
	#emit LCTRL       5
	#emit ADD
	#emit LOAD.I
	#emit STOR.S.pri  20
	return output;
}
stock ret_strreplace(const string[], const search[], const replacement[], bool:ignorecase = false, pos = 0, limit = -1) {
	new output[STRLIB_RETURN_SIZE];
	strcat(output, string);
	strreplace(output, search, replacement, ignorecase, pos, limit);
	return output;
}
stock ret_strfromliteral(const input[], &pos = 0) {
	new output[STRLIB_RETURN_SIZE];
	strcat(output, input);
	strfromliteral(output, input, pos);
	return output;
}
stock ret_strtoliteral(const input[], bool:paranoid = true) {
	new output[STRLIB_RETURN_SIZE];
	strcat(output, input);
	strtoliteral(output, input, paranoid);
	return output;
}
stock ret_strtrim(const string[], const chars[] = !"", string_edges:edge = edge_both) {
	new output[STRLIB_RETURN_SIZE];
	strcat(output, string);
	strtrim(output, chars, edge);
	return output;
}
stock ret_strpad(const string[], length, const substr[] = !" ", string_edges:edge = edge_both, bool:trim_first = true, const trim_chars[] = !"") {
	new output[STRLIB_RETURN_SIZE];
	strcat(output, string);
	strpad(output, length, substr, edge, trim_first, trim_chars);
	return output;
}
stock ret_strwrap(const left[], const string[], const right[]) {
	new output[STRLIB_RETURN_SIZE];
	strcat(output, left);
	strcat(output, string);
	strcat(output, right);
	return output;
}
stock ret_strurldecode(const input[]) {
	new output[STRLIB_RETURN_SIZE];
	strcat(output, input);
	strurldecode(output, input);
	return output;
}
stock ret_strurlencode(const input[], bool:pack = false) {
	new output[STRLIB_RETURN_SIZE];
	strcat(output, input);
	strurlencode(output, input, _, pack);
	return output;
}
stock ret_utf8encode(const input[]) {
	new output[STRLIB_RETURN_SIZE];
	utf8encode(output, input);
	return output;
}
stock ret_utf8decode(const input[]) {
	new output[STRLIB_RETURN_SIZE];
	utf8decode(output, input);
	return output;
}
stock ret_strpack(const source[]) {
	new output[STRLIB_RETURN_SIZE];
	strpack(output, source);
	return output;
}
stock ret_strunpack(const source[]) {
	new output[STRLIB_RETURN_SIZE];
	strunpack(output, source);
	return output;
}
stock ret_strcat(const string1[], const string2[]) {
	new output[STRLIB_RETURN_SIZE];
	strcat(output, string1);
	strcat(output, string2);
	return output;
}
stock ret_strmid(const source[], start, end) {
	new output[STRLIB_RETURN_SIZE];
	strmid(output, source, start, end);
	return output;
}
stock ret_strins(const string[], const substr[], pos, maxlength = sizeof(string)) {
	new output[STRLIB_RETURN_SIZE];
	strcat(output, string);
	strins(output, substr, pos);
	return output;
}
stock ret_strdel(const string[], start, end) {
	new output[STRLIB_RETURN_SIZE];
	strcat(output, string);
	strdel(output, start, end);
	return output;
}
stock ret_valstr(value, bool:pack = false) {
	new output[STRLIB_RETURN_SIZE];
	format(output, sizeof(output), "%d", value);
	if (pack)
		strpack(output, output);
	return output;
}
stock ret_GetPlayerName(playerid, bool:pack = false) {
	new output[MAX_PLAYER_NAME];
	GetPlayerName(playerid, output, sizeof(output));
	if (pack)
		strpack(output, output);
	return output;
}
stock sprintf(const fmat[], {Float, _}:...) {
	static output[STRLIB_RETURN_SIZE], frm_header[3], heap;
	const output_size = sizeof(output);
	if (ispacked(fmat)) {
		heap = CopyArgumentToHeap(0);
	} else {
		heap = 0;
	}{}
	#emit LCTRL      5
	#emit CONST.alt  frm_header
	#emit MOVS       12
	#emit LOAD.S.alt  8
	#emit ADD.C    12
	#emit SCTRL    4
	#emit PUSH.C      output_size
	#emit PUSH.C      output
	#emit MOVE.pri
	#emit ADD.C       8
	#emit PUSH.pri
	#if !STRLIB_USE_FORMATEX
		const formatex = 0;
		goto do_sysreq;
	#endif
	#emit LCTRL       6
	#emit ADD.C       36
	#emit PUSH.pri
	#emit CONST.pri   formatex
	#emit SCTRL       6
	#if !STRLIB_USE_FORMATEX
		do_sysreq:
	#endif
	#emit SYSREQ.C    format
	#emit LCTRL       5
	#emit SCTRL       4
	#emit MOVE.alt
	#emit CONST.pri   frm_header
	#emit MOVS        12
	if (heap) {
		RestoreHeapToAddress(heap);
	}{}
	#emit LOAD.S.pri  8
	#emit ADD.C       12
	#emit MOVE.alt
	#emit LCTRL       5
	#emit ADD
	#emit LOAD.I
	#emit STOR.S.pri  20
	return output;
	#pragma unused fmat
}