/+junk/codegen : contents of src/flag.h at revision 1

: (revision 1)

To get this branch, use:

bzr branch
http://gegoxaren.bato24.eu/bzr/%2Bjunk/codegen

// flag.h -- command-line flag parsing
//
//   Inspired by Go's flag module: https://pkg.go.dev/flag
//
#ifndef FLAG_H_
#define FLAG_H_

#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <stdint.h>
#include <stddef.h>
#include <inttypes.h>
#include <limits.h>
#include <string.h>
#include <errno.h>

// TODO: add support for -flag=x syntax
// TODO: *_var function variants
// void flag_bool_var(bool *var, const char *name, bool def, const char *desc);
// void flag_bool_uint64(uint64_t *var, const char *name, bool def, const char *desc);
// etc.
// WARNING! *_var functions may break the flag_name() functionality

char *flag_name(void *val);
bool *flag_bool(const char *name, bool def, const char *desc);
uint64_t *flag_uint64(const char *name, uint64_t def, const char *desc);
size_t *flag_size(const char *name, uint64_t def, const char *desc);
char **flag_str(const char *name, const char *def, const char *desc);
bool flag_parse(int argc, char **argv);
int flag_rest_argc(void);
char **flag_rest_argv(void);
void flag_print_error(FILE *stream);
void flag_print_options(FILE *stream);

#endif // FLAG_H_

//////////////////////////////

#ifdef FLAG_IMPLEMENTATION

typedef enum {
    FLAG_BOOL = 0,
    FLAG_UINT64,
    FLAG_SIZE,
    FLAG_STR,
    COUNT_FLAG_TYPES,
} Flag_Type;

static_assert(COUNT_FLAG_TYPES == 4, "Exhaustive Flag_Value definition");
typedef union {
    char *as_str;
    uint64_t as_uint64;
    bool as_bool;
    size_t as_size;
} Flag_Value;

typedef enum {
    FLAG_NO_ERROR = 0,
    FLAG_ERROR_UNKNOWN,
    FLAG_ERROR_NO_VALUE,
    FLAG_ERROR_INVALID_NUMBER,
    FLAG_ERROR_INTEGER_OVERFLOW,
    FLAG_ERROR_INVALID_SIZE_SUFFIX,
    COUNT_FLAG_ERRORS,
} Flag_Error;

typedef struct {
    Flag_Type type;
    char *name;
    char *desc;
    Flag_Value val;
    Flag_Value def;
} Flag;

#ifndef FLAGS_CAP
#define FLAGS_CAP 256
#endif

typedef struct {
    Flag flags[FLAGS_CAP];
    size_t flags_count;

    Flag_Error flag_error;
    char *flag_error_name;

    int rest_argc;
    char **rest_argv;
} Flag_Context;

static Flag_Context flag_global_context;

Flag *flag_new(Flag_Type type, const char *name, const char *desc)
{
    Flag_Context *c = &flag_global_context;

    assert(c->flags_count < FLAGS_CAP);
    Flag *flag = &c->flags[c->flags_count++];
    memset(flag, 0, sizeof(*flag));
    flag->type = type;
    // NOTE: I won't touch them I promise Kappa
    flag->name = (char*) name;
    flag->desc = (char*) desc;
    return flag;
}

char *flag_name(void *val)
{
    Flag *flag = (Flag*) ((char*) val - offsetof(Flag, val));
    return flag->name;
}

bool *flag_bool(const char *name, bool def, const char *desc)
{
    Flag *flag = flag_new(FLAG_BOOL, name, desc);
    flag->def.as_bool = def;
    flag->val.as_bool = def;
    return &flag->val.as_bool;
}

uint64_t *flag_uint64(const char *name, uint64_t def, const char *desc)
{
    Flag *flag = flag_new(FLAG_UINT64, name, desc);
    flag->val.as_uint64 = def;
    flag->def.as_uint64 = def;
    return &flag->val.as_uint64;
}

size_t *flag_size(const char *name, uint64_t def, const char *desc)
{
    Flag *flag = flag_new(FLAG_SIZE, name, desc);
    flag->val.as_size = def;
    flag->def.as_size = def;
    return &flag->val.as_size;
}

char **flag_str(const char *name, const char *def, const char *desc)
{
    Flag *flag = flag_new(FLAG_STR, name, desc);
    flag->val.as_str = (char*) def;
    flag->def.as_str = (char*) def;
    return &flag->val.as_str;
}

static char *flag_shift_args(int *argc, char ***argv)
{
    assert(*argc > 0);
    char *result = **argv;
    *argv += 1;
    *argc -= 1;
    return result;
}

int flag_rest_argc(void)
{
    return flag_global_context.rest_argc;
}

char **flag_rest_argv(void)
{
    return flag_global_context.rest_argv;
}

bool flag_parse(int argc, char **argv)
{
    Flag_Context *c = &flag_global_context;

    flag_shift_args(&argc, &argv);

    while (argc > 0) {
        char *flag = flag_shift_args(&argc, &argv);

        if (*flag != '-') {
            // NOTE: pushing flag back into args
            c->rest_argc = argc + 1;
            c->rest_argv = argv - 1;
            return true;
        }

        if (strcmp(flag, "--") == 0) {
            // NOTE: but if it's the terminator we don't need to push it back
            c->rest_argc = argc;
            c->rest_argv = argv;
            return true;
        }

        // NOTE: remove the dash
        flag += 1;

        bool found = false;
        for (size_t i = 0; i < c->flags_count; ++i) {
            if (strcmp(c->flags[i].name, flag) == 0) {
                static_assert(COUNT_FLAG_TYPES == 4, "Exhaustive flag type parsing");
                switch (c->flags[i].type) {
                case FLAG_BOOL: {
                    c->flags[i].val.as_bool = true;
                }
                break;

                case FLAG_STR: {
                    if (argc == 0) {
                        c->flag_error = FLAG_ERROR_NO_VALUE;
                        c->flag_error_name = flag;
                        return false;
                    }
                    char *arg = flag_shift_args(&argc, &argv);
                    c->flags[i].val.as_str = arg;
                }
                break;

                case FLAG_UINT64: {
                    if (argc == 0) {
                        c->flag_error = FLAG_ERROR_NO_VALUE;
                        c->flag_error_name = flag;
                        return false;
                    }
                    char *arg = flag_shift_args(&argc, &argv);

                    static_assert(sizeof(unsigned long long int) == sizeof(uint64_t), "The original author designed this for x86_64 machine with the compiler that expects unsigned long long int and uint64_t to be the same thing, so they could use strtoull() function to parse it. Please adjust this code for your case and maybe even send the patch to upstream to make it work on a wider range of environments.");
                    char *endptr;
                    // TODO: replace strtoull with a custom solution
                    // That way we can get rid of the dependency on errno and static_assert
                    unsigned long long int result = strtoull(arg, &endptr, 10);

                    if (*endptr != '\0') {
                        c->flag_error = FLAG_ERROR_INVALID_NUMBER;
                        c->flag_error_name = flag;
                        return false;
                    }
                    
                    if (result == ULLONG_MAX && errno == ERANGE) {
                        c->flag_error = FLAG_ERROR_INTEGER_OVERFLOW;
                        c->flag_error_name = flag;
                        return false;
                    }

                    c->flags[i].val.as_uint64 = result;
                }
                break;

                case FLAG_SIZE: {
                    if (argc == 0) {
                        c->flag_error = FLAG_ERROR_NO_VALUE;
                        c->flag_error_name = flag;
                        return false;
                    }
                    char *arg = flag_shift_args(&argc, &argv);

                    static_assert(sizeof(unsigned long long int) == sizeof(size_t), "The original author designed this for x86_64 machine with the compiler that expects unsigned long long int and size_t to be the same thing, so they could use strtoull() function to parse it. Please adjust this code for your case and maybe even send the patch to upstream to make it work on a wider range of environments.");
                    char *endptr;
                    // TODO: replace strtoull with a custom solution
                    // That way we can get rid of the dependency on errno and static_assert
                    unsigned long long int result = strtoull(arg, &endptr, 10);

                    // TODO: handle more multiplicative suffixes like in dd(1). From the dd(1) man page:
                    // > N and BYTES may be followed by the following
                    // > multiplicative suffixes: c =1, w =2, b =512, kB =1000, K
                    // > =1024, MB =1000*1000, M =1024*1024, xM =M, GB
                    // > =1000*1000*1000, G =1024*1024*1024, and so on for T, P,
                    // > E, Z, Y.
                    if (strcmp(endptr, "K") == 0) {
                        result *= 1024;
                    } else if (strcmp(endptr, "M") == 0) {
                        result *= 1024*1024;
                    } else if (strcmp(endptr, "G") == 0) {
                        result *= 1024*1024*1024;
                    } else if (strcmp(endptr, "") != 0) {
                        c->flag_error = FLAG_ERROR_INVALID_SIZE_SUFFIX;
                        c->flag_error_name = flag;
                        // TODO: capability to report what exactly is the wrong suffix
                        return false;
                    }

                    if (result == ULLONG_MAX && errno == ERANGE) {
                        c->flag_error = FLAG_ERROR_INTEGER_OVERFLOW;
                        c->flag_error_name = flag;
                        return false;
                    }

                    c->flags[i].val.as_size = result;
                }
                break;

                case COUNT_FLAG_TYPES:
                default: {
                    assert(0 && "unreachable");
                    exit(69);
                }
                }

                found = true;
            }
        }

        if (!found) {
            c->flag_error = FLAG_ERROR_UNKNOWN;
            c->flag_error_name = flag;
            return false;
        }
    }

    c->rest_argc = argc;
    c->rest_argv = argv;
    return true;
}

void flag_print_options(FILE *stream)
{
    Flag_Context *c = &flag_global_context;
    for (size_t i = 0; i < c->flags_count; ++i) {
        Flag *flag = &c->flags[i];

        fprintf(stream, "    -%s\n", flag->name);
        fprintf(stream, "        %s\n", flag->desc);
        static_assert(COUNT_FLAG_TYPES == 4, "Exhaustive flag type defaults printing");
        switch (c->flags[i].type) {
        case FLAG_BOOL:
            if (flag->def.as_bool) {
                fprintf(stream, "        Default: %s\n", flag->def.as_bool ? "true" : "false");
            }
            break;
        case FLAG_UINT64:
            fprintf(stream, "        Default: %" PRIu64 "\n", flag->def.as_uint64);
            break;
        case FLAG_SIZE:
            fprintf(stream, "        Default: %zu\n", flag->def.as_size);
            break;
        case FLAG_STR:
            if (flag->def.as_str) {
                fprintf(stream, "        Default: %s\n", flag->def.as_str);
            }
            break;
        default:
            assert(0 && "unreachable");
            exit(69);
        }
    }
}

void flag_print_error(FILE *stream)
{
    Flag_Context *c = &flag_global_context;
    static_assert(COUNT_FLAG_ERRORS == 6, "Exhaustive flag error printing");
    switch (c->flag_error) {
    case FLAG_NO_ERROR:
        // NOTE: don't call flag_print_error() if flag_parse() didn't return false, okay? ._.
        fprintf(stream, "Operation Failed Successfully! Please tell the developer of this software that they don't know what they are doing! :)");
        break;
    case FLAG_ERROR_UNKNOWN:
        fprintf(stream, "ERROR: -%s: unknown flag\n", c->flag_error_name);
        break;
    case FLAG_ERROR_NO_VALUE:
        fprintf(stream, "ERROR: -%s: no value provided\n", c->flag_error_name);
        break;
    case FLAG_ERROR_INVALID_NUMBER:
        fprintf(stream, "ERROR: -%s: invalid number\n", c->flag_error_name);
        break;
    case FLAG_ERROR_INTEGER_OVERFLOW:
        fprintf(stream, "ERROR: -%s: integer overflow\n", c->flag_error_name);
        break;
    case FLAG_ERROR_INVALID_SIZE_SUFFIX:
        fprintf(stream, "ERROR: -%s: invalid size suffix\n", c->flag_error_name);
        break;
    case COUNT_FLAG_ERRORS:
    default:
        assert(0 && "unreachable");
        exit(69);
    }
}

#endif
// Copyright 2021 Alexey Kutepov <reximkut@gmail.com>
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
// IN THE SOFTWARE.

1 by Gustav Hartvigsson Beep Boop, nothin yet.	1	// flag.h -- command-line flag parsing
	2	//
	3	// Inspired by Go's flag module: https://pkg.go.dev/flag
	4	//
	5	#ifndef FLAG_H_
	6	#define FLAG_H_
	7
	8	#include <assert.h>
	9	#include <stdio.h>
	10	#include <stdlib.h>
	11	#include <stdbool.h>
	12	#include <stdint.h>
	13	#include <stddef.h>
	14	#include <inttypes.h>
	15	#include <limits.h>
	16	#include <string.h>
	17	#include <errno.h>
	18
	19	// TODO: add support for -flag=x syntax
	20	// TODO: *_var function variants
	21	// void flag_bool_var(bool var, const char name, bool def, const char *desc);
	22	// void flag_bool_uint64(uint64_t var, const char name, bool def, const char *desc);
	23	// etc.
	24	// WARNING! *_var functions may break the flag_name() functionality
	25
	26	char flag_name(void val);
	27	bool flag_bool(const char name, bool def, const char *desc);
	28	uint64_t flag_uint64(const char name, uint64_t def, const char *desc);
	29	size_t flag_size(const char name, uint64_t def, const char *desc);
	30	char *flag_str(const char name, const char def, const char desc);
	31	bool flag_parse(int argc, char **argv);
	32	int flag_rest_argc(void);
	33	char **flag_rest_argv(void);
	34	void flag_print_error(FILE *stream);
	35	void flag_print_options(FILE *stream);
	36
	37	#endif // FLAG_H_
	38
	39	//////////////////////////////
	40
	41	#ifdef FLAG_IMPLEMENTATION
	42
	43	typedef enum {
	44	FLAG_BOOL = 0,
	45	FLAG_UINT64,
	46	FLAG_SIZE,
	47	FLAG_STR,
	48	COUNT_FLAG_TYPES,
	49	} Flag_Type;
	50
	51	static_assert(COUNT_FLAG_TYPES == 4, "Exhaustive Flag_Value definition");
	52	typedef union {
	53	char *as_str;
	54	uint64_t as_uint64;
	55	bool as_bool;
	56	size_t as_size;
	57	} Flag_Value;
	58
	59	typedef enum {
	60	FLAG_NO_ERROR = 0,
	61	FLAG_ERROR_UNKNOWN,
	62	FLAG_ERROR_NO_VALUE,
	63	FLAG_ERROR_INVALID_NUMBER,
	64	FLAG_ERROR_INTEGER_OVERFLOW,
65	FLAG_ERROR_INVALID_SIZE_SUFFIX,
66	COUNT_FLAG_ERRORS,
67	} Flag_Error;
68
69	typedef struct {
70	Flag_Type type;
71	char *name;
72	char *desc;
73	Flag_Value val;
74	Flag_Value def;
75	} Flag;
76
77	#ifndef FLAGS_CAP
78	#define FLAGS_CAP 256
79	#endif
80
81	typedef struct {
82	Flag flags[FLAGS_CAP];
83	size_t flags_count;
84
85	Flag_Error flag_error;
86	char *flag_error_name;
87
88	int rest_argc;
89	char **rest_argv;
90	} Flag_Context;
91
92	static Flag_Context flag_global_context;
93
94	Flag flag_new(Flag_Type type, const char name, const char *desc)
95	{
96	Flag_Context *c = &flag_global_context;
97
98	assert(c->flags_count < FLAGS_CAP);
99	Flag *flag = &c->flags[c->flags_count++];
100	memset(flag, 0, sizeof(*flag));
101	flag->type = type;
102	// NOTE: I won't touch them I promise Kappa
103	flag->name = (char*) name;
104	flag->desc = (char*) desc;
105	return flag;
106	}
107
108	char flag_name(void val)
109	{
110	Flag flag = (Flag) ((char*) val - offsetof(Flag, val));
111	return flag->name;
112	}
113
114	bool flag_bool(const char name, bool def, const char *desc)
115	{
116	Flag *flag = flag_new(FLAG_BOOL, name, desc);
117	flag->def.as_bool = def;
118	flag->val.as_bool = def;
119	return &flag->val.as_bool;
120	}
121
122	uint64_t flag_uint64(const char name, uint64_t def, const char *desc)
123	{
124	Flag *flag = flag_new(FLAG_UINT64, name, desc);
125	flag->val.as_uint64 = def;
126	flag->def.as_uint64 = def;
127	return &flag->val.as_uint64;
128	}
129
130	size_t flag_size(const char name, uint64_t def, const char *desc)
131	{
132	Flag *flag = flag_new(FLAG_SIZE, name, desc);
133	flag->val.as_size = def;
134	flag->def.as_size = def;
135	return &flag->val.as_size;
136	}
137
138	char *flag_str(const char name, const char def, const char desc)
139	{
140	Flag *flag = flag_new(FLAG_STR, name, desc);
141	flag->val.as_str = (char*) def;
142	flag->def.as_str = (char*) def;
143	return &flag->val.as_str;
144	}
145
146	static char flag_shift_args(int argc, char ***argv)
147	{
148	assert(*argc > 0);
149	char result = *argv;
150	*argv += 1;
151	*argc -= 1;
152	return result;
153	}
154
155	int flag_rest_argc(void)
156	{
157	return flag_global_context.rest_argc;
158	}
159
160	char **flag_rest_argv(void)
161	{
162	return flag_global_context.rest_argv;
163	}
164
165	bool flag_parse(int argc, char **argv)
166	{
167	Flag_Context *c = &flag_global_context;
168
169	flag_shift_args(&argc, &argv);
170
171	while (argc > 0) {
172	char *flag = flag_shift_args(&argc, &argv);
173
174	if (*flag != '-') {
175	// NOTE: pushing flag back into args
176	c->rest_argc = argc + 1;
177	c->rest_argv = argv - 1;
178	return true;
179	}
180
181	if (strcmp(flag, "--") == 0) {
182	// NOTE: but if it's the terminator we don't need to push it back
183	c->rest_argc = argc;
184	c->rest_argv = argv;
185	return true;
186	}
187
188	// NOTE: remove the dash
189	flag += 1;
190
191	bool found = false;
192	for (size_t i = 0; i < c->flags_count; ++i) {
193	if (strcmp(c->flags[i].name, flag) == 0) {
194	static_assert(COUNT_FLAG_TYPES == 4, "Exhaustive flag type parsing");
195	switch (c->flags[i].type) {
196	case FLAG_BOOL: {
197	c->flags[i].val.as_bool = true;
198	}
199	break;
200
201	case FLAG_STR: {
202	if (argc == 0) {
203	c->flag_error = FLAG_ERROR_NO_VALUE;
204	c->flag_error_name = flag;
205	return false;
206	}
207	char *arg = flag_shift_args(&argc, &argv);
208	c->flags[i].val.as_str = arg;
209	}
210	break;
211
212	case FLAG_UINT64: {
213	if (argc == 0) {
214	c->flag_error = FLAG_ERROR_NO_VALUE;
215	c->flag_error_name = flag;
216	return false;
217	}
218	char *arg = flag_shift_args(&argc, &argv);
219
220	static_assert(sizeof(unsigned long long int) == sizeof(uint64_t), "The original author designed this for x86_64 machine with the compiler that expects unsigned long long int and uint64_t to be the same thing, so they could use strtoull() function to parse it. Please adjust this code for your case and maybe even send the patch to upstream to make it work on a wider range of environments.");
221	char *endptr;
222	// TODO: replace strtoull with a custom solution
223	// That way we can get rid of the dependency on errno and static_assert
224	unsigned long long int result = strtoull(arg, &endptr, 10);
225
226	if (*endptr != '\0') {
227	c->flag_error = FLAG_ERROR_INVALID_NUMBER;
228	c->flag_error_name = flag;
229	return false;
230	}
231
232	if (result == ULLONG_MAX && errno == ERANGE) {
233	c->flag_error = FLAG_ERROR_INTEGER_OVERFLOW;
234	c->flag_error_name = flag;
235	return false;
236	}
237
238	c->flags[i].val.as_uint64 = result;
239	}
240	break;
241
242	case FLAG_SIZE: {
243	if (argc == 0) {
244	c->flag_error = FLAG_ERROR_NO_VALUE;
245	c->flag_error_name = flag;
246	return false;
247	}
248	char *arg = flag_shift_args(&argc, &argv);
249
250	static_assert(sizeof(unsigned long long int) == sizeof(size_t), "The original author designed this for x86_64 machine with the compiler that expects unsigned long long int and size_t to be the same thing, so they could use strtoull() function to parse it. Please adjust this code for your case and maybe even send the patch to upstream to make it work on a wider range of environments.");
251	char *endptr;
252	// TODO: replace strtoull with a custom solution
253	// That way we can get rid of the dependency on errno and static_assert
254	unsigned long long int result = strtoull(arg, &endptr, 10);
255
256	// TODO: handle more multiplicative suffixes like in dd(1). From the dd(1) man page:
257	// > N and BYTES may be followed by the following
258	// > multiplicative suffixes: c =1, w =2, b =512, kB =1000, K
259	// > =1024, MB =10001000, M =10241024, xM =M, GB
260	// > =100010001000, G =102410241024, and so on for T, P,
261	// > E, Z, Y.
262	if (strcmp(endptr, "K") == 0) {
263	result *= 1024;
264	} else if (strcmp(endptr, "M") == 0) {
265	result = 10241024;
266	} else if (strcmp(endptr, "G") == 0) {
267	result = 10241024*1024;
268	} else if (strcmp(endptr, "") != 0) {
269	c->flag_error = FLAG_ERROR_INVALID_SIZE_SUFFIX;
270	c->flag_error_name = flag;
271	// TODO: capability to report what exactly is the wrong suffix
272	return false;
273	}
274
275	if (result == ULLONG_MAX && errno == ERANGE) {
276	c->flag_error = FLAG_ERROR_INTEGER_OVERFLOW;
277	c->flag_error_name = flag;
278	return false;
279	}
280
281	c->flags[i].val.as_size = result;
282	}
283	break;
284
285	case COUNT_FLAG_TYPES:
286	default: {
287	assert(0 && "unreachable");
288	exit(69);
289	}
290	}
291
292	found = true;
293	}
294	}
295
296	if (!found) {
297	c->flag_error = FLAG_ERROR_UNKNOWN;
298	c->flag_error_name = flag;
299	return false;
300	}
301	}
302
303	c->rest_argc = argc;
304	c->rest_argv = argv;
305	return true;
306	}
307
308	void flag_print_options(FILE *stream)
309	{
310	Flag_Context *c = &flag_global_context;
311	for (size_t i = 0; i < c->flags_count; ++i) {
312	Flag *flag = &c->flags[i];
313
314	fprintf(stream, " -%s\n", flag->name);
315	fprintf(stream, " %s\n", flag->desc);
316	static_assert(COUNT_FLAG_TYPES == 4, "Exhaustive flag type defaults printing");
317	switch (c->flags[i].type) {
318	case FLAG_BOOL:
319	if (flag->def.as_bool) {
320	fprintf(stream, " Default: %s\n", flag->def.as_bool ? "true" : "false");
321	}
322	break;
323	case FLAG_UINT64:
324	fprintf(stream, " Default: %" PRIu64 "\n", flag->def.as_uint64);
325	break;
326	case FLAG_SIZE:
327	fprintf(stream, " Default: %zu\n", flag->def.as_size);
328	break;
329	case FLAG_STR:
330	if (flag->def.as_str) {
331	fprintf(stream, " Default: %s\n", flag->def.as_str);
332	}
333	break;
334	default:
335	assert(0 && "unreachable");
336	exit(69);
337	}
338	}
339	}
340
341	void flag_print_error(FILE *stream)
342	{
343	Flag_Context *c = &flag_global_context;
344	static_assert(COUNT_FLAG_ERRORS == 6, "Exhaustive flag error printing");
345	switch (c->flag_error) {
346	case FLAG_NO_ERROR:
347	// NOTE: don't call flag_print_error() if flag_parse() didn't return false, okay? ._.
348	fprintf(stream, "Operation Failed Successfully! Please tell the developer of this software that they don't know what they are doing! :)");
349	break;
350	case FLAG_ERROR_UNKNOWN:
351	fprintf(stream, "ERROR: -%s: unknown flag\n", c->flag_error_name);
352	break;
353	case FLAG_ERROR_NO_VALUE:
354	fprintf(stream, "ERROR: -%s: no value provided\n", c->flag_error_name);
355	break;
356	case FLAG_ERROR_INVALID_NUMBER:
357	fprintf(stream, "ERROR: -%s: invalid number\n", c->flag_error_name);
358	break;
359	case FLAG_ERROR_INTEGER_OVERFLOW:
360	fprintf(stream, "ERROR: -%s: integer overflow\n", c->flag_error_name);
361	break;
362	case FLAG_ERROR_INVALID_SIZE_SUFFIX:
363	fprintf(stream, "ERROR: -%s: invalid size suffix\n", c->flag_error_name);
364	break;
365	case COUNT_FLAG_ERRORS:
366	default:
367	assert(0 && "unreachable");
368	exit(69);
369	}
370	}
371
372	#endif
373	// Copyright 2021 Alexey Kutepov <reximkut@gmail.com>
374	//
375	// Permission is hereby granted, free of charge, to any person obtaining a copy
376	// of this software and associated documentation files (the "Software"), to
377	// deal in the Software without restriction, including without limitation the
378	// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
379	// sell copies of the Software, and to permit persons to whom the Software is
380	// furnished to do so, subject to the following conditions:
381	//
382	// The above copyright notice and this permission notice shall be included in
383	// all copies or substantial portions of the Software.
384	//
385	// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
386	// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
387	// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
388	// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
389	// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
390	// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
391	// IN THE SOFTWARE.