On Windows, when utilizing string_theory as a dependency, its scripts override any string_theory directory specification given in the cmake gui. The overridden value is the local build directory. This seems to be a major blocker to using string_theory in CWE master.

S_T does not correctly determine the presence of std::filesystem when compiling with VC++2017. Attempting to define ST_HAVE_CXX17_FILESYSTEM causes the build to fail because S_T is not compiled with C++17 features enabled. Defining ST_HAVE_EXPERIMENTAL_FILESYSTEM allows the build to proceed with support for std::experimental::filesystem, however.

Adding the following lines to CMakeLists.txt allows one to manually define ST_HAVE_CXX17_FILESYSTEM and build with std::filesystem support. However, the autodetection incorrectly undefs that and uses ST_HAVE_EXPERIMENTAL_FILESYSTEM instead.

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

Including string_theory\st_string.h generates the following warning (with compiler option /W3 at least):

string_theory\st_string_priv.h(157,40): warning C4146: unary minus operator applied to unsigned type, result still unsigned

Moving the - inside the static_cast should fix this issue.

When using the {#x} format specifier, eg ST::printf(fp, "\t{#x},", *codes++);, the 0x prefix will not be applied if the value passed in is 0. Other values correctly receive the prefix.

Testcase:

#include <string_theory/string>

const ST::string sAmount = "$AMOUN$";
ST::string amount = "$8,565";

ST::string no_heap_buffer_overflow()
{
    // This line does not produce an address violation:
    return (ST::string("$MERCNAME$")).replace(sAmount, amount);
}

ST::string heap_buffer_overflow()
{
    // But this line does:
   return (ST::string("Insurance Claim: $MERCNAME$")).replace(sAmount, amount);
}

int main()
{
    no_heap_buffer_overflow();
    heap_buffer_overflow();
}

==55732==ERROR: AddressSanitizer: heap-buffer-overflow on address 0x60300000005c at pc 0x000000270606 bp 0x7ffcf5d0fd00 sp 0x7ffcf5d0f4a8
READ of size 7 at 0x60300000005c thread T0
#0 0x270605 in MemcmpInterceptorCommon(void*, int ()(void const, void const*, unsigned long), void const*, void const*, unsigned long) (/tmp/test+0x270605) (BuildId: 483272504e84bd37)
#1 0x270b2d in memcmp (/tmp/test+0x270b2d) (BuildId: 483272504e84bd37)
#2 0x3308bb in std::char_traits::compare(char const*, char const*, unsigned long) /usr/bin/../lib/gcc/x86_64-redhat-linux/13/../../../../include/c++/13/bits/char_traits.h:399:9
#3 0x3307c4 in _ST_PRIVATE::compare_cs(char const*, char const*, unsigned long) /usr/local/include/string_theory/st_string_priv.h:50:16
#4 0x330103 in _ST_PRIVATE::find_cs(char const*, unsigned long, char const*, unsigned long) /usr/local/include/string_theory/st_string_priv.h:127:17
#5 0x32d840 in ST::string::replace(ST::string const&, ST::string const&, ST::case_sensitivity_t) const /usr/local/include/string_theory/st_string.h:2286:31
#6 0x32d198 in heap_buffer_overflow() /tmp/test.cpp:15:55
#7 0x32d399 in main /tmp/test.cpp:21:5
#8 0x7f78d9f44b49 in __libc_start_call_main (/lib64/libc.so.6+0x27b49) (BuildId: 245240a31888ad5c11bbc55b18e02d87388f59a9)
#9 0x7f78d9f44c0a in __libc_start_main@GLIBC_2.2.5 (/lib64/libc.so.6+0x27c0a) (BuildId: 245240a31888ad5c11bbc55b18e02d87388f59a9)
#10 0x2541b4 in _start (/tmp/test+0x2541b4) (BuildId: 483272504e84bd37)

0x60300000005c is located 0 bytes after 28-byte region [0x603000000040,0x60300000005c)
allocated by thread T0 here:
#0 0x32a911 in operator new[](unsigned long) (/tmp/test+0x32a911) (BuildId: 483272504e84bd37)
#1 0x32e584 in ST::buffer::buffer(char const*, unsigned long) /usr/local/include/string_theory/st_charbuffer.h:122:37
#2 0x32df57 in ST::string::_set_utf8(char const*, unsigned long, ST::utf_validation_t) /usr/local/include/string_theory/st_string.h:101:17
#3 0x32d59e in ST::string::string(char const*, unsigned long, ST::utf_validation_t) /usr/local/include/string_theory/st_string.h:165:13
#4 0x32d17e in heap_buffer_overflow() /tmp/test.cpp:15:12
#5 0x32d399 in main /tmp/test.cpp:21:5
#6 0x7f78d9f44b49 in __libc_start_call_main (/lib64/libc.so.6+0x27b49) (BuildId: 245240a31888ad5c11bbc55b18e02d87388f59a9)
#7 0x7f78d9f44c0a in __libc_start_main@GLIBC_2.2.5 (/lib64/libc.so.6+0x27c0a) (BuildId: 245240a31888ad5c11bbc55b18e02d87388f59a9)
#8 0x2541b4 in _start (/tmp/test+0x2541b4) (BuildId: 483272504e84bd37)

Compiled with clang++ test.cpp -fsanitize=address -Wall -g3 -o test

MSVC++2015 supports std::experimental::filesystem, but this is not correctly detected and enabled by string_theory cmake. Everything works if I manually #define ST_HAVE_EXPERIMENTAL_FILESYSTEM in st_config.h

On gcc-8, calling ST::string::to_path() returns an std::experimental::filesystem::v1::__cx11::path object. When assigning the result of this operation to a variable of type std::filesystem::path, a compiler error results because that type is aliased to std::filesystem::__cx11::path.

A newly generated st_config.h reveals this pertinent section:

#if (__cplusplus > 201402L) || (defined(_MSVC_LANG) && (_MSVC_LANG > 201402L))
#define ST_HAVE_CXX17_STRING_VIEW
/* #undef ST_HAVE_EXPERIMENTAL_STRING_VIEW */
/* #undef ST_HAVE_CXX17_FILESYSTEM */
#define ST_HAVE_EXPERIMENTAL_FILESYSTEM
#endif

Discovered while working on a fix for H-uru/libhsplasma#97:

ST::string foo;
ST::char_buffer init = {...};
try {
    foo = init;
} catch (ST::unicode_error &) {
    // init is now empty due to move constructor
}

Attempting to build string_theory on Solaris 10 using GCC 5.5.

First tests on format.decimal fail with:

[ RUN      ] format.decimal
FanCode/H-uru/string_theory/test/test_format.cpp:173: Failure
      Expected: ST::string::from_literal("" "xx127xx" "", sizeof("xx127xx") - 1)
      Which is: ST::string{"xx127xx"}
To be equal to: ST::format("xx{}xx", std::numeric_limits<int8_t>::max())
      Which is: ST::string{"xxx"}
FanCode/H-uru/string_theory/test/test_format.cpp:174: Failure
      Expected: ST::string::from_literal("" "xx+127xx" "", sizeof("xx+127xx") - 1)
      Which is: ST::string{"xx+127xx"}
To be equal to: ST::format("xx{+}xx", std::numeric_limits<int8_t>::max())
      Which is: ST::string{"xxx"}
FanCode/H-uru/string_theory/test/test_format.cpp:175: Failure
      Expected: ST::string::from_literal("" "xx-128xx" "", sizeof("xx-128xx") - 1)
      Which is: ST::string{"xx-128xx"}
To be equal to: ST::format("xx{}xx", std::numeric_limits<int8_t>::min())
      Which is: ST::string{"xx�xx"}
FanCode/H-uru/string_theory/test/test_format.cpp:176: Failure
      Expected: ST::string::from_literal("" "xx-128xx" "", sizeof("xx-128xx") - 1)
      Which is: ST::string{"xx-128xx"}
To be equal to: ST::format("xx{+}xx", std::numeric_limits<int8_t>::min())
      Which is: ST::string{"xx�xx"}
[  FAILED  ] format.decimal (0 ms)

=========
Other tests failing:
[  FAILED  ] 5 tests, listed below:
[  FAILED  ] format.decimal
[  FAILED  ] format.hex
[  FAILED  ] format.hex_upper
[  FAILED  ] format.octal
[  FAILED  ] format.binary

Will keep this issue updated as debugging progresses. Insights appreciated.

Just something i wanted to make an issue for:

CMake Deprecation Warning at external/string_theory/CMakeLists.txt:21 (cmake_minimum_required):
  Compatibility with CMake < 3.5 will be removed from a future version of
  CMake.

  Update the VERSION argument <min> value or use a ...<max> suffix to tell
  CMake that the project does not need compatibility with older versions.

When using modern versions of cmake you will see this warning every time you build string_theory which is quite annoying when using the repo as a git submodule through add_subdirectory

Is there any possibility to allow the use of the library with exceptions disabled?

GitHub tarballs are generated using git-archive, which does not include the contents of git submodules. In our case, that means the gtest folder is empty.

This causes problems if you try to run cmake with the contents of a downloaded tarball because string_theory defaults to trying to build tests, and fails when it can't find gtest.

Our options appear to be going back to vendoring gtest in the repo (rather than as a submodule) or adding some detection of the gtest folder before trying to enable tests.

See microsoft/vcpkg#2212

You could use a CMake option that's ON by default, and vcpkg can set it to OFF, which would be slightly cleaner than their current method of patching during the build process.

does string_theory have constexpr constructors? because it could allow for "frozen" ST strings that are resolved at compile time.

plus I had an idea of using it with this library https://github.com/serge-sans-paille/frozen

Mixing Release string_theory and RelWithDebInfo clients or vice versa yields errors in MSVC14:

• mismatch detected for '_ITERATOR_DEBUG_LEVEL': value '2' doesn't match value '0' in <filename.obj> [...]
• unresolved external symbol __imp__invalid_parameter
• unresolved external symbol __imp__CrtDbgReportW

Hi there, I tried out 2.3 and I really like this library.

In my case I need to enforce C++11, but CMakeLists.txt chooses the latest available.
I get around it by building as an external project and replacing the CMakeLists.txt in the patch step, with stuff related to newer standards removed.
Ideally there would be an option that lets me restrict the features to C++11.

string_theory was originally ported out of the plString and plFormat classes and associated tests from the H-uru/Plasma project. Since H-uru/Plasma is licensed under the GPLv3, and since string_theory is therefore considered a derivative work under the terms of the GPL, this means that string_theory exists today also under the GPLv3 license.

In order to allow greater flexibility in the use of string_theory by other applications and libraries, I would like to relicense string_theory under a more permissive license. The MIT license allows for maximum reuse by being compatible with a large variety of open- and closed-source software and licenses, while still maintaining the copyright and license for derivatives and end users.

This proposal is for the immediate relicensing of string_theory to the MIT license. For more information about the license terms, please see https://en.wikipedia.org/wiki/MIT_License. In order to go ahead with this proposal, we need permission from everyone who has contributed to the included code to relicense their code under the new terms. The complete list includes:

• Bartek Bok @boq
• Darryl Pogue @dpogue
• Adam Johnson @Hoikas
• Anne Marije van der Meer @Lunanne
• Michael Hansen @zrax (myself)

Please respond below with a statement clearly indicating if you will allow your code to be relicensed under the MIT license.

Although the default configuration is to build string_theory as a dynamic library, I'm only able to get it to link with Plasma (using VS2015 Update 3) when compiled as a static library.