common/io/printf.c

#include "printf.h"

#include <assert.h>
#include <math.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "../utils/xmalloc.h"

typedef enum format_flags format_flags_t;

enum format_flags
{
    FMT_STR = 0b0000000000001,
    FMT_INT = 0b0000000000010,
    FMT_UNSIGNED = 0b0000000000100,
    FMT_DECIMAL = 0b0000000001000,
    FMT_BINARY = 0b0000000010000,
    FMT_HEXADECIMAL = 0b0000000100000,
    FMT_OCTAL = 0b0000001000000,
    FMT_UNKNOWN = 0b0000010000000,
    FMT_INT_DEFAULT = 0b0000100000000,
    FMT_INT_LONG = 0b0001000000000,
    FMT_INT_LONG_LONG = 0b0010000000000,
    FMT_INT_SHORT = 0b0100000000000,
    FMT_LIT_SIZE = 0b1000000000000
};

static void
casprintf_buffer_push_char(char **buffer, size_t *buffer_size, const char c)
{
    size_t size = ++(*buffer_size);
    *buffer = xrealloc(*buffer, size);
    (*buffer)[size - 1] = c;
}

static void
casprintf_buffer_concat_str(char **buffer, size_t *buffer_size, const char *str)
{
    size_t len = strlen(str);
    *buffer_size += len;
    size_t size = *buffer_size;
    *buffer = xrealloc(*buffer, size);
    strncat(*buffer, str, len);
}

static format_flags_t casprintf_length_flags(
    const char *start, const char **next, size_t *literal_size, bool *_zero)
{
    format_flags_t flags = 0;
    char *sizebuf = NULL;
    size_t buflen = 0;
    bool zero = false;

    while (*start && *start >= '0' && *start <= '9')
    {
        if (*start == '0' && !zero)
        {
            zero = true;
            start++;
            continue;
        }

        casprintf_buffer_push_char(&sizebuf, &buflen, *start);
        start++;
    }

    if (buflen > 0 || zero)
    {
        size_t i = buflen - 1, size = 0, power = 0;

        if (buflen > 0)
        {
            while (true)
            {
                long long multiplier = (long long) powl(10, power++);
                int digit = sizebuf[i] - '0';

                assert(digit >= 0);

                size += multiplier * ((unsigned int) digit);

                if (i == 0)
                    break;

                i--;
            }
        }

        if (_zero != NULL)
        {
            *_zero = zero;
        }

        if (next != NULL)
        {
            *next = start;
        }

        free(sizebuf);
        *literal_size = size;
        return FMT_LIT_SIZE;
    }

    free(sizebuf);

    while (*start)
    {
        switch (*start)
        {
            case 'l':
                if (*(start + 1) == 'l')
                {
                    flags |= FMT_INT_LONG_LONG;
                    start++;
                }
                else
                    flags |= FMT_INT_LONG;

                break;

            case 'h':
                flags |= FMT_INT_SHORT;
                break;

            default:
#ifdef SUDOBOT_CASPRINTF_VERBOSE
                fprintf(
                    stderr, "%s: warning: unknown length specifier: %c\n",
                    __func__, *start);
#endif
                goto casprintf_length_flags_end;
        }

        start++;
    }

casprintf_length_flags_end:
    if (next != NULL)
    {
        *next = start;
    }

    return flags == 0 ? FMT_INT_DEFAULT : flags;
}

static format_flags_t casprintf_type_flag(const char c)
{
    format_flags_t flags = 0;

    switch (c)
    {
        case 'i':
        case 'd':
            flags = FMT_INT | FMT_DECIMAL;
            break;

        case 's':
            flags = FMT_STR;
            break;

        case 'u':
            flags = FMT_INT | FMT_UNSIGNED;
            break;

        default:
#ifdef SUDOBOT_CASPRINTF_VERBOSE
            fprintf(
                stderr, "%s: warning: unknown type specifier: %c\n", __func__,
                *start);
#endif
            return FMT_UNKNOWN;
    }

    return flags;
}

static void casprintf_concat(
    va_list *args, char **buffer, size_t *buffer_size, format_flags_t flags,
    size_t literal_size, bool zero)
{
    if (flags & FMT_INT)
    {
        uint64_t unsigned_arg =
            flags & FMT_INT_DEFAULT
                ? va_arg(*args, unsigned)
                : (flags & FMT_INT_LONG
                       ? va_arg(*args, unsigned long)
                       : (flags & FMT_INT_LONG_LONG
                              ? va_arg(*args, unsigned long long)
                              : (flags & FMT_INT_SHORT
                                     ? va_arg(*args, unsigned int)
                                     : va_arg(*args, unsigned int))));

        int64_t signed_arg = (int64_t) unsigned_arg;

        bool is_negative = flags & FMT_UNSIGNED ? false : (signed_arg < 0);
        uint64_t arg =
            flags & FMT_UNSIGNED
                ? unsigned_arg
                : ((uint64_t) (is_negative ? -signed_arg : signed_arg));

        char *numbuf = NULL;
        size_t numbuf_size = 0;

        do
        {
            const char digit = (arg % 10) + '0';
            casprintf_buffer_push_char(&numbuf, &numbuf_size, digit);
            arg /= 10;
        } while (arg > 0);

        if (is_negative)
            casprintf_buffer_push_char(buffer, buffer_size, '-');

        size_t i = (literal_size != 0 ? literal_size : numbuf_size) - 1;

        if (zero && literal_size > numbuf_size)
        {
            for (size_t zi = 0; zi < (literal_size - numbuf_size); zi++)
                casprintf_buffer_push_char(buffer, buffer_size, '0');
        }

        while (true)
        {
            casprintf_buffer_push_char(buffer, buffer_size, numbuf[i]);

            if (i == 0)
                break;

            i--;
        }

        free(numbuf);
    }
    else if (flags & FMT_STR)
    {
        const char *str = va_arg(*args, const char *);
        casprintf_buffer_concat_str(buffer, buffer_size, str);
    }
}

char *casprintf(const char *format, ...)
{
    char *buffer = NULL;
    size_t buffer_size = 0;
    va_list args;

    va_start(args, format);

    while (*format)
    {
        if (*format == '%')
        {
            format++;

            size_t literal_size = 0;
            bool zero = false;
            const char *old_format = format;
            format_flags_t length_flags =
                casprintf_length_flags(format, &format, &literal_size, &zero);
            format_flags_t type_flag = casprintf_type_flag(*format);

            if (type_flag == FMT_UNKNOWN)
            {
                casprintf_buffer_push_char(&buffer, &buffer_size, '%');

                for (long int i = 0; i < (format - old_format); i++)
                    casprintf_buffer_push_char(
                        &buffer, &buffer_size, old_format[i]);

                continue;
            }

            if (type_flag == 0)
                type_flag = FMT_INT | FMT_DECIMAL;
            else
                format++;

            format_flags_t flags = length_flags | type_flag;

            casprintf_concat(
                &args, &buffer, &buffer_size, flags, literal_size, zero);
            continue;
        }
        else
        {
            casprintf_buffer_push_char(&buffer, &buffer_size, *format);
        }

        format++;
    }

    casprintf_buffer_push_char(&buffer, &buffer_size, 0);
    va_end(args);
    return buffer;
}
1	#include "printf.h"
2
3	#include <assert.h>
4	#include <math.h>
5	#include <stdarg.h>
6	#include <stdbool.h>
7	#include <stdint.h>
8	#include <stdio.h>
9	#include <stdlib.h>
10	#include <string.h>
11
12	#include "../utils/xmalloc.h"
13
14	typedef enum format_flags format_flags_t;
15
16	enum format_flags
17	{
18	FMT_STR = 0b0000000000001,
19	FMT_INT = 0b0000000000010,
20	FMT_UNSIGNED = 0b0000000000100,
21	FMT_DECIMAL = 0b0000000001000,
22	FMT_BINARY = 0b0000000010000,
23	FMT_HEXADECIMAL = 0b0000000100000,
24	FMT_OCTAL = 0b0000001000000,
25	FMT_UNKNOWN = 0b0000010000000,
26	FMT_INT_DEFAULT = 0b0000100000000,
27	FMT_INT_LONG = 0b0001000000000,
28	FMT_INT_LONG_LONG = 0b0010000000000,
29	FMT_INT_SHORT = 0b0100000000000,
30	FMT_LIT_SIZE = 0b1000000000000
31	};
32
33	static void
34	casprintf_buffer_push_char(char *buffer, size_t buffer_size, const char c)
35	{
36	size_t size = ++(*buffer_size);
37	buffer = xrealloc(buffer, size);
38	(*buffer)[size - 1] = c;
39	}
40
41	static void
42	casprintf_buffer_concat_str(char *buffer, size_t buffer_size, const char *str)
43	{
44	size_t len = strlen(str);
45	*buffer_size += len;
46	size_t size = *buffer_size;
47	buffer = xrealloc(buffer, size);
48	strncat(*buffer, str, len);
49	}
50
51	static format_flags_t casprintf_length_flags(
52	const char start, const char next, size_t literal_size, bool *_zero)
53	{
54	format_flags_t flags = 0;
55	char *sizebuf = NULL;
56	size_t buflen = 0;
57	bool zero = false;
58
59	while (start && start >= '0' && *start <= '9')
60	{
61	if (*start == '0' && !zero)
62	{
63	zero = true;
64	start++;
65	continue;
66	}
67
68	casprintf_buffer_push_char(&sizebuf, &buflen, *start);
69	start++;
70	}
71
72	if (buflen > 0 \|\| zero)
73	{
74	size_t i = buflen - 1, size = 0, power = 0;
75
76	if (buflen > 0)
77	{
78	while (true)
79	{
80	long long multiplier = (long long) powl(10, power++);
81	int digit = sizebuf[i] - '0';
82
83	assert(digit >= 0);
84
85	size += multiplier * ((unsigned int) digit);
86
87	if (i == 0)
88	break;
89
90	i--;
91	}
92	}
93
94	if (_zero != NULL)
95	{
96	*_zero = zero;
97	}
98
99	if (next != NULL)
100	{
101	*next = start;
102	}
103
104	free(sizebuf);
105	*literal_size = size;
106	return FMT_LIT_SIZE;
107	}
108
109	free(sizebuf);
110
111	while (*start)
112	{
113	switch (*start)
114	{
115	case 'l':
116	if (*(start + 1) == 'l')
117	{
118	flags \|= FMT_INT_LONG_LONG;
119	start++;
120	}
121	else
122	flags \|= FMT_INT_LONG;
123
124	break;
125
126	case 'h':
127	flags \|= FMT_INT_SHORT;
128	break;
129
130	default:
131	#ifdef SUDOBOT_CASPRINTF_VERBOSE
132	fprintf(
133	stderr, "%s: warning: unknown length specifier: %c\n",
134	__func__, *start);
135	#endif
136	goto casprintf_length_flags_end;
137	}
138
139	start++;
140	}
141
142	casprintf_length_flags_end:
143	if (next != NULL)
144	{
145	*next = start;
146	}
147
148	return flags == 0 ? FMT_INT_DEFAULT : flags;
149	}
150
151	static format_flags_t casprintf_type_flag(const char c)
152	{
153	format_flags_t flags = 0;
154
155	switch (c)
156	{
157	case 'i':
158	case 'd':
159	flags = FMT_INT \| FMT_DECIMAL;
160	break;
161
162	case 's':
163	flags = FMT_STR;
164	break;
165
166	case 'u':
167	flags = FMT_INT \| FMT_UNSIGNED;
168	break;
169
170	default:
171	#ifdef SUDOBOT_CASPRINTF_VERBOSE
172	fprintf(
173	stderr, "%s: warning: unknown type specifier: %c\n", __func__,
174	*start);
175	#endif
176	return FMT_UNKNOWN;
177	}
178
179	return flags;
180	}
181
182	static void casprintf_concat(
183	va_list args, char buffer, size_t buffer_size, format_flags_t flags,
184	size_t literal_size, bool zero)
185	{
186	if (flags & FMT_INT)
187	{
188	uint64_t unsigned_arg =
189	flags & FMT_INT_DEFAULT
190	? va_arg(*args, unsigned)
191	: (flags & FMT_INT_LONG
192	? va_arg(*args, unsigned long)
193	: (flags & FMT_INT_LONG_LONG
194	? va_arg(*args, unsigned long long)
195	: (flags & FMT_INT_SHORT
196	? va_arg(*args, unsigned int)
197	: va_arg(*args, unsigned int))));
198
199	int64_t signed_arg = (int64_t) unsigned_arg;
200
201	bool is_negative = flags & FMT_UNSIGNED ? false : (signed_arg < 0);
202	uint64_t arg =
203	flags & FMT_UNSIGNED
204	? unsigned_arg
205	: ((uint64_t) (is_negative ? -signed_arg : signed_arg));
206
207	char *numbuf = NULL;
208	size_t numbuf_size = 0;
209
210	do
211	{
212	const char digit = (arg % 10) + '0';
213	casprintf_buffer_push_char(&numbuf, &numbuf_size, digit);
214	arg /= 10;
215	} while (arg > 0);
216
217	if (is_negative)
218	casprintf_buffer_push_char(buffer, buffer_size, '-');
219
220	size_t i = (literal_size != 0 ? literal_size : numbuf_size) - 1;
221
222	if (zero && literal_size > numbuf_size)
223	{
224	for (size_t zi = 0; zi < (literal_size - numbuf_size); zi++)
225	casprintf_buffer_push_char(buffer, buffer_size, '0');
226	}
227
228	while (true)
229	{
230	casprintf_buffer_push_char(buffer, buffer_size, numbuf[i]);
231
232	if (i == 0)
233	break;
234
235	i--;
236	}
237
238	free(numbuf);
239	}
240	else if (flags & FMT_STR)
241	{
242	const char str = va_arg(args, const char *);
243	casprintf_buffer_concat_str(buffer, buffer_size, str);
244	}
245	}
246
247	char casprintf(const char format, ...)
248	{
249	char *buffer = NULL;
250	size_t buffer_size = 0;
251	va_list args;
252
253	va_start(args, format);
254
255	while (*format)
256	{
257	if (*format == '%')
258	{
259	format++;
260
261	size_t literal_size = 0;
262	bool zero = false;
263	const char *old_format = format;
264	format_flags_t length_flags =
265	casprintf_length_flags(format, &format, &literal_size, &zero);
266	format_flags_t type_flag = casprintf_type_flag(*format);
267
268	if (type_flag == FMT_UNKNOWN)
269	{
270	casprintf_buffer_push_char(&buffer, &buffer_size, '%');
271
272	for (long int i = 0; i < (format - old_format); i++)
273	casprintf_buffer_push_char(
274	&buffer, &buffer_size, old_format[i]);
275
276	continue;
277	}
278
279	if (type_flag == 0)
280	type_flag = FMT_INT \| FMT_DECIMAL;
281	else
282	format++;
283
284	format_flags_t flags = length_flags \| type_flag;
285
286	casprintf_concat(
287	&args, &buffer, &buffer_size, flags, literal_size, zero);
288	continue;
289	}
290	else
291	{
292	casprintf_buffer_push_char(&buffer, &buffer_size, *format);
293	}
294
295	format++;
296	}
297
298	casprintf_buffer_push_char(&buffer, &buffer_size, 0);
299	va_end(args);
300	return buffer;
301	}