noobs 0.0.6

package/include/util/lexer.h

@@ -0,0 +1,273 @@
+/*
+ * 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 "dstr.h"
+#include "darray.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* ------------------------------------------------------------------------- */
+/* string reference (string segment within an already existing array) */
+
+struct strref {
+	const char *array;
+	size_t len;
+};
+
+static inline void strref_clear(struct strref *dst)
+{
+	dst->array = NULL;
+	dst->len = 0;
+}
+
+static inline void strref_set(struct strref *dst, const char *array, size_t len)
+{
+	dst->array = array;
+	dst->len = len;
+}
+
+static inline void strref_copy(struct strref *dst, const struct strref *src)
+{
+	dst->array = src->array;
+	dst->len = src->len;
+}
+
+static inline void strref_add(struct strref *dst, const struct strref *t)
+{
+	if (!dst->array)
+		strref_copy(dst, t);
+	else
+		dst->len += t->len;
+}
+
+static inline bool strref_is_empty(const struct strref *str)
+{
+	return !str || !str->array || !str->len || !*str->array;
+}
+
+EXPORT int strref_cmp(const struct strref *str1, const char *str2);
+EXPORT int strref_cmpi(const struct strref *str1, const char *str2);
+EXPORT int strref_cmp_strref(const struct strref *str1, const struct strref *str2);
+EXPORT int strref_cmpi_strref(const struct strref *str1, const struct strref *str2);
+
+/* ------------------------------------------------------------------------- */
+
+EXPORT bool valid_int_str(const char *str, size_t n);
+EXPORT bool valid_float_str(const char *str, size_t n);
+
+static inline bool valid_int_strref(const struct strref *str)
+{
+	return valid_int_str(str->array, str->len);
+}
+
+static inline bool valid_float_strref(const struct strref *str)
+{
+	return valid_float_str(str->array, str->len);
+}
+
+static inline bool is_whitespace(char ch)
+{
+	return ch == ' ' || ch == '\r' || ch == '\t' || ch == '\n';
+}
+
+static inline bool is_newline(char ch)
+{
+	return ch == '\r' || ch == '\n';
+}
+
+static inline bool is_space_or_tab(const char ch)
+{
+	return ch == ' ' || ch == '\t';
+}
+
+static inline bool is_newline_pair(char ch1, char ch2)
+{
+	return (ch1 == '\r' && ch2 == '\n') || (ch1 == '\n' && ch2 == '\r');
+}
+
+static inline int newline_size(const char *array)
+{
+	if (strncmp(array, "\r\n", 2) == 0 || strncmp(array, "\n\r", 2) == 0)
+		return 2;
+	else if (*array == '\r' || *array == '\n')
+		return 1;
+
+	return 0;
+}
+
+/* ------------------------------------------------------------------------- */
+
+/*
+ * A "base" token is one of four things:
+ *   1.) A sequence of alpha characters
+ *   2.) A sequence of numeric characters
+ *   3.) A single whitespace character if whitespace is not ignored
+ *   4.) A single character that does not fall into the above 3 categories
+ */
+
+enum base_token_type {
+	BASETOKEN_NONE,
+	BASETOKEN_ALPHA,
+	BASETOKEN_DIGIT,
+	BASETOKEN_WHITESPACE,
+	BASETOKEN_OTHER,
+};
+
+struct base_token {
+	struct strref text;
+	enum base_token_type type;
+	bool passed_whitespace;
+};
+
+static inline void base_token_clear(struct base_token *t)
+{
+	memset(t, 0, sizeof(struct base_token));
+}
+
+static inline void base_token_copy(struct base_token *dst, struct base_token *src)
+{
+	memcpy(dst, src, sizeof(struct base_token));
+}
+
+/* ------------------------------------------------------------------------- */
+
+#define LEX_ERROR 0
+#define LEX_WARNING 1
+
+struct error_item {
+	char *error;
+	const char *file;
+	uint32_t row, column;
+	int level;
+};
+
+static inline void error_item_init(struct error_item *ei)
+{
+	memset(ei, 0, sizeof(struct error_item));
+}
+
+static inline void error_item_free(struct error_item *ei)
+{
+	bfree(ei->error);
+	error_item_init(ei);
+}
+
+static inline void error_item_array_free(struct error_item *array, size_t num)
+{
+	size_t i;
+	for (i = 0; i < num; i++)
+		error_item_free(array + i);
+}
+
+/* ------------------------------------------------------------------------- */
+
+struct error_data {
+	DARRAY(struct error_item) errors;
+};
+
+static inline void error_data_init(struct error_data *data)
+{
+	da_init(data->errors);
+}
+
+static inline void error_data_free(struct error_data *data)
+{
+	error_item_array_free(data->errors.array, data->errors.num);
+	da_free(data->errors);
+}
+
+static inline const struct error_item *error_data_item(struct error_data *ed, size_t idx)
+{
+	return ed->errors.array + idx;
+}
+
+EXPORT char *error_data_buildstring(struct error_data *ed);
+
+EXPORT void error_data_add(struct error_data *ed, const char *file, uint32_t row, uint32_t column, const char *msg,
+			   int level);
+
+static inline size_t error_data_type_count(struct error_data *ed, int type)
+{
+	size_t count = 0, i;
+	for (i = 0; i < ed->errors.num; i++) {
+		if (ed->errors.array[i].level == type)
+			count++;
+	}
+
+	return count;
+}
+
+static inline bool error_data_has_errors(struct error_data *ed)
+{
+	size_t i;
+	for (i = 0; i < ed->errors.num; i++)
+		if (ed->errors.array[i].level == LEX_ERROR)
+			return true;
+
+	return false;
+}
+
+/* ------------------------------------------------------------------------- */
+
+struct lexer {
+	char *text;
+	const char *offset;
+};
+
+static inline void lexer_init(struct lexer *lex)
+{
+	memset(lex, 0, sizeof(struct lexer));
+}
+
+static inline void lexer_free(struct lexer *lex)
+{
+	bfree(lex->text);
+	lexer_init(lex);
+}
+
+static inline void lexer_start(struct lexer *lex, const char *text)
+{
+	lexer_free(lex);
+	lex->text = bstrdup(text);
+	lex->offset = lex->text;
+}
+
+static inline void lexer_start_move(struct lexer *lex, char *text)
+{
+	lexer_free(lex);
+	lex->text = text;
+	lex->offset = lex->text;
+}
+
+static inline void lexer_reset(struct lexer *lex)
+{
+	lex->offset = lex->text;
+}
+
+enum ignore_whitespace { PARSE_WHITESPACE, IGNORE_WHITESPACE };
+
+EXPORT bool lexer_getbasetoken(struct lexer *lex, struct base_token *t, enum ignore_whitespace iws);
+
+EXPORT void lexer_getstroffset(const struct lexer *lex, const char *str, uint32_t *row, uint32_t *col);
+
+#ifdef __cplusplus
+}
+#endif

package/include/util/pipe.h

@@ -0,0 +1,52 @@
+/*
+ * 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"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct os_process_pipe;
+typedef struct os_process_pipe os_process_pipe_t;
+
+struct os_process_args;
+typedef struct os_process_args os_process_args_t;
+
+EXPORT os_process_pipe_t *os_process_pipe_create(const char *cmd_line, const char *type);
+EXPORT os_process_pipe_t *os_process_pipe_create2(const os_process_args_t *args, const char *type);
+EXPORT int os_process_pipe_destroy(os_process_pipe_t *pp);
+
+EXPORT size_t os_process_pipe_read(os_process_pipe_t *pp, uint8_t *data, size_t len);
+EXPORT size_t os_process_pipe_read_err(os_process_pipe_t *pp, uint8_t *data, size_t len);
+EXPORT size_t os_process_pipe_write(os_process_pipe_t *pp, const uint8_t *data, size_t len);
+
+EXPORT struct os_process_args *os_process_args_create(const char *executable);
+EXPORT void os_process_args_add_arg(struct os_process_args *args, const char *arg);
+#ifndef _MSC_VER
+__attribute__((__format__(__printf__, 2, 3)))
+#endif
+EXPORT void
+os_process_args_add_argf(struct os_process_args *args, const char *format, ...);
+EXPORT char **os_process_args_get_argv(const struct os_process_args *args);
+EXPORT size_t os_process_args_get_argc(struct os_process_args *args);
+EXPORT void os_process_args_destroy(struct os_process_args *args);
+
+#ifdef __cplusplus
+}
+#endif

package/include/util/platform.h

@@ -0,0 +1,223 @@
+/*
+ * 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 <stdio.h>
+#include <wchar.h>
+#include <sys/types.h>
+#include "c99defs.h"
+
+/*
+ * Platform-independent functions for Accessing files, encoding, DLLs,
+ * sleep, timer, and timing.
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+EXPORT FILE *os_wfopen(const wchar_t *path, const char *mode);
+EXPORT FILE *os_fopen(const char *path, const char *mode);
+EXPORT int64_t os_fgetsize(FILE *file);
+
+#ifdef _WIN32
+EXPORT int os_stat(const char *file, struct stat *st);
+#else
+#define os_stat stat
+#endif
+
+EXPORT int os_fseeki64(FILE *file, int64_t offset, int origin);
+EXPORT int64_t os_ftelli64(FILE *file);
+
+EXPORT size_t os_fread_mbs(FILE *file, char **pstr);
+EXPORT size_t os_fread_utf8(FILE *file, char **pstr);
+
+/* functions purely for convenience */
+EXPORT char *os_quick_read_utf8_file(const char *path);
+EXPORT bool os_quick_write_utf8_file(const char *path, const char *str, size_t len, bool marker);
+EXPORT bool os_quick_write_utf8_file_safe(const char *path, const char *str, size_t len, bool marker,
+					  const char *temp_ext, const char *backup_ext);
+EXPORT char *os_quick_read_mbs_file(const char *path);
+EXPORT bool os_quick_write_mbs_file(const char *path, const char *str, size_t len);
+
+EXPORT int64_t os_get_file_size(const char *path);
+EXPORT int64_t os_get_free_space(const char *path);
+
+EXPORT size_t os_mbs_to_wcs(const char *str, size_t str_len, wchar_t *dst, size_t dst_size);
+EXPORT size_t os_utf8_to_wcs(const char *str, size_t len, wchar_t *dst, size_t dst_size);
+EXPORT size_t os_wcs_to_mbs(const wchar_t *str, size_t len, char *dst, size_t dst_size);
+EXPORT size_t os_wcs_to_utf8(const wchar_t *str, size_t len, char *dst, size_t dst_size);
+
+EXPORT size_t os_mbs_to_wcs_ptr(const char *str, size_t len, wchar_t **pstr);
+EXPORT size_t os_utf8_to_wcs_ptr(const char *str, size_t len, wchar_t **pstr);
+EXPORT size_t os_wcs_to_mbs_ptr(const wchar_t *str, size_t len, char **pstr);
+EXPORT size_t os_wcs_to_utf8_ptr(const wchar_t *str, size_t len, char **pstr);
+
+EXPORT size_t os_utf8_to_mbs_ptr(const char *str, size_t len, char **pstr);
+EXPORT size_t os_mbs_to_utf8_ptr(const char *str, size_t len, char **pstr);
+
+EXPORT double os_strtod(const char *str);
+EXPORT int os_dtostr(double value, char *dst, size_t size);
+
+EXPORT void *os_dlopen(const char *path);
+EXPORT void *os_dlsym(void *module, const char *func);
+EXPORT void os_dlclose(void *module);
+EXPORT bool os_is_obs_plugin(const char *path);
+
+struct os_cpu_usage_info;
+typedef struct os_cpu_usage_info os_cpu_usage_info_t;
+
+EXPORT os_cpu_usage_info_t *os_cpu_usage_info_start(void);
+EXPORT double os_cpu_usage_info_query(os_cpu_usage_info_t *info);
+EXPORT void os_cpu_usage_info_destroy(os_cpu_usage_info_t *info);
+
+typedef const void os_performance_token_t;
+EXPORT os_performance_token_t *os_request_high_performance(const char *reason);
+EXPORT void os_end_high_performance(os_performance_token_t *);
+
+/**
+ * Sleeps to a specific time (in nanoseconds).  Doesn't have to be super
+ * accurate in terms of actual slept time because the target time is ensured.
+ * Returns false if already at or past target time.
+ */
+EXPORT bool os_sleepto_ns(uint64_t time_target);
+EXPORT bool os_sleepto_ns_fast(uint64_t time_target);
+EXPORT void os_sleep_ms(uint32_t duration);
+
+EXPORT uint64_t os_gettime_ns(void);
+
+EXPORT int os_get_config_path(char *dst, size_t size, const char *name);
+EXPORT char *os_get_config_path_ptr(const char *name);
+
+EXPORT int os_get_program_data_path(char *dst, size_t size, const char *name);
+EXPORT char *os_get_program_data_path_ptr(const char *name);
+
+EXPORT char *os_get_executable_path_ptr(const char *name);
+
+EXPORT bool os_file_exists(const char *path);
+
+EXPORT size_t os_get_abs_path(const char *path, char *abspath, size_t size);
+EXPORT char *os_get_abs_path_ptr(const char *path);
+
+EXPORT const char *os_get_path_extension(const char *path);
+
+EXPORT bool os_get_emulation_status(void);
+
+struct os_dir;
+typedef struct os_dir os_dir_t;
+
+struct os_dirent {
+	char d_name[256];
+	bool directory;
+};
+
+EXPORT os_dir_t *os_opendir(const char *path);
+EXPORT struct os_dirent *os_readdir(os_dir_t *dir);
+EXPORT void os_closedir(os_dir_t *dir);
+
+struct os_globent {
+	char *path;
+	bool directory;
+};
+
+struct os_glob_info {
+	size_t gl_pathc;
+	struct os_globent *gl_pathv;
+};
+
+typedef struct os_glob_info os_glob_t;
+
+/* currently no flags available */
+
+EXPORT int os_glob(const char *pattern, int flags, os_glob_t **pglob);
+EXPORT void os_globfree(os_glob_t *pglob);
+
+EXPORT int os_unlink(const char *path);
+EXPORT int os_rmdir(const char *path);
+
+EXPORT char *os_getcwd(char *path, size_t size);
+EXPORT int os_chdir(const char *path);
+
+EXPORT uint64_t os_get_free_disk_space(const char *dir);
+
+#define MKDIR_EXISTS 1
+#define MKDIR_SUCCESS 0
+#define MKDIR_ERROR -1
+
+EXPORT int os_mkdir(const char *path);
+EXPORT int os_mkdirs(const char *path);
+EXPORT int os_rename(const char *old_path, const char *new_path);
+EXPORT int os_copyfile(const char *file_in, const char *file_out);
+EXPORT int os_safe_replace(const char *target_path, const char *from_path, const char *backup_path);
+
+EXPORT char *os_generate_formatted_filename(const char *extension, bool space, const char *format);
+
+struct os_inhibit_info;
+typedef struct os_inhibit_info os_inhibit_t;
+
+EXPORT os_inhibit_t *os_inhibit_sleep_create(const char *reason);
+EXPORT bool os_inhibit_sleep_set_active(os_inhibit_t *info, bool active);
+EXPORT void os_inhibit_sleep_destroy(os_inhibit_t *info);
+
+EXPORT void os_breakpoint(void);
+
+EXPORT int os_get_physical_cores(void);
+EXPORT int os_get_logical_cores(void);
+
+EXPORT uint64_t os_get_sys_free_size(void);
+EXPORT uint64_t os_get_sys_total_size(void);
+
+struct os_proc_memory_usage {
+	uint64_t resident_size;
+	uint64_t virtual_size;
+};
+typedef struct os_proc_memory_usage os_proc_memory_usage_t;
+
+EXPORT bool os_get_proc_memory_usage(os_proc_memory_usage_t *usage);
+EXPORT uint64_t os_get_proc_resident_size(void);
+EXPORT uint64_t os_get_proc_virtual_size(void);
+
+#define UUID_STR_LENGTH 36
+
+EXPORT char *os_generate_uuid(void);
+
+EXPORT
+struct timespec *os_nstime_to_timespec(uint64_t timestamp, struct timespec *storage);
+
+/* clang-format off */
+#ifdef __APPLE__
+# define ARCH_BITS 64
+#else
+# ifdef _WIN32
+#  ifdef _WIN64
+#   define ARCH_BITS 64
+#  else
+#   define ARCH_BITS 32
+#  endif
+# else
+#  ifdef __LP64__
+#   define ARCH_BITS 64
+#  else
+#   define ARCH_BITS 32
+#  endif
+# endif
+#endif
+/* clang-format on */
+
+#ifdef __cplusplus
+}
+#endif

package/include/util/profiler.h

@@ -0,0 +1,97 @@
+#pragma once
+
+#include "base.h"
+#include "darray.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct profiler_snapshot profiler_snapshot_t;
+typedef struct profiler_snapshot_entry profiler_snapshot_entry_t;
+typedef struct profiler_time_entry profiler_time_entry_t;
+
+/* ------------------------------------------------------------------------- */
+/* Profiling */
+
+EXPORT void profile_register_root(const char *name, uint64_t expected_time_between_calls);
+
+EXPORT void profile_start(const char *name);
+EXPORT void profile_end(const char *name);
+
+EXPORT void profile_reenable_thread(void);
+
+/* ------------------------------------------------------------------------- */
+/* Profiler control */
+
+EXPORT void profiler_start(void);
+EXPORT void profiler_stop(void);
+
+EXPORT void profiler_print(profiler_snapshot_t *snap);
+EXPORT void profiler_print_time_between_calls(profiler_snapshot_t *snap);
+
+EXPORT void profiler_free(void);
+
+/* ------------------------------------------------------------------------- */
+/* Profiler name storage */
+
+typedef struct profiler_name_store profiler_name_store_t;
+
+EXPORT profiler_name_store_t *profiler_name_store_create(void);
+EXPORT void profiler_name_store_free(profiler_name_store_t *store);
+
+#ifndef _MSC_VER
+#define PRINTFATTR(f, a) __attribute__((__format__(__printf__, f, a)))
+#else
+#define PRINTFATTR(f, a)
+#endif
+
+PRINTFATTR(2, 3)
+EXPORT const char *profile_store_name(profiler_name_store_t *store, const char *format, ...);
+
+#undef PRINTFATTR
+
+/* ------------------------------------------------------------------------- */
+/* Profiler data access */
+
+struct profiler_time_entry {
+	uint64_t time_delta;
+	uint64_t count;
+};
+
+typedef DARRAY(profiler_time_entry_t) profiler_time_entries_t;
+
+typedef bool (*profiler_entry_enum_func)(void *context, profiler_snapshot_entry_t *entry);
+
+EXPORT profiler_snapshot_t *profile_snapshot_create(void);
+EXPORT void profile_snapshot_free(profiler_snapshot_t *snap);
+
+EXPORT bool profiler_snapshot_dump_csv(const profiler_snapshot_t *snap, const char *filename);
+EXPORT bool profiler_snapshot_dump_csv_gz(const profiler_snapshot_t *snap, const char *filename);
+
+EXPORT size_t profiler_snapshot_num_roots(profiler_snapshot_t *snap);
+EXPORT void profiler_snapshot_enumerate_roots(profiler_snapshot_t *snap, profiler_entry_enum_func func, void *context);
+
+typedef bool (*profiler_name_filter_func)(void *data, const char *name, bool *remove);
+EXPORT void profiler_snapshot_filter_roots(profiler_snapshot_t *snap, profiler_name_filter_func func, void *data);
+
+EXPORT size_t profiler_snapshot_num_children(profiler_snapshot_entry_t *entry);
+EXPORT void profiler_snapshot_enumerate_children(profiler_snapshot_entry_t *entry, profiler_entry_enum_func func,
+						 void *context);
+
+EXPORT const char *profiler_snapshot_entry_name(profiler_snapshot_entry_t *entry);
+
+EXPORT profiler_time_entries_t *profiler_snapshot_entry_times(profiler_snapshot_entry_t *entry);
+EXPORT uint64_t profiler_snapshot_entry_min_time(profiler_snapshot_entry_t *entry);
+EXPORT uint64_t profiler_snapshot_entry_max_time(profiler_snapshot_entry_t *entry);
+EXPORT uint64_t profiler_snapshot_entry_overall_count(profiler_snapshot_entry_t *entry);
+
+EXPORT profiler_time_entries_t *profiler_snapshot_entry_times_between_calls(profiler_snapshot_entry_t *entry);
+EXPORT uint64_t profiler_snapshot_entry_expected_time_between_calls(profiler_snapshot_entry_t *entry);
+EXPORT uint64_t profiler_snapshot_entry_min_time_between_calls(profiler_snapshot_entry_t *entry);
+EXPORT uint64_t profiler_snapshot_entry_max_time_between_calls(profiler_snapshot_entry_t *entry);
+EXPORT uint64_t profiler_snapshot_entry_overall_between_calls_count(profiler_snapshot_entry_t *entry);
+
+#ifdef __cplusplus
+}
+#endif