Squashed 'external/ircolib/' changes from ce3cd726c..de6e324bd

de6e324bd separate emu thread 10d3daf86 Roms List improvements 95d202f37 Let's make the rom list process on a separate thread so the emulator doesnt take ages to load. fc306967f Wow the ROM Header was just completely busted. Game list view works now bad1691ee fuck this shit 2b59e5f46 game list in progress d26417b83 remappable inputs in progress ac4af8106 input e72abc240 update readme 430139dc9 Qt6 frontend 3080d4d45 Fix this small bug too 08cd13b85 Cop0 unused functions do not actually pose a threat (as per manual). They don't do anything, so shall we. 61bb4fb44 make idle loop detection a little more specific with where the load goes b037de4c3 SAZDFsdff 12e81e73e need to figure out why n64-systemtest loops indefinitely at some address that appears to be valid (i think it's me not invalidating the cache properly) 204f0e13b idle skipping seems to work! cb8bb634a sdkfjlasdf 58e5c89c1 Fix compilation issue on my machine (no idea) 24fb2898e attempting more serious idle skipping 214719577 Place rsp.Step inside cached interpreter. Gains about 3 more fps bb97dcc23 mmmmm 920b77d38 wjkhasdfjhkasdf 430ccdab4 it's a start... 4f42a673a Cached interpreter plays Mario 64. Start looking into RSP as well c9a030787 idle skipping works! 5fbda03ce new idea 366637aba Idle skipping... maybe? 609fa2fb0 Cache instructions implemented but broken lmao. Commented out for now e140a6d12 - Stop using inheritance for CPU, instead use composition. - Introduce KAIZEN_JIT_ENABLED optional define instead of relying on __aarch64__ and the like. - More cache work 68e613057 prep cache impl 811b4d809 fix clang format fda755f7d idk d5024ebbf small MI refactor in preparation of (eventually) implementing the RDRAM interface properly 694b45341 Merge commit '206dcdedf195fb320913584180edb12c7731e396' as 'external/SDL' 206dcdedf Squashed 'external/SDL/' content from commit 4d17b99d0a 4d16e1cb4 need to update sdl 848b19920 Fix compilation error db61b5299 Merge commit 'e94a94559f28e49678fbcf72199a5258137b0fe9' as 'external/imgui' e94a94559 Squashed 'external/imgui/' content from commit 02e9b8cac 52edb3757 need to update imgui c1a705e86 Emulate weird JALR behaviour 4b4c32f4b Fix exception for "unusable COP1" in 4 instructions i missed accidentally (again) df5828142 Bug putting 0s in the log everywhere f8b580048 Make isviewer a sink to file 8241e9735 Fix exception for "unusable COP1" in 4 instructions i missed accidentally b29715f20 small changes d9a620bc1 make use of my new small utility library 0d1aa938e Add 'external/ircolib/' from commit 'ce3cd726c8df8388d554abf8bb55d55020eb4450' e64eb40b3 Fuck git git-subtree-dir: external/ircolib git-subtree-split: de6e324bde
2026-06-15 11:56:38 +02:00
parent ce3cd726c8
commit 00cc9309cb
4479 changed files with 2943227 additions and 7 deletions
@@ -0,0 +1,29 @@
+/* Copyright 2015 the unarr project authors (see AUTHORS file).
+   License: LGPLv3 */
+
+#ifndef common_allocator_h
+#define common_allocator_h
+
+#ifdef USE_CUSTOM_ALLOCATOR
+
+#include <stddef.h>
+
+typedef void *(* custom_malloc_fn)(void *opaque, size_t size);
+typedef void (* custom_free_fn)(void *opaque, void *ptr);
+
+void ar_set_custom_allocator(custom_malloc_fn custom_malloc, custom_free_fn custom_free, void *opaque);
+
+#define malloc(size) ar_malloc(size)
+#define calloc(count, size) ar_calloc(count, size)
+#define free(ptr) ar_free(ptr)
+
+#define realloc(ptr, size) _use_malloc_memcpy_free_instead(ptr, size)
+#define strdup(str) _use_malloc_memcpy_instead(str)
+
+#elif !defined(NDEBUG) && defined(_MSC_VER)
+
+#include <crtdbg.h>
+
+#endif
+
+#endif
@@ -0,0 +1,96 @@
+/* Copyright 2015 the unarr project authors (see AUTHORS file).
+   License: LGPLv3 */
+
+#include "unarr-imp.h"
+
+#include <time.h>
+
+/* data from http://en.wikipedia.org/wiki/Cp437 */
+static const wchar_t gCp437[256] = {
+    0, 0x263A, 0x263B, 0x2665, 0x2666, 0x2663, 0x2660, 0x2022, 0x25D8, 0x25CB, 0x25D9, 0x2642, 0x2640, 0x266A, 0x266C, 0x263C,
+    0x25BA, 0x25C4, 0x2195, 0x203C, 0x00B6, 0x00A7, 0x25AC, 0x21A8, 0x2191, 0x2193, 0x2192, 0x2190, 0x221F, 0x2194, 0x25B2, 0x25BC,
+    ' ', '!', '"', '#', '$', '%', '&', '\'', '(', ')', '*', '+', ',', '-', '.', '/',
+    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ':', ';', '<', '=', '>', '?',
+    '@', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
+    'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '[', '\\', ']', '^', '_',
+    '`', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',
+    'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '{', '|', '}', '~', 0x2302,
+    0x00C7, 0x00FC, 0x00E9, 0x00E2, 0x00E4, 0x00E0, 0x00E5, 0x00E7, 0x00EA, 0x00EB, 0x00E8, 0x00EF, 0x00EE, 0x00EC, 0x00C4, 0x00C5,
+    0x00C9, 0x00E6, 0x00C6, 0x00F4, 0x00F6, 0x00F2, 0x00FB, 0x00F9, 0x00FF, 0x00D6, 0x00DC, 0x00A2, 0x00A3, 0x00A5, 0x20A7, 0x0192,
+    0x00E1, 0x00ED, 0x00F3, 0x00FA, 0x00F1, 0x00D1, 0x00AA, 0x00BA, 0x00BF, 0x2310, 0x00AC, 0x00BD, 0x00BC, 0x00A1, 0x00AB, 0x00BB,
+    0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x2561, 0x2562, 0x2556, 0x2555, 0x2563, 0x2551, 0x2557, 0x255D, 0x255C, 0x255B, 0x2510,
+    0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x255E, 0x255F, 0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x2567,
+    0x2568, 0x2564, 0x2565, 0x2559, 0x2558, 0x2552, 0x2553, 0x256B, 0x256A, 0x2518, 0x250C, 0x2588, 0x2584, 0x258C, 0x2590, 0x2580,
+    0x03B1, 0x00DF, 0x0393, 0x03C0, 0x03A3, 0x03C3, 0x00B5, 0x03C4, 0x03A6, 0x0398, 0x03A9, 0x03B4, 0x221E, 0x03C6, 0x03B5, 0x2229,
+    0x2261, 0x00B1, 0x2265, 0x2264, 0x2320, 0x2321, 0x00F7, 0x2248, 0x00B0, 0x2219, 0x00B7, 0x221A, 0x207F, 0x00B2, 0x25A0, 0x00A0,
+};
+
+size_t ar_conv_rune_to_utf8(wchar_t rune, char *out, size_t size)
+{
+    if (size < 1)
+        return 0;
+    if (rune < 0x0080) {
+        *out++ = rune & 0x7F;
+        return 1;
+    }
+    if (rune < 0x0800 && size >= 2) {
+        *out++ = 0xC0 | ((rune >> 6) & 0x1F);
+        *out++ = 0x80 | (rune & 0x3F);
+        return 2;
+    }
+    if (size >= 3) {
+        if ((0xD800 <= rune && rune <= 0xDFFF) || rune >= 0x10000)
+            rune = 0xFFFD;
+        *out++ = 0xE0 | ((rune >> 12) & 0x0F);
+        *out++ = 0x80 | ((rune >> 6) & 0x3F);
+        *out++ = 0x80 | (rune & 0x3F);
+        return 3;
+    }
+    *out++ = '?';
+    return 1;
+}
+
+char *ar_conv_dos_to_utf8(const char *astr)
+{
+    char *str, *out;
+    const char *in;
+    size_t size;
+
+    size = 0;
+    for (in = astr; *in; in++) {
+        char buf[4];
+        size += ar_conv_rune_to_utf8(gCp437[(uint8_t)*in], buf, sizeof(buf));
+    }
+
+    if (size == (size_t)-1)
+        return NULL;
+    str = malloc(size + 1);
+    if (!str)
+        return NULL;
+
+    for (in = astr, out = str; *in; in++) {
+        out += ar_conv_rune_to_utf8(gCp437[(uint8_t)*in], out, str + size - out);
+    }
+    *out = '\0';
+
+    return str;
+}
+
+time64_t ar_conv_dosdate_to_filetime(uint32_t dosdate)
+{
+    struct tm tm;
+    time_t t1, t2;
+
+    tm.tm_sec = (dosdate & 0x1F) * 2;
+    tm.tm_min = (dosdate >> 5) & 0x3F;
+    tm.tm_hour = (dosdate >> 11) & 0x1F;
+    tm.tm_mday = (dosdate >> 16) & 0x1F;
+    tm.tm_mon = ((dosdate >> 21) & 0x0F) - 1;
+    tm.tm_year = ((dosdate >> 25) & 0x7F) + 80;
+    tm.tm_isdst = -1;
+
+    t1 = mktime(&tm);
+    t2 = mktime(gmtime(&t1));
+
+    return (time64_t)(2 * t1 - t2 + 11644473600) * 10000000;
+}
@@ -0,0 +1,86 @@
+/* Copyright 2022 the unarr project authors (see AUTHORS file).
+   License: LGPLv3 */
+#include "unarr-imp.h"
+
+#if !defined HAVE_ZLIB || !defined USE_ZLIB_CRC
+
+/*
+   crc32 calculation based on Intel slice-by-8 algorithm with lookup-table generation code
+   adapted from https://gnunet.org/svn/gnunet/src/util/crypto_crc.c (public domain)        */
+
+static inline uint32_t uint32le(const uint8_t *data) { return data[0] | data[1] << 8 | data[2] << 16 | (uint32_t)data[3] << 24; }
+
+static bool crc_table_ready = false;
+static uint32_t crc_table[8][256];
+
+uint32_t ar_crc32(uint32_t crc32, const uint8_t * data, size_t data_len)
+{
+    if (!crc_table_ready) {
+
+        static const uint32_t crc_poly = 0xEDB88320;
+
+        uint32_t h = 1;
+        crc_table[0][0] = 0;
+
+        for (unsigned int i = 128; i; i >>= 1) {
+            h = (h >> 1) ^ ((h & 1) ? crc_poly : 0);
+            for (unsigned int j = 0; j < 256; j += 2 * i) {
+                crc_table[0][i+j] = crc_table[0][j] ^ h;
+            }
+        }
+
+        for (unsigned int i = 0; i < 256; i++) {
+            for (unsigned int j = 1; j < 8; j++) {
+                crc_table[j][i] = (crc_table[j-1][i] >> 8) ^ crc_table[0][crc_table[j-1][i] & 0xFF];
+            }
+        }
+
+        crc_table_ready = true;
+    }
+
+    crc32 ^= 0xFFFFFFFF;
+
+    while (data_len >= 8) {
+
+        uint32_t tmp = crc32 ^ uint32le(data);
+
+        crc32 = crc_table[7][ tmp        & 0xFF ] ^
+                crc_table[6][(tmp >>  8) & 0xFF ] ^
+                crc_table[5][(tmp >> 16) & 0xFF ] ^
+                crc_table[4][ tmp >> 24         ];
+
+        tmp = uint32le(data + 4);
+
+        crc32 ^= crc_table[3][tmp        & 0xFF] ^
+                crc_table[2][(tmp >>  8) & 0xFF] ^
+                crc_table[1][(tmp >> 16) & 0xFF] ^
+                crc_table[0][ tmp >> 24        ];
+
+        data += 8;
+        data_len -= 8;
+    }
+
+    while (data_len-- > 0) {
+        crc32 = (crc32 >> 8) ^ crc_table[0][(crc32 ^ *data++) & 0xFF];
+    }
+
+    return crc32 ^ 0xFFFFFFFF;
+}
+
+#else
+
+#include <zlib.h>
+
+uint32_t ar_crc32(uint32_t crc, const unsigned char *data, size_t data_len)
+{
+#if SIZE_MAX > UINT32_MAX
+    while (data_len > UINT32_MAX) {
+        crc = crc32(crc, data, UINT32_MAX);
+        data += UINT32_MAX;
+        data_len -= UINT32_MAX;
+    }
+#endif
+    return crc32(crc, data, (uint32_t)data_len);
+}
+
+#endif
@@ -0,0 +1,49 @@
+/* Copyright 2015 the unarr project authors (see AUTHORS file).
+   License: LGPLv3 */
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+
+typedef void *(* custom_malloc_fn)(void *opaque, size_t size);
+typedef void (* custom_free_fn)(void *opaque, void *ptr);
+
+static void *default_malloc(void *opaque, size_t size) { (void)opaque; return malloc(size); }
+static void default_free(void *opaque, void *ptr) { (void)opaque; free(ptr); }
+
+static struct {
+    custom_malloc_fn malloc;
+    custom_free_fn free;
+    void *opaque;
+} gAllocator = {
+    default_malloc,
+    default_free,
+    NULL,
+};
+
+void *ar_malloc(size_t size)
+{
+    return gAllocator.malloc(gAllocator.opaque, size);
+}
+
+void *ar_calloc(size_t count, size_t size)
+{
+    void *ptr = NULL;
+    if (size <= SIZE_MAX / count)
+        ptr = ar_malloc(count * size);
+    if (ptr)
+        memset(ptr, 0, count * size);
+    return ptr;
+}
+
+void ar_free(void *ptr)
+{
+    gAllocator.free(gAllocator.opaque, ptr);
+}
+
+void ar_set_custom_allocator(custom_malloc_fn custom_malloc, custom_free_fn custom_free, void *opaque)
+{
+    gAllocator.malloc = custom_malloc ? custom_malloc : default_malloc;
+    gAllocator.free = custom_free ? custom_free : default_free;
+    gAllocator.opaque = opaque;
+}
@@ -0,0 +1,217 @@
+/* Copyright 2015 the unarr project authors (see AUTHORS file).
+   License: LGPLv3 */
+
+#include "unarr-imp.h"
+
+ar_stream *ar_open_stream(void *data, ar_stream_close_fn close, ar_stream_read_fn read, ar_stream_seek_fn seek, ar_stream_tell_fn tell)
+{
+    ar_stream *stream = malloc(sizeof(ar_stream));
+    if (!stream) {
+        close(data);
+        return NULL;
+    }
+    stream->data = data;
+    stream->close = close;
+    stream->read = read;
+    stream->seek = seek;
+    stream->tell = tell;
+    return stream;
+}
+
+void ar_close(ar_stream *stream)
+{
+    if (stream)
+        stream->close(stream->data);
+    free(stream);
+}
+
+size_t ar_read(ar_stream *stream, void *buffer, size_t count)
+{
+    return stream->read(stream->data, buffer, count);
+}
+
+bool ar_seek(ar_stream *stream, off64_t offset, int origin)
+{
+    return stream->seek(stream->data, offset, origin);
+}
+
+bool ar_skip(ar_stream *stream, off64_t count)
+{
+    return stream->seek(stream->data, count, SEEK_CUR);
+}
+
+off64_t ar_tell(ar_stream *stream)
+{
+    return stream->tell(stream->data);
+}
+
+/***** stream based on FILE *****/
+
+static void file_close(void *data)
+{
+    fclose(data);
+}
+
+static size_t file_read(void *data, void *buffer, size_t count)
+{
+    return fread(buffer, 1, count, data);
+}
+
+static bool file_seek(void *data, off64_t offset, int origin)
+{
+#ifdef _WIN32
+    return _fseeki64(data, offset, origin) == 0;
+#else
+#if _POSIX_C_SOURCE >= 200112L
+    if (sizeof(off_t) == 8)
+        return fseeko(data, offset, origin) == 0;
+#endif
+    if (offset > INT32_MAX || offset < INT32_MIN)
+        return false;
+    return fseek(data, (long)offset, origin) == 0;
+#endif
+}
+
+static off64_t file_tell(void *data)
+{
+#ifdef _WIN32
+    return _ftelli64(data);
+#elif _POSIX_C_SOURCE >= 200112L
+    return ftello(data);
+#else
+    return ftell(data);
+#endif
+}
+
+ar_stream *ar_open_file(const char *path)
+{
+    FILE *f = path ? fopen(path, "rb") : NULL;
+    if (!f)
+        return NULL;
+    return ar_open_stream(f, file_close, file_read, file_seek, file_tell);
+}
+
+#ifdef _WIN32
+ar_stream *ar_open_file_w(const wchar_t *path)
+{
+    FILE *f = path ? _wfopen(path, L"rb") : NULL;
+    if (!f)
+        return NULL;
+    return ar_open_stream(f, file_close, file_read, file_seek, file_tell);
+}
+#endif
+
+/***** stream based on preallocated memory *****/
+
+struct MemoryStream {
+    const uint8_t *data;
+    size_t length;
+    size_t offset;
+};
+
+static void memory_close(void *data)
+{
+    struct MemoryStream *stm = data;
+    free(stm);
+}
+
+static size_t memory_read(void *data, void *buffer, size_t count)
+{
+    struct MemoryStream *stm = data;
+    if (count > stm->length - stm->offset)
+        count = stm->length - stm->offset;
+    memcpy(buffer, stm->data + stm->offset, count);
+    stm->offset += count;
+    return count;
+}
+
+static bool memory_seek(void *data, off64_t offset, int origin)
+{
+    struct MemoryStream *stm = data;
+    if (origin == SEEK_CUR)
+        offset += stm->offset;
+    else if (origin == SEEK_END)
+        offset += stm->length;
+    if (offset < 0 || offset > (off64_t)stm->length || (size_t)offset > stm->length)
+        return false;
+    stm->offset = (size_t)offset;
+    return true;
+}
+
+static off64_t memory_tell(void *data)
+{
+    struct MemoryStream *stm = data;
+    return stm->offset;
+}
+
+ar_stream *ar_open_memory(const void *data, size_t datalen)
+{
+    struct MemoryStream *stm = malloc(sizeof(struct MemoryStream));
+    if (!stm)
+        return NULL;
+    stm->data = data;
+    stm->length = datalen;
+    stm->offset = 0;
+    return ar_open_stream(stm, memory_close, memory_read, memory_seek, memory_tell);
+}
+
+#ifdef _WIN32
+/***** stream based on IStream *****/
+
+#define COBJMACROS
+#include <windows.h>
+
+static void stream_close(void *data)
+{
+    IUnknown_Release((IStream *)data);
+}
+
+static size_t stream_read(void *data, void *buffer, size_t count)
+{
+    size_t read = 0;
+    HRESULT res;
+    ULONG cbRead;
+#ifdef _WIN64
+    while (count > ULONG_MAX) {
+        res = IStream_Read((IStream *)data, buffer, ULONG_MAX, &cbRead);
+        if (FAILED(res))
+            return read;
+        read += cbRead;
+        buffer = (BYTE *)buffer + ULONG_MAX;
+        count -= ULONG_MAX;
+    }
+#endif
+    res = IStream_Read((IStream *)data, buffer, (ULONG)count, &cbRead);
+    if (SUCCEEDED(res))
+        read += cbRead;
+    return read;
+}
+
+static bool stream_seek(void *data, off64_t offset, int origin)
+{
+    LARGE_INTEGER off;
+    ULARGE_INTEGER n;
+    HRESULT res;
+    off.QuadPart = offset;
+    res = IStream_Seek((IStream *)data, off, origin, &n);
+    return SUCCEEDED(res);
+}
+
+static off64_t stream_tell(void *data)
+{
+    LARGE_INTEGER zero = { 0 };
+    ULARGE_INTEGER n = { 0 };
+    IStream_Seek((IStream *)data, zero, SEEK_CUR, &n);
+    return (off64_t)n.QuadPart;
+}
+
+ar_stream *ar_open_istream(IStream *stream)
+{
+    LARGE_INTEGER zero = { 0 };
+    HRESULT res = IStream_Seek(stream, zero, STREAM_SEEK_SET, NULL);
+    if (FAILED(res))
+        return NULL;
+    IUnknown_AddRef(stream);
+    return ar_open_stream(stream, stream_close, stream_read, stream_seek, stream_tell);
+}
+#endif
@@ -0,0 +1,84 @@
+/* Copyright 2015 the unarr project authors (see AUTHORS file).
+   License: LGPLv3 */
+
+/* this is the common private/implementation API of unarr which should only be used by unarr code */
+
+#ifndef common_unarr_imp_h
+#define common_unarr_imp_h
+
+#include "../unarr.h"
+#include "allocator.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <string.h>
+#include <inttypes.h>
+
+/***** conv ****/
+
+size_t ar_conv_rune_to_utf8(wchar_t rune, char *out, size_t size);
+char *ar_conv_dos_to_utf8(const char *astr);
+time64_t ar_conv_dosdate_to_filetime(uint32_t dosdate);
+
+/***** crc32 *****/
+
+uint32_t ar_crc32(uint32_t crc32, const unsigned char *data, size_t data_len);
+
+/***** stream *****/
+
+typedef void (* ar_stream_close_fn)(void *data);
+typedef size_t (* ar_stream_read_fn)(void *data, void *buffer, size_t count);
+typedef bool (* ar_stream_seek_fn)(void *data, off64_t offset, int origin);
+typedef off64_t (* ar_stream_tell_fn)(void *data);
+
+struct ar_stream_s {
+    ar_stream_close_fn close;
+    ar_stream_read_fn read;
+    ar_stream_seek_fn seek;
+    ar_stream_tell_fn tell;
+    void *data;
+};
+
+ar_stream *ar_open_stream(void *data, ar_stream_close_fn close, ar_stream_read_fn read, ar_stream_seek_fn seek, ar_stream_tell_fn tell);
+
+/***** unarr *****/
+#ifndef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
+#define warn(...) ar_log("!", __FILE__, __LINE__, __VA_ARGS__)
+#else
+#define warn(...) ((void)0)
+#endif
+#ifndef NDEBUG
+#define log(...) ar_log("-", __FILE__, __LINE__, __VA_ARGS__)
+#else
+#define log(...) ((void)0)
+#endif
+void ar_log(const char *prefix, const char *file, int line, const char *msg, ...);
+
+typedef void (* ar_archive_close_fn)(ar_archive *ar);
+typedef bool (* ar_parse_entry_fn)(ar_archive *ar, off64_t offset);
+typedef const char *(* ar_entry_get_name_fn)(ar_archive *ar, bool raw);
+typedef bool (* ar_entry_uncompress_fn)(ar_archive *ar, void *buffer, size_t count);
+typedef size_t (* ar_get_global_comment_fn)(ar_archive *ar, void *buffer, size_t count);
+
+struct ar_archive_s {
+    ar_archive_close_fn close;
+    ar_parse_entry_fn parse_entry;
+    ar_entry_get_name_fn get_name;
+    ar_entry_uncompress_fn uncompress;
+    ar_get_global_comment_fn get_comment;
+
+    ar_stream *stream;
+    bool at_eof;
+    off64_t entry_offset;
+    off64_t entry_offset_first;
+    off64_t entry_offset_next;
+    size_t entry_size_uncompressed;
+    time64_t entry_filetime;
+};
+
+ar_archive *ar_open_archive(ar_stream *stream, size_t struct_size, ar_archive_close_fn close, ar_parse_entry_fn parse_entry,
+                            ar_entry_get_name_fn get_name, ar_entry_uncompress_fn uncompress, ar_get_global_comment_fn get_comment,
+                            off64_t first_entry_offset);
+
+#endif
@@ -0,0 +1,114 @@
+/* Copyright 2015 the unarr project authors (see AUTHORS file).
+   License: LGPLv3 */
+
+#include "unarr-imp.h"
+
+ar_archive *ar_open_archive(ar_stream *stream, size_t struct_size, ar_archive_close_fn close, ar_parse_entry_fn parse_entry,
+                            ar_entry_get_name_fn get_name, ar_entry_uncompress_fn uncompress, ar_get_global_comment_fn get_comment,
+                            off64_t first_entry_offset)
+{
+    ar_archive *ar = malloc(struct_size);
+    if (!ar)
+        return NULL;
+    memset(ar, 0, struct_size);
+    ar->close = close;
+    ar->parse_entry = parse_entry;
+    ar->get_name = get_name;
+    ar->uncompress = uncompress;
+    ar->get_comment = get_comment;
+    ar->stream = stream;
+    ar->entry_offset_first = first_entry_offset;
+    ar->entry_offset_next = first_entry_offset;
+    return ar;
+}
+
+void ar_close_archive(ar_archive *ar)
+{
+    if (ar)
+        ar->close(ar);
+    free(ar);
+}
+
+bool ar_at_eof(ar_archive *ar)
+{
+    return ar->at_eof;
+}
+
+bool ar_parse_entry(ar_archive *ar)
+{
+    return ar->parse_entry(ar, ar->entry_offset_next);
+}
+
+bool ar_parse_entry_at(ar_archive *ar, off64_t offset)
+{
+    ar->at_eof = false;
+    return ar->parse_entry(ar, offset ? offset : ar->entry_offset_first);
+}
+
+bool ar_parse_entry_for(ar_archive *ar, const char *entry_name)
+{
+    ar->at_eof = false;
+    if (!entry_name)
+        return false;
+    if (!ar_parse_entry_at(ar, ar->entry_offset_first))
+        return false;
+    do {
+        const char *name = ar_entry_get_name(ar);
+        if (name && strcmp(name, entry_name) == 0)
+            return true;
+    } while (ar_parse_entry(ar));
+    return false;
+}
+
+const char *ar_entry_get_name(ar_archive *ar)
+{
+    return ar->get_name(ar, false);
+}
+
+const char *ar_entry_get_raw_name(ar_archive *ar)
+{
+    return ar->get_name(ar, true);
+}
+
+off64_t ar_entry_get_offset(ar_archive *ar)
+{
+    return ar->entry_offset;
+}
+
+size_t ar_entry_get_size(ar_archive *ar)
+{
+    return ar->entry_size_uncompressed;
+}
+
+time64_t ar_entry_get_filetime(ar_archive *ar)
+{
+    return ar->entry_filetime;
+}
+
+bool ar_entry_uncompress(ar_archive *ar, void *buffer, size_t count)
+{
+    return ar->uncompress(ar, buffer, count);
+}
+
+size_t ar_get_global_comment(ar_archive *ar, void *buffer, size_t count)
+{
+    if (!ar->get_comment)
+        return 0;
+    return ar->get_comment(ar, buffer, count);
+}
+
+void ar_log(const char *prefix, const char *file, int line, const char *msg, ...)
+{
+    va_list args;
+    va_start(args, msg);
+    if (prefix)
+        fprintf(stderr, "%s ", prefix);
+    if (strrchr(file, '/'))
+        file = strrchr(file, '/') + 1;
+    if (strrchr(file, '\\'))
+        file = strrchr(file, '\\') + 1;
+    fprintf(stderr, "%s:%d: ", file, line);
+    vfprintf(stderr, msg, args);
+    fprintf(stderr, "\n");
+    va_end(args);
+}