env.cpp

Go to the documentation of this file.

// -------------------------------------------------------//
//
// SHAMROCK code for hydrodynamics
// Copyright (c) 2021-2026 Timothée David--Cléris <tim.shamrock@proton.me>
// SPDX-License-Identifier: CeCILL Free Software License Agreement v2.1
// Shamrock is licensed under the CeCILL 2.1 License, see LICENSE for more information
//
// -------------------------------------------------------//

 
#include "sham/term/env.hpp"
#include "sham/term/color.hpp"
#include "sham/term/tty.hpp"
#include <string_view>
#include <cctype>
#include <vector>
 
namespace {

    static const std::vector<std::string_view> basic_color_term{
        "xterm", "vt100", "color", "ansi", "cygwin", "linux"};

    static const std::vector<std::string_view> ansi256_color_term{"xterm-256", "xterm-256color"};

    static const std::vector<std::string_view> truecolor_term{
        "xterm-truecolor", "xterm-direct", "xterm-kitty", "alacritty"};

    bool string_contains_ci(std::string_view haystack, std::string_view needle) {
        if (needle.size() > haystack.size()) {
            return false;
        }
        for (size_t i = 0; i + needle.size() <= haystack.size(); ++i) {
            bool match = true;
            for (size_t j = 0; j < needle.size(); ++j) {
                if (std::tolower(static_cast<unsigned char>(haystack[i + j]))
                    != std::tolower(static_cast<unsigned char>(needle[j]))) {
                    match = false;
                    break;
                }
            }
            if (match) {
                return true;
            }
        }
        return false;
    }

    bool contains_utf8_marker(std::string_view value) {
        return string_contains_ci(value, "utf-8") || string_contains_ci(value, "utf8");
    }

    bool term_support_utf8(sham::term::TermEnvVars vars) {
        if (vars.lc_all) {
            return contains_utf8_marker(*vars.lc_all);
        }
        if (vars.lc_ctype) {
            return contains_utf8_marker(*vars.lc_ctype);
        }
        if (vars.LANG) {
            return contains_utf8_marker(*vars.LANG);
        }
        return false;
    }
 
} // namespace
 
namespace sham::term {
 
    ColorLevel detect_color_level(TermEnvVars vars) {
 
        if (vars.COLORTERM) {
            if (*vars.COLORTERM == "truecolor" || *vars.COLORTERM == "24bit") {
                return ColorLevel::TrueColor;
            }
        }
 
        if (vars.TERM) {
            for (auto term : truecolor_term) {
                if (*vars.TERM == term) {
                    return ColorLevel::TrueColor;
                }
            }
            for (auto term : ansi256_color_term) {
                if (*vars.TERM == term) {
                    return ColorLevel::ANSI256;
                }
            }
            for (auto term : basic_color_term) {
                if (*vars.TERM == term) {
                    return ColorLevel::Basic;
                }
            }
        }
 
        return ColorLevel::NoColor;
    }
 
    void parse_terminal_support(TermEnvVars vars, const term_parse_callback_t &error_callback) {
        sham::term::set_color_level(detect_color_level(vars));
 
        bool has_envvar_nocolor = bool(vars.NO_COLOR);
        bool has_envvar_color   = bool(vars.CLICOLOR_FORCE);
 
        if (has_envvar_color && has_envvar_nocolor) {
            throw error_callback(
                "one can not set both NO_COLOR and CLICOLOR_FORCE",
                std::source_location::current());
        }
 
        if (has_envvar_nocolor) {
            disable_colors();
        }
 
        if (has_envvar_color) {
            enable_colors();
        }
 
        sham::term::set_support_utf8(term_support_utf8(vars));
 
        bool has_envvar_no_utf8    = bool(vars.NO_UTF8);
        bool has_envvar_force_utf8 = bool(vars.FORCE_UTF8);
 
        if (has_envvar_no_utf8 && has_envvar_force_utf8) {
            throw error_callback(
                "one can not set both NO_UTF8 and FORCE_UTF8", std::source_location::current());
        }
 
        if (has_envvar_no_utf8) {
            sham::term::set_support_utf8(false);
        }
 
        if (has_envvar_force_utf8) {
            sham::term::set_support_utf8(true);
        }
 
        auto &res = vars.COLUMN;
 
        int min_sz = 10;
        if (res) {
            try {
                int val = std::stoi(std::string(*res));
                if (val < min_sz) {
                    val = min_sz;
                }
                sham::term::set_tty_columns(val);
            } catch (const std::invalid_argument &a) {
                throw error_callback(
                    "Error : COLUMN is not an integer", std::source_location::current());
            } catch (const std::out_of_range &a) {
                throw error_callback(
                    "Error : COLUMN is out of range", std::source_location::current());
            }
        }
    }
 
} // namespace sham::term