StringTools_inl.hpp

// Copyright (c) 2017-2026, University of Cincinnati, developed by Henry Schreiner
// under NSF AWARD 1414736 and by the respective contributors.
// All rights reserved.
//
// SPDX-License-Identifier: BSD-3-Clause
 
#pragma once
 
// IWYU pragma: private, include "CLI/CLI.hpp"
 
// This include is only needed for IDEs to discover symbols
#include "../StringTools.hpp"
 
// [CLI11:public_includes:set]
#include <algorithm>
#include <cctype>
#include <cstddef>
#include <cstdint>
#include <cstdlib>
#include <iomanip>
#include <iterator>
#include <locale>
#include <sstream>
#include <stdexcept>
#include <string>
#include <utility>
#include <vector>
// [CLI11:public_includes:end]
 
namespace CLI {
// [CLI11:string_tools_inl_hpp:verbatim]
 
namespace detail {
 
CLI11_INLINE bool isalpha(const std::string &str) {
    return std::all_of(str.begin(), str.end(), [](char c) { return std::isalpha(c, std::locale()); });
}
 
CLI11_INLINE std::string to_lower(std::string str) {
    std::transform(std::begin(str), std::end(str), std::begin(str), [](const std::string::value_type &x) {
        return std::tolower(x, std::locale());
    });
    return str;
}
 
CLI11_INLINE std::vector<std::string> split(const std::string &s, char delim) {
    std::vector<std::string> elems;
    if(s.empty()) {
        elems.emplace_back();
        return elems;
    }
 
    std::size_t start = 0;
    std::size_t end = 0;
 
    while((end = s.find(delim, start)) != std::string::npos) {
        elems.push_back(s.substr(start, end - start));
        start = end + 1;
    }
    elems.push_back(s.substr(start));
    return elems;
}
 
CLI11_INLINE std::string &ltrim(std::string &str) {
    auto it = std::find_if(str.begin(), str.end(), [](char ch) { return !std::isspace<char>(ch, std::locale()); });
    str.erase(str.begin(), it);
    return str;
}
 
CLI11_INLINE std::string &ltrim(std::string &str, const std::string &filter) {
    auto it = std::find_if(str.begin(), str.end(), [&filter](char ch) { return filter.find(ch) == std::string::npos; });
    str.erase(str.begin(), it);
    return str;
}
 
CLI11_INLINE std::string &rtrim(std::string &str) {
    auto it = std::find_if(str.rbegin(), str.rend(), [](char ch) { return !std::isspace<char>(ch, std::locale()); });
    str.erase(it.base(), str.end());
    return str;
}
 
CLI11_INLINE std::string &rtrim(std::string &str, const std::string &filter) {
    auto it =
        std::find_if(str.rbegin(), str.rend(), [&filter](char ch) { return filter.find(ch) == std::string::npos; });
    str.erase(it.base(), str.end());
    return str;
}
 
CLI11_INLINE std::string &remove_quotes(std::string &str) {
    if(!str.empty() && (str.front() == '"' || str.front() == '\'' || str.front() == '`')) {
        remove_outer(str, str.front());
    }
    return str;
}
 
CLI11_INLINE std::string &remove_outer(std::string &str, char key) {
    if(str.length() > 1 && (str.front() == key)) {
        if(str.front() == str.back()) {
            str.pop_back();
            str.erase(str.begin(), str.begin() + 1);
        }
    }
    return str;
}
 
CLI11_INLINE std::string fix_newlines(const std::string &leader, std::string input) {
    std::string::size_type n = 0;
    while(n != std::string::npos && n < input.size()) {
        n = input.find_first_of("\r\n", n);
        if(n != std::string::npos) {
            input.insert(n + 1, leader);
            n += leader.size() + 1;
        }
    }
    return input;
}
 
CLI11_INLINE std::ostream &format_aliases(std::ostream &out, const std::vector<std::string> &aliases, std::size_t wid) {
    if(!aliases.empty()) {
        out << std::setw(static_cast<int>(wid)) << "     aliases: ";
        bool front = true;
        for(const auto &alias : aliases) {
            if(!front) {
                out << ", ";
            } else {
                front = false;
            }
            out << detail::fix_newlines("              ", alias);
        }
        out << "\n";
    }
    return out;
}
 
CLI11_INLINE bool valid_name_string(const std::string &str) {
    if(str.empty() || !valid_first_char(str[0])) {
        return false;
    }
    auto e = str.end();
    for(auto c = str.begin() + 1; c != e; ++c)
        if(!valid_later_char(*c))
            return false;
    return true;
}
 
CLI11_INLINE std::string get_group_separators() {
    std::string separators{"_'"};
#if CLI11_HAS_RTTI != 0
    char group_separator = std::use_facet<std::numpunct<char>>(std::locale()).thousands_sep();
    separators.push_back(group_separator);
#endif
    return separators;
}
 
CLI11_INLINE std::string find_and_replace(std::string str, std::string from, std::string to) {
 
    std::size_t start_pos = 0;
 
    while((start_pos = str.find(from, start_pos)) != std::string::npos) {
        str.replace(start_pos, from.length(), to);
        start_pos += to.length();
    }
 
    return str;
}
 
CLI11_INLINE void remove_default_flag_values(std::string &flags) {
    auto loc = flags.find_first_of('{', 2);
    while(loc != std::string::npos) {
        auto finish = flags.find_first_of("},", loc + 1);
        if((finish != std::string::npos) && (flags[finish] == '}')) {
            flags.erase(flags.begin() + static_cast<std::ptrdiff_t>(loc),
                        flags.begin() + static_cast<std::ptrdiff_t>(finish) + 1);
        }
        loc = flags.find_first_of('{', loc + 1);
    }
    flags.erase(std::remove(flags.begin(), flags.end(), '!'), flags.end());
}
 
CLI11_INLINE std::ptrdiff_t
find_member(std::string name, const std::vector<std::string> &names, bool ignore_case, bool ignore_underscore) {
    auto it = std::end(names);
    if(ignore_case) {
        if(ignore_underscore) {
            name = detail::to_lower(detail::remove_underscore(name));
            it = std::find_if(std::begin(names), std::end(names), [&name](std::string local_name) {
                return detail::to_lower(detail::remove_underscore(local_name)) == name;
            });
        } else {
            name = detail::to_lower(name);
            it = std::find_if(std::begin(names), std::end(names), [&name](std::string local_name) {
                return detail::to_lower(local_name) == name;
            });
        }
 
    } else if(ignore_underscore) {
        name = detail::remove_underscore(name);
        it = std::find_if(std::begin(names), std::end(names), [&name](std::string local_name) {
            return detail::remove_underscore(local_name) == name;
        });
    } else {
        it = std::find(std::begin(names), std::end(names), name);
    }
 
    return (it != std::end(names)) ? (it - std::begin(names)) : (-1);
}
 
CLI11_MODULE_INLINE const std::string &escapedChars() {
    static const std::string s{"\b\t\n\f\r\"\\"};
    return s;
}
CLI11_MODULE_INLINE const std::string &escapedCharsCode() {
    static const std::string s{"btnfr\"\\"};
    return s;
}
CLI11_MODULE_INLINE const std::string &bracketChars() {
    static const std::string s{"\"'`[(<{"};
    return s;
}
CLI11_MODULE_INLINE const std::string &matchBracketChars() {
    static const std::string s{"\"'`])>}"};
    return s;
}
 
CLI11_INLINE bool has_escapable_character(const std::string &str) {
    return (str.find_first_of(escapedChars()) != std::string::npos);
}
 
CLI11_INLINE std::string add_escaped_characters(const std::string &str) {
    std::string out;
    out.reserve(str.size() + 4);
    for(char s : str) {
        auto sloc = escapedChars().find_first_of(s);
        if(sloc != std::string::npos) {
            out.push_back('\\');
            out.push_back(escapedCharsCode()[sloc]);
        } else {
            out.push_back(s);
        }
    }
    return out;
}
 
CLI11_INLINE std::uint32_t hexConvert(char hc) {
    int hcode{0};
    if(hc >= '0' && hc <= '9') {
        hcode = (hc - '0');
    } else if(hc >= 'A' && hc <= 'F') {
        hcode = (hc - 'A' + 10);
    } else if(hc >= 'a' && hc <= 'f') {
        hcode = (hc - 'a' + 10);
    } else {
        hcode = -1;
    }
    return static_cast<uint32_t>(hcode);
}
 
CLI11_INLINE char make_char(std::uint32_t code) { return static_cast<char>(static_cast<unsigned char>(code)); }
 
CLI11_INLINE void append_codepoint(std::string &str, std::uint32_t code) {
    if(code < 0x80) {  // ascii code equivalent
        str.push_back(static_cast<char>(code));
    } else if(code < 0x800) {  // \u0080 to \u07FF
        // 110yyyyx 10xxxxxx; 0x3f == 0b0011'1111
        str.push_back(make_char(0xC0 | code >> 6));
        str.push_back(make_char(0x80 | (code & 0x3F)));
    } else if(code < 0x10000) {  // U+0800...U+FFFF
        if(0xD800 <= code && code <= 0xDFFF) {
            throw std::invalid_argument("[0xD800, 0xDFFF] are not valid code points.");
        }
        // 1110yyyy 10yxxxxx 10xxxxxx
        str.push_back(make_char(0xE0 | code >> 12));
        str.push_back(make_char(0x80 | (code >> 6 & 0x3F)));
        str.push_back(make_char(0x80 | (code & 0x3F)));
    } else if(code < 0x110000) {  // U+010000 ... U+10FFFF
        // 11110yyy 10yyxxxx 10xxxxxx 10xxxxxx
        str.push_back(make_char(0xF0 | code >> 18));
        str.push_back(make_char(0x80 | (code >> 12 & 0x3F)));
        str.push_back(make_char(0x80 | (code >> 6 & 0x3F)));
        str.push_back(make_char(0x80 | (code & 0x3F)));
    } else {  // code points above U+10FFFF are not valid
        throw std::invalid_argument("values above 0x10FFFF are not valid code points.");
    }
}
 
CLI11_INLINE std::string remove_escaped_characters(const std::string &str) {
 
    std::string out;
    out.reserve(str.size());
    for(auto loc = str.begin(); loc < str.end(); ++loc) {
        if(*loc == '\\') {
            if(str.end() - loc < 2) {
                throw std::invalid_argument("invalid escape sequence " + str);
            }
            auto ecloc = escapedCharsCode().find_first_of(*(loc + 1));
            if(ecloc != std::string::npos) {
                out.push_back(escapedChars()[ecloc]);
                ++loc;
            } else if(*(loc + 1) == 'u') {
                // must have 4 hex characters
                if(str.end() - loc < 6) {
                    throw std::invalid_argument("unicode sequence must have 4 hex codes " + str);
                }
                std::uint32_t code{0};
                std::uint32_t mplier{16 * 16 * 16};
                for(int ii = 2; ii < 6; ++ii) {
                    std::uint32_t res = hexConvert(*(loc + ii));
                    if(res > 0x0F) {
                        throw std::invalid_argument("unicode sequence must have 4 hex codes " + str);
                    }
                    code += res * mplier;
                    mplier = mplier / 16;
                }
                append_codepoint(out, code);
                loc += 5;
            } else if(*(loc + 1) == 'U') {
                // must have 8 hex characters
                if(str.end() - loc < 10) {
                    throw std::invalid_argument("unicode sequence must have 8 hex codes " + str);
                }
                std::uint32_t code{0};
                std::uint32_t mplier{16 * 16 * 16 * 16 * 16 * 16 * 16};
                for(int ii = 2; ii < 10; ++ii) {
                    std::uint32_t res = hexConvert(*(loc + ii));
                    if(res > 0x0F) {
                        throw std::invalid_argument("unicode sequence must have 8 hex codes " + str);
                    }
                    code += res * mplier;
                    mplier = mplier / 16;
                }
                append_codepoint(out, code);
                loc += 9;
            } else if(*(loc + 1) == '0') {
                out.push_back('\0');
                ++loc;
            } else {
                throw std::invalid_argument(std::string("unrecognized escape sequence \\") + *(loc + 1) + " in " + str);
            }
        } else {
            out.push_back(*loc);
        }
    }
    return out;
}
 
CLI11_INLINE std::size_t close_string_quote(const std::string &str, std::size_t start, char closure_char) {
    std::size_t loc{0};
    for(loc = start + 1; loc < str.size(); ++loc) {
        if(str[loc] == closure_char) {
            break;
        }
        if(str[loc] == '\\') {
            // skip the next character for escaped sequences
            ++loc;
        }
    }
    return loc;
}
 
CLI11_INLINE std::size_t close_literal_quote(const std::string &str, std::size_t start, char closure_char) {
    auto loc = str.find_first_of(closure_char, start + 1);
    return (loc != std::string::npos ? loc : str.size());
}
 
CLI11_INLINE std::size_t close_sequence(const std::string &str, std::size_t start, char closure_char) {
 
    auto bracket_loc = matchBracketChars().find(closure_char);
    switch(bracket_loc) {
    case 0:
        return close_string_quote(str, start, closure_char);
    case 1:
    case 2:
#if defined(_MSC_VER) && _MSC_VER < 1920
    case(std::size_t)-1:
#else
    case std::string::npos:
#endif
        return close_literal_quote(str, start, closure_char);
    default:
        break;
    }
 
    std::string closures(1, closure_char);
    auto loc = start + 1;
 
    while(loc < str.size()) {
        if(str[loc] == closures.back()) {
            closures.pop_back();
            if(closures.empty()) {
                return loc;
            }
        }
        bracket_loc = bracketChars().find(str[loc]);
        if(bracket_loc != std::string::npos) {
            switch(bracket_loc) {
            case 0:
                loc = close_string_quote(str, loc, str[loc]);
                break;
            case 1:
            case 2:
                loc = close_literal_quote(str, loc, str[loc]);
                break;
            default:
                closures.push_back(matchBracketChars()[bracket_loc]);
                break;
            }
        }
        ++loc;
    }
    if(loc > str.size()) {
        loc = str.size();
    }
    return loc;
}
 
CLI11_INLINE std::vector<std::string> split_up(std::string str, char delimiter) {
 
    auto find_ws = [delimiter](char ch) {
        return (delimiter == '\0') ? std::isspace<char>(ch, std::locale()) : (ch == delimiter);
    };
    trim(str);
 
    std::vector<std::string> output;
    while(!str.empty()) {
        if(bracketChars().find_first_of(str[0]) != std::string::npos) {
            auto bracketLoc = bracketChars().find_first_of(str[0]);
            auto end = close_sequence(str, 0, matchBracketChars()[bracketLoc]);
            if(end >= str.size()) {
                output.push_back(std::move(str));
                str.clear();
            } else {
                output.push_back(str.substr(0, end + 1));
                // The character following a closing quote/bracket is normally a delimiter and is
                // consumed.  If it is an ordinary character it must be retained (resume from it) so
                // no characters are silently lost (e.g. `"abc"def` -> {"abc", "def"}).  However if it
                // is itself a quote/bracket opening character, resuming from it would start a fresh
                // (potentially unterminated) quoted sequence that could swallow later delimiters, so
                // it is skipped like the original delimiter case to keep splitting well behaved.
                char follow = str[end + 1];
                bool skip_follow = find_ws(follow) || (bracketChars().find_first_of(follow) != std::string::npos);
                auto next = skip_follow ? end + 2 : end + 1;
                if(next < str.size()) {
                    str = str.substr(next);
                } else {
                    str.clear();
                }
            }
 
        } else {
            auto it = std::find_if(std::begin(str), std::end(str), find_ws);
            if(it != std::end(str)) {
                std::string value = std::string(str.begin(), it);
                output.push_back(value);
                str = std::string(it + 1, str.end());
            } else {
                output.push_back(str);
                str.clear();
            }
        }
        trim(str);
    }
    return output;
}
 
CLI11_INLINE std::size_t escape_detect(std::string &str, std::size_t offset) {
    auto next = str[offset + 1];
    if((next == '\"') || (next == '\'') || (next == '`')) {
        if(offset == 0) {
            // nothing precedes the trigger character, so there is nothing to reinterpret
            return offset + 1;
        }
        auto astart = str.find_last_of("-/ \"\'`", offset - 1);
        if(astart != std::string::npos) {
            if(str[astart] == ((str[offset] == '=') ? '-' : '/'))
                str[offset] = ' ';  // interpret this as a space so the split_up works properly
        }
    }
    return offset + 1;
}
 
CLI11_INLINE std::string binary_escape_string(const std::string &string_to_escape, bool force) {
    // s is our escaped output string
    std::string escaped_string{};
    // loop through all characters
    for(char c : string_to_escape) {
        // check if a given character is printable
        // the cast is necessary to avoid undefined behaviour
        if(isprint(static_cast<unsigned char>(c)) == 0) {
            std::stringstream stream;
            // if the character is not printable
            // we'll convert it to a hex string using a stringstream
            // note that since char is signed we have to cast it to unsigned first
            stream << std::hex << static_cast<unsigned int>(static_cast<unsigned char>(c));
            std::string code = stream.str();
            escaped_string += std::string("\\x") + (code.size() < 2 ? "0" : "") + code;
        } else if(c == 'x' || c == 'X') {
            // need to check for inadvertent binary sequences
            if(!escaped_string.empty() && escaped_string.back() == '\\') {
                escaped_string += std::string("\\x") + (c == 'x' ? "78" : "58");
            } else {
                escaped_string.push_back(c);
            }
 
        } else {
            escaped_string.push_back(c);
        }
    }
    if(escaped_string != string_to_escape || force) {
        auto sqLoc = escaped_string.find('\'');
        while(sqLoc != std::string::npos) {
            escaped_string[sqLoc] = '\\';
            escaped_string.insert(sqLoc + 1, "x27");
            sqLoc = escaped_string.find('\'', sqLoc + 4);
        }
        escaped_string.insert(0, "'B\"(");
        escaped_string.push_back(')');
        escaped_string.push_back('"');
        escaped_string.push_back('\'');
    }
    return escaped_string;
}
 
CLI11_INLINE bool is_binary_escaped_string(const std::string &escaped_string) {
    size_t ssize = escaped_string.size();
    if(escaped_string.compare(0, 3, "B\"(") == 0 && escaped_string.compare(ssize - 2, 2, ")\"") == 0) {
        return true;
    }
    return (escaped_string.compare(0, 4, "'B\"(") == 0 && escaped_string.compare(ssize - 3, 3, ")\"'") == 0);
}
 
CLI11_INLINE std::string extract_binary_string(const std::string &escaped_string) {
    std::size_t start{0};
    std::size_t tail{0};
    size_t ssize = escaped_string.size();
    if(escaped_string.compare(0, 3, "B\"(") == 0 && escaped_string.compare(ssize - 2, 2, ")\"") == 0) {
        start = 3;
        tail = 2;
    } else if(escaped_string.compare(0, 4, "'B\"(") == 0 && escaped_string.compare(ssize - 3, 3, ")\"'") == 0) {
        start = 4;
        tail = 3;
    }
 
    if(start == 0) {
        return escaped_string;
    }
    std::string outstring;
 
    outstring.reserve(ssize - start - tail);
    std::size_t loc = start;
    while(loc < ssize - tail) {
        // ssize-2 to skip )" at the end
        if(escaped_string[loc] == '\\' && (escaped_string[loc + 1] == 'x' || escaped_string[loc + 1] == 'X')) {
            auto c1 = escaped_string[loc + 2];
            auto c2 = escaped_string[loc + 3];
 
            std::uint32_t res1 = hexConvert(c1);
            std::uint32_t res2 = hexConvert(c2);
            if(res1 <= 0x0F && res2 <= 0x0F) {
                loc += 4;
                outstring.push_back(static_cast<char>(res1 * 16 + res2));
                continue;
            }
        }
        outstring.push_back(escaped_string[loc]);
        ++loc;
    }
    return outstring;
}
 
CLI11_INLINE void remove_quotes(std::vector<std::string> &args) {
    for(auto &arg : args) {
        if(arg.empty()) {
            continue;
        }
        if(arg.front() == '\"' && arg.back() == '\"') {
            remove_quotes(arg);
            // only remove escaped for string arguments not literal strings
            arg = remove_escaped_characters(arg);
        } else {
            remove_quotes(arg);
        }
    }
}
 
CLI11_INLINE void handle_secondary_array(std::string &str) {
    if(str.size() >= 2 && str.front() == '[' && str.back() == ']') {
        // handle some special array processing for arguments if it might be interpreted as a secondary array
        std::string tstr{"[["};
        for(std::size_t ii = 1; ii < str.size(); ++ii) {
            tstr.push_back(str[ii]);
            tstr.push_back(str[ii]);
        }
        str = std::move(tstr);
    }
}
 
CLI11_INLINE bool
process_quoted_string(std::string &str, char string_char, char literal_char, bool disable_secondary_array_processing) {
    if(str.size() <= 1) {
        return false;
    }
    if(detail::is_binary_escaped_string(str)) {
        str = detail::extract_binary_string(str);
        if(!disable_secondary_array_processing)
            handle_secondary_array(str);
        return true;
    }
    if(str.front() == string_char && str.back() == string_char) {
        detail::remove_outer(str, string_char);
        if(str.find_first_of('\\') != std::string::npos) {
            str = detail::remove_escaped_characters(str);
        }
        if(!disable_secondary_array_processing)
            handle_secondary_array(str);
        return true;
    }
    if((str.front() == literal_char || str.front() == '`') && str.back() == str.front()) {
        detail::remove_outer(str, str.front());
        if(!disable_secondary_array_processing)
            handle_secondary_array(str);
        return true;
    }
    return false;
}
 
CLI11_INLINE std::string get_environment_value(const std::string &env_name) {
    std::string ename_string;
 
#ifdef _MSC_VER
    // Windows version
    char *buffer = nullptr;
    std::size_t sz = 0;
    if(_dupenv_s(&buffer, &sz, env_name.c_str()) == 0 && buffer != nullptr) {
        ename_string = std::string(buffer);
        free(buffer);
    }
#else
    // This also works on Windows, but gives a warning
 
    // MISRA static analysis need. MISRACPP2023-25_5_2-a-1
    const char *buffer = nullptr;
    buffer = std::getenv(env_name.c_str());
    if(buffer != nullptr) {
        ename_string = std::string(buffer);
    }
#endif
    return ename_string;
}
 
CLI11_INLINE std::ostream &streamOutAsParagraph(std::ostream &out,
                                                const std::string &text,
                                                std::size_t paragraphWidth,
                                                const std::string &linePrefix,
                                                bool skipPrefixOnFirstLine) {
    std::istringstream lss(text);
    std::string line = "";
    while(std::getline(lss, line)) {
        std::istringstream iss(line);
        std::string word = "";
        std::size_t charsWritten = 0;
 
        if(!skipPrefixOnFirstLine)
            out << linePrefix;
        skipPrefixOnFirstLine = false;  // subsequent lines always get the prefix
 
        while(iss >> word) {
            if(charsWritten > 0 && (word.length() + 1 + charsWritten > paragraphWidth)) {
                out << '\n' << linePrefix;
                charsWritten = 0;
            }
            if(charsWritten == 0) {
                out << word;
                charsWritten += word.length();
            } else {
                out << ' ' << word;
                charsWritten += word.length() + 1;
            }
        }
 
        if(!lss.eof())
            out << '\n';
    }
    return out;
}
 
}  // namespace detail
// [CLI11:string_tools_inl_hpp:end]
}  // namespace CLI