?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
incrementaltp: respect physics overrides
[waspsaliva.git] / src / util / string.cpp
blob8381a29c5acce46f2184dfc0dee6f26f3e125ffa
1 /*
2 Minetest
3 Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
4
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU Lesser General Public License as published by
7 the Free Software Foundation; either version 2.1 of the License, or
8 (at your option) any later version.
9
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU Lesser General Public License for more details.
14
15 You should have received a copy of the GNU Lesser General Public License along
16 with this program; if not, write to the Free Software Foundation, Inc.,
17 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 */
19
20 #include "string.h"
21 #include "pointer.h"
22 #include "numeric.h"
23 #include "log.h"
24
25 #include "hex.h"
26 #include "porting.h"
27 #include "translation.h"
28
29 #include <algorithm>
30 #include <array>
31 #include <sstream>
32 #include <iomanip>
33 #include <map>
34
35 #ifndef _WIN32
36 #include <iconv.h>
37 #else
38 #define _WIN32_WINNT 0x0501
39 #include <windows.h>
40 #endif
41
42 #if defined(_ICONV_H_) && (defined(__FreeBSD__) || defined(__NetBSD__) || \
43 defined(__OpenBSD__) || defined(__DragonFly__))
44 #define BSD_ICONV_USED
45 #endif
46
47 static bool parseHexColorString(const std::string &value, video::SColor &color,
48 unsigned char default_alpha = 0xff);
49 static bool parseNamedColorString(const std::string &value, video::SColor &color);
50
51 #ifndef _WIN32
52
53 bool convert(const char *to, const char *from, char *outbuf,
54 size_t outbuf_size, char *inbuf, size_t inbuf_size)
55 {
56 iconv_t cd = iconv_open(to, from);
57
58 #ifdef BSD_ICONV_USED
59 const char *inbuf_ptr = inbuf;
60 #else
61 char *inbuf_ptr = inbuf;
62 #endif
63
64 char *outbuf_ptr = outbuf;
65
66 size_t *inbuf_left_ptr = &inbuf_size;
67 size_t *outbuf_left_ptr = &outbuf_size;
68
69 size_t old_size = inbuf_size;
70 while (inbuf_size > 0) {
71 iconv(cd, &inbuf_ptr, inbuf_left_ptr, &outbuf_ptr, outbuf_left_ptr);
72 if (inbuf_size == old_size) {
73 iconv_close(cd);
74 return false;
75 }
76 old_size = inbuf_size;
77 }
78
79 iconv_close(cd);
80 return true;
81 }
82
83 #ifdef __ANDROID__
84 // Android need manual caring to support the full character set possible with wchar_t
85 const char *DEFAULT_ENCODING = "UTF-32LE";
86 #else
87 const char *DEFAULT_ENCODING = "WCHAR_T";
88 #endif
89
90 std::wstring utf8_to_wide(const std::string &input)
91 {
92 size_t inbuf_size = input.length() + 1;
93 // maximum possible size, every character is sizeof(wchar_t) bytes
94 size_t outbuf_size = (input.length() + 1) * sizeof(wchar_t);
95
96 char *inbuf = new char[inbuf_size];
97 memcpy(inbuf, input.c_str(), inbuf_size);
98 char *outbuf = new char[outbuf_size];
99 memset(outbuf, 0, outbuf_size);
100
101 #ifdef __ANDROID__
102 // Android need manual caring to support the full character set possible with wchar_t
103 SANITY_CHECK(sizeof(wchar_t) == 4);
104 #endif
105
106 if (!convert(DEFAULT_ENCODING, "UTF-8", outbuf, outbuf_size, inbuf, inbuf_size)) {
107 infostream << "Couldn't convert UTF-8 string 0x" << hex_encode(input)
108 << " into wstring" << std::endl;
109 delete[] inbuf;
110 delete[] outbuf;
111 return L"<invalid UTF-8 string>";
112 }
113 std::wstring out((wchar_t *)outbuf);
114
115 delete[] inbuf;
116 delete[] outbuf;
117
118 return out;
119 }
120
121 std::string wide_to_utf8(const std::wstring &input)
122 {
123 size_t inbuf_size = (input.length() + 1) * sizeof(wchar_t);
124 // maximum possible size: utf-8 encodes codepoints using 1 up to 6 bytes
125 size_t outbuf_size = (input.length() + 1) * 6;
126
127 char *inbuf = new char[inbuf_size];
128 memcpy(inbuf, input.c_str(), inbuf_size);
129 char *outbuf = new char[outbuf_size];
130 memset(outbuf, 0, outbuf_size);
131
132 if (!convert("UTF-8", DEFAULT_ENCODING, outbuf, outbuf_size, inbuf, inbuf_size)) {
133 infostream << "Couldn't convert wstring 0x" << hex_encode(inbuf, inbuf_size)
134 << " into UTF-8 string" << std::endl;
135 delete[] inbuf;
136 delete[] outbuf;
137 return "<invalid wstring>";
138 }
139 std::string out(outbuf);
140
141 delete[] inbuf;
142 delete[] outbuf;
143
144 return out;
145 }
146
147 #else // _WIN32
148
149 std::wstring utf8_to_wide(const std::string &input)
150 {
151 size_t outbuf_size = input.size() + 1;
152 wchar_t *outbuf = new wchar_t[outbuf_size];
153 memset(outbuf, 0, outbuf_size * sizeof(wchar_t));
154 MultiByteToWideChar(CP_UTF8, 0, input.c_str(), input.size(),
155 outbuf, outbuf_size);
156 std::wstring out(outbuf);
157 delete[] outbuf;
158 return out;
159 }
160
161 std::string wide_to_utf8(const std::wstring &input)
162 {
163 size_t outbuf_size = (input.size() + 1) * 6;
164 char *outbuf = new char[outbuf_size];
165 memset(outbuf, 0, outbuf_size);
166 WideCharToMultiByte(CP_UTF8, 0, input.c_str(), input.size(),
167 outbuf, outbuf_size, NULL, NULL);
168 std::string out(outbuf);
169 delete[] outbuf;
170 return out;
171 }
172
173 #endif // _WIN32
174
175 // You must free the returned string!
176 // The returned string is allocated using new
177 wchar_t *utf8_to_wide_c(const char *str)
178 {
179 std::wstring ret = utf8_to_wide(std::string(str));
180 size_t len = ret.length();
181 wchar_t *ret_c = new wchar_t[len + 1];
182 memset(ret_c, 0, (len + 1) * sizeof(wchar_t));
183 memcpy(ret_c, ret.c_str(), len * sizeof(wchar_t));
184 return ret_c;
185 }
186
187 // You must free the returned string!
188 // The returned string is allocated using new
189 wchar_t *narrow_to_wide_c(const char *str)
190 {
191 wchar_t *nstr = nullptr;
192 #if defined(_WIN32)
193 int nResult = MultiByteToWideChar(CP_UTF8, 0, (LPCSTR) str, -1, 0, 0);
194 if (nResult == 0) {
195 errorstream<<"gettext: MultiByteToWideChar returned null"<<std::endl;
196 } else {
197 nstr = new wchar_t[nResult];
198 MultiByteToWideChar(CP_UTF8, 0, (LPCSTR) str, -1, (WCHAR *) nstr, nResult);
199 }
200 #else
201 size_t len = strlen(str);
202 nstr = new wchar_t[len + 1];
203
204 std::wstring intermediate = narrow_to_wide(str);
205 memset(nstr, 0, (len + 1) * sizeof(wchar_t));
206 memcpy(nstr, intermediate.c_str(), len * sizeof(wchar_t));
207 #endif
208
209 return nstr;
210 }
211
212 std::wstring narrow_to_wide(const std::string &mbs) {
213 #ifdef __ANDROID__
214 return utf8_to_wide(mbs);
215 #else
216 size_t wcl = mbs.size();
217 Buffer<wchar_t> wcs(wcl + 1);
218 size_t len = mbstowcs(*wcs, mbs.c_str(), wcl);
219 if (len == (size_t)(-1))
220 return L"<invalid multibyte string>";
221 wcs[len] = 0;
222 return *wcs;
223 #endif
224 }
225
226
227 std::string wide_to_narrow(const std::wstring &wcs)
228 {
229 #ifdef __ANDROID__
230 return wide_to_utf8(wcs);
231 #else
232 size_t mbl = wcs.size() * 4;
233 SharedBuffer<char> mbs(mbl+1);
234 size_t len = wcstombs(*mbs, wcs.c_str(), mbl);
235 if (len == (size_t)(-1))
236 return "Character conversion failed!";
237
238 mbs[len] = 0;
239 return *mbs;
240 #endif
241 }
242
243
244 std::string urlencode(const std::string &str)
245 {
246 // Encodes non-unreserved URI characters by a percent sign
247 // followed by two hex digits. See RFC 3986, section 2.3.
248 static const char url_hex_chars[] = "0123456789ABCDEF";
249 std::ostringstream oss(std::ios::binary);
250 for (unsigned char c : str) {
251 if (isalnum(c) || c == '-' || c == '.' || c == '_' || c == '~') {
252 oss << c;
253 } else {
254 oss << "%"
255 << url_hex_chars[(c & 0xf0) >> 4]
256 << url_hex_chars[c & 0x0f];
257 }
258 }
259 return oss.str();
260 }
261
262 std::string urldecode(const std::string &str)
263 {
264 // Inverse of urlencode
265 std::ostringstream oss(std::ios::binary);
266 for (u32 i = 0; i < str.size(); i++) {
267 unsigned char highvalue, lowvalue;
268 if (str[i] == '%' &&
269 hex_digit_decode(str[i+1], highvalue) &&
270 hex_digit_decode(str[i+2], lowvalue)) {
271 oss << (char) ((highvalue << 4) | lowvalue);
272 i += 2;
273 } else {
274 oss << str[i];
275 }
276 }
277 return oss.str();
278 }
279
280 u32 readFlagString(std::string str, const FlagDesc *flagdesc, u32 *flagmask)
281 {
282 u32 result = 0;
283 u32 mask = 0;
284 char *s = &str[0];
285 char *flagstr;
286 char *strpos = nullptr;
287
288 while ((flagstr = strtok_r(s, ",", &strpos))) {
289 s = nullptr;
290
291 while (*flagstr == ' ' || *flagstr == '\t')
292 flagstr++;
293
294 bool flagset = true;
295 if (!strncasecmp(flagstr, "no", 2)) {
296 flagset = false;
297 flagstr += 2;
298 }
299
300 for (int i = 0; flagdesc[i].name; i++) {
301 if (!strcasecmp(flagstr, flagdesc[i].name)) {
302 mask |= flagdesc[i].flag;
303 if (flagset)
304 result |= flagdesc[i].flag;
305 break;
306 }
307 }
308 }
309
310 if (flagmask)
311 *flagmask = mask;
312
313 return result;
314 }
315
316 std::string writeFlagString(u32 flags, const FlagDesc *flagdesc, u32 flagmask)
317 {
318 std::string result;
319
320 for (int i = 0; flagdesc[i].name; i++) {
321 if (flagmask & flagdesc[i].flag) {
322 if (!(flags & flagdesc[i].flag))
323 result += "no";
324
325 result += flagdesc[i].name;
326 result += ", ";
327 }
328 }
329
330 size_t len = result.length();
331 if (len >= 2)
332 result.erase(len - 2, 2);
333
334 return result;
335 }
336
337 size_t mystrlcpy(char *dst, const char *src, size_t size)
338 {
339 size_t srclen = strlen(src) + 1;
340 size_t copylen = MYMIN(srclen, size);
341
342 if (copylen > 0) {
343 memcpy(dst, src, copylen);
344 dst[copylen - 1] = '\0';
345 }
346
347 return srclen;
348 }
349
350 char *mystrtok_r(char *s, const char *sep, char **lasts)
351 {
352 char *t;
353
354 if (!s)
355 s = *lasts;
356
357 while (*s && strchr(sep, *s))
358 s++;
359
360 if (!*s)
361 return nullptr;
362
363 t = s;
364 while (*t) {
365 if (strchr(sep, *t)) {
366 *t++ = '\0';
367 break;
368 }
369 t++;
370 }
371
372 *lasts = t;
373 return s;
374 }
375
376 u64 read_seed(const char *str)
377 {
378 char *endptr;
379 u64 num;
380
381 if (str[0] == '0' && str[1] == 'x')
382 num = strtoull(str, &endptr, 16);
383 else
384 num = strtoull(str, &endptr, 10);
385
386 if (*endptr)
387 num = murmur_hash_64_ua(str, (int)strlen(str), 0x1337);
388
389 return num;
390 }
391
392 bool parseColorString(const std::string &value, video::SColor &color, bool quiet,
393 unsigned char default_alpha)
394 {
395 bool success;
396
397 if (value[0] == '#')
398 success = parseHexColorString(value, color, default_alpha);
399 else
400 success = parseNamedColorString(value, color);
401
402 if (!success && !quiet)
403 errorstream << "Invalid color: \"" << value << "\"" << std::endl;
404
405 return success;
406 }
407
408 static bool parseHexColorString(const std::string &value, video::SColor &color,
409 unsigned char default_alpha)
410 {
411 unsigned char components[] = { 0x00, 0x00, 0x00, default_alpha }; // R,G,B,A
412
413 if (value[0] != '#')
414 return false;
415
416 size_t len = value.size();
417 bool short_form;
418
419 if (len == 9 || len == 7) // #RRGGBBAA or #RRGGBB
420 short_form = false;
421 else if (len == 5 || len == 4) // #RGBA or #RGB
422 short_form = true;
423 else
424 return false;
425
426 bool success = true;
427
428 for (size_t pos = 1, cc = 0; pos < len; pos++, cc++) {
429 assert(cc < sizeof components / sizeof components[0]);
430 if (short_form) {
431 unsigned char d;
432 if (!hex_digit_decode(value[pos], d)) {
433 success = false;
434 break;
435 }
436 components[cc] = (d & 0xf) << 4 | (d & 0xf);
437 } else {
438 unsigned char d1, d2;
439 if (!hex_digit_decode(value[pos], d1) ||
440 !hex_digit_decode(value[pos+1], d2)) {
441 success = false;
442 break;
443 }
444 components[cc] = (d1 & 0xf) << 4 | (d2 & 0xf);
445 pos++; // skip the second digit -- it's already used
446 }
447 }
448
449 if (success) {
450 color.setRed(components[0]);
451 color.setGreen(components[1]);
452 color.setBlue(components[2]);
453 color.setAlpha(components[3]);
454 }
455
456 return success;
457 }
458
459 struct ColorContainer {
460 ColorContainer();
461 std::map<const std::string, u32> colors;
462 };
463
464 ColorContainer::ColorContainer()
465 {
466 colors["aliceblue"] = 0xf0f8ff;
467 colors["antiquewhite"] = 0xfaebd7;
468 colors["aqua"] = 0x00ffff;
469 colors["aquamarine"] = 0x7fffd4;
470 colors["azure"] = 0xf0ffff;
471 colors["beige"] = 0xf5f5dc;
472 colors["bisque"] = 0xffe4c4;
473 colors["black"] = 00000000;
474 colors["blanchedalmond"] = 0xffebcd;
475 colors["blue"] = 0x0000ff;
476 colors["blueviolet"] = 0x8a2be2;
477 colors["brown"] = 0xa52a2a;
478 colors["burlywood"] = 0xdeb887;
479 colors["cadetblue"] = 0x5f9ea0;
480 colors["chartreuse"] = 0x7fff00;
481 colors["chocolate"] = 0xd2691e;
482 colors["coral"] = 0xff7f50;
483 colors["cornflowerblue"] = 0x6495ed;
484 colors["cornsilk"] = 0xfff8dc;
485 colors["crimson"] = 0xdc143c;
486 colors["cyan"] = 0x00ffff;
487 colors["darkblue"] = 0x00008b;
488 colors["darkcyan"] = 0x008b8b;
489 colors["darkgoldenrod"] = 0xb8860b;
490 colors["darkgray"] = 0xa9a9a9;
491 colors["darkgreen"] = 0x006400;
492 colors["darkgrey"] = 0xa9a9a9;
493 colors["darkkhaki"] = 0xbdb76b;
494 colors["darkmagenta"] = 0x8b008b;
495 colors["darkolivegreen"] = 0x556b2f;
496 colors["darkorange"] = 0xff8c00;
497 colors["darkorchid"] = 0x9932cc;
498 colors["darkred"] = 0x8b0000;
499 colors["darksalmon"] = 0xe9967a;
500 colors["darkseagreen"] = 0x8fbc8f;
501 colors["darkslateblue"] = 0x483d8b;
502 colors["darkslategray"] = 0x2f4f4f;
503 colors["darkslategrey"] = 0x2f4f4f;
504 colors["darkturquoise"] = 0x00ced1;
505 colors["darkviolet"] = 0x9400d3;
506 colors["deeppink"] = 0xff1493;
507 colors["deepskyblue"] = 0x00bfff;
508 colors["dimgray"] = 0x696969;
509 colors["dimgrey"] = 0x696969;
510 colors["dodgerblue"] = 0x1e90ff;
511 colors["firebrick"] = 0xb22222;
512 colors["floralwhite"] = 0xfffaf0;
513 colors["forestgreen"] = 0x228b22;
514 colors["fuchsia"] = 0xff00ff;
515 colors["gainsboro"] = 0xdcdcdc;
516 colors["ghostwhite"] = 0xf8f8ff;
517 colors["gold"] = 0xffd700;
518 colors["goldenrod"] = 0xdaa520;
519 colors["gray"] = 0x808080;
520 colors["green"] = 0x008000;
521 colors["greenyellow"] = 0xadff2f;
522 colors["grey"] = 0x808080;
523 colors["honeydew"] = 0xf0fff0;
524 colors["hotpink"] = 0xff69b4;
525 colors["indianred"] = 0xcd5c5c;
526 colors["indigo"] = 0x4b0082;
527 colors["ivory"] = 0xfffff0;
528 colors["khaki"] = 0xf0e68c;
529 colors["lavender"] = 0xe6e6fa;
530 colors["lavenderblush"] = 0xfff0f5;
531 colors["lawngreen"] = 0x7cfc00;
532 colors["lemonchiffon"] = 0xfffacd;
533 colors["lightblue"] = 0xadd8e6;
534 colors["lightcoral"] = 0xf08080;
535 colors["lightcyan"] = 0xe0ffff;
536 colors["lightgoldenrodyellow"] = 0xfafad2;
537 colors["lightgray"] = 0xd3d3d3;
538 colors["lightgreen"] = 0x90ee90;
539 colors["lightgrey"] = 0xd3d3d3;
540 colors["lightpink"] = 0xffb6c1;
541 colors["lightsalmon"] = 0xffa07a;
542 colors["lightseagreen"] = 0x20b2aa;
543 colors["lightskyblue"] = 0x87cefa;
544 colors["lightslategray"] = 0x778899;
545 colors["lightslategrey"] = 0x778899;
546 colors["lightsteelblue"] = 0xb0c4de;
547 colors["lightyellow"] = 0xffffe0;
548 colors["lime"] = 0x00ff00;
549 colors["limegreen"] = 0x32cd32;
550 colors["linen"] = 0xfaf0e6;
551 colors["magenta"] = 0xff00ff;
552 colors["maroon"] = 0x800000;
553 colors["mediumaquamarine"] = 0x66cdaa;
554 colors["mediumblue"] = 0x0000cd;
555 colors["mediumorchid"] = 0xba55d3;
556 colors["mediumpurple"] = 0x9370db;
557 colors["mediumseagreen"] = 0x3cb371;
558 colors["mediumslateblue"] = 0x7b68ee;
559 colors["mediumspringgreen"] = 0x00fa9a;
560 colors["mediumturquoise"] = 0x48d1cc;
561 colors["mediumvioletred"] = 0xc71585;
562 colors["midnightblue"] = 0x191970;
563 colors["mintcream"] = 0xf5fffa;
564 colors["mistyrose"] = 0xffe4e1;
565 colors["moccasin"] = 0xffe4b5;
566 colors["navajowhite"] = 0xffdead;
567 colors["navy"] = 0x000080;
568 colors["oldlace"] = 0xfdf5e6;
569 colors["olive"] = 0x808000;
570 colors["olivedrab"] = 0x6b8e23;
571 colors["orange"] = 0xffa500;
572 colors["orangered"] = 0xff4500;
573 colors["orchid"] = 0xda70d6;
574 colors["palegoldenrod"] = 0xeee8aa;
575 colors["palegreen"] = 0x98fb98;
576 colors["paleturquoise"] = 0xafeeee;
577 colors["palevioletred"] = 0xdb7093;
578 colors["papayawhip"] = 0xffefd5;
579 colors["peachpuff"] = 0xffdab9;
580 colors["peru"] = 0xcd853f;
581 colors["pink"] = 0xffc0cb;
582 colors["plum"] = 0xdda0dd;
583 colors["powderblue"] = 0xb0e0e6;
584 colors["purple"] = 0x800080;
585 colors["red"] = 0xff0000;
586 colors["rosybrown"] = 0xbc8f8f;
587 colors["royalblue"] = 0x4169e1;
588 colors["saddlebrown"] = 0x8b4513;
589 colors["salmon"] = 0xfa8072;
590 colors["sandybrown"] = 0xf4a460;
591 colors["seagreen"] = 0x2e8b57;
592 colors["seashell"] = 0xfff5ee;
593 colors["sienna"] = 0xa0522d;
594 colors["silver"] = 0xc0c0c0;
595 colors["skyblue"] = 0x87ceeb;
596 colors["slateblue"] = 0x6a5acd;
597 colors["slategray"] = 0x708090;
598 colors["slategrey"] = 0x708090;
599 colors["snow"] = 0xfffafa;
600 colors["springgreen"] = 0x00ff7f;
601 colors["steelblue"] = 0x4682b4;
602 colors["tan"] = 0xd2b48c;
603 colors["teal"] = 0x008080;
604 colors["thistle"] = 0xd8bfd8;
605 colors["tomato"] = 0xff6347;
606 colors["turquoise"] = 0x40e0d0;
607 colors["violet"] = 0xee82ee;
608 colors["wheat"] = 0xf5deb3;
609 colors["white"] = 0xffffff;
610 colors["whitesmoke"] = 0xf5f5f5;
611 colors["yellow"] = 0xffff00;
612 colors["yellowgreen"] = 0x9acd32;
613
614 }
615
616 static const ColorContainer named_colors;
617
618 static bool parseNamedColorString(const std::string &value, video::SColor &color)
619 {
620 std::string color_name;
621 std::string alpha_string;
622
623 /* If the string has a # in it, assume this is the start of a specified
624 * alpha value (if it isn't the string is invalid and the error will be
625 * caught later on, either because the color name won't be found or the
626 * alpha value will fail conversion)
627 */
628 size_t alpha_pos = value.find('#');
629 if (alpha_pos != std::string::npos) {
630 color_name = value.substr(0, alpha_pos);
631 alpha_string = value.substr(alpha_pos + 1);
632 } else {
633 color_name = value;
634 }
635
636 color_name = lowercase(value);
637
638 std::map<const std::string, unsigned>::const_iterator it;
639 it = named_colors.colors.find(color_name);
640 if (it == named_colors.colors.end())
641 return false;
642
643 u32 color_temp = it->second;
644
645 /* An empty string for alpha is ok (none of the color table entries
646 * have an alpha value either). Color strings without an alpha specified
647 * are interpreted as fully opaque
648 *
649 * For named colors the supplied alpha string (representing a hex value)
650 * must be exactly two digits. For example: colorname#08
651 */
652 if (!alpha_string.empty()) {
653 if (alpha_string.length() != 2)
654 return false;
655
656 unsigned char d1, d2;
657 if (!hex_digit_decode(alpha_string.at(0), d1)
658 || !hex_digit_decode(alpha_string.at(1), d2))
659 return false;
660 color_temp |= ((d1 & 0xf) << 4 | (d2 & 0xf)) << 24;
661 } else {
662 color_temp |= 0xff << 24; // Fully opaque
663 }
664
665 color = video::SColor(color_temp);
666
667 return true;
668 }
669
670 void str_replace(std::string &str, char from, char to)
671 {
672 std::replace(str.begin(), str.end(), from, to);
673 }
674
675 /* Translated strings have the following format:
676 * \x1bT marks the beginning of a translated string
677 * \x1bE marks its end
678 *
679 * \x1bF marks the beginning of an argument, and \x1bE its end.
680 *
681 * Arguments are *not* translated, as they may contain escape codes.
682 * Thus, if you want a translated argument, it should be inside \x1bT/\x1bE tags as well.
683 *
684 * This representation is chosen so that clients ignoring escape codes will
685 * see untranslated strings.
686 *
687 * For instance, suppose we have a string such as "@1 Wool" with the argument "White"
688 * The string will be sent as "\x1bT\x1bF\x1bTWhite\x1bE\x1bE Wool\x1bE"
689 * To translate this string, we extract what is inside \x1bT/\x1bE tags.
690 * When we notice the \x1bF tag, we recursively extract what is there up to the \x1bE end tag,
691 * translating it as well.
692 * We get the argument "White", translated, and create a template string with "@1" instead of it.
693 * We finally get the template "@1 Wool" that was used in the beginning, which we translate
694 * before filling it again.
695 */
696
697 void translate_all(const std::wstring &s, size_t &i,
698 Translations *translations, std::wstring &res);
699
700 void translate_string(const std::wstring &s, Translations *translations,
701 const std::wstring &textdomain, size_t &i, std::wstring &res)
702 {
703 std::wostringstream output;
704 std::vector<std::wstring> args;
705 int arg_number = 1;
706 while (i < s.length()) {
707 // Not an escape sequence: just add the character.
708 if (s[i] != '\x1b') {
709 output.put(s[i]);
710 // The character is a literal '@'; add it twice
711 // so that it is not mistaken for an argument.
712 if (s[i] == L'@')
713 output.put(L'@');
714 ++i;
715 continue;
716 }
717
718 // We have an escape sequence: locate it and its data
719 // It is either a single character, or it begins with '('
720 // and extends up to the following ')', with '\' as an escape character.
721 ++i;
722 size_t start_index = i;
723 size_t length;
724 if (i == s.length()) {
725 length = 0;
726 } else if (s[i] == L'(') {
727 ++i;
728 ++start_index;
729 while (i < s.length() && s[i] != L')') {
730 if (s[i] == L'\\')
731 ++i;
732 ++i;
733 }
734 length = i - start_index;
735 ++i;
736 if (i > s.length())
737 i = s.length();
738 } else {
739 ++i;
740 length = 1;
741 }
742 std::wstring escape_sequence(s, start_index, length);
743
744 // The escape sequence is now reconstructed.
745 std::vector<std::wstring> parts = split(escape_sequence, L'@');
746 if (parts[0] == L"E") {
747 // "End of translation" escape sequence. We are done locating the string to translate.
748 break;
749 } else if (parts[0] == L"F") {
750 // "Start of argument" escape sequence.
751 // Recursively translate the argument, and add it to the argument list.
752 // Add an "@n" instead of the argument to the template to translate.
753 if (arg_number >= 10) {
754 errorstream << "Ignoring too many arguments to translation" << std::endl;
755 std::wstring arg;
756 translate_all(s, i, translations, arg);
757 args.push_back(arg);
758 continue;
759 }
760 output.put(L'@');
761 output << arg_number;
762 ++arg_number;
763 std::wstring arg;
764 translate_all(s, i, translations, arg);
765 args.push_back(arg);
766 } else {
767 // This is an escape sequence *inside* the template string to translate itself.
768 // This should not happen, show an error message.
769 errorstream << "Ignoring escape sequence '" << wide_to_narrow(escape_sequence) << "' in translation" << std::endl;
770 }
771 }
772
773 std::wstring toutput;
774 // Translate the template.
775 if (translations != nullptr)
776 toutput = translations->getTranslation(
777 textdomain, output.str());
778 else
779 toutput = output.str();
780
781 // Put back the arguments in the translated template.
782 std::wostringstream result;
783 size_t j = 0;
784 while (j < toutput.length()) {
785 // Normal character, add it to output and continue.
786 if (toutput[j] != L'@' || j == toutput.length() - 1) {
787 result.put(toutput[j]);
788 ++j;
789 continue;
790 }
791
792 ++j;
793 // Literal escape for '@'.
794 if (toutput[j] == L'@') {
795 result.put(L'@');
796 ++j;
797 continue;
798 }
799
800 // Here we have an argument; get its index and add the translated argument to the output.
801 int arg_index = toutput[j] - L'1';
802 ++j;
803 if (0 <= arg_index && (size_t)arg_index < args.size()) {
804 result << args[arg_index];
805 } else {
806 // This is not allowed: show an error message
807 errorstream << "Ignoring out-of-bounds argument escape sequence in translation" << std::endl;
808 }
809 }
810 res = result.str();
811 }
812
813 void translate_all(const std::wstring &s, size_t &i,
814 Translations *translations, std::wstring &res)
815 {
816 std::wostringstream output;
817 while (i < s.length()) {
818 // Not an escape sequence: just add the character.
819 if (s[i] != '\x1b') {
820 output.put(s[i]);
821 ++i;
822 continue;
823 }
824
825 // We have an escape sequence: locate it and its data
826 // It is either a single character, or it begins with '('
827 // and extends up to the following ')', with '\' as an escape character.
828 size_t escape_start = i;
829 ++i;
830 size_t start_index = i;
831 size_t length;
832 if (i == s.length()) {
833 length = 0;
834 } else if (s[i] == L'(') {
835 ++i;
836 ++start_index;
837 while (i < s.length() && s[i] != L')') {
838 if (s[i] == L'\\') {
839 ++i;
840 }
841 ++i;
842 }
843 length = i - start_index;
844 ++i;
845 if (i > s.length())
846 i = s.length();
847 } else {
848 ++i;
849 length = 1;
850 }
851 std::wstring escape_sequence(s, start_index, length);
852
853 // The escape sequence is now reconstructed.
854 std::vector<std::wstring> parts = split(escape_sequence, L'@');
855 if (parts[0] == L"E") {
856 // "End of argument" escape sequence. Exit.
857 break;
858 } else if (parts[0] == L"T") {
859 // Beginning of translated string.
860 std::wstring textdomain;
861 if (parts.size() > 1)
862 textdomain = parts[1];
863 std::wstring translated;
864 translate_string(s, translations, textdomain, i, translated);
865 output << translated;
866 } else {
867 // Another escape sequence, such as colors. Preserve it.
868 output << std::wstring(s, escape_start, i - escape_start);
869 }
870 }
871
872 res = output.str();
873 }
874
875 // Translate string server side
876 std::wstring translate_string(const std::wstring &s, Translations *translations)
877 {
878 size_t i = 0;
879 std::wstring res;
880 translate_all(s, i, translations, res);
881 return res;
882 }
883
884 // Translate string client side
885 std::wstring translate_string(const std::wstring &s)
886 {
887 #ifdef SERVER
888 return translate_string(s, nullptr);
889 #else
890 return translate_string(s, g_client_translations);
891 #endif
892 }
893
894 static const std::array<std::wstring, 22> disallowed_dir_names = {
895 // Problematic filenames from here:
896 // https://docs.microsoft.com/en-us/windows/win32/fileio/naming-a-file#file-and-directory-names
897 L"CON",
898 L"PRN",
899 L"AUX",
900 L"NUL",
901 L"COM1",
902 L"COM2",
903 L"COM3",
904 L"COM4",
905 L"COM5",
906 L"COM6",
907 L"COM7",
908 L"COM8",
909 L"COM9",
910 L"LPT1",
911 L"LPT2",
912 L"LPT3",
913 L"LPT4",
914 L"LPT5",
915 L"LPT6",
916 L"LPT7",
917 L"LPT8",
918 L"LPT9",
919 };
920
921 /**
922 * List of characters that are blacklisted from created directories
923 */
924 static const std::wstring disallowed_path_chars = L"<>:\"/\\|?*.";
925
926 /**
927 * Sanitize the name of a new directory. This consists of two stages:
928 * 1. Check for 'reserved filenames' that can't be used on some filesystems
929 * and add a prefix to them
930 * 2. Remove 'unsafe' characters from the name by replacing them with '_'
931 */
932 std::string sanitizeDirName(const std::string &str, const std::string &optional_prefix)
933 {
934 std::wstring safe_name = utf8_to_wide(str);
935
936 for (std::wstring disallowed_name : disallowed_dir_names) {
937 if (str_equal(safe_name, disallowed_name, true)) {
938 safe_name = utf8_to_wide(optional_prefix) + safe_name;
939 break;
940 }
941 }
942
943 for (unsigned long i = 0; i < safe_name.length(); i++) {
944 bool is_valid = true;
945
946 // Unlikely, but control characters should always be blacklisted
947 if (safe_name[i] < 32) {
948 is_valid = false;
949 } else if (safe_name[i] < 128) {
950 is_valid = disallowed_path_chars.find_first_of(safe_name[i])
951 == std::wstring::npos;
952 }
953
954 if (!is_valid)
955 safe_name[i] = '_';
956 }
957
958 return wide_to_utf8(safe_name);
959 }
minetest hacked client (dragonfire fork)