StrClear

Macro
August 22, 2025

Table of Contents

`StrClear`

Description

Set string length to 0.

Parameters

Name	Direction	Description
`vec`	in,out	Str to be cleared.

Failure

NULL

Usage example (Cross-references)

In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In rogrammer/MisraStdC/blob/master/Source/Misra/Parsers/JSON.c#L200 target=_blank>JSON.c:200:
if (!StrIterRemainingLength(&si)) { LOG_ERROR("Unexpected end of string."); StrClear(str); return saved_si; } JSON.c:257:
default : LOG_ERROR("Invalid JSON object key string."); StrClear(str); return saved_si; } Str.c:22:
ValidateStr(str); StrClear(str); va_list args; Str.c:340:
} StrClear(str); // Add prefix if requested Str.c:421:
} StrClear(str); // Handle special cases MisraEnum.c:104:
}); StrClear(&code); // Use a temporary variable for enum name Str.Convert.c:42:
// Test hexadecimal conversion (lowercase) style=color:#75715e> StrClear(&s); config = (StrIntFormat) {.base = 16, .uppercase = false, .use_prefix = true}; StrFromU64(&s, 0xABCD, &config); Str.Convert.c:51:
// Test hexadecimal conversion (uppercase) style=color:#75715e> StrClear(&s); config = (StrIntFormat) {.base = 16, .uppercase = true, .use_prefix = true}; StrFromU64(&s, 0xABCD, &config); Str.Convert.c:60:
// Test binary conversion style=color:#75715e> StrClear(&s); config = (StrIntFormat) {.base = 2, .uppercase = false, .use_prefix = true}; StrFromU64(&s, 42, &config); Str.Convert.c:69:
// Test octal conversion style=color:#75715e> StrClear(&s); config = (StrIntFormat) {.base = 8, .uppercase = false, .use_prefix = true}; StrFromU64(&s, 42, &config); Str.Convert.c:78:
// Test zero style=color:#75715e> StrClear(&s); config = (StrIntFormat) {.base = 10, .uppercase = false}; StrFromU64(&s, 0, &config); Str.Convert.c:105:
// Test negative decimal conversion (only decimal supports negative sign) style=color:#75715e> StrClear(&s); config = (StrIntFormat) {.base = 10, .uppercase = false}; StrFromI64(&s, -12345, &config); Str.Convert.c:114:
// Test hexadecimal conversion of negative number (negative non-decimal treated as unsigned) style=color:#75715e> StrClear(&s); config = (StrIntFormat) {.base = 16, .uppercase = false, .use_prefix = true}; StrFromI64(&s, -0xABCD, &config); Str.Convert.c:125:
// Test zero style=color:#75715e> StrClear(&s); config = (StrIntFormat) {.base = 10, .uppercase = false}; StrFromI64(&s, 0, &config); Str.Convert.c:134:
// Test binary conversion style=color:#75715e> StrClear(&s); config = (StrIntFormat) {.base = 2, .uppercase = false, .use_prefix = true}; StrFromI64(&s, 42, &config); Str.Convert.c:161:
// Test fractional conversion style=color:#75715e> StrClear(&s); config = (StrFloatFormat) {.precision = 3, .force_sci = false, .uppercase = false}; StrFromF64(&s, 123.456, &config); Str.Convert.c:170:
// Test negative number style=color:#75715e> StrClear(&s); config = (StrFloatFormat) {.precision = 3, .force_sci = false, .uppercase = false}; StrFromF64(&s, -123.456, &config); Str.Convert.c:176:
// Test scientific notation (forced) style=color:#75715e> StrClear(&s); config = (StrFloatFormat) {.precision = 3, .force_sci = true, .uppercase = false}; StrFromF64(&s, 123.456, &config); Str.Convert.c:182:
// Test scientific notation (uppercase) style=color:#75715e> StrClear(&s); config = (StrFloatFormat) {.precision = 3, .force_sci = true, .uppercase = true}; StrFromF64(&s, 123.456, &config); Str.Convert.c:188:
// Test very small number (auto scientific notation) style=color:#75715e> StrClear(&s); config = (StrFloatFormat) {.precision = 3, .force_sci = false, .uppercase = false}; StrFromF64(&s, 0.0000123, &config); Str.Convert.c:194:
// Test very large number (auto scientific notation) style=color:#75715e> StrClear(&s); config = (StrFloatFormat) {.precision = 2, .force_sci = false, .uppercase = false}; StrFromF64(&s, 1234567890123.0, &config); Str.Convert.c:200:
// Test zero style=color:#75715e> StrClear(&s); config = (StrFloatFormat) {.precision = 2, .force_sci = false, .uppercase = false}; StrFromF64(&s, 0.0, &config); Str.Convert.c:206:
// Test infinity style=color:#75715e> StrClear(&s); config = (StrFloatFormat) {.precision = 2, .force_sci = false, .uppercase = false}; StrFromF64(&s, INFINITY, &config); Str.Convert.c:212:
// Test negative infinity style=color:#75715e> StrClear(&s); config = (StrFloatFormat) {.precision = 2, .force_sci = false, .uppercase = false}; StrFromF64(&s, -INFINITY, &config); Str.Convert.c:218:
// Test NaN style=color:#75715e> StrClear(&s); config = (StrFloatFormat) {.precision = 2, .force_sci = false, .uppercase = false}; StrFromF64(&s, NAN, &config); Str.Convert.c:423:
// Test hex round-trip style=color:#75715e> StrClear(&s); config = (StrIntFormat) {.base = 16, .uppercase = false, .use_prefix = true}; StrFromU64(&s, u64_values[i], &config); Str.Convert.c:503:
// Test minimum i64 (avoid INT64_MIN due to negation UB) style=color:#75715e> StrClear(&s); config = (StrIntFormat) {.base = 10, .uppercase = false}; StrFromI64(&s, INT64_MIN + 1, &config); Str.Convert.c:511:
// Test very small floating point style=color:#75715e> StrClear(&s); StrFloatFormat fconfig = {.precision = 3, .force_sci = false, .uppercase = false}; StrFromF64(&s, 1e-300, &fconfig); Str.Convert.c:519:
// Test very large floating point style=color:#75715e> StrClear(&s); fconfig = (StrFloatFormat) {.precision = 3, .force_sci = false, .uppercase = false}; StrFromF64(&s, 1e300, &fconfig); Str.Convert.c:593:
// Test uppercase E style=color:#75715e> StrClear(&s); config = (StrFloatFormat) {.precision = 3, .force_sci = true, .uppercase = true}; StrFromF64(&s, sci_values[i], &config); Str.Memory.c:117:
// Test StrClear function style=color:#75715e> bool test_str_clear(void) { printf("Testing StrClear\n"); Str s = StrInitFromZstr("Hello, World!"); Str.Memory.c:125:
// Clear the string style=color:#75715e> StrClear(&s); // Length should now be 0, but capacity should remain Io.Write.c:39:
StrWriteFmt(&output, ""); success = success && (output.length == 0); StrClear(&output); // Test literal text Io.Write.c:44:
StrWriteFmt(&output, "Hello, world!"); success = success && (ZstrCompare(output.data, "Hello, world!") == 0); StrClear(&output); // Test escaped braces Io.Write.c:49:
StrWriteFmt(&output, "{{Hello}}"); success = success && (ZstrCompare(output.data, "{Hello}") == 0); StrClear(&output); // Test double escaped braces Io.Write.c:70:
StrWriteFmt(&output, "{}", str); success = success && (ZstrCompare(output.data, "Hello") == 0); StrClear(&output); // Test empty string Io.Write.c:76:
StrWriteFmt(&output, "{}", empty); success = success && (output.length == 0); StrClear(&output); // Test string with width and alignment Io.Write.c:81:
StrWriteFmt(&output, "{>10}", str); success = success && (ZstrCompare(output.data, " Hello") == 0); StrClear(&output); StrWriteFmt(&output, "{<10}", str); Io.Write.c:85:
StrWriteFmt(&output, "{<10}", str); success = success && (ZstrCompare(output.data, "Hello ") == 0); StrClear(&output); StrWriteFmt(&output, "{^10}", str); Io.Write.c:89:
StrWriteFmt(&output, "{^10}", str); success = success && (ZstrCompare(output.data, " Hello ") == 0); StrClear(&output); // Test Str object Io.Write.c:112:
StrWriteFmt(&output, "{}", i8_val); success = success && (ZstrCompare(output.data, "-42") == 0); StrClear(&output); i16 i16_val = -1234; Io.Write.c:117:
StrWriteFmt(&output, "{}", i16_val); success = success && (ZstrCompare(output.data, "-1234") == 0); StrClear(&output); i32 i32_val = -123456; Io.Write.c:122:
StrWriteFmt(&output, "{}", i32_val); success = success && (ZstrCompare(output.data, "-123456") == 0); StrClear(&output); i64 i64_val = -1234567890LL; Io.Write.c:127:
StrWriteFmt(&output, "{}", i64_val); success = success && (ZstrCompare(output.data, "-1234567890") == 0); StrClear(&output); // Test unsigned integers Io.Write.c:133:
StrWriteFmt(&output, "{}", u8_val); success = success && (ZstrCompare(output.data, "42") == 0); StrClear(&output); u16 u16_val = 1234; Io.Write.c:138:
StrWriteFmt(&output, "{}", u16_val); success = success && (ZstrCompare(output.data, "1234") == 0); StrClear(&output); u32 u32_val = 123456; Io.Write.c:143:
StrWriteFmt(&output, "{}", u32_val); success = success && (ZstrCompare(output.data, "123456") == 0); StrClear(&output); u64 u64_val = 1234567890ULL; Io.Write.c:148:
StrWriteFmt(&output, "{}", u64_val); success = success && (ZstrCompare(output.data, "1234567890") == 0); StrClear(&output); // Test edge cases Io.Write.c:154:
StrWriteFmt(&output, "{}", i8_max); success = success && (ZstrCompare(output.data, "127") == 0); StrClear(&output); i8 i8_min = -128; Io.Write.c:159:
StrWriteFmt(&output, "{}", i8_min); success = success && (ZstrCompare(output.data, "-128") == 0); StrClear(&output); u8 u8_max = 255; Io.Write.c:164:
StrWriteFmt(&output, "{}", u8_max); success = success && (ZstrCompare(output.data, "255") == 0); StrClear(&output); u8 u8_min = 0; Io.Write.c:184:
StrWriteFmt(&output, "{x}", val); success = success && (ZstrCompare(output.data, "0xdeadbeef") == 0); StrClear(&output); StrWriteFmt(&output, "{X}", val); Io.Write.c:233:
StrWriteFmt(&output, "{}", f32_val); success = success && (ZstrCompare(output.data, "3.141590") == 0); StrClear(&output); f64 f64_val = 2.71828; Io.Write.c:255:
StrWriteFmt(&output, "{.2}", val); success = success && (ZstrCompare(output.data, "3.14") == 0); StrClear(&output); StrWriteFmt(&output, "{.0}", val); Io.Write.c:259:
StrWriteFmt(&output, "{.0}", val); success = success && (ZstrCompare(output.data, "3") == 0); StrClear(&output); StrWriteFmt(&output, "{.10}", val); Io.Write.c:279:
StrWriteFmt(&output, "{}", pos_inf); success = success && (ZstrCompare(output.data, "inf") == 0); StrClear(&output); f64 neg_inf = -INFINITY; Io.Write.c:284:
StrWriteFmt(&output, "{}", neg_inf); success = success && (ZstrCompare(output.data, "-inf") == 0); StrClear(&output); // Test NaN Io.Write.c:306:
StrWriteFmt(&output, "{5}", val); success = success && (ZstrCompare(output.data, " 42") == 0); StrClear(&output); StrWriteFmt(&output, "{<5}", val); Io.Write.c:310:
StrWriteFmt(&output, "{<5}", val); success = success && (ZstrCompare(output.data, "42 ") == 0); StrClear(&output); StrWriteFmt(&output, "{^5}", val); Io.Write.c:314:
StrWriteFmt(&output, "{^5}", val); success = success && (ZstrCompare(output.data, " 42 ") == 0); StrClear(&output); // Test with strings Io.Write.c:320:
StrWriteFmt(&output, "{5}", str); success = success && (ZstrCompare(output.data, " abc") == 0); StrClear(&output); StrWriteFmt(&output, "{<5}", str); Io.Write.c:324:
StrWriteFmt(&output, "{<5}", str); success = success && (ZstrCompare(output.data, "abc ") == 0); StrClear(&output); StrWriteFmt(&output, "{^5}", str); Io.Write.c:346:
StrWriteFmt(&output, "{} {} {}", hello, num, pi); success = success && (ZstrCompare(output.data, "Hello 42 3.140000") == 0); StrClear(&output); // Instead of using positional arguments, we'll just reorder the arguments themselves Io.Write.c:367:
StrWriteFmt(&output, "{c}", mixed_case); success = success && (ZstrCompare(output.data, "MiXeD CaSe") == 0); StrClear(&output); // Test mixed case string with :a (lowercase) Io.Write.c:372:
StrWriteFmt(&output, "{a}", mixed_case); success = success && (ZstrCompare(output.data, "mixed case") == 0); StrClear(&output); // Test mixed case string with :A (uppercase) Io.Write.c:377:
StrWriteFmt(&output, "{A}", mixed_case); success = success && (ZstrCompare(output.data, "MIXED CASE") == 0); StrClear(&output); // Test with Str object Io.Write.c:385:
StrWriteFmt(&output, "{c}", s); success = success && (ZstrCompare(output.data, "MiXeD CaSe") == 0); StrClear(&output); // Test with :a (lowercase) Io.Write.c:390:
StrWriteFmt(&output, "{a}", s); success = success && (ZstrCompare(output.data, "mixed case") == 0); StrClear(&output); // Test with :A (uppercase) Io.Write.c:395:

    StrWriteFmt(&output, "{A}", s); success = success && (ZstrCompare(output.data, "MIXED CASE") == 0); StrClear(&output);

// Test with character values (u8) Io.Write.c:404:

    StrWriteFmt(&output, "{c}", upper_char); success = success && (ZstrCompare(output.data, "M") == 0); StrClear(&output);

// Test uppercase char with :a (lowercase) Io.Write.c:409:

    StrWriteFmt(&output, "{a}", upper_char); success = success && (ZstrCompare(output.data, "m") == 0); StrClear(&output);

// Test lowercase char with :A (uppercase) Io.Write.c:414:

    StrWriteFmt(&output, "{A}", lower_char); success = success && (ZstrCompare(output.data, "M") == 0); StrClear(&output);

// Test with u16 (containing ASCII values) Io.Write.c:422:

    StrWriteFmt(&output, "{c}", u16_value); success = success && (output.length == 2 && output.data[0] == 'A' && output.data[1] == 'B'); StrClear(&output);

// Test u16 with :a (lowercase) Io.Write.c:427:

    StrWriteFmt(&output, "{a}", u16_value); success = success && (output.length == 2 && output.data[0] == 'a' && output.data[1] == 'b'); StrClear(&output);

// Test u16 with :A (uppercase) Io.Write.c:432:

    StrWriteFmt(&output, "{A}", u16_value); success = success && (output.length == 2 && output.data[0] == 'A' && output.data[1] == 'B'); StrClear(&output);

// Test with i16 (containing ASCII values) Io.Write.c:440:

    StrWriteFmt(&output, "{c}", i16_value); success = success && (output.length == 2 && output.data[0] == 'C' && output.data[1] == 'd'); StrClear(&output);

// Test i16 with :a (lowercase) Io.Write.c:445:

    StrWriteFmt(&output, "{a}", i16_value); success = success && (output.length == 2 && output.data[0] == 'c' && output.data[1] == 'd'); StrClear(&output);

// Test i16 with :A (uppercase) Io.Write.c:450:

    StrWriteFmt(&output, "{A}", i16_value); success = success && (output.length == 2 && output.data[0] == 'C' && output.data[1] == 'D'); StrClear(&output);

// Test with u32 (containing ASCII values) Io.Write.c:459:

    success = success && (output.length == 4 && output.data[0] == 'E' && output.data[1] == 'f' && output.data[2] == 'G' && output.data[3] == 'h'); StrClear(&output);

// Test u32 with :a (lowercase) Io.Write.c:465:

    success = success && (output.length == 4 && output.data[0] == 'e' && output.data[1] == 'f' && output.data[2] == 'g' && output.data[3] == 'h'); StrClear(&output);

// Test u32 with :A (uppercase) Io.Write.c:471:

    success = success && (output.length == 4 && output.data[0] == 'E' && output.data[1] == 'F' && output.data[2] == 'G' && output.data[3] == 'H'); StrClear(&output);

// Test with i32 (containing ASCII values) Io.Write.c:480:

    success = success && (output.length == 4 && output.data[0] == 'I' && output.data[1] == 'j' && output.data[2] == 'K' && output.data[3] == 'l'); StrClear(&output);

// Test i32 with :a (lowercase) Io.Write.c:486:

    success = success && (output.length == 4 && output.data[0] == 'i' && output.data[1] == 'j' && output.data[2] == 'k' && output.data[3] == 'l'); StrClear(&output);

// Test i32 with :A (uppercase) Io.Write.c:492:

    success = success && (output.length == 4 && output.data[0] == 'I' && output.data[1] == 'J' && output.data[2] == 'K' && output.data[3] == 'L'); StrClear(&output);

// Test with u64 (containing ASCII values) Io.Write.c:503:

    output.data[2] == 'O' && output.data[3] == 'p' && output.data[4] == 'Q' && output.data[5] == 'r' && output.data[6] == 'S' && output.data[7] == 't'); StrClear(&output);

// Test u64 with :a (lowercase) Io.Write.c:510:

    output.data[2] == 'o' && output.data[3] == 'p' && output.data[4] == 'q' && output.data[5] == 'r' && output.data[6] == 's' && output.data[7] == 't'); StrClear(&output);

// Test u64 with :A (uppercase) Io.Write.c:517:

    output.data[2] == 'O' && output.data[3] == 'P' && output.data[4] == 'Q' && output.data[5] == 'R' && output.data[6] == 'S' && output.data[7] == 'T'); StrClear(&output);

// Test with i64 (containing ASCII values) Io.Write.c:528:

    output.data[2] == 'W' && output.data[3] == 'x' && output.data[4] == 'Y' && output.data[5] == 'z' && output.data[6] == '1' && output.data[7] == '2'); StrClear(&output);

// Test i64 with :a (lowercase) Io.Write.c:535:

    output.data[2] == 'w' && output.data[3] == 'x' && output.data[4] == 'y' && output.data[5] == 'z' && output.data[6] == '1' && output.data[7] == '2'); StrClear(&output);

// Test i64 with :A (uppercase) Io.Write.c:559:

    StrWriteFmt(&output, "{}", bv1); success = success && (ZstrCompare(output.data, "10110") == 0); StrClear(&output);

// Test 2: Empty BitVec Io.Write.c:565:

    StrWriteFmt(&output, "{}", bv_empty); success = success && (output.length == 0); StrClear(&output);

// Test 3: Hex formatting Io.Write.c:571:

    StrWriteFmt(&output, "{x}", bv2); success = success && (ZstrCompare(output.data, "0xabcd") == 0); StrClear(&output);

// Test 4: Uppercase hex formatting Io.Write.c:576:

    StrWriteFmt(&output, "{X}", bv2); success = success && (ZstrCompare(output.data, "0xABCD") == 0); StrClear(&output);

// Test 5: Octal formatting Io.Write.c:582:

    StrWriteFmt(&output, "{o}", bv3); success = success && (ZstrCompare(output.data, "0o755") == 0); StrClear(&output);

// Test 6: Width and alignment Io.Write.c:587:

    StrWriteFmt(&output, "{>10}", bv1); success = success && (ZstrCompare(output.data, "     10110") == 0); StrClear(&output);

StrWriteFmt(&output, "{<10}", bv1); Io.Write.c:591:

    StrWriteFmt(&output, "{<10}", bv1); success = success && (ZstrCompare(output.data, "10110     ") == 0); StrClear(&output);

StrWriteFmt(&output, "{^10}", bv1); Io.Write.c:595:    StrWriteFmt(&output, "{^10}", bv1); success = success && (ZstrCompare(output.data, "  10110   ") == 0); StrClear(&output);

// Test 7: Zero value Io.Write.c:601:    StrWriteFmt(&output, "{x}", bv_zero); success = success && (ZstrCompare(output.data, "0x0") == 0); StrClear(&output);

StrWriteFmt(&output, "{o}", bv_zero); Io.Write.c:605:    StrWriteFmt(&output, "{o}", bv_zero); success = success && (ZstrCompare(output.data, "0o0") == 0); StrClear(&output);

// Cleanup Io.Read.c:290:    success      = success && (StrCmp(&s, &expected) == 0); StrDeinit(&expected); StrClear(&s);

// Test quoted string reading Io.Read.c:319:    success      = success && (StrCmp(&name, &expected) == 0); StrDeinit(&expected); StrClear(&name);

// Test with different order
Share :