source: cpp/common/util-string.cpp @ 1310

// This file is a part of Framsticks SDK.  http://www.framsticks.com/
// Copyright (C) 1999-2023  Maciej Komosinski and Szymon Ulatowski.
// See LICENSE.txt for details.

#include "util-string.h"
#include <stdarg.h>
#include "nonstd_stdio.h"
#include "nonstd.h"
#include <assert.h>
#include <cstdlib> //malloc()
#include <algorithm>
#ifdef USE_VIRTFILE
#include <common/virtfile/virtfile.h>
#endif
#ifdef __ANDROID__
#include <android/log.h> //only needed to print error messages related to a workaround for Android bug
#endif

string repr(const char *str)
{
        string out = "";
        char hex[4];
        while (*str)
        {
                unsigned char ch = *str;
                if (ch >= 32 && ch < 128)
                        out += ch;
                else
                {
                        if (ch == 10) out += "\\n"; else
                                if (ch == 13) out += "\\r"; else
                                {
                                        sprintf(hex, "%X", ch);
                                        out += "\\x";
                                        out += hex;
                                }
                }
                str++;
        }
        return out;
}


string ssprintf_va(const char* format, va_list ap)
{
        string s; //clang crashed when this declaration was in s=buf
        int size = 256;
        char* buf;
        va_list ap_copy; // "va_list ap" can only by used once by printf-type functions as they advance the current argument pointer (crashed on linux x86_64)
        // (does not apply to SString::sprintf, it does not have the va_list variant)

        //almost like SString::sprintf, but there is no common code to share because SString can use its directWrite to avoid double allocating/copying
#ifdef USE_VSCPRINTF
        va_copy(ap_copy, ap);
        size = _vscprintf(format, ap_copy) + 1; //+1 for terminating null character
        va_end(ap_copy);
#endif

        while (true)
        {
                buf = (char*)malloc(size);
                assert(buf != NULL);
                va_copy(ap_copy, ap);
                int n = vsnprintf(buf, size, format, ap_copy);
                va_end(ap_copy);

#ifdef __ANDROID__
                //Workaround for Android bug. /system/lib64/libc.so? maybe only arm 64-bit? "If an encoding error occurs, a negative number is returned". On some devices keeps returning -1 forever.
                //https://github.com/android-ndk/ndk/issues/879 but unfortunately during google play tests (Firebase Test Lab) this problem turned out to be not limited to Chinese devices and occurred in Mate 9, Galaxy S9, Pixel, Pixel 2, Moto Z (even with the en_GB locale; the locale is not important but the problem seem to be utf8 non-ascii chars in the format string).
                if (n < 0 && size >= (1 << 24)) //wants more than 16M
                {
                        buf[size - 1] = 0; //just to ensure there is at least some ending \0 in memory... who knows what buggy vsnprintf() did.
                        __android_log_print(ANDROID_LOG_ERROR, LOG_APP_NAME, "Giving up due to Android bug: vsnprintf() wants more than %d bytes, it used %zu bytes, for format='%s'", size, strlen(buf), format);
                        //in my tests, it always used 0 bytes, so it produced a 0-length string: ""
                        va_copy(ap_copy, ap);
                        n = vsprintf(buf, format, ap_copy); //hoping 16M is enough
                        va_end(ap_copy);
                        __android_log_print(ANDROID_LOG_INFO, LOG_APP_NAME, "Fallback to vsprintf() produced string: '%s'", buf);
                        if (n < 0) //vsprintf was also buggy. If we were strict, we should abort the app now.
                        {
                                strcpy(buf, "[STR_ERR] "); //a special prefix just to indicate the returned string is incorrect
                                strcat(buf, format); //append and return the original formatting string
                                __android_log_print(ANDROID_LOG_ERROR, LOG_APP_NAME, "vsprintf() also failed, using the incorrect resulting string: '%s'", buf);
                        }
                        n = strlen(buf); //pretend vsnprintf() or vsprintf() was OK to exit the endless loop
                }
#endif

                if (n > -1 && n < size)
                {
                        s = buf;
                        free(buf);
                        return s;
                }
#ifdef VSNPRINTF_RETURNS_REQUIRED_SIZE
                if (n > -1)    /* glibc 2.1 */
                        size = n + 1; /* precisely what is needed */
                else           /* glibc 2.0 */
#endif
                        size *= 2;  /* twice the old size */
                free(buf);
        }
}

bool str_starts_with(const char *str, const char *prefix)
{
        return strncmp(str, prefix, strlen(prefix)) == 0;
}

bool ends_with(std::string_view str, std::string_view suffix)
{
        return str.size() >= suffix.size() && 0 == str.compare(str.size() - suffix.size(), suffix.size(), suffix);
}

bool strip_prefix(string& modify_me, const char* prefix)
{
        if (starts_with(modify_me, prefix))
        {
                modify_me = modify_me.substr(strlen(prefix));
                return true;
        }
        return false;
}

char* strmove(char *a, char *b) //strcpy that works well for overlapping strings ("Source and destination overlap")
{
        if (a == NULL || b == NULL)
                return NULL;
        memmove(a, b, strlen(b) + 1);
        return a;
}

string ssprintf(const char* format, ...)
{
        va_list ap;
        va_start(ap, format);
        string ret = ssprintf_va(format, ap); //is it too wasteful? copying the string again... unless the compiler can handle it better
        va_end(ap);
        return ret;
}

string stripExt(const string& filename)
{
        size_t dot = filename.rfind('.');
        if (dot == string::npos) return filename;
        size_t sep = filename.rfind(PATH_SEPARATOR_CHAR);
        if ((sep == string::npos) || (sep < dot))
                return filename.substr(0, dot);
        return filename;
}

string stripFileDir(const string& filename)
{
        size_t sep = filename.rfind(PATH_SEPARATOR_CHAR);
        if (sep == string::npos) return filename;
        return filename.substr(sep + 1);
}

string getFileExt(const string& filename)
{
        size_t dot = filename.rfind('.');
        if (dot == string::npos) return string("");
        size_t sep = filename.rfind(PATH_SEPARATOR_CHAR);
        if ((sep == string::npos) || (sep < dot))
                return filename.substr(dot);
        return string("");
}

string getFileDir(const string& filename)
{
        size_t slash = filename.rfind(PATH_SEPARATOR_CHAR);
        if (slash == string::npos) return string("");
        return (slash == 0) ? string(PATH_SEPARATOR_STRING) : filename.substr(0, slash);
}

string concatPath(const string& path, const string& other_path)
{
        string result = path;
        if (!result.empty() && result.back() != PATH_SEPARATOR_CHAR && !other_path.empty())
                result += PATH_SEPARATOR_CHAR;
        result += other_path;
        return result;
}

//trimming functions, https://stackoverflow.com/questions/216823/whats-the-best-way-to-trim-stdstring

void ltrim_inplace(string &s)
{
        s.erase(s.begin(), find_if(s.begin(), s.end(), [](int ch) {
                return !isspace(ch);
                }));
}

void rtrim_inplace(string &s)
{
        s.erase(find_if(s.rbegin(), s.rend(), [](int ch) {
                return !isspace(ch);
                }).base(), s.end());
}

void trim_inplace(string &s)
{
        ltrim_inplace(s);
        rtrim_inplace(s);
}

string ltrim(string s)
{
        ltrim_inplace(s);
        return s;
}

string rtrim(string s)
{
        rtrim_inplace(s);
        return s;
}

string trim(string s)
{
        trim_inplace(s);
        return s;
}