noobs 0.0.6

package/include/util/cf-parser.h

@@ -0,0 +1,281 @@
+/*
+ * Copyright (c) 2023 Lain Bailey <lain@obsproject.com>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#pragma once
+
+#include "cf-lexer.h"
+
+/*
+ * C-family parser
+ *
+ *   Handles preprocessing/lexing/errors when parsing a file, and provides a
+ * set of parsing functions to be able to go through all the resulting tokens
+ * more easily.
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define PARSE_SUCCESS 0
+#define PARSE_CONTINUE -1
+#define PARSE_BREAK -2
+#define PARSE_UNEXPECTED_CONTINUE -3
+#define PARSE_UNEXPECTED_BREAK -4
+#define PARSE_EOF -5
+
+struct cf_parser {
+	struct cf_lexer lex;
+	struct cf_preprocessor pp;
+	struct error_data error_list;
+
+	struct cf_token *cur_token;
+};
+
+static inline void cf_parser_init(struct cf_parser *parser)
+{
+	cf_lexer_init(&parser->lex);
+	cf_preprocessor_init(&parser->pp);
+	error_data_init(&parser->error_list);
+
+	parser->cur_token = NULL;
+}
+
+static inline void cf_parser_free(struct cf_parser *parser)
+{
+	cf_lexer_free(&parser->lex);
+	cf_preprocessor_free(&parser->pp);
+	error_data_free(&parser->error_list);
+
+	parser->cur_token = NULL;
+}
+
+static inline bool cf_parser_parse(struct cf_parser *parser, const char *str, const char *file)
+{
+	if (!cf_lexer_lex(&parser->lex, str, file))
+		return false;
+
+	if (!cf_preprocess(&parser->pp, &parser->lex, &parser->error_list))
+		return false;
+
+	parser->cur_token = cf_preprocessor_get_tokens(&parser->pp);
+	return true;
+}
+
+EXPORT void cf_adderror(struct cf_parser *parser, const char *error, int level, const char *val1, const char *val2,
+			const char *val3);
+
+static inline void cf_adderror_expecting(struct cf_parser *p, const char *expected)
+{
+	cf_adderror(p, "Expected '$1'", LEX_ERROR, expected, NULL, NULL);
+}
+
+static inline void cf_adderror_unexpected_eof(struct cf_parser *p)
+{
+	cf_adderror(p, "Unexpected EOF", LEX_ERROR, NULL, NULL, NULL);
+}
+
+static inline void cf_adderror_syntax_error(struct cf_parser *p)
+{
+	cf_adderror(p, "Syntax error", LEX_ERROR, NULL, NULL, NULL);
+}
+
+static inline bool cf_next_token(struct cf_parser *p)
+{
+	if (p->cur_token->type != CFTOKEN_SPACETAB && p->cur_token->type != CFTOKEN_NEWLINE &&
+	    p->cur_token->type != CFTOKEN_NONE)
+		p->cur_token++;
+
+	while (p->cur_token->type == CFTOKEN_SPACETAB || p->cur_token->type == CFTOKEN_NEWLINE)
+		p->cur_token++;
+
+	return p->cur_token->type != CFTOKEN_NONE;
+}
+
+static inline bool cf_next_valid_token(struct cf_parser *p)
+{
+	if (!cf_next_token(p)) {
+		cf_adderror_unexpected_eof(p);
+		return false;
+	}
+
+	return true;
+}
+
+EXPORT bool cf_pass_pair(struct cf_parser *p, char in, char out);
+
+static inline bool cf_go_to_token(struct cf_parser *p, const char *str1, const char *str2)
+{
+	while (cf_next_token(p)) {
+		if (strref_cmp(&p->cur_token->str, str1) == 0) {
+			return true;
+		} else if (str2 && strref_cmp(&p->cur_token->str, str2) == 0) {
+			return true;
+		} else if (*p->cur_token->str.array == '{') {
+			if (!cf_pass_pair(p, '{', '}'))
+				break;
+		}
+	}
+
+	return false;
+}
+
+static inline bool cf_go_to_valid_token(struct cf_parser *p, const char *str1, const char *str2)
+{
+	if (!cf_go_to_token(p, str1, str2)) {
+		cf_adderror_unexpected_eof(p);
+		return false;
+	}
+
+	return true;
+}
+
+static inline bool cf_go_to_token_type(struct cf_parser *p, enum cf_token_type type)
+{
+	while (p->cur_token->type != CFTOKEN_NONE && p->cur_token->type != type)
+		p->cur_token++;
+
+	return p->cur_token->type != CFTOKEN_NONE;
+}
+
+static inline int cf_token_should_be(struct cf_parser *p, const char *str, const char *goto1, const char *goto2)
+{
+	if (strref_cmp(&p->cur_token->str, str) == 0)
+		return PARSE_SUCCESS;
+
+	if (goto1) {
+		if (!cf_go_to_token(p, goto1, goto2))
+			return PARSE_EOF;
+	}
+
+	cf_adderror_expecting(p, str);
+	return PARSE_CONTINUE;
+}
+
+static inline int cf_next_token_should_be(struct cf_parser *p, const char *str, const char *goto1, const char *goto2)
+{
+	if (!cf_next_token(p)) {
+		cf_adderror_unexpected_eof(p);
+		return PARSE_EOF;
+	} else if (strref_cmp(&p->cur_token->str, str) == 0) {
+		return PARSE_SUCCESS;
+	}
+
+	if (goto1) {
+		if (!cf_go_to_token(p, goto1, goto2))
+			return PARSE_EOF;
+	}
+
+	cf_adderror_expecting(p, str);
+	return PARSE_CONTINUE;
+}
+
+static inline bool cf_peek_token(struct cf_parser *p, struct cf_token *peek)
+{
+	struct cf_token *cur_token = p->cur_token;
+	bool success = cf_next_token(p);
+
+	*peek = *p->cur_token;
+	p->cur_token = cur_token;
+
+	return success;
+}
+
+static inline bool cf_peek_valid_token(struct cf_parser *p, struct cf_token *peek)
+{
+	bool success = cf_peek_token(p, peek);
+	if (!success)
+		cf_adderror_unexpected_eof(p);
+	return success;
+}
+
+static inline bool cf_token_is(struct cf_parser *p, const char *val)
+{
+	return strref_cmp(&p->cur_token->str, val) == 0;
+}
+
+static inline int cf_token_is_type(struct cf_parser *p, enum cf_token_type type, const char *type_expected,
+				   const char *goto_token)
+{
+	if (p->cur_token->type != type) {
+		cf_adderror_expecting(p, type_expected);
+		if (goto_token) {
+			if (!cf_go_to_valid_token(p, goto_token, NULL))
+				return PARSE_EOF;
+		}
+		return PARSE_CONTINUE;
+	}
+
+	return PARSE_SUCCESS;
+}
+
+static inline void cf_copy_token(struct cf_parser *p, char **dst)
+{
+	*dst = bstrdup_n(p->cur_token->str.array, p->cur_token->str.len);
+}
+
+static inline int cf_get_name(struct cf_parser *p, char **dst, const char *name, const char *goto_token)
+{
+	int errcode;
+
+	errcode = cf_token_is_type(p, CFTOKEN_NAME, name, goto_token);
+	if (errcode != PARSE_SUCCESS)
+		return errcode;
+
+	*dst = bstrdup_n(p->cur_token->str.array, p->cur_token->str.len);
+	return PARSE_SUCCESS;
+}
+
+static inline int cf_next_name(struct cf_parser *p, char **dst, const char *name, const char *goto_token)
+{
+	if (!cf_next_valid_token(p))
+		return PARSE_EOF;
+
+	return cf_get_name(p, dst, name, goto_token);
+}
+
+static inline int cf_next_token_copy(struct cf_parser *p, char **dst)
+{
+	if (!cf_next_valid_token(p))
+		return PARSE_EOF;
+
+	cf_copy_token(p, dst);
+	return PARSE_SUCCESS;
+}
+
+static inline int cf_get_name_ref(struct cf_parser *p, struct strref *dst, const char *name, const char *goto_token)
+{
+	int errcode;
+
+	errcode = cf_token_is_type(p, CFTOKEN_NAME, name, goto_token);
+	if (errcode != PARSE_SUCCESS)
+		return errcode;
+
+	strref_copy(dst, &p->cur_token->str);
+	return PARSE_SUCCESS;
+}
+
+static inline int cf_next_name_ref(struct cf_parser *p, struct strref *dst, const char *name, const char *goto_token)
+{
+	if (!cf_next_valid_token(p))
+		return PARSE_EOF;
+
+	return cf_get_name_ref(p, dst, name, goto_token);
+}
+
+#ifdef __cplusplus
+}
+#endif

package/include/util/circlebuf.h

@@ -0,0 +1,319 @@
+/*
+ * Copyright (c) 2023 Lain Bailey <lain@obsproject.com>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#pragma once
+
+#include "c99defs.h"
+#include <string.h>
+#include <stdlib.h>
+#include <assert.h>
+
+#include "bmem.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dynamic circular buffer */
+
+OBS_DEPRECATED struct circlebuf {
+	void *data;
+	size_t size;
+
+	size_t start_pos;
+	size_t end_pos;
+	size_t capacity;
+};
+
+OBS_DEPRECATED static inline void circlebuf_init(struct circlebuf *cb)
+{
+	memset(cb, 0, sizeof(struct circlebuf));
+}
+
+OBS_DEPRECATED static inline void circlebuf_free(struct circlebuf *cb)
+{
+	bfree(cb->data);
+	memset(cb, 0, sizeof(struct circlebuf));
+}
+
+OBS_DEPRECATED static inline void circlebuf_reorder_data(struct circlebuf *cb, size_t new_capacity)
+{
+	size_t difference;
+	uint8_t *data;
+
+	if (!cb->size || !cb->start_pos || cb->end_pos > cb->start_pos)
+		return;
+
+	difference = new_capacity - cb->capacity;
+	data = (uint8_t *)cb->data + cb->start_pos;
+	memmove(data + difference, data, cb->capacity - cb->start_pos);
+	cb->start_pos += difference;
+}
+
+OBS_DEPRECATED static inline void circlebuf_ensure_capacity(struct circlebuf *cb)
+{
+	size_t new_capacity;
+	if (cb->size <= cb->capacity)
+		return;
+
+	new_capacity = cb->capacity * 2;
+	if (cb->size > new_capacity)
+		new_capacity = cb->size;
+
+	cb->data = brealloc(cb->data, new_capacity);
+	circlebuf_reorder_data(cb, new_capacity);
+	cb->capacity = new_capacity;
+}
+
+OBS_DEPRECATED static inline void circlebuf_reserve(struct circlebuf *cb, size_t capacity)
+{
+	if (capacity <= cb->capacity)
+		return;
+
+	cb->data = brealloc(cb->data, capacity);
+	circlebuf_reorder_data(cb, capacity);
+	cb->capacity = capacity;
+}
+
+OBS_DEPRECATED static inline void circlebuf_upsize(struct circlebuf *cb, size_t size)
+{
+	size_t add_size = size - cb->size;
+	size_t new_end_pos = cb->end_pos + add_size;
+
+	if (size <= cb->size)
+		return;
+
+	cb->size = size;
+	circlebuf_ensure_capacity(cb);
+
+	if (new_end_pos > cb->capacity) {
+		size_t back_size = cb->capacity - cb->end_pos;
+		size_t loop_size = add_size - back_size;
+
+		if (back_size)
+			memset((uint8_t *)cb->data + cb->end_pos, 0, back_size);
+
+		memset(cb->data, 0, loop_size);
+		new_end_pos -= cb->capacity;
+	} else {
+		memset((uint8_t *)cb->data + cb->end_pos, 0, add_size);
+	}
+
+	cb->end_pos = new_end_pos;
+}
+
+/** Overwrites data at a specific point in the buffer (relative).  */
+OBS_DEPRECATED static inline void circlebuf_place(struct circlebuf *cb, size_t position, const void *data, size_t size)
+{
+	size_t end_point = position + size;
+	size_t data_end_pos;
+
+	if (end_point > cb->size)
+		circlebuf_upsize(cb, end_point);
+
+	position += cb->start_pos;
+	if (position >= cb->capacity)
+		position -= cb->capacity;
+
+	data_end_pos = position + size;
+	if (data_end_pos > cb->capacity) {
+		size_t back_size = data_end_pos - cb->capacity;
+		size_t loop_size = size - back_size;
+
+		memcpy((uint8_t *)cb->data + position, data, loop_size);
+		memcpy(cb->data, (uint8_t *)data + loop_size, back_size);
+	} else {
+		memcpy((uint8_t *)cb->data + position, data, size);
+	}
+}
+
+OBS_DEPRECATED static inline void circlebuf_push_back(struct circlebuf *cb, const void *data, size_t size)
+{
+	size_t new_end_pos = cb->end_pos + size;
+
+	cb->size += size;
+	circlebuf_ensure_capacity(cb);
+
+	if (new_end_pos > cb->capacity) {
+		size_t back_size = cb->capacity - cb->end_pos;
+		size_t loop_size = size - back_size;
+
+		if (back_size)
+			memcpy((uint8_t *)cb->data + cb->end_pos, data, back_size);
+		memcpy(cb->data, (uint8_t *)data + back_size, loop_size);
+
+		new_end_pos -= cb->capacity;
+	} else {
+		memcpy((uint8_t *)cb->data + cb->end_pos, data, size);
+	}
+
+	cb->end_pos = new_end_pos;
+}
+
+OBS_DEPRECATED static inline void circlebuf_push_front(struct circlebuf *cb, const void *data, size_t size)
+{
+	cb->size += size;
+	circlebuf_ensure_capacity(cb);
+
+	if (cb->size == size) {
+		cb->start_pos = 0;
+		cb->end_pos = size;
+		memcpy((uint8_t *)cb->data, data, size);
+
+	} else if (cb->start_pos < size) {
+		size_t back_size = size - cb->start_pos;
+
+		if (cb->start_pos)
+			memcpy(cb->data, (uint8_t *)data + back_size, cb->start_pos);
+
+		cb->start_pos = cb->capacity - back_size;
+		memcpy((uint8_t *)cb->data + cb->start_pos, data, back_size);
+	} else {
+		cb->start_pos -= size;
+		memcpy((uint8_t *)cb->data + cb->start_pos, data, size);
+	}
+}
+
+OBS_DEPRECATED static inline void circlebuf_push_back_zero(struct circlebuf *cb, size_t size)
+{
+	size_t new_end_pos = cb->end_pos + size;
+
+	cb->size += size;
+	circlebuf_ensure_capacity(cb);
+
+	if (new_end_pos > cb->capacity) {
+		size_t back_size = cb->capacity - cb->end_pos;
+		size_t loop_size = size - back_size;
+
+		if (back_size)
+			memset((uint8_t *)cb->data + cb->end_pos, 0, back_size);
+		memset(cb->data, 0, loop_size);
+
+		new_end_pos -= cb->capacity;
+	} else {
+		memset((uint8_t *)cb->data + cb->end_pos, 0, size);
+	}
+
+	cb->end_pos = new_end_pos;
+}
+
+OBS_DEPRECATED static inline void circlebuf_push_front_zero(struct circlebuf *cb, size_t size)
+{
+	cb->size += size;
+	circlebuf_ensure_capacity(cb);
+
+	if (cb->size == size) {
+		cb->start_pos = 0;
+		cb->end_pos = size;
+		memset((uint8_t *)cb->data, 0, size);
+
+	} else if (cb->start_pos < size) {
+		size_t back_size = size - cb->start_pos;
+
+		if (cb->start_pos)
+			memset(cb->data, 0, cb->start_pos);
+
+		cb->start_pos = cb->capacity - back_size;
+		memset((uint8_t *)cb->data + cb->start_pos, 0, back_size);
+	} else {
+		cb->start_pos -= size;
+		memset((uint8_t *)cb->data + cb->start_pos, 0, size);
+	}
+}
+
+OBS_DEPRECATED static inline void circlebuf_peek_front(struct circlebuf *cb, void *data, size_t size)
+{
+	assert(size <= cb->size);
+
+	if (data) {
+		size_t start_size = cb->capacity - cb->start_pos;
+
+		if (start_size < size) {
+			memcpy(data, (uint8_t *)cb->data + cb->start_pos, start_size);
+			memcpy((uint8_t *)data + start_size, cb->data, size - start_size);
+		} else {
+			memcpy(data, (uint8_t *)cb->data + cb->start_pos, size);
+		}
+	}
+}
+
+OBS_DEPRECATED static inline void circlebuf_peek_back(struct circlebuf *cb, void *data, size_t size)
+{
+	assert(size <= cb->size);
+
+	if (data) {
+		size_t back_size = (cb->end_pos ? cb->end_pos : cb->capacity);
+
+		if (back_size < size) {
+			size_t front_size = size - back_size;
+			size_t new_end_pos = cb->capacity - front_size;
+
+			memcpy((uint8_t *)data + (size - back_size), cb->data, back_size);
+			memcpy(data, (uint8_t *)cb->data + new_end_pos, front_size);
+		} else {
+			memcpy(data, (uint8_t *)cb->data + cb->end_pos - size, size);
+		}
+	}
+}
+
+OBS_DEPRECATED static inline void circlebuf_pop_front(struct circlebuf *cb, void *data, size_t size)
+{
+	circlebuf_peek_front(cb, data, size);
+
+	cb->size -= size;
+	if (!cb->size) {
+		cb->start_pos = cb->end_pos = 0;
+		return;
+	}
+
+	cb->start_pos += size;
+	if (cb->start_pos >= cb->capacity)
+		cb->start_pos -= cb->capacity;
+}
+
+OBS_DEPRECATED static inline void circlebuf_pop_back(struct circlebuf *cb, void *data, size_t size)
+{
+	circlebuf_peek_back(cb, data, size);
+
+	cb->size -= size;
+	if (!cb->size) {
+		cb->start_pos = cb->end_pos = 0;
+		return;
+	}
+
+	if (cb->end_pos <= size)
+		cb->end_pos = cb->capacity - (size - cb->end_pos);
+	else
+		cb->end_pos -= size;
+}
+
+OBS_DEPRECATED static inline void *circlebuf_data(struct circlebuf *cb, size_t idx)
+{
+	uint8_t *ptr = (uint8_t *)cb->data;
+	size_t offset = cb->start_pos + idx;
+
+	if (idx >= cb->size)
+		return NULL;
+
+	if (offset >= cb->capacity)
+		offset -= cb->capacity;
+
+	return ptr + offset;
+}
+
+#ifdef __cplusplus
+}
+#endif

package/include/util/config-file.h

@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) 2023 Lain Bailey <lain@obsproject.com>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#pragma once
+
+#include "c99defs.h"
+
+/*
+ * Generic ini-style config file functions
+ *
+ * NOTE: It is highly recommended to use the default value functions (bottom of
+ * the file) before reading any variables from config files.
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct config_data;
+typedef struct config_data config_t;
+
+#define CONFIG_SUCCESS 0
+#define CONFIG_FILENOTFOUND -1
+#define CONFIG_ERROR -2
+
+enum config_open_type {
+	CONFIG_OPEN_EXISTING,
+	CONFIG_OPEN_ALWAYS,
+};
+
+EXPORT config_t *config_create(const char *file);
+EXPORT int config_open(config_t **config, const char *file, enum config_open_type open_type);
+EXPORT int config_open_string(config_t **config, const char *str);
+EXPORT int config_save(config_t *config);
+EXPORT int config_save_safe(config_t *config, const char *temp_ext, const char *backup_ext);
+EXPORT void config_close(config_t *config);
+
+EXPORT size_t config_num_sections(config_t *config);
+EXPORT const char *config_get_section(config_t *config, size_t idx);
+
+EXPORT void config_set_string(config_t *config, const char *section, const char *name, const char *value);
+EXPORT void config_set_int(config_t *config, const char *section, const char *name, int64_t value);
+EXPORT void config_set_uint(config_t *config, const char *section, const char *name, uint64_t value);
+EXPORT void config_set_bool(config_t *config, const char *section, const char *name, bool value);
+EXPORT void config_set_double(config_t *config, const char *section, const char *name, double value);
+
+EXPORT const char *config_get_string(config_t *config, const char *section, const char *name);
+EXPORT int64_t config_get_int(config_t *config, const char *section, const char *name);
+EXPORT uint64_t config_get_uint(config_t *config, const char *section, const char *name);
+EXPORT bool config_get_bool(config_t *config, const char *section, const char *name);
+EXPORT double config_get_double(config_t *config, const char *section, const char *name);
+
+EXPORT bool config_remove_value(config_t *config, const char *section, const char *name);
+
+/*
+ * DEFAULT VALUES
+ *
+ * The following functions are used to set what values will return if they do
+ * not exist.  Call these functions *once* for each known value before reading
+ * any of them anywhere else.
+ *
+ * These do *not* actually set any values, they only set what values will be
+ * returned for config_get_* if the specified variable does not exist.
+ *
+ * You can initialize the defaults programmatically using config_set_default_*
+ * functions (recommended for most cases), or you can initialize it via a file
+ * with config_open_defaults.
+ */
+EXPORT int config_open_defaults(config_t *config, const char *file);
+
+EXPORT void config_set_default_string(config_t *config, const char *section, const char *name, const char *value);
+EXPORT void config_set_default_int(config_t *config, const char *section, const char *name, int64_t value);
+EXPORT void config_set_default_uint(config_t *config, const char *section, const char *name, uint64_t value);
+EXPORT void config_set_default_bool(config_t *config, const char *section, const char *name, bool value);
+EXPORT void config_set_default_double(config_t *config, const char *section, const char *name, double value);
+
+/* These functions allow you to get the current default values rather than get
+ * the actual values.  Probably almost never really needed */
+EXPORT const char *config_get_default_string(config_t *config, const char *section, const char *name);
+EXPORT int64_t config_get_default_int(config_t *config, const char *section, const char *name);
+EXPORT uint64_t config_get_default_uint(config_t *config, const char *section, const char *name);
+EXPORT bool config_get_default_bool(config_t *config, const char *section, const char *name);
+EXPORT double config_get_default_double(config_t *config, const char *section, const char *name);
+
+EXPORT bool config_has_user_value(config_t *config, const char *section, const char *name);
+EXPORT bool config_has_default_value(config_t *config, const char *section, const char *name);
+
+#ifdef __cplusplus
+}
+#endif