@patleeman/pi-boy 0.1.0

package/mgba-bridge/vendor/mgba/include/mgba-util/table.h

@@ -0,0 +1,93 @@
+/* Copyright (c) 2013-2014 Jeffrey Pfau
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+#ifndef TABLE_H
+#define TABLE_H
+
+#include <mgba-util/common.h>
+
+CXX_GUARD_START
+
+struct TableList;
+typedef uint32_t (*HashFunction)(const void* key, size_t len, uint32_t seed);
+
+struct TableFunctions {
+	void (*deinitializer)(void*);
+	HashFunction hash;
+	bool (*equal)(const void*, const void*);
+	void* (*ref)(void*);
+	void (*deref)(void*);
+};
+
+struct Table {
+	struct TableList* table;
+	size_t tableSize;
+	size_t size;
+	uint32_t seed;
+	struct TableFunctions fn;
+};
+
+struct TableIterator {
+	size_t bucket;
+	size_t entry;
+};
+
+void TableInit(struct Table*, size_t initialSize, void (*deinitializer)(void*));
+void TableDeinit(struct Table*);
+
+void* TableLookup(const struct Table*, uint32_t key);
+void TableInsert(struct Table*, uint32_t key, void* value);
+
+void TableRemove(struct Table*, uint32_t key);
+void TableClear(struct Table*);
+
+void TableEnumerate(const struct Table*, void (*handler)(uint32_t key, void* value, void* user), void* user);
+size_t TableSize(const struct Table*);
+
+bool TableIteratorStart(const struct Table*, struct TableIterator*);
+bool TableIteratorNext(const struct Table*, struct TableIterator*);
+uint32_t TableIteratorGetKey(const struct Table*, const struct TableIterator*);
+void* TableIteratorGetValue(const struct Table*, const struct TableIterator*);
+bool TableIteratorLookup(const struct Table*, struct TableIterator*, uint32_t key);
+
+void HashTableInit(struct Table* table, size_t initialSize, void (*deinitializer)(void*));
+void HashTableInitCustom(struct Table* table, size_t initialSize, const struct TableFunctions* funcs);
+void HashTableDeinit(struct Table* table);
+
+void* HashTableLookup(const struct Table*, const char* key);
+void* HashTableLookupBinary(const struct Table*, const void* key, size_t keylen);
+void* HashTableLookupCustom(const struct Table*, void* key);
+void HashTableInsert(struct Table*, const char* key, void* value);
+void HashTableInsertBinary(struct Table*, const void* key, size_t keylen, void* value);
+void HashTableInsertCustom(struct Table*, void* key, void* value);
+
+void HashTableRemove(struct Table*, const char* key);
+void HashTableRemoveBinary(struct Table*, const void* key, size_t keylen);
+void HashTableRemoveCustom(struct Table*, void* key);
+void HashTableClear(struct Table*);
+
+void HashTableEnumerate(const struct Table*, void (*handler)(const char* key, void* value, void* user), void* user);
+void HashTableEnumerateBinary(const struct Table*, void (*handler)(const char* key, size_t keylen, void* value, void* user), void* user);
+void HashTableEnumerateCustom(const struct Table*, void (*handler)(void* key, void* value, void* user), void* user);
+const char* HashTableSearch(const struct Table* table, bool (*predicate)(const char* key, const void* value, const void* user), const void* user);
+const char* HashTableSearchPointer(const struct Table* table, const void* value);
+const char* HashTableSearchData(const struct Table* table, const void* value, size_t bytes);
+const char* HashTableSearchString(const struct Table* table, const char* value);
+size_t HashTableSize(const struct Table*);
+
+bool HashTableIteratorStart(const struct Table*, struct TableIterator*);
+bool HashTableIteratorNext(const struct Table*, struct TableIterator*);
+const char* HashTableIteratorGetKey(const struct Table*, const struct TableIterator*);
+const void* HashTableIteratorGetBinaryKey(const struct Table*, const struct TableIterator*);
+size_t HashTableIteratorGetBinaryKeyLen(const struct Table*, const struct TableIterator*);
+void* HashTableIteratorGetCustomKey(const struct Table*, const struct TableIterator*);
+void* HashTableIteratorGetValue(const struct Table*, const struct TableIterator*);
+bool HashTableIteratorLookup(const struct Table*, struct TableIterator*, const char* key);
+bool HashTableIteratorLookupBinary(const struct Table*, struct TableIterator*, const void* key, size_t keylen);
+bool HashTableIteratorLookupCustom(const struct Table*, struct TableIterator*, void* key);
+
+CXX_GUARD_END
+
+#endif

package/mgba-bridge/vendor/mgba/include/mgba-util/text-codec.h

@@ -0,0 +1,36 @@
+/* Copyright (c) 2013-2016 Jeffrey Pfau
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+#ifndef TEXT_CODEC_H
+#define TEXT_CODEC_H
+
+#include <mgba-util/common.h>
+
+CXX_GUARD_START
+
+struct TextCodecNode;
+struct TextCodec {
+	struct TextCodecNode* forwardRoot;
+	struct TextCodecNode* reverseRoot;
+};
+
+struct TextCodecIterator {
+	struct TextCodecNode* root;
+	struct TextCodecNode* current;
+};
+
+struct VFile;
+bool TextCodecLoadTBL(struct TextCodec*, struct VFile*, bool createReverse);
+void TextCodecDeinit(struct TextCodec*);
+
+void TextCodecStartDecode(struct TextCodec*, struct TextCodecIterator*);
+void TextCodecStartEncode(struct TextCodec*, struct TextCodecIterator*);
+
+ssize_t TextCodecAdvance(struct TextCodecIterator*, uint8_t byte, uint8_t* output, size_t outputLength);
+ssize_t TextCodecFinish(struct TextCodecIterator*, uint8_t* output, size_t outputLength);
+
+CXX_GUARD_END
+
+#endif

package/mgba-bridge/vendor/mgba/include/mgba-util/threading.h

@@ -0,0 +1,123 @@
+/* Copyright (c) 2013-2015 Jeffrey Pfau
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+#ifndef THREADING_H
+#define THREADING_H
+
+#include <mgba-util/common.h>
+
+CXX_GUARD_START
+
+#ifndef DISABLE_THREADING
+#ifdef USE_PTHREADS
+#include <mgba-util/platform/posix/threading.h>
+#elif defined(_WIN32)
+#include <mgba-util/platform/windows/threading.h>
+#elif defined(PSP2)
+#include <mgba-util/platform/psp2/threading.h>
+#elif defined(__3DS__)
+#include <mgba-util/platform/3ds/threading.h>
+#elif defined(__SWITCH__)
+#include <mgba-util/platform/switch/threading.h>
+#else
+#define DISABLE_THREADING
+#endif
+#endif
+
+#ifndef DISABLE_THREADING
+#if (__STDC_VERSION__ >= 201112L) && (__STDC_NO_THREADS__ != 1)
+#define ThreadLocal _Thread_local void*
+#define ThreadLocalInitKey(X)
+#define ThreadLocalSetKey(K, V) K = V
+#define ThreadLocalGetValue(K) K
+#endif
+#else
+#ifdef __3DS__
+// ctrulib already has a type called Thread
+#include <3ds/thread.h>
+#elif defined(__SWITCH__)
+#include <switch/kernel/thread.h>
+#else
+typedef void* Thread;
+#endif
+#ifdef __SWITCH__
+#include <switch/kernel/mutex.h>
+#else
+typedef void* Mutex;
+#endif
+typedef void* Condition;
+typedef int ThreadLocal;
+
+static inline int MutexInit(Mutex* mutex) {
+	UNUSED(mutex);
+	return 0;
+}
+
+static inline int MutexDeinit(Mutex* mutex) {
+	UNUSED(mutex);
+	return 0;
+}
+
+static inline int MutexLock(Mutex* mutex) {
+	UNUSED(mutex);
+	return 0;
+}
+
+static inline int MutexTryLock(Mutex* mutex) {
+	UNUSED(mutex);
+	return 0;
+}
+
+static inline int MutexUnlock(Mutex* mutex) {
+	UNUSED(mutex);
+	return 0;
+}
+
+static inline int ConditionInit(Condition* cond) {
+	UNUSED(cond);
+	return 0;
+}
+
+static inline int ConditionDeinit(Condition* cond) {
+	UNUSED(cond);
+	return 0;
+}
+
+static inline int ConditionWait(Condition* cond, Mutex* mutex) {
+	UNUSED(cond);
+	UNUSED(mutex);
+	return 0;
+}
+
+static inline int ConditionWaitTimed(Condition* cond, Mutex* mutex, int32_t timeoutMs) {
+	UNUSED(cond);
+	UNUSED(mutex);
+	UNUSED(timeoutMs);
+	return 0;
+}
+
+static inline int ConditionWake(Condition* cond) {
+	UNUSED(cond);
+	return 0;
+}
+
+static inline void ThreadLocalInitKey(ThreadLocal* key) {
+	UNUSED(key);
+}
+
+static inline void ThreadLocalSetKey(ThreadLocal key, void* value) {
+	UNUSED(key);
+	UNUSED(value);
+}
+
+static inline void* ThreadLocalGetValue(ThreadLocal key) {
+	UNUSED(key);
+	return NULL;
+}
+#endif
+
+CXX_GUARD_END
+
+#endif

package/mgba-bridge/vendor/mgba/include/mgba-util/vector.h

@@ -0,0 +1,128 @@
+/* Copyright (c) 2013-2015 Jeffrey Pfau
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+#ifndef VECTOR_H
+#define VECTOR_H
+
+#include <mgba-util/common.h>
+
+CXX_GUARD_START
+
+#ifdef vector
+#undef vector
+#endif
+
+#define DECLARE_VECTOR(NAME, TYPE) \
+	struct NAME { \
+		TYPE* vector; \
+		size_t size; \
+		size_t capacity; \
+	}; \
+	void NAME ## Init(struct NAME* vector, size_t capacity); \
+	void NAME ## Deinit(struct NAME* vector); \
+	TYPE* NAME ## GetPointer(struct NAME* vector, size_t location); \
+	TYPE const* NAME ## GetConstPointer(const struct NAME* vector, size_t location); \
+	TYPE* NAME ## Append(struct NAME* vector); \
+	void NAME ## Clear(struct NAME* vector); \
+	void NAME ## Resize(struct NAME* vector, ssize_t change); \
+	void NAME ## Shift(struct NAME* vector, size_t location, size_t difference); \
+	void NAME ## Unshift(struct NAME* vector, size_t location, size_t difference); \
+	void NAME ## EnsureCapacity(struct NAME* vector, size_t capacity); \
+	size_t NAME ## Size(const struct NAME* vector); \
+	size_t NAME ## Index(const struct NAME* vector, const TYPE* member); \
+	void NAME ## Copy(struct NAME* dest, const struct NAME* src);
+
+#ifdef NDEBUG
+#define VECTOR_BOUNDS_CHECK(NAME, V, L)
+#else
+#define VECTOR_BOUNDS_CHECK(NAME, V, L) \
+	if ((L) >= (V)->size) { \
+		fprintf(stderr, "Vector type %s invalid access of index %" PRIuPTR " into vector of size %" PRIuPTR "\n", #NAME, (L), (V)->size); \
+		abort(); \
+	}
+#endif
+
+#define DEFINE_VECTOR(NAME, TYPE) \
+	void NAME ## Init(struct NAME* vector, size_t capacity) { \
+		vector->size = 0; \
+		if (capacity == 0) { \
+			capacity = 4; \
+		} \
+		vector->capacity = capacity; \
+		vector->vector = calloc(capacity, sizeof(TYPE)); \
+	} \
+	void NAME ## Deinit(struct NAME* vector) { \
+		free(vector->vector); \
+		vector->vector = 0; \
+		vector->capacity = 0; \
+		vector->size = 0; \
+	} \
+	TYPE* NAME ## GetPointer(struct NAME* vector, size_t location) { \
+		VECTOR_BOUNDS_CHECK(NAME, vector, location); \
+		return &vector->vector[location]; \
+	} \
+	TYPE const* NAME ## GetConstPointer(const struct NAME* vector, size_t location) { \
+		VECTOR_BOUNDS_CHECK(NAME, vector, location); \
+		return &vector->vector[location]; \
+	} \
+	TYPE* NAME ## Append(struct NAME* vector) { \
+		NAME ## Resize(vector, 1); \
+		return &vector->vector[vector->size - 1]; \
+	} \
+	void NAME ## Resize(struct NAME* vector, ssize_t change) { \
+		if (change > 0) { \
+			NAME ## EnsureCapacity(vector, vector->size + change); \
+		} \
+		vector->size += change; \
+	} \
+	void NAME ## Clear(struct NAME* vector) { \
+		vector->size = 0; \
+	} \
+	void NAME ## EnsureCapacity(struct NAME* vector, size_t capacity) { \
+		if (capacity <= vector->capacity) { \
+			return; \
+		} \
+		while (capacity > vector->capacity) { \
+			vector->capacity <<= 1; \
+		} \
+		vector->vector = realloc(vector->vector, vector->capacity * sizeof(TYPE)); \
+	} \
+	void NAME ## Shift(struct NAME* vector, size_t location, size_t difference) { \
+		VECTOR_BOUNDS_CHECK(NAME, vector, location); \
+		memmove(&vector->vector[location], &vector->vector[location + difference], (vector->size - location - difference) * sizeof(TYPE)); \
+		vector->size -= difference; \
+	} \
+	void NAME ## Unshift(struct NAME* vector, size_t location, size_t difference) { \
+		VECTOR_BOUNDS_CHECK(NAME, vector, location); \
+		NAME ## Resize(vector, difference); \
+		memmove(&vector->vector[location + difference], &vector->vector[location], (vector->size - location - difference) * sizeof(TYPE)); \
+	} \
+	size_t NAME ## Size(const struct NAME* vector) { \
+		return vector->size; \
+	} \
+	size_t NAME ## Index(const struct NAME* vector, const TYPE* member) { \
+		return member - (const TYPE*) vector->vector; \
+	} \
+	void NAME ## Copy(struct NAME* dest, const struct NAME* src) { \
+		NAME ## EnsureCapacity(dest, src->size); \
+		memcpy(dest->vector, src->vector, src->size * sizeof(TYPE)); \
+		dest->size = src->size; \
+	} \
+
+DECLARE_VECTOR(IntList, int);
+DECLARE_VECTOR(UIntList, unsigned);
+DECLARE_VECTOR(SInt8List, int8_t);
+DECLARE_VECTOR(SInt16List, int16_t);
+DECLARE_VECTOR(SInt32List, int32_t);
+DECLARE_VECTOR(SIntPtrList, intptr_t);
+DECLARE_VECTOR(UInt8List, uint8_t);
+DECLARE_VECTOR(UInt16List, uint16_t);
+DECLARE_VECTOR(UInt32List, uint32_t);
+DECLARE_VECTOR(UIntPtrList, uintptr_t);
+DECLARE_VECTOR(StringList, char*);
+
+CXX_GUARD_END
+
+#endif

package/mgba-bridge/vendor/mgba/include/mgba-util/vfs.h

@@ -0,0 +1,125 @@
+/* Copyright (c) 2013-2014 Jeffrey Pfau
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+#ifndef VFS_H
+#define VFS_H
+
+#include <mgba-util/common.h>
+
+CXX_GUARD_START
+
+#ifdef _WIN32
+#include <io.h>
+#include <windows.h>
+#define PATH_SEP "/" // Windows can handle slashes, and backslashes confuse some libraries
+#else
+#define PATH_SEP "/"
+#endif
+
+#ifndef PATH_MAX
+#ifdef MAX_PATH
+#define PATH_MAX MAX_PATH
+#else
+#define PATH_MAX 128
+#endif
+#endif
+
+enum {
+	MAP_READ = 1,
+	MAP_WRITE = 2
+};
+
+enum VFSType {
+	VFS_UNKNOWN = 0,
+	VFS_FILE,
+	VFS_DIRECTORY
+};
+
+struct VFile {
+	bool (*close)(struct VFile* vf);
+	off_t (*seek)(struct VFile* vf, off_t offset, int whence);
+	ssize_t (*read)(struct VFile* vf, void* buffer, size_t size);
+	ssize_t (*readline)(struct VFile* vf, char* buffer, size_t size);
+	ssize_t (*write)(struct VFile* vf, const void* buffer, size_t size);
+	void* (*map)(struct VFile* vf, size_t size, int flags);
+	void (*unmap)(struct VFile* vf, void* memory, size_t size);
+	void (*truncate)(struct VFile* vf, size_t size);
+	ssize_t (*size)(struct VFile* vf);
+	bool (*sync)(struct VFile* vf, void* buffer, size_t size);
+};
+
+#if defined(ENABLE_VFS) && defined(ENABLE_DIRECTORIES)
+struct VDirEntry {
+	const char* (*name)(struct VDirEntry* vde);
+	enum VFSType (*type)(struct VDirEntry* vde);
+};
+
+struct VDir {
+	bool (*close)(struct VDir* vd);
+	void (*rewind)(struct VDir* vd);
+	struct VDirEntry* (*listNext)(struct VDir* vd);
+	struct VFile* (*openFile)(struct VDir* vd, const char* name, int mode);
+	struct VDir* (*openDir)(struct VDir* vd, const char* name);
+	bool (*deleteFile)(struct VDir* vd, const char* name);
+};
+#endif
+
+#ifdef ENABLE_VFS
+struct VFile* VFileOpen(const char* path, int flags);
+#endif
+
+#ifdef ENABLE_VFS_FD
+struct VFile* VFileOpenFD(const char* path, int flags);
+struct VFile* VFileFromFD(int fd);
+#endif
+
+#ifdef ENABLE_VFS_FILE
+struct VFile* VFileFOpen(const char* path, const char* mode);
+struct VFile* VFileFromFILE(FILE* file);
+#endif
+
+struct VFile* VFileFromMemory(void* mem, size_t size);
+struct VFile* VFileFromConstMemory(const void* mem, size_t size);
+struct VFile* VFileMemChunk(const void* mem, size_t size);
+
+struct mCircleBuffer;
+struct VFile* VFileFIFO(struct mCircleBuffer* backing);
+
+#if defined(ENABLE_VFS) && defined(ENABLE_DIRECTORIES)
+struct VDir* VDirOpen(const char* path);
+struct VDir* VDirOpenArchive(const char* path);
+
+#if defined(USE_LIBZIP) || defined(USE_MINIZIP)
+struct VDir* VDirOpenZip(const char* path, int flags);
+#endif
+
+#ifdef USE_LZMA
+struct VDir* VDirOpen7z(const char* path, int flags);
+#endif
+
+#if defined(__wii__) || defined(__3DS__) || defined(PSP2)
+struct VDir* VDeviceList(void);
+#endif
+
+bool VDirCreate(const char* path);
+struct VFile* VDirFindFirst(struct VDir* dir, bool (*filter)(struct VFile*));
+struct VFile* VDirFindNextAvailable(struct VDir*, const char* basename, const char* infix, const char* suffix, int mode);
+#endif
+
+void separatePath(const char* path, char* dirname, char* basename, char* extension);
+
+bool isAbsolute(const char* path);
+void makeAbsolute(const char* path, const char* base, char* out);
+
+ssize_t VFileReadline(struct VFile* vf, char* buffer, size_t size);
+
+ssize_t VFileWrite32LE(struct VFile* vf, int32_t word);
+ssize_t VFileWrite16LE(struct VFile* vf, int16_t hword);
+ssize_t VFileRead32LE(struct VFile* vf, void* word);
+ssize_t VFileRead16LE(struct VFile* vf, void* hword);
+
+CXX_GUARD_END
+
+#endif

package/mgba-bridge/vendor/mgba/intl/activate.py

@@ -0,0 +1,70 @@
+#!/usr/bin/env python3
+
+import os
+import glob
+import random as r
+
+# --------------------          MAIN          -------------------- #
+
+if __name__ == '__main__':
+   DIR_PATH = os.path.dirname(os.path.realpath(__file__))
+   if os.path.basename(DIR_PATH) != "intl":
+      raise RuntimeError("Script is not in intl folder!")
+
+   BASE_PATH = os.path.dirname(DIR_PATH)
+   WORKFLOW_PATH = os.path.join(BASE_PATH, ".github", "workflows")
+   PREP_WF = os.path.join(WORKFLOW_PATH, "crowdin_prep.yml")
+   TRANSLATE_WF = os.path.join(WORKFLOW_PATH, "crowdin_translate.yml")
+   CORE_NAME = os.path.basename(BASE_PATH)
+   CORE_OP_FILE = os.path.join(BASE_PATH, "**", "libretro_core_options.h")
+
+   core_options_hits = glob.glob(CORE_OP_FILE, recursive=True)
+
+   if len(core_options_hits) == 0:
+      raise RuntimeError("libretro_core_options.h not found!")
+   elif len(core_options_hits) > 1:
+      print("More than one libretro_core_options.h file found:\n\n")
+      for i, file in enumerate(core_options_hits):
+         print(f"{i} {file}\n")
+
+      while True:
+         user_choice = input("Please choose one ('q' will exit): ")
+         if user_choice == 'q':
+            exit(0)
+         elif user_choice.isdigit():
+            core_op_file = core_options_hits[int(user_choice)]
+            break
+         else:
+            print("Please make a valid choice!\n\n")
+   else:
+      core_op_file = core_options_hits[0]
+
+   core_intl_file = os.path.join(os.path.dirname(core_op_file.replace(BASE_PATH, ''))[1:],
+                                 'libretro_core_options_intl.h')
+   core_op_file   = os.path.join(os.path.dirname(core_op_file.replace(BASE_PATH, ''))[1:],
+                                 'libretro_core_options.h')
+   minutes = r.randrange(0, 59, 5)
+   hour = r.randrange(0, 23)
+
+   with open(PREP_WF, 'r') as wf_file:
+      prep_txt = wf_file.read()
+
+   prep_txt = prep_txt.replace("<CORE_NAME>", CORE_NAME)
+   prep_txt = prep_txt.replace("<PATH/TO>/libretro_core_options.h",
+                               core_op_file)
+   with open(PREP_WF, 'w') as wf_file:
+      wf_file.write(prep_txt)
+
+
+   with open(TRANSLATE_WF, 'r') as wf_file:
+      translate_txt = wf_file.read()
+
+   translate_txt = translate_txt.replace('<0-59>', f"{minutes}")
+   translate_txt = translate_txt.replace('<0-23>', f"{hour}")
+   translate_txt = translate_txt.replace('# Fridays at , UTC',
+                                         f"# Fridays at {hour%12}:{minutes if minutes > 9 else '0' + str(minutes)} {'AM' if hour < 12 else 'PM'}, UTC")
+   translate_txt = translate_txt.replace("<CORE_NAME>", CORE_NAME)
+   translate_txt = translate_txt.replace('<PATH/TO>/libretro_core_options_intl.h',
+                                         core_intl_file)
+   with open(TRANSLATE_WF, 'w') as wf_file:
+      wf_file.write(translate_txt)

package/mgba-bridge/vendor/mgba/intl/core_option_regex.py

@@ -0,0 +1,95 @@
+import re
+
+# 0: full struct; 1: up to & including first []; 2 & 3: comments; 4: content between first {}
+p_struct = re.compile(r'(\bstruct\b\s*[a-zA-Z0-9_\s]+\[])\s*'  # 1st capturing group
+                      r'(?:(?=(\/\*(?:.|[\r\n])*?\*\/|\/\/.*[\r\n]+))\2\s*)*'  # 2nd capturing group
+                      r'=\s*'  # =
+                      r'(?:(?=(\/\*(?:.|[\r\n])*?\*\/|\/\/.*[\r\n]+))\3\s*)*'  # 3rd capturing group
+                      r'{((?:.|[\r\n])*?)\{\s*NULL,\s*NULL,\s*NULL\s*(?:.|[\r\n])*?},?(?:.|[\r\n])*?};')  # captures full struct, it's beginning and it's content
+# 0: type name[]; 1: type; 2: name
+p_type_name = re.compile(r'(\bretro_core_option_[a-zA-Z0-9_]+)\s*'
+                         r'(\boption_cats([a-z_]{0,8})|\boption_defs([a-z_]*))\s*\[]')
+# 0: full option; 1: key; 2: description; 3: additional info; 4: key/value pairs
+p_option = re.compile(r'{\s*'  # opening braces
+                      r'(?:(?:\/\*(?:.|[\r\n])*?\*\/|\/\/.*[\r\n]+|#.*[\r\n]+)\s*)*'
+                      r'(\".*?\"|'  # key start; group 1
+                      r'[a-zA-Z0-9_]+\s*\((?:.|[\r\n])*?\)|'
+                      r'[a-zA-Z0-9_]+\s*\[(?:.|[\r\n])*?]|'
+                      r'[a-zA-Z0-9_]+\s*\".*?\")\s*'  # key end
+                      r'(?:(?:\/\*(?:.|[\r\n])*?\*\/|\/\/.*[\r\n]+|#.*[\r\n]+)\s*)*'
+                      r',\s*'  # comma
+                      r'(?:(?:\/\*(?:.|[\r\n])*?\*\/|\/\/.*[\r\n]+|#.*[\r\n]+)\s*)*'
+                      r'(\".*?\")\s*'  # description; group 2
+                      r'(?:(?:\/\*(?:.|[\r\n])*?\*\/|\/\/.*[\r\n]+|#.*[\r\n]+)\s*)*'
+                      r',\s*'  # comma
+                      r'(?:(?:\/\*(?:.|[\r\n])*?\*\/|\/\/.*[\r\n]+|#.*[\r\n]+)\s*)*'
+                      r'((?:'  # group 3
+                      r'(?:NULL|\"(?:.|[\r\n])*?\")\s*'  # description in category, info, info in category, category
+                      r'(?:(?:\/\*(?:.|[\r\n])*?\*\/|\/\/.*[\r\n]+|#.*[\r\n]+)\s*)*'
+                      r',?\s*'  # comma
+                      r'(?:(?:\/\*(?:.|[\r\n])*?\*\/|\/\/.*[\r\n]+|#.*[\r\n]+)\s*)*'
+                      r')+)'
+                      r'(?:'  # defs only start
+                      r'{\s*'  # opening braces
+                      r'(?:(?:\/\*(?:.|[\r\n])*?\*\/|\/\/.*[\r\n]+|#.*[\r\n]+)\s*)*'
+                      r'((?:'  # key/value pairs start; group 4
+                      r'{\s*'  # opening braces
+                      r'(?:(?:\/\*(?:.|[\r\n])*?\*\/|\/\/.*[\r\n]+|#.*[\r\n]+)\s*)*'
+                      r'(?:NULL|\".*?\")\s*'  # option key
+                      r'(?:(?:\/\*(?:.|[\r\n])*?\*\/|\/\/.*[\r\n]+|#.*[\r\n]+)\s*)*'
+                      r',\s*'  # comma
+                      r'(?:(?:\/\*(?:.|[\r\n])*?\*\/|\/\/.*[\r\n]+|#.*[\r\n]+)\s*)*'
+                      r'(?:NULL|\".*?\")\s*'  # option value
+                      r'(?:(?:\/\*(?:.|[\r\n])*?\*\/|\/\/.*[\r\n]+|#.*[\r\n]+)\s*)*'
+                      r'}\s*'  # closing braces
+                      r'(?:(?:\/\*(?:.|[\r\n])*?\*\/|\/\/.*[\r\n]+|#.*[\r\n]+)\s*)*'
+                      r',?\s*'  # comma
+                      r'(?:(?:\/\*(?:.|[\r\n])*?\*\/|\/\/.*[\r\n]+|#.*[\r\n]+)\s*)*'
+                      r')*)'  # key/value pairs end
+                      r'}\s*'  # closing braces
+                      r'(?:(?:\/\*(?:.|[\r\n])*?\*\/|\/\/.*[\r\n]+|#.*[\r\n]+)\s*)*'
+                      r',?\s*'  # comma
+                      r'(?:(?:\/\*(?:.|[\r\n])*?\*\/|\/\/.*[\r\n]+|#.*[\r\n]+)\s*)*'
+                      r'(?:'  # defaults start
+                      r'(?:NULL|\".*?\")\s*'  # default value
+                      r'(?:(?:\/\*(?:.|[\r\n])*?\*\/|\/\/.*[\r\n]+|#.*[\r\n]+)\s*)*'
+                      r',?\s*'  # comma
+                      r'(?:(?:\/\*(?:.|[\r\n])*?\*\/|\/\/.*[\r\n]+|#.*[\r\n]+)\s*)*'
+                      r')*'  # defaults end
+                      r')?'  # defs only end
+                      r'},')  # closing braces
+# analyse option group 3
+p_info = re.compile(r'(NULL|\"(?:.|[\r\n])*?\")\s*'  # description in category, info, info in category, category
+                    r'(?:(?:\/\*(?:.|[\r\n])*?\*\/|\/\/.*[\r\n]+|#.*[\r\n]+)\s*)*'
+                    r',')
+p_info_cat = re.compile(r'(NULL|\"(?:.|[\r\n])*?\")')
+# analyse option group 4
+p_key_value = re.compile(r'{\s*'  # opening braces
+                         r'(?:(?:\/\*(?:.|[\r\n])*?\*\/|\/\/.*[\r\n]+|#.*[\r\n]+)\s*)*'
+                         r'(NULL|\".*?\")\s*'  # option key; 1
+                         r'(?:(?:\/\*(?:.|[\r\n])*?\*\/|\/\/.*[\r\n]+|#.*[\r\n]+)\s*)*'
+                         r',\s*'  # comma
+                         r'(?:(?:\/\*(?:.|[\r\n])*?\*\/|\/\/.*[\r\n]+|#.*[\r\n]+)\s*)*'
+                         r'(NULL|\".*?\")\s*'  # option value; 2
+                         r'(?:(?:\/\*(?:.|[\r\n])*?\*\/|\/\/.*[\r\n]+|#.*[\r\n]+)\s*)*'
+                         r'}')
+
+p_masked = re.compile(r'([A-Z_][A-Z0-9_]+)\s*(\"(?:"\s*"|\\\s*|.)*\")')
+
+p_intl = re.compile(r'(\bstruct retro_core_option_definition \*option_defs_intl\[RETRO_LANGUAGE_LAST]) = {'
+                    r'((?:.|[\r\n])*?)};')
+p_set = re.compile(r'\bstatic INLINE void libretro_set_core_options\(retro_environment_t environ_cb\)'
+                   r'(?:.|[\r\n])*?};?\s*#ifdef __cplusplus\s*}\s*#endif')
+
+p_yaml = re.compile(r'"project_id": "[0-9]+".*\s*'
+                    r'"api_token": "([a-zA-Z0-9]+)".*\s*'
+                    r'"base_path": "\./intl".*\s*'
+                    r'"base_url": "https://api\.crowdin\.com".*\s*'
+                    r'"preserve_hierarchy": true.*\s*'
+                    r'"files": \[\s*'
+                    r'\{\s*'
+                    r'"source": "/_us/\*\.json",.*\s*'
+                    r'"translation": "/_%two_letters_code%/%original_file_name%",.*\s*'
+                    r'"skip_untranslated_strings": true.*\s*'
+                    r'},\s*'
+                    r']')