viclib.h

/* date = December 29th 2024 10:12 pm
--Author: Víctor López Cortés
--version: 1.6.1
--Usage:
Defines: To have any of these take effect, you must define them _before_ including this file
 - VICLIB_IMPLEMENTATION: If you want to have the implementation (only in one file)
 - READ_ENTIRE_FILE_MAX: If you want to have a max file read size, default is 0xFFFFFFFF (4GB)
 - QUIET_ASSERT: If you want the assertions to add a breakpoint but not print
 - RELEASE_MODE: Have some stuff work faster, right now, assertions get compiled out when this is defined
 - VICLIB_PROC: Define to 'static' or some kind of export as needed
 - VICLIB_TEMP_SIZE: ArenaTemp size, default is 4*1024*1024 bytes
 - VICLIB_NO*: If you want to remove parts of the library:
   - VICLIB_NO_TEMP_ARENA: remove ArenaTemp
   - VICLIB_NO_SORT: remove Sort and all functions used by it
Check VL_ErrorNumber when errors occur.

--Many thanks to the inspirations for this library:
 - Mr4th's 4ed_base_types.h - https://mr-4th.itch.io/4coder (find the file in 'custom' directory)
 - stb header-only libraries - https://github.com/nothings/stb
 - tsoding's string view implementation - https://github.com/tsoding/sv

I modified tsoding's string view so that it doesn't use the stdlib by implementing the couple
functions it uses

LICENCES:
tsoding string view implementation:
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.

License to viclib.h:
Copyright (c) 2024 Víctor López

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.
*/
#ifndef VICLIB_H
#define VICLIB_H

#if defined(_WIN32)
# define OS_WINDOWS 1
#endif

#if defined(__gnu_linux__)
# define OS_LINUX 1
#endif

#if defined(__APPLE__) && defined(__MACH__)
# define OS_MAC 1
#endif

#if defined(_MSC_VER) && !defined(__clang__)
# define COMPILER_CL 1
# define PRAGMA(x) __pragma(x)
# define thread_local __declspec(thread)
#elif defined(__clang__)
# define COMPILER_CLANG 1
# define PRAGMA(x) _Pragma(#x)
# define thread_local __thread
#elif defined(__GNUC__) || defined(__GNUG__)
# define COMPILER_GCC 1
# define PRAGMA(x) _Pragma(#x)
# define thread_local __thread
#elif defined(__TINYC__)
# define COMPILER_TCC 1
# define PRAGMA(x) _Pragma(#x)
// NOTE: tcc doesn't support thread-local storage
// TODO: thread local storage using win32/unistd?
//       using VL_Init() to start it up?
# define thread_local 
#else
/* unsupported compiler, to support, define:
 necessary:
 - thread_local
 useful:
 - PUSH_IGNORE_UNINITIALIZED
 - RESTORE_WARNINGS
*/
# define thread_local
#endif

#if defined(__x86_64__) || defined(_M_AMD64)
# define ARCH_X64 1
#elif defined(__aarch64__) || defined(_M_ARM64)
# define ARCH_ARM64 1
#include <arm_neon.h>
#endif

#if !defined(__COLUMN__)
# define __COLUMN__ 0
#endif

#if COMPILER_CL || COMPILER_GCC || COMPILER_CLANG
/* gcc and clang define __FUNCTION__ as a string constant,
 which means it cannot be concatenated to a string literal at compile time */
# define __PROC__ __FUNCTION__
#endif

#if defined(_UNISTD_H_) && defined(_SYS_STAT_H_)
# define VL_FILE_LINUX
#endif
#if !defined(VL_INC_STDLIB_H) && (defined(_STDLIB_H_) || defined(_STDLIB_H) || defined(_INC_STDLIB))
# define VL_INC_STDLIB_H
#endif
#if !defined(VL_INC_STDIO_H) && (defined(_STDIO_H_) || defined(_STDIO_H) || defined(_INC_STDIO))
# define VL_INC_STDIO_H
#endif
#if !defined(VL_INC_STRING_H) && (defined(_STRING_H_) || defined(_INC_STRING))
# define VL_INC_STRING_H
#endif

#if !defined(VICLIB_NO_PLATFORM)
#if OS_WINDOWS
#define WIN32_LEAN_AND_MEAN
#include <windows.h>

#if defined(_MSC_VER)
#include <intrin.h>
#endif

#elif OS_LINUX
#include <time.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/stat.h>

#elif OS_MAC // I think it works with the same includes as linux for now...?
#include <time.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/stat.h>

#else
#error Unsupported OS
#endif // OS
#endif // !defined(VICLIB_NO_PLATFORM)

/* DebugBreakpoint for different platforms.
Implementation by SDL3 (sdl wiki says SDL2 also had this but code says since SDL3.1.3) */
#if defined(SDL_h_)
# define DebugBreakpoint SDL_TriggerBreakpoint()
#elif defined(_MSC_VER)
/* Don't include intrin.h here because it contains C++ code */
extern void __cdecl __debugbreak(void);
# define DebugBreakpoint __debugbreak()
#elif defined(ANDROID)
# include <assert.h>
# define DebugBreakpoint assert(0)
#elif (defined(__GNUC__) || defined(__clang__)) && (defined(__i386__) || defined(__x86_64__))
# define DebugBreakpoint __asm__ __volatile__ ( "int $3\n\t" )
#elif (defined(__GNUC__) || defined(__clang__)) && defined(__riscv)
# define DebugBreakpoint __asm__ __volatile__ ( "ebreak\n\t" )
#elif (defined(OS_MAC) && (defined(__arm64__) || defined(__aarch64__)) )  /* this might work on other ARM targets, but this is a known quantity... */
# define DebugBreakpoint __asm__ __volatile__ ( "brk #22\n\t" )
#elif defined(OS_MAC) && defined(__arm__)
# define DebugBreakpoint __asm__ __volatile__ ( "bkpt #22\n\t" )
#elif defined(_WIN32) && ((defined(__GNUC__) || defined(__clang__)) && (defined(__arm64__) || defined(__aarch64__)) )
# define DebugBreakpoint __asm__ __volatile__ ( "brk #0xF000\n\t" )
#elif defined(__386__) && defined(__WATCOMC__)
# define DebugBreakpoint { _asm { int 0x03 } }
#elif defined(HAVE_SIGNAL_H) && !defined(__WATCOMC__)
# include <signal.h>
# define DebugBreakpoint raise(SIGTRAP)
#else
/* How do we trigger breakpoints on this platform? */
# define DebugBreakpoint Assert(false)
#endif

#if COMPILER_GCC || COMPILER_CLANG
// gcc and cl (haven't tried clang)
// don't understand how functions like ReadEntireFile work
// but I want to keep the warnings for other functions
# define PUSH_IGNORE_UNINITIALIZED PRAGMA(GCC diagnostic push) PRAGMA(GCC diagnostic ignored "-Wuninitialized")
# define RESTORE_WARNINGS PRAGMA(GCC diagnostic pop)
#elif COMPILER_CL
# define PUSH_IGNORE_UNINITIALIZED PRAGMA(warning(push)) PRAGMA(warning(disable: 4701)) PRAGMA(warning(disable: 4703))
# define RESTORE_WARNINGS PRAGMA(warning(pop))
#else
// compiler specific implementation
# define PUSH_IGNORE_UNINITIALIZED
# define RESTORE_WARNINGS
#endif

// only works with static arrays!
#define ArrayLen(arr) sizeof(arr)/sizeof(arr[0])

#if !defined(stringify)
# define stringify_(a) #a
# define stringify(a) stringify_(a)
#endif
#if !defined(glue)
# define glue_(a,b) a##b
# define glue(a,b) glue_(a,b)
#endif

#ifndef min
# define min(A, B) ((A) < (B) ? (A) : (B))
#endif
#ifndef max
# define max(A, B) ((A) > (B) ? (A) : (B))
#endif

#define VL_ReturnDefer(value) do { result = (value); goto defer; } while(0)

#if defined(__cplusplus)
# if __cplusplus >= 201703L
#  define fallthrough [[fallthrough]]
# elif defined(__GNUC__) && __GNUC__ >= 7
#  define fallthrough __attribute__((fallthrough))
# else
#  define fallthrough /* fall through */
# endif
#else
# if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L
#  define fallthrough [[fallthrough]]
# elif defined(__GNUC__) && __GNUC__ >= 7
#  define fallthrough __attribute__((fallthrough))
# else
#  define fallthrough /* fall through */
# endif
#endif

#include <stdint.h>
#include <stdbool.h>

typedef uint8_t  u8;
typedef uint16_t u16;
typedef uint32_t u32;
typedef uint64_t u64;

typedef int8_t   s8;
typedef int16_t  s16;
typedef int32_t  s32;
typedef int64_t  s64;

typedef uint32_t b32;
typedef float    f32;
typedef double   f64;

// Any windows compiler
#if defined(_MSC_VER) || defined(__MINGW32__) || defined(__MINGW64__)
# define U64_Fmt "%llu"
# define S64_Fmt "%lld"
#else
# define U64_Fmt "%lu"
# define S64_Fmt "%ld"
#endif

// TODO: Print for different platforms...?

#if !defined(AssertAlways) || !defined(AssertMsgAlways)
# if defined(SDL_h_)
#  define AssertAlways(e) do{ if(!(e)){ \
        SDL_Log(__FILE__"("stringify(__LINE__)"): Assert fail: "#e "\n"); \
        DebugBreakpoint; } }while(0)
#  define AssertMsgAlways(e, msglit) do{ if(!(e)){ \
        SDL_Log(__FILE__"("stringify(__LINE__)"): " msglit "\n"); \
        DebugBreakpoint; } }while(0)
# elif defined(VL_INC_STDIO_H)
#  define AssertAlways(e) do{ if(!(e)){ \
        printf(__FILE__"("stringify(__LINE__)"): Assert fail: "#e "\n"); \
        fflush(stdout); DebugBreakpoint; } }while(0)
#  define AssertMsgAlways(e, msglit) do{ if(!(e)){ \
        printf(__FILE__"("stringify(__LINE__)"): " msglit "\n"); \
        fflush(stdout); DebugBreakpoint; } }while(0)
# else
#  if !defined(QUIET_ASSERT)
#   define QUIET_ASSERT
#   pragma message("Warning: Using quiet assert since stdio.h is not included")
#   define AssertAlways(e) do{ if(!(e)) { DebugBreakpoint; } }while(0)
#   define AssertMsgAlways(e, msg) AssertAlways(e)
#  endif
# endif
#endif // !defined(AssertAlways) || !defined(AssertMsgAlways)

#if RELEASE_MODE
# define Assert(expr)
# define AssertMsg(expr, msg)
#else
# define Assert(expr) AssertAlways(expr)
# define AssertMsg(expr, msg) AssertMsgAlways(expr, msg)
#endif

typedef enum {
    ERROR_NO_ERROR = 0,

    ERROR_READ_UNKNOWN,
    ERROR_WRITE_UNKNOWN,
    ERROR_READ_FILE_NOT_FOUND,
    ERROR_WRITE_PATH_NOT_FOUND,
    ERROR_FILE_ACCESS_DENIED,
    ERROR_NO_MEM,
    ERROR_READ_FILE_TOO_BIG, /* READ_ENTIRE_FILE_MAX exceeded */
} error_number_value;

thread_local error_number_value VL_ErrorNumber = 0;

#ifndef VLIBPROC
# define VLIBPROC
#endif

/* bool found = false; 
 * LinearSearch(string_view_array, string_view, view_Eq);
 * if(found) {...}
 * 
 * string_view_array must have count and items attributes
 */
#define LinearSearch(arr, item, equal) \
    for(size_t glue(i, glue(_, __LINE__)) = 0; \
        glue(i, glue(_, __LINE__)) < (arr)->count; \
        glue(i, glue(_, __LINE__))++) { \
        if(equal((item), (arr)->items[glue(i, glue(_, __LINE__))])) { found = true; break; } \
    }

////////////////////////////////
// intrinsics
////////////////////////////////

/* Returns the number of leading 0-bits in val, starting at the most significant bit position
 * If val is 0, the result is undefined
 */
static inline uint32_t CountLeadingZerosU32(uint32_t val);
/* Returns the number of leading 0-bits in val, starting at the most significant bit position
 * If val is 0, the result is undefined
 */
static inline uint32_t CountLeadingZerosU64(uint64_t val);

/* Returns the number of leading 0-bits in val, starting at the least significant bit position
 * If val is 0, the result is undefined
 */
static inline uint32_t CountTrailingZerosU32(uint32_t val);
/* Returns the number of leading 0-bits in val, starting at the least significant bit position
 * If val is 0, the result is undefined
 */
static inline uint32_t CountTrailingZerosU64(uint64_t val);

/* Returns the number of leading 0-bits in val, starting at the most significant bit position
 * If val is 0, returns 32
 */
static inline uint32_t CountLeadingZerosSafeU32(uint32_t val);
/* Returns the number of leading 0-bits in val, starting at the most significant bit position
 * If val is 0, returns 64
 */
static inline uint32_t CountLeadingZerosSafeU64(uint64_t val);

/* Returns the number of leading 0-bits in val, starting at the least significant bit position
 * If val is 0, returns 32
 */
static inline uint32_t CountTrailingZerosSafeU32(uint32_t val);
/* Returns the number of leading 0-bits in val, starting at the least significant bit position
 * If val is 0, returns 64
 */
static inline uint32_t CountTrailingZerosSafeU64(uint64_t val);

#if defined(VL_INC_STRING_H)
# define mem_copy_non_overlapping(dst, src, len) memcpy(dst, src, len)
# define mem_copy(dst, src, len) memmove(dst, src, len)
# define mem_zero(data, len) memset(data, 0, len)
# define mem_compare(str1, str2, count) memcmp(str1, str2, count)
#elif defined(SDL_h_)
# define mem_copy_non_overlapping(dst, src, len) SDL_memcpy(dst, src, len)
# define mem_copy(dst, src, len) SDL_memmove(dst, src, len)
# define mem_zero(data, len) SDL_memset(data, 0, len)
# define mem_compare(str1, str2, count) SDL_memcmp(str1, str2, count)
#else
VLIBPROC void mem_copy_non_overlapping(void *dst, const void *src, size_t len);
VLIBPROC void mem_copy(void *dst, const void *src, size_t len);
VLIBPROC void mem_zero(void *data, size_t len);
VLIBPROC int mem_compare(const void *str1, const void *str2, size_t count);
#endif
#define ZeroStruct(S) mem_zero(&(S), sizeof(S))

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

typedef struct {
    const char *items;
    size_t count;
} view;
#define VIEW(cstr_lit) ViewFromParts((cstr_lit), sizeof(cstr_lit) - 1)
#if defined(__cplusplus)
#define VIEW_STATIC(cstr_lit) {(const char*)(cstr_lit), sizeof(cstr_lit) - 1}
#else
#define VIEW_STATIC(cstr_lit) (view){(const char*)(cstr_lit), sizeof(cstr_lit) - 1}
#endif
#define VIEW_FMT "%.*s"
#define VIEW_ARG(v) (int)(v).count, (v).items

#ifndef VIEWPROC
# define VIEWPROC VLIBPROC
#endif

#ifndef VL_INC_STRING_H
size_t strlen(const char *s);
#endif // VL_INC_STRING_H

int is_space(int _c); // only checks ascii space characters
VIEWPROC view ViewFromParts(const char *data, size_t count);
VIEWPROC view ViewFromCstr(const char *cstr);
VIEWPROC view ViewSlice(view v, size_t start, size_t end); // won't include end -> [start, end)
VIEWPROC int  ViewCompare(view a, view b); // result = A - B
VIEWPROC bool ViewEq(view a, view b);
VIEWPROC bool ViewStartsWith(view v, view start);
// Chops start from v when it gets found
VIEWPROC bool ViewChopStartsWith(view *v, view start);
VIEWPROC const char *ViewFind(view haystack, view needle); // result = pointer to where the needle is in haystack or null
// If the needle gets found, chop the haystack until the first ocurrence of needle in haystack
VIEWPROC bool ViewFindChop(view *haystack, view needle, view *chopped);
VIEWPROC bool ViewFindCharacter(view v, char c, size_t *n);
VIEWPROC bool ViewFindChopCharacter(view *v, char c, view *chopped);
#define ViewEndWith ViewEndsWith /* in case of singular/plural annoyance */
VIEWPROC bool ViewEndsWith(view v, view end);
VIEWPROC view ViewChopByDelim(view *v, char delim);
VIEWPROC view ViewChopByLine(view *v); // '\n' or "\r\n"
VIEWPROC view ViewChopByAnyDelim(view *v, view delims, char *delimiter); // checks for any character in Delims, stores found delimiter in Delimiter
VIEWPROC view ViewChopByView(view *v, view delim); // full view is the delim
VIEWPROC view ViewChopLeft(view *v, size_t n);
VIEWPROC view ViewChopRight(view *v, size_t n);
VIEWPROC view ViewTrimLeft(view v);
VIEWPROC view ViewTrimRight(view v);
VIEWPROC view ViewTrim(view v);

#define ViewIterateLines(src, idxName, lineName) \
    view lineName = ViewChopByLine(src); \
    for(size_t idxName = 0; (src)->count > 0 || lineName.count > 0; lineName = ViewChopByLine(src), idxName++)

#define ViewIterateSpaces(src, idxName, wordName) \
    view wordName = ViewChopByAnyDelim((src), VIEW_STATIC(" \n\t\v\f\r"), 0); \
    for(size_t idxName = 0; (src)->count > 0 || wordName.count > 0; wordName = ViewChopByAnyDelim((src), VIEW_STATIC(" \n\t\v\f\r"), 0), idxName++) \
        if(word.count > 0)

#define ViewIterateDelimiters(src, delims, idxName, tokName, delimName) \
    char delimName; \
    view tokName = ViewChopByAnyDelim((src), delims, &delimName); \
    for(size_t idxName = 0; (src)->count > 0 || tokName.count > 0 || delimName != '\0'; \
        tokName = ViewChopByAnyDelim((src), delims, &delimName), idxName++)

#define PARSE_FAIL 0
#define PARSE_NO_DECIMALS 1 // for when you might want integer precision
#define PARSE_OK 2
VIEWPROC bool ViewParseS64(view v, s64 *result, view *remaining);
// TODO: Better exp parsing
VIEWPROC int ViewParseF64(view v, f64 *result, view *remaining);

typedef struct {
    view file;
    s32 line;
    s32 column;
    view proc;
} code_location;
#define CURR_LOC \
(code_location){VIEW_STATIC(__FILE__), __LINE__, __COLUMN__, VIEW_STATIC(__PROC__)}
// odin style, unix style would be :%d:%d
// prefer LOC_STR to fmt + arg if possible
#define LOC_UNIX_STR __FILE__":" stringify(__LINE__)":" stringify(__COLUMN__)
#define LOC_MSVC_STR __FILE__"(" stringify(__LINE__)")"
#define LOC_STR __FILE__"(" stringify(__LINE__)":" stringify(__COLUMN__)")"
#define LOC_FMT VIEW_FMT"(%d:%d)"
#define LOC_ARG(loc) VIEW_ARG((loc).file), (loc).line, (loc.column)

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

typedef struct {
    size_t size;
    u8 *base;
    size_t used;

    s32 scratchCount;
    s32 splitCount;
} memory_arena;

typedef struct {
    memory_arena *Arena;
    size_t startMemOffset;
} scratch_arena;

#ifndef ARENAPROC
# define ARENAPROC VLIBPROC
#endif

struct ArenaGetRemaining_opts {
    memory_arena *Arena;
    size_t Alignment;
};
struct ArenaPushSize_opts {
    memory_arena *Arena;
    size_t RequestSize;
    size_t Alignment;
};
struct ArenaSplit_opts {
    memory_arena *Arena;
    memory_arena *SplitArena;
    size_t SplitSize;
};

// NOTE: Thanks Vjekoslav for the idea! (https://twitter.com/vkrajacic/status/1749816169736073295)

#define ArenaGetRemaining(arena, ...) ArenaGetRemaining_Opt((struct ArenaGetRemaining_opts){.Arena = (arena), __VA_ARGS__})
#define ArenaPushSize(arena, size, ...) ArenaPushSize_Opt((struct ArenaPushSize_opts){.Arena = (arena), .RequestSize = (size), __VA_ARGS__})
#define PushStruct(arena, type, ...) ArenaPushSize_Opt((struct ArenaPushSize_opts){.Arena = (arena), .RequestSize = sizeof(type), __VA_ARGS__})
#define PushArray(arena, count, type, ...) ArenaPushSize_Opt((struct ArenaPushSize_opts){.Arena = (arena), .RequestSize = (count)*sizeof(type), __VA_ARGS__})
#define ArenaClear(arena, ZeroMem) do{ \
        if(ZeroMem) { mem_zero((arena)->base, (arena)->size); } \
        (arena)->used = 0; \
    } while(0)
ARENAPROC char *Arena_strndup(memory_arena *Arena, const char *s, size_t n);
// s MUST be null terminated
ARENAPROC char *Arena_strdup(memory_arena *Arena, const char *s);

/* Split arenas work like a stack, you must rejoin them as first in last out.
 * When you call ArenaSplit, it will remove the size requested from the original at (Base + Size - SplitSize)
 * Calling ArenaSplit without SplitSize will split the arena into two equal parts (*they could be different sizes due to alignment)
**/
#define ArenaSplit(arena, split, ...) ArenaSplit_Opt((struct ArenaSplit_opts){.Arena = (arena), .SplitArena = (split), __VA_ARGS__})
// Split an arena into multiple equal parts
#define ArenaSplitMultiple(arena, split, ...) ArenaSplitMultiple_Impl((arena), \
    (memory_arena*[]){(split), __VA_ARGS__}, sizeof((memory_arena*[]){(split), __VA_ARGS__})/sizeof(memory_arena*))
#define ArenaRejoinMultiple(arena, split, ...) ArenaRejoinMultiple_Impl((arena), \
    (memory_arena*[]){(split), __VA_ARGS__}, sizeof((memory_arena*[]){(split), __VA_ARGS__})/sizeof(memory_arena*))
ARENAPROC void ArenaInit(memory_arena *Arena, size_t Size, void *Base);
ARENAPROC scratch_arena ArenaBeginScratch(memory_arena *Arena);
ARENAPROC void ArenaEndScratch(scratch_arena Scratch, bool ZeroMem);
ARENAPROC size_t ArenaGetAlignmentOffset(memory_arena *Arena, size_t Alignment);

ARENAPROC size_t ArenaGetRemaining_Opt(struct ArenaGetRemaining_opts opt);
ARENAPROC void *ArenaPushSize_Opt(struct ArenaPushSize_opts opt);
ARENAPROC void ArenaSplit_Opt(struct ArenaSplit_opts opt);
ARENAPROC void ArenaRejoin(memory_arena *Arena, memory_arena *SplitArena);
ARENAPROC void ArenaSplitMultiple_Impl(memory_arena *Arena, memory_arena **SplitArenas, size_t SplitArenaCount);
ARENAPROC void ArenaRejoinMultiple_Impl(memory_arena *Arena, memory_arena **SplitArenas, size_t SplitArenaCount);

#ifndef VICLIB_NO_TEMP_ARENA
# define temp_reset() ArenaClear(&ArenaTemp, true)
// will align to 4 bytes
# define temp_alloc(size, ...) ArenaPushSize_Opt((struct ArenaPushSize_opts){.Arena = &ArenaTemp, .RequestSize = (size), __VA_ARGS__})
# define temp_strdup(s) Arena_strdup(&ArenaTemp, s)
# define temp_strndup(s, n) Arena_strndup(&ArenaTemp, s, n)
# define temp_save() ArenaTemp.used
# define temp_rewind(checkpoint) ArenaTemp.used = checkpoint;

#endif

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

#ifdef RADDBG_MARKUP_H
#if COMPILER_CL
raddbg_type_view(view, array($.items, $.count));

#if defined(SDL_h_)
raddbg_type_view(SDL_Surface, $.format == SDL_PixelFormat.SDL_PIXELFORMAT_RGBA32 ? 
    bitmap($.pixels, $.w, $.h, RGBA32) : $);
#endif
#endif // COMPILER_CL
#endif // RADDBG_MARKUP_H

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

struct vl_globalcontext {
    bool initted; // called VL_Init()
    s64 initTime;
#if !defined(VICLIB_NO_PLATFORM)
#if OS_WINDOWS
    LARGE_INTEGER performanceFrequency;
#else

#endif
#endif // !defined(VICLIB_NO_PLATFORM)
};

extern struct vl_globalcontext VL_globalContext;

VLIBPROC bool VL_Init(void);

#define VL_HadError() (VL_ErrorNumber != ERROR_NO_ERROR)

#if !defined(VICLIB_NO_PLATFORM)

#ifndef READ_ENTIRE_FILE_MAX
#define READ_ENTIRE_FILE_MAX 0xFFFFFFFF
#endif

VLIBPROC bool VL_SetCurrentDir(const char *path);
VLIBPROC bool VL_FileExists(const char *path);

#if !OS_WINDOWS
bool IsDebuggerPresent(void);
#endif

typedef enum {
    VL_FILE_INVALID = -1,
    VL_FILE_REGULAR = 0,
    VL_FILE_DIRECTORY,
    VL_FILE_SYMLINK,
    VL_FILE_OTHER,
} file_type;
VLIBPROC bool GetLastWriteTime(const char *file, u64 *WriteTime);
VLIBPROC file_type VL_GetFileType(const char *path);

#define VL_NANOS_PER_SEC 1000000000
// Gets nanoseconds since the time VL_Init() was called, 
// if it wasn't called, it will get nanoseconds since unspecified epoch
VLIBPROC u64 VL_GetNanos(void);

#if !defined(VICLIB_NO_FILE_IO)

typedef struct {
#if OS_WINDOWS
    HANDLE File;
#elif OS_LINUX || OS_MAC
    int fd;
    bool didFirstIteration; // Need because fd could be 0 (stdin)
#endif
    u32 BufferSize;
    u8 *Buffer;
    size_t RemainingFileSize;
} vl_file_chunk;

VLIBPROC bool ReadFileChunk(vl_file_chunk *Chunk, const char *File, u32 *ChunkSize);

VLIBPROC char *ReadEntireFile(memory_arena *Arena, char *File, size_t *Size);
VLIBPROC bool WriteEntireFile(const char *File, const void *Data, size_t Size);

#endif // !defined(VICLIB_NO_FILE_IO)

VLIBPROC const char *VL_GetError(void);

#endif // !defined(VICLIB_NO_PLATFORM)

// TODO(vic): I think the sort doesn't work 100% of the time? test this
#if !defined(VICLIB_NO_SORT)
bool int_less_than(const void *A, const void *B);

#define VL_Swap(A,B) temp = (A); (A) = (B); (B) = temp
#define VL_SwapType(A,B,T) VL_SwapSize(&(A), &(B), sizeof(T))
void VL_SwapSize(void *A, void *B, size_t Size);
// introsort
void Sort(void *Data, size_t Count, size_t ElementSize, bool (*less_than)(const void *, const void *));
void VL_IntroSort(void *Data, size_t lo, size_t hi, int Depth, size_t ElementSize, bool (*less_than)(const void *, const void *));
void VL_InsertionSort(void *Data, size_t Count, size_t ElementSize, bool (*less_than)(const void *, const void *));
void VL_HeapSort(void *Data, size_t Count, size_t ElementSize, bool (*less_than)(const void *, const void *));

#endif // !defined(VICLIB_NO_SORT)

#ifdef VICLIB_IMPLEMENTATION

int is_space(int _c)
{
    char c = (char)_c;
    return(c == ' ' || c == '\n' || c == '\t' ||
           c == '\v' || c == '\f' || c == '\r');
}

#ifndef strlen
size_t strlen(const char *s)
{
    size_t n = 0;
    for(; *s != 0; s++) n++;
    return n;
}
#endif // strlen

VIEWPROC view ViewFromParts(const char *data, size_t count)
{
    view v;
    v.items = data;
    v.count = count;
    return v;
}

VIEWPROC view ViewFromCstr(const char *cstr)
{
    view v;
    v.items = cstr;
    v.count = strlen(cstr);
    return v;
}

VIEWPROC view ViewSlice(view a, size_t start, size_t end)
{
    AssertMsg(start <= end, "start must be smaller or equal to end");
    AssertMsg(end <= a.count, "end must be less or equal to the source view count");
    return ViewFromParts(a.items + start, end - start);
}

VIEWPROC view ViewTrimLeft(view v)
{
    size_t i = 0;
    for(;i < v.count && is_space(v.items[i]);) i += 1;

    return ViewFromParts((const char*)(v.items + i), v.count - i);
}
VIEWPROC view ViewTrimRight(view v)
{
    size_t i = 0;
    for(;i < v.count && is_space(v.items[v.count - 1 - i]);) i += 1;

    return ViewFromParts((const char*)v.items, v.count - i);
}
VIEWPROC view ViewTrim(view v)
{
    return ViewTrimRight(ViewTrimLeft(v));
}

VIEWPROC int ViewCompare(view a, view b)
{
    char res = 0;
    for(size_t i = 0; i < min(a.count, b.count); i++)
    {
        res = a.items[i] - b.items[i];
        if(res != 0) return res;
    }
    return (int)a.count - (int)b.count;
}

VIEWPROC bool ViewEq(view a, view b)
{
    if(a.count != b.count) return false;
    else return mem_compare(a.items, b.items, a.count) == 0;
}

VIEWPROC bool ViewStartsWith(view v, view start)
{
    if(start.count > v.count) return false;
    else return ViewEq(ViewFromParts(v.items, start.count), start);
}

VIEWPROC bool ViewChopStartsWith(view *v, view start)
{
    bool found = ViewStartsWith(*v, start);
    if(found) {
        v->items += start.count;
        v->count -= start.count;
    }
    return found;
}

VIEWPROC const char *ViewFind(view haystack, view needle)
{
    if(needle.count == 0) return haystack.items;
    if(needle.count > haystack.count) return (const char*)0;
    else if(needle.count == haystack.count) {
        return mem_compare(haystack.items, needle.items, haystack.count) == 0 ?
            haystack.items : 0;
    }

    size_t i = 0;
    for(; i < haystack.count && haystack.items[i] != needle.items[0]; i++);
    if(i == haystack.count || needle.count == 1) return (const char*)0;
    haystack.items += i;
    haystack.count -= i;
    if(haystack.count < needle.count) return (const char*)0;

    // Stolen from the musl's implementation of memmem
    switch(needle.count) {
        case 2: {
            // twobyte_memmem
            uint16_t nw = needle.items[0] << 8 | needle.items[1];
            uint16_t hw = haystack.items[0] << 8 | haystack.items[1];
            for (haystack.items += 2, haystack.count -= 2; haystack.count; haystack.count--, hw = hw << 8 | *haystack.items++)
                if(hw == nw) return (const char*)(haystack.items - 2);
            return hw == nw ? (const char*)(haystack.items - 2) : (const char*)0;
        } break;

        case 3: {
            // threebyte_memmem
            uint32_t nw = (uint32_t)needle.items[0] << 24 | needle.items[1] << 16 | needle.items[2] << 8;
            uint32_t hw = (uint32_t)haystack.items[0] << 24 | haystack.items[1] << 16 | haystack.items[2] << 8;
            for (haystack.items += 3, haystack.count -= 3; haystack.count; haystack.count--, hw = (hw | *haystack.items++) << 8)
                if (hw == nw) return (const char*)(haystack.items - 3);
            return hw == nw ? (const char*)(haystack.items - 3) : (const char*)0;
        } break;

        case 4: {
            // fourbyte_memmem
            uint32_t nw = (uint32_t)needle.items[0] << 24 | needle.items[1] << 16 | needle.items[2] << 8 | needle.items[3];
            uint32_t hw = (uint32_t)haystack.items[0] << 24 | haystack.items[1] << 16 | haystack.items[2] << 8 | haystack.items[3];
            for (haystack.items += 4, haystack.count -= 4; haystack.count; haystack.count--, hw = hw << 8 | *haystack.items++)
                if (hw == nw) return (const char*)(haystack.items - 4);
            return hw == nw ? (const char*)(haystack.items - 4) : (const char*)0;
        } break;
    }

    // twoway_memmem
    // TODO
    for(i = 0; i < haystack.count - needle.count; i++) {
        if(mem_compare(haystack.items + i, needle.items, needle.count) == 0)
            return (const char*)(haystack.items + i);
    }
    return (const char*)0;
}

VIEWPROC bool ViewFindChop(view *haystack, view needle, view *chopped)
{
    const char *s = ViewFind(*haystack, needle);
    if(s) {
        size_t count = s - haystack->items;
        if(chopped) {
            chopped->items = haystack->items;
            chopped->count = count;
        }
        haystack->items = s + needle.count;
        haystack->count -= count + needle.count;
        return true;
    }
    return false;
}

VIEWPROC bool ViewFindCharacter(view v, char c, size_t *n)
{
    for(size_t i = 0; i < v.count; i++) {
        if(v.items[i] == c) {
            if(n) *n = i;
            return true;
        }
    }
    return false;
}

VIEWPROC bool ViewFindChopCharacter(view *v, char c, view *chopped)
{
    size_t count;
    bool found = ViewFindCharacter(*v, c, &count);
    if(found) {
        if(chopped) {
            chopped->items = v->items;
            chopped->count = count;
        }
        // skip the character
        v->items = v->items + count + 1;
        v->count -= count + 1;
    }
    return found;
}

VIEWPROC bool ViewEndsWith(view v, view end)
{
    if(end.count > v.count) return false;
    else return ViewEq(ViewFromParts(v.items + v.count - end.count, end.count), end);
}

VIEWPROC view ViewChopByDelim(view *v, char delim)
{
    size_t i = 0;
    for(;i < v->count && v->items[i] != delim;) i += 1;

    view Result = ViewFromParts((const char*)v->items, i);

    if(i < v->count) {
        v->count -= i + 1;
        v->items += i + 1;
    }
    else {
        v->count -= i;
        v->items += i;
    }

    return Result;
}

VIEWPROC view ViewChopByLine(view *v)
{
    size_t moveLen = 1;
    size_t i = 0;
    for(;i < v->count && v->items[i] != '\n';) i += 1;
    if(v->items[i-1] == '\r') {
        moveLen = 2;
        i--;
    }

    view Result = ViewFromParts((const char*)v->items, i);

    if(i < v->count) {
        v->count -= i + moveLen;
        v->items += i + moveLen;
    }
    else {
        v->count -= i;
        v->items += i;
    }

    return Result;
}

VIEWPROC view ViewChopByAnyDelim(view *v, view delims, char *delimiter)
{
    view Result;
    if(delimiter) *delimiter = 0;

    size_t i = 0;
    for(; i < v->count; i++) {
        for(size_t j = 0; j < delims.count; j++)
            if(delims.items[j] == v->items[i]) {
                if(delimiter) *delimiter = v->items[i];
                goto done;
            }
    }

done:
    Result = ViewFromParts((const char*)v->items, i);

    if(i < v->count) {
        v->count -= i + 1;
        v->items += i + 1;
    }
    else {
        v->count -= i;
        v->items += i;
    }

    return Result;
}

VIEWPROC view ViewChopByView(view *v, view delim)
{
    view Window = ViewFromParts((const char*)v->items, delim.count);
    size_t i = 0;
    for(; i + delim.count < v->count && !ViewEq(Window, delim);) {
        i++;
        Window.items++;
    }

    view Result = ViewFromParts((const char*)v->items, i);

    if(i + delim.count == v->count) {
        // include last <delim.count> characters if they aren't
        //  equal to delim
        Result.count += delim.count;
    }

    v->items += i + delim.count;
    v->count -= i + delim.count;

    return Result;
}

VIEWPROC view ViewChopLeft(view *v, size_t n)
{
    if(n > v->count) n = v->count;

    view Result = ViewFromParts((const char*)v->items, n);
    v->items += n;
    v->count -= n;

    return Result;
}

VIEWPROC view ViewChopRight(view *v, size_t n)
{
    if(n > v->count) n = v->count;

    view Result = ViewFromParts((const char*)(v->items + v->count - n), n);
    v->count -= n;

    return Result;
}

int _digit_val(int c)
{
    int v = 16;
    if(c >= '0' && c <= '9') {
        v = c - '0';
    }
    else if(c >= 'a' && c <= 'z') {
        v = c - 'a' + 10;
    }
    else if(c >= 'A' && c <= 'Z') {
        v = c - 'A' + 10;
    }
    return v;
}

// '0' is the prefix for octal in C, surprisingly, so '080' is an invalid number
// try to compile: int n = 080;
// I checked out how Odin did octal and they do "0o" prefix, seemed more logical.
// I also don't know what the "0z" prefix of base 12 is for but I'll just leave it there
VIEWPROC bool ViewParseS64(view v, s64 *result, view *remaining)
{
    AssertMsg(result != 0, "Result parameter must be a valid pointer");
    v = ViewTrimLeft(v);
    if(v.count == 0) return false;

    bool Neg = false;
    if(v.count > 1) {
        if(v.items[0] == '-') {
            Neg = true;
            v.items++;
            v.count--;
        }
        else if(v.items[0] == '+') {
            v.items++;
            v.count--;
        }
    }

    int Base = 10;
    // try to parse a prefix
    if(v.count > 2 && v.items[0] == '0') {
        if(v.items[1] == 'b' || v.items[1] == 'B') {
            Base = 2; v.items += 2; v.count -= 2;
        }
        else if(v.items[1] == 'o') {
            Base = 8; v.items += 2; v.count -= 2;
        }
        else if(v.items[1] == 'd') {
            Base = 10; v.items += 2; v.count -= 2;
        }
        else if(v.items[1] == 'z') {
            Base = 12; v.items += 2; v.count -= 2;
        }
        else if(v.items[1] == 'x' || v.items[1] == 'X') {
            Base = 16; v.items += 2; v.count -= 2;
        }
    }

    int Digit = _digit_val((int)v.items[0]);
    if(Digit >= Base) return false;

    s64 Value = 0;
    int j = 0;
    for(; j < (int)v.count; j++) {
        char c = v.items[j];
        if(c != '_') {
            Digit = _digit_val((int)c);
            if(Digit >= Base) {
                // invalid digit
                break;
            }
            Value *= Base;
            Value += Digit;
        }
    }

    if(Neg) Value = -Value;
    *result = Value;
    if(remaining) {
        remaining->items = v.items + (size_t)j;
        remaining->count = v.count - (size_t)j;
    }

    return true;
}

int ViewParseF64(view v, f64 *result, view *remaining)
{
    AssertMsg(result != 0, "Result parameter must be a valid pointer");
    v = ViewTrimLeft(v);
    if(v.count == 0) return PARSE_FAIL;
    bool DecimalPart = false;

    bool Neg = false;
    if(v.count > 1) {
        if(v.items[0] == '-') {
            Neg = true;
            v.items++;
            v.count--;
        }
        else if(v.items[0] == '+') {
            v.items++;
            v.count--;
        }
    }

    if(v.count > 1 && v.items[0] == '.') {
        DecimalPart = true;
        v.items++;
        v.count--;
    }

    if(*v.items > '9' || *v.items < '0') return PARSE_FAIL;

    double Val = 0.0;
    double Multiplier = 1.0;

    bool FoundExponent = false;
    view ExponentStr;
    size_t j = 0;
    for(; j < v.count; j++) {
        char c = v.items[j];
        if(c == '.') {
            DecimalPart = true;
            if(j+1 < v.count && (v.items[j+1] > '9' || v.items[j+1] < '0')) {
                break;
            }
        }
        else if(c == 'e' || c == 'E') {
            // Try to parse exponent
            // Not sure how I feel about this, there probably is a better way to do this
            ExponentStr = ViewFromParts(v.items + j + 1, v.count - j - 1);

            bool Prefixed = false;
            bool ExpNeg = false;
            if(ExponentStr.count > 1) {
                if(ExponentStr.items[0] == '-') {
                    Prefixed = true;
                    ExpNeg = true;
                    ExponentStr.items++;
                    ExponentStr.count--;
                }
                else if(ExponentStr.items[0] == '+') {
                    Prefixed = true;
                    ExponentStr.items++;
                    ExponentStr.count--;
                }
            }

            if(ExponentStr.count < 1) break;
            if(*ExponentStr.items > '9' || *ExponentStr.items < '0') break;
            
            FoundExponent = true;
            size_t ExpEnd = 0;
            for(; ExpEnd < ExponentStr.count; ExpEnd++) {
                if(ExponentStr.items[ExpEnd] > '9' || ExponentStr.items[ExpEnd] < '0') break;
            }

            double ExpMultiplier = 10.0;
            int charVal = ExponentStr.items[ExpEnd - 1] - '0';
            if(ExpNeg) {
                for(int k = 0; k < charVal; k++) Val /= ExpMultiplier;
                ExpMultiplier = 10000000000.0;
                for(s64 k = (s64)ExpEnd - 2; k >= 0; k--) {
                    charVal = ExponentStr.items[k] - '0';
                    for(int l = 0; l < charVal; l++) Val /= ExpMultiplier;
                    ExpMultiplier *= 10000000000.0;
                }
            } else {
                for(int k = 0; k < charVal; k++) Val *= ExpMultiplier;
                ExpMultiplier = 10000000000.0;
                for(s64 k = (s64)ExpEnd - 2; k >= 0; k--) {
                    charVal = ExponentStr.items[k] - '0';
                    for(int l = 0; l < charVal; l++) Val *= ExpMultiplier;
                    ExpMultiplier *= 10000000000.0;
                }
            }

            j += 1 + ExpEnd + (size_t)Prefixed;
            break;
        }
        else if(c > '9' || c < '0') {
            // found non numeric character
            break;
        }
        else if(DecimalPart) {
            Multiplier *= 0.1;
            Val += (v.items[j] - '0')*Multiplier;
        }
        else {
            Val *= 10.0;
            Val += v.items[j] - '0';
        }
    }

    if(Neg) Val = -Val;
    *result = Val;
    if(remaining) {
        remaining->items = v.items + j;
        remaining->count = v.count - j;
    }
    return (DecimalPart || FoundExponent) ? PARSE_OK : PARSE_NO_DECIMALS;
}

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

#if !defined(VL_INC_STRING_H) && !defined(SDL_h_)
#define VICLIB_MEMCPY_ALIGN (sizeof(size_t)-1)
VLIBPROC void mem_copy_non_overlapping(void *dst, const void *src, size_t len)
{
    u8 *d = (u8*)dst;
    const u8 *s = (const u8*)src;
    if(((uintptr_t)d & VICLIB_MEMCPY_ALIGN) != ((uintptr_t)s & VICLIB_MEMCPY_ALIGN))
        goto misaligned;

    for(; ((uintptr_t)d & VICLIB_MEMCPY_ALIGN) && len != 0; len--) *d++ = *s++;
    if(len != 0) {
        size_t *wideDst = (size_t*)d;
        const size_t *wideSrc = (const size_t*)s;

        for(; len >= sizeof(size_t); len -= sizeof(size_t)) *wideDst++ = *wideSrc++;
        d = (u8*)wideDst;
        s = (const u8*)wideSrc;
misaligned:
        for(; len != 0; len--) *d++ = *s++;
    }
}
#undef VICLIB_MEMCPY_ALIGN

VLIBPROC void mem_copy(void *dst, const void *src, size_t len)
{
    u8 *d = (u8*)dst;
    const u8 *s = (const u8*)src;

    if((uintptr_t)dst == (uintptr_t)src) return;
    if((uintptr_t)s-(uintptr_t)d-len <= -2*len) {
        mem_copy_non_overlapping(d, s, len);
        return;
    }

    if(d < s) {
#if COMPILER_GCC
		if((uintptr_t)s % sizeof(size_t) == (uintptr_t)d % sizeof(size_t)) {
			while((uintptr_t)d % sizeof(size_t)) {
				if(!len--) return;
				*d++ = *s++;
			}
            __attribute__((__may_alias__)) size_t *wideDst = (size_t*)d;
            __attribute__((__may_alias__)) size_t *wideSrc = (size_t*)s;
			for(; len >= sizeof(size_t); len -= sizeof(size_t)) *d++ = *s++;
            d = (u8*)wideDst;
            s = (const u8*)wideSrc;
        }
#endif
		for(; len; len--) *d++ = *s++;
    } else {
#if COMPILER_GCC
		if((uintptr_t)s % sizeof(size_t) == (uintptr_t)d % sizeof(size_t)) {
			while((uintptr_t)(d + len) % sizeof(size_t)) {
				if(!len--) return;
				d[len] = s[len];
			}
			while(len >= sizeof(size_t)) {
                len -= sizeof(size_t);
                *(__attribute__((__may_alias__)) size_t*)(d + len) = 
                    *(__attribute__((__may_alias__)) size_t*)(s + len);
            }
        }
#endif
		while(len) len--, d[len] = s[len];
    }
}

VLIBPROC void mem_zero(void *data, size_t len)
{
    size_t i;

    if ((uintptr_t)data % sizeof(size_t) == 0 &&
        len % sizeof(size_t) == 0) {
        size_t *d = (size_t*)data;

        for(i = 0; i < len/sizeof(size_t); i++) {
            d[i] = 0;
        }
    }
    else {
        char *d = (char*)data;

        for(i = 0; i < len; i++) {
            d[i] = 0;
        }
    }
}

VLIBPROC int mem_compare(const void *str1, const void *str2, size_t count)
{
    const unsigned char *s1 = (const unsigned char*)str1;
    const unsigned char *s2 = (const unsigned char*)str2;

    for(;count-- > 0;) {
        if(*s1++ != *s2++)
            return s1[-1] < s2[-1] ? -1 : 1;
    }
    return 0;
}
#endif // !defined(VL_INC_STRING_H) && !defined(SDL_h_)

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

#if !defined(VICLIB_NO_TEMP_ARENA)
# ifndef VICLIB_TEMP_SIZE
#  define VICLIB_TEMP_SIZE (4*1024*1024)
# endif // !defined(VICLIB_TEMP_SIZE)
static u8 ViclibTempMem[VICLIB_TEMP_SIZE] = {0};
memory_arena ArenaTemp = {
    .size = VICLIB_TEMP_SIZE,
    .base = ViclibTempMem,
    .used = 0,
    .scratchCount = 0,
};
#endif // !defined(VICLIB_NO_TEMP_ARENA)

ARENAPROC char *Arena_strndup(memory_arena *Arena, const char *s, size_t n)
{
    char *Result = ArenaPushSize(Arena, n + 1);
    mem_copy_non_overlapping(Result, s, n);
    Result[n] = '\0';
    return Result;
}

ARENAPROC char *Arena_strdup(memory_arena *Arena, const char *s)
{
    size_t n = strlen(s);
    return Arena_strndup(Arena, s, n);
}

ARENAPROC void ArenaInit(memory_arena *Arena, size_t Size, void *Base)
{
    Arena->used = 0;
    Arena->size = Size;
    Arena->base = (u8*)Base;
    Arena->scratchCount = 0;
}

ARENAPROC size_t ArenaGetAlignmentOffset(memory_arena *Arena, size_t Alignment)
{
    size_t alignOffset = 0;
    size_t currentMemLoc = (size_t)Arena->base + Arena->used;
    size_t alignMask = Alignment - 1;
    if(currentMemLoc & alignMask) {
        alignOffset = Alignment - (currentMemLoc & alignMask);
    }
    return alignOffset;
}

ARENAPROC size_t ArenaGetRemaining_Opt(struct ArenaGetRemaining_opts opt)
{
    if(opt.Alignment < 1) opt.Alignment = 4;
    size_t Result = opt.Arena->size - (opt.Arena->used + ArenaGetAlignmentOffset(opt.Arena, opt.Alignment));
    return Result;
}

ARENAPROC void *ArenaPushSize_Opt(struct ArenaPushSize_opts opt)
{
    if(opt.Alignment < 1) opt.Alignment = 4;
    size_t Size = opt.RequestSize;
    size_t alignOffset = ArenaGetAlignmentOffset(opt.Arena, opt.Alignment);
    Size += alignOffset;

    AssertMsg((opt.Arena->used + Size) <= opt.Arena->size, "Assert Fail: Full arena size reached");
    void *Mem = opt.Arena->base + opt.Arena->used + alignOffset;
    opt.Arena->used += Size;

    return Mem;
}

ARENAPROC void ArenaSplit_Opt(struct ArenaSplit_opts opt)
{
    AssertMsg(opt.Arena->size > opt.SplitSize, "Need more memory in arena to split to requested size");
    if(opt.SplitSize == 0) opt.SplitSize = ArenaGetRemaining(opt.Arena, .Alignment = 1) / 2;

    opt.Arena->splitCount++;
    opt.Arena->size = opt.Arena->size - opt.SplitSize;

    opt.SplitArena->size = opt.SplitSize;
    opt.SplitArena->base = opt.Arena->base + opt.Arena->size;
    opt.SplitArena->used = 0;
    opt.SplitArena->scratchCount = 0;
    opt.SplitArena->splitCount = 0;
    ArenaPushSize(opt.SplitArena, 0, .Alignment = 4); // 'leak' up to 4 bytes here to keep the memory aligned
}

ARENAPROC void ArenaRejoin(memory_arena *Arena, memory_arena *SplitArena)
{
    AssertMsg(Arena->splitCount > 0, "This split arena doesn't belong to the arena");
    AssertMsg(Arena->base + Arena->size == SplitArena->base, "Split arenas must be rejoined as a stack; first in last out");
    AssertMsg(SplitArena->scratchCount == 0, "Rejoining a split arena without Ending all its scratch arenas will cause conflicts with the original arena");
    AssertMsg(SplitArena->splitCount == 0, "Rejoining a split arena without rejoining its split arenas will cause memory leaks");
    SplitArena->base = 0;
    SplitArena->used = 0;
    Arena->size += SplitArena->size;
    Arena->splitCount--;
}

ARENAPROC void ArenaSplitMultiple_Impl(memory_arena *Arena, memory_arena **SplitArenas, size_t SplitArenaCount)
{
    size_t splitSize = ArenaGetRemaining(Arena, .Alignment = 1) / (SplitArenaCount + 1);
    for(size_t splitIdx = 0; splitIdx < SplitArenaCount; splitIdx++) ArenaSplit(Arena, SplitArenas[splitIdx], splitSize);
}

ARENAPROC void ArenaRejoinMultiple_Impl(memory_arena *Arena, memory_arena **SplitArenas, size_t SplitArenaCount)
{
    for(int64_t splitIdx = (int64_t)SplitArenaCount - 1; splitIdx >= 0; splitIdx--) ArenaRejoin(Arena, SplitArenas[splitIdx]);
}

ARENAPROC scratch_arena ArenaBeginScratch(memory_arena *Arena)
{
    scratch_arena scratch = {
        .Arena = Arena,
        .startMemOffset = Arena->used,
    };
    Arena->scratchCount += 1;

    return scratch;
}

ARENAPROC void ArenaEndScratch(scratch_arena Scratch, bool ZeroMem)
{
    memory_arena *Arena = Scratch.Arena;
    Assert(Arena->used >= Scratch.startMemOffset);
    if(ZeroMem) {
        mem_zero(Arena->base + Scratch.startMemOffset, Arena->used - Scratch.startMemOffset);
    }
    Arena->used = Scratch.startMemOffset;
    Assert(Arena->scratchCount > 0);
    Arena->scratchCount -= 1;
}

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

struct vl_globalcontext VL_globalContext = {0};

VLIBPROC bool VL_Init(void)
{
    if(VL_globalContext.initted) {
        return false; // Only do init once
    }
    VL_globalContext.initted = true;
#if !defined(VICLIB_NO_PLATFORM)
#if OS_WINDOWS
    LARGE_INTEGER time;
#ifdef __cplusplus
    VL_globalContext.performanceFrequency = {0};
#else
    VL_globalContext.performanceFrequency = (LARGE_INTEGER){0};
#endif

    QueryPerformanceFrequency(&VL_globalContext.performanceFrequency);
    QueryPerformanceCounter(&time);
    u64 secs = time.QuadPart / VL_globalContext.performanceFrequency.QuadPart;
    u64 nanos = (time.QuadPart % VL_globalContext.performanceFrequency.QuadPart) *
        VL_NANOS_PER_SEC / VL_globalContext.performanceFrequency.QuadPart;
    VL_globalContext.initTime = VL_NANOS_PER_SEC * secs + nanos;
#elif OS_LINUX || OS_MAC
    struct timespec ts;
    clock_gettime(CLOCK_MONOTONIC, &ts);
    VL_globalContext.initTime = VL_NANOS_PER_SEC * ts.tv_sec + ts.tv_nsec;
#else
#error Unsupported
#endif // OS
#endif // !defined(VICLIB_NO_PLATFORM)

    return true;
}

#if !defined(VICLIB_NO_PLATFORM)

VLIBPROC bool VL_SetCurrentDir(const char *path)
{
#if OS_WINDOWS
    return (bool)SetCurrentDirectory(path);
#elif OS_LINUX || OS_MAC
    return chdir(path) >= 0;
#else
#error Unsupported
#endif
}

VLIBPROC bool VL_FileExists(const char *path)
{
#if _WIN32
    return GetFileAttributesA(path) != INVALID_FILE_ATTRIBUTES;
#else
    return access(path, F_OK) == 0;
#endif
}

#if !OS_WINDOWS
#include <string.h> /* strstr */
#include <ctype.h>
bool IsDebuggerPresent(void)
{
    // https://stackoverflow.com/questions/3596781/how-to-detect-if-the-current-process-is-being-run-by-gdb
    char buf[4096];
    const int status_fd = open("/proc/self/status", O_RDONLY);
    if (status_fd == -1)
        return false;

    const ssize_t num_read = read(status_fd, buf, sizeof(buf) - 1);
    close(status_fd);

    if (num_read <= 0)
        return false;

    buf[num_read] = '\0';
    char tracerPidString[] = "TracerPid:";
    const char *tracer_pid_ptr = strstr(buf, tracerPidString); // TODO: use ViewContains (when it is better)
    if (!tracer_pid_ptr)
        return false;
    
    for(const char* characterPtr = tracer_pid_ptr + sizeof(tracerPidString) - 1; characterPtr <= buf + num_read; ++characterPtr) {
        if (isspace(*characterPtr))
            continue;
        else
            return isdigit(*characterPtr) != 0 && *characterPtr != '0';
    }

    return false;
}
#endif

VLIBPROC bool GetLastWriteTime(const char *file, u64 *WriteTime)
{
    bool ok = false;

#if OS_WINDOWS
    WIN32_FILE_ATTRIBUTE_DATA data;
    if(GetFileAttributesEx(file, GetFileExInfoStandard, &data) &&
        (uint64_t)data.nFileSizeHigh + (uint64_t)data.nFileSizeLow > 0)
    {
        *WriteTime = *(uint64_t*)&data.ftLastWriteTime;
        ok = true;
    }
#elif OS_LINUX || OS_MAC
    struct stat attr;
    if(!stat(file, &attr) && attr.st_size > 0) {
        ok = true;
        *WriteTime = *(uint64_t*)&attr.st_mtim;
    }
#else
#error Unsupported
#endif

    return ok;
}

VLIBPROC file_type VL_GetFileType(const char *path)
{
#if OS_WINDOWS
    DWORD attr = GetFileAttributesA(path);
    if(attr == INVALID_FILE_ATTRIBUTES) return VL_FILE_INVALID;
    if(attr & FILE_ATTRIBUTE_DIRECTORY) return VL_FILE_DIRECTORY;
    if(attr & FILE_ATTRIBUTE_REPARSE_POINT) return VL_FILE_SYMLINK;
    return VL_FILE_REGULAR;
#elif OS_LINUX || OS_MAC
    struct stat statbuf;
    if(lstat(path, &statbuf) < 0) return VL_FILE_INVALID;
    if(S_ISREG(statbuf.st_mode)) return VL_FILE_REGULAR;
    if(S_ISDIR(statbuf.st_mode)) return VL_FILE_DIRECTORY;
    if(S_ISLNK(statbuf.st_mode)) return VL_FILE_SYMLINK;
    return VL_FILE_OTHER;
#else
#error Unsupported
#endif
}

VLIBPROC u64 VL_GetNanos(void)
{
#if OS_WINDOWS
    AssertMsg(VL_globalContext.performanceFrequency.QuadPart != 0, "Error: You must call VL_Init() before calling VL_GetNanos()");

    LARGE_INTEGER time;
    QueryPerformanceCounter(&time);
    u64 secs = time.QuadPart / VL_globalContext.performanceFrequency.QuadPart;
    u64 nanos = (time.QuadPart % VL_globalContext.performanceFrequency.QuadPart) * 
        VL_NANOS_PER_SEC / VL_globalContext.performanceFrequency.QuadPart;
    return (VL_NANOS_PER_SEC * secs + nanos) - VL_globalContext.initTime;
#elif OS_LINUX || OS_MAC
    struct timespec ts;
    clock_gettime(CLOCK_MONOTONIC, &ts);
    return (VL_NANOS_PER_SEC * ts.tv_sec + ts.tv_nsec) - VL_globalContext.initTime;
#else
#error Unsupported
#endif
}

#if !defined(VICLIB_NO_FILE_IO)

PUSH_IGNORE_UNINITIALIZED
VLIBPROC char *ReadEntireFile(memory_arena *Arena, char *File, size_t *Size)
{
    VL_ErrorNumber = ERROR_NO_ERROR;
#if OS_WINDOWS
    AssertMsg(Size != 0, "Size parameter must be a valid pointer");
    char *result = 0;
    HANDLE FileHandle = CreateFileA(File, GENERIC_READ, FILE_SHARE_READ, 0, OPEN_EXISTING, 0, 0);
    bool ok = FileHandle != INVALID_HANDLE_VALUE;
    if(!ok) {
        DWORD Error = GetLastError();
        switch(Error) {
            case ERROR_INVALID_DRIVE: fallthrough;
            case ERROR_PATH_NOT_FOUND: fallthrough;
            case ERROR_FILE_NOT_FOUND: VL_ErrorNumber = ERROR_READ_FILE_NOT_FOUND; break;
            case ERROR_ACCESS_DENIED: VL_ErrorNumber = ERROR_FILE_ACCESS_DENIED; break;

            default: VL_ErrorNumber = ERROR_READ_UNKNOWN; break;
        }
    }

    LARGE_INTEGER FileSize;
    if(ok) {
        ok = (bool)GetFileSizeEx(FileHandle, &FileSize);
        if(!ok) VL_ErrorNumber = ERROR_READ_UNKNOWN;
    }

    u64 Limit = READ_ENTIRE_FILE_MAX;

    if(ok) {
        ok = (u64)FileSize.QuadPart <= Limit;
        if(!ok) VL_ErrorNumber = ERROR_READ_FILE_TOO_BIG;
    }
    u32 FileSizeU32 = (u32)FileSize.QuadPart;

    size_t arenaMark = Arena->used;
    if(ok) {
        if(ArenaGetRemaining(Arena) < (size_t)FileSize.QuadPart) {
            VL_ErrorNumber = ERROR_NO_MEM;
            ok = false;
        } else {
            result = ArenaPushSize(Arena, FileSize.QuadPart);
        }
    }

    if(ok) {
        DWORD BytesRead;
        if(ReadFile(FileHandle, result, FileSizeU32, &BytesRead, 0) && (FileSize.QuadPart == BytesRead))
        {
            *Size = FileSize.QuadPart;
        } else {
            VL_ErrorNumber = ERROR_READ_UNKNOWN;
            mem_zero(Arena->base + arenaMark, Arena->used - arenaMark);
            Arena->used = arenaMark;
        }
    }

    CloseHandle(FileHandle);
#elif OS_LINUX || OS_MAC
    char *result = 0;
    int fd = open(File, O_RDONLY);
    if(fd == -1) {
        if(errno == EACCES || errno == EPERM) VL_ErrorNumber = ERROR_FILE_ACCESS_DENIED;
        else if(errno == ENOMEM) VL_ErrorNumber = ERROR_NO_MEM;
        else if(errno == EOVERFLOW) VL_ErrorNumber = ERROR_READ_FILE_TOO_BIG;
        else if(errno == EBADF || errno == ENOENT)
            VL_ErrorNumber = ERROR_READ_FILE_NOT_FOUND;
        else VL_ErrorNumber = ERROR_READ_UNKNOWN;
        return 0;
    }

    struct stat stat;
    if(fstat(fd, &stat) == -1) {
        VL_ErrorNumber = ERROR_READ_UNKNOWN;
        close(fd);
        return 0;
    }

    size_t arenaMark = Arena->used;
    if(ArenaGetRemaining(Arena) < (size_t)stat.st_size) {
        VL_ErrorNumber = ERROR_NO_MEM;
        close(fd);
        return 0;
    } else {
        result = ArenaPushSize(Arena, (size_t)stat.st_size);
    }

    ssize_t bytesRead = read(fd, result, stat.st_size);
    if(bytesRead != stat.st_size) {
        VL_ErrorNumber = ERROR_READ_UNKNOWN;
        close(fd);
        mem_zero(Arena->base + arenaMark, Arena->used - arenaMark);
        Arena->used = arenaMark;
        return 0;
    }

    close(fd);

    if(Size) *Size = stat.st_size;
#else
#error Unsupported
#endif
    return result;
}
RESTORE_WARNINGS

bool ReadFileChunk(vl_file_chunk *Chunk, const char *File, u32 *ChunkSize)
{
    AssertMsg(Chunk->Buffer && Chunk->BufferSize, "Requires a valid buffer and a buffer size");
    VL_ErrorNumber = 0;

#if OS_WINDOWS
    if(!Chunk->File) {
        Chunk->File = CreateFileA(File, GENERIC_READ, FILE_SHARE_READ, 0, OPEN_EXISTING, 0, 0);
        if(Chunk->File == INVALID_HANDLE_VALUE) {
            DWORD Error = GetLastError();
            switch(Error) {
                case ERROR_INVALID_DRIVE: fallthrough;
                case ERROR_PATH_NOT_FOUND: fallthrough;
                case ERROR_FILE_NOT_FOUND: VL_ErrorNumber = ERROR_READ_FILE_NOT_FOUND; break;
                case ERROR_ACCESS_DENIED: VL_ErrorNumber = ERROR_FILE_ACCESS_DENIED; break;

                default: VL_ErrorNumber = ERROR_READ_UNKNOWN; break;
            }
            return false;
        }

        LARGE_INTEGER FileSize;
        if(GetFileSizeEx(Chunk->File, &FileSize) == 0) {
            // NOTE: Shouldn't fail if CreateFile didn't fail
            VL_ErrorNumber = ERROR_READ_UNKNOWN;
            return false;
        }

        Chunk->RemainingFileSize = FileSize.QuadPart;
    } else if(Chunk->RemainingFileSize == 0) {
        CloseHandle(Chunk->File);
        Chunk->File = 0;
        return false;
    }
    size_t OutSize = min(Chunk->RemainingFileSize, (size_t)Chunk->BufferSize);

    DWORD BytesRead;
    if(ReadFile(Chunk->File, Chunk->Buffer, (u32)OutSize, &BytesRead, 0) && (OutSize == BytesRead))
    {
        *ChunkSize = (u32)OutSize;
    } else {
        VL_ErrorNumber = ERROR_READ_UNKNOWN;
        return false;
    }

#elif OS_LINUX || OS_LINUX
    if(!Chunk->didFirstIteration) {
        Chunk->didFirstIteration = true;
        Chunk->fd = open(File, O_RDONLY);
        if(Chunk->fd == -1) {
            if(errno == EACCES || errno == EPERM) VL_ErrorNumber = ERROR_FILE_ACCESS_DENIED;
            else if(errno == ENOMEM) VL_ErrorNumber = ERROR_NO_MEM;
            else if(errno == EOVERFLOW) VL_ErrorNumber = ERROR_READ_FILE_TOO_BIG;
            else if(errno == EBADF || errno == ENOENT)
                VL_ErrorNumber = ERROR_READ_FILE_NOT_FOUND;
            else VL_ErrorNumber = ERROR_READ_UNKNOWN;
            return false;
        }

        struct stat stat;
        if(fstat(Chunk->fd, &stat) == -1) {
            VL_ErrorNumber = ERROR_READ_UNKNOWN;
            close(Chunk->fd);
            return false;
        }

        Chunk->RemainingFileSize = stat.st_size;
    } else if(Chunk->RemainingFileSize == 0) {
        if(Chunk->fd > 2) close(Chunk->fd); // I don't think I should try to close stdin, stdout, stderr?
        Chunk->didFirstIteration = false;
        Chunk->fd = 0;
        return false;
    }

    size_t OutSize = min(Chunk->RemainingFileSize, (size_t)Chunk->BufferSize);

    if(OutSize == (size_t)read(Chunk->fd, Chunk->Buffer, OutSize)) {
        *ChunkSize = (u32)OutSize;
    } else {
        VL_ErrorNumber = ERROR_READ_UNKNOWN;
        return false;
    }
#else
#error Unsupported
#endif

    Chunk->RemainingFileSize -= (u32)OutSize;
    return true;
}

VLIBPROC bool WriteEntireFile(const char *File, const void *Data, size_t Size)
{
    bool result = true;

#if OS_WINDOWS
    HANDLE fhandle = INVALID_HANDLE_VALUE;

    fhandle = CreateFileA(File, GENERIC_WRITE, 0, 0, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
    if(fhandle == INVALID_HANDLE_VALUE) {
        DWORD Error = GetLastError();
        switch(Error) {
            case ERROR_INVALID_DRIVE: fallthrough;
            case ERROR_PATH_NOT_FOUND: fallthrough;
            case ERROR_FILE_NOT_FOUND: VL_ErrorNumber = ERROR_WRITE_PATH_NOT_FOUND; break;
            case ERROR_ACCESS_DENIED: VL_ErrorNumber = ERROR_FILE_ACCESS_DENIED; break;

            default: VL_ErrorNumber = ERROR_WRITE_UNKNOWN;
        }
        VL_ReturnDefer(false);
    }

    Assert(Size < 0xFFFFFFFFULL);
    u8 *fData = (u8*)Data;
    DWORD bytesToWriteTotal = (DWORD)Size;
    DWORD bytesWrittenTotal = 0;
    DWORD bytesWritten = 0;
    while(bytesToWriteTotal > bytesWrittenTotal) {
        if(!WriteFile(fhandle, fData, bytesToWriteTotal - bytesWrittenTotal, &bytesWritten, 0)) {
            VL_ErrorNumber = ERROR_WRITE_UNKNOWN;
            VL_ReturnDefer(false);
        }
        bytesWrittenTotal += bytesWritten;
        fData += bytesWritten;
    }

defer:
    if(fhandle != INVALID_HANDLE_VALUE) CloseHandle(fhandle);
    return result;

#elif OS_LINUX || OS_MAC
    int fd = open(File, O_CREAT | O_WRONLY | O_TRUNC);
    if(fd == -1) {
        if(errno == EACCES || errno == EPERM) VL_ErrorNumber = ERROR_FILE_ACCESS_DENIED;
        else if(errno == ENOMEM) VL_ErrorNumber = ERROR_NO_MEM;
        else if(errno == EOVERFLOW) VL_ErrorNumber = ERROR_READ_FILE_TOO_BIG;
        // this could happen if creating a file in a directory that doesn't exist I think?
        else if(errno == EBADF || errno == ENOENT)
            VL_ErrorNumber = ERROR_READ_FILE_NOT_FOUND;
        else VL_ErrorNumber = ERROR_READ_UNKNOWN;
        return false;
    }

    u8 *fData = (u8*)Data;
    ssize_t bytesToWriteTotal = (ssize_t)Size;
    ssize_t bytesWrittenTotal = 0;
    while(bytesToWriteTotal > bytesWrittenTotal) {
        ssize_t bytesWritten = write(fd, fData, bytesToWriteTotal - bytesWrittenTotal);
        if(bytesWritten == -1) {
            VL_ErrorNumber = ERROR_WRITE_UNKNOWN;
            VL_ReturnDefer(false);
        }
        bytesWrittenTotal += bytesWritten;
        fData += bytesWritten;
    }

defer:
    close(fd);
    return result;
#else
#error Unsupported
#endif
}

#endif // !defined(VICLIB_NO_FILE_IO)

VLIBPROC const char *VL_GetError(void) {
    switch(VL_ErrorNumber) {
        case ERROR_READ_UNKNOWN: return "Unknown read error";
        case ERROR_WRITE_UNKNOWN: return "Unknown write error";
        case ERROR_READ_FILE_NOT_FOUND: return "File not found";
        case ERROR_WRITE_PATH_NOT_FOUND: return "Path not found"; /* A directory specified to get to the file does not exist */
        case ERROR_FILE_ACCESS_DENIED: return "Access denied";
        case ERROR_NO_MEM: return "No remaining memory";
        case ERROR_READ_FILE_TOO_BIG: return "File too large";
    
        case ERROR_NO_ERROR:
        default: return "Unknown error";
    }
}

#endif // !defined(VICLIB_NO_PLATFORM)

#ifndef VICLIB_NO_SORT

bool int_less_than(const void *A, const void *B) {
    return (*(int*)A < *(int*)B);
}

void VL_SwapSize(void *A, void *B, size_t Size)
{
    size_t i;
    if((uintptr_t)A % sizeof(size_t) == 0 &&
       (uintptr_t)B % sizeof(size_t) == 0 &&
       Size % sizeof(size_t) == 0)
    {
        size_t temp;
        size_t *APtr = (size_t*)A;
        size_t *BPtr = (size_t*)B;

        for(i = 0; i < Size/sizeof(size_t); i++) {
            VL_Swap(*APtr, *BPtr);
            APtr++; BPtr++;
        }
    }
    else {
        char temp;
        char *APtr = (char*)A;
        char *BPtr = (char*)B;

        for(i = 0; i < Size; i++) {
            VL_Swap(*APtr, *BPtr);
            APtr++; BPtr++;
        }
    }
}

// introsort
void Sort(void *Data, size_t Count, size_t ElementSize, bool (*less_than)(const void *, const void *))
{
    // compute MaxDepth = 2*log_2(Count)
    int MaxDepth = -2;
    for(size_t i = Count; i != 0; i >>= 1) MaxDepth += 2;
    VL_IntroSort(Data, 0, Count - 1, MaxDepth, ElementSize, less_than);
}
void VL_IntroSort(void *Data, size_t lo, size_t hi, int Depth, size_t ElementSize, bool (*less_than)(const void *, const void *))
{
    if(lo < hi) {
        if((hi - lo + 1) < 16) {
            VL_InsertionSort((u8*)Data + lo*ElementSize, hi - lo + 1, ElementSize, less_than);
        }
        else if(Depth == 0) {
            VL_HeapSort((u8*)Data + lo*ElementSize, hi - lo + 1, ElementSize, less_than);
        }
        else {
            size_t PivotIdx = (lo + hi)/2; // median of 3 could be better here, I'm not sure

            VL_SwapSize((u8*)Data + PivotIdx*ElementSize, (u8*)Data + lo*ElementSize, ElementSize);
            void *Pivot = (u8*)Data + lo*ElementSize;

            size_t i = lo + 1;
            for(size_t j = lo + 1; j < hi + 1; j++)
            {
                if(less_than((u8*)Data + j*ElementSize, Pivot)) {
                    // swap(Arr[i], Arr[j]);
                    VL_SwapSize((u8*)Data + i*ElementSize, (u8*)Data + j*ElementSize, ElementSize);
                    i++;
                }
            }
            // swap(Arr[lo], Arr[i-1]);
            VL_SwapSize((u8*)Data + lo*ElementSize, (u8*)Data + (i-1)*ElementSize, ElementSize);
            PivotIdx = i - 1;

            if(PivotIdx > 0) VL_IntroSort(Data, lo, PivotIdx - 1, Depth - 1, ElementSize, less_than);
            VL_IntroSort(Data, PivotIdx + 1, hi, Depth - 1, ElementSize, less_than);
        }
    }
}

void VL_InsertionSort(void *Data, size_t Count, size_t ElementSize, bool (*less_than)(const void *, const void *))
{
    for(size_t i = 1; i < Count; i++)
    {
        void *Val = (u8*)Data + i*ElementSize;

        int64_t j = i - 1;
        for(;j >= 0 && less_than(Val, (u8*)Data + j*ElementSize); j--)
        {
            mem_copy((u8*)Data + (j+1)*ElementSize, (u8*)Data + j*ElementSize, ElementSize);
        }
        mem_copy((u8*)Data + (j+1)*ElementSize, Val, ElementSize);
    }
}
void VL_HeapSort(void *Data, size_t Count, size_t ElementSize, bool (*less_than)(const void *, const void *))
{
    // left child = 2*i + 1
    // right child = 2*i + 2
    // parent = (i-1)/2 (truncated)

    for(size_t Start = (Count - 2) / 2; Start > 0; Start--) {
        size_t Root = Start;
        while(2*Root + 1 < Count) {
            size_t Child = 2*Root + 1;
            if(Child + 1 < Count && less_than((u8*)Data + Child*ElementSize, (u8*)Data + (Child+1)*ElementSize)) {
                Child++;
            }
            
            if(less_than((u8*)Data + Root*ElementSize, (u8*)Data + Child*ElementSize)) {
                VL_SwapSize((u8*)Data + Root*ElementSize, (u8*)Data + Child*ElementSize, ElementSize);
                Root = Child;
            } else {
                break;
            }
        }
    }
    
    for(size_t End = Count - 1; End > 0; End--) {
        VL_SwapSize(Data, (u8*)Data + End*ElementSize, ElementSize);
        
        size_t Root = 0;
        while(2*Root + 1 < End) {
            size_t Child = 2*Root + 1;
            if(Child + 1 < End && less_than((u8*)Data + Child*ElementSize, (u8*)Data + (Child+1)*ElementSize)) {
                Child++;
            }
            
            if(less_than((u8*)Data + Root*ElementSize, (u8*)Data + Child*ElementSize)) {
                VL_SwapSize((u8*)Data + Root*ElementSize, (u8*)Data + Child*ElementSize, ElementSize);
                Root = Child;
            } else {
                break;
            }
        }
    }
}

#endif // !defined(VICLIB_NO_SORT)
#endif // VICLIB_IMPLEMENTATION

// NOTE: 'static inline' functions should be outside VICLIB_IMPLEMENTATION

uint32_t CountLeadingZerosU32(uint32_t val)
{
#if COMPILER_GCC || COMPILER_CLANG || COMPILER_TCC
    return __builtin_clz(val);
#elif COMPILER_CL
    DWORD idx = 0;
    _BitScanReverse(&idx, val);
    return idx ^ 31;
#else
    for(uint32_t i = 0; i < 32; i++) {
        if((val & (1 << (31 - i))) != 0) return i;
    }
    return 32;
#endif
}

uint32_t CountLeadingZerosU64(uint64_t val)
{
#if COMPILER_GCC || COMPILER_CLANG || COMPILER_TCC
    return __builtin_clzll(val);
#elif COMPILER_CL
    DWORD idx = 0;
    _BitScanReverse64(&idx, val);
    return idx ^ 63;
#else
    for(uint32_t i = 0; i < 64; i++) {
        if((val & (1 << (63 - i))) != 0) return i;
    }
    return 64;
#endif
}

uint32_t CountTrailingZerosU32(uint32_t val)
{
#if COMPILER_GCC || COMPILER_CLANG || COMPILER_TCC
    return __builtin_ctz(val);
#elif COMPILER_CL
    DWORD idx = 0;
    _BitScanForward(&idx, val);
    return idx;
#else
    for(uint32_t i = 0; i < 32; i++) {
        if((val & (1 << i)) != 0) return i;
    }
    return 32;
#endif
}

uint32_t CountTrailingZerosU64(uint64_t val)
{
#if COMPILER_GCC || COMPILER_CLANG || COMPILER_TCC
    return __builtin_ctzll(val);
#elif COMPILER_CL
    DWORD idx = 0;
    _BitScanForward64(&idx, val);
    return idx;
#else
    for(uint32_t i = 0; i < 64; i++) {
        if((val & (1 << i)) != 0) return i;
    }
    return 64;
#endif
}

uint32_t CountLeadingZerosSafeU32(uint32_t val)
{
#if COMPILER_GCC || COMPILER_CLANG || COMPILER_TCC
    return val ? __builtin_clz(val) : 32;
#elif COMPILER_CL
    DWORD idx = 0;
    _BitScanReverse(&idx, val);
    return val ? idx ^ 31 : 32;
#else
    for(uint32_t i = 0; i < 32; i++) {
        if((val & (1 << (31 - i))) != 0) return i;
    }
    return 32;
#endif
}

uint32_t CountLeadingZerosSafeU64(uint64_t val)
{
#if COMPILER_GCC || COMPILER_CLANG || COMPILER_TCC
    return val ? __builtin_clzll(val) : 64;
#elif COMPILER_CL
    DWORD idx = 0;
    _BitScanReverse64(&idx, val);
    return val ? idx ^ 63 : 64;
#else
    for(uint32_t i = 0; i < 64; i++) {
        if((val & (1 << (63 - i))) != 0) return i;
    }
    return 64;
#endif
}

uint32_t CountTrailingZerosSafeU32(uint32_t val)
{
#if COMPILER_GCC || COMPILER_CLANG || COMPILER_TCC
    return val ? __builtin_ctz(val) : 32;
#elif COMPILER_CL
    DWORD idx = 0;
    return _BitScanForward(&idx, val) ? idx : 32;
#else
    for(uint32_t i = 0; i < 32; i++) {
        if((val & (1 << i)) != 0) return i;
    }
    return 32;
#endif
}

uint32_t CountTrailingZerosSafeU64(uint64_t val)
{
#if COMPILER_GCC || COMPILER_CLANG || COMPILER_TCC
    return val ? __builtin_ctzll(val) : 64;
#elif COMPILER_CL
    DWORD idx = 0;
    return _BitScanForward64(&idx, val) ? idx : 64;
#else
    for(uint32_t i = 0; i < 64; i++) {
        if((val & (1 << i)) != 0) return i;
    }
    return 64;
#endif
}

#endif //VICLIB_H