asar coverage - build #164

src/asar/
File: src/asar/libstr.cpp
Date: 2024-01-27 07:02:16
Lines:
272/320
85.0%
Functions:
21/21
100.0%
Branches:
393/660
59.5%
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 624 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 0 not taken.
✓ Branch 1 taken 624 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
 624 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 312 return 0u;
35 }
36
37
38 186893 size_t utf8_val(int* codepoint, const char* inp) {
39 186893 unsigned char c = *inp++;
40 int val;
41
1/2
✓ Branch 0 taken 186893 times.
✗ Branch 1 not taken.
 186893 if (c < 0x80) {
42 // plain ascii
43 186893 *codepoint = c;
44 186893 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 624 bool is_valid_utf8(const char* inp) {
89
2/2
✓ Branch 0 taken 186893 times.
✓ Branch 1 taken 624 times.
 187517 while (*inp != '\0') {
90 94387 int codepoint;
91 186893 inp += utf8_val(&codepoint, inp);
92
93
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 186893 times.
 186893 if (codepoint == -1) return false;
94 }
95
96 312 return true;
97 }
98
99 // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
100
101
102 228 char * readfile(const char * fname, const char * basepath)
103 {
104 228 virtual_file_handle myfile = filesystem->open_file(fname, basepath);
105
2/2
✓ Branch 0 taken 114 times.
✓ Branch 1 taken 114 times.
 228 if (myfile == INVALID_VIRTUAL_FILE_HANDLE) return nullptr;
106 228 size_t datalen = filesystem->get_file_size(myfile);
107 228 char * data= typed_malloc(char, datalen+1);
108 228 data[filesystem->read_file(myfile, data, 0u, datalen)] = 0;
109 228 filesystem->close_file(myfile);
110 114 int inpos=0;
111 114 int outpos=0;
112 228 inpos += check_bom(data + inpos);
113
2/2
✓ Branch 0 taken 159470 times.
✓ Branch 1 taken 228 times.
 159698 while (data[inpos])
114 {
115
1/2
✓ Branch 0 taken 159470 times.
✗ Branch 1 not taken.
 159470 if (data[inpos]!='\r') data[outpos++]=data[inpos];
116 159470 inpos++;
117 }
118 228 data[outpos]=0;
119
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 228 times.
 228 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 114 return data;
121 }
122
123 // RPG Hacker: like readfile(), but doesn't use virtual file system
124 // and instead read our file directly.
125 396 char * readfilenative(const char * fname)
126 {
127 396 FILE* myfile = fopen(fname, "rb");
128
2/2
✓ Branch 0 taken 198 times.
✓ Branch 1 taken 198 times.
 396 if (myfile == nullptr) return nullptr;
129 396 fseek(myfile, 0, SEEK_END);
130 396 size_t datalen = (size_t)ftell(myfile);
131 396 fseek(myfile, 0, SEEK_SET);
132 396 char * data = typed_malloc(char, datalen + 1);
133 396 data[fread(data, 1u, datalen, myfile)] = 0;
134 396 fclose(myfile);
135 198 int inpos = 0;
136 198 int outpos = 0;
137 396 inpos += check_bom(data + inpos);
138
2/2
✓ Branch 0 taken 27423 times.
✓ Branch 1 taken 396 times.
 27819 while (data[inpos])
139 {
140
1/2
✓ Branch 0 taken 27423 times.
✗ Branch 1 not taken.
 27423 if (data[inpos] != '\r') data[outpos++] = data[inpos];
141 27423 inpos++;
142 }
143 396 data[outpos] = 0;
144
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 396 times.
 396 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 198 return data;
146 }
147
148 230 bool readfile(const char * fname, const char * basepath, char ** data, int * len)
149 {
150 230 virtual_file_handle myfile = filesystem->open_file(fname, basepath);
151
2/2
✓ Branch 0 taken 115 times.
✓ Branch 1 taken 115 times.
 230 if (!myfile) return false;
152 224 size_t datalen = filesystem->get_file_size(myfile);
153 224 *data= typed_malloc(char, datalen);
154 224 *len = (int)filesystem->read_file(myfile, *data, 0, datalen);
155 224 filesystem->close_file(myfile);
156 224 return true;
157 }
158
159 #define dequote(var, next, error) if (var=='"') do { next; while (var!='"' && var != '\0') { if (!var) error; next; } if (var == '\0') error; next; } while(0); else if (var=='\'') do { next; if (!var) error; /* ''' special case hack */ if (var=='\'') { next; if (var!='\'') error; next; } else { next; while (var!='\'' && var != '\0') { if (!var) error; next; } if (var == '\0') error; next; } } while(0)
160 #define skippar(var, next, error) dequote(var, next, error); else if (var=='(') { int par=1; next; while (par) { dequote(var, next, error); else { \
161 if (var=='(') par++; if (var==')') par--; if (!var) error; next; } } } else if (var==')') error
162
163 968 string& string::replace(const char * instr, const char * outstr, bool all)
164 {
165 484 string& thisstring=*this;
166
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 968 times.
 968 if (!all)
167 {
168 ✗ const char * ptr=strstr(thisstring, instr);
169 ✗ if (!ptr) return thisstring;
170 ✗ string out=STR substr(thisstring, (int)(ptr-thisstring.data()))+outstr+(ptr+strlen(instr));
171 ✗ thisstring =out;
172 ✗ return thisstring;
173 ✗ }
174 //performance hack (obviously for ", "->"," in asar, but who cares, it's a performance booster)
175
4/4
✓ Branch 0 taken 484 times.
✓ Branch 1 taken 484 times.
✓ Branch 2 taken 469 times.
✓ Branch 3 taken 469 times.
 968 if (strlen(instr)==strlen(outstr)+1 && !memcmp(instr, outstr, strlen(outstr)))
176 {
177 469 const char * indat= thisstring;
178 938 char * trueoutdat= typed_malloc(char, strlen(indat)+1);
179 469 char * outdat=trueoutdat;
180 938 int thelen=(int)strlen(outstr);
181 //nested hack
182
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 936 times.
 938 if (thelen==0)
183 {
184 2 char thechar=instr[0];
185
2/2
✓ Branch 0 taken 60 times.
✓ Branch 1 taken 2 times.
 62 while (*indat)
186 {
187
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 54 times.
 60 if (*indat==thechar) indat++;
188 54 else *outdat++=*indat++;
189 }
190 2 *outdat=0;
191 1 thisstring =trueoutdat;
192 2 free(trueoutdat);
193 2 return thisstring;
194 }
195
1/2
✓ Branch 0 taken 936 times.
✗ Branch 1 not taken.
 936 else if (thelen==1)
196 {
197 936 char firstchar=instr[0];
198 936 char secondchar=instr[1];
199
2/2
✓ Branch 0 taken 13114 times.
✓ Branch 1 taken 936 times.
 14050 while (*indat)
200 {
201
2/2
✓ Branch 0 taken 1054 times.
✓ Branch 1 taken 12060 times.
 13114 if (*indat==firstchar)
202 {
203 1054 *outdat++=*indat++;
204
2/2
✓ Branch 0 taken 1050 times.
✓ Branch 1 taken 1054 times.
 2104 while (*indat==secondchar) indat++;
205 }
206 12060 else *outdat++=*indat++;
207 }
208 936 *outdat=0;
209 468 thisstring =trueoutdat;
210 936 free(trueoutdat);
211 936 return thisstring;
212 }
213 else
214 //end hack
215 {
216 ✗ char thehatedchar=instr[thelen];
217 ✗ while (*indat)
218 {
219 ✗ if (!memcmp(indat, outstr, (size_t)thelen))
220 {
221 ✗ memcpy(outdat, outstr, (size_t)thelen);
222 ✗ outdat+=thelen;
223 ✗ indat+=thelen;
224 ✗ while (*indat==thehatedchar) indat++;
225 }
226 ✗ else *outdat++=*indat++;
227 }
228 }
229 ✗ *outdat=0;
230 ✗ thisstring =trueoutdat;
231 ✗ free(trueoutdat);
232 ✗ return thisstring;
233 }
234 //end hack
235 15 bool replaced=true;
236
2/2
✓ Branch 0 taken 60 times.
✓ Branch 1 taken 30 times.
 90 while (replaced)
237 {
238 30 replaced=false;
239 30 string out;
240 30 const char * in= thisstring;
241 60 int inlen=(int)strlen(instr);
242
2/2
✓ Branch 0 taken 1014 times.
✓ Branch 1 taken 60 times.
 1074 while (*in)
243 {
244
2/2
✓ Branch 0 taken 30 times.
✓ Branch 1 taken 984 times.
 1014 if (!strncmp(in, instr, (size_t)inlen))
245 {
246 15 replaced=true;
247
1/2
✓ Branch 0 taken 15 times.
✗ Branch 1 not taken.
 30 out+=outstr;
248 30 in+=inlen;
249 }
250
1/2
✓ Branch 0 taken 492 times.
✗ Branch 1 not taken.
 984 else out+=*in++;
251 }
252
1/2
✓ Branch 0 taken 30 times.
✗ Branch 1 not taken.
 30 thisstring =out;
253 60 }
254 15 return thisstring;
255 }
256
257
2/2
✓ Branch 0 taken 604 times.
✓ Branch 1 taken 2064394 times.
 4129996 string& string::qreplace(const char * instr, const char * outstr, bool all)
258 {
259 2064998 string& thisstring =*this;
260
2/2
✓ Branch 0 taken 2064998 times.
✓ Branch 1 taken 2064998 times.
 4129996 if (!strstr(thisstring, instr)) return thisstring;
261
6/6
✓ Branch 0 taken 968 times.
✓ Branch 1 taken 240 times.
✓ Branch 2 taken 484 times.
✓ Branch 3 taken 484 times.
✓ Branch 4 taken 484 times.
✓ Branch 5 taken 120 times.
 1208 if (!strchr(thisstring, '"') && !strchr(thisstring, '\''))
262 {
263 968 thisstring.replace(instr, outstr, all);
264 968 return thisstring;
265 }
266 120 bool replaced=true;
267
2/2
✓ Branch 0 taken 450 times.
✓ Branch 1 taken 240 times.
 690 while (replaced)
268 {
269 225 replaced=false;
270 225 string out;
271
2/2
✓ Branch 0 taken 11490 times.
✓ Branch 1 taken 450 times.
 11940 for (int i=0;thisstring[i];)
272 {
273
14/48
✓ Branch 0 taken 1062 times.
✓ Branch 1 taken 10428 times.
✓ Branch 2 taken 6873 times.
✓ Branch 3 taken 531 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 12684 times.
✓ Branch 6 taken 6873 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 6342 times.
✓ Branch 9 taken 5745 times.
✓ Branch 10 taken 6342 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 6342 times.
✓ Branch 13 taken 531 times.
✗ Branch 14 not taken.
✓ Branch 15 taken 531 times.
✓ Branch 16 taken 531 times.
✗ Branch 17 not taken.
✗ Branch 18 not taken.
✓ Branch 19 taken 5214 times.
✗ Branch 20 not taken.
✗ Branch 21 not taken.
✗ Branch 22 not taken.
✗ Branch 23 not taken.
✗ Branch 24 not taken.
✗ Branch 25 not taken.
✗ Branch 26 not taken.
✗ Branch 27 not taken.
✗ Branch 28 not taken.
✗ Branch 29 not taken.
✗ Branch 30 not taken.
✗ Branch 31 not taken.
✗ Branch 32 not taken.
✗ Branch 33 not taken.
✗ Branch 34 not taken.
✗ Branch 35 not taken.
✗ Branch 36 not taken.
✗ Branch 37 not taken.
✗ Branch 38 not taken.
✗ Branch 39 not taken.
✗ Branch 40 not taken.
✗ Branch 41 not taken.
✗ Branch 42 not taken.
✗ Branch 43 not taken.
✗ Branch 44 not taken.
✗ Branch 45 not taken.
✗ Branch 46 not taken.
✗ Branch 47 not taken.
 24174 dequote(thisstring[i], out+= thisstring[i++], return thisstring);
274 else
275 {
276
2/2
✓ Branch 0 taken 372 times.
✓ Branch 1 taken 10056 times.
 10428 if (!strncmp((const char*)thisstring + i, instr, strlen(instr)))
277 {
278 186 replaced = true;
279
1/2
✓ Branch 0 taken 186 times.
✗ Branch 1 not taken.
 372 out += outstr;
280 372 i += (int)strlen(instr);
281
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 372 times.
 372 if (!all)
282 {
283 ✗ out += ((const char*)thisstring) + i;
284 ✗ thisstring = out;
285 ✗ return thisstring;
286 }
287 }
288 // randomdude999: prevent appending the null terminator to the output
289
2/4
✓ Branch 0 taken 5028 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5028 times.
✗ Branch 3 not taken.
 10056 else if (thisstring[i]) out += thisstring[i++];
290 }
291 }
292
1/2
✓ Branch 0 taken 225 times.
✗ Branch 1 not taken.
 225 thisstring =out;
293
1/2
✓ Branch 0 taken 225 times.
✗ Branch 1 not taken.
 450 }
294 120 return thisstring;
295 }
296
297 883244 bool confirmquotes(const char * str)
298 {
299
2/2
✓ Branch 0 taken 6688914 times.
✓ Branch 1 taken 883236 times.
 7572150 for (int i=0;str[i];)
300 {
301
20/26
✓ Branch 0 taken 1998 times.
✓ Branch 1 taken 6686916 times.
✓ Branch 2 taken 13205 times.
✓ Branch 3 taken 14196 times.
✓ Branch 4 taken 26406 times.
✓ Branch 5 taken 999 times.
✓ Branch 6 taken 14196 times.
✓ Branch 7 taken 8 times.
✓ Branch 8 taken 151 times.
✓ Branch 9 taken 3344306 times.
✓ Branch 10 taken 294 times.
✓ Branch 11 taken 3343311 times.
✓ Branch 12 taken 8 times.
✓ Branch 13 taken 286 times.
✓ Branch 14 taken 16 times.
✓ Branch 15 taken 139 times.
✗ Branch 16 not taken.
✓ Branch 17 taken 147 times.
✗ Branch 18 not taken.
✗ Branch 19 not taken.
✓ Branch 20 taken 139 times.
✓ Branch 21 taken 139 times.
✗ Branch 22 not taken.
✗ Branch 23 not taken.
✗ Branch 24 not taken.
✓ Branch 25 taken 139 times.
 6715316 dequote(str[i], i++, return false);
302 6686622 else i++;
303 }
304 441618 return true;
305 }
306
307 214400 bool confirmqpar(const char * str)
308 {
309
2/2
✓ Branch 0 taken 230622 times.
✓ Branch 1 taken 214400 times.
 445022 for (int i=0;str[i];)
310 {
311
47/64
✓ Branch 0 taken 238 times.
✓ Branch 1 taken 230384 times.
✓ Branch 2 taken 997 times.
✓ Branch 3 taken 1116 times.
✓ Branch 4 taken 1994 times.
✓ Branch 5 taken 119 times.
✓ Branch 6 taken 1116 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 36 times.
✓ Branch 9 taken 115275 times.
✓ Branch 10 taken 72 times.
✓ Branch 11 taken 115156 times.
✓ Branch 12 taken 3 times.
✓ Branch 13 taken 69 times.
✓ Branch 14 taken 6 times.
✓ Branch 15 taken 33 times.
✗ Branch 16 not taken.
✓ Branch 17 taken 36 times.
✗ Branch 18 not taken.
✗ Branch 19 not taken.
✓ Branch 20 taken 33 times.
✓ Branch 21 taken 33 times.
✓ Branch 22 taken 621 times.
✓ Branch 23 taken 114535 times.
✓ Branch 24 taken 192 times.
✓ Branch 25 taken 3713 times.
✓ Branch 26 taken 2793 times.
✓ Branch 27 taken 114727 times.
✓ Branch 28 taken 2364 times.
✓ Branch 29 taken 3680 times.
✓ Branch 30 taken 192 times.
✓ Branch 31 taken 2172 times.
✓ Branch 32 taken 2172 times.
✓ Branch 33 taken 3872 times.
✓ Branch 34 taken 2172 times.
✗ Branch 35 not taken.
✗ Branch 36 not taken.
✓ Branch 37 taken 192 times.
✗ Branch 38 not taken.
✓ Branch 39 taken 3680 times.
✗ Branch 40 not taken.
✗ Branch 41 not taken.
✗ Branch 42 not taken.
✗ Branch 43 not taken.
✗ Branch 44 not taken.
✗ Branch 45 not taken.
✗ Branch 46 not taken.
✓ Branch 47 taken 3680 times.
✓ Branch 48 taken 621 times.
✓ Branch 49 taken 3059 times.
✓ Branch 50 taken 3680 times.
✗ Branch 51 not taken.
✓ Branch 52 taken 3872 times.
✓ Branch 53 taken 621 times.
✓ Branch 54 taken 114535 times.
✓ Branch 55 taken 3680 times.
✓ Branch 56 taken 621 times.
✓ Branch 57 taken 3059 times.
✗ Branch 58 not taken.
✓ Branch 59 taken 3680 times.
✓ Branch 60 taken 3872 times.
✓ Branch 61 taken 621 times.
✗ Branch 62 not taken.
✓ Branch 63 taken 114535 times.
 244704 skippar(str[i], i++, return false);
312 229070 else i++;
313 }
314 107200 return true;
315 }
316
317 1747392 char ** nsplit(char * str, const char * key, int maxlen, int * len)
318 {
319
2/2
✓ Branch 0 taken 1308732 times.
✓ Branch 1 taken 438660 times.
 1747392 if (!strstr(str, key))
320 {
321 1308732 char ** out= typed_malloc(char*, 2);
322 1308732 out[0]=str;
323 1308732 out[1]=nullptr;
324
2/2
✓ Branch 0 taken 436884 times.
✓ Branch 1 taken 871848 times.
 1308732 if (len) *len=1;
325 1308732 return out;
326 }
327 438660 int keylen=(int)strlen(key);
328 219330 int count=7; //makes the default alloc 8 elements, sounds fair.
329
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 438660 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 438660 if (maxlen && count>maxlen) count=maxlen;
330 438660 char ** outdata= typed_malloc(char*, (size_t)count+1);
331
332 219330 int newcount=0;
333 219330 char *thisentry=str;
334 438660 outdata[newcount++]=thisentry;
335
2/2
✓ Branch 0 taken 872962 times.
✓ Branch 1 taken 438660 times.
 1311622 while((thisentry = strstr(thisentry, key))){
336 872962 *thisentry = 0;
337 872962 thisentry += keylen;
338 872962 outdata[newcount++]=thisentry;
339
2/2
✓ Branch 0 taken 584 times.
✓ Branch 1 taken 872378 times.
 872962 if(newcount >= count)
340 {
341 584 outdata = typed_realloc(char *, outdata, count * 2);
342 292 count *= 2;
343 }
344 }
345
346 438660 outdata[newcount]= nullptr;
347
2/2
✓ Branch 0 taken 437076 times.
✓ Branch 1 taken 1584 times.
 438660 if (len) *len=newcount;
348 219330 return outdata;
349 }
350
351 1749240 char ** qnsplit(char * str, const char * key, int maxlen, int * len)
352 {
353
4/4
✓ Branch 0 taken 1746576 times.
✓ Branch 1 taken 2664 times.
✓ Branch 2 taken 1746204 times.
✓ Branch 3 taken 372 times.
 1749240 if (!strchr(str, '"') && !strchr(str, '\'')) return nsplit(str, key, maxlen, len);
354 3036 int keylen=(int)strlen(key);
355 1518 int count=7;
356
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 3036 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 3036 if (maxlen && count>maxlen) count=maxlen;
357 3036 char ** outdata= typed_malloc(char*, (size_t)count+1);
358 1518 int newcount=0;
359 1518 char * thisentry=str;
360 3036 outdata[newcount++]=thisentry;
361
2/2
✓ Branch 0 taken 35400 times.
✓ Branch 1 taken 3036 times.
 38436 while (*thisentry) /*todo fix*/
362 {
363
19/26
✓ Branch 0 taken 3228 times.
✓ Branch 1 taken 32172 times.
✓ Branch 2 taken 20872 times.
✓ Branch 3 taken 22486 times.
✓ Branch 4 taken 41744 times.
✓ Branch 5 taken 1614 times.
✓ Branch 6 taken 22486 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 222 times.
✓ Branch 9 taken 17478 times.
✓ Branch 10 taken 444 times.
✓ Branch 11 taken 15864 times.
✓ Branch 12 taken 12 times.
✓ Branch 13 taken 432 times.
✓ Branch 14 taken 24 times.
✓ Branch 15 taken 210 times.
✗ Branch 16 not taken.
✓ Branch 17 taken 222 times.
✗ Branch 18 not taken.
✗ Branch 19 not taken.
✓ Branch 20 taken 210 times.
✓ Branch 21 taken 210 times.
✗ Branch 22 not taken.
✗ Branch 23 not taken.
✗ Branch 24 not taken.
✓ Branch 25 taken 210 times.
 77144 dequote(*thisentry, thisentry++, return nullptr);
364
2/2
✓ Branch 0 taken 1716 times.
✓ Branch 1 taken 30012 times.
 31728 else if (!strncmp(thisentry, key, (size_t)keylen))
365 {
366 1716 *thisentry=0;
367 1716 thisentry+=keylen;
368 1716 outdata[newcount++]=thisentry;
369
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1716 times.
 1716 if(newcount >= count)
370 {
371 ✗ outdata = typed_realloc(char *, outdata, count * 2);
372 ✗ count *= 2;
373 }
374 }
375 30012 else thisentry++;
376 }
377 3036 outdata[newcount]= nullptr;
378
2/2
✓ Branch 0 taken 1518 times.
✓ Branch 1 taken 1518 times.
 3036 if (len) *len=newcount;
379 1518 return outdata;
380 }
381
382 219980 char ** qpnsplit(char * str, const char * key, int maxlen, int * len)
383 {
384 219980 int keylen=(int)strlen(key);
385 109990 int count=7;
386
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 219980 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 219980 if (maxlen && count>maxlen) count=maxlen;
387 219980 char ** outdata= typed_malloc(char*, (size_t)count+1);
388
389 109990 int newcount=0;
390 109990 char * thisentry=str;
391 219980 outdata[newcount++]=thisentry;
392
2/2
✓ Branch 0 taken 251904 times.
✓ Branch 1 taken 219980 times.
 471884 while (*thisentry)
393 {
394
47/64
✓ Branch 0 taken 478 times.
✓ Branch 1 taken 251426 times.
✓ Branch 2 taken 1645 times.
✓ Branch 3 taken 1884 times.
✓ Branch 4 taken 3290 times.
✓ Branch 5 taken 239 times.
✓ Branch 6 taken 1884 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 36 times.
✓ Branch 9 taken 125916 times.
✓ Branch 10 taken 72 times.
✓ Branch 11 taken 125677 times.
✓ Branch 12 taken 3 times.
✓ Branch 13 taken 69 times.
✓ Branch 14 taken 6 times.
✓ Branch 15 taken 33 times.
✗ Branch 16 not taken.
✓ Branch 17 taken 36 times.
✗ Branch 18 not taken.
✗ Branch 19 not taken.
✓ Branch 20 taken 33 times.
✓ Branch 21 taken 33 times.
✓ Branch 22 taken 952 times.
✓ Branch 23 taken 124725 times.
✓ Branch 24 taken 84 times.
✓ Branch 25 taken 4978 times.
✓ Branch 26 taken 2773 times.
✓ Branch 27 taken 124809 times.
✓ Branch 28 taken 1905 times.
✓ Branch 29 taken 4945 times.
✓ Branch 30 taken 84 times.
✓ Branch 31 taken 1821 times.
✓ Branch 32 taken 1821 times.
✓ Branch 33 taken 5029 times.
✓ Branch 34 taken 1821 times.
✗ Branch 35 not taken.
✗ Branch 36 not taken.
✓ Branch 37 taken 84 times.
✗ Branch 38 not taken.
✓ Branch 39 taken 4945 times.
✗ Branch 40 not taken.
✗ Branch 41 not taken.
✗ Branch 42 not taken.
✗ Branch 43 not taken.
✗ Branch 44 not taken.
✗ Branch 45 not taken.
✗ Branch 46 not taken.
✓ Branch 47 taken 4945 times.
✓ Branch 48 taken 952 times.
✓ Branch 49 taken 3993 times.
✓ Branch 50 taken 4945 times.
✗ Branch 51 not taken.
✓ Branch 52 taken 5029 times.
✓ Branch 53 taken 952 times.
✓ Branch 54 taken 124725 times.
✓ Branch 55 taken 4945 times.
✓ Branch 56 taken 952 times.
✓ Branch 57 taken 3993 times.
✗ Branch 58 not taken.
✓ Branch 59 taken 4945 times.
✓ Branch 60 taken 5029 times.
✓ Branch 61 taken 952 times.
✗ Branch 62 not taken.
✓ Branch 63 taken 124725 times.
 268894 skippar(*thisentry, thisentry++, return nullptr);
395
2/2
✓ Branch 0 taken 3328 times.
✓ Branch 1 taken 246122 times.
 249450 else if (!strncmp(thisentry, key, (size_t)keylen))
396 {
397 3328 *thisentry=0;
398 3328 thisentry+=keylen;
399 3328 outdata[newcount++]=thisentry;
400
2/2
✓ Branch 0 taken 38 times.
✓ Branch 1 taken 3290 times.
 3328 if(newcount >= count)
401 {
402 38 outdata = typed_realloc(char *, outdata, count * 2);
403 19 count *= 2;
404 }
405 }
406 246122 else thisentry++;
407 }
408 219980 outdata[newcount]= nullptr;
409
2/2
✓ Branch 0 taken 5992 times.
✓ Branch 1 taken 213988 times.
 219980 if (len) *len=newcount;
410 109990 return outdata;
411 }
412
413 877758 string &strip_prefix(string &str, char c, bool multi)
414 {
415
2/2
✓ Branch 0 taken 2382 times.
✓ Branch 1 taken 875376 times.
 877758 if(!multi){
416
2/2
✓ Branch 0 taken 1194 times.
✓ Branch 1 taken 1188 times.
 2382 if(str.data()[0] == c){
417
3/6
✓ Branch 0 taken 597 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 597 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 597 times.
✗ Branch 5 not taken.
 1194 str = string(str.data() + 1, str.length() - 1);
418 }
419 2382 return str;
420 }
421 437688 int length = str.length();
422
2/2
✓ Branch 0 taken 653618 times.
✓ Branch 1 taken 221758 times.
 875376 for(int i = 0; i < length; i++){
423
1/2
✓ Branch 0 taken 653618 times.
✗ Branch 1 not taken.
 653618 if(str.data()[i] != c){
424
3/6
✓ Branch 0 taken 326809 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 326809 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 326809 times.
✗ Branch 5 not taken.
 653618 str = string(str.data() + i, str.length() - i);
425 653618 return str;
426 }
427 }
428 110879 return str;
429 }
430
431 875502 string &strip_suffix(string &str, char c, bool multi)
432 {
433
2/2
✓ Branch 0 taken 126 times.
✓ Branch 1 taken 875376 times.
 875502 if(!multi){
434
1/2
✓ Branch 0 taken 126 times.
✗ Branch 1 not taken.
 126 if(str.data()[str.length() - 1] == c){
435 126 str.truncate(str.length() - 1);
436 }
437 126 return str;
438 }
439
2/2
✓ Branch 0 taken 653660 times.
✓ Branch 1 taken 221758 times.
 875418 for(int i = str.length() - 1; i >= 0; i--){
440
2/2
✓ Branch 0 taken 653618 times.
✓ Branch 1 taken 42 times.
 653660 if(str.data()[i] != c){
441 653618 str.truncate(i + 1);
442 653618 return str;
443 }
444 }
445 110879 return str;
446 }
447
448 875376 string &strip_both(string &str, char c, bool multi)
449 {
450 875376 return strip_suffix(strip_prefix(str, c, multi), c, multi);
451 }
452
453
2/2
✓ Branch 0 taken 543540 times.
✓ Branch 1 taken 210 times.
 1087500 string &strip_whitespace(string &str)
454 {
455
2/2
✓ Branch 0 taken 1077386 times.
✓ Branch 1 taken 10924 times.
 1088310 for(int i = str.length() - 1; i >= 0; i--){
456
5/6
✓ Branch 0 taken 1076576 times.
✓ Branch 1 taken 810 times.
✓ Branch 2 taken 1076576 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 538288 times.
✓ Branch 5 taken 405 times.
 1077386 if(str.data()[i] != ' ' && str.data()[i] != '\t'){
457 1076576 str.truncate(i + 1);
458 538288 break;
459 }
460 }
461
462 543750 int length = str.length();
463
2/2
✓ Branch 0 taken 1077170 times.
✓ Branch 1 taken 10924 times.
 1088094 for(int i = 0; i < length; i++){
464
6/6
✓ Branch 0 taken 1076576 times.
✓ Branch 1 taken 594 times.
✓ Branch 2 taken 538288 times.
✓ Branch 3 taken 538288 times.
✓ Branch 4 taken 538288 times.
✓ Branch 5 taken 297 times.
 1077170 if(str.data()[i] != ' ' && str.data()[i] != '\t'){
465
3/6
✓ Branch 0 taken 538288 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 538288 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 538288 times.
✗ Branch 5 not taken.
 1076576 str = string(str.data() + i, str.length() - i);
466 1076576 return str;
467 }
468 }
469 5462 return str;
470 }
471
472 9476 char * itrim(char * str, const char * left, const char * right, bool multi)
473 {
474
1/2
✓ Branch 0 taken 4738 times.
✗ Branch 1 not taken.
 4738 string tmp(str);
475
1/2
✓ Branch 0 taken 4738 times.
✗ Branch 1 not taken.
 14214 return strcpy(str, itrim(tmp, left, right, multi).data());
476 9476 }
477
478 //todo merge above with this
479
2/2
✓ Branch 0 taken 5091 times.
✓ Branch 1 taken 70 times.
 10322 string &itrim(string &input, const char * left, const char * right, bool multi)
480 {
481 5161 bool nukeright=true;
482 5161 int totallen=input.length();
483 10322 int rightlen=(int)strlen(right);
484
4/4
✓ Branch 0 taken 8647 times.
✓ Branch 1 taken 1675 times.
✓ Branch 2 taken 3486 times.
✓ Branch 3 taken 1675 times.
 10322 if (rightlen && rightlen<=totallen)
485 {
486 do
487 {
488 22054 const char * rightend=right+rightlen;
489 22054 const char * strend=input.data()+totallen;
490
2/2
✓ Branch 0 taken 23200 times.
✓ Branch 1 taken 22054 times.
 45254 while (right!=rightend)
491 {
492 23200 rightend--;
493 23200 strend--;
494
2/2
✓ Branch 0 taken 6006 times.
✓ Branch 1 taken 17194 times.
 23200 if (to_lower(*strend)!=to_lower(*rightend)) nukeright=false;
495 }
496
2/2
✓ Branch 0 taken 16048 times.
✓ Branch 1 taken 6006 times.
 22054 if (nukeright)
497 {
498 16048 totallen-=rightlen;
499 8024 input.truncate(totallen);
500 }
501
6/6
✓ Branch 0 taken 18205 times.
✓ Branch 1 taken 3849 times.
✓ Branch 2 taken 15142 times.
✓ Branch 3 taken 3063 times.
✓ Branch 4 taken 7541 times.
✓ Branch 5 taken 60 times.
 22054 } while (multi && nukeright && rightlen<=totallen);
502 }
503 5161 bool nukeleft=true;
504 10322 int leftlen = strlen(left);
505
7/8
✓ Branch 0 taken 525 times.
✓ Branch 1 taken 9797 times.
✓ Branch 2 taken 204 times.
✓ Branch 3 taken 321 times.
✓ Branch 4 taken 102 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 102 times.
✓ Branch 7 taken 5059 times.
 10322 if(!multi && leftlen == 1 && input.data()[0] == left[0])
506 {
507
3/6
✓ Branch 0 taken 102 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 102 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 102 times.
✗ Branch 5 not taken.
 204 return input = string(input.data()+1, (input.length()-1));
508 }
509 else
510 {
511 do
512 {
513
514
2/2
✓ Branch 0 taken 11000 times.
✓ Branch 1 taken 11642 times.
 22642 for (int i = 0; i < leftlen; i++)
515 {
516
2/2
✓ Branch 0 taken 9476 times.
✓ Branch 1 taken 1524 times.
 11000 if (to_lower(input.data()[i])!=to_lower(left[i])) nukeleft=false;
517 }
518
5/8
✓ Branch 0 taken 2166 times.
✓ Branch 1 taken 9476 times.
✓ Branch 2 taken 1083 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1083 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 1083 times.
✗ Branch 7 not taken.
 12725 if (nukeleft) input = string(input.data()+leftlen, (input.length()-leftlen));
519
4/4
✓ Branch 0 taken 6262 times.
✓ Branch 1 taken 5380 times.
✓ Branch 2 taken 762 times.
✓ Branch 3 taken 4738 times.
 11642 } while (multi && nukeleft);
520 }
521 5059 return input;
522 }
523
524 6 char* strqpchr(const char* str, char key)
525 {
526
1/2
✓ Branch 0 taken 24 times.
✗ Branch 1 not taken.
 24 while (*str)
527 {
528
25/64
✗ Branch 0 not taken.
✓ Branch 1 taken 24 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✓ Branch 9 taken 12 times.
✗ Branch 10 not taken.
✓ Branch 11 taken 12 times.
✗ Branch 12 not taken.
✗ Branch 13 not taken.
✗ Branch 14 not taken.
✗ Branch 15 not taken.
✗ Branch 16 not taken.
✗ Branch 17 not taken.
✗ Branch 18 not taken.
✗ Branch 19 not taken.
✗ Branch 20 not taken.
✗ Branch 21 not taken.
✓ Branch 22 taken 6 times.
✓ Branch 23 taken 6 times.
✗ Branch 24 not taken.
✓ Branch 25 taken 24 times.
✓ Branch 26 taken 6 times.
✓ Branch 27 taken 6 times.
✗ Branch 28 not taken.
✓ Branch 29 taken 24 times.
✗ Branch 30 not taken.
✗ Branch 31 not taken.
✗ Branch 32 not taken.
✓ Branch 33 taken 24 times.
✗ Branch 34 not taken.
✗ Branch 35 not taken.
✗ Branch 36 not taken.
✗ Branch 37 not taken.
✗ Branch 38 not taken.
✓ Branch 39 taken 24 times.
✗ Branch 40 not taken.
✗ Branch 41 not taken.
✗ Branch 42 not taken.
✗ Branch 43 not taken.
✗ Branch 44 not taken.
✗ Branch 45 not taken.
✗ Branch 46 not taken.
✓ Branch 47 taken 24 times.
✓ Branch 48 taken 6 times.
✓ Branch 49 taken 18 times.
✓ Branch 50 taken 24 times.
✗ Branch 51 not taken.
✓ Branch 52 taken 24 times.
✓ Branch 53 taken 6 times.
✓ Branch 54 taken 6 times.
✓ Branch 55 taken 24 times.
✓ Branch 56 taken 6 times.
✓ Branch 57 taken 18 times.
✗ Branch 58 not taken.
✓ Branch 59 taken 24 times.
✓ Branch 60 taken 24 times.
✓ Branch 61 taken 6 times.
✗ Branch 62 not taken.
✓ Branch 63 taken 6 times.
 72 skippar(*str, str++, return nullptr);
529
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 6 times.
 12 else if (*str == key) return const_cast<char*>(str);
530
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3 times.
 3 else if (!*str) return nullptr;
531 6 else str++;
532 }
533 ✗ return nullptr;
534 }
535
536
537 162 char* strqpstr(const char* str, const char* key)
538 {
539 162 size_t keylen = strlen(key);
540
2/2
✓ Branch 0 taken 816 times.
✓ Branch 1 taken 6 times.
 822 while (*str)
541 {
542
25/64
✗ Branch 0 not taken.
✓ Branch 1 taken 816 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✓ Branch 9 taken 408 times.
✗ Branch 10 not taken.
✓ Branch 11 taken 408 times.
✗ Branch 12 not taken.
✗ Branch 13 not taken.
✗ Branch 14 not taken.
✗ Branch 15 not taken.
✗ Branch 16 not taken.
✗ Branch 17 not taken.
✗ Branch 18 not taken.
✗ Branch 19 not taken.
✗ Branch 20 not taken.
✗ Branch 21 not taken.
✓ Branch 22 taken 9 times.
✓ Branch 23 taken 399 times.
✗ Branch 24 not taken.
✓ Branch 25 taken 42 times.
✓ Branch 26 taken 9 times.
✓ Branch 27 taken 399 times.
✗ Branch 28 not taken.
✓ Branch 29 taken 42 times.
✗ Branch 30 not taken.
✗ Branch 31 not taken.
✗ Branch 32 not taken.
✓ Branch 33 taken 42 times.
✗ Branch 34 not taken.
✗ Branch 35 not taken.
✗ Branch 36 not taken.
✗ Branch 37 not taken.
✗ Branch 38 not taken.
✓ Branch 39 taken 42 times.
✗ Branch 40 not taken.
✗ Branch 41 not taken.
✗ Branch 42 not taken.
✗ Branch 43 not taken.
✗ Branch 44 not taken.
✗ Branch 45 not taken.
✗ Branch 46 not taken.
✓ Branch 47 taken 42 times.
✓ Branch 48 taken 9 times.
✓ Branch 49 taken 33 times.
✓ Branch 50 taken 42 times.
✗ Branch 51 not taken.
✓ Branch 52 taken 42 times.
✓ Branch 53 taken 9 times.
✓ Branch 54 taken 399 times.
✓ Branch 55 taken 42 times.
✓ Branch 56 taken 9 times.
✓ Branch 57 taken 33 times.
✗ Branch 58 not taken.
✓ Branch 59 taken 42 times.
✓ Branch 60 taken 42 times.
✓ Branch 61 taken 9 times.
✗ Branch 62 not taken.
✓ Branch 63 taken 399 times.
 900 skippar(*str, str++, return nullptr);
543
2/2
✓ Branch 0 taken 156 times.
✓ Branch 1 taken 642 times.
 798 else if (!strncmp(str, key, keylen)) return const_cast<char*>(str);
544
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 321 times.
 321 else if (!*str) return nullptr;
545 642 else str++;
546 }
547 3 return nullptr;
548 }
549
550 extern const uint8_t char_props[256] = {
551 //x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF
552 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80,0x80,0x00,0x00,0x80,0x00,0x00, // 0x
553 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, // 1x
554 0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, // 2x !"#$%&'()*+,-./
555 0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x00,0x00,0x00,0x00,0x00,0x00, // 3x 0123456789:;<=>?
556 0x00,0x23,0x23,0x23,0x23,0x23,0x23,0x22,0x22,0x22,0x22,0x22,0x22,0x22,0x22,0x22, // 4x @ABCDEFGHIJKLMNO
557 0x22,0x22,0x22,0x22,0x22,0x22,0x22,0x22,0x22,0x22,0x22,0x00,0x00,0x00,0x00,0x08, // 5x PQRSTUVWXYZ[\]^_
558 0x00,0x25,0x25,0x25,0x25,0x25,0x25,0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x24, // 6x `abcdefghijklmno
559 0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x00,0x00,0x00,0x00,0x00, // 7x pqrstuvwxyz{|}~
560 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, // 8x
561 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, // 9x
562 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, // Ax
563 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, // Bx
564 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, // Cx
565 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, // Dx
566 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, // Ex
567 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, // Fx
568 };
569