StrIntFormat

Documentation

API Reference

StrIntFormat

Description

Configuration for integer formatting

Usage example (Cross-references)

Usage examples (Cross-references)

In Io.c:1076:

            if (fmt_info->flags & FMT_FLAG_HEX) {
                // Format each character as hex
                StrIntFormat config = {.base = 16, .uppercase = (fmt_info->flags & FMT_FLAG_CAPS) != 0};
                StrForeachIdx(s, c, i) {
                    if (i > 0) {

In Io.c:1152:

                    // Create hex string for each character
                    Str          hex    = StrInit();
                    StrIntFormat config = {.base = 16, .uppercase = (fmt_info->flags & FMT_FLAG_CAPS) != 0};
                    StrFromU64(&hex, (u8)xs[i], &config);
                    // Ensure 2 digits with leading zero

In Io.c:1232:

        // Use StrFromU64 directly with the appropriate base
        bool         use_prefix = (base != 10); // Add prefix for non-decimal bases
        StrIntFormat config = {.base = base, .uppercase = (fmt_info->flags & FMT_FLAG_CAPS) != 0, .use_prefix = use_prefix};
        StrFromU64(&temp, *v, &config);

In Io.c:1324:

        // Use StrFromI64 directly with the appropriate base
        bool         use_prefix = (base != 10); // Add prefix for non-decimal bases
        StrIntFormat config = {.base = base, .uppercase = (fmt_info->flags & FMT_FLAG_CAPS) != 0, .use_prefix = use_prefix};
        StrFromI64(&temp, *v, &config);

In Io.c:2576:

                // Convert to integer (up to 64 bits) and format as hex
                u64          value  = BitVecToInteger(bv);
                StrIntFormat config = {.base = 16, .uppercase = (fmt_info->flags & FMT_FLAG_CAPS) != 0, .use_prefix = true};
                StrFromU64(o, value, &config);
            }

In Io.c:2585:

            } else {
                u64          value  = BitVecToInteger(bv);
                StrIntFormat config = {.base = 8, .uppercase = false, .use_prefix = true};
                StrFromU64(o, value, &config);
            }

In Str.c:329:

    // ======================================
    
    Str *StrFromU64(Str *str, u64 value, const StrIntFormat *config) {
        ValidateStr(str);

In Str.c:376:

    }
    
    Str *StrFromI64(Str *str, i64 value, const StrIntFormat *config) {
        ValidateStr(str);

In Str.c:874:

    
    // Default configurations
    const StrIntFormat STR_INT_DEFAULT =
        {.base = 10, .uppercase = false, .use_prefix = false, .pad_zeros = false, .min_width = 0};

In Str.Convert.c:34:

    
        // Test decimal conversion
        StrIntFormat config = {.base = 10, .uppercase = false};
        StrFromU64(&s, 12345, &config);
        bool result = (ZstrCompare(s.data, "12345") == 0);

In Str.Convert.c:43:

        // Test hexadecimal conversion (lowercase)
        StrClear(&s);
        config = (StrIntFormat) {.base = 16, .uppercase = false, .use_prefix = true};
        StrFromU64(&s, 0xABCD, &config);
        result = result && (ZstrCompare(s.data, "0xabcd") == 0);

In Str.Convert.c:52:

        // Test hexadecimal conversion (uppercase)
        StrClear(&s);
        config = (StrIntFormat) {.base = 16, .uppercase = true, .use_prefix = true};
        StrFromU64(&s, 0xABCD, &config);
        result = result && (ZstrCompare(s.data, "0xABCD") == 0);

In Str.Convert.c:61:

        // Test binary conversion
        StrClear(&s);
        config = (StrIntFormat) {.base = 2, .uppercase = false, .use_prefix = true};
        StrFromU64(&s, 42, &config);
        result = result && (ZstrCompare(s.data, "0b101010") == 0);

In Str.Convert.c:70:

        // Test octal conversion
        StrClear(&s);
        config = (StrIntFormat) {.base = 8, .uppercase = false, .use_prefix = true};
        StrFromU64(&s, 42, &config);
        result = result && (ZstrCompare(s.data, "0o52") == 0);

In Str.Convert.c:79:

        // Test zero
        StrClear(&s);
        config = (StrIntFormat) {.base = 10, .uppercase = false};
        StrFromU64(&s, 0, &config);
        result = result && (ZstrCompare(s.data, "0") == 0);

In Str.Convert.c:97:

    
        // Test positive decimal conversion
        StrIntFormat config = {.base = 10, .uppercase = false};
        StrFromI64(&s, 12345, &config);
        bool result = (ZstrCompare(s.data, "12345") == 0);

In Str.Convert.c:106:

        // Test negative decimal conversion (only decimal supports negative sign)
        StrClear(&s);
        config = (StrIntFormat) {.base = 10, .uppercase = false};
        StrFromI64(&s, -12345, &config);
        result = result && (ZstrCompare(s.data, "-12345") == 0);

In Str.Convert.c:115:

        // Test hexadecimal conversion of negative number (negative non-decimal treated as unsigned)
        StrClear(&s);
        config = (StrIntFormat) {.base = 16, .uppercase = false, .use_prefix = true};
        StrFromI64(&s, -0xABCD, &config);
        // For negative numbers in non-decimal bases, it uses unsigned representation

In Str.Convert.c:126:

        // Test zero
        StrClear(&s);
        config = (StrIntFormat) {.base = 10, .uppercase = false};
        StrFromI64(&s, 0, &config);
        result = result && (ZstrCompare(s.data, "0") == 0);

In Str.Convert.c:135:

        // Test binary conversion
        StrClear(&s);
        config = (StrIntFormat) {.base = 2, .uppercase = false, .use_prefix = true};
        StrFromI64(&s, 42, &config);
        result = result && (ZstrCompare(s.data, "0b101010") == 0);

In Str.Convert.c:416:

    
            // Test decimal round-trip
            StrIntFormat config = {.base = 10, .uppercase = false};
            StrFromU64(&s, u64_values[i], &config);
            u64  recovered_u64 = 0;

In Str.Convert.c:424:

            // Test hex round-trip
            StrClear(&s);
            config = (StrIntFormat) {.base = 16, .uppercase = false, .use_prefix = true};
            StrFromU64(&s, u64_values[i], &config);
            recovered_u64 = 0;

In Str.Convert.c:437:

    
            // Test decimal round-trip
            StrIntFormat config = {.base = 10, .uppercase = false};
            StrFromI64(&s, i64_values[i], &config);
            i64  recovered_i64 = 0;

In Str.Convert.c:480:

    
            // Test with base value itself
            StrIntFormat config = {.base = base, .uppercase = false, .use_prefix = (base == 2 || base == 8 || base == 16)};
            StrFromU64(&s, base, &config);
            u64 recovered = 0;

In Str.Convert.c:496:

    
        // Test maximum u64
        StrIntFormat config = {.base = 10, .uppercase = false};
        StrFromU64(&s, UINT64_MAX, &config);
        u64  recovered_max = 0;

In Str.Convert.c:504:

        // Test minimum i64 (avoid INT64_MIN due to negation UB)
        StrClear(&s);
        config = (StrIntFormat) {.base = 10, .uppercase = false};
        StrFromI64(&s, INT64_MIN + 1, &config);
        i64 recovered_min = 0;

In Str.Convert.c:608:

            Str s = StrInit();
    
            StrIntFormat config = {.base = base, .uppercase = false};
            StrFromU64(&s, large_value, &config);
            u64            recovered = 0;

In Str.Convert.c:635:

    
            // Test StrFromU64
            StrIntFormat config = {.base = base, .uppercase = false, .use_prefix = false};
            StrFromU64(&s, test_value, &config);

In Str.Convert.c:652:

            Str s = StrInit();
    
            StrIntFormat config = {.base = base, .uppercase = true, .use_prefix = false};
            StrFromU64(&s, test_value, &config);

In Str.Convert.c:671:

                Str s = StrInit();
    
                StrIntFormat config = {.base = base, .uppercase = false, .use_prefix = false};
                StrFromU64(&s, test_values[i], &config);

In Str.Convert.c:702:

    
            Str          s      = StrInit();
            StrIntFormat config = {.base = 10, .uppercase = false};
            StrFromU64(&s, test_value, &config);

In Str.Convert.c:763:

    
        // Test NULL string pointer - should abort
        StrIntFormat config = {.base = 10, .uppercase = false};
        StrFromU64(NULL, 42, &config);

In Str.Convert.c:773:

    
        // Test StrFromI64 with NULL pointer - should abort
        StrIntFormat config = {.base = 10, .uppercase = false};
        StrFromI64(NULL, 42, &config);

In Convert.h:23:

            bool pad_zeros;  ///< Pad with leading zeros
            u8   min_width;  ///< Minimum field width
        } StrIntFormat;
    
        /// Configuration for float formatting

In Convert.h:42:

    
        /// Default configurations
        extern const StrIntFormat   STR_INT_DEFAULT;
        extern const StrFloatFormat STR_FLOAT_DEFAULT;
        extern const StrParseConfig STR_PARSE_DEFAULT;

In Convert.h:56:

        /// FAILURE : Returns NULL if config is invalid
        ///
        Str *StrFromU64(Str *str, u64 value, const StrIntFormat *config);
    
        ///

In Convert.h:68:

        /// FAILURE : Returns NULL if config is invalid
        ///
        Str *StrFromI64(Str *str, i64 value, const StrIntFormat *config);
    
        ///

Last updated on April 20, 2026

StrInsertZstr strip_str