utf.h

Go to the documentation of this file.

 
#pragma once
 
#include <iomanip>
#include <regex>
#include <cstdint>
#include <iostream>
 
#include "BashSpark/tools/fakestream.h"
 
namespace bs {
    constexpr char32_t combine_surrogates(const char16_t high, const char16_t low) {
        return ((static_cast<char32_t>(high) - 0xD800) << 10
                | static_cast<char32_t>(low) - 0xDC00) + 0x10000;
    }
 
    inline std::string to_hex_string(const char32_t cChar, const std::size_t nLength) {
        std::ostringstream oStream;
        if (nLength == 1) oStream.write("\\x", 2);
        if (nLength == 2) oStream.write("\\u", 2);
        if (nLength == 4) oStream.write("\\U", 2);
        oStream << std::hex << std::setfill('0')
                << std::setw(static_cast<std::ostream::int_type>(nLength))
                << static_cast<std::uint32_t>(cChar);
        return oStream.str();
    }
 
    inline void write_char32_t(ofakestream &oStream, const char32_t cChar) {
        if (cChar <= 0x7F) {
            // 1 byte (ASCII range)
            oStream.put(static_cast<char>(cChar));
        } else if (cChar <= 0x7FF) {
            // 2 bytes
            oStream.put(static_cast<char>(cChar >> 6 | 0xC0));
            oStream.put(static_cast<char>(cChar & 0x3F | 0x80));
        } else if (cChar <= 0xFFFF) {
            // 3 bytes
            oStream.put(static_cast<char>(cChar >> 12 | 0xE0));
            oStream.put(static_cast<char>(cChar >> 6 & 0x3F | 0x80));
            oStream.put(static_cast<char>(cChar & 0x3F | 0x80));
        } else if (cChar <= 0x10FFFF) {
            // 4 bytes
            oStream.put(static_cast<char>(cChar >> 18 | 0xF0));
            oStream.put(static_cast<char>(cChar >> 12 & 0x3F | 0x80));
            oStream.put(static_cast<char>(cChar >> 6 & 0x3F | 0x80));
            oStream.put(static_cast<char>(cChar & 0x3F | 0x80));
        }
    }
 
    inline std::string write_char32_t(const char32_t cChar) {
        ofakestream oStream;
        write_char32_t(oStream, cChar);
        return oStream.str();
    }
 
    inline bool parse_utf(ifakestream &oIstream, const std::size_t nCount, char32_t &cResult) {
        // Read
        std::string sValue(nCount * 2, '\0');
        oIstream.read(sValue.data(), nCount * 2);
 
        // Check hex
        static std::regex oRegex("^[0-9A-Fa-f]+$");
        if (!std::regex_match(sValue, oRegex))
            return false;
        auto cChar = static_cast<char32_t>(std::stoull(sValue, nullptr, 16));
 
        switch (nCount) {
            case 1: {
                if (cChar > 0x7F)
                    return false;
                break;
            }
            case 2: {
                // Deal with surrogates
                if (cChar >= 0xD800 && cChar <= 0xDBFF) {
                    if (oIstream.get() != '\\') return false;
                    if (oIstream.get() != 'u') return false;
 
                    // Load other surrogate and check regex
                    oIstream.read(sValue.data(), nCount * 2);
                    if (!std::regex_match(sValue, oRegex))
                        return false;
 
                    const auto cLow = static_cast<char32_t>(std::stoull(sValue, nullptr, 16));
                    if (cLow < 0xDC00 || cLow > 0xDFFF)
                        return false;
 
                    cChar = combine_surrogates(
                        static_cast<char16_t>(cChar),
                        static_cast<char16_t>(cLow)
                    );
                } else if (cChar >= 0xDC00) {
                    // High surrogates and above
                    return false;
                }
                break;
            }
 
            case 4: {
                if ((cChar >= 0xD800 && cChar <= 0xDFFF) || cChar > 0x10FFFF)
                    return false;
                break;
            }
 
            default: break;
        }
 
        cResult = cChar;
        return true;
    }
}