source: cpp/frams/util/sstringutils.cpp @ 1341

Last change on this file since 1341 was 1341, checked in by Maciej Komosinski, 45 hours ago

Cosmetic
  • Property svn:eol-style set to native
File size: 10.4 KB
Line 
1// This file is a part of Framsticks SDK.  http://www.framsticks.com/
2// Copyright (C) 1999-2025  Maciej Komosinski and Szymon Ulatowski.
3// See LICENSE.txt for details.
4
5#include <inttypes.h> //PRIu64
6#include "sstringutils.h"
7#include <common/virtfile/virtfile.h>
8#include <common/log.h>
9#include <common/nonstd.h>
10#include <common/Convert.h>
11#include <common/nonstd_span.h>
12
13int loadSString(const char* filename, SString& s, const char* framsgmodule, const char* error, bool remove_cr)
14{
15        VirtFILE *f;
16        int ret = 0;
17        if (f = Vfopen(filename, FOPEN_READ_BINARY))
18        {
19                loadSString(f, s, remove_cr);
20                ret = 1;
21                delete f;
22        }
23        else if (framsgmodule)
24                logPrintf(framsgmodule, "loadSString", LOG_WARN, error ? error : "Can't open file \"%s\"", filename);
25        return ret;
26}
27
28void loadSString(VirtFILE *f, SString& s, bool remove_cr)
29{
30        char buf[1024];
31        int len;
32        while (!f->Veof())
33        {
34                len = (int)f->Vread(buf, 1, sizeof(buf));
35                s.append(buf, len);
36        }
37        if (remove_cr)
38                removeCR(s);
39}
40
41//load single line, discarding any \r or \n found at the end, return false if nothing could be loaded (error or eof)
42bool loadSStringLine(VirtFILE* f, SString& s)
43{
44        char buf[100];
45        bool eolfound = false;
46        bool ret = false;
47        s = SString::empty();
48        while (!eolfound)
49        {
50                char *r = f->Vgets(buf, sizeof(buf));
51                if (r == NULL) break;
52                ret = true;
53                int d = (int)strlen(r);
54                if (d > 0)
55                {
56                        if (r[d - 1] == '\n') { d--; eolfound = true; }
57                        if (d > 0) if (r[d - 1] == '\r') d--;
58                        s += SString(r, d);
59                }
60        }
61        return ret;
62}
63
64//////////////////////////
65
66/** "x~xx~xxx" -> "x\~xx\~xxx"  */
67int quoteTilde(SString &target)
68{
69        const char* x = target.c_str();
70        SString tmp;
71        char *f;
72        while (1)
73        {
74                f = strchr((char*)x, '~');
75                if (f)
76                {
77                        tmp.append(x, f - x);
78                        tmp += "\\~";
79                        x = f + 1;
80                }
81                else
82                {
83                        if (tmp.length() == 0) return 0; // nothing was changed!
84                        tmp += x;
85                        target = tmp;
86                        return 1;
87                }
88        }
89}
90
91/** "x\~xx\~xxx" -> "x~xx~xxx"  */
92int unquoteTilde(SString &target)
93{
94        const char* x = target.c_str();
95        SString tmp;
96        char *f;
97        while (1)
98        {
99                f = strchr((char*)x, '\\');
100                if (f)
101                {
102                        tmp.append(x, f - x);
103                        if (f[1] == '~')
104                        {
105                                tmp += '~';
106                                x = f + 2;
107                        }
108                        else
109                        {
110                                tmp += "\\";
111                                x = f + 1;
112                        }
113                }
114                else
115                {
116                        if (tmp.length() == 0) return 0; // nothing was changed!
117                        tmp += x;
118                        target = tmp;
119                        return 1;
120                }
121        }
122}
123
124/////////////////
125
126bool strContainsOneOf(const char* str, const char* chars)
127{
128        while (*str)
129        {
130                if (strchr(chars, *str)) return 1;
131                str++;
132        }
133        return 0;
134}
135
136//////////////
137
138bool sstringQuote(SString& target)
139{
140        const char* x = target.c_str();
141        bool changed = 0;
142        SString tmp;
143        tmp.reserve(target.length());
144        while (*x)
145        {
146                switch (*x)
147                {
148                case '\n': tmp += "\\n"; changed = 1; break;
149                case '\r': tmp += "\\r"; changed = 1; break;
150                case '\t': tmp += "\\t"; changed = 1; break;
151                case '\"': tmp += "\\\""; changed = 1; break;
152                case '\\': tmp += "\\\\"; changed = 1; break;
153                default: tmp += *x;
154                }
155                x++;
156        }
157        if (changed) target = tmp;
158        return changed;
159}
160
161SString sstringDelimitAndShorten(const SString &in, int maxlen, bool show_length, const SString& before, const SString& after)
162{
163        SString out;
164        if (in.length() > maxlen)
165                out = in.substr(0, maxlen / 2) + "..." + in.substr(in.length() - maxlen + maxlen / 2);
166        else
167        {
168                out = in; show_length = false;
169        }
170        sstringQuote(out);
171        out = before + out + after;
172        if (show_length)
173                out += SString::sprintf(" (length %d)", in.length());
174        return out;
175}
176
177const char* skipQuoteString(const char* txt, const char* limit)
178{
179        while (*txt)
180        {
181                if (*txt == '\"') return txt;
182                if (*txt == '\\') txt++;
183                txt++;
184                if (txt == limit) break;
185        }
186        return txt;
187}
188
189int sstringUnquote(SString &target)
190{
191        const char* x = target.c_str();
192        SString tmp;
193        char *f;
194        while (1)
195        {
196                f = strchr((char*)x, '\\');
197                if (f)
198                {
199                        tmp.append(x, f - x);
200                        switch (f[1])
201                        {
202                        case 'n': tmp += '\n'; break;
203                        case 'r': tmp += '\r'; break;
204                        case 't': tmp += '\t'; break;
205                        case '\"': tmp += '\"'; break;
206                        default: tmp += f[1];
207                        }
208                        x = f + 2;
209                }
210                else
211                {
212                        if (tmp.length() == 0) return 0; // nothing was changed!
213                        tmp += x;
214                        target = tmp;
215                        return 1;
216                }
217        }
218}
219
220int strFindField(const SString& txt, const SString& name, int &end)
221{
222        const char* t = txt.c_str(), *n;
223        int pos = 0;
224        while (1)
225        {
226                n = strchr(t + pos, ',');
227                if ((!strncmp(t + pos, name.c_str(), name.length())) && (t[pos + name.length()] == '='))
228                {
229                        if (n) end = n - t; else end = txt.length();
230                        return pos;
231                }
232                if (n) pos = n - t + 1; else break;
233        }
234        return -1;
235}
236
237SString strGetField(const SString& txt, const SString& name)
238{
239        int p, e;
240        p = strFindField(txt, name, e);
241        if (p < 0) return SString();
242        p += name.length() + 1;
243        return SString(txt.substr(p, e - p));
244}
245
246void strSetField(SString& txt, const SString& name, const SString& value)
247{
248        int p, e;
249        p = strFindField(txt, name, e);
250        if (p < 0)
251        {
252                if (!value.length()) return;
253                char *t = txt.directAppend(1 + name.length() + value.length());
254                char *b = t;
255                if (txt.length()) *(t++) = ',';
256                strcpy(t, name.c_str()); t += name.length();
257                *(t++) = '=';
258                strcpy(t, value.c_str()); t += value.length();
259                txt.endAppend(t - b);
260        }
261        else
262        {
263                if (!value.length())
264                {
265                        if (p > 0) p--; else if (e < txt.length()) e++;
266                        char *t = txt.directWrite(0);
267                        memmove(t + p, t + e, txt.length() - e);
268                        txt.endWrite(txt.length() + value.length() - (e - p));
269                }
270                else
271                {
272                        p += name.length() + 1;
273                        char *t = txt.directWrite(txt.length() + value.length() - (e - p));
274                        memmove(t + p + value.length(), t + e, txt.length() - e);
275                        memmove(t + p, value.c_str(), value.length());
276                        txt.endWrite(txt.length() + value.length() - (e - p));
277                }
278        }
279}
280
281SString trim(const SString& s)
282{
283        const unsigned char*b = (const unsigned char*)s.c_str();
284        const unsigned char*e = b + s.length();
285        while ((b < e) && (*b <= ' ')) b++;
286        while ((b < e) && (e[-1] <= ' ')) e--;
287        if ((e - b) == s.length()) return s;
288        SString newstring;
289        char* t = newstring.directWrite(e - b);
290        memmove(t, b, e - b);
291        newstring.endWrite(e - b);
292        return newstring;
293}
294
295SString concatPath(const SString& in1, const SString& in2)
296{
297        SString out = in1;
298        if (out.length() > 0 && out[out.length() - 1] != PATH_SEPARATOR_CHAR)
299                out += PATH_SEPARATOR_CHAR;
300        out += in2;
301        return out;
302}
303
304bool removeCR(SString& s)
305{
306        const char* p = s.c_str();
307        const char* cr = strchr(p, '\r');
308        if (!cr) return false;
309        char* begin = s.directWrite();
310        char* src = begin + (cr - p), *dst = src;
311        while (*src)
312                if (*src == '\r')
313                        src++;
314                else
315                        *(dst++) = *(src++);
316        s.endWrite(dst - begin);
317        return true;
318}
319
320bool matchWildcard(const SString& word, const SString& pattern)
321{
322        if (pattern.length() == 0)
323                return word.length() == 0;
324        int aster = pattern.indexOf('*');
325        if (aster >= 0)
326        {
327                SString before = pattern.substr(0, aster);
328                SString after = pattern.substr(aster + 1);
329                if (!word.length()) return false;
330                if (before.length()) if (!word.startsWith(before.c_str())) return false;
331                if (after.length())
332                        if ((word.length() < after.length())
333                                || (strcmp(after.c_str(), word.c_str() + word.length() - after.length())))
334                                return false;
335                return true;
336        }
337        else
338                return word == pattern;
339}
340
341bool matchWildcardList(const SString& word, const SString& patterns)
342{
343        if (patterns.length() == 0)
344                return word.length() == 0;
345        int pos = 0;
346        SString pattern;
347        while (patterns.getNextToken(pos, pattern, ','))
348                if (matchWildcard(word, pattern))
349                        return true;
350        return false;
351}
352
353SString getUIDString(uint64_t uid, char prefix)
354{
355        return SString::sprintf("%c%" PRIu64, prefix, uid);
356}
357
358bool parseUIDString(const char* str, char prefix, uint64_t &uid, bool err)
359{
360        if ((str[0] == prefix) && (isdigit(str[1])))
361        {
362                char* end;
363                uid = strtoull(str + 1, &end, 10);
364                if (end == (str + 1 + strlen(str + 1)))
365                        return true;
366        }
367        if (err)
368                logPrintf("SString", "parseUIDString", LOG_ERROR, "Invalid uid: '%s'", str);
369        return false;
370}
371
372bool sstringURLEncode(SString& target)
373{
374        const char* x = target.c_str();
375        bool changed = 0;
376        SString tmp;
377        tmp.reserve(target.length());
378        static constexpr const char* ALLOWED_CHARS = "-_.~";
379        for (; *x; x++)
380        {
381                if (!(isalnum(*x) || strchr(ALLOWED_CHARS, *x)))
382                {
383                        tmp += "%";
384                        tmp += SString::sprintf("%02x", *x);
385                        changed = 1;
386                }
387                else
388                        tmp += *x;
389        }
390        if (changed) target = tmp;
391        return changed;
392}
393
394bool sstringURLDecode(SString &target)
395{
396        const char* x = target.c_str();
397        SString tmp;
398        char *f;
399        while (1)
400        {
401                f = strchr((char*)x, '%');
402                if (f)
403                {
404                        tmp.append(x, f - x);
405                        char hex[3] = { f[1],f[2],0 };
406                        char* after;
407                        unsigned long intvalue = strtoul(hex, &after, 16);
408                        tmp += (char)intvalue;
409                        x = f + 3;
410                }
411                else
412                {
413                        if (tmp.length() == 0) return false; // nothing was changed!
414                        tmp += x;
415                        target = tmp;
416                        return true;
417                }
418        }
419}
420
421static span<char> findEof(span<char> field, const char* pos) // 'eof' includes any number of leading '\'s and is only detected when there is nothing else in the line
422{
423        const char* eof = strstr(pos, "eof");
424        if (!eof)
425                return span<char>();
426
427        if (!(((eof + 3) == field.end()) || (eof[3] == '\n')))
428                return span<char>();
429
430        const char* begin = eof - 1;
431        for (; begin >= field.begin(); begin--)
432        {
433                if (*begin == '\n')
434                        break;
435                if (*begin != '\\')
436                        return span<char>();
437        }
438
439        return span<char>((char*)(begin + 1), (eof + 3) - (begin + 1));
440}
441
442bool sstringQuoteEOF(SString& target)
443{
444        span<char> field((char*)target.c_str(), target.size());
445        const char* pos = field.begin();
446
447        bool changed = false;
448
449        SString tmp;
450
451        while (true)
452        {
453                auto eof = findEof(field, pos);
454                if (eof.size())
455                {
456                        if (!changed)
457                        {
458                                tmp.reserve(target.length() + 10);
459                                changed = true;
460                        }
461                        tmp.append(pos, eof.begin() - pos);
462                        tmp += "\\";
463                        tmp.append(eof.begin(), (int)eof.size());
464                        pos = eof.end();
465                }
466                else
467                {
468                        if (!changed)
469                                return false;
470                        tmp.append(pos, field.end() - pos);
471                        break;
472                }
473        }
474
475        target = tmp;
476        return true;
477}
478
479bool sstringUnquoteEOF(SString& target)
480{
481        span<char> field((char*)target.c_str(), target.size());
482        const char* pos = field.begin();
483
484        bool changed = false;
485
486        SString tmp;
487
488        while (true)
489        {
490                auto eof = findEof(field, pos);
491                if (eof.size() > 3)
492                {
493                        if (!changed)
494                        {
495                                tmp.reserve(target.length());
496                                changed = true;
497                        }
498                        tmp.append(pos, eof.begin() - pos);
499                        tmp.append(eof.begin() + 1, (int)eof.size() - 1);
500                        pos = eof.end();
501                }
502                else
503                {
504                        if (eof.size() == 3) //size()==3 means bare 'eof', which cannot be unquoted (and means something went wrong somewhere else)
505                                logPrintf("String", "unquoteEof", LOG_WARN, "Unexpected bare \"eof\" line");
506                        if (!changed)
507                                return false;
508                        tmp.append(pos, field.end() - pos);
509                        break;
510                }
511        }
512
513        target = tmp;
514        return true;
515}
Note: See TracBrowser for help on using the repository browser.