Skip to content

Instantly share code, notes, and snippets.

@mlabbe

mlabbe/ftg_core.h

Last active December 4, 2021 00:26
Show Gist options
  • Save mlabbe/b7d30615de3ec6c5980dbde867df3db8 to your computer and use it in GitHub Desktop.
Save mlabbe/b7d30615de3ec6c5980dbde867df3db8 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
ftg_core.h
/* clang-format off */
/* ftg_core.h - v0.6 - Frogtoss Toolbox. Public domain-like license below.
ftg libraries are copyright (C) 2015-2021 Frogtoss Games, Inc.
http://github.com/mlabbe/ftg_toolbox
ftg header files are single file header files intended to be useful
in C/C++. ftg_core contains generally useful functions
Special thanks to STB for the inspiration.
****
You must
#define FTG_IMPLEMENT_CORE
in exactly one C or C++ file.
****
If _DEBUG is defined, assert behaviors change.
OPTIONS
1. define FTG_ENABLE_ASSERT to enable FTG_ASSERT and related macros.
2. define FTG_ENABLE_STOPWATCH to enable code timing stopwatch macros.
3. See SELF-TESTING below to enable self testing.
4. define FTG_BIG_ENDIAN if you are compiling for big
endian. Otherwise FTG_LITTLE_ENDIAN will be set.
5. define FTG_DISABLE_BRIEF_TYPES to avoid u8, i8, etc.
PURPOSE
ftg_core.h contains common routines and aims to smooth over the
differences between compilers and their libraries. It is tested on
Visual C++ 98 (c89), Visual Studio 2015 (roughly c99), modern Clang
and modern GCC both in --std=gnu89 and --std=gnu99 dialects.
It also contains a grab bag of commonly-useful routines and is
somewhat unfocused.
SELF-TESTING
This file contains unit tests. In order to run them, add
ftg_core.h as follows:
#define FTG_IMPLEMENT_TEST
#define FTG_IMPLEMENT_CORE
#define <ftg_test.h>
#define <ftg_core.h>
{
ftg_decl_suite();
int num_failures = ftgt_run_all_tests(NULL);
}
Version history
0.7 simple arena allocator
0.6 windows console alloc/free
0.5 file management
limited utf-8 support (u8 functions)
FTG_MALLOC/FREE/REALLOC macros
0.4 stopwatch timers
0.3 ftg_index_array,
64-bit file management
0.2 ftg_strncpy, ftg_tests,
ftg_va
0.1 ftg_stristr, ftg_stricmp,
compiler macros
Future additions
delete file, dir
unit test 64-bit file functions
wrap allocations in ifdefs
standard utf-8 string ops
*/
#ifndef FTG__INCLUDE_CORE_H
#define FTG__INCLUDE_CORE_H
#if defined(_WIN32) && !defined(__MINGW32__)
# ifndef _CRT_SECURE_NO_WARNINGS
# define _CRT_SECURE_NO_WARNINGS
# endif
#endif
#ifndef FTG_CORE_NO_STDIO
# include <stdio.h>
#else
# include <stddef.h> // for size_t
#endif
/* for off64_t */
#if defined(__linux__) && _FILE_OFFSET_BITS == 64
# include <sys/types.h>
#endif
/* set FTG_DEBUG to either 0 or 1, and ensure both debug and !debug aren't
set across popular macros */
#if defined(NDEBUG)
# define FTG_DEBUG 0
#endif
#if defined(_DEBUG) || defined(DEBUG)
# if defined(FTG_DEBUG)
# error "Both DEBUG and NDEBUG are set."
# endif
# define FTG_DEBUG 1
#endif
/* broad test for OSes that are vaguely POSIX compliant */
#if defined(__linux__) || defined(__APPLE__) || defined(ANDROID) || \
defined(TARGET_OS_IPHONE) || defined(TARGET_IPHONE_SIMULATOR) || \
defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__EMSCRIPTEN__)
# define FTG_POSIX_LIKE 1
#endif
#if defined(__EMSCRIPTEN__)
# define FTG_WASM 1
#endif
/* detect target enviroment bits */
#if _WIN64
# define FTG_BITS 64
#elif _WIN32
# define FTG_BITS 32
#endif
#if __GNUC__
# if __x86_64__ || __ppc64__ || __aarch64__
# define FTG_BITS 64
# else
# define FTG_BITS 32 // todo: confirm emscripten sets this
# endif
#endif
/* unicode strategy: UTF-8 everywhere, except when dealing with Windows functions.
On Windows, define UNICODE and directly call wide versions of functions.
By defining UNICODE, TCHAR functions don't accept char* which is a safety mechanism.
I agree with and attempt to comply with utf8everywhere.org.
Define FTG_IGNORE_UNICODE at your own peril.
*/
#ifndef FTG_IGNORE_UNICODE
# ifdef _WIN32
# if !defined(UNICODE) || !defined(_UNICODE)
# error _UNICODE and UNICODE not defined -- see header comment for justification
# endif
# endif
#endif
#ifndef FTG_BITS
# error "ftg_core.h could not determine 32-bit or 64-bit"
#endif
/* min/max */
#define FTG_MAX(a,b) ((a) > (b) ? (a) : (b))
#define FTG_MIN(a,b) ((a) < (b) ? (a) : (b))
#define FTG_CLAMP(x,xmin,xmax) ((x) < (xmin) ? (xmin) : (x) > (xmax) ? (xmax) : (x))
/* portable specifiers -- used to portably printf these types, ex:
printf("size_t is %" FTG_SPEC_SIZE_T, (size_t)1);
These are piecemeal, as encountered, and best-guess.
If using C99, just use inttypes.h.
*/
#if defined(_MSC_VER) && _MSC_VER < 1310
# define FTG_SPEC_SIZE_T "u"
# define FTG_SPEC_SSIZE_T "d"
# define FTG_SPEC_PTRDIFF_T "d"
#elif defined(_MSC_VER) || defined(__MINGW32__)
# define FTG_SPEC_SIZE_T "Iu"
# define FTG_SPEC_SSIZE_T "Id"
# define FTG_SPEC_PTRDIFF_T "Id"
#elif defined(__GNUC__)
# define FTG_SPEC_SIZE_T "zu"
# define FTG_SPEC_SSIZE_T "zd"
# define FTG_SPEC_PTRDIFF_T "zd"
#endif
#if defined(_MSC_VER)
# define FTG_SPEC_INT64 "I64d"
# define FTG_SPEC_UINT64 "I64d"
#else
# if FTG_BITS == 64 && !defined(__APPLE__) && !defined(__OpenBSD__)
# define FTG_SPEC_INT64 "li"
# define FTG_SPEC_UINT64 "lu"
# elif FTG_BITS == 32 || defined(__APPLE__) || defined(__OpenBSD__)
# define FTG_SPEC_INT64 "lli"
# define FTG_SPEC_UINT64 "lld"
# endif
#endif
/* ftg_off_t printing */
#ifndef FTG_CORE_NO_STDIO
# define FTG_SPEC_OFF_T FTG_SPEC_INT64
#endif
/* octal directory creation mode for posix-like OSes; override if needed */
#ifndef FTG_DIRECTORY_MODE
# define FTG_DIRECTORY_MODE 0750
#endif
#if defined(_MSC_VER) && (_MSC_VER >= 1800)
// VS doesn't define STDC_VERSION because it isn't fully compliant, but this
// actually lets us compile code that we couldn't without it.
# if !defined(__STDC_VERSION__) && !defined(__cplusplus)
# define __STDC_VERSION__ 199901L
# endif
// Because VS doesn't support C99, it thinks non-constant aggregate initializers
// are non-standard per C89 3.5.7, but they are in C99. Disable warning
// in vs2013 and greater.
# ifndef __cplusplus
# pragma warning(disable : 4204)
# endif
#endif
#if __STDC_VERSION__ < 199901L
#define FTG_FUNC ""
#else
#define FTG_FUNC __func__
#endif
/* break */
#ifdef FTGT_TESTS_ENABLED
# define FTG_BREAK() do{}while(0)
#endif
#ifndef FTG_BREAK
#if defined(_WIN32) && _MSC_VER >= 1310
#define FTG_BREAK() __debugbreak();
#elif defined(_WIN32) && defined(_MSC_VER)
#define FTG_BREAK() __asm{ int 0x3 }
#elif defined(__MINGW32__)
#define FTG_BREAK() __asm__ volatile("int $0x03");
#elif defined(__linux__)
#ifdef __arm__
#define FTG_BREAK() __asm__ volatile(".inst 0xde01");
#elif defined(__aarch64__)
#define FTG_BREAK() __builtin_trap();
#else
#define FTG_BREAK() __asm__("int $0x3");
#endif
#elif defined(TARGET_OS_MAC) && defined(__LITTLE_ENDIAN__)
#define FTG_BREAK() __builtin_trap();
#elif defined(ANDROID)
#define FTG_BREAK() __android_log_assert("breakpoint()", "ftg", "breakpoint");
#elif defined(TARGET_IPHONE_SIMULATOR)
#define FTG_BREAK() { __builtin_trap(); }
#elif defined(TARGET_OS_IPHONE)
#ifdef __ARM_ARCH_ISA_A64
asm("svc 0");
#else
asm("trap");
#endif
#else
#include <assert.h>
#define FTG_BREAK() assert(0)
#endif
#endif
/* Make true/false/bool universal macros */
#ifndef __cplusplus
#if __STDC_VERSION__ < 199901L
#if !__bool_true_false_are_defined
#define true 1
#define false 0
#define bool int
#endif
#else
#include <stdbool.h>
#endif
#endif
/* assert
define FTG_ENABLE_ASSERT with FTG_DEBUG=1 to prevent asserts from being noops
Further, define FTG_CUSTOM_ASSERT_REPORTER to provide alternative diagnostics for FTG_ASSERT calls.
Alternatively, undef it to use system assert.
*/
#if !defined(FTG_CUSTOM_ASSERT_REPORTER) && defined(FTGT_TESTS_ENABLED)
# define FTG_CUSTOM_ASSERT_REPORTER ftg__test_assert_reporter
#elif !defined(FTG_CUSTOM_ASSERT_REPORTER)
# define FTG_CUSTOM_ASSERT_REPORTER ftg__default_assert_reporter
#endif
#if defined(FTG_ENABLE_ASSERT) || FTG_DEBUG==1 || defined(FTGT_TESTS_ENABLED)
# ifdef FTG_CUSTOM_ASSERT_REPORTER
# define FTG_ASSERT(exp) \
{ if (!(exp) && FTG_CUSTOM_ASSERT_REPORTER(#exp, __FILE__, FTG_FUNC, __LINE__)) FTG_BREAK() \
;}
# define FTG_ASSERT_FAIL(exp) \
{ FTG_CUSTOM_ASSERT_REPORTER(#exp, __FILE__, FTG_FUNC, __LINE__); FTG_BREAK() \
;((void)exp);}
# else
# include <assert.h>
# define FTG_ASSERT(exp) (void)((exp)||(assert(exp)))
# define FTG_ASSERT_FAIL(exp) (assert(0);)
# endif
#else
# define FTG_ASSERT(exp) ((void)0)
# define FTG_ASSERT_FAIL(exp) ((void)0)
#endif
#define FTG_ASSERT_ALWAYS(exp) \
{ if (!(exp) && FTG_CUSTOM_ASSERT_REPORTER(#exp, __FILE__, FTG_FUNC, __LINE__)) FTG_BREAK(); }
/* static assert */
#define FTG_STATIC_ASSERT_MSG(x, msg) typedef int FTG__StaticAssert_##msg[(x) ? 1 : -1]
#define FTG__STATIC_ASSERT_3(x,L) FTG_STATIC_ASSERT_MSG(x, assertion_at_line_##L)
#define FTG__STATIC_ASSERT_2(x,L) FTG__STATIC_ASSERT_3(x,L)
#define FTG_STATIC_ASSERT(x) FTG__STATIC_ASSERT_2(x,__LINE__)
/* int types */
#if (defined(_MSC_VER) && (_MSC_VER >= 1800)) || defined (__GNUC__) || defined(__clang__)
# include <stdint.h>
# include <stddef.h>
#else
typedef unsigned char uint8_t;
typedef signed char int8_t;
typedef unsigned short uint16_t;
typedef signed short int16_t;
typedef unsigned int uint32_t;
typedef signed int int32_t;
#if FTG_BITS == 32
typedef unsigned int uintptr_t;
typedef int intptr_t;
#else
typedef unsigned long int uintptr_t;
typedef long int intptr_t;
#endif
# if defined(_MSC_VER)
typedef unsigned __int64 uint64_t;
typedef signed __int64 int64_t;
# if FTG_BITS == 64
# define SIZE_MAX (18446744073709551615UL)
# else
# define SIZE_MAX (4294967295U)
# endif
# else
typedef unsigned long long uint64_t;
typedef signed long long int64_t;
# endif
#endif
#ifndef FTG_DISABLE_BRIEF_TYPES
# define FTG_HAS_BRIEF_TYPES
typedef int8_t i8;
typedef int16_t i16;
typedef int32_t i32;
typedef int64_t i64;
typedef uint8_t u8;
typedef uint16_t u16;
typedef uint32_t u32;
typedef uint64_t u64;
typedef float f32;
typedef double f64;
typedef size_t usize;
typedef ptrdiff_t isize;
FTG_STATIC_ASSERT(sizeof(i8) == 1);
FTG_STATIC_ASSERT(sizeof(i16) == 2);
FTG_STATIC_ASSERT(sizeof(i32) == 4);
FTG_STATIC_ASSERT(sizeof(i64) == 8);
FTG_STATIC_ASSERT(sizeof(u8) == 1);
FTG_STATIC_ASSERT(sizeof(u16) == 2);
FTG_STATIC_ASSERT(sizeof(u32) == 4);
FTG_STATIC_ASSERT(sizeof(u64) == 8);
FTG_STATIC_ASSERT(sizeof(f32) == 4);
FTG_STATIC_ASSERT(sizeof(f64) == 8);
FTG_STATIC_ASSERT(sizeof(isize) == sizeof(usize));
#endif
/* portable 64-bit offset types
ftg_off_t is guaranteed to be 64-bit, even on 32-bit builds
on all OSes.
ftg_fopen, ftg_ftell, etc. all operate on 64-bit values.
*/
#ifndef FTG_CORE_NO_STDIO
struct ftg_dirhandle_s;
typedef struct ftg_dirhandle_s ftg_dirhandle_t;
#if defined(__APPLE__)
# define FTG_IO64_EXPLICIT 0
# if _FILE_OFFSET_BITS == 64 || defined(__LP64__)
typedef off_t ftg_off_t;
# else
typedef off64_t ftg_off_t
# endif
#elif defined(__linux__)
/* Linux is a fun one. It offers three separate ways to get a
64-bit file descriptor. The first is through explicit 64-bit
calls and typedefs: defining _LARGEFILE64_SOURCE. The
alternative is specifying _FILE_OFFSET_BITS=64 and then using
transparently using the normal routines. Finally, if __LP64__
is defined, off_t is 64-bit anyway.
As a library trying to work in all cases, we use explicit calls
if they are available, or fall back on transparent calls if they
are not. To simplify preprocessor tests, we define
FTG__IO64_EXPLICIT.
And we statically assert if neither of these are defined. */
# if defined(_LARGEFILE64_SOURCE)
# define FTG__IO64_EXPLICIT 1
typedef off64_t ftg_off_t;
# elif _FILE_OFFSET_BITS == 64
# define FTG__IO64_EXPLICIT 0
typedef off_t ftg_off_t;
# else
# define FTG__IO64_EXPLICIT 0
# if defined(__LP64__)
typedef off_t ftg_off_t;
# else
/* if this is hit, define _FILE_OFFSET_BITS=64 across your compile, or
define FTG_CORE_NO_STDIO to disable all ftg_core I/O */
# error "no 64-bit fopen support."
# endif
# endif
#elif defined(_WIN32)
typedef int64_t ftg_off_t;
typedef wchar_t ftg_wchar_t;
#elif defined(__FreeBSD__) || defined(__OpenBSD__)
typedef off_t ftg_off_t;
#elif defined(FTG_WASM)
typedef off_t ftg_off_t;
#endif
FTG_STATIC_ASSERT(sizeof(ftg_off_t)==8);
#endif /* !FTG_CORE_NO_STDIO */
FTG_STATIC_ASSERT(sizeof(int8_t)==1);
FTG_STATIC_ASSERT(sizeof(int16_t)==2);
FTG_STATIC_ASSERT(sizeof(int32_t)==4);
FTG_STATIC_ASSERT(sizeof(int64_t)==8);
/* these will fail on 16-bit segmented memory platforms. Comment them
out if that happens. */
FTG_STATIC_ASSERT(sizeof(intptr_t) == sizeof(ptrdiff_t));
FTG_STATIC_ASSERT(sizeof(uintptr_t) == sizeof(size_t));
#define FTG_ARRAY_ELEMENTS(n) (sizeof((n)) / sizeof((*n)))
/*
Compiler extensions made portable
USAGE
In MSVC, attributes must be on declarations in addition to prototypes.
Use FTG_ATTRIBUTES to declare them.
Prototype
FTG_EXT_warn_unused_result FTG_EXT_force_inline int SomeFunc( void );
Declaration
FTG_ATTRIBUTES(FTG_EXT_warn_unused_result) int SomeFunc( void );
Keyword extensions made portable
Goal is to use language and compiler-native versions of keywords added
after the c89 standard.
ftg_inline
ftg_restrict
*/
#if defined(__GNUC__) || defined(__clang__)
#define FTG_EXT_warn_unused_result __attribute__((warn_unused_result))
#define FTG_EXT_force_inline __attribute__((always_inline))
#define FTG_EXT_pure_function __attribute__((pure))
#define FTG_EXT_const_function __attribute__((const))
#define FTG_EXT_unused __attribute__((unused))
#define FTG_EXT_no_vtable
#ifdef __cplusplus
#define ftg_restrict __restrict
#else
#if __STDC_VERSION__ >= 199901L
#define ftg_restrict restrict
#endif
#endif
#if __STDC_VERSION__ < 199901L
#define ftg_inline __inline
#else
#define ftg_inline inline
#endif
#define FTG_ATTRIBUTES(x)
// todo: investigate https://twitter.com/deplinenoise/status/971873640609300480
#elif defined(_MSC_VER) && (_MSC_VER >= 1700) /* vs2012 */
#define ftg_restrict __restrict
#define ftg_inline __inline
#define FTG_EXT_warn_unused_result _Check_return_
#define FTG_EXT_force_inline __forceinline
#define FTG_EXT_unused
#define FTG_ATTRIBUTES(x) x
#elif defined(_MSC_VER) && (_MSC_VER >= 1400) /* vs2005 */
#define FTG_EXT_no_vtable __declspec(novtable)
#define ftg_restrict __restrict
#define ftg_inline __inline
#define FTG_EXT_unused
#define FTG_ATTRIBUTES(x) x
#endif
#ifndef FTG_EXT_warn_unused_result
#define FTG_EXT_warn_unused_result
#endif
#ifndef FTG_EXT_force_inline
#define FTG_EXT_force_inline
#endif
#ifndef FTG_EXT_pure_function
#define FTG_EXT_pure_function
#endif
#ifndef FTG_EXT_const_function
#define FTG_EXT_const_function
#endif
#ifndef ftg_restrict
#define ftg_restrict
#endif
#ifndef ftg_inline
#define ftg_inline
#endif
#ifndef FTG_ATTRIBUTES
#define FTG_ATTRIBUTES(x)
#endif
#ifdef FTG_CORE_STATIC
# define FTGDEF static FTG_EXT_unused
#else
# define FTGDEF extern
#endif
/* endianness
use little endian unless FTG_BIG_ENDIAN is defined.
*/
#ifndef FTG_BIG_ENDIAN
# define FTG_LITTLE_ENDIAN
#endif
/* fourcc */
#ifdef FTG_LITTLE_ENDIAN
# define FTG_FOURCC(a,b,c,d) ((d) | ((c)<<8) | ((b)<<16) | ((a)<<24))
#elif FTG_BIG_ENDIAN
# define FTG_FOURCC(a,b,c,d) ((a) | ((b)<<8) | ((c)<<16) | ((d)<<24))
#endif
/* misc macros */
#define FTG_UNUSED(x) ((void)x)
#define FTG_STRLEN 255
#define FTG_STRLEN_SHORT 16
#define FTG_STRLEN_LONG 1024
#define FTG_UNDEFINED_HUE 360.f*2
#define FTG_IA_INIT_ZERO {NULL, 0, 0}
#define FTG_IA_INITIAL_RECORD_COUNT 8
/* usually better to use ftg_correct_dirslash than reference this directly */
#ifdef _WIN32
# define FTG_DIRSLASH '\\'
# define FTG_DIRSLASH_STR "\\"
#elif defined(FTG_POSIX_LIKE)
# define FTG_DIRSLASH '/'
# define FTG_DIRSLASH_STR "/"
#endif
#if defined(__linux__)
# define FTG__HAVE_EXPLICIT_BZERO
#elif defined(__APPLE__)
# define FTG__HAVE_MEMSET_S
#endif
/*
stopwatch -- portable, high precision start/next/stop timer
#define FTG_ENABLE_STOPWATCH before calling this function, or every
call is a noop.
USAGE
1. Declare a stopwatch variable mytimer:
FTG_STOPWATCH_DECL(mytimer);
2. Start the timer, storing time in the bucket named "0":
FTG_STOPWATCH_START(mytimer, 0)
3. (optional) Track additional times within the timer.
This buckets the remaining code into bucket "1":
FTG_STOPWATCH_NEXT(mytimer, 1)
4. Stop the timer
FTG_STOPWATCH_STOP(mytimer)
TIMING AFTER STOP
If FTG_STOPWATCH_NEXT() is encountered after a timer has stopped,
no additional time is counted. This is a key subtlety.
Time spent in subfunction c() of a() is accumulated, but when c()
is a subfunction of b(), it is not accumulated, providing the timer
was stopped before b() was called.
DESCRIBING THE STEPS (optional)
Instead of using numerical steps, you can use named steps like this:
#define A_STEP_NAME 1
Then,
FTG_STOPWATCH_NEXT(mytimer, A_STEP_NAME)
This increases the readability of the reporting.
CUSTOM REPORTING (optional)
After a stopwatch ends, a function with the following prototype is called
to report the stopwatch:
void ftg__default_stopwatch_reporter(const struct ftg_stopwatch_s *);
#define FTG_STOPWATCH_REPORTER to your own function in the file that implements ftg_core
to call that instead.
*/
#ifdef FTG_ENABLE_STOPWATCH
# define FTG_STOPWATCH_DECL(sw) struct ftg_stopwatch_s sw = {"", {0}, {""}, 0, FTG__MAX_STOPWATCH_TIMES+100, false};
# define FTG_STOPWATCH_START(sw, bucket) ftg__stopwatch_start(&sw, #sw, #bucket, bucket)
# define FTG_STOPWATCH_NEXT(sw, bucket) ftg__stopwatch_next_bucket(&sw, #bucket, bucket)
# define FTG_STOPWATCH_STOP(sw) ftg__stopwatch_stop(&sw)
# define FTG_STOPWATCH_EXPR(exp) exp
#define FTG__MAX_STOPWATCH_TIMES 12
struct ftg_stopwatch_s {
char name[FTG_STRLEN_SHORT];
uint64_t times[FTG__MAX_STOPWATCH_TIMES];
char time_names[FTG__MAX_STOPWATCH_TIMES][FTG_STRLEN_SHORT];
uint64_t start_time;
size_t current_bucket;
bool currently_logging;
};
#else
# define FTG_STOPWATCH_DECL(sw)
# define FTG_STOPWATCH_START(sw, bucket)
# define FTG_STOPWATCH_NEXT(sw, bucket)
# define FTG_STOPWATCH_STOP(sw)
# define FTG_STOPWATCH_EXPR(exp)
struct ftg_stopwatch_s;
#endif
/* Define a type by its language-native class type. Useful for
creating types as forward declarations which are ignored when
actually compiling in C.
Usage:
#define TYPE_MACRO FTG_DECL_CLASS(some_type)
TYPE_MACRO;
void some_func(TYPE_MACRO *);
*/
#ifdef __cplusplus
#define FTG_DECL_CLASS(T) class T
#elif __OBJC__
#define FTG_DECL_CLASS(T) @class T
#else
#define FTG_DECL_CLASS(T) struct T
#endif
/* exported decls */
#ifdef __cplusplus
extern "C" {
#endif
/* MSVC earlier than 2005 does not include these in stdio.h. */
#if defined(_MSC_VER) && _MSC_VER < 1400
extern int __cdecl _fseeki64(FILE *, __int64, int);
extern __int64 __cdecl _ftelli64(FILE *);
#endif
#if defined(FTG_MALLOC) && defined(FTG_FREE) && defined(FTG_REALLOC)
// okay
#elif !defined(FTG_MALLOC) && !defined(FTG_FREE) && !defined(FTG_REALLOC)
// also okay
#else
#error "Must define all or none of FTG_MALLOC, FTG_FREE and FTG_REALLOC."
#endif
/* default implementations just call system malloc with assert guards
for OOM and overflow.
ftg_free zeroes pointer in calling code after free.
num - number of elements, size - size of each element */
#ifndef FTG_MALLOC
# define FTG_MALLOC(size, num) ftg_malloc(size, num);
# define FTG_FREE(ptr) ftg_free((void**)&ptr);
# define FTG_REALLOC(ptr, size, num) ftg_realloc(ptr, size, num)
#endif
/*
Arena Allocator
Useful for lots of small allocations on the same thread that all need
to be freed at the same time.
See FTG_ARENA_OVERRIDE to override alignment and page size.
USAGE
ftg_arena_t *arena = ftg_arena_new();
void *ptr = ftg_arena_alloc(&arena, sizeof(sometype_t));
assert(ptr);
ftg_arena_free(arena);
*/
#define FTG_ALIGN_DOWN(n, a) ((n) & ~((a)-1))
#define FTG_ALIGN_UP(n, a) FTG_ALIGN_DOWN((n) + (a)-1, (a))
#define FTG_ALIGN_DOWN_PTR(p, a) ((void*)FTG_ALIGN_DOWN((uintptr_t)(p), (a)))
#define FTG_ALIGN_UP_PTR(p, a) ((void*)FTG_ALIGN_UP((uintptr_t)(p), (a)))
#ifndef FTG_ARENA_OVERRIDE
# define FTG_ARENA_ALIGNMENT 8
# define FTG_ARENA_BLOCK_SIZE (1024 * 4)
#endif
struct ftg_arena_s {
uint8_t* ptr;
uint8_t* start;
uint8_t* end;
struct ftg_arena_s* prev;
};
typedef struct ftg_arena_s ftg_arena_t;
FTGDEF void *
ftg_malloc(size_t size, size_t num);
FTGDEF void *
ftg_calloc(size_t size, size_t num);
FTGDEF void
ftg_free(void **heap);
FTGDEF int
ftg_stricmp(const char *s1, const char *s2);
FTGDEF void *
ftg_realloc(void *ptr, size_t size, size_t num);
FTGDEF char *
ftg_stristr(const char *haystack, const char *needle);
FTGDEF FTG_EXT_warn_unused_result int
ftg_strncpy(char *ftg_restrict dst, const char *ftg_restrict src, size_t max_copy);
FTGDEF FTG_EXT_warn_unused_result char *
ftg_strcatall(size_t num, ...);
FTGDEF const char*
ftg_strsplit(const char *str, char split_ch, size_t index, size_t *out_len);
FTGDEF void
ftg_bzero(void *ptr, size_t num);
FTGDEF char *
ftg_va(const char *fmt, ...);
FTGDEF uint32_t
ftg_hash_fast(const void *p, uint32_t len);
FTGDEF uint32_t
ftg_hash_number(uint32_t number);
FTGDEF int
ftg__default_assert_reporter(const char *expr, const char *filename, const char *func, unsigned int lineno);
#ifdef FTGT_TESTS_ENABLED
FTGDEF int
ftg__test_assert_reporter(const char *expr, const char *filename, const char *func, unsigned int lineno);
#endif
#ifndef FTG_CORE_NO_STDIO
FTGDEF unsigned char *
ftg_file_read(const char *path, bool make_string, ftg_off_t *len);
FTGDEF bool
ftg_file_write(const char *path, const uint8_t *buf, size_t buf_bytes);
FTGDEF bool
ftg_file_write_string(const char *path, const char *str);
#endif
FTGDEF void
ftg_gethsv(float r, float g, float b, float *ftg_restrict h, float *ftg_restrict s, float *ftg_restrict v);
FTGDEF void
ftg_getrgb(float h, float s, float v, float *ftg_restrict r, float *ftg_restrict g, float *ftg_restrict b);
FTGDEF float
ftg_aspect_correct_scale_for_rect(const float screen[2], const float rect[2]);
FTGDEF size_t
ftg_u8_strlen(const char *s);
struct ftg_index_array_s {
size_t *indices;
size_t count; /* num used */
size_t records; /* alloced, always > count */
};
/* warning: ftg_ia api will be deprecated and moved to a container-specific header file */
FTGDEF bool
ftg_ia_is_init(struct ftg_index_array_s *i);
FTGDEF bool
ftg_ia_append(struct ftg_index_array_s *i, size_t index);
FTGDEF void
ftg_ia_prealloc(struct ftg_index_array_s *i, size_t initial_record_count);
FTGDEF void
ftg_ia_free(struct ftg_index_array_s *i);
FTGDEF const char *
ftg_correct_dirslash(char *path);
FTGDEF char *
ftg_get_filename_ext(const char *path);
FTGDEF char *
ftg_get_filename_from_path(const char *path);
FTGDEF bool
ftg_is_dirslash(char c);
FTGDEF bool
ftg_push_path(char *dst_path, const char *src_path, size_t max_path);
FTGDEF void
ftg_pop_path(char *dst_path);
#ifndef FTG_CORE_NO_STDIO
FTGDEF FILE *
ftg_fopen64(const char *filename, const char *type);
FTGDEF ftg_off_t
ftg_ftell64(FILE *stream);
FTGDEF int64_t
ftg_fseek64(FILE *stream, ftg_off_t offset, int origin);
FTGDEF const char *
ftg_opendir(ftg_dirhandle_t *handle, const char *path, char *out, size_t out_len);
FTGDEF const char *
ftg_readdir(ftg_dirhandle_t *handle, char *out, size_t out_len);
FTGDEF void
ftg_closedir(ftg_dirhandle_t *handle);
FTGDEF bool
ftg_is_dir(const char *path);
FTGDEF bool
ftg_path_exists(const char *path);
FTGDEF bool
ftg_mkdir(const char *path);
FTGDEF void
ftg_mkalldirs(const char *path);
FTGDEF void
ftg_rmalldirs(const char *path);
FTGDEF bool
ftg_rmdir(const char *path);
FTGDEF void
ftg_alloc_console(void);
FTGDEF void
ftg_free_console(void);
#endif
#ifdef FTG_ENABLE_STOPWATCH
FTGDEF void
ftg__stopwatch_start(struct ftg_stopwatch_s *stopwatch,
const char *name, const char *bucket_name, size_t bucket);
FTGDEF void
ftg__stopwatch_stop(struct ftg_stopwatch_s *stopwatch);
FTGDEF void
ftg__stopwatch_next_bucket(struct ftg_stopwatch_s *stopwatch,
const char *bucket_name, size_t bucket);
FTGDEF void
ftg__default_stopwatch_reporter(struct ftg_stopwatch_s *sw);
#endif
FTGDEF ftg_arena_t *
ftg_arena_new(void);
FTGDEF void*
ftg_arena_alloc(ftg_arena_t **arena, size_t size);
FTGDEF void
ftg_arena_free(ftg_arena_t* arena);
#ifdef __cplusplus
}
#endif
/* implementation */
#ifdef FTG_IMPLEMENT_CORE
#ifndef FTG_CORE_NO_STDIO
# include <stdio.h>
# ifdef FTG_POSIX_LIKE
# include <unistd.h>
# include <dirent.h>
# include <sys/stat.h>
# include <sys/types.h>
# include <errno.h>
# elif defined(_WIN32)
# define WIN32_LEAN_AND_MEAN
# include <windows.h> /* for HANDLE in ftg_opendir */
# include <direct.h>
# ifndef INVALID_FILE_ATTRIBUTES
# define INVALID_FILE_ATTRIBUTES ((DWORD)-1) /* missing in older sdks */
# endif
# undef WIN32_LEAN_AND_MEAN
# endif
#endif
#include <ctype.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <math.h>
#include <stddef.h>
/* SIZE_MAX may not be defined in C++ because C++ does not know about this C99 addition. */
#ifndef SIZE_MAX
# if FTG_BITS == 64
# define FTG__SIZE_MAX (18446744073709551615UL)
# else
# define FTG__SIZE_MAX (4294967295U)
# endif
#else
# define FTG__SIZE_MAX SIZE_MAX
#endif
int
ftg__default_assert_reporter(const char *expr, const char *filename, const char *func, unsigned int lineno)
{
((void)filename);
fprintf(stderr, "assert %s(%d)%s: %s\n", filename, lineno, func, expr);
return 1;
}
#ifdef FTGT_TESTS_ENABLED
int
ftg__test_assert_reporter(const char *expr, const char *filename, const char *func, unsigned int lineno)
{
printf("\n[ftg_test intercepted assert] ");
ftg__default_assert_reporter(expr, filename, func, lineno);
ftgt_notify_assert_hit();
return 1;
}
#endif
/* memory */
void *
ftg_malloc(size_t size, size_t num)
{
void *heap = NULL;
FTG_ASSERT(size != 0 && num != 0);
if (size > 0 && num > 0 && FTG__SIZE_MAX/size >= num)
{
size_t alloc_size = size * num;
heap = malloc(alloc_size);
if (!heap)
{
FTG_ASSERT_FAIL("oom");
}
}
else
{
FTG_ASSERT_FAIL("ftg_malloc overflow - no memory allocated");
}
return heap;
}
void
ftg_free(void **heap)
{
FTG_ASSERT(heap && *heap);
free(*heap);
*heap = NULL;
}
void *
ftg_calloc(size_t size, size_t num) {
void *p;
// unfortuanately, the size and num parameters are reversed from
// calloc(), but match ftg_malloc()
FTG_ASSERT(size != 0 && num != 0);
if (size == 0 || num == 0)
return NULL;
p = ftg_malloc(size, num);
if (p) {
ftg_bzero(p, size * num);
}
return p;
}
/* strings */
/* ascii case folded string compare */
int
ftg_stricmp(const char *s1, const char *s2)
{
int result;
const char *p1;
const char *p2;
if ( s1==s2)
return 0;
p1 = s1;
p2 = s2;
result = 0;
if ( p1 == p2 )
return result;
while (!result)
{
result = tolower(*p1) - tolower(*p2);
if ( *p1 == '\0' )
break;
++p1;
++p2;
}
return result;
}
/* Fill up to max_copy characters in dst, including null. Unlike strncpy(), a null
terminating character is guaranteed to be appended, EVEN if it overwrites
the last character in the string.
Only appends a single NULL character instead of NULL filling the string. The
trailing bytes are left uninitialized.
No bytes are written if max_copy is 0, and FTG_ASSERT is thrown.
\return 1 on truncation or max_copy==0, zero otherwise.
*/
FTG_ATTRIBUTES(FTG_EXT_warn_unused_result) int
ftg_strncpy(char *ftg_restrict dst, const char *ftg_restrict src, size_t max_copy)
{
size_t n;
char *d;
FTG_ASSERT(dst);
FTG_ASSERT(src);
FTG_ASSERT(max_copy > 0);
if (max_copy == 0)
return 1;
n = max_copy;
d = dst;
while ( n > 0 && *src != '\0' )
{
*d++ = *src++;
--n;
}
/* Truncation case -
terminate string and return true */
if ( n == 0 )
{
dst[max_copy-1] = '\0';
return 1;
}
/* No truncation. Append a single NULL and return. */
*d = '\0';
return 0;
}
/* case insensitive strstr */
char *
ftg_stristr(const char *haystack, const char *needle)
{
if ( !*needle )
return (char*)(haystack+strlen(haystack));
for ( ; *haystack; ++haystack )
{
if ( tolower( *haystack ) == tolower( *needle ) )
{
const char *h,*n;
for ( h = haystack, n = needle; *h && *n; ++h, ++n )
{
if ( tolower( *h ) != tolower( *n ) )
break;
}
if ( !*n )
return (char*)haystack;
}
}
return NULL;
}
/* append num strings, returning heap-allocated string.
caller must free() returned ptr. */
FTG_ATTRIBUTES(FTG_EXT_warn_unused_result) char *
ftg_strcatall(size_t num, ...)
{
size_t i, alloc_size = 0;
va_list va1, va2;
char *buf, *p_buf;
va_start(va1, num);
for (i = 0; i < num; i++)
{
alloc_size += strlen(va_arg(va1, char*));
}
va_end(va1);
alloc_size += 1;
buf = p_buf = (char*)FTG_MALLOC(sizeof(char), alloc_size);
if (!buf) return NULL;
va_start(va2, num);
for (i = 0; i < num; i++)
{
char *s = va_arg(va2, char*);
while (*s)
{
*p_buf = *s;
p_buf++; s++;
}
}
va_end(va2);
buf[alloc_size-1] = '\0';
return buf;
}
/* split *str on split_chr, returing the split number 'index'.
index 0 = beginning of string, NULL when index exceeds number of splits
len is set to the length of the string or 0 if NULL is returned */
FTGDEF const char*
ftg_strsplit(const char *str, char split_ch, size_t index, size_t *len) {
size_t encounters = 0;
const char *p = str;
const char *end;
if (index == 0) {
goto find_next_split;
}
for (p = str; *p; p++) {
if (*p == split_ch)
encounters++;
if (encounters == index) {
break;
}
}
// hit end of string; requested index does not exist
if (!*p) {
if (len) *len = 0;
return NULL;
}
p++;
find_next_split:
// skip search for next split char if not needed
if (!len)
return p;
for (end = p; *end && *end != split_ch; end++)
;
*len = end-p;
return p;
}
/* avoids memset argument order confusion for most common use case,
guards against 0 num, works on platforms that don't have bzero,
can't be optimized away. */
void
ftg_bzero(void *ptr, size_t num)
{
FTG_ASSERT(num > 0);
FTG_ASSERT(ptr);
#ifdef FTG__HAVE_MEMSET_S
errno_t err = memset_s(ptr, num, 0, num);
FTG_ASSERT(err == 0);
FTG_UNUSED(err);
#elif defined(FTG__HAVE_EXPLICIT_BZERO)
explicit_bzero(ptr, num);
#else
memset(ptr, 0, num);
#endif
}
/* calls realloc with guards -- behaves the same way */
void *
ftg_realloc(void *ptr, size_t size, size_t num)
{
void *alloc_ptr = NULL;
FTG_ASSERT(size != 0 && num != 0);
if (size > 0 && num > 0 && FTG__SIZE_MAX/size >= num)
{
size_t alloc_size = size * num;
alloc_ptr = realloc(ptr, alloc_size);
FTG_ASSERT(alloc_ptr);
}
else
{
FTG_ASSERT_FAIL("ftg_realloc overflow - no memory allocated");
}
/* return result from realloc even if null */
return alloc_ptr;
}
char *
ftg_va(const char *fmt, ...)
{
static char buf[FTG_STRLEN_LONG];
int len;
va_list ap;
va_start(ap, fmt);
#ifdef _WIN32
len = _vsnprintf(buf, FTG_STRLEN_LONG, fmt, ap);
FTG_ASSERT(len != -1);
FTG_UNUSED(len);
#else
len = vsnprintf(buf, FTG_STRLEN_LONG, fmt, ap);
FTG_ASSERT(len < FTG_STRLEN_LONG);
FTG_UNUSED(len);
#endif
va_end(ap);
buf[FTG_STRLEN_LONG-1] = 0;
return buf;
}
/* in-place swapping of slashes to match executing platform's
directory slash order. returns a pointer to *path
*/
const char *ftg_correct_dirslash(char *path)
{
#ifdef _WIN32
char bad_slash = '/';
char good_slash = '\\';
#elif defined(FTG_POSIX_LIKE)
char bad_slash = '\\';
char good_slash = '/';
#endif
char *p = &path[0];
while(*p)
{
if (*p == bad_slash)
*p = good_slash;
p++;
}
return path;
}
/* get extension of the filename, not including the '.' */
FTGDEF char *
ftg_get_filename_ext(const char *path)
{
size_t len = strlen(path);
const char *end = &path[len];
while(len > 0)
{
char c;
len--;
c = path[len];
if (c == FTG_DIRSLASH)
break;
if (c == '.')
return (char*)&path[len+1];
}
return (char*)end; /* return null terminator */
}
/* return the filename part of a path using the current OS's slash char */
FTGDEF char *
ftg_get_filename_from_path(const char *path)
{
const char *p = path + strlen(path)-1;
while (p != path)
{
if (ftg_is_dirslash(*p))
return (char*)p+1;
p--;
}
return (char*)path;
}
/* cross-environment dir slash check */
FTGDEF ftg_inline bool
ftg_is_dirslash(char c)
{
return (c == '/' || c == '\\');
}
/* append a directory to a path, separated by a directory slash ('/' or '\')
return true if truncation occurs */
FTGDEF bool
ftg_push_path(char *dst_path, const char *src_path, size_t max_path)
{
char *dst = dst_path;
const char *src = dst_path;
bool slashing = false;
char c;
#define FTG__CHECK_MAX_PATH \
if ((ptrdiff_t)(dst - dst_path + 1) >= (ptrdiff_t)max_path) return true;
FTG_ASSERT(src_path && dst_path);
// start with a slash if src_path is absolute
if (ftg_is_dirslash(dst_path[0]))
{
FTG__CHECK_MAX_PATH;
dst++;
src++;
slashing = true;
}
while ((c = *src) != '\0')
{
bool is_slash;
FTG__CHECK_MAX_PATH;
is_slash = ftg_is_dirslash(c);
if (!slashing || !is_slash)
*dst++ = c;
slashing = is_slash;
src++;
}
// begin reading from src_path
src = src_path;
// insert a separating slash (or leading slash for an abs path)
if (((dst != dst_path) && !slashing) ||
((dst == dst_path) && (ftg_is_dirslash(src_path[0]))))
{
FTG__CHECK_MAX_PATH;
*dst++ = FTG_DIRSLASH;
slashing = true;
}
while ((c = *src) != '\0')
{
bool is_slash;
FTG__CHECK_MAX_PATH;
is_slash = ftg_is_dirslash(c);
if (!slashing || !is_slash)
*dst++ = c;
slashing = is_slash;
src++;
}
*dst = '\0';
// strip any trailing slash
if (slashing && ((dst - dst_path) > 1))
{
dst--;
*dst = '\0';
}
return false;
#undef FTG__CHECK_MAX_PATH
}
/* in-place truncate dst_path to remove last path component:
filename or directory. */
FTGDEF void
ftg_pop_path(char *dst_path)
{
size_t length = strlen(dst_path);
if (length == 0)
return;
if ((length == 1) && (ftg_is_dirslash(dst_path[0])))
return;
if (ftg_is_dirslash(dst_path[length-1]))
length--;
// don't strip the root / of an abs path
if (ftg_is_dirslash(dst_path[0]))
{
dst_path++;
length--;
}
while(length > 0)
{
char c;
length--;
c = dst_path[length];
if (ftg_is_dirslash(c))
break;
}
dst_path[length] = '\0';
}
/* read a file into a memory buffer. clear the memory with ftg_free.
if make_string is true, a null terminator is attached.
len is the number of bytes returned, including the null terminator if
return is non-NULL, otherwise it is unchanged.
Uses 64-bit file routines internally.
*/
#ifndef FTG_CORE_NO_STDIO
FTGDEF uint8_t *
ftg_file_read(const char *path, bool make_string, ftg_off_t *len)
{
int64_t file_len;
ftg_off_t out_size;
size_t size;
unsigned char *buf;
size_t num_elements;
FILE *fp = ftg_fopen64(path, "rb");
if (!fp)
return NULL;
ftg_fseek64(fp, 0L, SEEK_END);
file_len = ftg_ftell64(fp);
ftg_fseek64(fp, 0L, SEEK_SET);
out_size = make_string ? file_len+1 : file_len;
#ifdef _MSC_VER
# pragma warning(push)
# pragma warning(disable: 4127)
#endif
if (sizeof(int64_t) > sizeof(size_t) && (size_t)file_len > FTG__SIZE_MAX)
{
// fread will truncate if trying to read more than 2GB on a 32-bit OS in one call.
FTG_ASSERT_FAIL("File is larger than a single fread() call and will be truncated.");
file_len = FTG__SIZE_MAX;
}
#ifdef _MSC_VER
# pragma warning(pop)
#endif
/* ftg_off_t is a signed value, size_t is an unsigned value.
rather than work with memory with a signed value, cast
to size_t. */
FTG_ASSERT(out_size >= 0);
size = (size_t)out_size;
buf = (unsigned char*)FTG_MALLOC(sizeof(unsigned char), size);
if (!buf)
return NULL;
num_elements = fread(buf, (size_t)file_len, 1, fp);
if (num_elements != 1)
goto fail;
fclose(fp);
if (make_string)
buf[size-1] = '\0';
if (len)
*len = out_size;
return buf;
fail:
FTG_FREE(buf);
return NULL;
}
/* write *buf bytes into a file. Returns whether all the bytes were written.
buf does not necessarily point to a string. */
FTGDEF bool
ftg_file_write(const char *path, const uint8_t *buf, size_t buf_bytes)
{
size_t write_bytes;
FILE *fp = ftg_fopen64(path, "wb");
if (!fp)
return false;
write_bytes = fwrite(buf, sizeof(uint8_t), buf_bytes, fp);
fclose(fp);
FTG_ASSERT(write_bytes == buf_bytes);
return write_bytes == buf_bytes;
}
/* writes a string to a file, not including the terminator */
FTGDEF bool
ftg_file_write_string(const char *path, const char *str)
{
size_t byte_count = strlen(str);
return ftg_file_write(path, (const uint8_t*)str, byte_count);
}
#endif /* !FTG_CORE_NO_STDIO */
static ftg_inline
float ftg__get_min(float a, float b, float c)
{
float r = a;
if (r > b) r = b;
if (r > c) r = c;
return r;
}
static ftg_inline
float ftg__get_max(float a, float b, float c)
{
float r = a;
if (r < b) r = b;
if (r < c) r = c;
return r;
}
void
ftg_gethsv(float r, float g, float b, float *ftg_restrict h, float *ftg_restrict s, float *ftg_restrict v)
{
float max_chan = ftg__get_max(r,g,b);
float min_chan = ftg__get_min(r,g,b);
float delta;
*v = max_chan;
*s = (max_chan != 0.0f) ? (( max_chan - min_chan) / max_chan ): 0.0f;
if ( *s == 0.0f )
{
*h = FTG_UNDEFINED_HUE; /* undefined */
}
else
{
delta = max_chan - min_chan;
if (r == max_chan)
*h = (g - b) / delta; /* Color between yellow and magenta */
else if ( g == max_chan )
*h = 2.0f + (b-r) / delta; /* Color between cyan and yellow */
else if ( b == max_chan )
*h = 4.0f + (r-g) / delta; /* Color between magenta and cyan */
*h *= 60.0f; /* Convert hue to degrees */
if ( *h < 0.0f )
*h += 360.0f;
}
}
void
ftg_getrgb(float h, float s, float v, float *ftg_restrict r, float *ftg_restrict g, float *ftg_restrict b)
{
FTG_ASSERT( h==FTG_UNDEFINED_HUE || (h >= 0.0f && h <= 360.0f) );
FTG_ASSERT( s >= 0.0f && s <= 1.0f );
FTG_ASSERT( v >= 0.0f && v <= 1.0f );
if ( s == 0.0f )
{
/* Achromatic color */
if ( h == FTG_UNDEFINED_HUE )
{
*r = *g = *b = v;
}
else
{
FTG_ASSERT_FAIL("If s == 0 and hue has value, this is an invalid HSV set");
return;
}
}
else
{
// Chromatic case: s != 0 so there is a hue.
float f,p,q,t;
int i;
if ( h == 360.0f )
h = 0.0f;
h /= 60.0f;
i = (int)h;
f = h - i;
p = v * (1.0f - s);
q = v * (1.0f - (s * f ));
t = v * (1.0f - (s * (1.0f - f )));
switch(i)
{
case 0: *r = v; *g = t; *b = p; break;
case 1: *r = q; *g = v; *b = p; break;
case 2: *r = p; *g = v; *b = t; break;
case 3: *r = p; *g = q; *b = v; break;
case 4: *r = t; *g = p; *b = v; break;
case 5: *r = v; *g = p; *b = q; break;
}
}
}
/* For a rectangle inside a screen, get the scale factor that permits the rectangle
to be scaled without stretching or squashing. */
float
ftg_aspect_correct_scale_for_rect(const float screen[2], const float rect[2])
{
float screenAspect = screen[0] / screen[1];
float rectAspect = rect[0] / rect[1];
float scaleFactor;
if (screenAspect > rectAspect)
scaleFactor = screen[1] / rect[1];
else
scaleFactor = screen[0] / rect[0];
return scaleFactor;
}
FTGDEF size_t
ftg_u8_strlen(const char *s)
{
const char *p = s;
size_t j = 0;
while (*p) {
if ((*p & 0xc0) != 0x80)
j++;
p++;
}
return j;
}
bool
ftg_ia_is_init(struct ftg_index_array_s *i)
{
return (i && i->indices && i->records > 0);
}
void
ftg_ia_prealloc(struct ftg_index_array_s *i, size_t initial_record_count)
{
FTG_ASSERT(initial_record_count > 0);
if (i->records > initial_record_count || initial_record_count == 0)
return;
i->indices = (size_t*)FTG_MALLOC(initial_record_count, sizeof(size_t));
if (!i->indices)
return;
i->records = initial_record_count;
i->count = 0;
}
bool
ftg_ia_append(struct ftg_index_array_s *i, size_t index_value)
{
if (i->count+1 > i->records)
{
size_t new_record_count;
size_t *new_frame_indices;
if (i->count == 0)
new_record_count = FTG_IA_INITIAL_RECORD_COUNT;
else
new_record_count = i->count*2;
new_frame_indices = (size_t*)FTG_REALLOC(i->indices,
sizeof(size_t), new_record_count);
if (!new_frame_indices) {
FTG_ASSERT_FAIL("Could not reallocate index array.");
return false;
}
i->records = new_record_count;
i->indices = new_frame_indices;
}
i->indices[i->count] = index_value;
i->count++;
return true;
}
void
ftg_ia_free(struct ftg_index_array_s *i)
{
if (i->indices)
FTG_FREE(i->indices);
i->records = i->count = 0;
}
/* portable 64-bit UTF-8 file routines */
#ifndef FTG_CORE_NO_STDIO
#ifdef _WIN32
/* these utf8 conversion routines are taken from public domain stb.h
with minor tweaks */
FTGDEF ftg_wchar_t *
ftg_wchar_from_u8(const char *in_str, ftg_wchar_t *out_str, size_t n)
{
unsigned char *str = (unsigned char *)in_str;
uint32_t c;
unsigned int i = 0;
--n;
while (*str) {
if (i >= n)
return NULL;
if (!(*str & 0x80))
out_str[i++] = *str++;
else if ((*str & 0xe0) == 0xc0) {
if (*str < 0xc2) return NULL;
c = (*str++ & 0x1f) << 6;
if ((*str & 0xc0) != 0x80) return NULL;
out_str[i++] = (ftg_wchar_t)(c + (*str++ & 0x3f));
} else if ((*str & 0xf0) == 0xe0) {
if (*str == 0xe0 && (str[1] < 0xa0 || str[1] > 0xbf)) return NULL;
if (*str == 0xed && str[1] > 0x9f) return NULL; // str[1] < 0x80 is checked below
c = (*str++ & 0x0f) << 12;
if ((*str & 0xc0) != 0x80) return NULL;
c += (*str++ & 0x3f) << 6;
if ((*str & 0xc0) != 0x80) return NULL;
out_str[i++] = (ftg_wchar_t)(c + (*str++ & 0x3f));
} else if ((*str & 0xf8) == 0xf0) {
if (*str > 0xf4) return NULL;
if (*str == 0xf0 && (str[1] < 0x90 || str[1] > 0xbf)) return NULL;
if (*str == 0xf4 && str[1] > 0x8f) return NULL; // str[1] < 0x80 is checked below
c = (*str++ & 0x07) << 18;
if ((*str & 0xc0) != 0x80) return NULL;
c += (*str++ & 0x3f) << 12;
if ((*str & 0xc0) != 0x80) return NULL;
c += (*str++ & 0x3f) << 6;
if ((*str & 0xc0) != 0x80) return NULL;
c += (*str++ & 0x3f);
// utf-8 encodings of values used in surrogate pairs are invalid
if ((c & 0xFFFFF800) == 0xD800) return NULL;
if (c >= 0x10000) {
c -= 0x10000;
if ((size_t)i + 2 > n) return NULL;
out_str[i++] = 0xD800 | (0x3ff & (c >> 10));
out_str[i++] = 0xDC00 | (0x3ff & (c ));
}
} else
return NULL;
}
out_str[i] = 0;
return out_str;
}
FTGDEF char *
ftg_wchar_to_u8(const ftg_wchar_t *in_str, char *out_str, size_t n)
{
unsigned int i = 0;
--n;
while (*in_str) {
if (*in_str < 0x80) {
if ((size_t)i+1 > n) return NULL;
out_str[i++] = (char) *in_str++;
} else if (*in_str < 0x800) {
if ((size_t)i+2 > n) return NULL;
out_str[i++] = (char)(0xc0 + (*in_str >> 6));
out_str[i++] = 0x80 + (*in_str & 0x3f);
in_str += 1;
} else if (*in_str >= 0xd800 && *in_str < 0xdc00) {
uint32_t c;
if ((size_t)i+4 > n) return NULL;
c = ((in_str[0] - 0xd800) << 10) + ((in_str[1]) - 0xdc00) + 0x10000;
out_str[i++] = (char)(0xf0 + (c >> 18));
out_str[i++] = 0x80 + ((c >> 12) & 0x3f);
out_str[i++] = 0x80 + ((c >> 6) & 0x3f);
out_str[i++] = 0x80 + ((c ) & 0x3f);
in_str += 2;
} else if (*in_str >= 0xdc00 && *in_str < 0xe000) {
return NULL;
} else {
if ((size_t)i+3 > n) return NULL;
out_str[i++] = 0xe0 + (*in_str >> 12);
out_str[i++] = 0x80 + ((*in_str >> 6) & 0x3f);
out_str[i++] = 0x80 + ((*in_str ) & 0x3f);
in_str += 1;
}
}
out_str[i] = 0;
return out_str;
}
#endif
FILE *
ftg_fopen64(const char *filename, const char *type)
{
#ifdef _WIN32
/* win32 fopen is not utf-8, it's some stupid codepage */
ftg_wchar_t wfilename[FTG_STRLEN_LONG];
ftg_wchar_t wtype[4];
ftg_wchar_from_u8(filename, wfilename, FTG_STRLEN_LONG);
ftg_wchar_from_u8(type, wtype, 4);
return _wfopen(wfilename, wtype);
#else
# if FTG__IO64_EXPLICIT
return fopen64(filename, type);
# else
return fopen(filename, type);
# endif
#endif
}
ftg_off_t
ftg_ftell64(FILE *stream)
{
#ifdef _WIN32
int64_t tell = _ftelli64(stream);
#if FTG_DEBUG
if (tell == -1L)
{
const char *fail_reason = strerror(errno);
FTG_ASSERT_FAIL(fail_reason);
}
#endif
return tell;
#else
# if FTG__IO64_EXPLICIT
off64_t tell = ftello64(stream);
# else
off_t tell = ftello(stream);
# endif
FTG_ASSERT(tell >= 0);
return tell;
#endif
}
int64_t
ftg_fseek64(FILE *stream, ftg_off_t offset, int origin)
{
#ifdef _WIN32
int seek = _fseeki64(stream, offset, origin);
FTG_ASSERT(seek == 0);
return (int64_t)seek;
#else
# if FTG__IO64_EXPLICIT
int seek = fseeko64(stream, offset, origin);
# else
int seek = fseeko(stream, offset, origin);
# endif
FTG_ASSERT(seek != -1);
return (int64_t)seek;
#endif
}
struct ftg_dirhandle_s {
#if defined(_WIN32)
HANDLE d;
# elif defined(FTG_POSIX_LIKE)
DIR *d;
#endif
};
/* see ftg__test_opendir for iteration example
returns *out, the first file in the directory.
*/
FTGDEF const char *
ftg_opendir(ftg_dirhandle_t *handle, const char *path, char *out, size_t out_len)
{
#ifdef FTG_POSIX_LIKE
struct dirent *dirent;
bool trunc;
handle->d = opendir(path);
if (handle->d == NULL)
{
FTG_ASSERT_FAIL("OpenDir failed.");
*out = 0;
return out;
}
dirent = readdir(handle->d);
trunc = ftg_strncpy(out, dirent->d_name, out_len);
if (trunc)
{
FTG_ASSERT_FAIL(ftg_va("Truncation on ftg_opendir for path %s.", path));
/* never return truncated paths */
*out = 0;
return out;
}
return out;
#elif defined(_WIN32)
WIN32_FIND_DATAW fd;
ftg_wchar_t search_path[MAX_PATH+3];
if (ftg_u8_strlen(path) > MAX_PATH + 3)
{
FTG_ASSERT_FAIL("path is too long");
*out = 0;
return out;
}
ftg_wchar_from_u8(path, search_path, MAX_PATH+3);
wcsncat(search_path, L"\\*", 2);
handle->d = FindFirstFileW(search_path, &fd);
if (handle->d == INVALID_HANDLE_VALUE)
{
FTG_ASSERT_FAIL("OpenDir failed.");
*out = 0;
return out;
}
ftg_wchar_to_u8(fd.cFileName, out, out_len);
return out;
#endif
}
FTGDEF const char *
ftg_readdir(ftg_dirhandle_t *handle, char *out, size_t out_len)
{
#ifdef FTG_POSIX_LIKE
struct dirent *dirent;
bool trunc;
dirent = readdir(handle->d);
if (dirent==NULL)
{
*out = 0;
return out;
}
trunc = ftg_strncpy(out, dirent->d_name, out_len);
if (trunc)
{
FTG_ASSERT_FAIL(ftg_va("Truncation on ftg_readdir for path %s.",
dirent->d_name));
*out = 0;
return out;
}
return out;
#elif defined(_WIN32)
WIN32_FIND_DATAW fd;
if (FindNextFileW(handle->d, &fd) != 0)
{
ftg_wchar_to_u8(fd.cFileName, out, out_len);
}
else
{
DWORD error = GetLastError();
if (error == ERROR_NO_MORE_FILES)
{
*out = 0;
return out;
}
else
{
FTG_ASSERT_FAIL(ftg_va("ftg_readdir() error %d", error));
*out = 0;
return out;
}
}
return out;
#endif
}
FTGDEF void
ftg_closedir(ftg_dirhandle_t *handle)
{
#ifdef FTG_POSIX_LIKE
int ret = closedir(handle->d);
FTG_ASSERT(ret != -1);
FTG_UNUSED(ret);
return;
#elif defined(_WIN32)
if (!FindClose(handle->d))
{
FTG_ASSERT_FAIL(ftg_va("ftg_closedir() error: %d", GetLastError()));
}
#endif
}
/* returns true if path exists and is a directory */
FTGDEF bool
ftg_is_dir(const char *path)
{
#ifdef FTG_POSIX_LIKE
struct stat buf;
if (stat(path, &buf) == -1)
return false; /* does not exist */
return (S_ISDIR(buf.st_mode));
#elif defined(_WIN32)
ftg_wchar_t wpath[FTG_STRLEN_LONG];
DWORD attr = GetFileAttributesW(ftg_wchar_from_u8(path, wpath, FTG_STRLEN_LONG));
if (attr == INVALID_FILE_ATTRIBUTES)
return false; /* does not exist */
return ((attr & FILE_ATTRIBUTE_DIRECTORY) == FILE_ATTRIBUTE_DIRECTORY);
#endif
}
/* returns true if the dir or file exists */
FTGDEF bool
ftg_path_exists(const char *path)
{
#ifdef FTG_POSIX_LIKE
return access(path, F_OK) != -1;
#elif defined(_WIN32)
ftg_wchar_t wide_path[MAX_PATH];
DWORD attrib;
ftg_wchar_from_u8(path, wide_path, MAX_PATH);
attrib = GetFileAttributesW(wide_path);
return (attrib != INVALID_FILE_ATTRIBUTES);
#endif
}
/* make a directory that must not already exist */
FTGDEF bool
ftg_mkdir(const char *path)
{
#ifdef FTG_POSIX_LIKE
int result = mkdir(path, FTG_DIRECTORY_MODE);
if (result != 0)
{
FTG_ASSERT_FAIL(strerror(errno));
}
return (result == 0);
#elif defined(_WIN32)
ftg_wchar_t wide_path[MAX_PATH];
int result;
ftg_wchar_from_u8(path, wide_path, MAX_PATH);
result = _wmkdir(wide_path);
if (result != 0)
{
FTG_ASSERT_FAIL(strerror(errno));
}
return (result == 0);
#endif
}
/* recursively make all directories in *path that are not yet created */
FTGDEF void
ftg_mkalldirs(const char *path)
{
if (!ftg_is_dir(path))
{
if(path[0] != '\0')
{
bool trunc;
char parent_path[FTG_STRLEN_LONG] = {'\0'};
trunc = ftg_push_path(parent_path, path, FTG_STRLEN_LONG);
FTG_ASSERT(!trunc);
FTG_UNUSED(trunc);
ftg_pop_path(parent_path);
ftg_mkalldirs(parent_path);
ftg_mkdir(path);
}
}
}
static void
ftg__remove_dir_contents(const char *path)
{
ftg_dirhandle_t dir_handle;
char dir_path[FTG_STRLEN_LONG];
const char *filename;
int i = 5;
filename = ftg_opendir(&dir_handle, path, dir_path, FTG_STRLEN_LONG);
while(*filename)
{
if (strcmp(filename, ".") && strcmp(filename, ".."))
{
char child_path[FTG_STRLEN_LONG] = {'\0'};
ftg_push_path(child_path, path, FTG_STRLEN_LONG);
ftg_push_path(child_path, filename, FTG_STRLEN_LONG);
i--;
if (i == 0)
exit(0);
ftg_rmalldirs(child_path);
}
filename = ftg_readdir(&dir_handle, dir_path, FTG_STRLEN_LONG);
}
ftg_closedir(&dir_handle);
}
/* recursively remove all directories in *path, deleting contents */
FTGDEF void
ftg_rmalldirs(const char *path)
{
if (ftg_is_dir(path))
{
ftg__remove_dir_contents(path);
ftg_rmdir(path);
}
else
{
int result = remove(path);
FTG_ASSERT(result == 0);
FTG_UNUSED(result);
}
}
/* remove a directory that must already exist and be empty */
FTGDEF bool
ftg_rmdir(const char *path)
{
#ifdef FTG_POSIX_LIKE
int result = rmdir(path);
if (result != 0)
{
FTG_ASSERT_FAIL(strerror(errno));
}
return (result == 0);
#elif defined(_WIN32)
ftg_wchar_t wide_path[MAX_PATH];
int result;
ftg_wchar_from_u8(path, wide_path, MAX_PATH);
result = _wrmdir(wide_path);
if (result != 0)
{
FTG_ASSERT_FAIL(strerror(errno));
}
return (result == 0);
#endif
}
/* add a console on windows -- exit silently on others.
note that only one console can exist per process */
#ifdef _WIN32
static FILE *ftg__io[3] = {0,0,0};
#endif
FTGDEF void
ftg_alloc_console(void)
{
#if defined(_WIN32)
int i;
bool result = AllocConsole();
DWORD mode;
HANDLE handle_stdout;
FTG_ASSERT(result); FTG_UNUSED(result);
if (!result)
return;
#if FTG_DEBUG
for (i = 0; i < 3; i++)
FTG_ASSERT(!ftg__io[i]);
#endif
FTG_UNUSED(i);
ftg__io[0] = freopen("conin$","r",stdin);
ftg__io[1] = freopen("conout$","w",stdout);
ftg__io[2] = freopen("conout$","w",stderr);
// enable ansi codes
handle_stdout = GetStdHandle(STD_OUTPUT_HANDLE);
GetConsoleMode(handle_stdout, &mode);
mode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING;
mode |= DISABLE_NEWLINE_AUTO_RETURN;
SetConsoleMode(handle_stdout, mode);
#endif
}
FTGDEF void
ftg_free_console(void)
{
#if defined(_WIN32)
int i;
FreeConsole();
for (i = 0; i < 3; i++)
{
if (!ftg__io[i]) continue;
fclose(ftg__io[i]);
ftg__io[i] = NULL;
}
#endif
}
#endif /* !FTG_CORE_NO_STDIO */
// Paul Hsieh hash (borrowed from stb.h with type changes for
// portability)
#define ftg__get16_slow(p) ((p)[0] + ((p)[1] << 8))
#if defined(_MSC_VER)
#define ftg__get16(p) (*((unsigned short *) (p)))
#else
#define ftg__get16(p) ftg__get16_slow(p)
#endif
FTGDEF uint32_t
ftg_hash_fast(const void *p, uint32_t len)
{
unsigned char *q = (unsigned char *) p;
uint32_t hash = len;
if (len <= 0 || q == NULL) return 0;
/* Main loop */
if (((size_t) q & 1) == 0) {
for (;len > 3; len -= 4) {
uint32_t val;
hash += ftg__get16(q);
val = (ftg__get16(q+2) << 11);
hash = (hash << 16) ^ hash ^ val;
q += 4;
hash += hash >> 11;
}
} else {
for (;len > 3; len -= 4) {
uint32_t val;
hash += ftg__get16_slow(q);
val = (ftg__get16_slow(q+2) << 11);
hash = (hash << 16) ^ hash ^ val;
q += 4;
hash += hash >> 11;
}
}
/* Handle end cases */
switch (len) {
case 3: hash += ftg__get16_slow(q);
hash ^= hash << 16;
hash ^= q[2] << 18;
hash += hash >> 11;
break;
case 2: hash += ftg__get16_slow(q);
hash ^= hash << 11;
hash += hash >> 17;
break;
case 1: hash += q[0];
hash ^= hash << 10;
hash += hash >> 1;
break;
case 0: break;
}
/* Force "avalanching" of final 127 bits */
hash ^= hash << 3;
hash += hash >> 5;
hash ^= hash << 4;
hash += hash >> 17;
hash ^= hash << 25;
hash += hash >> 6;
return hash;
}
FTGDEF uint32_t
ftg_hash_number(uint32_t hash)
{
hash ^= hash << 3;
hash += hash >> 5;
hash ^= hash << 4;
hash += hash >> 17;
hash ^= hash << 25;
hash += hash >> 6;
return hash;
}
/* stopwatch (code timing routines) */
#ifdef FTG_ENABLE_STOPWATCH
#ifdef _WIN32
# define WIN32_LEAN_AND_MEAN
# include <windows.h>
# undef WIN32_LEAN_AND_MEAN
#elif defined(__APPLE__)
# include <mach/mach_time.h>
# define FTG__CLOCK_MACH
#else
# include <time.h>
# define FTG__CLOCK_GETTIME
# ifdef CLOCK_MONOTONIC_RAW
# define FTG__CLOCK_MONOTONIC CLOCK_MONOTONIC_RAW
# else
# define FTG__CLOCK_MONOTONIC CLOCK_MONOTONIC
# endif
#endif
#ifndef FTG_STOPWATCH_REPORTER
# define FTG_STOPWATCH_REPORTER ftg__default_stopwatch_reporter
#endif
#ifdef FTG__CLOCK_GETTIME
static uint64_t ftg__stopwatch_get_usec_since_init(void)
{
static struct timespec ftg__init_time = {0,0};
struct timespec now, since_init;
uint64_t usec;
int ret;
if (ftg__init_time.tv_sec == 0 && ftg__init_time.tv_nsec == 0)
{
ret = clock_gettime(FTG__CLOCK_MONOTONIC, &ftg__init_time);
FTG_ASSERT(ret==0); FTG_UNUSED(ret);
}
ret = clock_gettime(FTG__CLOCK_MONOTONIC, &now);
FTG_ASSERT(ret==0); FTG_UNUSED(ret);
since_init.tv_sec = now.tv_sec - ftg__init_time.tv_sec;
since_init.tv_nsec = now.tv_nsec - ftg__init_time.tv_nsec;
usec = (since_init.tv_sec * 1000000) + (since_init.tv_nsec / 1000);
return usec;
}
#endif
static uint64_t
ftg__stopwatch_elapsed_usec(struct ftg_stopwatch_s *sw)
{
#ifdef _WIN32
LARGE_INTEGER end_time, freq, elapsed;
QueryPerformanceCounter(&end_time);
QueryPerformanceFrequency(&freq);
// calculate elapsed time
elapsed.QuadPart = end_time.QuadPart - sw->start_time;
// convert to microseconds
elapsed.QuadPart *= 1000000;
// divide by ticks per second
elapsed.QuadPart /= freq.QuadPart;
return (uint64_t)elapsed.QuadPart;
#elif defined(FTG__CLOCK_MACH)
static mach_timebase_info_data_t timebase = {0,0};
uint64_t end, elapsed;
if (timebase.denom == 0)
mach_timebase_info(&timebase);
end = mach_absolute_time();
elapsed = end - sw->start_time;
// convert to microseconds before applying timebase
elapsed /= 1000;
elapsed *= timebase.numer / timebase.denom;
return elapsed;
#elif defined(FTG__CLOCK_GETTIME)
return ftg__stopwatch_get_usec_since_init() - sw->start_time;
#endif
}
static void
ftg__stopwatch_set_start_time(struct ftg_stopwatch_s *sw)
{
#ifdef _WIN32
LARGE_INTEGER start_time;
QueryPerformanceCounter(&start_time);
sw->start_time = (int64_t)start_time.QuadPart;
#elif defined(FTG__CLOCK_MACH)
sw->start_time = mach_absolute_time();
#elif defined(FTG__CLOCK_GETTIME)
sw->start_time = ftg__stopwatch_get_usec_since_init();
#endif
}
void
ftg__stopwatch_next_bucket(struct ftg_stopwatch_s *sw, const char *bucket_name, size_t bucket_idx)
{
// if this is hit then FTG_STOPWATCH_START was not called after FTG_STOPWATCH_DECL.
FTG_ASSERT(sw->current_bucket != FTG__MAX_STOPWATCH_TIMES+100);
// it is possible to end up entering a sub-function that is being logged without coming
// from the parent which is logging. This guards against incorrectly logging the time.
if (sw->currently_logging == false)
return;
if (sw->times[bucket_idx] == 0)
{
bool truncate = ftg_strncpy(sw->time_names[bucket_idx], bucket_name, FTG_STRLEN_SHORT);
FTG_UNUSED(truncate);
}
sw->times[sw->current_bucket] += ftg__stopwatch_elapsed_usec(sw);
ftg__stopwatch_set_start_time(sw);
if (bucket_idx >= FTG__MAX_STOPWATCH_TIMES)
{
FTG_ASSERT_FAIL("stopwatch with bucket index > FTG__MAX_STOPWATCH_TIMES specified. not dumped.");
sw->currently_logging = false;
return;
}
sw->current_bucket = bucket_idx;
}
void
ftg__stopwatch_start(struct ftg_stopwatch_s *sw, const char *name, const char *bucket_name, size_t bucket_idx)
{
bool truncate = ftg_strncpy(sw->name, name, FTG_STRLEN_SHORT);
FTG_UNUSED(truncate);
sw->currently_logging = true;
ftg_bzero(sw->times, sizeof(sw->times));
ftg_bzero(sw->time_names, sizeof(sw->time_names));
// todo: compress this
if (bucket_idx >= FTG__MAX_STOPWATCH_TIMES)
{
FTG_ASSERT_FAIL("stopwatch with bucket index > FTG__MAX_STOPWATCH_TIMES specified. not dumped.");
return;
}
sw->current_bucket = bucket_idx;
truncate = ftg_strncpy(sw->time_names[bucket_idx], bucket_name, FTG_STRLEN_SHORT);
FTG_UNUSED(truncate);
// start counter at the end of this function to avoid profiling setup work.
ftg__stopwatch_set_start_time(sw);
}
void
ftg__stopwatch_stop(struct ftg_stopwatch_s *sw)
{
// if this is hit then FTG_STOPWATCH_START was not called after FTG_STOPWATCH_DECL.
FTG_ASSERT(sw->current_bucket != FTG__MAX_STOPWATCH_TIMES+100);
sw->times[sw->current_bucket] += ftg__stopwatch_elapsed_usec(sw);
sw->currently_logging = false;
FTG_STOPWATCH_REPORTER(sw);
}
void
ftg__default_stopwatch_reporter(struct ftg_stopwatch_s *sw)
{
size_t i;
uint64_t accum_ms = 0;
#if FTG_DEBUG
const char debug_str[] = "FTG_DEBUG=1 ";
#else
const char debug_str[] = "";
#endif
printf("%sstopwatch %s completed:\n", debug_str, sw->name);
for (i = 0; i < FTG__MAX_STOPWATCH_TIMES; ++i)
{
if (sw->times[i] == 0 && sw->time_names[i][0] == '\0')
continue;
accum_ms += sw->times[i] / 1000;
printf("\t%s[%" FTG_SPEC_SIZE_T "]: %" FTG_SPEC_UINT64 " usec\n",
sw->time_names[i], i, sw->times[i]);
}
printf("total ms: %" FTG_SPEC_UINT64 "\n", accum_ms);
}
#endif /* FTG_ENABLE_STOPWATCH */
static void
ftg__arena_grow(ftg_arena_t** arena, size_t min_size)
{
size_t size;
ftg_arena_t* a = *arena;
if (a->ptr != NULL) {
ftg_arena_t* new_block = (ftg_arena_t*)FTG_MALLOC(sizeof(ftg_arena_t), 1);
new_block->prev = a;
a = *arena = new_block;
}
size = FTG_ALIGN_UP(FTG_MAX(FTG_ARENA_BLOCK_SIZE, min_size), FTG_ARENA_ALIGNMENT);
a->ptr = a->start = FTG_MALLOC(size, 1);
a->end = a->ptr + size;
}
// alloc memory from arena. returns null if an alloc failed.
// arena pointer is altered if a new page is created
// zero thread safety
void*
ftg_arena_alloc(ftg_arena_t** arena, size_t size)
{
void* ptr;
if (size > (size_t)((*arena)->end - (*arena)->ptr)) {
ftg__arena_grow(arena, size);
FTG_ASSERT(size <= (size_t)((*arena)->end - (*arena)->ptr));
if (!(*arena)->ptr)
return NULL;
}
ptr = (*arena)->ptr;
(*arena)->ptr = FTG_ALIGN_UP_PTR((*arena)->ptr + size, FTG_ARENA_ALIGNMENT);
FTG_ASSERT((*arena)->ptr <= (*arena)->end);
FTG_ASSERT(ptr == FTG_ALIGN_DOWN_PTR(ptr, FTG_ARENA_ALIGNMENT));
return ptr;
}
ftg_arena_t*
ftg_arena_new(void)
{
ftg_arena_t* arena = FTG_MALLOC(sizeof(ftg_arena_t), 1);
ftg_bzero(arena, sizeof(ftg_arena_t));
return arena;
}
void
ftg_arena_free(ftg_arena_t* arena)
{
ftg_arena_t *prev;
while (arena) {
if (arena->start) {
FTG_FREE(arena->start);
}
prev = arena->prev;
FTG_FREE(arena);
arena = prev;
}
}
/* test suite
ftg_decl_suite() should be called somewhere in the declaring
C file.
*/
#ifdef FTGT_TESTS_ENABLED
#include<string.h>
struct ftg_testvars_s {
char *s1, *s2, *s3;
};
static struct ftg_testvars_s tv;
static int ftg__test_setup(void) {
tv.s1 = (char*)FTG_MALLOC(sizeof(char*), FTG_STRLEN);
tv.s2 = (char*)FTG_MALLOC(sizeof(char*), FTG_STRLEN);
tv.s3 = (char*)FTG_MALLOC(sizeof(char*), FTG_STRLEN);
strcpy(tv.s1, "catdoghamster");
strcpy(tv.s2, "CATDOGhamster");
strcpy(tv.s3, "fooballs");
return (tv.s1&&tv.s2&&tv.s3)?0:1;
}
static int ftg__test_teardown(void) {
FTG_FREE(tv.s1);
FTG_FREE(tv.s2);
FTG_FREE(tv.s3);
return 0;
}
static int ftg__test_stricmp(void)
{
FTGT_ASSERT(ftg_stricmp(tv.s1,tv.s2)==0);
FTGT_ASSERT(ftg_stricmp(tv.s1,tv.s2)==0);
FTGT_ASSERT(ftg_stricmp(tv.s1,tv.s2)==0);
FTGT_ASSERT(ftg_stricmp(tv.s1,tv.s3)!=0);
FTGT_ASSERT(ftg_stricmp(tv.s1,tv.s1)==0);
return ftgt_test_errorlevel();
}
static int ftg__test_stristr(void)
{
FTGT_ASSERT(ftg_stristr(tv.s1, "dog") == tv.s1+3);
FTGT_ASSERT(ftg_stristr(tv.s1, "DOG") == tv.s1+3);
FTGT_ASSERT(ftg_stristr(tv.s1, tv.s1) == tv.s1);
FTGT_ASSERT(ftg_stristr(tv.s1, "\0") == tv.s1+strlen(tv.s1));
return ftgt_test_errorlevel();
}
static int ftg__test_strncpy(void)
{
int trunc = 0;
char buf[FTG_STRLEN];
trunc = ftg_strncpy(buf, tv.s1, FTG_STRLEN);
FTGT_ASSERT(strlen(buf)==strlen(tv.s1));
FTGT_ASSERT(!trunc);
trunc = ftg_strncpy(buf, tv.s1, 0);
FTGT_ASSERT(ftgt_test_errorlevel());
trunc = ftg_strncpy(buf, tv.s1, 7);
FTGT_ASSERT(strcmp(buf, "catdog")==0);
FTGT_ASSERT(trunc);
return ftgt_test_errorlevel();
}
static int ftg__test_strcatall(void)
{
char *str = ftg_strcatall(3, "one", "two", "three");
FTGT_ASSERT(strcmp(str, "onetwothree")==0);
FTG_FREE(str);
str = ftg_strcatall(0);
FTGT_ASSERT(str[0] == '\0');
FTG_FREE(str);
return ftgt_test_errorlevel();
}
static int ftg__test_va(void)
{
char *buf = ftg_va("hello");
FTGT_ASSERT(strcmp(buf, "hello")==0);
buf = ftg_va("%d %d", 2, 3);
FTGT_ASSERT(strcmp(buf, "2 3")==0);
buf = ftg_va("%d", (int)1048576);
FTGT_ASSERT(strcmp(buf, "1048576")==0);
return ftgt_test_errorlevel();
}
static int ftg__test_correct_dirslash(void)
{
char dir[255];
strcpy(dir, "/dir/a");
ftg_correct_dirslash(dir);
FTGT_ASSERT(dir[0] == FTG_DIRSLASH);
FTGT_ASSERT(dir[4] == FTG_DIRSLASH);
strcpy(dir, "\\dir\\a");
ftg_correct_dirslash(dir);
FTGT_ASSERT(dir[0] == FTG_DIRSLASH);
FTGT_ASSERT(dir[4] == FTG_DIRSLASH);
return ftgt_test_errorlevel();
}
static int ftg__test_opendir(void)
{
#ifndef FTG_CORE_NO_STDIO
ftg_dirhandle_t dir;
char path_str[FTG_STRLEN_LONG];
int dot_count = 0;
ftg_opendir(&dir, ".", path_str, FTG_STRLEN_LONG);
while (*path_str)
{
if (strcmp(path_str, ".")==0)
dot_count++;
if (strcmp(path_str, "..")==0)
dot_count++;
/* finished with path_str, get the next one */
ftg_readdir(&dir, path_str, FTG_STRLEN_LONG);
}
ftg_closedir(&dir);
FTGT_ASSERT(dot_count==2);
#endif
return ftgt_test_errorlevel();
}
static int ftg__test_is_dir(void)
{
#ifndef FTG_CORE_NO_STDIO
#ifdef FTG_POSIX_LIKE
FTGT_ASSERT(ftg_is_dir("/"));
#elif _WIN32
FTGT_ASSERT(ftg_is_dir("c:\\"));
#endif
FTGT_ASSERT(!ftg_is_dir("this does not exist"));
FTGT_ASSERT(ftg_is_dirslash('/'));
FTGT_ASSERT(ftg_is_dirslash('\\'));
FTGT_ASSERT(!ftg_is_dirslash(' '));
#endif
return ftgt_test_errorlevel();
}
static int ftg__test_get_filename_ext(void)
{
char *ext;
char str[1024];
/* regular */
ext = ftg_get_filename_ext("hello.txt");
FTGT_ASSERT(strcmp(ext, "txt") == 0);
/* multiple extensions */
ext = ftg_get_filename_ext("hello.wat.txt");
FTGT_ASSERT(strcmp(ext, "txt") == 0);
/* dot in directory part of path */
strcpy(str, "/some.ext/hello.txt");
ftg_correct_dirslash(str);
ext = ftg_get_filename_ext(str);
FTGT_ASSERT(strcmp(ext, "txt") == 0);
strcpy(str, "/some.ext/hello");
ftg_correct_dirslash(str);
ext = ftg_get_filename_ext(str);
FTGT_ASSERT(ext[0] == '\0');
strcpy(str, "/some.ext/");
ftg_correct_dirslash(str);
ext = ftg_get_filename_ext(str);
FTGT_ASSERT(ext[0] == '\0');
/* no extension */
ext = ftg_get_filename_ext("hello");
FTGT_ASSERT(ext[0] == '\0');
/* empty */
ext = ftg_get_filename_ext("");
FTGT_ASSERT(ext[0] == '\0');
return ftgt_test_errorlevel();
}
static int ftg__test_get_filename_from_path(void)
{
int i;
const char *tests[][2] =
{
{"bar.txt", "bar.txt"},
{"foo/bar.txt", "bar.txt"},
{"/a/b/", ""},
{NULL, NULL}
};
for (i = 0; tests[i][0] != NULL; i++)
{
const char *q = tests[i][0];
const char *a = tests[i][1];
char q_buf[FTG_STRLEN];
bool trunc;
trunc = ftg_strncpy(q_buf, q, FTG_STRLEN);
FTG_ASSERT(!trunc);
ftg_correct_dirslash(q_buf);
FTGT_ASSERT(strcmp(ftg_get_filename_from_path(q_buf), a)==0);
}
return ftgt_test_errorlevel();
}
static int ftg__test_file_rw(void)
{
#ifndef FTG_CORE_NO_STDIO
const char tmp_file[] = "ftg_core_tmp_file.txt";
const char test_str[] = "hello\nworld!";
unsigned char *read_str;
ftg_off_t read_len;
bool result;
result = ftg_file_write(tmp_file, (uint8_t*)test_str, strlen(test_str)+1);
FTGT_ASSERT(result);
read_str = ftg_file_read(tmp_file, true, &read_len);
FTGT_ASSERT(memcmp(read_str, test_str, strlen(test_str)+1)==0);
FTG_FREE(read_str);
// todo: rm temp file
#endif
return ftgt_test_errorlevel();
}
static int ftg__test_ia(void)
{
struct ftg_index_array_s ia = FTG_IA_INIT_ZERO;
size_t i;
FTGT_ASSERT(!ftg_ia_is_init(&ia));
for (i = 0; i < FTG_IA_INITIAL_RECORD_COUNT * 2; ++i)
{
bool success = ftg_ia_append(&ia, i*2);
FTGT_ASSERT(success);
}
FTGT_ASSERT(ia.records > FTG_IA_INITIAL_RECORD_COUNT);
for (i = 0; i < ia.count; i++)
{
FTGT_ASSERT(ia.indices[i] == i*2);
}
ftg_ia_free(&ia);
return ftgt_test_errorlevel();
}
static int ftg__test_dircreate(void)
{
#ifndef FTG_CORE_NO_STDIO
bool success;
if (ftg_is_dir("testdir"))
{
printf("removing testdir which shouldn't exist");
success = ftg_rmdir("testdir");
FTG_ASSERT(success);
}
success = ftg_mkdir("testdir");
FTGT_ASSERT(success);
FTGT_ASSERT(ftg_is_dir("testdir"));
// this assumes FTG_DIRECTORY_MODE allows for the deletion
// of the created directory.
success = ftg_rmdir("testdir");
FTGT_ASSERT(success);
FTGT_ASSERT(!ftg_is_dir("testdir"));
ftg_mkalldirs("one/two/three");
FTGT_ASSERT(ftg_is_dir("one/two/three"));
ftg_rmalldirs("one");
FTGT_ASSERT(!ftg_is_dir("one"));
#endif
return ftgt_test_errorlevel();
}
static int ftg__test_push_path(void)
{
char buffer[64];
bool trunc;
int i;
// [0] + [1] must equal [2] to pass the test
const char * tests[][3] =
{
{ "/a", "b", "/a/b" },
{ "/a", "/b", "/a/b" },
{ "/a", "b/", "/a/b" },
{ "/a", "/b/", "/a/b" },
{ "/a/", "b", "/a/b" },
{ "/a/", "/b", "/a/b" },
{ "/a/", "b/", "/a/b" },
{ "/a/", "/b/", "/a/b" },
{ "a", "b", "a/b" },
{ "a", "/b", "a/b" },
{ "a", "b/", "a/b" },
{ "a", "/b/", "a/b" },
{ "a/", "b", "a/b" },
{ "a/", "/b", "a/b" },
{ "a/", "b/", "a/b" },
{ "a/", "/b/", "a/b" },
{ "", "b", "b" },
{ "", "/b", "/b" },
{ "", "b/", "b" },
{ "", "/b/", "/b" },
{ "/", "b", "/b" },
{ "/", "/b", "/b" },
{ "/", "b/", "/b" },
{ "/", "/b/", "/b" },
{ "a", "", "a" },
{ "a/", "", "a" },
{ "/a", "", "/a" },
{ "/a/", "", "/a" },
{ "a", "/", "a" },
{ "a/", "/", "a" },
{ "/a", "/", "/a" },
{ "/a/", "/", "/a" },
{ "", "", "" },
{ "/", "", "/" },
{ "", "/", "/" },
{ "/", "/", "/" },
{ "//a", "", "/a" },
{ "a//", "", "a" },
{ "", "//b", "/b" },
{ "", "b//", "b" },
{ "//a//", "//b//","/a/b" },
{ NULL, NULL, NULL }
};
for(i = 0; tests[i][0] != NULL; i++)
{
const char *a = tests[i][0];
const char *b = tests[i][1];
const char *c = tests[i][2];
char c_buf[64];
trunc = ftg_strncpy(buffer, a, 8);
FTG_ASSERT(!trunc);
ftg_push_path(buffer, b, 8);
ftg_correct_dirslash(buffer);
trunc = ftg_strncpy(c_buf, c, 64);
FTG_ASSERT(!trunc);
ftg_correct_dirslash(c_buf);
FTGT_ASSERT(strcmp(buffer, c_buf) == 0);
}
// test truncation cases
trunc = ftg_strncpy(buffer, "aaaaaaa", 8);
FTG_ASSERT(!trunc);
trunc = ftg_push_path(buffer, "a", 8);
FTGT_ASSERT(trunc);
FTGT_ASSERT(strcmp(buffer, "aaaaaaa") == 0);
trunc = ftg_strncpy(buffer, "aaaaaa", 8);
FTG_ASSERT(!trunc);
trunc = ftg_push_path(buffer, "a", 8);
ftg_correct_dirslash(buffer);
FTGT_ASSERT(trunc);
FTGT_ASSERT(strcmp(buffer, ftg_va("aaaaaa%c", FTG_DIRSLASH))==0);
trunc = ftg_strncpy(buffer, "aaaaaa/", 8);
FTG_ASSERT(!trunc);
trunc = ftg_push_path(buffer, "a", 8);
ftg_correct_dirslash(buffer);
FTGT_ASSERT(trunc);
FTGT_ASSERT(strcmp(buffer, ftg_va("aaaaaa%c", FTG_DIRSLASH))==0);
trunc = ftg_strncpy(buffer, "a/", 8);
FTG_ASSERT(!trunc);
trunc = ftg_push_path(buffer, "aaaaaa", 8);
ftg_correct_dirslash(buffer);
FTGT_ASSERT(trunc);
FTGT_ASSERT(strcmp(buffer, ftg_va("a%caaaaa", FTG_DIRSLASH))==0);
return ftgt_test_errorlevel();
}
static int ftg__test_pop_path(void)
{
const char * paths[][2] =
{
{ "/dir/file.ext", "/dir" },
{ "/dir/file", "/dir" },
{ "/dir/", "/" },
{ "/dir", "/" },
{ "/", "/" },
{ "dir", "" },
{ "", "" },
{ NULL, NULL }
};
int i;
for (i = 0; paths[i][0] != NULL; i++)
{
const char *a = paths[i][0];
const char *b = paths[i][1];
char path[FTG_STRLEN];
bool trunc;
trunc = ftg_strncpy(path, a, FTG_STRLEN);
FTG_ASSERT(!trunc);
ftg_pop_path(path);
FTGT_ASSERT(strcmp(path, b) == 0);
}
return ftgt_test_errorlevel();
}
static int ftg__test_strsplit(void)
{
const char *p;
size_t i;
size_t len;
const char PATH[] = "ab:cd:ef";
const char WILL_REACH_END[] = "abc";
const char EMPTY[] = "";
FTGT_ASSERT(ftg_strsplit(PATH, ':', 0, &len) == &PATH[0] && len == 2);
FTGT_ASSERT(ftg_strsplit(PATH, ':', 1, &len) == &PATH[3] && len == 2);
FTGT_ASSERT(ftg_strsplit(PATH, ':', 2, &len) == &PATH[6] && len == 2);
FTGT_ASSERT(ftg_strsplit(PATH, ':', 3, &len) == NULL && len == 0);
FTGT_ASSERT(ftg_strsplit(WILL_REACH_END, ':', 1, &len) == NULL && len == 0);
FTGT_ASSERT(ftg_strsplit(EMPTY, ':', 0, &len) == &EMPTY[0] && len == 0);
FTGT_ASSERT(ftg_strsplit(EMPTY, ':', 1, &len) == NULL && len == 0);
// iteration usage example
for (p = PATH, i = 0; (p = ftg_strsplit(PATH, ':', i, &len)) != NULL; i++) {
switch(i) {
case 0:
FTGT_ASSERT(p == &PATH[0] && len == 2);
break;
case 1:
FTGT_ASSERT(p == &PATH[3] && len == 2);
break;
case 2:
FTGT_ASSERT(p == &PATH[6] && len == 2);
break;
default:
FTGT_ASSERT(0);
}
}
return ftgt_test_errorlevel();
}
static int ftg__test_arena(void)
{
ftg_arena_t* arena = ftg_arena_new();
void* ptr[5];
size_t i;
ptr[0] = ftg_arena_alloc(&arena, 1);
ptr[1] = ftg_arena_alloc(&arena, 1);
ptr[2] = ftg_arena_alloc(&arena, 1);
ptr[3] = ftg_arena_alloc(&arena, FTG_ARENA_BLOCK_SIZE + 1);
ptr[4] = ftg_arena_alloc(&arena, 1);
for (i = 1; i < 5; i++) {
FTGT_ASSERT(ptr[i-1] < ptr[i]);
}
ftg_arena_free(arena);
return ftgt_test_errorlevel();
}
FTGDEF
void ftg_decl_suite(void)
{
ftgt_suite_s *suite = ftgt_create_suite(NULL, "ftg_core", ftg__test_setup, ftg__test_teardown);
FTGT_ADD_TEST(suite, ftg__test_stricmp);
FTGT_ADD_TEST(suite, ftg__test_stristr);
FTGT_ADD_TEST(suite, ftg__test_strncpy);
FTGT_ADD_TEST(suite, ftg__test_strcatall);
FTGT_ADD_TEST(suite, ftg__test_va);
FTGT_ADD_TEST(suite, ftg__test_correct_dirslash);
FTGT_ADD_TEST(suite, ftg__test_opendir);
FTGT_ADD_TEST(suite, ftg__test_is_dir);
FTGT_ADD_TEST(suite, ftg__test_get_filename_ext);
FTGT_ADD_TEST(suite, ftg__test_get_filename_from_path);
FTGT_ADD_TEST(suite, ftg__test_file_rw);
FTGT_ADD_TEST(suite, ftg__test_ia);
FTGT_ADD_TEST(suite, ftg__test_dircreate);
FTGT_ADD_TEST(suite, ftg__test_push_path);
FTGT_ADD_TEST(suite, ftg__test_pop_path);
FTGT_ADD_TEST(suite, ftg__test_strsplit);
FTGT_ADD_TEST(suite, ftg__test_arena);
}
#ifdef FTG_JUST_TEST
int main(void)
{
ftg_decl_suite();
return ftgt_run_all_tests(NULL);
}
#endif /* FTG_JUST_TEST */
#endif /* FTGT_TESTS_ENABLED */
#endif /* FTG_IMPLEMENT_CORE */
#endif /* eof */
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment