libstr.cpp - asar coverage

libstr.cpp

Line	Branch	Exec	Source
1			#include "std-includes.h"
2			#include "libstr.h"
3			#include "virtualfile.h"
4			#include "asar.h"
5			#include "warnings.h"
6
7			#define typed_malloc(type, count) (type)malloc(sizeof(type)(count))
8			#define typed_realloc(type, ptr, count) (type)realloc(ptr, sizeof(type)(count))
9
10
11			// RPG Hacker: Functions below are copied over from Asar 2.0 branch for the sole purpose of generating
12			// non-UTF-8 deprecation warnings in 1.9. Don't know if there's a better way to handle this, but it means
13			// we should delete all of this again once we merge branches.
14
15			// vvvvvvvvvvvvvvvvvvvvvv
16
17			// Detects if str starts with a UTF-8 byte order mark.
18			// If so, throws a warning, then returns the number of bytes we should skip ahead in the string.
19		630	size_t check_bom(const char* str)
20			{
21			// RPG Hacker: We could also check for BoMs of incompatible encodings here (like UTF-16)
22			// and throw errors, but not sure if that's worth adding. Asar never supported any wide
23			// encodings to begin with, so it's unreasonable to assume that any UTF-16 patches currently
24			// exist for it. As for future patches, those should be caught by the "must be UTF-8" checks
25			// I have already implemented further below.
26			// I think UTF-8 + BoM is the only case that could lead to confusion if we didn't handle it,
27			// so that's why I have added this.
28	1/6 ✗ Branch 2 → 3 not taken. ✓ Branch 2 → 7 taken 630 times. ✗ Branch 3 → 4 not taken. ✗ Branch 3 → 7 not taken. ✗ Branch 4 → 5 not taken. ✗ Branch 4 → 7 not taken.	630	if (str[0u] == '\xEF' && str[1u] == '\xBB' && str[2u] == '\xBF')
29			{
30		✗	asar_throw_warning(0, warning_id_byte_order_mark_utf8);
31		✗	return 3u;
32			}
33
34		630	return 0u;
35			}
36
37
38		188438	size_t utf8_val(int* codepoint, const char* inp) {
39		188438	unsigned char c = *inp++;
40			int val;
41	1/2 ✓ Branch 2 → 3 taken 188438 times. ✗ Branch 2 → 4 not taken.	188438	if (c < 0x80) {
42			// plain ascii
43		188438	*codepoint = c;
44		188438	return 1u;
45			}
46			// RPG Hacker: Byte sequences starting with 0xC0 or 0xC1 are invalid.
47			// So are byte sequences starting with anything >= 0xF5.
48			// And anything below 0xC0 indicates a follow-up byte and should never be at the start of a sequence.
49		✗	else if (c > 0xC1 && c < 0xF5) {
50			// 1, 2 or 3 continuation bytes
51		✗	int cont_byte_count = (c >= 0xF0) ? 3 : (c >= 0xE0) ? 2 : 1;
52			// bit hack to extract the significant bits from the start byte
53		✗	val = (c & ((1 << (6 - cont_byte_count)) - 1));
54		✗	for (int i = 0; i < cont_byte_count; i++) {
55		✗	unsigned char next = *inp++;
56		✗	if ((next & 0xC0) != 0x80) {
57		✗	*codepoint = -1;
58		✗	return 0u;
59			}
60		✗	val = (val << 6) \| (next & 0x3F);
61			}
62		✗	if (// too many cont.bytes
63		✗	(*inp & 0xC0) == 0x80 \|\|
64
65			// invalid codepoints
66		✗	val > 0x10FFFF \|\|
67
68			// check overlong encodings
69		✗	(cont_byte_count == 3 && val < 0x1000) \|\|
70		✗	(cont_byte_count == 2 && val < 0x800) \|\|
71		✗	(cont_byte_count == 1 && val < 0x80) \|\|
72
73			// UTF16 surrogates
74		✗	(val >= 0xD800 && val <= 0xDFFF)
75			) {
76		✗	*codepoint = -1;
77		✗	return 0u;
78			};
79		✗	*codepoint = val;
80		✗	return 1u + cont_byte_count;
81			}
82
83			// if none of the above, this couldn't possibly be a valid encoding
84		✗	*codepoint = -1;
85		✗	return 0u;
86			}
87
88		630	bool is_valid_utf8(const char* inp) {
89	4/4 ✓ Branch 8 → 3 taken 93169 times. ✓ Branch 8 → 9 taken 315 times. ✓ Branch 11 → 3 taken 95269 times. ✓ Branch 11 → 12 taken 315 times.	189068	while (*inp != '\0') {
90		95269	int codepoint;
91		188438	inp += utf8_val(&codepoint, inp);
92
93	2/4 ✗ Branch 4 → 5 not taken. ✓ Branch 4 → 6 taken 93169 times. ✗ Branch 5 → 6 not taken. ✓ Branch 5 → 7 taken 95269 times.	188438	if (codepoint == -1) return false;
94			}
95
96		630	return true;
97			}
98
99			// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
100
101
102		230	char * readfile(const char * fname, const char * basepath)
103			{
104		230	virtual_file_handle myfile = filesystem->open_file(fname, basepath);
105	1/2 ✗ Branch 3 → 4 not taken. ✓ Branch 3 → 5 taken 230 times.	230	if (myfile == INVALID_VIRTUAL_FILE_HANDLE) return nullptr;
106		230	size_t datalen = filesystem->get_file_size(myfile);
107		230	char * data= typed_malloc(char, datalen+1);
108		230	data[filesystem->read_file(myfile, data, 0u, datalen)] = 0;
109		230	filesystem->close_file(myfile);
110		230	int inpos=0;
111		230	int outpos=0;
112		230	inpos += check_bom(data + inpos);
113	2/2 ✓ Branch 13 → 10 taken 159738 times. ✓ Branch 13 → 14 taken 230 times.	159968	while (data[inpos])
114			{
115	1/2 ✓ Branch 10 → 11 taken 159738 times. ✗ Branch 10 → 12 not taken.	159738	if (data[inpos]!='\r') data[outpos++]=data[inpos];
116		159738	inpos++;
117			}
118		230	data[outpos]=0;
119	1/2 ✗ Branch 15 → 16 not taken. ✓ Branch 15 → 17 taken 230 times.	230	if (!is_valid_utf8(data)) asar_throw_warning(0, warning_id_feature_deprecated, "non-UTF-8 source files", "Re-save the file as UTF-8 in a text editor of choice and avoid using non-ASCII characters in Asar versions < 2.0");
120		230	return data;
121			}
122
123			// RPG Hacker: like readfile(), but doesn't use virtual file system
124			// and instead read our file directly.
125		400	char * readfilenative(const char * fname)
126			{
127		400	FILE* myfile = fopen(fname, "rb");
128	1/2 ✗ Branch 3 → 4 not taken. ✓ Branch 3 → 5 taken 400 times.	400	if (myfile == nullptr) return nullptr;
129		400	fseek(myfile, 0, SEEK_END);
130		400	size_t datalen = (size_t)ftell(myfile);
131		400	fseek(myfile, 0, SEEK_SET);
132		400	char * data = typed_malloc(char, datalen + 1);
133		400	data[fread(data, 1u, datalen, myfile)] = 0;
134		400	fclose(myfile);
135		400	int inpos = 0;
136		400	int outpos = 0;
137		400	inpos += check_bom(data + inpos);
138	2/2 ✓ Branch 15 → 12 taken 28700 times. ✓ Branch 15 → 16 taken 400 times.	29100	while (data[inpos])
139			{
140	1/2 ✓ Branch 12 → 13 taken 28700 times. ✗ Branch 12 → 14 not taken.	28700	if (data[inpos] != '\r') data[outpos++] = data[inpos];
141		28700	inpos++;
142			}
143		400	data[outpos] = 0;
144	1/2 ✗ Branch 17 → 18 not taken. ✓ Branch 17 → 19 taken 400 times.	400	if (!is_valid_utf8(data)) asar_throw_warning(0, warning_id_feature_deprecated, "non-UTF-8 source files", "Re-save the file as UTF-8 in a text editor of choice and avoid using non-ASCII characters in Asar versions < 2.0");
145		400	return data;
146			}
147
148		232	bool readfile(const char * fname, const char * basepath, char ** data, int * len)
149			{
150		232	virtual_file_handle myfile = filesystem->open_file(fname, basepath);
151	2/2 ✓ Branch 3 → 4 taken 6 times. ✓ Branch 3 → 5 taken 226 times.	232	if (!myfile) return false;
152		226	size_t datalen = filesystem->get_file_size(myfile);
153		226	*data= typed_malloc(char, datalen);
154		226	len = (int)filesystem->read_file(myfile, data, 0, datalen);
155		226	filesystem->close_file(myfile);
156		226	return true;
157			}
158
159			#define dequote(var, next, error) \
160			if (var=='"') \
161			do { \
162			next; \
163			while (var!='"' && var != '\0') { \
164			if (!var) error; \
165			next; \
166			} \
167			if (var == '\0') error; \
168			next; \
169			} while(0); \
170			else if (var=='\'') \
171			do { \
172			next; \
173			if (!var) error; /* ''' special case hack */ \
174			if (var=='\'') { \
175			next; \
176			if (var!='\'') error; \
177			next; \
178			} else { \
179			next; \
180			while (var!='\'' && var != '\0') { \
181			if (!var) error; \
182			next; \
183			} \
184			if (var == '\0') error; \
185			next; \
186			} \
187			} while(0)
188
189			#define skippar(var, next, error) \
190			dequote(var, next, error); \
191			else if (var=='(') { \
192			int par=1; next; \
193			while (par) { \
194			dequote(var, next, error); \
195			else { \
196			if (var=='(') par++; \
197			if (var==')') par--; \
198			if (!var) error; \
199			next; \
200			} \
201			} \
202			} else if (var==')') error
203
204		968	string& string::replace(const char * instr, const char * outstr, bool all)
205			{
206		968	string& thisstring=*this;
207	2/3 ✗ Branch 2 → 3 not taken. ✓ Branch 2 → 16 taken 484 times. ✓ Branch 2 → 21 taken 484 times.	968	if (!all)
208			{
209		✗	const char * ptr=strstr(thisstring, instr);
210		✗	if (!ptr) return thisstring;
211		✗	string out=STR substr(thisstring, (int)(ptr-thisstring.data()))+outstr+(ptr+strlen(instr));
212		✗	thisstring =out;
213		✗	return thisstring;
214		✗	}
215			//performance hack (obviously for ", "->"," in asar, but who cares, it's a performance booster)
216	6/8 ✓ Branch 16 → 17 taken 469 times. ✓ Branch 16 → 49 taken 15 times. ✓ Branch 17 → 18 taken 469 times. ✗ Branch 17 → 49 not taken. ✓ Branch 21 → 22 taken 469 times. ✓ Branch 21 → 54 taken 15 times. ✓ Branch 22 → 23 taken 469 times. ✗ Branch 22 → 54 not taken.	968	if (strlen(instr)==strlen(outstr)+1 && !memcmp(instr, outstr, strlen(outstr)))
217			{
218		938	const char * indat= thisstring;
219		938	char * trueoutdat= typed_malloc(char, strlen(indat)+1);
220		938	char * outdat=trueoutdat;
221		938	int thelen=(int)strlen(outstr);
222			//nested hack
223	4/4 ✓ Branch 19 → 20 taken 1 time. ✓ Branch 19 → 28 taken 468 times. ✓ Branch 24 → 25 taken 1 time. ✓ Branch 24 → 33 taken 468 times.	938	if (thelen==0)
224			{
225		2	char thechar=instr[0];
226	4/4 ✓ Branch 25 → 21 taken 30 times. ✓ Branch 25 → 26 taken 1 time. ✓ Branch 30 → 26 taken 30 times. ✓ Branch 30 → 31 taken 1 time.	62	while (*indat)
227			{
228	4/4 ✓ Branch 21 → 22 taken 3 times. ✓ Branch 21 → 23 taken 27 times. ✓ Branch 26 → 27 taken 3 times. ✓ Branch 26 → 28 taken 27 times.	60	if (*indat==thechar) indat++;
229		54	else outdat++=indat++;
230			}
231		2	*outdat=0;
232		2	thisstring =trueoutdat;
233		2	free(trueoutdat);
234		2	return thisstring;
235			}
236	2/4 ✓ Branch 28 → 29 taken 468 times. ✗ Branch 28 → 39 not taken. ✓ Branch 33 → 34 taken 468 times. ✗ Branch 33 → 44 not taken.	936	else if (thelen==1)
237			{
238		936	char firstchar=instr[0];
239		936	char secondchar=instr[1];
240	4/4 ✓ Branch 36 → 30 taken 6557 times. ✓ Branch 36 → 37 taken 468 times. ✓ Branch 41 → 35 taken 6557 times. ✓ Branch 41 → 42 taken 468 times.	14050	while (*indat)
241			{
242	4/4 ✓ Branch 30 → 31 taken 527 times. ✓ Branch 30 → 34 taken 6030 times. ✓ Branch 35 → 36 taken 527 times. ✓ Branch 35 → 39 taken 6030 times.	13114	if (*indat==firstchar)
243			{
244		1054	outdat++=indat++;
245	4/4 ✓ Branch 33 → 32 taken 525 times. ✓ Branch 33 → 35 taken 527 times. ✓ Branch 38 → 37 taken 525 times. ✓ Branch 38 → 40 taken 527 times.	2104	while (*indat==secondchar) indat++;
246			}
247		12060	else outdat++=indat++;
248			}
249		936	*outdat=0;
250		936	thisstring =trueoutdat;
251		936	free(trueoutdat);
252		936	return thisstring;
253			}
254			else
255			//end hack
256			{
257		✗	char thehatedchar=instr[thelen];
258		✗	while (*indat)
259			{
260		✗	if (!memcmp(indat, outstr, (size_t)thelen))
261			{
262		✗	memcpy(outdat, outstr, (size_t)thelen);
263		✗	outdat+=thelen;
264		✗	indat+=thelen;
265		✗	while (*indat==thehatedchar) indat++;
266			}
267		✗	else outdat++=indat++;
268			}
269			}
270		✗	*outdat=0;
271		✗	thisstring =trueoutdat;
272		✗	free(trueoutdat);
273		✗	return thisstring;
274			}
275			//end hack
276		30	bool replaced=true;
277	4/4 ✓ Branch 62 → 50 taken 30 times. ✓ Branch 62 → 63 taken 15 times. ✓ Branch 68 → 55 taken 30 times. ✓ Branch 68 → 69 taken 15 times.	90	while (replaced)
278			{
279		60	replaced=false;
280		60	string out;
281		60	const char * in= thisstring;
282		60	int inlen=(int)strlen(instr);
283	4/4 ✓ Branch 58 → 53 taken 507 times. ✓ Branch 58 → 59 taken 30 times. ✓ Branch 64 → 59 taken 507 times. ✓ Branch 64 → 65 taken 30 times.	1074	while (*in)
284			{
285	4/4 ✓ Branch 53 → 54 taken 15 times. ✓ Branch 53 → 56 taken 492 times. ✓ Branch 59 → 60 taken 15 times. ✓ Branch 59 → 62 taken 492 times.	1014	if (!strncmp(in, instr, (size_t)inlen))
286			{
287		30	replaced=true;
288	2/4 ✓ Branch 54 → 55 taken 15 times. ✗ Branch 54 → 74 not taken. ✓ Branch 60 → 61 taken 15 times. ✗ Branch 60 → 83 not taken.	30	out+=outstr;
289		30	in+=inlen;
290			}
291	2/4 ✓ Branch 56 → 57 taken 492 times. ✗ Branch 56 → 74 not taken. ✓ Branch 62 → 63 taken 492 times. ✗ Branch 62 → 83 not taken.	984	else out+=*in++;
292			}
293	2/4 ✓ Branch 59 → 60 taken 30 times. ✗ Branch 59 → 74 not taken. ✓ Branch 65 → 66 taken 30 times. ✗ Branch 65 → 83 not taken.	60	thisstring =out;
294		60	}
295		30	return thisstring;
296			}
297
298		4130212	string& string::qreplace(const char * instr, const char * outstr, bool all)
299			{
300		4130212	string& thisstring =*this;
301	2/2 ✓ Branch 3 → 4 taken 4129004 times. ✓ Branch 3 → 5 taken 1208 times.	4130212	if (!strstr(thisstring, instr)) return thisstring;
302	5/6 ✓ Branch 6 → 7 taken 968 times. ✓ Branch 6 → 10 taken 240 times. ✓ Branch 8 → 9 taken 968 times. ✗ Branch 8 → 10 not taken. ✓ Branch 11 → 12 taken 968 times. ✓ Branch 11 → 14 taken 240 times.	1208	if (!strchr(thisstring, '"') && !strchr(thisstring, '\''))
303			{
304		968	thisstring.replace(instr, outstr, all);
305		968	return thisstring;
306			}
307		240	bool replaced=true;
308	4/4 ✓ Branch 97 → 15 taken 225 times. ✓ Branch 97 → 98 taken 120 times. ✓ Branch 100 → 15 taken 225 times. ✓ Branch 100 → 101 taken 120 times.	690	while (replaced)
309			{
310		450	replaced=false;
311		450	string out;
312	4/4 ✓ Branch 89 → 17 taken 5745 times. ✓ Branch 89 → 90 taken 225 times. ✓ Branch 90 → 18 taken 5745 times. ✓ Branch 90 → 91 taken 225 times.	11940	for (int i=0;thisstring[i];)
313			{
314	26/96 ✓ Branch 18 → 19 taken 531 times. ✓ Branch 18 → 39 taken 5214 times. ✓ Branch 19 → 20 taken 531 times. ✓ Branch 19 → 40 taken 5214 times. ✓ Branch 20 → 21 taken 531 times. ✗ Branch 20 → 100 not taken. ✓ Branch 21 → 22 taken 531 times. ✗ Branch 21 → 103 not taken. ✗ Branch 23 → 24 not taken. ✓ Branch 23 → 25 taken 6342 times. ✗ Branch 24 → 25 not taken. ✓ Branch 24 → 26 taken 6342 times. ✓ Branch 26 → 27 taken 6342 times. ✗ Branch 26 → 100 not taken. ✓ Branch 27 → 28 taken 6342 times. ✗ Branch 27 → 103 not taken. ✓ Branch 28 → 29 taken 6342 times. ✓ Branch 28 → 32 taken 531 times. ✓ Branch 29 → 30 taken 6342 times. ✓ Branch 29 → 33 taken 531 times. ✓ Branch 30 → 31 taken 6342 times. ✗ Branch 30 → 32 not taken. ✓ Branch 31 → 32 taken 6342 times. ✗ Branch 31 → 33 not taken. ✓ Branch 33 → 22 taken 6342 times. ✓ Branch 33 → 34 taken 531 times. ✓ Branch 34 → 23 taken 6342 times. ✓ Branch 34 → 35 taken 531 times. ✗ Branch 35 → 36 not taken. ✓ Branch 35 → 37 taken 531 times. ✗ Branch 36 → 37 not taken. ✓ Branch 36 → 38 taken 531 times. ✓ Branch 38 → 87 taken 531 times. ✗ Branch 38 → 100 not taken. ✓ Branch 39 → 88 taken 531 times. ✗ Branch 39 → 103 not taken. ✗ Branch 40 → 41 not taken. ✓ Branch 40 → 75 taken 5214 times. ✗ Branch 41 → 42 not taken. ✓ Branch 41 → 76 taken 5214 times. ✗ Branch 42 → 43 not taken. ✗ Branch 42 → 100 not taken. ✗ Branch 43 → 44 not taken. ✗ Branch 43 → 103 not taken. ✗ Branch 44 → 45 not taken. ✗ Branch 44 → 46 not taken. ✗ Branch 45 → 46 not taken. ✗ Branch 45 → 47 not taken. ✗ Branch 47 → 48 not taken. ✗ Branch 47 → 55 not taken. ✗ Branch 48 → 49 not taken. ✗ Branch 48 → 56 not taken. ✗ Branch 49 → 50 not taken. ✗ Branch 49 → 100 not taken. ✗ Branch 50 → 51 not taken. ✗ Branch 50 → 103 not taken. ✗ Branch 51 → 52 not taken. ✗ Branch 51 → 53 not taken. ✗ Branch 52 → 53 not taken. ✗ Branch 52 → 54 not taken. ✗ Branch 54 → 87 not taken. ✗ Branch 54 → 100 not taken. ✗ Branch 55 → 88 not taken. ✗ Branch 55 → 103 not taken. ✗ Branch 56 → 57 not taken. ✗ Branch 56 → 100 not taken. ✗ Branch 57 → 58 not taken. ✗ Branch 57 → 103 not taken. ✗ Branch 59 → 60 not taken. ✗ Branch 59 → 61 not taken. ✗ Branch 60 → 61 not taken. ✗ Branch 60 → 62 not taken. ✗ Branch 62 → 63 not taken. ✗ Branch 62 → 100 not taken. ✗ Branch 63 → 64 not taken. ✗ Branch 63 → 103 not taken. ✗ Branch 64 → 65 not taken. ✗ Branch 64 → 68 not taken. ✗ Branch 65 → 66 not taken. ✗ Branch 65 → 69 not taken. ✗ Branch 66 → 67 not taken. ✗ Branch 66 → 68 not taken. ✗ Branch 67 → 68 not taken. ✗ Branch 67 → 69 not taken. ✗ Branch 69 → 58 not taken. ✗ Branch 69 → 70 not taken. ✗ Branch 70 → 59 not taken. ✗ Branch 70 → 71 not taken. ✗ Branch 71 → 72 not taken. ✗ Branch 71 → 73 not taken. ✗ Branch 72 → 73 not taken. ✗ Branch 72 → 74 not taken. ✗ Branch 74 → 87 not taken. ✗ Branch 74 → 100 not taken. ✗ Branch 75 → 88 not taken. ✗ Branch 75 → 103 not taken.	24174	dequote(thisstring[i], out+= thisstring[i++], return thisstring);
315			else
316			{
317	4/4 ✓ Branch 76 → 77 taken 186 times. ✓ Branch 76 → 83 taken 5028 times. ✓ Branch 77 → 78 taken 186 times. ✓ Branch 77 → 84 taken 5028 times.	10428	if (!strncmp((const char*)thisstring + i, instr, strlen(instr)))
318			{
319		372	replaced = true;
320	2/4 ✓ Branch 77 → 78 taken 186 times. ✗ Branch 77 → 100 not taken. ✓ Branch 78 → 79 taken 186 times. ✗ Branch 78 → 103 not taken.	372	out += outstr;
321		372	i += (int)strlen(instr);
322	2/4 ✗ Branch 78 → 79 not taken. ✓ Branch 78 → 87 taken 186 times. ✗ Branch 79 → 80 not taken. ✓ Branch 79 → 88 taken 186 times.	372	if (!all)
323			{
324		✗	out += ((const char*)thisstring) + i;
325		✗	thisstring = out;
326		✗	return thisstring;
327			}
328			}
329			// randomdude999: prevent appending the null terminator to the output
330	4/8 ✓ Branch 84 → 85 taken 5028 times. ✗ Branch 84 → 87 not taken. ✓ Branch 85 → 86 taken 5028 times. ✗ Branch 85 → 88 not taken. ✓ Branch 86 → 87 taken 5028 times. ✗ Branch 86 → 100 not taken. ✓ Branch 87 → 88 taken 5028 times. ✗ Branch 87 → 103 not taken.	10056	else if (thisstring[i]) out += thisstring[i++];
331			}
332			}
333	2/4 ✓ Branch 90 → 91 taken 225 times. ✗ Branch 90 → 100 not taken. ✓ Branch 91 → 92 taken 225 times. ✗ Branch 91 → 103 not taken.	450	thisstring =out;
334	2/4 ✓ Branch 93 → 94 taken 225 times. ✗ Branch 93 → 96 not taken. ✓ Branch 94 → 95 taken 225 times. ✗ Branch 94 → 96 not taken.	450	}
335		240	return thisstring;
336			}
337
338		883316	bool confirmquotes(const char * str)
339			{
340	2/2 ✓ Branch 31 → 3 taken 6689884 times. ✓ Branch 31 → 32 taken 883308 times.	7573192	for (int i=0;str[i];)
341			{
342	17/26 ✓ Branch 3 → 4 taken 1982 times. ✓ Branch 3 → 13 taken 6687902 times. ✗ Branch 5 → 6 not taken. ✓ Branch 5 → 7 taken 26194 times. ✓ Branch 8 → 9 taken 26202 times. ✓ Branch 8 → 10 taken 1974 times. ✓ Branch 9 → 5 taken 26194 times. ✓ Branch 9 → 10 taken 8 times. ✓ Branch 10 → 11 taken 8 times. ✓ Branch 10 → 12 taken 1974 times. ✓ Branch 13 → 14 taken 294 times. ✓ Branch 13 → 29 taken 6687608 times. ✗ Branch 14 → 15 not taken. ✓ Branch 14 → 16 taken 294 times. ✓ Branch 16 → 17 taken 16 times. ✓ Branch 16 → 20 taken 278 times. ✗ Branch 17 → 18 not taken. ✓ Branch 17 → 19 taken 16 times. ✗ Branch 21 → 22 not taken. ✗ Branch 21 → 23 not taken. ✗ Branch 24 → 25 not taken. ✓ Branch 24 → 26 taken 278 times. ✗ Branch 25 → 21 not taken. ✗ Branch 25 → 26 not taken. ✗ Branch 26 → 27 not taken. ✓ Branch 26 → 28 taken 278 times.	6716078	dequote(str[i], i++, return false);
343		6687608	else i++;
344			}
345		883308	return true;
346			}
347
348		214478	bool confirmqpar(const char * str)
349			{
350	2/2 ✓ Branch 70 → 3 taken 231042 times. ✓ Branch 70 → 71 taken 214478 times.	445520	for (int i=0;str[i];)
351			{
352	32/64 ✓ Branch 3 → 4 taken 238 times. ✓ Branch 3 → 13 taken 230804 times. ✗ Branch 5 → 6 not taken. ✓ Branch 5 → 7 taken 1994 times. ✓ Branch 8 → 9 taken 1994 times. ✓ Branch 8 → 10 taken 238 times. ✓ Branch 9 → 5 taken 1994 times. ✗ Branch 9 → 10 not taken. ✗ Branch 10 → 11 not taken. ✓ Branch 10 → 12 taken 238 times. ✓ Branch 13 → 14 taken 72 times. ✓ Branch 13 → 29 taken 230732 times. ✗ Branch 14 → 15 not taken. ✓ Branch 14 → 16 taken 72 times. ✓ Branch 16 → 17 taken 6 times. ✓ Branch 16 → 20 taken 66 times. ✗ Branch 17 → 18 not taken. ✓ Branch 17 → 19 taken 6 times. ✗ Branch 21 → 22 not taken. ✗ Branch 21 → 23 not taken. ✗ Branch 24 → 25 not taken. ✓ Branch 24 → 26 taken 66 times. ✗ Branch 25 → 21 not taken. ✗ Branch 25 → 26 not taken. ✗ Branch 26 → 27 not taken. ✓ Branch 26 → 28 taken 66 times. ✓ Branch 29 → 30 taken 1242 times. ✓ Branch 29 → 66 taken 229490 times. ✓ Branch 31 → 32 taken 384 times. ✓ Branch 31 → 41 taken 7360 times. ✗ Branch 33 → 34 not taken. ✓ Branch 33 → 35 taken 4344 times. ✓ Branch 36 → 37 taken 4344 times. ✓ Branch 36 → 38 taken 384 times. ✓ Branch 37 → 33 taken 4344 times. ✗ Branch 37 → 38 not taken. ✗ Branch 38 → 39 not taken. ✓ Branch 38 → 40 taken 384 times. ✗ Branch 41 → 42 not taken. ✓ Branch 41 → 57 taken 7360 times. ✗ Branch 42 → 43 not taken. ✗ Branch 42 → 44 not taken. ✗ Branch 44 → 45 not taken. ✗ Branch 44 → 48 not taken. ✗ Branch 45 → 46 not taken. ✗ Branch 45 → 47 not taken. ✗ Branch 49 → 50 not taken. ✗ Branch 49 → 51 not taken. ✗ Branch 52 → 53 not taken. ✗ Branch 52 → 54 not taken. ✗ Branch 53 → 49 not taken. ✗ Branch 53 → 54 not taken. ✗ Branch 54 → 55 not taken. ✗ Branch 54 → 56 not taken. ✗ Branch 57 → 58 not taken. ✓ Branch 57 → 59 taken 7360 times. ✓ Branch 59 → 60 taken 1242 times. ✓ Branch 59 → 61 taken 6118 times. ✗ Branch 61 → 62 not taken. ✓ Branch 61 → 63 taken 7360 times. ✓ Branch 65 → 31 taken 7744 times. ✓ Branch 65 → 69 taken 1242 times. ✗ Branch 66 → 67 not taken. ✓ Branch 66 → 68 taken 229490 times.	245124	skippar(str[i], i++, return false);
353		229490	else i++;
354			}
355		214478	return true;
356			}
357
358		1747526	char ** nsplit(char * str, const char * key, int maxlen, int * len)
359			{
360	2/2 ✓ Branch 2 → 3 taken 1308786 times. ✓ Branch 2 → 6 taken 438740 times.	1747526	if (!strstr(str, key))
361			{
362		1308786	char ** out= typed_malloc(char*, 2);
363		1308786	out[0]=str;
364		1308786	out[1]=nullptr;
365	2/2 ✓ Branch 3 → 4 taken 436872 times. ✓ Branch 3 → 5 taken 871914 times.	1308786	if (len) *len=1;
366		1308786	return out;
367			}
368		438740	int keylen=(int)strlen(key);
369		438740	int count=7; //makes the default alloc 8 elements, sounds fair.
370	1/4 ✗ Branch 6 → 7 not taken. ✓ Branch 6 → 9 taken 438740 times. ✗ Branch 7 → 8 not taken. ✗ Branch 7 → 9 not taken.	438740	if (maxlen && count>maxlen) count=maxlen;
371		438740	char ** outdata= typed_malloc(char*, (size_t)count+1);
372
373		438740	int newcount=0;
374		438740	char *thisentry=str;
375		438740	outdata[newcount++]=thisentry;
376	2/2 ✓ Branch 13 → 10 taken 873110 times. ✓ Branch 13 → 14 taken 438740 times.	1311850	while((thisentry = strstr(thisentry, key))){
377		873110	*thisentry = 0;
378		873110	thisentry += keylen;
379		873110	outdata[newcount++]=thisentry;
380	2/2 ✓ Branch 10 → 11 taken 586 times. ✓ Branch 10 → 12 taken 872524 times.	873110	if(newcount >= count)
381			{
382		586	outdata = typed_realloc(char , outdata, count 2);
383		586	count *= 2;
384			}
385			}
386
387		438740	outdata[newcount]= nullptr;
388	2/2 ✓ Branch 14 → 15 taken 437154 times. ✓ Branch 14 → 16 taken 1586 times.	438740	if (len) *len=newcount;
389		438740	return outdata;
390			}
391
392		1749348	char ** qnsplit(char * str, const char * key, int maxlen, int * len)
393			{
394	4/4 ✓ Branch 2 → 3 taken 1746708 times. ✓ Branch 2 → 5 taken 2640 times. ✓ Branch 3 → 4 taken 1746336 times. ✓ Branch 3 → 5 taken 372 times.	1749348	if (!strchr(str, '"') && !strchr(str, '\'')) return nsplit(str, key, maxlen, len);
395		3012	int keylen=(int)strlen(key);
396		3012	int count=7;
397	1/4 ✗ Branch 5 → 6 not taken. ✓ Branch 5 → 8 taken 3012 times. ✗ Branch 6 → 7 not taken. ✗ Branch 6 → 8 not taken.	3012	if (maxlen && count>maxlen) count=maxlen;
398		3012	char ** outdata= typed_malloc(char*, (size_t)count+1);
399		3012	int newcount=0;
400		3012	char * thisentry=str;
401		3012	outdata[newcount++]=thisentry;
402	2/2 ✓ Branch 40 → 9 taken 34632 times. ✓ Branch 40 → 41 taken 3012 times.	37644	while (thisentry) /todo fix*/
403			{
404	15/26 ✓ Branch 9 → 10 taken 3204 times. ✓ Branch 9 → 19 taken 31428 times. ✗ Branch 11 → 12 not taken. ✓ Branch 11 → 13 taken 41432 times. ✓ Branch 14 → 15 taken 41432 times. ✓ Branch 14 → 16 taken 3204 times. ✓ Branch 15 → 11 taken 41432 times. ✗ Branch 15 → 16 not taken. ✗ Branch 16 → 17 not taken. ✓ Branch 16 → 18 taken 3204 times. ✓ Branch 19 → 20 taken 444 times. ✓ Branch 19 → 35 taken 30984 times. ✗ Branch 20 → 21 not taken. ✓ Branch 20 → 22 taken 444 times. ✓ Branch 22 → 23 taken 24 times. ✓ Branch 22 → 26 taken 420 times. ✗ Branch 23 → 24 not taken. ✓ Branch 23 → 25 taken 24 times. ✗ Branch 27 → 28 not taken. ✗ Branch 27 → 29 not taken. ✗ Branch 30 → 31 not taken. ✓ Branch 30 → 32 taken 420 times. ✗ Branch 31 → 27 not taken. ✗ Branch 31 → 32 not taken. ✗ Branch 32 → 33 not taken. ✓ Branch 32 → 34 taken 420 times.	76064	dequote(*thisentry, thisentry++, return nullptr);
405	2/2 ✓ Branch 35 → 36 taken 1704 times. ✓ Branch 35 → 38 taken 29280 times.	30984	else if (!strncmp(thisentry, key, (size_t)keylen))
406			{
407		1704	*thisentry=0;
408		1704	thisentry+=keylen;
409		1704	outdata[newcount++]=thisentry;
410	1/2 ✗ Branch 36 → 37 not taken. ✓ Branch 36 → 39 taken 1704 times.	1704	if(newcount >= count)
411			{
412		✗	outdata = typed_realloc(char , outdata, count 2);
413		✗	count *= 2;
414			}
415			}
416		29280	else thisentry++;
417			}
418		3012	outdata[newcount]= nullptr;
419	2/2 ✓ Branch 41 → 42 taken 1506 times. ✓ Branch 41 → 43 taken 1506 times.	3012	if (len) *len=newcount;
420		3012	return outdata;
421			}
422
423		219998	char ** qpnsplit(char * str, const char * key, int maxlen, int * len)
424			{
425		219998	int keylen=(int)strlen(key);
426		219998	int count=7;
427	1/4 ✗ Branch 2 → 3 not taken. ✓ Branch 2 → 5 taken 219998 times. ✗ Branch 3 → 4 not taken. ✗ Branch 3 → 5 not taken.	219998	if (maxlen && count>maxlen) count=maxlen;
428		219998	char ** outdata= typed_malloc(char*, (size_t)count+1);
429
430		219998	int newcount=0;
431		219998	char * thisentry=str;
432		219998	outdata[newcount++]=thisentry;
433	2/2 ✓ Branch 76 → 6 taken 252132 times. ✓ Branch 76 → 77 taken 219998 times.	472130	while (*thisentry)
434			{
435	32/64 ✓ Branch 6 → 7 taken 478 times. ✓ Branch 6 → 16 taken 251654 times. ✗ Branch 8 → 9 not taken. ✓ Branch 8 → 10 taken 3290 times. ✓ Branch 11 → 12 taken 3290 times. ✓ Branch 11 → 13 taken 478 times. ✓ Branch 12 → 8 taken 3290 times. ✗ Branch 12 → 13 not taken. ✗ Branch 13 → 14 not taken. ✓ Branch 13 → 15 taken 478 times. ✓ Branch 16 → 17 taken 72 times. ✓ Branch 16 → 32 taken 251582 times. ✗ Branch 17 → 18 not taken. ✓ Branch 17 → 19 taken 72 times. ✓ Branch 19 → 20 taken 6 times. ✓ Branch 19 → 23 taken 66 times. ✗ Branch 20 → 21 not taken. ✓ Branch 20 → 22 taken 6 times. ✗ Branch 24 → 25 not taken. ✗ Branch 24 → 26 not taken. ✗ Branch 27 → 28 not taken. ✓ Branch 27 → 29 taken 66 times. ✗ Branch 28 → 24 not taken. ✗ Branch 28 → 29 not taken. ✗ Branch 29 → 30 not taken. ✓ Branch 29 → 31 taken 66 times. ✓ Branch 32 → 33 taken 1904 times. ✓ Branch 32 → 69 taken 249678 times. ✓ Branch 34 → 35 taken 168 times. ✓ Branch 34 → 44 taken 9890 times. ✗ Branch 36 → 37 not taken. ✓ Branch 36 → 38 taken 3642 times. ✓ Branch 39 → 40 taken 3642 times. ✓ Branch 39 → 41 taken 168 times. ✓ Branch 40 → 36 taken 3642 times. ✗ Branch 40 → 41 not taken. ✗ Branch 41 → 42 not taken. ✓ Branch 41 → 43 taken 168 times. ✗ Branch 44 → 45 not taken. ✓ Branch 44 → 60 taken 9890 times. ✗ Branch 45 → 46 not taken. ✗ Branch 45 → 47 not taken. ✗ Branch 47 → 48 not taken. ✗ Branch 47 → 51 not taken. ✗ Branch 48 → 49 not taken. ✗ Branch 48 → 50 not taken. ✗ Branch 52 → 53 not taken. ✗ Branch 52 → 54 not taken. ✗ Branch 55 → 56 not taken. ✗ Branch 55 → 57 not taken. ✗ Branch 56 → 52 not taken. ✗ Branch 56 → 57 not taken. ✗ Branch 57 → 58 not taken. ✗ Branch 57 → 59 not taken. ✗ Branch 60 → 61 not taken. ✓ Branch 60 → 62 taken 9890 times. ✓ Branch 62 → 63 taken 1904 times. ✓ Branch 62 → 64 taken 7986 times. ✗ Branch 64 → 65 not taken. ✓ Branch 64 → 66 taken 9890 times. ✓ Branch 68 → 34 taken 10058 times. ✓ Branch 68 → 75 taken 1904 times. ✗ Branch 69 → 70 not taken. ✓ Branch 69 → 71 taken 249678 times.	269122	skippar(*thisentry, thisentry++, return nullptr);
436	2/2 ✓ Branch 71 → 72 taken 3340 times. ✓ Branch 71 → 74 taken 246338 times.	249678	else if (!strncmp(thisentry, key, (size_t)keylen))
437			{
438		3340	*thisentry=0;
439		3340	thisentry+=keylen;
440		3340	outdata[newcount++]=thisentry;
441	2/2 ✓ Branch 72 → 73 taken 38 times. ✓ Branch 72 → 75 taken 3302 times.	3340	if(newcount >= count)
442			{
443		38	outdata = typed_realloc(char , outdata, count 2);
444		38	count *= 2;
445			}
446			}
447		246338	else thisentry++;
448			}
449		219998	outdata[newcount]= nullptr;
450	2/2 ✓ Branch 77 → 78 taken 6004 times. ✓ Branch 77 → 79 taken 213994 times.	219998	if (len) *len=newcount;
451		219998	return outdata;
452			}
453
454		878404	string &strip_prefix(string &str, char c, bool multi)
455			{
456	3/3 ✓ Branch 2 → 3 taken 2974 times. ✓ Branch 2 → 12 taken 437715 times. ✓ Branch 2 → 13 taken 437715 times.	878404	if(!multi){
457	3/3 ✓ Branch 4 → 5 taken 1774 times. ✓ Branch 4 → 11 taken 600 times. ✓ Branch 4 → 12 taken 600 times.	2974	if(str.data()[0] == c){
458	5/11 ✓ Branch 5 → 6 taken 887 times. ✗ Branch 5 → 28 not taken. ✓ Branch 6 → 7 taken 887 times. ✗ Branch 6 → 31 not taken. ✓ Branch 7 → 8 taken 887 times. ✗ Branch 7 → 28 not taken. ✓ Branch 8 → 9 taken 1774 times. ✗ Branch 8 → 26 not taken. ✗ Branch 8 → 31 not taken. ✓ Branch 9 → 10 taken 887 times. ✗ Branch 9 → 29 not taken.	1774	str = string(str.data() + 1, str.length() - 1);
459			}
460		2974	return str;
461			}
462		875430	int length = str.length();
463	4/4 ✓ Branch 23 → 14 taken 326833 times. ✓ Branch 23 → 24 taken 110882 times. ✓ Branch 26 → 15 taken 326833 times. ✓ Branch 26 → 27 taken 110882 times.	875430	for(int i = 0; i < length; i++){
464	2/4 ✓ Branch 15 → 16 taken 326833 times. ✗ Branch 15 → 22 not taken. ✓ Branch 16 → 17 taken 326833 times. ✗ Branch 16 → 25 not taken.	653666	if(str.data()[i] != c){
465	5/11 ✓ Branch 16 → 17 taken 326833 times. ✗ Branch 16 → 31 not taken. ✓ Branch 18 → 19 taken 653666 times. ✗ Branch 18 → 31 not taken. ✗ Branch 18 → 35 not taken. ✓ Branch 19 → 20 taken 326833 times. ✗ Branch 19 → 29 not taken. ✓ Branch 20 → 21 taken 326833 times. ✗ Branch 20 → 35 not taken. ✓ Branch 21 → 22 taken 326833 times. ✗ Branch 21 → 33 not taken.	653666	str = string(str.data() + i, str.length() - i);
466		653666	return str;
467			}
468			}
469		221764	return str;
470			}
471
472		875670	string &strip_suffix(string &str, char c, bool multi)
473			{
474	2/2 ✓ Branch 2 → 3 taken 240 times. ✓ Branch 2 → 9 taken 875430 times.	875670	if(!multi){
475	1/2 ✓ Branch 5 → 6 taken 240 times. ✗ Branch 5 → 8 not taken.	240	if(str.data()[str.length() - 1] == c){
476		240	str.truncate(str.length() - 1);
477			}
478		240	return str;
479			}
480	2/2 ✓ Branch 16 → 11 taken 653708 times. ✓ Branch 16 → 17 taken 221764 times.	875472	for(int i = str.length() - 1; i >= 0; i--){
481	2/2 ✓ Branch 12 → 13 taken 653666 times. ✓ Branch 12 → 15 taken 42 times.	653708	if(str.data()[i] != c){
482		653666	str.truncate(i + 1);
483		653666	return str;
484			}
485			}
486		221764	return str;
487			}
488
489		875430	string &strip_both(string &str, char c, bool multi)
490			{
491		875430	return strip_suffix(strip_prefix(str, c, multi), c, multi);
492			}
493
494		1087576	string &strip_whitespace(string &str)
495			{
496	2/2 ✓ Branch 14 → 4 taken 1077442 times. ✓ Branch 14 → 15 taken 10934 times.	1088376	for(int i = str.length() - 1; i >= 0; i--){
497	5/6 ✓ Branch 5 → 6 taken 1076642 times. ✓ Branch 5 → 9 taken 800 times. ✓ Branch 7 → 8 taken 1076642 times. ✗ Branch 7 → 9 not taken. ✓ Branch 10 → 11 taken 1076642 times. ✓ Branch 10 → 13 taken 800 times.	1077442	if(str.data()[i] != ' ' && str.data()[i] != '\t'){
498		1076642	str.truncate(i + 1);
499		1076642	break;
500			}
501			}
502
503		1087576	int length = str.length();
504	4/4 ✓ Branch 31 → 17 taken 538621 times. ✓ Branch 31 → 32 taken 5467 times. ✓ Branch 33 → 17 taken 538621 times. ✓ Branch 33 → 34 taken 5467 times.	1088176	for(int i = 0; i < length; i++){
505	6/7 ✓ Branch 18 → 19 taken 1076642 times. ✓ Branch 18 → 22 taken 600 times. ✓ Branch 20 → 21 taken 1076642 times. ✗ Branch 20 → 22 not taken. ✓ Branch 23 → 24 taken 1076642 times. ✓ Branch 23 → 30 taken 300 times. ✓ Branch 23 → 32 taken 300 times.	1077242	if(str.data()[i] != ' ' && str.data()[i] != '\t'){
506	5/11 ✓ Branch 24 → 25 taken 538321 times. ✗ Branch 24 → 36 not taken. ✓ Branch 25 → 26 taken 538321 times. ✗ Branch 25 → 38 not taken. ✓ Branch 26 → 27 taken 538321 times. ✗ Branch 26 → 36 not taken. ✓ Branch 27 → 28 taken 1076642 times. ✗ Branch 27 → 34 not taken. ✗ Branch 27 → 38 not taken. ✓ Branch 28 → 29 taken 538321 times. ✗ Branch 28 → 36 not taken.	1076642	str = string(str.data() + i, str.length() - i);
507		1076642	return str;
508			}
509			}
510		10934	return str;
511			}
512
513		9494	char * itrim(char * str, const char * left, const char * right, bool multi)
514			{
515	2/4 ✓ Branch 2 → 3 taken 4747 times. ✗ Branch 2 → 11 not taken. ✓ Branch 3 → 4 taken 4747 times. ✗ Branch 3 → 12 not taken.	9494	string tmp(str);
516	2/4 ✓ Branch 3 → 4 taken 4747 times. ✗ Branch 3 → 9 not taken. ✓ Branch 4 → 5 taken 4747 times. ✗ Branch 4 → 10 not taken.	18988	return strcpy(str, itrim(tmp, left, right, multi).data());
517		9494	}
518
519			//todo merge above with this
520		11186	string &itrim(string &input, const char * left, const char * right, bool multi)
521			{
522		11186	bool nukeright=true;
523		11186	int totallen=input.length();
524		11186	int rightlen=(int)strlen(right);
525	3/4 ✓ Branch 3 → 4 taken 11186 times. ✗ Branch 3 → 18 not taken. ✓ Branch 4 → 5 taken 7834 times. ✓ Branch 4 → 18 taken 3352 times.	11186	if (rightlen && rightlen<=totallen)
526			{
527			do
528			{
529		22916	const char * rightend=right+rightlen;
530		22916	const char * strend=input.data()+totallen;
531	2/2 ✓ Branch 12 → 7 taken 25208 times. ✓ Branch 12 → 13 taken 22916 times.	48124	while (right!=rightend)
532			{
533		25208	rightend--;
534		25208	strend--;
535	2/2 ✓ Branch 9 → 10 taken 6022 times. ✓ Branch 9 → 11 taken 19186 times.	25208	if (to_lower(strend)!=to_lower(rightend)) nukeright=false;
536			}
537	2/2 ✓ Branch 13 → 14 taken 16894 times. ✓ Branch 13 → 15 taken 6022 times.	22916	if (nukeright)
538			{
539		16894	totallen-=rightlen;
540		16894	input.truncate(totallen);
541			}
542	6/6 ✓ Branch 15 → 16 taken 21224 times. ✓ Branch 15 → 18 taken 1692 times. ✓ Branch 16 → 17 taken 15202 times. ✓ Branch 16 → 18 taken 6022 times. ✓ Branch 17 → 5 taken 15082 times. ✓ Branch 17 → 18 taken 120 times.	22916	} while (multi && nukeright && rightlen<=totallen);
543			}
544		11186	bool nukeleft=true;
545		11186	int leftlen = strlen(left);
546	8/9 ✓ Branch 18 → 19 taken 1692 times. ✓ Branch 18 → 23 taken 9494 times. ✓ Branch 19 → 20 taken 408 times. ✓ Branch 19 → 23 taken 1284 times. ✓ Branch 21 → 22 taken 408 times. ✗ Branch 21 → 23 not taken. ✓ Branch 24 → 25 taken 408 times. ✓ Branch 24 → 32 taken 5389 times. ✓ Branch 24 → 33 taken 5389 times.	11186	if(!multi && leftlen == 1 && input.data()[0] == left[0])
547			{
548	5/11 ✓ Branch 25 → 26 taken 204 times. ✗ Branch 25 → 53 not taken. ✓ Branch 26 → 27 taken 204 times. ✗ Branch 26 → 55 not taken. ✓ Branch 27 → 28 taken 204 times. ✗ Branch 27 → 53 not taken. ✓ Branch 28 → 29 taken 408 times. ✗ Branch 28 → 51 not taken. ✗ Branch 28 → 55 not taken. ✓ Branch 29 → 30 taken 204 times. ✗ Branch 29 → 53 not taken.	408	return input = string(input.data()+1, (input.length()-1));
549			}
550			else
551			{
552			do
553			{
554
555	4/4 ✓ Branch 39 → 33 taken 5509 times. ✓ Branch 39 → 40 taken 6151 times. ✓ Branch 40 → 34 taken 5509 times. ✓ Branch 40 → 41 taken 6151 times.	23320	for (int i = 0; i < leftlen; i++)
556			{
557	4/4 ✓ Branch 36 → 37 taken 4747 times. ✓ Branch 36 → 38 taken 762 times. ✓ Branch 37 → 38 taken 4747 times. ✓ Branch 37 → 39 taken 762 times.	11018	if (to_lower(input.data()[i])!=to_lower(left[i])) nukeleft=false;
558			}
559	8/14 ✓ Branch 40 → 41 taken 1404 times. ✓ Branch 40 → 47 taken 4747 times. ✓ Branch 41 → 42 taken 2808 times. ✓ Branch 41 → 49 taken 4747 times. ✗ Branch 41 → 56 not taken. ✓ Branch 43 → 44 taken 2808 times. ✗ Branch 43 → 56 not taken. ✗ Branch 43 → 59 not taken. ✓ Branch 44 → 45 taken 1404 times. ✗ Branch 44 → 54 not taken. ✓ Branch 45 → 46 taken 1404 times. ✗ Branch 45 → 59 not taken. ✓ Branch 46 → 47 taken 1404 times. ✗ Branch 46 → 57 not taken.	12302	if (nukeleft) input = string(input.data()+leftlen, (input.length()-leftlen));
560	8/8 ✓ Branch 47 → 48 taken 5509 times. ✓ Branch 47 → 49 taken 642 times. ✓ Branch 48 → 32 taken 762 times. ✓ Branch 48 → 49 taken 4747 times. ✓ Branch 49 → 50 taken 5509 times. ✓ Branch 49 → 51 taken 642 times. ✓ Branch 50 → 33 taken 762 times. ✓ Branch 50 → 51 taken 4747 times.	12302	} while (multi && nukeleft);
561			}
562		10778	return input;
563			}
564
565		6	char* strqpchr(const char* str, char key)
566			{
567	1/2 ✓ Branch 74 → 3 taken 24 times. ✗ Branch 74 → 75 not taken.	24	while (*str)
568			{
569	13/64 ✗ Branch 3 → 4 not taken. ✓ Branch 3 → 13 taken 24 times. ✗ Branch 5 → 6 not taken. ✗ Branch 5 → 7 not taken. ✗ Branch 8 → 9 not taken. ✗ Branch 8 → 10 not taken. ✗ Branch 9 → 5 not taken. ✗ Branch 9 → 10 not taken. ✗ Branch 10 → 11 not taken. ✗ Branch 10 → 12 not taken. ✗ Branch 13 → 14 not taken. ✓ Branch 13 → 29 taken 24 times. ✗ Branch 14 → 15 not taken. ✗ Branch 14 → 16 not taken. ✗ Branch 16 → 17 not taken. ✗ Branch 16 → 20 not taken. ✗ Branch 17 → 18 not taken. ✗ Branch 17 → 19 not taken. ✗ Branch 21 → 22 not taken. ✗ Branch 21 → 23 not taken. ✗ Branch 24 → 25 not taken. ✗ Branch 24 → 26 not taken. ✗ Branch 25 → 21 not taken. ✗ Branch 25 → 26 not taken. ✗ Branch 26 → 27 not taken. ✗ Branch 26 → 28 not taken. ✓ Branch 29 → 30 taken 12 times. ✓ Branch 29 → 66 taken 12 times. ✗ Branch 31 → 32 not taken. ✓ Branch 31 → 41 taken 48 times. ✗ Branch 33 → 34 not taken. ✗ Branch 33 → 35 not taken. ✗ Branch 36 → 37 not taken. ✗ Branch 36 → 38 not taken. ✗ Branch 37 → 33 not taken. ✗ Branch 37 → 38 not taken. ✗ Branch 38 → 39 not taken. ✗ Branch 38 → 40 not taken. ✗ Branch 41 → 42 not taken. ✓ Branch 41 → 57 taken 48 times. ✗ Branch 42 → 43 not taken. ✗ Branch 42 → 44 not taken. ✗ Branch 44 → 45 not taken. ✗ Branch 44 → 48 not taken. ✗ Branch 45 → 46 not taken. ✗ Branch 45 → 47 not taken. ✗ Branch 49 → 50 not taken. ✗ Branch 49 → 51 not taken. ✗ Branch 52 → 53 not taken. ✗ Branch 52 → 54 not taken. ✗ Branch 53 → 49 not taken. ✗ Branch 53 → 54 not taken. ✗ Branch 54 → 55 not taken. ✗ Branch 54 → 56 not taken. ✗ Branch 57 → 58 not taken. ✓ Branch 57 → 59 taken 48 times. ✓ Branch 59 → 60 taken 12 times. ✓ Branch 59 → 61 taken 36 times. ✗ Branch 61 → 62 not taken. ✓ Branch 61 → 63 taken 48 times. ✓ Branch 65 → 31 taken 48 times. ✓ Branch 65 → 73 taken 12 times. ✗ Branch 66 → 67 not taken. ✓ Branch 66 → 68 taken 12 times.	72	skippar(*str, str++, return nullptr);
570	2/2 ✓ Branch 68 → 69 taken 6 times. ✓ Branch 68 → 70 taken 6 times.	12	else if (str == key) return const_cast<char>(str);
571	1/2 ✗ Branch 70 → 71 not taken. ✓ Branch 70 → 72 taken 6 times.	6	else if (!*str) return nullptr;
572		6	else str++;
573			}
574		✗	return nullptr;
575			}
576
577
578		138	char* strqpstr(const char* str, const char* key)
579			{
580		138	size_t keylen = strlen(key);
581	2/2 ✓ Branch 74 → 3 taken 552 times. ✓ Branch 74 → 75 taken 6 times.	558	while (*str)
582			{
583	13/64 ✗ Branch 3 → 4 not taken. ✓ Branch 3 → 13 taken 552 times. ✗ Branch 5 → 6 not taken. ✗ Branch 5 → 7 not taken. ✗ Branch 8 → 9 not taken. ✗ Branch 8 → 10 not taken. ✗ Branch 9 → 5 not taken. ✗ Branch 9 → 10 not taken. ✗ Branch 10 → 11 not taken. ✗ Branch 10 → 12 not taken. ✗ Branch 13 → 14 not taken. ✓ Branch 13 → 29 taken 552 times. ✗ Branch 14 → 15 not taken. ✗ Branch 14 → 16 not taken. ✗ Branch 16 → 17 not taken. ✗ Branch 16 → 20 not taken. ✗ Branch 17 → 18 not taken. ✗ Branch 17 → 19 not taken. ✗ Branch 21 → 22 not taken. ✗ Branch 21 → 23 not taken. ✗ Branch 24 → 25 not taken. ✗ Branch 24 → 26 not taken. ✗ Branch 25 → 21 not taken. ✗ Branch 25 → 26 not taken. ✗ Branch 26 → 27 not taken. ✗ Branch 26 → 28 not taken. ✓ Branch 29 → 30 taken 18 times. ✓ Branch 29 → 66 taken 534 times. ✗ Branch 31 → 32 not taken. ✓ Branch 31 → 41 taken 84 times. ✗ Branch 33 → 34 not taken. ✗ Branch 33 → 35 not taken. ✗ Branch 36 → 37 not taken. ✗ Branch 36 → 38 not taken. ✗ Branch 37 → 33 not taken. ✗ Branch 37 → 38 not taken. ✗ Branch 38 → 39 not taken. ✗ Branch 38 → 40 not taken. ✗ Branch 41 → 42 not taken. ✓ Branch 41 → 57 taken 84 times. ✗ Branch 42 → 43 not taken. ✗ Branch 42 → 44 not taken. ✗ Branch 44 → 45 not taken. ✗ Branch 44 → 48 not taken. ✗ Branch 45 → 46 not taken. ✗ Branch 45 → 47 not taken. ✗ Branch 49 → 50 not taken. ✗ Branch 49 → 51 not taken. ✗ Branch 52 → 53 not taken. ✗ Branch 52 → 54 not taken. ✗ Branch 53 → 49 not taken. ✗ Branch 53 → 54 not taken. ✗ Branch 54 → 55 not taken. ✗ Branch 54 → 56 not taken. ✗ Branch 57 → 58 not taken. ✓ Branch 57 → 59 taken 84 times. ✓ Branch 59 → 60 taken 18 times. ✓ Branch 59 → 61 taken 66 times. ✗ Branch 61 → 62 not taken. ✓ Branch 61 → 63 taken 84 times. ✓ Branch 65 → 31 taken 84 times. ✓ Branch 65 → 73 taken 18 times. ✗ Branch 66 → 67 not taken. ✓ Branch 66 → 68 taken 534 times.	636	skippar(*str, str++, return nullptr);
584	2/2 ✓ Branch 68 → 69 taken 132 times. ✓ Branch 68 → 70 taken 402 times.	534	else if (!strncmp(str, key, keylen)) return const_cast<char*>(str);
585	1/2 ✗ Branch 70 → 71 not taken. ✓ Branch 70 → 72 taken 402 times.	402	else if (!*str) return nullptr;
586		402	else str++;
587			}
588		6	return nullptr;
589			}
590
591			extern const uint8_t char_props[256] = {
592			//x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF
593			0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80,0x80,0x00,0x00,0x80,0x00,0x00, // 0x
594			0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, // 1x
595			0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, // 2x !"#$%&'()*+,-./
596			0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x00,0x00,0x00,0x00,0x00,0x00, // 3x 0123456789:;<=>?
597			0x00,0x23,0x23,0x23,0x23,0x23,0x23,0x22,0x22,0x22,0x22,0x22,0x22,0x22,0x22,0x22, // 4x @ABCDEFGHIJKLMNO
598			0x22,0x22,0x22,0x22,0x22,0x22,0x22,0x22,0x22,0x22,0x22,0x00,0x00,0x00,0x00,0x08, // 5x PQRSTUVWXYZ[\]^_
599			0x00,0x25,0x25,0x25,0x25,0x25,0x25,0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x24, // 6x `abcdefghijklmno
600			0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x00,0x00,0x00,0x00,0x00, // 7x pqrstuvwxyz{\|}~
601			0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, // 8x
602			0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, // 9x
603			0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, // Ax
604			0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, // Bx
605			0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, // Cx
606			0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, // Dx
607			0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, // Ex
608			0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, // Fx
609			};
610

asar coverage - build #