format_integer()

template<typename T>

fl::string fl::format_detail::format_integer	(	T	value,
		const FormatSpec &	spec )

Definition at line 165 of file format.h.

                                                         {
    char buf[68]; // Enough for 64-bit binary + prefix
    char* p = buf + sizeof(buf);
    *--p = '\0';
 
    bool negative = false;
    using UnsignedT = typename fl::make_unsigned<T>::type;
    UnsignedT uval;
 
    if (fl::is_signed<T>::value && value < 0) {
        negative = true;
        uval = static_cast<UnsignedT>(-(value + 1)) + 1; // Safe negation
    } else {
        uval = static_cast<UnsignedT>(value);
    }
 
    char type = spec.type ? spec.type : 'd';
    int base = 10;
    const char* digits = "0123456789abcdef";
 
    switch (type) {
        case 'b': case 'B': base = 2; break;
        case 'o': base = 8; break;
        case 'x': base = 16; digits = "0123456789abcdef"; break;
        case 'X': base = 16; digits = "0123456789ABCDEF"; break;
        case 'c': {
            // Character output
            char ch = static_cast<char>(value);
            return fl::string(&ch, 1);
        }
        default: base = 10; break;
    }
 
    // Convert to string (in reverse)
    if (uval == 0) {
        *--p = '0';
    } else {
        while (uval > 0) {
            *--p = digits[uval % base];
            uval /= base;
        }
    }
 
    // Build prefix
    fl::string prefix;
    if (negative) {
        prefix.append('-');
    } else if (spec.sign == '+') {
        prefix.append('+');
    } else if (spec.sign == ' ') {
        prefix.append(' ');
    }
 
    if (spec.alternate && base != 10) {
        if (base == 16) {
            prefix.append('0');
            prefix.append('x');  // Always lowercase 'x' in prefix (digits control case)
        } else if (base == 2) {
            prefix.append('0');
            prefix.append('b');  // Always lowercase 'b' in prefix
        } else if (base == 8 && *p != '0') {
            prefix.append('0');
        }
    }
 
    fl::string num_str(p);
 
    // Handle zero padding
    if (spec.zero_pad && spec.width > 0) {
        int num_width = spec.width - static_cast<int>(prefix.size());
        if (num_width > static_cast<int>(num_str.size())) {
            fl::string padded;
            for (int i = 0; i < num_width - static_cast<int>(num_str.size()); ++i) {
                padded.append('0');
            }
            padded.append(num_str);
            return fl::string(prefix) += padded;
        }
    }
 
    return fl::string(prefix) += num_str;
}

References fl::format_detail::FormatSpec::alternate, fl::string::append(), fl::numeric_limits< char >::digits, fl::format_detail::FormatSpec::sign, fl::basic_string::size(), fl::format_detail::FormatSpec::type, fl::type_rank< T >::value, fl::fl::is_signed< T >::value, fl::format_detail::FormatSpec::width, and fl::format_detail::FormatSpec::zero_pad.

Referenced by fl::format_detail::FormatArg::format(), and format_pointer().

Here is the call graph for this function:

Here is the caller graph for this function: