Commit Graph
115 Commits
Author SHA1 Message Date
LibretroAdmin 22ba917922 libretro-common: word_wrap_offset(), with a test
menu_wrap_offset(), which finds where a byte of a string landed in its
word_wrap() or word_wrap_wideglyph() wrap, moves to stdstring.c beside
them as word_wrap_offset(), and MaterialUI and XMB call it from there.

It gave a glyph the wide-glyph wrap had put a line end before the
offset of that line end, so the input dialog's caret sat at the end
of the line above; it now gives the glyph's own.

word_wrap_offset_test wraps plain, wide-glyph and mixed text at every
width from 1 to 39, with line ends left or made NUL as the drivers
make them, and checks that every character lands on itself or on the
line end its space or newline became, in order, that the end lands
on the end, that no wrap more than doubles its text, and that the
caret before a word moved to the next line is on that line. It found
the wrong offset and the wide-glyph wrap's runaway at narrow widths.
2026-11-16 11:49:11 +01:00
LibretroAdmin 6f41f7b119 libretro-common: word_wrap_wideglyph - no runaway at a narrow width
At a line width narrower than a wide glyph, the wrap put a line end
before a glyph that already began its line, then found the line still
too long and put another there, until the buffer was full: 13 bytes of
Japanese came back as 1021, nearly all line ends. And after breaking
before a wide glyph it kept the line's last space, which now lay on
the line above, and could break there again, rewinding to text it had
already laid out, with the same result.

A glyph that begins its line is no longer broken before - wider than
the line, it keeps a line of its own - and a break before a wide glyph
forgets the space before it.
2026-11-16 11:49:07 +01:00
Codex a810576b97 string: carry wide wrapping widths across space breaks
Keep the measured word tail after a space break instead of copying and decoding it again. Preserve the rewind paths for stale spaces and short remaining input. Add a scan-count regression for accented word tails.
2026-10-12 00:30:45 +02:00
Codex ed4af44226 string: skip UTF-8 decoding for ASCII wrapping
Advance directly over ASCII bytes in both wrapping paths. Keep multibyte decoding unchanged and verify that ASCII wrapping produces the expected text without calling utf8skip.
2026-10-12 00:25:31 +02:00
Codex fe04a9a7bc string: avoid replaying wide glyphs at line breaks
Emit a break before the current wide glyph and carry its measured width forward when the glyph fits on the next line. Keep the existing fallback for earlier break positions and constrained buffers. Add a regression check that these breaks scan each glyph at most once.
2026-10-12 00:22:45 +02:00
Codex 0a6d081ea2 string: avoid rescanning wrapped word tails
Keep the glyph count after the chosen space instead of rewinding and decoding that span again. Retain the existing embedded-newline fallback and early-return decisions so wrapping output and line limits stay unchanged.

Count glyph scans in the regression harness to verify ordinary word-boundary wrapping visits each glyph at most once.
2026-10-12 00:15:18 +02:00
Codex cae9ec0154 string: wrap text with one input copy
Copy the input once and only replace the spaces chosen as line breaks. Advance over UTF-8 spans without writing them again when the wrapping loop rewinds. Preserve wrapping decisions, line limits, return lengths and short-buffer rejection.

Add regression cases for word boundaries, multibyte text, existing newlines, leading spaces and bounded destinations.
2026-10-12 00:07:20 +02:00
LibretroAdmin 247ff38a18 libretro-common: move the percent decoder into stdstring
string_percent_decode() is net_http_urldecode() without the networking
dependency, so builds without HAVE_NETWORKING can decode file:// URIs.
net_http_urldecode() and net_http_urldecode_inplace() now call it.
2026-10-02 11:36:38 +02:00
LibretroAdmin baa8536a17 libretro-common: ask for the POSIX profile the sources need
strdup(), strcasecmp(), fstatat(), O_CLOEXEC, M_PI, sigaltstack() and
syscall() all sit behind __USE_XOPEN2K8 or __USE_MISC, so a consumer
compiling the library under a stricter feature profile than the default
sees none of them. The Debian/Launchpad core packaging passes
-D_XOPEN_SOURCE=600, where ten of these translation units reach an
implicitly declared function; at -D_POSIX_C_SOURCE=200112L strdup joins
them, and an implicit strdup returns int, so the pointer is truncated on
LP64 rather than merely warned about.

Add retro_posix_source.h, which asks for that profile, and include it
first in the files that need it. The guards only raise the profile and
ask for what a build passing no feature macros already gets, so no path
the library selects changes: every touched object is byte-identical
under the default profile.

nbio_linux.c defined _GNU_SOURCE after its first include, where it had
no effect; retro_posix_source.h replaces it.

Verified: all 221 standalone-compilable libretro-common units clean
under no macros, _XOPEN_SOURCE 600 and 700, _POSIX_C_SOURCE 200112L and
200809L, and _GNU_SOURCE, with implicit declarations and int-conversion
as errors; the fifteen samples suites that link these units build and
pass; compile-matrix.sh gives results identical to before the change.
Building with -DRETRO_POSIX_SOURCE_CHECK_ORDER turns a late include into
an error, and was itself checked both ways.
2026-09-21 18:45:55 +02:00
LibretroAdmin bd79aee4a7 menu: Fix EXC_BREAKPOINT when typing in OSK on macOS (in-place word_wrap)
ozone_draw_osk and the OSK caret rendering in xmb/materialui all
called word_wrap() with the same buffer as source and destination:

   (ozone->word_wrap)(cursor_message, sizeof(cursor_message),
         cursor_message, strlen(cursor_message), ...);

word_wrap()/word_wrap_wideglyph() copy via strlcpy(), whose buffers
must not overlap. On macOS, compat/strl.h force-defines HAVE_STRL, so
the system strlcpy is used; with _FORTIFY_SOURCE this resolves to
__strlcpy_chk, which aborts on any overlap (including exact aliasing)
via __chk_fail_overlap. As a result, typing a single character into
any OSK field (e.g. the IP Address setting under SMB Network
Settings) hits word_wrap's short-string early return
`strlcpy(s, src, len)` with s == src and raises EXC_BREAKPOINT.
Crash frame: len=2048, src_len=1, line_width=84, s == src == "1";
video_thread_loop -> ozone_draw_osk -> word_wrap -> __strlcpy_chk ->
__chk_fail_overlap. Linux/Windows never crashed only because the
strlcpy_retro__ fallback tolerates exact aliasing by accident.

In addition, in-place use of word_wrap_wideglyph() silently corrupts
CJK OSK text on all platforms: the lastwideglyph wrap branch
overwrites a source byte with '\n' before rewinding src onto it.
In-place wrapping of the kana string
E3 81 82 .. E3 81 93 (10 glyphs, line_width 4, wideglyph_width 200)
produces glyph 1 + 24 bare newlines + glyph 10 instead of one glyph
per line.

Fix: stage the OSK text in a separate cursor_src buffer at all three
call sites and wrap into the destination, matching the tmpstr pattern
already used for ozone's sidebar metadata. Document the
non-overlapping-buffers requirement for word_wrap()/
word_wrap_wideglyph() in stdstring.{c,h}. All other in-tree callers
(rgui, gfx_widgets, message boxes, sublabels) already use distinct
buffers.

Sanitizer sweep (ASan+UBSan+LSan, gcc, system strlcpy via
-DHAVE_STRL on glibc 2.39):
- fixed caller pattern yields "1" for the crashing input, clean
- separate-buffer output verified byte-exact against the previous
  in-place output for ASCII inputs across line widths 5/10/30/84
  (no rendering change for existing users)
- libretro-common word_wrap_wideglyph overflow regression tests pass
- ozone.c, xmb.c, materialui.c, stdstring.c compile clean
TSan: not applicable (single-threaded string path, no concurrency
change).
2026-08-10 16:59:40 +02:00
U-DESKTOP-SPFP6AQ\twistedtechre 0e648390c9 libretro-common: clamp word_wrap_wideglyph return to bytes-written + CI
word_wrap_wideglyph violated its implicit contract that the returned
length always fits inside the destination buffer.  Three return paths
forwarded strlcpy()'s return value, which is strlen(src) per spec --
not bytes-actually-written -- so on truncation the function returned
a value larger than the destination it had written into.

The sister function word_wrap() has a `len < src_len + 1` guard up
front that bails to 0 when the buffer is too small, sidestepping
this entirely.  word_wrap_wideglyph has no such guard and tries to
fit what it can, which is correct behaviour, but the inflated return
breaks every caller that uses it as a length argument.

Concrete impact: three menu drivers (xmb, ozone, materialui) feed
this return value as the `n` argument to memchr() over the wrapped
destination buffer when laying out messageboxes
(xmb_render_messagebox_internal at xmb.c line ~1183;
ozone_draw_messagebox at ozone.c line ~7362;
materialui_render_messagebox at materialui.c line ~2825).  Pre-patch,
an inflated `n` walks memchr past the destination into adjacent stack
memory (the lines[] / line_lengths[] arrays the messagebox helpers
keep right next to the wrapped buffer).  A '\n' byte found there
yields a wild pointer used in pointer arithmetic and as a length
argument to font_driver_get_message_width(), causing stack info
disclosure or a crash.

The wideglyph path is selected by msg_hash_get_wideglyph_str(), so
the bug is reachable in CJK locales (Japanese, Korean, Chinese) via
any messagebox payload exceeding MENU_LABEL_MAX_LENGTH (256 bytes
default) -- error notifications, file paths, network handshake
text, search results.

Two issues fixed in stdstring.c:

* Return value: every truncating return path
  (`return strlcpy(...)` and `return (s - s_start) + strlcpy(...)`)
  now clamps strlcpy's return to the actual bytes written:

      copied = strlcpy(s, src, n);
      if (copied >= n) copied = (n > 0) ? n - 1 : 0;
      return [(s - s_start) +] copied;

  This avoids introducing a strnlen() dependency (not used anywhere
  else in libretro-common, portability concerns on old MSVC).

* `len` semantic drift: the loop body decremented `len` by char_len
  on every byte written, while the early-return paths computed
  `remaining = len - (s - s_start)`.  Both expressions track "bytes
  used", so the formula effectively double-subtracted, yielding a
  too-small `remaining` and forcing the strlcpys to truncate harder
  than necessary.  The lastspace/lastwideglyph rewinds at lines ~411
  and ~429 also moved `s` backward without a matching `len` adjustment,
  desyncing the two over time.  Drop the `len -= char_len`, compute
  `remaining = len - (s - s_start)` once at the top of each loop
  iteration (and reuse it for the buffer-overflow guard previously
  spelled `if (char_len >= len)`).  `len` now stays constant across
  the function body, matching word_wrap()'s convention.

Regression test: libretro-common/samples/string/word_wrap_overflow
_test/.  Five cases covering both truncating and non-truncating
inputs across the line-358 early-return path and the main-loop
late-return paths.  The discriminator is two-fold: the test asserts
return-value-vs-bytes-written directly, AND mimics the menu drivers'
call shape by feeding the returned value to memchr() over the
destination, so an ASan build catches pre-patch failures via
heap-buffer-overflow on the memchr.  Verified by running against
both pre-patch and post-patch stdstring.c:

    pre-patch:  short_input_tiny_dest fails
                (returned=47, dst_size=16) -> exit 1
    post-patch: all five cases pass -> exit 0

CI: word_wrap_overflow_test added to RUN_TARGETS in
.github/workflows/Linux-libretro-common-samples.yml.  Builds under
SANITIZER=address,undefined like the other overflow regression
tests in the same workflow (rpng_chunk_overflow_test,
vfs_read_overflow_test, cdrom_cuesheet_overflow_test,
chd_meta_overflow_test, cdfs_dir_record_test, rzip_chunk_size_test).

Note on libretro-common/test/string/test_stdstring.c (the
libcheck-based suite): I considered adding a unit-test entry there
too, but the file is already broken at HEAD on master --
test_string_replacesubstr calls string_replace_substring with the
old 3-arg signature, but the API was extended to 5 args some time
ago; the test fails to compile.  Wiring up Makefile.test in CI
would have caught that regression but is out of scope here.
The samples-based regression test is the working surface and
matches the established pattern for every other overflow test
in the tree.
2026-04-28 22:05:12 +02:00
U-DESKTOP-SPFP6AQ\twistedtechre c268f73d67 libretro-common/string: drop redundant NUL write in string_tokenize
Reported by gcc 15.2.0 (msys2 / MinGW) building libretro-net-retropad
under -Wstringop-overflow:

   stdstring.c: In function 'string_tokenize':
   stdstring.c:500:16: warning: writing 1 byte into a region of
   size 0 [-Wstringop-overflow=]
     500 |    token[_len] = '\0';
         |    ~~~~~~~~~~~~^~~~~~

The flagged write is redundant.  string_tokenize allocates
malloc((_len + 1) * sizeof(char)) and then calls
strlcpy(token, str_ptr, _len + 1).  Looking at the strlcpy
contract in libretro-common/compat/compat_strl.c:31-41:

   size_t __len = _len < len - 1 ? _len : len - 1;
   memcpy(s, in, __len);
   s[__len] = '\0';

strlcpy already NUL-terminates within the `_len + 1` byte limit.
Because _len was computed at lines 489-492 as either
(delim_ptr - str_ptr) -- strictly <= strlen(str_ptr) -- or
strlen(str_ptr) directly, _len <= strlen(str_ptr) is always
true, so strlcpy's __len resolves to _len and the terminator
lands at token[_len].  The token[_len] = '\0' line just rewrites
the byte strlcpy already wrote.

gcc 15's tightened -Wstringop-overflow analyser cannot constrain
the relationship between _len and the malloc'd size (the size
expression `(_len + 1) * sizeof(char)` involves a multiply that
the analyser doesn't fold through to the bounds check on
token[_len]), so it warns under the assumption that _len could
exceed the malloc'd size by one.  Removing the redundant write
silences the warning without changing semantics.

Not a strlcpy_append situation: that helper (78c52ab) is for
chained appends of the form

    _len += strlcpy(s + _len, src, len - _len);

This is a single copy into a freshly-malloc'd buffer -- the
right fix is to delete the redundant trailing write, not to
swap idioms.

* libretro-common/string/stdstring.c

  Drop the redundant token[_len] = '\0' that follows the strlcpy
  in string_tokenize, with an inline comment explaining the
  strlcpy contract that makes the line dead and the
  -Wstringop-overflow interaction that made it actively harmful.

Verified locally:
  - The five string_tokenize behaviours that callers rely on
    (basic comma split, empty token at start, multi-char
    delimiter, no-delimiter pass-through, empty input) all pass
    under -fsanitize=address with the redundant write removed.
  - Cannot reproduce the gcc 15 warning on local gcc 13.3
    (warning is gcc-15-specific), but verified the local build
    stays clean under -Wstringop-overflow=4 and -Werror after
    the change.
2026-04-28 19:02:17 +02:00
U-DESKTOP-SPFP6AQ\twistedtechre 78c52ab36e libretro-common/string: add strlcpy_append helper and apply to database_info_build_query_enum
Add strlcpy_append, a bound-checked replacement for the unsafe
idiom that's widespread in this codebase:

   _len += strlcpy(s + _len, src, len - _len);

That looks like a self-bounding chain but isn't.  strlcpy
returns strlen(source) regardless of how much was actually
written, so on truncation _len overshoots len and the next
(len - _len) underflows to a huge size_t, driving the next
strlcpy into an OOB-write or memcpy of attacker-influenced
size.  This is the same primitive that drove the shader-
wildcard fix (commit bac6894).

strlcpy_append takes (s, len, *pos, src), checks the
truncation condition correctly, and on overflow:
  - leaves s NUL-terminated at len - 1 (strlcpy's contract)
  - clamps *pos to len - 1 so subsequent calls in a chain
    short-circuit (also returning -1)
  - returns -1 to the caller

The clamp is what makes chained use safe with a single check
at the end of the chain.

Apply to database_info_build_query_enum (database_info.c).
That function builds DB query strings of the shape

   {'KEY':"PATH"}      (or numeric variants without the quotes,
                        or {'developer':glob('*PATH*')})

via 22 switch cases, each of which was a hand-unrolled chain
of s[++_len] = '...' character writes followed by a path
strlcpy and another short s[++_len] = '...' chain to close
the brace.  None of those writes was bounded against len.
A caller passing a buffer smaller than the prefix length
got OOB-writes from the prefix; a caller whose buffer was
just barely enough for prefix + path got the trailing
s[_len]='"';s[++_len]='}' writes off the end (up to 3 bytes
OOB).  All callers in tree pass query[4096] from the menu
displaylist, so practical buffers are large -- but the
pattern is wrong and the path component is attacker-
influenced when scanning content metadata.

Side fix in DATABASE_QUERY_ENTRY_BBFC_RATING: pre-rewrite
the case wrote s[++_len] = '"' after the path strlcpy
instead of s[_len] = '"', leaving the strlcpy's NUL
terminator embedded in the query.  BBFC rating searches
have been silently returning nothing since this code was
written.  Fixed while rewriting.

Adds libretro-common/samples/string/strlcpy_append/
strlcpy_append_test as a regression test, registered in
.github/workflows/Linux-libretro-common-samples.yml's
RUN_TARGETS allowlist (which builds with ASan + UBSan
default since the cdfs/chd commit).  Eight cases covering
the contract: basic append, chained append, exact-fit
boundary, wide-margin truncation, chain short-circuiting
after truncation, empty source, NULL/zero-length args, and
*pos already at or past len.

Test follows the existing libretro-common/samples pattern
(heap-allocated destinations sized to exactly the legal
capacity so any reintroduction of the unbounded chain is
flagged by ASan).  Verified to fire under ASan when the
helper is replaced with the unsafe naive idiom: heap-
buffer-overflow WRITE of size 2 at offset 26 of an 8-byte
allocation in test_chain_short_circuits_after_truncation.
With the safe helper all 8 cases pass clean.

Verified database_info_build_query_enum produces identical
output for all 21 enum values at len=4096 (the production
caller's buffer size); also verified that at len=8 the
function returns -1 with no OOB write, which is the
behaviour the unsafe naive replacement would have failed at.
2026-04-28 06:44:59 +02:00
U-DESKTOP-SPFP6AQ\twistedtechre a51455561b core_info_list->all_ext would irresponsibly concatenate every core's
delimiter-separated valid extensions far beyond PATH_MAX_LENGTH bounds.
now use a proper dedup function that makes sure we don't add duplicate
entries to this delimiter-separated list of valid extensions. This way
we can vastly reduce the size of newstr2 in general_push too (now
renamed ext_filters which is more true to what it actually does)
2026-04-12 22:07:01 +02:00
U-DESKTOP-SPFP6AQ\twistedtechre a63c881a51 word_wrap functions now return written length, can save on strlen
calls from callee
2026-04-08 12:29:04 +02:00
U-DESKTOP-SPFP6AQ\twistedtechre 6603fe2369 Replace string_is_empty 2026-04-07 03:35:23 +02:00
U-DESKTOP-SPFP6AQ\twistedtechre 6d07ac41b8 Remove some ISSPACE usage 2026-04-01 21:02:09 +02:00
U-DESKTOP-SPFP6AQ\twistedtechre 9d489a0237 Get rid of more strtok_r calls 2026-03-30 14:52:10 +02:00
U-DESKTOP-SPFP6AQ\twistedtechre f248d3dbc5 string_remove_all_whitespaces - return a length now 2026-03-29 03:33:41 +02:00
U-DESKTOP-SPFP6AQ\twistedtechre 9c0f937ae8 stdstring improvements:
Bug fixes:
1. string_ucwords — added NULL/empty guard, and added a '\0' check before uppercasing *(cs+1)
2. word_wrap and word_wrap_wideglyph — all mid-loop strlcpy early returns now pass the remaining buffer capacity (len - (s - s_start)) instead of the total buffer len.
3. string_hex_to_unsigned — reworked the prefix check so single-character hex strings like "A" are accepted.
4. string_replace_substring — replaced the strcpy at the end with a bounded strlcpy, computing the remaining byte count from the input pointers.
Performance:
1. string_trim_whitespace_left — removed the up-front strlen()
2. string_tokenize — delimiter length is computed once into delim_len at the top and reused for the pointer advance, instead of calling strlen(delim) a second time.
2026-03-11 20:26:18 +01:00
U-DESKTOP-SPFP6AQ\twistedtechre 1d5d8d58f4 Revert code back 2026-03-04 22:37:23 +01:00
U-DESKTOP-SPFP6AQ\twistedtechre 73d1b487ff Optimize more libretro-common files 2026-03-04 20:00:13 +01:00
U-DESKTOP-SPFP6AQ\twistedtechre 9a84acb71f (stdstring) optimize word_wrap_wideglyph 2026-03-04 08:30:23 +01:00
U-DESKTOP-SPFP6AQ\twistedtechre 7cf3f3ea17 Small cleanups/optimizations of functions:
* string_tokenize (stdstring.c)
* slang_get_include_file (glslang_util.c)
* slang_name_to_texture_semantic_array (glslang_util.c)
2026-03-04 03:41:08 +01:00
libretroadmin 954d202637 string_remove_all_chars - only write if the character is not the
one to remove
2025-07-20 03:14:20 +02:00
LibretroAdmin c57c4fbd1a Style nits 2025-02-10 13:59:25 +01:00
LibretroAdmin ed58e4a8d8 Conventionalize len variables:
* In function arguments, use 'size_t len'
* Inside the function, use '_len'
* If you need a seciondary len variable inside the function, use '__len'
2024-12-27 05:51:33 +01:00
libretroadmin ca7e53e3ca string_replace_substring - move out implicit strlen 2024-12-23 00:40:09 +01:00
Viačasłaŭ 3019b926c2 Fix typos (#17068) 2024-10-01 17:36:33 -07:00
libretroadmin 4b86886d30 (libretro-common) stdstring - get rid of these pointless functions 2024-09-05 11:44:57 +02:00
libretroadmin 24287b1cce Cleanups/simplifications 2023-08-17 21:58:41 +02:00
libretroadmin 1c9d3ad0bf Silence some warnings 2022-11-21 20:56:28 +01:00
reallibretroadmin 0033224c25 Fix some implicit conversion signedness warnings 2022-10-02 03:22:34 +02:00
LibretroAdmin 6894600d41 (stdstring) word_wrap - use strlcpy instead of strcpy 2022-08-24 15:06:03 +02:00
LibretroAdmin e769436876 (word wrap functions in stdstring.c) Avoid implicit strlens, caller
should pass the 'length' to the function instead
2022-08-23 17:06:01 +02:00
LibretroAdmin ec6f4c1f55 (libretro-common) refinements to documentation 2022-08-01 13:06:35 +02:00
LibretroAdmin c7a1d83675 (libretro-common) Start documenting leaf functon calls in function documentation
(libretro-common) docs - document when string has to be non-NULL or else UB (undefined behavior)
(libretro-common) stdstring.c - string_hex_to_unsigned - make strlen call unneeded
2022-08-01 09:52:39 +02:00
LibretroAdmin 29774f5b7a Small opts (#14186)
* (joypad_connection) Small optimizations -
* Turn functions static where possible
* Hose strlen call out of loop

* (input_driver.c) General cleanups:
* Some small code/style nits

task_screenshot.c:
* Move widget callback function for screenshots to task_screenshot.c

(file_path.c):
* Turn get_pathname_num_slashes into static function
* path_linked_list_free - always returns true, so get rid of return value
* path_linked_list_new - fix function signature
* path_get_archive_delim - do not NULL-terminate string, already done by strlcpy later on

General:
* Slight optimizations - use int/size_t for loop counter variable instead of unsigned
* Take advantage of fact that strlcpy already NULL-terminates, so don't do this explicitly
outside if we're just going to end up calling strlcpy/fill_pathname_join on it anyway
2022-07-19 10:01:33 +02:00
Cthulhu-throwaway 98ca6232aa (String) Some function fixes (#14171) 2022-07-12 22:32:58 +02:00
Cthulhu-throwaway f39df40728 (String) Do not assume char is unsigned (#14168) 2022-07-12 02:55:56 +02:00
libretroadmin 7b83636b64 Remove variables that are never used because the return value
of the function is already used instead
2022-07-11 18:15:08 +02:00
libretroadmin 0e85113eb3 (libretro-common) Style nits/cleanups 2022-07-10 18:13:49 +02:00
Tony 044e1ec655 (WinRaw) Fix multiple light guns (#13840)
* (WinRaw) Fix multiple light guns

* Strip non-ASCII characters from mouse display names
2022-04-08 21:46:00 +02:00
pkos a192064403 (Database) Serial scanning for Gamecube/MegaCD/SegaCD/Saturn/PSX/PSP/Dreamcast/Wii 2021-12-31 21:35:16 -05:00
toshixm 4fab84ca9e improve message wrapping with CJK languages 2021-06-03 21:09:35 +09:00
toshixm a39c38f267 refactor word_wrap() 2021-05-27 19:55:37 +09:00
twinaphex ee474b4feb Add missing string.h header include 2020-10-24 17:01:55 +02:00
twinaphex c744baeb89 Add ctype variants to stdstring and use it in RA 2020-09-27 22:15:32 +02:00
twinaphex 5a8da81d07 Simplify string_set 2020-08-20 19:12:38 +02:00
twinaphex fa6d5333f7 More silencing of warnings 2020-07-23 06:39:21 +02:00