ValidateStr

Function
October 8, 2025

Table of Contents

`ValidateStr`

Description

Validate whether a given Str object is valid. Not foolproof but will work most of the time. Aborts if provided Str is not valid.

Parameters

Name	Direction	Description
`s`	in	Pointer to `Str` object to validate.

Success

Continue execution, meaning given Str object is most probably valid.

Failure

abort

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 rogrammer/MisraStdC/blob/master/Source/Misra/Std/Io.c#L841 target=_blank>Io.c:841:
} ValidateStr(o); ValidateStr(s); Io.c:842:
ValidateStr(o); ValidateStr(s); // Store original length to calculate content size later Io.c:910:
} ValidateStr(o); // Store original length to calculate content size later Io.c:1315:
LOG_FATAL("Invalid arguments"); ValidateStr(s); // Check for case conversion flags Io.c:2301:
} ValidateStr(o); ValidateBitVec(bv); Str.c:20:
Str *StrPrintf(Str *str, const char *fmt, ...) { ValidateStr(str); StrClear(str); Str.c:33:
Str *StrAppendf(Str *str, const char *fmt, ...) { ValidateStr(str); va_list args; Str.c:44:
static Str *string_va_printf(Str *str, const char *fmt, va_list args) { ValidateStr(str); va_list args_copy; Str.c:71:
bool StrInitCopy(Str *dst, const Str *src) { ValidateStr(src); MemSet(dst, 0, sizeof(Str));Str.c:80:
VecMergeR(dst, src); ValidateStr(dst); return true; Str.c:86:
void StrDeinit(Str *copy) { ValidateStr(copy); if (copy->data) { FREE(copy->data); Str.c:94:
StrIters StrSplitToIters(Str *s, const char *key) { ValidateStr(s); StrIters sv = VecInit(); Str.c:119:
Strs StrSplit(Str *s, const char *key) { ValidateStr(s); Strs sv = VecInitWithDeepCopy(NULL, StrDeinit); Str.c:162:
// = 1 means from right style=color:#75715e> Str strip_str(Str *s, const char *chars_to_strip, int split_direction) { ValidateStr(s); const char *strip_chars = chars_to_strip ? chars_to_strip : " \t\n\r\v\f"; Str.c:195:
bool StrStartsWithZstr(const Str *s, const char *prefix) { ValidateStr(s); return starts_with(s->data, s->length, prefix, ZstrLen(prefix)); } Str.c:200:
bool StrEndsWithZstr(const Str *s, const char *suffix) { ValidateStr(s); return ends_with(s->data, s->length, suffix, ZstrLen(suffix)); } Str.c:205:
bool StrStartsWithCstr(const Str *s, const char *prefix, size prefix_len) { ValidateStr(s); return starts_with(s->data, s->length, prefix, prefix_len); } Str.c:210:
bool StrEndsWithCstr(const Str *s, const char *suffix, size suffix_len) { ValidateStr(s); return ends_with(s->data, s->length, suffix, suffix_len); } Str.c:215:
bool StrStartsWith(const Str *s, const Str *prefix) { ValidateStr(s); return starts_with(s->data, s->length, prefix->data, prefix->length); } Str.c:220:
bool StrEndsWith(const Str *s, const Str *suffix) { ValidateStr(s); return ends_with(s->data, s->length, suffix->data, suffix->length); } Str.c:227:
static void str_replace(Str *s, const char *match, size match_len, const char *replacement, size replacement_len, size count) { ValidateStr(s); size i = 0; size replaced = 0; Str.c:244:
void StrReplaceZstr(Str *s, const char *match, const char *replacement, size count) { ValidateStr(s); str_replace(s, match, ZstrLen(match), replacement, ZstrLen(replacement), count); } Str.c:256:
size count ) { ValidateStr(s); str_replace(s, match, match_len, replacement, replacement_len, count); } Str.c:261:
void StrReplace(Str *s, const Str *match, const Str *replacement, size count) { ValidateStr(s); str_replace(s, match->data, match->length, replacement->data, replacement->length, count); } Str.c:330:
Str *StrFromU64(Str *str, u64 value, const StrIntFormat *config) { ValidateStr(str); if (!config) { Str.c:377:
Str *StrFromI64(Str *str, i64 value, const StrIntFormat *config) { ValidateStr(str); if (!config) { Str.c:411:
Str *StrFromF64(Str *str, f64 value, const StrFloatFormat *config) { ValidateStr(str); if (!config) { Str.c:569:
bool StrToU64(const Str *str, u64 *value, const StrParseConfig *config) { ValidateStr(str); if (!value) { Str.c:659:
bool StrToI64(const Str *str, i64 *value, const StrParseConfig *config) { ValidateStr(str); if (!value) { Str.c:719:
bool StrToF64(const Str *str, f64 *value, const StrParseConfig *config) { ValidateStr(str); if (!value) { Str.c:858:
} void ValidateStr(const Str *s) { return ValidateVec(s); } Str.c:865:
ValidateVec(vs); VecForeachPtr(vs, sp) { ValidateStr(sp); } } Str.Type.c:72:
// Test ValidateStr macro style=color:#75715e> bool test_validate_str(void) { WriteFmt("Testing ValidateStr macro\n"); // Create a valid Str Str.Type.c:78:
// This should not crash style=color:#75715e> ValidateStr(&s); // Note: We can't really test invalid strings here as ValidateStr Str.Type.c:111:
// Deadend test: Test ValidateStr with invalid string (should crash/abort) style=color:#75715e> bool test_validate_invalid_str(void) { WriteFmt("Testing ValidateStr with invalid string (should abort)\n"); // Create an invalid Str by corrupting its fields Str.Type.c:122:
// This should abort the program style=color:#75715e> ValidateStr(&s); // Should never reach here Str.Init.c:28:
// Validate the string style=color:#75715e> ValidateStr(&s); // Check that it's initialized correctly Str.Init.c:47:
// Validate the string style=color:#75715e> ValidateStr(&s); // Check that it's initialized correctly Str.Init.c:64:
// Validate the string style=color:#75715e> ValidateStr(&s); // Check that it's initialized correctly Str.Init.c:81:
// Validate both strings style=color:#75715e> ValidateStr(&src); ValidateStr(&dst); Str.Init.c:82:
// Validate both strings style=color:#75715e> ValidateStr(&src); ValidateStr(&dst); // Check that dst is initialized correctly Str.Init.c:100:
// Validate both strings style=color:#75715e> ValidateStr(&src); ValidateStr(&dst); Str.Init.c:101:

    // Validate both strings style=color:#75715e>    ValidateStr(&src); ValidateStr(&dst);

// Check that dst is initialized correctly Str.Init.c:119:

 // Validate the string style=color:#75715e>    ValidateStr(&s);

// Check that it's initialized correctly Str.Init.c:141: // Validate the string style=color:#75715e>    ValidateStr(&stack_str);

// Check that it works correctly Str.Init.c:173: // Validate both strings style=color:#75715e>    ValidateStr(&src); ValidateStr(&dst); Str.Init.c:174:    // Validate both strings style=color:#75715e>    ValidateStr(&src); ValidateStr(&dst);

// Check that the copy was successful Str.Init.c:191: // Validate the string before deinit style=color:#75715e>    ValidateStr(&s);

// Deinit the string Str.c:617: case STR_VALIDATE : { ValidateStr(str); break; }
Share :