| 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 0 not taken.
✓ Branch 1 taken 630 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✗ Branch 5 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 |
|
315 |
return 0u; |
| 35 |
|
|
} |
| 36 |
|
|
|
| 37 |
|
|
|
| 38 |
|
188010 |
size_t utf8_val(int* codepoint, const char* inp) { |
| 39 |
|
188010 |
unsigned char c = *inp++; |
| 40 |
|
|
int val; |
| 41 |
1/2
✓ Branch 0 taken 188010 times.
✗ Branch 1 not taken.
|
188010 |
if (c < 0x80) { |
| 42 |
|
|
// plain ascii |
| 43 |
|
188010 |
*codepoint = c; |
| 44 |
|
188010 |
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 |
2/2
✓ Branch 0 taken 188010 times.
✓ Branch 1 taken 630 times.
|
188640 |
while (*inp != '\0') { |
| 90 |
|
94955 |
int codepoint; |
| 91 |
|
188010 |
inp += utf8_val(&codepoint, inp); |
| 92 |
|
|
|
| 93 |
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 188010 times.
|
188010 |
if (codepoint == -1) return false; |
| 94 |
|
|
} |
| 95 |
|
|
|
| 96 |
|
315 |
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 |
2/2
✓ Branch 0 taken 115 times.
✓ Branch 1 taken 115 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 |
|
115 |
int inpos=0; |
| 111 |
|
115 |
int outpos=0; |
| 112 |
|
230 |
inpos += check_bom(data + inpos); |
| 113 |
2/2
✓ Branch 0 taken 160310 times.
✓ Branch 1 taken 230 times.
|
160540 |
while (data[inpos]) |
| 114 |
|
|
{ |
| 115 |
1/2
✓ Branch 0 taken 160310 times.
✗ Branch 1 not taken.
|
160310 |
if (data[inpos]!='\r') data[outpos++]=data[inpos]; |
| 116 |
|
160310 |
inpos++; |
| 117 |
|
|
} |
| 118 |
|
230 |
data[outpos]=0; |
| 119 |
1/2
✗ Branch 0 not taken.
✓ Branch 1 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 |
|
115 |
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 |
2/2
✓ Branch 0 taken 200 times.
✓ Branch 1 taken 200 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 |
|
200 |
int inpos = 0; |
| 136 |
|
200 |
int outpos = 0; |
| 137 |
|
400 |
inpos += check_bom(data + inpos); |
| 138 |
2/2
✓ Branch 0 taken 27700 times.
✓ Branch 1 taken 400 times.
|
28100 |
while (data[inpos]) |
| 139 |
|
|
{ |
| 140 |
1/2
✓ Branch 0 taken 27700 times.
✗ Branch 1 not taken.
|
27700 |
if (data[inpos] != '\r') data[outpos++] = data[inpos]; |
| 141 |
|
27700 |
inpos++; |
| 142 |
|
|
} |
| 143 |
|
400 |
data[outpos] = 0; |
| 144 |
1/2
✗ Branch 0 not taken.
✓ Branch 1 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 |
|
200 |
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 0 taken 116 times.
✓ Branch 1 taken 116 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 |
|
484 |
string& thisstring=*this; |
| 207 |
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 968 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 |
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))) |
| 217 |
|
|
{ |
| 218 |
|
469 |
const char * indat= thisstring; |
| 219 |
|
938 |
char * trueoutdat= typed_malloc(char, strlen(indat)+1); |
| 220 |
|
469 |
char * outdat=trueoutdat; |
| 221 |
|
938 |
int thelen=(int)strlen(outstr); |
| 222 |
|
|
//nested hack |
| 223 |
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 936 times.
|
938 |
if (thelen==0) |
| 224 |
|
|
{ |
| 225 |
|
2 |
char thechar=instr[0]; |
| 226 |
2/2
✓ Branch 0 taken 60 times.
✓ Branch 1 taken 2 times.
|
62 |
while (*indat) |
| 227 |
|
|
{ |
| 228 |
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 54 times.
|
60 |
if (*indat==thechar) indat++; |
| 229 |
|
54 |
else *outdat++=*indat++; |
| 230 |
|
|
} |
| 231 |
|
2 |
*outdat=0; |
| 232 |
|
1 |
thisstring =trueoutdat; |
| 233 |
|
2 |
free(trueoutdat); |
| 234 |
|
2 |
return thisstring; |
| 235 |
|
|
} |
| 236 |
1/2
✓ Branch 0 taken 936 times.
✗ Branch 1 not taken.
|
936 |
else if (thelen==1) |
| 237 |
|
|
{ |
| 238 |
|
936 |
char firstchar=instr[0]; |
| 239 |
|
936 |
char secondchar=instr[1]; |
| 240 |
2/2
✓ Branch 0 taken 13114 times.
✓ Branch 1 taken 936 times.
|
14050 |
while (*indat) |
| 241 |
|
|
{ |
| 242 |
2/2
✓ Branch 0 taken 1054 times.
✓ Branch 1 taken 12060 times.
|
13114 |
if (*indat==firstchar) |
| 243 |
|
|
{ |
| 244 |
|
1054 |
*outdat++=*indat++; |
| 245 |
2/2
✓ Branch 0 taken 1050 times.
✓ Branch 1 taken 1054 times.
|
2104 |
while (*indat==secondchar) indat++; |
| 246 |
|
|
} |
| 247 |
|
12060 |
else *outdat++=*indat++; |
| 248 |
|
|
} |
| 249 |
|
936 |
*outdat=0; |
| 250 |
|
468 |
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 |
|
15 |
bool replaced=true; |
| 277 |
2/2
✓ Branch 0 taken 60 times.
✓ Branch 1 taken 30 times.
|
90 |
while (replaced) |
| 278 |
|
|
{ |
| 279 |
|
30 |
replaced=false; |
| 280 |
|
30 |
string out; |
| 281 |
|
30 |
const char * in= thisstring; |
| 282 |
|
60 |
int inlen=(int)strlen(instr); |
| 283 |
2/2
✓ Branch 0 taken 1014 times.
✓ Branch 1 taken 60 times.
|
1074 |
while (*in) |
| 284 |
|
|
{ |
| 285 |
2/2
✓ Branch 0 taken 30 times.
✓ Branch 1 taken 984 times.
|
1014 |
if (!strncmp(in, instr, (size_t)inlen)) |
| 286 |
|
|
{ |
| 287 |
|
15 |
replaced=true; |
| 288 |
1/2
✓ Branch 0 taken 15 times.
✗ Branch 1 not taken.
|
30 |
out+=outstr; |
| 289 |
|
30 |
in+=inlen; |
| 290 |
|
|
} |
| 291 |
1/2
✓ Branch 0 taken 492 times.
✗ Branch 1 not taken.
|
984 |
else out+=*in++; |
| 292 |
|
|
} |
| 293 |
1/2
✓ Branch 0 taken 30 times.
✗ Branch 1 not taken.
|
30 |
thisstring =out; |
| 294 |
|
60 |
} |
| 295 |
|
15 |
return thisstring; |
| 296 |
|
|
} |
| 297 |
|
|
|
| 298 |
2/2
✓ Branch 0 taken 604 times.
✓ Branch 1 taken 2064682 times.
|
4130572 |
string& string::qreplace(const char * instr, const char * outstr, bool all) |
| 299 |
|
|
{ |
| 300 |
|
2065286 |
string& thisstring =*this; |
| 301 |
2/2
✓ Branch 0 taken 2065286 times.
✓ Branch 1 taken 2065286 times.
|
4130572 |
if (!strstr(thisstring, instr)) return thisstring; |
| 302 |
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, '\'')) |
| 303 |
|
|
{ |
| 304 |
|
968 |
thisstring.replace(instr, outstr, all); |
| 305 |
|
968 |
return thisstring; |
| 306 |
|
|
} |
| 307 |
|
120 |
bool replaced=true; |
| 308 |
2/2
✓ Branch 0 taken 450 times.
✓ Branch 1 taken 240 times.
|
690 |
while (replaced) |
| 309 |
|
|
{ |
| 310 |
|
225 |
replaced=false; |
| 311 |
|
225 |
string out; |
| 312 |
2/2
✓ Branch 0 taken 11490 times.
✓ Branch 1 taken 450 times.
|
11940 |
for (int i=0;thisstring[i];) |
| 313 |
|
|
{ |
| 314 |
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); |
| 315 |
|
|
else |
| 316 |
|
|
{ |
| 317 |
2/2
✓ Branch 0 taken 372 times.
✓ Branch 1 taken 10056 times.
|
10428 |
if (!strncmp((const char*)thisstring + i, instr, strlen(instr))) |
| 318 |
|
|
{ |
| 319 |
|
186 |
replaced = true; |
| 320 |
1/2
✓ Branch 0 taken 186 times.
✗ Branch 1 not taken.
|
372 |
out += outstr; |
| 321 |
|
372 |
i += (int)strlen(instr); |
| 322 |
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 372 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 |
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++]; |
| 331 |
|
|
} |
| 332 |
|
|
} |
| 333 |
1/2
✓ Branch 0 taken 225 times.
✗ Branch 1 not taken.
|
225 |
thisstring =out; |
| 334 |
1/2
✓ Branch 0 taken 225 times.
✗ Branch 1 not taken.
|
450 |
} |
| 335 |
|
120 |
return thisstring; |
| 336 |
|
|
} |
| 337 |
|
|
|
| 338 |
|
883436 |
bool confirmquotes(const char * str) |
| 339 |
|
|
{ |
| 340 |
2/2
✓ Branch 0 taken 6690948 times.
✓ Branch 1 taken 883428 times.
|
7574376 |
for (int i=0;str[i];) |
| 341 |
|
|
{ |
| 342 |
20/26
✓ Branch 0 taken 1998 times.
✓ Branch 1 taken 6688950 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 3345323 times.
✓ Branch 10 taken 294 times.
✓ Branch 11 taken 3344328 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.
|
6717350 |
dequote(str[i], i++, return false); |
| 343 |
|
6688656 |
else i++; |
| 344 |
|
|
} |
| 345 |
|
441714 |
return true; |
| 346 |
|
|
} |
| 347 |
|
|
|
| 348 |
|
214478 |
bool confirmqpar(const char * str) |
| 349 |
|
|
{ |
| 350 |
2/2
✓ Branch 0 taken 231042 times.
✓ Branch 1 taken 214478 times.
|
445520 |
for (int i=0;str[i];) |
| 351 |
|
|
{ |
| 352 |
47/64
✓ Branch 0 taken 238 times.
✓ Branch 1 taken 230804 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 115485 times.
✓ Branch 10 taken 72 times.
✓ Branch 11 taken 115366 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 114745 times.
✓ Branch 24 taken 192 times.
✓ Branch 25 taken 3713 times.
✓ Branch 26 taken 2793 times.
✓ Branch 27 taken 114937 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 114745 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 114745 times.
|
245124 |
skippar(str[i], i++, return false); |
| 353 |
|
229490 |
else i++; |
| 354 |
|
|
} |
| 355 |
|
107239 |
return true; |
| 356 |
|
|
} |
| 357 |
|
|
|
| 358 |
|
1747682 |
char ** nsplit(char * str, const char * key, int maxlen, int * len) |
| 359 |
|
|
{ |
| 360 |
2/2
✓ Branch 0 taken 1308918 times.
✓ Branch 1 taken 438764 times.
|
1747682 |
if (!strstr(str, key)) |
| 361 |
|
|
{ |
| 362 |
|
1308918 |
char ** out= typed_malloc(char*, 2); |
| 363 |
|
1308918 |
out[0]=str; |
| 364 |
|
1308918 |
out[1]=nullptr; |
| 365 |
2/2
✓ Branch 0 taken 436926 times.
✓ Branch 1 taken 871992 times.
|
1308918 |
if (len) *len=1; |
| 366 |
|
1308918 |
return out; |
| 367 |
|
|
} |
| 368 |
|
438764 |
int keylen=(int)strlen(key); |
| 369 |
|
219382 |
int count=7; //makes the default alloc 8 elements, sounds fair. |
| 370 |
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 438764 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
438764 |
if (maxlen && count>maxlen) count=maxlen; |
| 371 |
|
438764 |
char ** outdata= typed_malloc(char*, (size_t)count+1); |
| 372 |
|
|
|
| 373 |
|
219382 |
int newcount=0; |
| 374 |
|
219382 |
char *thisentry=str; |
| 375 |
|
438764 |
outdata[newcount++]=thisentry; |
| 376 |
2/2
✓ Branch 0 taken 873164 times.
✓ Branch 1 taken 438764 times.
|
1311928 |
while((thisentry = strstr(thisentry, key))){ |
| 377 |
|
873164 |
*thisentry = 0; |
| 378 |
|
873164 |
thisentry += keylen; |
| 379 |
|
873164 |
outdata[newcount++]=thisentry; |
| 380 |
2/2
✓ Branch 0 taken 588 times.
✓ Branch 1 taken 872576 times.
|
873164 |
if(newcount >= count) |
| 381 |
|
|
{ |
| 382 |
|
588 |
outdata = typed_realloc(char *, outdata, count * 2); |
| 383 |
|
294 |
count *= 2; |
| 384 |
|
|
} |
| 385 |
|
|
} |
| 386 |
|
|
|
| 387 |
|
438764 |
outdata[newcount]= nullptr; |
| 388 |
2/2
✓ Branch 0 taken 437178 times.
✓ Branch 1 taken 1586 times.
|
438764 |
if (len) *len=newcount; |
| 389 |
|
219382 |
return outdata; |
| 390 |
|
|
} |
| 391 |
|
|
|
| 392 |
|
1749528 |
char ** qnsplit(char * str, const char * key, int maxlen, int * len) |
| 393 |
|
|
{ |
| 394 |
4/4
✓ Branch 0 taken 1746864 times.
✓ Branch 1 taken 2664 times.
✓ Branch 2 taken 1746492 times.
✓ Branch 3 taken 372 times.
|
1749528 |
if (!strchr(str, '"') && !strchr(str, '\'')) return nsplit(str, key, maxlen, len); |
| 395 |
|
3036 |
int keylen=(int)strlen(key); |
| 396 |
|
1518 |
int count=7; |
| 397 |
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; |
| 398 |
|
3036 |
char ** outdata= typed_malloc(char*, (size_t)count+1); |
| 399 |
|
1518 |
int newcount=0; |
| 400 |
|
1518 |
char * thisentry=str; |
| 401 |
|
3036 |
outdata[newcount++]=thisentry; |
| 402 |
2/2
✓ Branch 0 taken 35400 times.
✓ Branch 1 taken 3036 times.
|
38436 |
while (*thisentry) /*todo fix*/ |
| 403 |
|
|
{ |
| 404 |
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); |
| 405 |
2/2
✓ Branch 0 taken 1716 times.
✓ Branch 1 taken 30012 times.
|
31728 |
else if (!strncmp(thisentry, key, (size_t)keylen)) |
| 406 |
|
|
{ |
| 407 |
|
1716 |
*thisentry=0; |
| 408 |
|
1716 |
thisentry+=keylen; |
| 409 |
|
1716 |
outdata[newcount++]=thisentry; |
| 410 |
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1716 times.
|
1716 |
if(newcount >= count) |
| 411 |
|
|
{ |
| 412 |
|
✗ |
outdata = typed_realloc(char *, outdata, count * 2); |
| 413 |
|
✗ |
count *= 2; |
| 414 |
|
|
} |
| 415 |
|
|
} |
| 416 |
|
30012 |
else thisentry++; |
| 417 |
|
|
} |
| 418 |
|
3036 |
outdata[newcount]= nullptr; |
| 419 |
2/2
✓ Branch 0 taken 1518 times.
✓ Branch 1 taken 1518 times.
|
3036 |
if (len) *len=newcount; |
| 420 |
|
1518 |
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 |
|
109999 |
int count=7; |
| 427 |
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 219998 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
219998 |
if (maxlen && count>maxlen) count=maxlen; |
| 428 |
|
219998 |
char ** outdata= typed_malloc(char*, (size_t)count+1); |
| 429 |
|
|
|
| 430 |
|
109999 |
int newcount=0; |
| 431 |
|
109999 |
char * thisentry=str; |
| 432 |
|
219998 |
outdata[newcount++]=thisentry; |
| 433 |
2/2
✓ Branch 0 taken 252132 times.
✓ Branch 1 taken 219998 times.
|
472130 |
while (*thisentry) |
| 434 |
|
|
{ |
| 435 |
47/64
✓ Branch 0 taken 478 times.
✓ Branch 1 taken 251654 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 126030 times.
✓ Branch 10 taken 72 times.
✓ Branch 11 taken 125791 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 124839 times.
✓ Branch 24 taken 84 times.
✓ Branch 25 taken 4978 times.
✓ Branch 26 taken 2773 times.
✓ Branch 27 taken 124923 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 124839 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 124839 times.
|
269122 |
skippar(*thisentry, thisentry++, return nullptr); |
| 436 |
2/2
✓ Branch 0 taken 3340 times.
✓ Branch 1 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 0 taken 38 times.
✓ Branch 1 taken 3302 times.
|
3340 |
if(newcount >= count) |
| 442 |
|
|
{ |
| 443 |
|
38 |
outdata = typed_realloc(char *, outdata, count * 2); |
| 444 |
|
19 |
count *= 2; |
| 445 |
|
|
} |
| 446 |
|
|
} |
| 447 |
|
246338 |
else thisentry++; |
| 448 |
|
|
} |
| 449 |
|
219998 |
outdata[newcount]= nullptr; |
| 450 |
2/2
✓ Branch 0 taken 6004 times.
✓ Branch 1 taken 213994 times.
|
219998 |
if (len) *len=newcount; |
| 451 |
|
109999 |
return outdata; |
| 452 |
|
|
} |
| 453 |
|
|
|
| 454 |
|
878494 |
string &strip_prefix(string &str, char c, bool multi) |
| 455 |
|
|
{ |
| 456 |
2/2
✓ Branch 0 taken 2974 times.
✓ Branch 1 taken 875520 times.
|
878494 |
if(!multi){ |
| 457 |
2/2
✓ Branch 0 taken 1774 times.
✓ Branch 1 taken 1200 times.
|
2974 |
if(str.data()[0] == c){ |
| 458 |
3/6
✓ Branch 0 taken 887 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 887 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 887 times.
✗ Branch 5 not taken.
|
1774 |
str = string(str.data() + 1, str.length() - 1); |
| 459 |
|
|
} |
| 460 |
|
2974 |
return str; |
| 461 |
|
|
} |
| 462 |
|
437760 |
int length = str.length(); |
| 463 |
2/2
✓ Branch 0 taken 653708 times.
✓ Branch 1 taken 221812 times.
|
875520 |
for(int i = 0; i < length; i++){ |
| 464 |
1/2
✓ Branch 0 taken 653708 times.
✗ Branch 1 not taken.
|
653708 |
if(str.data()[i] != c){ |
| 465 |
3/6
✓ Branch 0 taken 326854 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 326854 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 326854 times.
✗ Branch 5 not taken.
|
653708 |
str = string(str.data() + i, str.length() - i); |
| 466 |
|
653708 |
return str; |
| 467 |
|
|
} |
| 468 |
|
|
} |
| 469 |
|
110906 |
return str; |
| 470 |
|
|
} |
| 471 |
|
|
|
| 472 |
|
875760 |
string &strip_suffix(string &str, char c, bool multi) |
| 473 |
|
|
{ |
| 474 |
2/2
✓ Branch 0 taken 240 times.
✓ Branch 1 taken 875520 times.
|
875760 |
if(!multi){ |
| 475 |
1/2
✓ Branch 0 taken 240 times.
✗ Branch 1 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 0 taken 653750 times.
✓ Branch 1 taken 221812 times.
|
875562 |
for(int i = str.length() - 1; i >= 0; i--){ |
| 481 |
2/2
✓ Branch 0 taken 653708 times.
✓ Branch 1 taken 42 times.
|
653750 |
if(str.data()[i] != c){ |
| 482 |
|
653708 |
str.truncate(i + 1); |
| 483 |
|
653708 |
return str; |
| 484 |
|
|
} |
| 485 |
|
|
} |
| 486 |
|
110906 |
return str; |
| 487 |
|
|
} |
| 488 |
|
|
|
| 489 |
|
875520 |
string &strip_both(string &str, char c, bool multi) |
| 490 |
|
|
{ |
| 491 |
|
875520 |
return strip_suffix(strip_prefix(str, c, multi), c, multi); |
| 492 |
|
|
} |
| 493 |
|
|
|
| 494 |
2/2
✓ Branch 0 taken 543623 times.
✓ Branch 1 taken 210 times.
|
1087666 |
string &strip_whitespace(string &str) |
| 495 |
|
|
{ |
| 496 |
2/2
✓ Branch 0 taken 1077484 times.
✓ Branch 1 taken 10982 times.
|
1088466 |
for(int i = str.length() - 1; i >= 0; i--){ |
| 497 |
5/6
✓ Branch 0 taken 1076684 times.
✓ Branch 1 taken 800 times.
✓ Branch 2 taken 1076684 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 538342 times.
✓ Branch 5 taken 400 times.
|
1077484 |
if(str.data()[i] != ' ' && str.data()[i] != '\t'){ |
| 498 |
|
1076684 |
str.truncate(i + 1); |
| 499 |
|
538342 |
break; |
| 500 |
|
|
} |
| 501 |
|
|
} |
| 502 |
|
|
|
| 503 |
|
543833 |
int length = str.length(); |
| 504 |
2/2
✓ Branch 0 taken 1077284 times.
✓ Branch 1 taken 10982 times.
|
1088266 |
for(int i = 0; i < length; i++){ |
| 505 |
6/6
✓ Branch 0 taken 1076684 times.
✓ Branch 1 taken 600 times.
✓ Branch 2 taken 538342 times.
✓ Branch 3 taken 538342 times.
✓ Branch 4 taken 538342 times.
✓ Branch 5 taken 300 times.
|
1077284 |
if(str.data()[i] != ' ' && str.data()[i] != '\t'){ |
| 506 |
3/6
✓ Branch 0 taken 538342 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 538342 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 538342 times.
✗ Branch 5 not taken.
|
1076684 |
str = string(str.data() + i, str.length() - i); |
| 507 |
|
1076684 |
return str; |
| 508 |
|
|
} |
| 509 |
|
|
} |
| 510 |
|
5491 |
return str; |
| 511 |
|
|
} |
| 512 |
|
|
|
| 513 |
|
9524 |
char * itrim(char * str, const char * left, const char * right, bool multi) |
| 514 |
|
|
{ |
| 515 |
1/2
✓ Branch 0 taken 4762 times.
✗ Branch 1 not taken.
|
4762 |
string tmp(str); |
| 516 |
1/2
✓ Branch 0 taken 4762 times.
✗ Branch 1 not taken.
|
14286 |
return strcpy(str, itrim(tmp, left, right, multi).data()); |
| 517 |
|
9524 |
} |
| 518 |
|
|
|
| 519 |
|
|
//todo merge above with this |
| 520 |
2/2
✓ Branch 0 taken 5538 times.
✓ Branch 1 taken 70 times.
|
11216 |
string &itrim(string &input, const char * left, const char * right, bool multi) |
| 521 |
|
|
{ |
| 522 |
|
5608 |
bool nukeright=true; |
| 523 |
|
5608 |
int totallen=input.length(); |
| 524 |
|
11216 |
int rightlen=(int)strlen(right); |
| 525 |
4/4
✓ Branch 0 taken 9532 times.
✓ Branch 1 taken 1684 times.
✓ Branch 2 taken 3924 times.
✓ Branch 3 taken 1684 times.
|
11216 |
if (rightlen && rightlen<=totallen) |
| 526 |
|
|
{ |
| 527 |
|
|
do |
| 528 |
|
|
{ |
| 529 |
|
22930 |
const char * rightend=right+rightlen; |
| 530 |
|
22930 |
const char * strend=input.data()+totallen; |
| 531 |
2/2
✓ Branch 0 taken 25222 times.
✓ Branch 1 taken 22930 times.
|
48152 |
while (right!=rightend) |
| 532 |
|
|
{ |
| 533 |
|
25222 |
rightend--; |
| 534 |
|
25222 |
strend--; |
| 535 |
2/2
✓ Branch 0 taken 6036 times.
✓ Branch 1 taken 19186 times.
|
25222 |
if (to_lower(*strend)!=to_lower(*rightend)) nukeright=false; |
| 536 |
|
|
} |
| 537 |
2/2
✓ Branch 0 taken 16894 times.
✓ Branch 1 taken 6036 times.
|
22930 |
if (nukeright) |
| 538 |
|
|
{ |
| 539 |
|
16894 |
totallen-=rightlen; |
| 540 |
|
8447 |
input.truncate(totallen); |
| 541 |
|
|
} |
| 542 |
6/6
✓ Branch 0 taken 18220 times.
✓ Branch 1 taken 4710 times.
✓ Branch 2 taken 15142 times.
✓ Branch 3 taken 3078 times.
✓ Branch 4 taken 7541 times.
✓ Branch 5 taken 60 times.
|
22930 |
} while (multi && nukeright && rightlen<=totallen); |
| 543 |
|
|
} |
| 544 |
|
5608 |
bool nukeleft=true; |
| 545 |
|
11216 |
int leftlen = strlen(left); |
| 546 |
7/8
✓ Branch 0 taken 1050 times.
✓ Branch 1 taken 10166 times.
✓ Branch 2 taken 408 times.
✓ Branch 3 taken 642 times.
✓ Branch 4 taken 204 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 204 times.
✓ Branch 7 taken 5404 times.
|
11216 |
if(!multi && leftlen == 1 && input.data()[0] == left[0]) |
| 547 |
|
|
{ |
| 548 |
3/6
✓ Branch 0 taken 204 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 204 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 204 times.
✗ Branch 5 not taken.
|
408 |
return input = string(input.data()+1, (input.length()-1)); |
| 549 |
|
|
} |
| 550 |
|
|
else |
| 551 |
|
|
{ |
| 552 |
|
|
do |
| 553 |
|
|
{ |
| 554 |
|
|
|
| 555 |
2/2
✓ Branch 0 taken 11048 times.
✓ Branch 1 taken 12332 times.
|
23380 |
for (int i = 0; i < leftlen; i++) |
| 556 |
|
|
{ |
| 557 |
2/2
✓ Branch 0 taken 9524 times.
✓ Branch 1 taken 1524 times.
|
11048 |
if (to_lower(input.data()[i])!=to_lower(left[i])) nukeleft=false; |
| 558 |
|
|
} |
| 559 |
5/8
✓ Branch 0 taken 2808 times.
✓ Branch 1 taken 9524 times.
✓ Branch 2 taken 1404 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1404 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 1404 times.
✗ Branch 7 not taken.
|
13736 |
if (nukeleft) input = string(input.data()+leftlen, (input.length()-leftlen)); |
| 560 |
4/4
✓ Branch 0 taken 6286 times.
✓ Branch 1 taken 6046 times.
✓ Branch 2 taken 762 times.
✓ Branch 3 taken 4762 times.
|
12332 |
} while (multi && nukeleft); |
| 561 |
|
|
} |
| 562 |
|
5404 |
return input; |
| 563 |
|
|
} |
| 564 |
|
|
|
| 565 |
|
6 |
char* strqpchr(const char* str, char key) |
| 566 |
|
|
{ |
| 567 |
1/2
✓ Branch 0 taken 24 times.
✗ Branch 1 not taken.
|
24 |
while (*str) |
| 568 |
|
|
{ |
| 569 |
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); |
| 570 |
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 6 times.
|
12 |
else if (*str == key) return const_cast<char*>(str); |
| 571 |
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3 times.
|
3 |
else if (!*str) return nullptr; |
| 572 |
|
6 |
else str++; |
| 573 |
|
|
} |
| 574 |
|
✗ |
return nullptr; |
| 575 |
|
|
} |
| 576 |
|
|
|
| 577 |
|
|
|
| 578 |
|
162 |
char* strqpstr(const char* str, const char* key) |
| 579 |
|
|
{ |
| 580 |
|
162 |
size_t keylen = strlen(key); |
| 581 |
2/2
✓ Branch 0 taken 816 times.
✓ Branch 1 taken 6 times.
|
822 |
while (*str) |
| 582 |
|
|
{ |
| 583 |
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); |
| 584 |
2/2
✓ Branch 0 taken 156 times.
✓ Branch 1 taken 642 times.
|
798 |
else if (!strncmp(str, key, keylen)) return const_cast<char*>(str); |
| 585 |
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 321 times.
|
321 |
else if (!*str) return nullptr; |
| 586 |
|
642 |
else str++; |
| 587 |
|
|
} |
| 588 |
|
3 |
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 |
|
|
|