asar coverage - build #110

src/asar/
File: src/asar/libstr.cpp
Date: 2024-01-21 00:03:54
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 600 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 600 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
 600 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 300 return 0u;
35 }
36
37
38 178294 size_t utf8_val(int* codepoint, const char* inp) {
39 178294 unsigned char c = *inp++;
40 int val;
41
1/2
✓ Branch 0 taken 178294 times.
✗ Branch 1 not taken.
 178294 if (c < 0x80) {
42 // plain ascii
43 178294 *codepoint = c;
44 178294 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 600 bool is_valid_utf8(const char* inp) {
89
2/2
✓ Branch 0 taken 178294 times.
✓ Branch 1 taken 600 times.
 178894 while (*inp != '\0') {
90 89052 int codepoint;
91 178294 inp += utf8_val(&codepoint, inp);
92
93
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 178294 times.
 178294 if (codepoint == -1) return false;
94 }
95
96 300 return true;
97 }
98
99 // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
100
101
102 220 char * readfile(const char * fname, const char * basepath)
103 {
104 220 virtual_file_handle myfile = filesystem->open_file(fname, basepath);
105
2/2
✓ Branch 0 taken 110 times.
✓ Branch 1 taken 110 times.
 220 if (myfile == INVALID_VIRTUAL_FILE_HANDLE) return nullptr;
106 220 size_t datalen = filesystem->get_file_size(myfile);
107 220 char * data= typed_malloc(char, datalen+1);
108 220 data[filesystem->read_file(myfile, data, 0u, datalen)] = 0;
109 220 filesystem->close_file(myfile);
110 110 int inpos=0;
111 110 int outpos=0;
112 220 inpos += check_bom(data + inpos);
113
2/2
✓ Branch 0 taken 153974 times.
✓ Branch 1 taken 220 times.
 154194 while (data[inpos])
114 {
115
1/2
✓ Branch 0 taken 153974 times.
✗ Branch 1 not taken.
 153974 if (data[inpos]!='\r') data[outpos++]=data[inpos];
116 153974 inpos++;
117 }
118 220 data[outpos]=0;
119
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 220 times.
 220 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 110 return data;
121 }
122
123 // RPG Hacker: like readfile(), but doesn't use virtual file system
124 // and instead read our file directly.
125 380 char * readfilenative(const char * fname)
126 {
127 380 FILE* myfile = fopen(fname, "rb");
128
2/2
✓ Branch 0 taken 190 times.
✓ Branch 1 taken 190 times.
 380 if (myfile == nullptr) return nullptr;
129 380 fseek(myfile, 0, SEEK_END);
130 380 size_t datalen = (size_t)ftell(myfile);
131 380 fseek(myfile, 0, SEEK_SET);
132 380 char * data = typed_malloc(char, datalen + 1);
133 380 data[fread(data, 1u, datalen, myfile)] = 0;
134 380 fclose(myfile);
135 190 int inpos = 0;
136 190 int outpos = 0;
137 380 inpos += check_bom(data + inpos);
138
2/2
✓ Branch 0 taken 24320 times.
✓ Branch 1 taken 380 times.
 24700 while (data[inpos])
139 {
140
1/2
✓ Branch 0 taken 24320 times.
✗ Branch 1 not taken.
 24320 if (data[inpos] != '\r') data[outpos++] = data[inpos];
141 24320 inpos++;
142 }
143 380 data[outpos] = 0;
144
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 380 times.
 380 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 190 return data;
146 }
147
148 222 bool readfile(const char * fname, const char * basepath, char ** data, int * len)
149 {
150 222 virtual_file_handle myfile = filesystem->open_file(fname, basepath);
151
2/2
✓ Branch 0 taken 111 times.
✓ Branch 1 taken 111 times.
 222 if (!myfile) return false;
152 216 size_t datalen = filesystem->get_file_size(myfile);
153 216 *data= typed_malloc(char, datalen);
154 216 *len = (int)filesystem->read_file(myfile, *data, 0, datalen);
155 216 filesystem->close_file(myfile);
156 216 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 2061838 times.
 4124884 string& string::qreplace(const char * instr, const char * outstr, bool all)
258 {
259 2062442 string& thisstring =*this;
260
2/2
✓ Branch 0 taken 2062442 times.
✓ Branch 1 taken 2062442 times.
 4124884 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 881540 bool confirmquotes(const char * str)
298 {
299
2/2
✓ Branch 0 taken 6678978 times.
✓ Branch 1 taken 881532 times.
 7560510 for (int i=0;str[i];)
300 {
301
20/26
✓ Branch 0 taken 1998 times.
✓ Branch 1 taken 6676980 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 3339338 times.
✓ Branch 10 taken 294 times.
✓ Branch 11 taken 3338343 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.
 6705380 dequote(str[i], i++, return false);
302 6676686 else i++;
303 }
304 440766 return true;
305 }
306
307 214434 bool confirmqpar(const char * str)
308 {
309
2/2
✓ Branch 0 taken 231194 times.
✓ Branch 1 taken 214434 times.
 445628 for (int i=0;str[i];)
310 {
311
47/64
✓ Branch 0 taken 378 times.
✓ Branch 1 taken 230816 times.
✓ Branch 2 taken 2373 times.
✓ Branch 3 taken 2562 times.
✓ Branch 4 taken 4746 times.
✓ Branch 5 taken 189 times.
✓ Branch 6 taken 2562 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 36 times.
✓ Branch 9 taken 115561 times.
✓ Branch 10 taken 72 times.
✓ Branch 11 taken 115372 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 659 times.
✓ Branch 23 taken 114713 times.
✓ Branch 24 taken 192 times.
✓ Branch 25 taken 4135 times.
✓ Branch 26 taken 2831 times.
✓ Branch 27 taken 114905 times.
✓ Branch 28 taken 2364 times.
✓ Branch 29 taken 4102 times.
✓ Branch 30 taken 192 times.
✓ Branch 31 taken 2172 times.
✓ Branch 32 taken 2172 times.
✓ Branch 33 taken 4294 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 4102 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 4102 times.
✓ Branch 48 taken 659 times.
✓ Branch 49 taken 3443 times.
✓ Branch 50 taken 4102 times.
✗ Branch 51 not taken.
✓ Branch 52 taken 4294 times.
✓ Branch 53 taken 659 times.
✓ Branch 54 taken 114713 times.
✓ Branch 55 taken 4102 times.
✓ Branch 56 taken 659 times.
✓ Branch 57 taken 3443 times.
✗ Branch 58 not taken.
✓ Branch 59 taken 4102 times.
✓ Branch 60 taken 4294 times.
✓ Branch 61 taken 659 times.
✗ Branch 62 not taken.
✓ Branch 63 taken 114713 times.
 248872 skippar(str[i], i++, return false);
312 229426 else i++;
313 }
314 107217 return true;
315 }
316
317 1744774 char ** nsplit(char * str, const char * key, int maxlen, int * len)
318 {
319
2/2
✓ Branch 0 taken 1306584 times.
✓ Branch 1 taken 438190 times.
 1744774 if (!strstr(str, key))
320 {
321 1306584 char ** out= typed_malloc(char*, 2);
322 1306584 out[0]=str;
323 1306584 out[1]=nullptr;
324
2/2
✓ Branch 0 taken 436014 times.
✓ Branch 1 taken 870570 times.
 1306584 if (len) *len=1;
325 1306584 return out;
326 }
327 438190 int keylen=(int)strlen(key);
328 219095 int count=7; //makes the default alloc 8 elements, sounds fair.
329
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 438190 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 438190 if (maxlen && count>maxlen) count=maxlen;
330 438190 char ** outdata= typed_malloc(char*, (size_t)count+1);
331
332 219095 int newcount=0;
333 219095 char *thisentry=str;
334 438190 outdata[newcount++]=thisentry;
335
2/2
✓ Branch 0 taken 871854 times.
✓ Branch 1 taken 438190 times.
 1310044 while((thisentry = strstr(thisentry, key))){
336 871854 *thisentry = 0;
337 871854 thisentry += keylen;
338 871854 outdata[newcount++]=thisentry;
339
2/2
✓ Branch 0 taken 554 times.
✓ Branch 1 taken 871300 times.
 871854 if(newcount >= count)
340 {
341 554 outdata = typed_realloc(char *, outdata, count * 2);
342 277 count *= 2;
343 }
344 }
345
346 438190 outdata[newcount]= nullptr;
347
2/2
✓ Branch 0 taken 436668 times.
✓ Branch 1 taken 1522 times.
 438190 if (len) *len=newcount;
348 219095 return outdata;
349 }
350
351 1746684 char ** qnsplit(char * str, const char * key, int maxlen, int * len)
352 {
353
4/4
✓ Branch 0 taken 1744020 times.
✓ Branch 1 taken 2664 times.
✓ Branch 2 taken 1743648 times.
✓ Branch 3 taken 372 times.
 1746684 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 220078 char ** qpnsplit(char * str, const char * key, int maxlen, int * len)
383 {
384 220078 int keylen=(int)strlen(key);
385 110039 int count=7;
386
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 220078 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 220078 if (maxlen && count>maxlen) count=maxlen;
387 220078 char ** outdata= typed_malloc(char*, (size_t)count+1);
388
389 110039 int newcount=0;
390 110039 char * thisentry=str;
391 220078 outdata[newcount++]=thisentry;
392
2/2
✓ Branch 0 taken 253166 times.
✓ Branch 1 taken 220078 times.
 473244 while (*thisentry)
393 {
394
47/64
✓ Branch 0 taken 618 times.
✓ Branch 1 taken 252548 times.
✓ Branch 2 taken 3021 times.
✓ Branch 3 taken 3330 times.
✓ Branch 4 taken 6042 times.
✓ Branch 5 taken 309 times.
✓ Branch 6 taken 3330 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 36 times.
✓ Branch 9 taken 126547 times.
✓ Branch 10 taken 72 times.
✓ Branch 11 taken 126238 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 990 times.
✓ Branch 23 taken 125248 times.
✓ Branch 24 taken 84 times.
✓ Branch 25 taken 5400 times.
✓ Branch 26 taken 2811 times.
✓ Branch 27 taken 125332 times.
✓ Branch 28 taken 1905 times.
✓ Branch 29 taken 5367 times.
✓ Branch 30 taken 84 times.
✓ Branch 31 taken 1821 times.
✓ Branch 32 taken 1821 times.
✓ Branch 33 taken 5451 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 5367 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 5367 times.
✓ Branch 48 taken 990 times.
✓ Branch 49 taken 4377 times.
✓ Branch 50 taken 5367 times.
✗ Branch 51 not taken.
✓ Branch 52 taken 5451 times.
✓ Branch 53 taken 990 times.
✓ Branch 54 taken 125248 times.
✓ Branch 55 taken 5367 times.
✓ Branch 56 taken 990 times.
✓ Branch 57 taken 4377 times.
✗ Branch 58 not taken.
✓ Branch 59 taken 5367 times.
✓ Branch 60 taken 5451 times.
✓ Branch 61 taken 990 times.
✗ Branch 62 not taken.
✓ Branch 63 taken 125248 times.
 273752 skippar(*thisentry, thisentry++, return nullptr);
395
2/2
✓ Branch 0 taken 3502 times.
✓ Branch 1 taken 246994 times.
 250496 else if (!strncmp(thisentry, key, (size_t)keylen))
396 {
397 3502 *thisentry=0;
398 3502 thisentry+=keylen;
399 3502 outdata[newcount++]=thisentry;
400
2/2
✓ Branch 0 taken 42 times.
✓ Branch 1 taken 3460 times.
 3502 if(newcount >= count)
401 {
402 42 outdata = typed_realloc(char *, outdata, count * 2);
403 21 count *= 2;
404 }
405 }
406 246994 else thisentry++;
407 }
408 220078 outdata[newcount]= nullptr;
409
2/2
✓ Branch 0 taken 6068 times.
✓ Branch 1 taken 214010 times.
 220078 if (len) *len=newcount;
410 110039 return outdata;
411 }
412
413 876408 string &strip_prefix(string &str, char c, bool multi)
414 {
415
2/2
✓ Branch 0 taken 2310 times.
✓ Branch 1 taken 874098 times.
 876408 if(!multi){
416
2/2
✓ Branch 0 taken 1170 times.
✓ Branch 1 taken 1140 times.
 2310 if(str.data()[0] == c){
417
3/6
✓ Branch 0 taken 585 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 585 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 585 times.
✗ Branch 5 not taken.
 1170 str = string(str.data() + 1, str.length() - 1);
418 }
419 2310 return str;
420 }
421 437049 int length = str.length();
422
2/2
✓ Branch 0 taken 653018 times.
✓ Branch 1 taken 221080 times.
 874098 for(int i = 0; i < length; i++){
423
1/2
✓ Branch 0 taken 653018 times.
✗ Branch 1 not taken.
 653018 if(str.data()[i] != c){
424
3/6
✓ Branch 0 taken 326509 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 326509 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 326509 times.
✗ Branch 5 not taken.
 653018 str = string(str.data() + i, str.length() - i);
425 653018 return str;
426 }
427 }
428 110540 return str;
429 }
430
431 874224 string &strip_suffix(string &str, char c, bool multi)
432 {
433
2/2
✓ Branch 0 taken 126 times.
✓ Branch 1 taken 874098 times.
 874224 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 653060 times.
✓ Branch 1 taken 221080 times.
 874140 for(int i = str.length() - 1; i >= 0; i--){
440
2/2
✓ Branch 0 taken 653018 times.
✓ Branch 1 taken 42 times.
 653060 if(str.data()[i] != c){
441 653018 str.truncate(i + 1);
442 653018 return str;
443 }
444 }
445 110540 return str;
446 }
447
448 874098 string &strip_both(string &str, char c, bool multi)
449 {
450 874098 return strip_suffix(strip_prefix(str, c, multi), c, multi);
451 }
452
453
2/2
✓ Branch 0 taken 542857 times.
✓ Branch 1 taken 210 times.
 1086134 string &strip_whitespace(string &str)
454 {
455
2/2
✓ Branch 0 taken 1076682 times.
✓ Branch 1 taken 10230 times.
 1086912 for(int i = str.length() - 1; i >= 0; i--){
456
5/6
✓ Branch 0 taken 1075904 times.
✓ Branch 1 taken 778 times.
✓ Branch 2 taken 1075904 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 537952 times.
✓ Branch 5 taken 389 times.
 1076682 if(str.data()[i] != ' ' && str.data()[i] != '\t'){
457 1075904 str.truncate(i + 1);
458 537952 break;
459 }
460 }
461
462 543067 int length = str.length();
463
2/2
✓ Branch 0 taken 1076474 times.
✓ Branch 1 taken 10230 times.
 1086704 for(int i = 0; i < length; i++){
464
6/6
✓ Branch 0 taken 1075904 times.
✓ Branch 1 taken 570 times.
✓ Branch 2 taken 537952 times.
✓ Branch 3 taken 537952 times.
✓ Branch 4 taken 537952 times.
✓ Branch 5 taken 285 times.
 1076474 if(str.data()[i] != ' ' && str.data()[i] != '\t'){
465
3/6
✓ Branch 0 taken 537952 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 537952 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 537952 times.
✗ Branch 5 not taken.
 1075904 str = string(str.data() + i, str.length() - i);
466 1075904 return str;
467 }
468 }
469 5115 return str;
470 }
471
472 9050 char * itrim(char * str, const char * left, const char * right, bool multi)
473 {
474
1/2
✓ Branch 0 taken 4525 times.
✗ Branch 1 not taken.
 4525 string tmp(str);
475
1/2
✓ Branch 0 taken 4525 times.
✗ Branch 1 not taken.
 13575 return strcpy(str, itrim(tmp, left, right, multi).data());
476 9050 }
477
478 //todo merge above with this
479
2/2
✓ Branch 0 taken 4878 times.
✓ Branch 1 taken 70 times.
 9896 string &itrim(string &input, const char * left, const char * right, bool multi)
480 {
481 4948 bool nukeright=true;
482 4948 int totallen=input.length();
483 9896 int rightlen=(int)strlen(right);
484
4/4
✓ Branch 0 taken 8334 times.
✓ Branch 1 taken 1562 times.
✓ Branch 2 taken 3386 times.
✓ Branch 3 taken 1562 times.
 9896 if (rightlen && rightlen<=totallen)
485 {
486 do
487 {
488 21854 const char * rightend=right+rightlen;
489 21854 const char * strend=input.data()+totallen;
490
2/2
✓ Branch 0 taken 23000 times.
✓ Branch 1 taken 21854 times.
 44854 while (right!=rightend)
491 {
492 23000 rightend--;
493 23000 strend--;
494
2/2
✓ Branch 0 taken 5806 times.
✓ Branch 1 taken 17194 times.
 23000 if (to_lower(*strend)!=to_lower(*rightend)) nukeright=false;
495 }
496
2/2
✓ Branch 0 taken 16048 times.
✓ Branch 1 taken 5806 times.
 21854 if (nukeright)
497 {
498 16048 totallen-=rightlen;
499 8024 input.truncate(totallen);
500 }
501
6/6
✓ Branch 0 taken 18105 times.
✓ Branch 1 taken 3749 times.
✓ Branch 2 taken 15142 times.
✓ Branch 3 taken 2963 times.
✓ Branch 4 taken 7541 times.
✓ Branch 5 taken 60 times.
 21854 } while (multi && nukeright && rightlen<=totallen);
502 }
503 4948 bool nukeleft=true;
504 9896 int leftlen = strlen(left);
505
7/8
✓ Branch 0 taken 525 times.
✓ Branch 1 taken 9371 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 4846 times.
 9896 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 10574 times.
✓ Branch 1 taken 11216 times.
 21790 for (int i = 0; i < leftlen; i++)
515 {
516
2/2
✓ Branch 0 taken 9050 times.
✓ Branch 1 taken 1524 times.
 10574 if (to_lower(input.data()[i])!=to_lower(left[i])) nukeleft=false;
517 }
518
5/8
✓ Branch 0 taken 2166 times.
✓ Branch 1 taken 9050 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.
 12299 if (nukeleft) input = string(input.data()+leftlen, (input.length()-leftlen));
519
4/4
✓ Branch 0 taken 6049 times.
✓ Branch 1 taken 5167 times.
✓ Branch 2 taken 762 times.
✓ Branch 3 taken 4525 times.
 11216 } while (multi && nukeleft);
520 }
521 4846 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