common/utils/strutils.c

#include <string.h>
#include <ctype.h>
#include <stdbool.h>
#include <stdlib.h>
#include <stdarg.h>
#include "strutils.h"
#include "xmalloc.h"

/**
 * @brief Allocates a buffer and stores the left-trimmed string into it.
 */
char *str_ltrim(const char *restrict str)
{
    size_t length = strlen(str);

    if (length == 0)
    {
        return strdup(str);
    }

    char *outstr = xmalloc(length + 1);
    bool is_start = true;
    size_t j = 0;

    for (size_t i = 0; i < length; i++)
    {
        if (is_start && isspace(str[i]))
            continue;
        else if (is_start)
            is_start = false;

        outstr[j++] = str[i];
    }

    outstr[j] = 0;
    return outstr;
}

/**
 * @brief Allocates a buffer and stores the right-trimmed string into it.
 */
char *str_rtrim(const char *restrict str)
{
    size_t length = strlen(str);

    if (length == 0)
    {
        return strdup(str);
    }

    char *outstr = xmalloc(length + 1);
    size_t spaces = 0;

    for (size_t i = length;; i--)
    {
        if (str[i] == 0)
            continue;

        if (isspace(str[i]))
            spaces++;
        else
            break;

        if (i == 0)
            break;
    }

    for (size_t i = 0; i < (length - spaces); i++)
    {
        outstr[i] = str[i];
    }

    outstr[length - spaces] = 0;
    return outstr;
}

/**
 * @brief Allocates a buffer and stores the both right and left-trimmed string into it.
 */
char *str_trim(const char *restrict str)
{
    char *ltrimmed = str_ltrim(str);
    char *final = str_rtrim(ltrimmed);
    free(ltrimmed);
    return final;
}

bool str_starts_with(const char *restrict haystack, const char *restrict needle)
{
    size_t haystack_length = strlen(haystack);
    size_t needle_length = strlen(needle);

    if (haystack_length < needle_length)
    {
        return false;
    }

    for (size_t i = 0; i < needle_length; i++)
    {
        if (haystack[i] != needle[i])
        {
            return false;
        }
    }

    return true;
}

char *str_concat_varg(const char *start, ...)
{
    va_list args;
    char *buffer = strdup(start);
    size_t length = strlen(start);    

    va_start(args, start);

    while (true)
    {
        const char *part = va_arg(args, const char *);
        size_t part_length;
        
        if (part == NULL)
            break;

        part_length = strlen(part);
        length += part_length;
        buffer = xrealloc(buffer, length);
        strncat(buffer, part, part_length);
    }
    
    va_end(args);
    return buffer;
}
1	rakinar2	575	#include <string.h>
2			#include <ctype.h>
3			#include <stdbool.h>
4			#include <stdlib.h>
5			#include <stdarg.h>
6			#include "strutils.h"
7			#include "xmalloc.h"
8
9			/**
10			* @brief Allocates a buffer and stores the left-trimmed string into it.
11			*/
12			char str_ltrim(const char restrict str)
13			{
14			size_t length = strlen(str);
15
16			if (length == 0)
17			{
18			return strdup(str);
19			}
20
21			char *outstr = xmalloc(length + 1);
22			bool is_start = true;
23			size_t j = 0;
24
25			for (size_t i = 0; i < length; i++)
26			{
27			if (is_start && isspace(str[i]))
28			continue;
29			else if (is_start)
30			is_start = false;
31
32			outstr[j++] = str[i];
33			}
34
35			outstr[j] = 0;
36			return outstr;
37			}
38
39			/**
40			* @brief Allocates a buffer and stores the right-trimmed string into it.
41			*/
42			char str_rtrim(const char restrict str)
43			{
44			size_t length = strlen(str);
45
46			if (length == 0)
47			{
48			return strdup(str);
49			}
50
51			char *outstr = xmalloc(length + 1);
52			size_t spaces = 0;
53
54			for (size_t i = length;; i--)
55			{
56			if (str[i] == 0)
57			continue;
58
59			if (isspace(str[i]))
60			spaces++;
61			else
62			break;
63
64			if (i == 0)
65			break;
66			}
67
68			for (size_t i = 0; i < (length - spaces); i++)
69			{
70			outstr[i] = str[i];
71			}
72
73			outstr[length - spaces] = 0;
74			return outstr;
75			}
76
77			/**
78			* @brief Allocates a buffer and stores the both right and left-trimmed string into it.
79			*/
80			char str_trim(const char restrict str)
81			{
82			char *ltrimmed = str_ltrim(str);
83			char *final = str_rtrim(ltrimmed);
84			free(ltrimmed);
85			return final;
86			}
87
88			bool str_starts_with(const char restrict haystack, const char restrict needle)
89			{
90			size_t haystack_length = strlen(haystack);
91			size_t needle_length = strlen(needle);
92
93			if (haystack_length < needle_length)
94			{
95			return false;
96			}
97
98			for (size_t i = 0; i < needle_length; i++)
99			{
100			if (haystack[i] != needle[i])
101			{
102			return false;
103			}
104			}
105
106			return true;
107			}
108
109			char str_concat_varg(const char start, ...)
110			{
111			va_list args;
112			char *buffer = strdup(start);
113			size_t length = strlen(start);
114
115			va_start(args, start);
116
117			while (true)
118			{
119			const char part = va_arg(args, const char );
120			size_t part_length;
121
122			if (part == NULL)
123			break;
124
125			part_length = strlen(part);
126			length += part_length;
127			buffer = xrealloc(buffer, length);
128			strncat(buffer, part, part_length);
129			}
130
131			va_end(args);
132			return buffer;
133			}