test/awtk
1
0
Fork 0
mirror of https://gitee.com/zlgopen/awtk.git synced 2024-12-02 12:08:16 +08:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity
2cb3d3888a
awtk/3rd/stb/stb.h
jim a68c7d049f init
2018-02-21 19:36:38 +08:00

14329 lines
448 KiB
C
Raw Blame History

/* stb.h - v2.30 - Sean's Tool Box -- public domain -- http://nothings.org/stb.h
no warranty is offered or implied; use this code at your own risk
This is a single header file with a bunch of useful utilities
for getting stuff done in C/C++.
Documentation: http://nothings.org/stb/stb_h.html
Unit tests: http://nothings.org/stb/stb.c
============================================================================
You MUST
#define STB_DEFINE
in EXACTLY _one_ C or C++ file that includes this header, BEFORE the
include, like this:
#define STB_DEFINE
#include "stb.h"
All other files should just #include "stb.h" without the #define.
============================================================================
Version History
2.30 MinGW fix
2.29 attempt to fix use of swprintf()
2.28 various new functionality
2.27 test _WIN32 not WIN32 in STB_THREADS
2.26 various warning & bugfixes
2.25 various warning & bugfixes
2.24 various warning & bugfixes
2.23 fix 2.22
2.22 64-bit fixes from '!='; fix stb_sdict_copy() to have preferred name
2.21 utf-8 decoder rejects "overlong" encodings; attempted 64-bit improvements
2.20 fix to hash "copy" function--reported by someone with handle "!="
2.19 ???
2.18 stb_readdir_subdirs_mask
2.17 stb_cfg_dir
2.16 fix stb_bgio_, add stb_bgio_stat(); begin a streaming wrapper
2.15 upgraded hash table template to allow:
- aggregate keys (explicit comparison func for EMPTY and DEL keys)
- "static" implementations (so they can be culled if unused)
2.14 stb_mprintf
2.13 reduce identifiable strings in STB_NO_STB_STRINGS
2.12 fix STB_ONLY -- lots of uint32s, TRUE/FALSE things had crept in
2.11 fix bug in stb_dirtree_get() which caused "c://path" sorts of stuff
2.10 STB_F(), STB_I() inline constants (also KI,KU,KF,KD)
2.09 stb_box_face_vertex_axis_side
2.08 bugfix stb_trimwhite()
2.07 colored printing in windows (why are we in 1985?)
2.06 comparison functions are now functions-that-return-functions and
accept a struct-offset as a parameter (not thread-safe)
2.05 compile and pass tests under Linux (but no threads); thread cleanup
2.04 stb_cubic_bezier_1d, smoothstep, avoid dependency on registry
2.03 ?
2.02 remove integrated documentation
2.01 integrate various fixes; stb_force_uniprocessor
2.00 revised stb_dupe to use multiple hashes
1.99 stb_charcmp
1.98 stb_arr_deleten, stb_arr_insertn
1.97 fix stb_newell_normal()
1.96 stb_hash_number()
1.95 hack stb__rec_max; clean up recursion code to use new functions
1.94 stb_dirtree; rename stb_extra to stb_ptrmap
1.93 stb_sem_new() API cleanup (no blockflag-starts blocked; use 'extra')
1.92 stb_threadqueue--multi reader/writer queue, fixed size or resizeable
1.91 stb_bgio_* for reading disk asynchronously
1.90 stb_mutex uses CRITICAL_REGION; new stb_sync primitive for thread
joining; workqueue supports stb_sync instead of stb_semaphore
1.89 support ';' in constant-string wildcards; stb_mutex wrapper (can
implement with EnterCriticalRegion eventually)
1.88 portable threading API (only for win32 so far); worker thread queue
1.87 fix wildcard handling in stb_readdir_recursive
1.86 support ';' in wildcards
1.85 make stb_regex work with non-constant strings;
beginnings of stb_introspect()
1.84 (forgot to make notes)
1.83 whoops, stb_keep_if_different wasn't deleting the temp file
1.82 bring back stb_compress from stb_file.h for cmirror
1.81 various bugfixes, STB_FASTMALLOC_INIT inits FASTMALLOC in release
1.80 stb_readdir returns utf8; write own utf8-utf16 because lib was wrong
1.79 stb_write
1.78 calloc() support for malloc wrapper, STB_FASTMALLOC
1.77 STB_FASTMALLOC
1.76 STB_STUA - Lua-like language; (stb_image, stb_csample, stb_bilinear)
1.75 alloc/free array of blocks; stb_hheap bug; a few stb_ps_ funcs;
hash*getkey, hash*copy; stb_bitset; stb_strnicmp; bugfix stb_bst
1.74 stb_replaceinplace; use stdlib C function to convert utf8 to UTF-16
1.73 fix performance bug & leak in stb_ischar (C++ port lost a 'static')
1.72 remove stb_block, stb_block_manager, stb_decompress (to stb_file.h)
1.71 stb_trimwhite, stb_tokens_nested, etc.
1.70 back out 1.69 because it might problemize mixed builds; stb_filec()
1.69 (stb_file returns 'char *' in C++)
1.68 add a special 'tree root' data type for stb_bst; stb_arr_end
1.67 full C++ port. (stb_block_manager)
1.66 stb_newell_normal
1.65 stb_lex_item_wild -- allow wildcard items which MUST match entirely
1.64 stb_data
1.63 stb_log_name
1.62 stb_define_sort; C++ cleanup
1.61 stb_hash_fast -- Paul Hsieh's hash function (beats Bob Jenkins'?)
1.60 stb_delete_directory_recursive
1.59 stb_readdir_recursive
1.58 stb_bst variant with parent pointer for O(1) iteration, not O(log N)
1.57 replace LCG random with Mersenne Twister (found a public domain one)
1.56 stb_perfect_hash, stb_ischar, stb_regex
1.55 new stb_bst API allows multiple BSTs per node (e.g. secondary keys)
1.54 bugfix: stb_define_hash, stb_wildmatch, regexp
1.53 stb_define_hash; recoded stb_extra, stb_sdict use it
1.52 stb_rand_define, stb_bst, stb_reverse
1.51 fix 'stb_arr_setlen(NULL, 0)'
1.50 stb_wordwrap
1.49 minor improvements to enable the scripting language
1.48 better approach for stb_arr using stb_malloc; more invasive, clearer
1.47 stb_lex (lexes stb.h at 1.5ML/s on 3Ghz P4; 60/70% of optimal/flex)
1.46 stb_wrapper_*, STB_MALLOC_WRAPPER
1.45 lightly tested DFA acceleration of regexp searching
1.44 wildcard matching & searching; regexp matching & searching
1.43 stb_temp
1.42 allow stb_arr to use stb_malloc/realloc; note this is global
1.41 make it compile in C++; (disable stb_arr in C++)
1.40 stb_dupe tweak; stb_swap; stb_substr
1.39 stb_dupe; improve stb_file_max to be less stupid
1.38 stb_sha1_file: generate sha1 for file, even > 4GB
1.37 stb_file_max; partial support for utf8 filenames in Windows
1.36 remove STB__NO_PREFIX - poor interaction with IDE, not worth it
streamline stb_arr to make it separately publishable
1.35 bugfixes for stb_sdict, stb_malloc(0), stristr
1.34 (streaming interfaces for stb_compress)
1.33 stb_alloc; bug in stb_getopt; remove stb_overflow
1.32 (stb_compress returns, smaller&faster; encode window & 64-bit len)
1.31 stb_prefix_count
1.30 (STB__NO_PREFIX - remove stb_ prefixes for personal projects)
1.29 stb_fput_varlen64, etc.
1.28 stb_sha1
1.27 ?
1.26 stb_extra
1.25 ?
1.24 stb_copyfile
1.23 stb_readdir
1.22 ?
1.21 ?
1.20 ?
1.19 ?
1.18 ?
1.17 ?
1.16 ?
1.15 stb_fixpath, stb_splitpath, stb_strchr2
1.14 stb_arr
1.13 ?stb, stb_log, stb_fatal
1.12 ?stb_hash2
1.11 miniML
1.10 stb_crc32, stb_adler32
1.09 stb_sdict
1.08 stb_bitreverse, stb_ispow2, stb_big32
stb_fopen, stb_fput_varlen, stb_fput_ranged
stb_fcmp, stb_feq
1.07 (stb_encompress)
1.06 stb_compress
1.05 stb_tokens, (stb_hheap)
1.04 stb_rand
1.03 ?(s-strings)
1.02 ?stb_filelen, stb_tokens
1.01 stb_tolower
1.00 stb_hash, stb_intcmp
stb_file, stb_stringfile, stb_fgets
stb_prefix, stb_strlower, stb_strtok
stb_image
(stb_array), (stb_arena)
Parenthesized items have since been removed.
LICENSE
See end of file for license information.
CREDITS
Written by Sean Barrett.
Fixes:
Philipp Wiesemann
Robert Nix
r-lyeh
blackpawn
github:Mojofreem
Ryan Whitworth
Vincent Isambart
Mike Sartain
Eugene Opalev
Tim Sjostrand
github:infatum
*/
#include <stdarg.h>
#ifndef STB__INCLUDE_STB_H
#define STB__INCLUDE_STB_H
#define STB_VERSION 1
#ifdef STB_INTROSPECT
#define STB_DEFINE
#endif
#ifdef STB_DEFINE_THREADS
#ifndef STB_DEFINE
#define STB_DEFINE
#endif
#ifndef STB_THREADS
#define STB_THREADS
#endif
#endif
#if defined(_WIN32) && !defined(__MINGW32__)
#ifndef _CRT_SECURE_NO_WARNINGS
#define _CRT_SECURE_NO_WARNINGS
#endif
#ifndef _CRT_NONSTDC_NO_DEPRECATE
#define _CRT_NONSTDC_NO_DEPRECATE
#endif
#ifndef _CRT_NON_CONFORMING_SWPRINTFS
#define _CRT_NON_CONFORMING_SWPRINTFS
#endif
#if !defined(_MSC_VER) || _MSC_VER > 1700
#include <intrin.h> // _BitScanReverse
#endif
#endif
#include <stdlib.h> // stdlib could have min/max
#include <stdio.h> // need FILE
#include <string.h> // stb_define_hash needs memcpy/memset
#include <time.h> // stb_dirtree
#ifdef __MINGW32__
#include <fcntl.h> // O_RDWR
#endif
#ifdef STB_PERSONAL
typedef int Bool;
#define False 0
#define True 1
#endif
#ifdef STB_MALLOC_WRAPPER_PAGED
#define STB_MALLOC_WRAPPER_DEBUG
#endif
#ifdef STB_MALLOC_WRAPPER_DEBUG
#define STB_MALLOC_WRAPPER
#endif
#ifdef STB_MALLOC_WRAPPER_FASTMALLOC
#define STB_FASTMALLOC
#define STB_MALLOC_WRAPPER
#endif
#ifdef STB_FASTMALLOC
#ifndef _WIN32
#undef STB_FASTMALLOC
#endif
#endif
#ifdef STB_DEFINE
#include <assert.h>
#include <stdarg.h>
#include <stddef.h>
#include <ctype.h>
#include <math.h>
#ifndef _WIN32
#include <unistd.h>
#else
#include <io.h> // _mktemp
#include <direct.h> // _rmdir
#endif
#include <sys/types.h> // stat()/_stat()
#include <sys/stat.h> // stat()/_stat()
#endif
#define stb_min(a,b) ((a) < (b) ? (a) : (b))
#define stb_max(a,b) ((a) > (b) ? (a) : (b))
#ifndef STB_ONLY
#if !defined(__cplusplus) && !defined(min) && !defined(max)
#define min(x,y) stb_min(x,y)
#define max(x,y) stb_max(x,y)
#endif
#ifndef M_PI
#define M_PI 3.14159265358979323846f
#endif
#ifndef TRUE
#define TRUE 1
#define FALSE 0
#endif
#ifndef deg2rad
#define deg2rad(a) ((a)*(M_PI/180))
#endif
#ifndef rad2deg
#define rad2deg(a) ((a)*(180/M_PI))
#endif
#ifndef swap
#ifndef __cplusplus
#define swap(TYPE,a,b) \
do { TYPE stb__t; stb__t = (a); (a) = (b); (b) = stb__t; } while (0)
#endif
#endif
typedef unsigned char uint8 ;
typedef signed char int8 ;
typedef unsigned short uint16;
typedef signed short int16;
#if defined(STB_USE_LONG_FOR_32_BIT_INT) || defined(STB_LONG32)
typedef unsigned long uint32;
typedef signed long int32;
#else
typedef unsigned int uint32;
typedef signed int int32;
#endif
typedef unsigned char uchar ;
typedef unsigned short ushort;
typedef unsigned int uint ;
typedef unsigned long ulong ;
// produce compile errors if the sizes aren't right
typedef char stb__testsize16[sizeof(int16)==2];
typedef char stb__testsize32[sizeof(int32)==4];
#endif
#ifndef STB_TRUE
#define STB_TRUE 1
#define STB_FALSE 0
#endif
// if we're STB_ONLY, can't rely on uint32 or even uint, so all the
// variables we'll use herein need typenames prefixed with 'stb':
typedef unsigned char stb_uchar;
typedef unsigned char stb_uint8;
typedef unsigned int stb_uint;
typedef unsigned short stb_uint16;
typedef short stb_int16;
typedef signed char stb_int8;
#if defined(STB_USE_LONG_FOR_32_BIT_INT) || defined(STB_LONG32)
typedef unsigned long stb_uint32;
typedef long stb_int32;
#else
typedef unsigned int stb_uint32;
typedef int stb_int32;
#endif
typedef char stb__testsize2_16[sizeof(stb_uint16)==2 ? 1 : -1];
typedef char stb__testsize2_32[sizeof(stb_uint32)==4 ? 1 : -1];
#ifdef _MSC_VER
typedef unsigned __int64 stb_uint64;
typedef __int64 stb_int64;
#define STB_IMM_UINT64(literalui64) (literalui64##ui64)
#define STB_IMM_INT64(literali64) (literali64##i64)
#else
// ??
typedef unsigned long long stb_uint64;
typedef long long stb_int64;
#define STB_IMM_UINT64(literalui64) (literalui64##ULL)
#define STB_IMM_INT64(literali64) (literali64##LL)
#endif
typedef char stb__testsize2_64[sizeof(stb_uint64)==8 ? 1 : -1];
// add platform-specific ways of checking for sizeof(char*) == 8,
// and make those define STB_PTR64
#if defined(_WIN64) || defined(__x86_64__) || defined(__ia64__) || defined(__LP64__)
#define STB_PTR64
#endif
#ifdef STB_PTR64
typedef char stb__testsize2_ptr[sizeof(char *) == 8];
typedef stb_uint64 stb_uinta;
typedef stb_int64 stb_inta;
#else
typedef char stb__testsize2_ptr[sizeof(char *) == 4];
typedef stb_uint32 stb_uinta;
typedef stb_int32 stb_inta;
#endif
typedef char stb__testsize2_uinta[sizeof(stb_uinta)==sizeof(char*) ? 1 : -1];
// if so, we should define an int type that is the pointer size. until then,
// we'll have to make do with this (which is not the same at all!)
typedef union
{
unsigned int i;
void * p;
} stb_uintptr;
#ifdef __cplusplus
#define STB_EXTERN extern "C"
#else
#define STB_EXTERN extern
#endif
// check for well-known debug defines
#if defined(DEBUG) || defined(_DEBUG) || defined(DBG)
#ifndef NDEBUG
#define STB_DEBUG
#endif
#endif
#ifdef STB_DEBUG
#include <assert.h>
#endif
STB_EXTERN void stb_wrapper_malloc(void *newp, int sz, char *file, int line);
STB_EXTERN void stb_wrapper_free(void *oldp, char *file, int line);
STB_EXTERN void stb_wrapper_realloc(void *oldp, void *newp, int sz, char *file, int line);
STB_EXTERN void stb_wrapper_calloc(size_t num, size_t sz, char *file, int line);
STB_EXTERN void stb_wrapper_listall(void (*func)(void *ptr, int sz, char *file, int line));
STB_EXTERN void stb_wrapper_dump(char *filename);
STB_EXTERN int stb_wrapper_allocsize(void *oldp);
STB_EXTERN void stb_wrapper_check(void *oldp);
#ifdef STB_DEFINE
// this is a special function used inside malloc wrapper
// to do allocations that aren't tracked (to avoid
// reentrancy). Of course if someone _else_ wraps realloc,
// this breaks, but if they're doing that AND the malloc
// wrapper they need to explicitly check for reentrancy.
//
// only define realloc_raw() and we do realloc(NULL,sz)
// for malloc() and realloc(p,0) for free().
static void * stb__realloc_raw(void *p, int sz)
{
if (p == NULL) return malloc(sz);
if (sz == 0) { free(p); return NULL; }
return realloc(p,sz);
}
#endif
#ifdef _WIN32
STB_EXTERN void * stb_smalloc(size_t sz);
STB_EXTERN void stb_sfree(void *p);
STB_EXTERN void * stb_srealloc(void *p, size_t sz);
STB_EXTERN void * stb_scalloc(size_t n, size_t sz);
STB_EXTERN char * stb_sstrdup(char *s);
#endif
#ifdef STB_FASTMALLOC
#define malloc stb_smalloc
#define free stb_sfree
#define realloc stb_srealloc
#define strdup stb_sstrdup
#define calloc stb_scalloc
#endif
#ifndef STB_MALLOC_ALLCHECK
#define stb__check(p) 1
#else
#ifndef STB_MALLOC_WRAPPER
#error STB_MALLOC_ALLCHECK requires STB_MALLOC_WRAPPER
#else
#define stb__check(p) stb_mcheck(p)
#endif
#endif
#ifdef STB_MALLOC_WRAPPER
STB_EXTERN void * stb__malloc(int, char *, int);
STB_EXTERN void * stb__realloc(void *, int, char *, int);
STB_EXTERN void * stb__calloc(size_t n, size_t s, char *, int);
STB_EXTERN void stb__free(void *, char *file, int);
STB_EXTERN char * stb__strdup(char *s, char *file, int);
STB_EXTERN void stb_malloc_checkall(void);
STB_EXTERN void stb_malloc_check_counter(int init_delay, int rep_delay);
#ifndef STB_MALLOC_WRAPPER_DEBUG
#define stb_mcheck(p) 1
#else
STB_EXTERN int stb_mcheck(void *);
#endif
#ifdef STB_DEFINE
#ifdef STB_MALLOC_WRAPPER_DEBUG
#define STB__PAD 32
#define STB__BIAS 16
#define STB__SIG 0x51b01234
#define STB__FIXSIZE(sz) (((sz+3) & ~3) + STB__PAD)
#define STB__ptr(x,y) ((char *) (x) + (y))
#else
#define STB__ptr(x,y) (x)
#define STB__FIXSIZE(sz) (sz)
#endif
#ifdef STB_MALLOC_WRAPPER_DEBUG
int stb_mcheck(void *p)
{
unsigned int sz;
if (p == NULL) return 1;
p = ((char *) p) - STB__BIAS;
sz = * (unsigned int *) p;
assert(* (unsigned int *) STB__ptr(p,4) == STB__SIG);
assert(* (unsigned int *) STB__ptr(p,8) == STB__SIG);
assert(* (unsigned int *) STB__ptr(p,12) == STB__SIG);
assert(* (unsigned int *) STB__ptr(p,sz-4) == STB__SIG+1);
assert(* (unsigned int *) STB__ptr(p,sz-8) == STB__SIG+1);
assert(* (unsigned int *) STB__ptr(p,sz-12) == STB__SIG+1);
assert(* (unsigned int *) STB__ptr(p,sz-16) == STB__SIG+1);
stb_wrapper_check(STB__ptr(p, STB__BIAS));
return 1;
}
static void stb__check2(void *p, int sz, char *file, int line)
{
stb_mcheck(p);
}
void stb_malloc_checkall(void)
{
stb_wrapper_listall(stb__check2);
}
#else
void stb_malloc_checkall(void) { }
#endif
static int stb__malloc_wait=(1 << 30), stb__malloc_next_wait = (1 << 30), stb__malloc_iter;
void stb_malloc_check_counter(int init_delay, int rep_delay)
{
stb__malloc_wait = init_delay;
stb__malloc_next_wait = rep_delay;
}
void stb_mcheck_all(void)
{
#ifdef STB_MALLOC_WRAPPER_DEBUG
++stb__malloc_iter;
if (--stb__malloc_wait <= 0) {
stb_malloc_checkall();
stb__malloc_wait = stb__malloc_next_wait;
}
#endif
}
#ifdef STB_MALLOC_WRAPPER_PAGED
#define STB__WINDOWS_PAGE (1 << 12)
#ifndef _WINDOWS_
STB_EXTERN __declspec(dllimport) void * __stdcall VirtualAlloc(void *p, unsigned long size, unsigned long type, unsigned long protect);
STB_EXTERN __declspec(dllimport) int __stdcall VirtualFree(void *p, unsigned long size, unsigned long freetype);
#endif
#endif
static void *stb__malloc_final(int sz)
{
#ifdef STB_MALLOC_WRAPPER_PAGED
int aligned = (sz + STB__WINDOWS_PAGE - 1) & ~(STB__WINDOWS_PAGE-1);
char *p = VirtualAlloc(NULL, aligned + STB__WINDOWS_PAGE, 0x2000, 0x04); // RESERVE, READWRITE
if (p == NULL) return p;
VirtualAlloc(p, aligned, 0x1000, 0x04); // COMMIT, READWRITE
return p;
#else
return malloc(sz);
#endif
}
static void stb__free_final(void *p)
{
#ifdef STB_MALLOC_WRAPPER_PAGED
VirtualFree(p, 0, 0x8000); // RELEASE
#else
free(p);
#endif
}
int stb__malloc_failure;
static void *stb__realloc_final(void *p, int sz, int old_sz)
{
#ifdef STB_MALLOC_WRAPPER_PAGED
void *q = stb__malloc_final(sz);
if (q == NULL)
return ++stb__malloc_failure, q;
// @TODO: deal with p being smaller!
memcpy(q, p, sz < old_sz ? sz : old_sz);
stb__free_final(p);
return q;
#else
return realloc(p,sz);
#endif
}
void stb__free(void *p, char *file, int line)
{
stb_mcheck_all();
if (!p) return;
#ifdef STB_MALLOC_WRAPPER_DEBUG
stb_mcheck(p);
#endif
stb_wrapper_free(p,file,line);
#ifdef STB_MALLOC_WRAPPER_DEBUG
p = STB__ptr(p,-STB__BIAS);
* (unsigned int *) STB__ptr(p,0) = 0xdeadbeef;
* (unsigned int *) STB__ptr(p,4) = 0xdeadbeef;
* (unsigned int *) STB__ptr(p,8) = 0xdeadbeef;
* (unsigned int *) STB__ptr(p,12) = 0xdeadbeef;
#endif
stb__free_final(p);
}
void * stb__malloc(int sz, char *file, int line)
{
void *p;
stb_mcheck_all();
if (sz == 0) return NULL;
p = stb__malloc_final(STB__FIXSIZE(sz));
if (p == NULL) p = stb__malloc_final(STB__FIXSIZE(sz));
if (p == NULL) p = stb__malloc_final(STB__FIXSIZE(sz));
if (p == NULL) {
++stb__malloc_failure;
#ifdef STB_MALLOC_WRAPPER_DEBUG
stb_malloc_checkall();
#endif
return p;
}
#ifdef STB_MALLOC_WRAPPER_DEBUG
* (int *) STB__ptr(p,0) = STB__FIXSIZE(sz);
* (unsigned int *) STB__ptr(p,4) = STB__SIG;
* (unsigned int *) STB__ptr(p,8) = STB__SIG;
* (unsigned int *) STB__ptr(p,12) = STB__SIG;
* (unsigned int *) STB__ptr(p,STB__FIXSIZE(sz)-4) = STB__SIG+1;
* (unsigned int *) STB__ptr(p,STB__FIXSIZE(sz)-8) = STB__SIG+1;
* (unsigned int *) STB__ptr(p,STB__FIXSIZE(sz)-12) = STB__SIG+1;
* (unsigned int *) STB__ptr(p,STB__FIXSIZE(sz)-16) = STB__SIG+1;
p = STB__ptr(p, STB__BIAS);
#endif
stb_wrapper_malloc(p,sz,file,line);
return p;
}
void * stb__realloc(void *p, int sz, char *file, int line)
{
void *q;
stb_mcheck_all();
if (p == NULL) return stb__malloc(sz,file,line);
if (sz == 0 ) { stb__free(p,file,line); return NULL; }
#ifdef STB_MALLOC_WRAPPER_DEBUG
stb_mcheck(p);
p = STB__ptr(p,-STB__BIAS);
#endif
#ifdef STB_MALLOC_WRAPPER_PAGED
{
int n = stb_wrapper_allocsize(STB__ptr(p,STB__BIAS));
if (!n)
stb_wrapper_check(STB__ptr(p,STB__BIAS));
q = stb__realloc_final(p, STB__FIXSIZE(sz), STB__FIXSIZE(n));
}
#else
q = realloc(p, STB__FIXSIZE(sz));
#endif
if (q == NULL)
return ++stb__malloc_failure, q;
#ifdef STB_MALLOC_WRAPPER_DEBUG
* (int *) STB__ptr(q,0) = STB__FIXSIZE(sz);
* (unsigned int *) STB__ptr(q,4) = STB__SIG;
* (unsigned int *) STB__ptr(q,8) = STB__SIG;
* (unsigned int *) STB__ptr(q,12) = STB__SIG;
* (unsigned int *) STB__ptr(q,STB__FIXSIZE(sz)-4) = STB__SIG+1;
* (unsigned int *) STB__ptr(q,STB__FIXSIZE(sz)-8) = STB__SIG+1;
* (unsigned int *) STB__ptr(q,STB__FIXSIZE(sz)-12) = STB__SIG+1;
* (unsigned int *) STB__ptr(q,STB__FIXSIZE(sz)-16) = STB__SIG+1;
q = STB__ptr(q, STB__BIAS);
p = STB__ptr(p, STB__BIAS);
#endif
stb_wrapper_realloc(p,q,sz,file,line);
return q;
}
STB_EXTERN int stb_log2_ceil(unsigned int);
static void *stb__calloc(size_t n, size_t sz, char *file, int line)
{
void *q;
stb_mcheck_all();
if (n == 0 || sz == 0) return NULL;
if (stb_log2_ceil(n) + stb_log2_ceil(sz) >= 32) return NULL;
q = stb__malloc(n*sz, file, line);
if (q) memset(q, 0, n*sz);
return q;
}
char * stb__strdup(char *s, char *file, int line)
{
char *p;
stb_mcheck_all();
p = stb__malloc(strlen(s)+1, file, line);
if (!p) return p;
strcpy(p, s);
return p;
}
#endif // STB_DEFINE
#ifdef STB_FASTMALLOC
#undef malloc
#undef realloc
#undef free
#undef strdup
#undef calloc
#endif
// include everything that might define these, BEFORE making macros
#include <stdlib.h>
#include <string.h>
#include <malloc.h>
#define malloc(s) stb__malloc ( s, __FILE__, __LINE__)
#define realloc(p,s) stb__realloc(p,s, __FILE__, __LINE__)
#define calloc(n,s) stb__calloc (n,s, __FILE__, __LINE__)
#define free(p) stb__free (p, __FILE__, __LINE__)
#define strdup(p) stb__strdup (p, __FILE__, __LINE__)
#endif
//////////////////////////////////////////////////////////////////////////////
//
// Windows pretty display
//
STB_EXTERN void stbprint(const char *fmt, ...);
STB_EXTERN char *stb_sprintf(const char *fmt, ...);
STB_EXTERN char *stb_mprintf(const char *fmt, ...);
STB_EXTERN int stb_snprintf(char *s, size_t n, const char *fmt, ...);
STB_EXTERN int stb_vsnprintf(char *s, size_t n, const char *fmt, va_list v);
#ifdef STB_DEFINE
int stb_vsnprintf(char *s, size_t n, const char *fmt, va_list v)
{
int res;
#ifdef _WIN32
// Could use "_vsnprintf_s(s, n, _TRUNCATE, fmt, v)" ?
res = _vsnprintf(s,n,fmt,v);
#else
res = vsnprintf(s,n,fmt,v);
#endif
if (n) s[n-1] = 0;
// Unix returns length output would require, Windows returns negative when truncated.
return (res >= (int) n || res < 0) ? -1 : res;
}
int stb_snprintf(char *s, size_t n, const char *fmt, ...)
{
int res;
va_list v;
va_start(v,fmt);
res = stb_vsnprintf(s, n, fmt, v);
va_end(v);
return res;
}
char *stb_sprintf(const char *fmt, ...)
{
static char buffer[1024];
va_list v;
va_start(v,fmt);
stb_vsnprintf(buffer,1024,fmt,v);
va_end(v);
return buffer;
}
char *stb_mprintf(const char *fmt, ...)
{
static char buffer[1024];
va_list v;
va_start(v,fmt);
stb_vsnprintf(buffer,1024,fmt,v);
va_end(v);
return strdup(buffer);
}
#ifdef _WIN32
#ifndef _WINDOWS_
STB_EXTERN __declspec(dllimport) int __stdcall WriteConsoleA(void *, const void *, unsigned int, unsigned int *, void *);
STB_EXTERN __declspec(dllimport) void * __stdcall GetStdHandle(unsigned int);
STB_EXTERN __declspec(dllimport) int __stdcall SetConsoleTextAttribute(void *, unsigned short);
#endif
static void stb__print_one(void *handle, char *s, int len)
{
if (len)
if (WriteConsoleA(handle, s, len, NULL,NULL))
fwrite(s, 1, len, stdout); // if it fails, maybe redirected, so do normal
}
static void stb__print(char *s)
{
void *handle = GetStdHandle((unsigned int) -11); // STD_OUTPUT_HANDLE
int pad=0; // number of padding characters to add
char *t = s;
while (*s) {
int lpad;
while (*s && *s != '{') {
if (pad) {
if (*s == '\r' || *s == '\n')
pad = 0;
else if (s[0] == ' ' && s[1] == ' ') {
stb__print_one(handle, t, s-t);
t = s;
while (pad) {
stb__print_one(handle, t, 1);
--pad;
}
}
}
++s;
}
if (!*s) break;
stb__print_one(handle, t, s-t);
if (s[1] == '{') {
++s;
continue;
}
if (s[1] == '#') {
t = s+3;
if (isxdigit(s[2]))
if (isdigit(s[2]))
SetConsoleTextAttribute(handle, s[2] - '0');
else
SetConsoleTextAttribute(handle, tolower(s[2]) - 'a' + 10);
else {
SetConsoleTextAttribute(handle, 0x0f);
t=s+2;
}
} else if (s[1] == '!') {
SetConsoleTextAttribute(handle, 0x0c);
t = s+2;
} else if (s[1] == '@') {
SetConsoleTextAttribute(handle, 0x09);
t = s+2;
} else if (s[1] == '$') {
SetConsoleTextAttribute(handle, 0x0a);
t = s+2;
} else {
SetConsoleTextAttribute(handle, 0x08); // 0,7,8,15 => shades of grey
t = s+1;
}
lpad = (t-s);
s = t;
while (*s && *s != '}') ++s;
if (!*s) break;
stb__print_one(handle, t, s-t);
if (s[1] == '}') {
t = s+2;
} else {
pad += 1+lpad;
t = s+1;
}
s=t;
SetConsoleTextAttribute(handle, 0x07);
}
stb__print_one(handle, t, s-t);
SetConsoleTextAttribute(handle, 0x07);
}
void stbprint(const char *fmt, ...)
{
int res;
char buffer[1024];
char *tbuf = buffer;
va_list v;
va_start(v,fmt);
res = stb_vsnprintf(buffer, sizeof(buffer), fmt, v);
va_end(v);
if (res < 0) {
tbuf = (char *) malloc(16384);
va_start(v,fmt);
res = _vsnprintf(tbuf,16384, fmt, v);
va_end(v);
tbuf[16383] = 0;
}
stb__print(tbuf);
if (tbuf != buffer)
free(tbuf);
}
#else // _WIN32
void stbprint(const char *fmt, ...)
{
va_list v;
va_start(v,fmt);
vprintf(fmt,v);
va_end(v);
}
#endif // _WIN32
#endif // STB_DEFINE
//////////////////////////////////////////////////////////////////////////////
//
// Windows UTF8 filename handling
//
// Windows stupidly treats 8-bit filenames as some dopey code page,
// rather than utf-8. If we want to use utf8 filenames, we have to
// convert them to WCHAR explicitly and call WCHAR versions of the
// file functions. So, ok, we do.
#ifdef _WIN32
#define stb__fopen(x,y) _wfopen((const wchar_t *)stb__from_utf8(x), (const wchar_t *)stb__from_utf8_alt(y))
#define stb__windows(x,y) x
#else
#define stb__fopen(x,y) fopen(x,y)
#define stb__windows(x,y) y
#endif
typedef unsigned short stb__wchar;
STB_EXTERN stb__wchar * stb_from_utf8(stb__wchar *buffer, char *str, int n);
STB_EXTERN char * stb_to_utf8 (char *buffer, stb__wchar *str, int n);
STB_EXTERN stb__wchar *stb__from_utf8(char *str);
STB_EXTERN stb__wchar *stb__from_utf8_alt(char *str);
STB_EXTERN char *stb__to_utf8(stb__wchar *str);
#ifdef STB_DEFINE
stb__wchar * stb_from_utf8(stb__wchar *buffer, char *ostr, int n)
{
unsigned char *str = (unsigned char *) ostr;
stb_uint32 c;
int i=0;
--n;
while (*str) {
if (i >= n)
return NULL;
if (!(*str & 0x80))
buffer[i++] = *str++;
else if ((*str & 0xe0) == 0xc0) {
if (*str < 0xc2) return NULL;
c = (*str++ & 0x1f) << 6;
if ((*str & 0xc0) != 0x80) return NULL;
buffer[i++] = 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;
buffer[i++] = 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 (i + 2 > n) return NULL;
buffer[i++] = 0xD800 | (0x3ff & (c >> 10));
buffer[i++] = 0xDC00 | (0x3ff & (c ));
}
} else
return NULL;
}
buffer[i] = 0;
return buffer;
}
char * stb_to_utf8(char *buffer, stb__wchar *str, int n)
{
int i=0;
--n;
while (*str) {
if (*str < 0x80) {
if (i+1 > n) return NULL;
buffer[i++] = (char) *str++;
} else if (*str < 0x800) {
if (i+2 > n) return NULL;
buffer[i++] = 0xc0 + (*str >> 6);
buffer[i++] = 0x80 + (*str & 0x3f);
str += 1;
} else if (*str >= 0xd800 && *str < 0xdc00) {
stb_uint32 c;
if (i+4 > n) return NULL;
c = ((str[0] - 0xd800) << 10) + ((str[1]) - 0xdc00) + 0x10000;
buffer[i++] = 0xf0 + (c >> 18);
buffer[i++] = 0x80 + ((c >> 12) & 0x3f);
buffer[i++] = 0x80 + ((c >> 6) & 0x3f);
buffer[i++] = 0x80 + ((c ) & 0x3f);
str += 2;
} else if (*str >= 0xdc00 && *str < 0xe000) {
return NULL;
} else {
if (i+3 > n) return NULL;
buffer[i++] = 0xe0 + (*str >> 12);
buffer[i++] = 0x80 + ((*str >> 6) & 0x3f);
buffer[i++] = 0x80 + ((*str ) & 0x3f);
str += 1;
}
}
buffer[i] = 0;
return buffer;
}
stb__wchar *stb__from_utf8(char *str)
{
static stb__wchar buffer[4096];
return stb_from_utf8(buffer, str, 4096);
}
stb__wchar *stb__from_utf8_alt(char *str)
{
static stb__wchar buffer[64];
return stb_from_utf8(buffer, str, 64);
}
char *stb__to_utf8(stb__wchar *str)
{
static char buffer[4096];
return stb_to_utf8(buffer, str, 4096);
}
#endif
//////////////////////////////////////////////////////////////////////////////
//
// Miscellany
//
STB_EXTERN void stb_fatal(char *fmt, ...);
STB_EXTERN void stb_(char *fmt, ...);
STB_EXTERN void stb_append_to_file(char *file, char *fmt, ...);
STB_EXTERN void stb_log(int active);
STB_EXTERN void stb_log_fileline(int active);
STB_EXTERN void stb_log_name(char *filename);
STB_EXTERN void stb_swap(void *p, void *q, size_t sz);
STB_EXTERN void *stb_copy(void *p, size_t sz);
STB_EXTERN void stb_pointer_array_free(void *p, int len);
STB_EXTERN void **stb_array_block_alloc(int count, int blocksize);
#define stb_arrcount(x) (sizeof(x)/sizeof((x)[0]))
STB_EXTERN int stb__record_fileline(char *f, int n);
#ifdef STB_DEFINE
static char *stb__file;
static int stb__line;
int stb__record_fileline(char *f, int n)
{
stb__file = f;
stb__line = n;
return 0;
}
void stb_fatal(char *s, ...)
{
va_list a;
if (stb__file)
fprintf(stderr, "[%s:%d] ", stb__file, stb__line);
va_start(a,s);
fputs("Fatal error: ", stderr);
vfprintf(stderr, s, a);
va_end(a);
fputs("\n", stderr);
#ifdef STB_DEBUG
#ifdef _MSC_VER
#ifndef STB_PTR64
__asm int 3; // trap to debugger!
#else
__debugbreak();
#endif
#else
__builtin_trap();
#endif
#endif
exit(1);
}
static int stb__log_active=1, stb__log_fileline=1;
void stb_log(int active)
{
stb__log_active = active;
}
void stb_log_fileline(int active)
{
stb__log_fileline = active;
}
#ifdef STB_NO_STB_STRINGS
char *stb__log_filename = "temp.log";
#else
char *stb__log_filename = "stb.log";
#endif
void stb_log_name(char *s)
{
stb__log_filename = s;
}
void stb_(char *s, ...)
{
if (stb__log_active) {
FILE *f = fopen(stb__log_filename, "a");
if (f) {
va_list a;
if (stb__log_fileline && stb__file)
fprintf(f, "[%s:%4d] ", stb__file, stb__line);
va_start(a,s);
vfprintf(f, s, a);
va_end(a);
fputs("\n", f);
fclose(f);
}
}
}
void stb_append_to_file(char *filename, char *s, ...)
{
FILE *f = fopen(filename, "a");
if (f) {
va_list a;
va_start(a,s);
vfprintf(f, s, a);
va_end(a);
fputs("\n", f);
fclose(f);
}
}
typedef struct { char d[4]; } stb__4;
typedef struct { char d[8]; } stb__8;
// optimize the small cases, though you shouldn't be calling this for those!
void stb_swap(void *p, void *q, size_t sz)
{
char buffer[256];
if (p == q) return;
if (sz == 4) {
stb__4 temp = * ( stb__4 *) p;
* (stb__4 *) p = * ( stb__4 *) q;
* (stb__4 *) q = temp;
return;
} else if (sz == 8) {
stb__8 temp = * ( stb__8 *) p;
* (stb__8 *) p = * ( stb__8 *) q;
* (stb__8 *) q = temp;
return;
}
while (sz > sizeof(buffer)) {
stb_swap(p, q, sizeof(buffer));
p = (char *) p + sizeof(buffer);
q = (char *) q + sizeof(buffer);
sz -= sizeof(buffer);
}
memcpy(buffer, p , sz);
memcpy(p , q , sz);
memcpy(q , buffer, sz);
}
void *stb_copy(void *p, size_t sz)
{
void *q = malloc(sz);
memcpy(q, p, sz);
return q;
}
void stb_pointer_array_free(void *q, int len)
{
void **p = (void **) q;
int i;
for (i=0; i < len; ++i)
free(p[i]);
}
void **stb_array_block_alloc(int count, int blocksize)
{
int i;
char *p = (char *) malloc(sizeof(void *) * count + count * blocksize);
void **q;
if (p == NULL) return NULL;
q = (void **) p;
p += sizeof(void *) * count;
for (i=0; i < count; ++i)
q[i] = p + i * blocksize;
return q;
}
#endif
#ifdef STB_DEBUG
// tricky hack to allow recording FILE,LINE even in varargs functions
#define STB__RECORD_FILE(x) (stb__record_fileline(__FILE__, __LINE__),(x))
#define stb_log STB__RECORD_FILE(stb_log)
#define stb_ STB__RECORD_FILE(stb_)
#ifndef STB_FATAL_CLEAN
#define stb_fatal STB__RECORD_FILE(stb_fatal)
#endif
#define STB__DEBUG(x) x
#else
#define STB__DEBUG(x)
#endif
//////////////////////////////////////////////////////////////////////////////
//
// stb_temp
//
#define stb_temp(block, sz) stb__temp(block, sizeof(block), (sz))
STB_EXTERN void * stb__temp(void *b, int b_sz, int want_sz);
STB_EXTERN void stb_tempfree(void *block, void *ptr);
#ifdef STB_DEFINE
void * stb__temp(void *b, int b_sz, int want_sz)
{
if (b_sz >= want_sz)
return b;
else
return malloc(want_sz);
}
void stb_tempfree(void *b, void *p)
{
if (p != b)
free(p);
}
#endif
//////////////////////////////////////////////////////////////////////////////
//
// math/sampling operations
//
#define stb_lerp(t,a,b) ( (a) + (t) * (float) ((b)-(a)) )
#define stb_unlerp(t,a,b) ( ((t) - (a)) / (float) ((b) - (a)) )
#define stb_clamp(x,xmin,xmax) ((x) < (xmin) ? (xmin) : (x) > (xmax) ? (xmax) : (x))
STB_EXTERN void stb_newell_normal(float *normal, int num_vert, float **vert, int normalize);
STB_EXTERN int stb_box_face_vertex_axis_side(int face_number, int vertex_number, int axis);
STB_EXTERN void stb_linear_controller(float *curpos, float target_pos, float acc, float deacc, float dt);
STB_EXTERN int stb_float_eq(float x, float y, float delta, int max_ulps);
STB_EXTERN int stb_is_prime(unsigned int m);
STB_EXTERN unsigned int stb_power_of_two_nearest_prime(int n);
STB_EXTERN float stb_smoothstep(float t);
STB_EXTERN float stb_cubic_bezier_1d(float t, float p0, float p1, float p2, float p3);
STB_EXTERN double stb_linear_remap(double x, double a, double b,
double c, double d);
#ifdef STB_DEFINE
float stb_smoothstep(float t)
{
return (3 - 2*t)*(t*t);
}
float stb_cubic_bezier_1d(float t, float p0, float p1, float p2, float p3)
{
float it = 1-t;
return it*it*it*p0 + 3*it*it*t*p1 + 3*it*t*t*p2 + t*t*t*p3;
}
void stb_newell_normal(float *normal, int num_vert, float **vert, int normalize)
{
int i,j;
float p;
normal[0] = normal[1] = normal[2] = 0;
for (i=num_vert-1,j=0; j < num_vert; i=j++) {
float *u = vert[i];
float *v = vert[j];
normal[0] += (u[1] - v[1]) * (u[2] + v[2]);
normal[1] += (u[2] - v[2]) * (u[0] + v[0]);
normal[2] += (u[0] - v[0]) * (u[1] + v[1]);
}
if (normalize) {
p = normal[0]*normal[0] + normal[1]*normal[1] + normal[2]*normal[2];
p = (float) (1.0 / sqrt(p));
normal[0] *= p;
normal[1] *= p;
normal[2] *= p;
}
}
int stb_box_face_vertex_axis_side(int face_number, int vertex_number, int axis)
{
static int box_vertices[6][4][3] =
{
{ { 1,1,1 }, { 1,0,1 }, { 1,0,0 }, { 1,1,0 } },
{ { 0,0,0 }, { 0,0,1 }, { 0,1,1 }, { 0,1,0 } },
{ { 0,0,0 }, { 0,1,0 }, { 1,1,0 }, { 1,0,0 } },
{ { 0,0,0 }, { 1,0,0 }, { 1,0,1 }, { 0,0,1 } },
{ { 1,1,1 }, { 0,1,1 }, { 0,0,1 }, { 1,0,1 } },
{ { 1,1,1 }, { 1,1,0 }, { 0,1,0 }, { 0,1,1 } },
};
assert(face_number >= 0 && face_number < 6);
assert(vertex_number >= 0 && vertex_number < 4);
assert(axis >= 0 && axis < 3);
return box_vertices[face_number][vertex_number][axis];
}
void stb_linear_controller(float *curpos, float target_pos, float acc, float deacc, float dt)
{
float sign = 1, p, cp = *curpos;
if (cp == target_pos) return;
if (target_pos < cp) {
target_pos = -target_pos;
cp = -cp;
sign = -1;
}
// first decelerate
if (cp < 0) {
p = cp + deacc * dt;
if (p > 0) {
p = 0;
dt = dt - cp / deacc;
if (dt < 0) dt = 0;
} else {
dt = 0;
}
cp = p;
}
// now accelerate
p = cp + acc*dt;
if (p > target_pos) p = target_pos;
*curpos = p * sign;
// @TODO: testing
}
float stb_quadratic_controller(float target_pos, float curpos, float maxvel, float maxacc, float dt, float *curvel)
{
return 0; // @TODO
}
int stb_float_eq(float x, float y, float delta, int max_ulps)
{
if (fabs(x-y) <= delta) return 1;
if (abs(*(int *)&x - *(int *)&y) <= max_ulps) return 1;
return 0;
}
int stb_is_prime(unsigned int m)
{
unsigned int i,j;
if (m < 2) return 0;
if (m == 2) return 1;
if (!(m & 1)) return 0;
if (m % 3 == 0) return (m == 3);
for (i=5; (j=i*i), j <= m && j > i; i += 6) {
if (m % i == 0) return 0;
if (m % (i+2) == 0) return 0;
}
return 1;
}
unsigned int stb_power_of_two_nearest_prime(int n)
{
static signed char tab[32] = { 0,0,0,0,1,0,-1,0,1,-1,-1,3,-1,0,-1,2,1,
0,2,0,-1,-4,-1,5,-1,18,-2,15,2,-1,2,0 };
if (!tab[0]) {
int i;
for (i=0; i < 32; ++i)
tab[i] = (1 << i) + 2*tab[i] - 1;
tab[1] = 2;
tab[0] = 1;
}
if (n >= 32) return 0xfffffffb;
return tab[n];
}
double stb_linear_remap(double x, double x_min, double x_max,
double out_min, double out_max)
{
return stb_lerp(stb_unlerp(x,x_min,x_max),out_min,out_max);
}
#endif
// create a macro so it's faster, but you can get at the function pointer
#define stb_linear_remap(t,a,b,c,d) stb_lerp(stb_unlerp(t,a,b),c,d)
//////////////////////////////////////////////////////////////////////////////
//
// bit operations
//
#define stb_big32(c) (((c)[0]<<24) + (c)[1]*65536 + (c)[2]*256 + (c)[3])
#define stb_little32(c) (((c)[3]<<24) + (c)[2]*65536 + (c)[1]*256 + (c)[0])
#define stb_big16(c) ((c)[0]*256 + (c)[1])
#define stb_little16(c) ((c)[1]*256 + (c)[0])
STB_EXTERN int stb_bitcount(unsigned int a);
STB_EXTERN unsigned int stb_bitreverse8(unsigned char n);
STB_EXTERN unsigned int stb_bitreverse(unsigned int n);
STB_EXTERN int stb_is_pow2(unsigned int n);
STB_EXTERN int stb_log2_ceil(unsigned int n);
STB_EXTERN int stb_log2_floor(unsigned int n);
STB_EXTERN int stb_lowbit8(unsigned int n);
STB_EXTERN int stb_highbit8(unsigned int n);
#ifdef STB_DEFINE
int stb_bitcount(unsigned int a)
{
a = (a & 0x55555555) + ((a >> 1) & 0x55555555); // max 2
a = (a & 0x33333333) + ((a >> 2) & 0x33333333); // max 4
a = (a + (a >> 4)) & 0x0f0f0f0f; // max 8 per 4, now 8 bits
a = (a + (a >> 8)); // max 16 per 8 bits
a = (a + (a >> 16)); // max 32 per 8 bits
return a & 0xff;
}
unsigned int stb_bitreverse8(unsigned char n)
{
n = ((n & 0xAA) >> 1) + ((n & 0x55) << 1);
n = ((n & 0xCC) >> 2) + ((n & 0x33) << 2);
return (unsigned char) ((n >> 4) + (n << 4));
}
unsigned int stb_bitreverse(unsigned int n)
{
n = ((n & 0xAAAAAAAA) >> 1) | ((n & 0x55555555) << 1);
n = ((n & 0xCCCCCCCC) >> 2) | ((n & 0x33333333) << 2);
n = ((n & 0xF0F0F0F0) >> 4) | ((n & 0x0F0F0F0F) << 4);
n = ((n & 0xFF00FF00) >> 8) | ((n & 0x00FF00FF) << 8);
return (n >> 16) | (n << 16);
}
int stb_is_pow2(unsigned int n)
{
return (n & (n-1)) == 0;
}
// tricky use of 4-bit table to identify 5 bit positions (note the '-1')
// 3-bit table would require another tree level; 5-bit table wouldn't save one
#if defined(_WIN32) && !defined(__MINGW32__)
#pragma warning(push)
#pragma warning(disable: 4035) // disable warning about no return value
int stb_log2_floor(unsigned int n)
{
#if _MSC_VER > 1700
unsigned long i;
_BitScanReverse(&i, n);
return i != 0 ? i : -1;
#else
__asm {
bsr eax,n
jnz done
mov eax,-1
}
done:;
#endif
}
#pragma warning(pop)
#else
int stb_log2_floor(unsigned int n)
{
static signed char log2_4[16] = { -1,0,1,1,2,2,2,2,3,3,3,3,3,3,3,3 };
// 2 compares if n < 16, 3 compares otherwise
if (n < (1U << 14))
if (n < (1U << 4)) return 0 + log2_4[n ];
else if (n < (1U << 9)) return 5 + log2_4[n >> 5];
else return 10 + log2_4[n >> 10];
else if (n < (1U << 24))
if (n < (1U << 19)) return 15 + log2_4[n >> 15];
else return 20 + log2_4[n >> 20];
else if (n < (1U << 29)) return 25 + log2_4[n >> 25];
else return 30 + log2_4[n >> 30];
}
#endif
// define ceil from floor
int stb_log2_ceil(unsigned int n)
{
if (stb_is_pow2(n)) return stb_log2_floor(n);
else return 1 + stb_log2_floor(n);
}
int stb_highbit8(unsigned int n)
{
return stb_log2_ceil(n&255);
}
int stb_lowbit8(unsigned int n)
{
static signed char lowbit4[16] = { -1,0,1,0, 2,0,1,0, 3,0,1,0, 2,0,1,0 };
int k = lowbit4[n & 15];
if (k >= 0) return k;
k = lowbit4[(n >> 4) & 15];
if (k >= 0) return k+4;
return k;
}
#endif
//////////////////////////////////////////////////////////////////////////////
//
// qsort Compare Routines
//
#ifdef _WIN32
#define stb_stricmp(a,b) stricmp(a,b)
#define stb_strnicmp(a,b,n) strnicmp(a,b,n)
#else
#define stb_stricmp(a,b) strcasecmp(a,b)
#define stb_strnicmp(a,b,n) strncasecmp(a,b,n)
#endif
STB_EXTERN int (*stb_intcmp(int offset))(const void *a, const void *b);
STB_EXTERN int (*stb_qsort_strcmp(int offset))(const void *a, const void *b);
STB_EXTERN int (*stb_qsort_stricmp(int offset))(const void *a, const void *b);
STB_EXTERN int (*stb_floatcmp(int offset))(const void *a, const void *b);
STB_EXTERN int (*stb_doublecmp(int offset))(const void *a, const void *b);
STB_EXTERN int (*stb_charcmp(int offset))(const void *a, const void *b);
#ifdef STB_DEFINE
static int stb__intcmpoffset, stb__charcmpoffset, stb__strcmpoffset;
static int stb__floatcmpoffset, stb__doublecmpoffset;
int stb__intcmp(const void *a, const void *b)
{
const int p = *(const int *) ((const char *) a + stb__intcmpoffset);
const int q = *(const int *) ((const char *) b + stb__intcmpoffset);
return p < q ? -1 : p > q;
}
int stb__charcmp(const void *a, const void *b)
{
const int p = *(const unsigned char *) ((const char *) a + stb__charcmpoffset);
const int q = *(const unsigned char *) ((const char *) b + stb__charcmpoffset);
return p < q ? -1 : p > q;
}
int stb__floatcmp(const void *a, const void *b)
{
const float p = *(const float *) ((const char *) a + stb__floatcmpoffset);
const float q = *(const float *) ((const char *) b + stb__floatcmpoffset);
return p < q ? -1 : p > q;
}
int stb__doublecmp(const void *a, const void *b)
{
const double p = *(const double *) ((const char *) a + stb__doublecmpoffset);
const double q = *(const double *) ((const char *) b + stb__doublecmpoffset);
return p < q ? -1 : p > q;
}
int stb__qsort_strcmp(const void *a, const void *b)
{
const char *p = *(const char **) ((const char *) a + stb__strcmpoffset);
const char *q = *(const char **) ((const char *) b + stb__strcmpoffset);
return strcmp(p,q);
}
int stb__qsort_stricmp(const void *a, const void *b)
{
const char *p = *(const char **) ((const char *) a + stb__strcmpoffset);
const char *q = *(const char **) ((const char *) b + stb__strcmpoffset);
return stb_stricmp(p,q);
}
int (*stb_intcmp(int offset))(const void *, const void *)
{
stb__intcmpoffset = offset;
return &stb__intcmp;
}
int (*stb_charcmp(int offset))(const void *, const void *)
{
stb__charcmpoffset = offset;
return &stb__charcmp;
}
int (*stb_qsort_strcmp(int offset))(const void *, const void *)
{
stb__strcmpoffset = offset;
return &stb__qsort_strcmp;
}
int (*stb_qsort_stricmp(int offset))(const void *, const void *)
{
stb__strcmpoffset = offset;
return &stb__qsort_stricmp;
}
int (*stb_floatcmp(int offset))(const void *, const void *)
{
stb__floatcmpoffset = offset;
return &stb__floatcmp;
}
int (*stb_doublecmp(int offset))(const void *, const void *)
{
stb__doublecmpoffset = offset;
return &stb__doublecmp;
}
#endif
//////////////////////////////////////////////////////////////////////////////
//
// Binary Search Toolkit
//
typedef struct
{
int minval, maxval, guess;
int mode, step;
} stb_search;
STB_EXTERN int stb_search_binary(stb_search *s, int minv, int maxv, int find_smallest);
STB_EXTERN int stb_search_open(stb_search *s, int minv, int find_smallest);
STB_EXTERN int stb_probe(stb_search *s, int compare, int *result); // return 0 when done
#ifdef STB_DEFINE
enum
{
STB_probe_binary_smallest,
STB_probe_binary_largest,
STB_probe_open_smallest,
STB_probe_open_largest,
};
static int stb_probe_guess(stb_search *s, int *result)
{
switch(s->mode) {
case STB_probe_binary_largest:
if (s->minval == s->maxval) {
*result = s->minval;
return 0;
}
assert(s->minval < s->maxval);
// if a < b, then a < p <= b
s->guess = s->minval + (((unsigned) s->maxval - s->minval + 1) >> 1);
break;
case STB_probe_binary_smallest:
if (s->minval == s->maxval) {
*result = s->minval;
return 0;
}
assert(s->minval < s->maxval);
// if a < b, then a <= p < b
s->guess = s->minval + (((unsigned) s->maxval - s->minval) >> 1);
break;
case STB_probe_open_smallest:
case STB_probe_open_largest:
s->guess = s->maxval; // guess the current maxval
break;
}
*result = s->guess;
return 1;
}
int stb_probe(stb_search *s, int compare, int *result)
{
switch(s->mode) {
case STB_probe_open_smallest:
case STB_probe_open_largest: {
if (compare <= 0) {
// then it lies within minval & maxval
if (s->mode == STB_probe_open_smallest)
s->mode = STB_probe_binary_smallest;
else
s->mode = STB_probe_binary_largest;
} else {
// otherwise, we need to probe larger
s->minval = s->maxval + 1;
s->maxval = s->minval + s->step;
s->step += s->step;
}
break;
}
case STB_probe_binary_smallest: {
// if compare < 0, then s->minval <= a < p
// if compare = 0, then s->minval <= a <= p
// if compare > 0, then p < a <= s->maxval
if (compare <= 0)
s->maxval = s->guess;
else
s->minval = s->guess+1;
break;
}
case STB_probe_binary_largest: {
// if compare < 0, then s->minval <= a < p
// if compare = 0, then p <= a <= s->maxval
// if compare > 0, then p < a <= s->maxval
if (compare < 0)
s->maxval = s->guess-1;
else
s->minval = s->guess;
break;
}
}
return stb_probe_guess(s, result);
}
int stb_search_binary(stb_search *s, int minv, int maxv, int find_smallest)
{
int r;
if (maxv < minv) return minv-1;
s->minval = minv;
s->maxval = maxv;
s->mode = find_smallest ? STB_probe_binary_smallest : STB_probe_binary_largest;
stb_probe_guess(s, &r);
return r;
}
int stb_search_open(stb_search *s, int minv, int find_smallest)
{
int r;
s->step = 4;
s->minval = minv;
s->maxval = minv+s->step;
s->mode = find_smallest ? STB_probe_open_smallest : STB_probe_open_largest;
stb_probe_guess(s, &r);
return r;
}
#endif
//////////////////////////////////////////////////////////////////////////////
//
// String Processing
//
#define stb_prefixi(s,t) (0==stb_strnicmp((s),(t),strlen(t)))
enum stb_splitpath_flag
{
STB_PATH = 1,
STB_FILE = 2,
STB_EXT = 4,
STB_PATH_FILE = STB_PATH + STB_FILE,
STB_FILE_EXT = STB_FILE + STB_EXT,
STB_EXT_NO_PERIOD = 8,
};
STB_EXTERN char * stb_skipwhite(char *s);
STB_EXTERN char * stb_trimwhite(char *s);
STB_EXTERN char * stb_skipnewline(char *s);
STB_EXTERN char * stb_strncpy(char *s, char *t, int n);
STB_EXTERN char * stb_substr(char *t, int n);
STB_EXTERN char * stb_duplower(char *s);
STB_EXTERN void stb_tolower (char *s);
STB_EXTERN char * stb_strchr2 (char *s, char p1, char p2);
STB_EXTERN char * stb_strrchr2(char *s, char p1, char p2);
STB_EXTERN char * stb_strtok(char *output, char *src, char *delimit);
STB_EXTERN char * stb_strtok_keep(char *output, char *src, char *delimit);
STB_EXTERN char * stb_strtok_invert(char *output, char *src, char *allowed);
STB_EXTERN char * stb_dupreplace(char *s, char *find, char *replace);
STB_EXTERN void stb_replaceinplace(char *s, char *find, char *replace);
STB_EXTERN char * stb_splitpath(char *output, char *src, int flag);
STB_EXTERN char * stb_splitpathdup(char *src, int flag);
STB_EXTERN char * stb_replacedir(char *output, char *src, char *dir);
STB_EXTERN char * stb_replaceext(char *output, char *src, char *ext);
STB_EXTERN void stb_fixpath(char *path);
STB_EXTERN char * stb_shorten_path_readable(char *path, int max_len);
STB_EXTERN int stb_suffix (char *s, char *t);
STB_EXTERN int stb_suffixi(char *s, char *t);
STB_EXTERN int stb_prefix (char *s, char *t);
STB_EXTERN char * stb_strichr(char *s, char t);
STB_EXTERN char * stb_stristr(char *s, char *t);
STB_EXTERN int stb_prefix_count(char *s, char *t);
STB_EXTERN char * stb_plural(int n); // "s" or ""
STB_EXTERN size_t stb_strscpy(char *d, const char *s, size_t n);
STB_EXTERN char **stb_tokens(char *src, char *delimit, int *count);
STB_EXTERN char **stb_tokens_nested(char *src, char *delimit, int *count, char *nest_in, char *nest_out);
STB_EXTERN char **stb_tokens_nested_empty(char *src, char *delimit, int *count, char *nest_in, char *nest_out);
STB_EXTERN char **stb_tokens_allowempty(char *src, char *delimit, int *count);
STB_EXTERN char **stb_tokens_stripwhite(char *src, char *delimit, int *count);
STB_EXTERN char **stb_tokens_withdelim(char *src, char *delimit, int *count);
STB_EXTERN char **stb_tokens_quoted(char *src, char *delimit, int *count);
// with 'quoted', allow delimiters to appear inside quotation marks, and don't
// strip whitespace inside them (and we delete the quotation marks unless they
// appear back to back, in which case they're considered escaped)
#ifdef STB_DEFINE
size_t stb_strscpy(char *d, const char *s, size_t n)
{
size_t len = strlen(s);
if (len >= n) {
if (n) d[0] = 0;
return 0;
}
strcpy(d,s);
return len + 1;
}
char *stb_plural(int n)
{
return n == 1 ? "" : "s";
}
int stb_prefix(char *s, char *t)
{
while (*t)
if (*s++ != *t++)
return STB_FALSE;
return STB_TRUE;
}
int stb_prefix_count(char *s, char *t)
{
int c=0;
while (*t) {
if (*s++ != *t++)
break;
++c;
}
return c;
}
int stb_suffix(char *s, char *t)
{
size_t n = strlen(s);
size_t m = strlen(t);
if (m <= n)
return 0 == strcmp(s+n-m, t);
else
return 0;
}
int stb_suffixi(char *s, char *t)
{
size_t n = strlen(s);
size_t m = strlen(t);
if (m <= n)
return 0 == stb_stricmp(s+n-m, t);
else
return 0;
}
// originally I was using this table so that I could create known sentinel
// values--e.g. change whitetable[0] to be true if I was scanning for whitespace,
// and false if I was scanning for nonwhite. I don't appear to be using that
// functionality anymore (I do for tokentable, though), so just replace it
// with isspace()
char *stb_skipwhite(char *s)
{
while (isspace((unsigned char) *s)) ++s;
return s;
}
char *stb_skipnewline(char *s)
{
if (s[0] == '\r' || s[0] == '\n') {
if (s[0]+s[1] == '\r' + '\n') ++s;
++s;
}
return s;
}
char *stb_trimwhite(char *s)
{
int i,n;
s = stb_skipwhite(s);
n = (int) strlen(s);
for (i=n-1; i >= 0; --i)
if (!isspace(s[i]))
break;
s[i+1] = 0;
return s;
}
char *stb_strncpy(char *s, char *t, int n)
{
strncpy(s,t,n);
s[n-1] = 0;
return s;
}
char *stb_substr(char *t, int n)
{
char *a;
int z = (int) strlen(t);
if (z < n) n = z;
a = (char *) malloc(n+1);
strncpy(a,t,n);
a[n] = 0;
return a;
}
char *stb_duplower(char *s)
{
char *p = strdup(s), *q = p;
while (*q) {
*q = tolower(*q);
++q;
}
return p;
}
void stb_tolower(char *s)
{
while (*s) {
*s = tolower(*s);
++s;
}
}
char *stb_strchr2(char *s, char x, char y)
{
for(; *s; ++s)
if (*s == x || *s == y)
return s;
return NULL;
}
char *stb_strrchr2(char *s, char x, char y)
{
char *r = NULL;
for(; *s; ++s)
if (*s == x || *s == y)
r = s;
return r;
}
char *stb_strichr(char *s, char t)
{
if (tolower(t) == toupper(t))
return strchr(s,t);
return stb_strchr2(s, (char) tolower(t), (char) toupper(t));
}
char *stb_stristr(char *s, char *t)
{
size_t n = strlen(t);
char *z;
if (n==0) return s;
while ((z = stb_strichr(s, *t)) != NULL) {
if (0==stb_strnicmp(z, t, n))
return z;
s = z+1;
}
return NULL;
}
static char *stb_strtok_raw(char *output, char *src, char *delimit, int keep, int invert)
{
if (invert) {
while (*src && strchr(delimit, *src) != NULL) {
*output++ = *src++;
}
} else {
while (*src && strchr(delimit, *src) == NULL) {
*output++ = *src++;
}
}
*output = 0;
if (keep)
return src;
else
return *src ? src+1 : src;
}
char *stb_strtok(char *output, char *src, char *delimit)
{
return stb_strtok_raw(output, src, delimit, 0, 0);
}
char *stb_strtok_keep(char *output, char *src, char *delimit)
{
return stb_strtok_raw(output, src, delimit, 1, 0);
}
char *stb_strtok_invert(char *output, char *src, char *delimit)
{
return stb_strtok_raw(output, src, delimit, 1,1);
}
static char **stb_tokens_raw(char *src_, char *delimit, int *count,
int stripwhite, int allow_empty, char *start, char *end)
{
int nested = 0;
unsigned char *src = (unsigned char *) src_;
static char stb_tokentable[256]; // rely on static initializion to 0
static char stable[256],etable[256];
char *out;
char **result;
int num=0;
unsigned char *s;
s = (unsigned char *) delimit; while (*s) stb_tokentable[*s++] = 1;
if (start) {
s = (unsigned char *) start; while (*s) stable[*s++] = 1;
s = (unsigned char *) end; if (s) while (*s) stable[*s++] = 1;
s = (unsigned char *) end; if (s) while (*s) etable[*s++] = 1;
}
stable[0] = 1;
// two passes through: the first time, counting how many
s = (unsigned char *) src;
while (*s) {
// state: just found delimiter
// skip further delimiters
if (!allow_empty) {
stb_tokentable[0] = 0;
while (stb_tokentable[*s])
++s;
if (!*s) break;
}
++num;
// skip further non-delimiters
stb_tokentable[0] = 1;
if (stripwhite == 2) { // quoted strings
while (!stb_tokentable[*s]) {
if (*s != '"')
++s;
else {
++s;
if (*s == '"')
++s; // "" -> ", not start a string
else {
// begin a string
while (*s) {
if (s[0] == '"') {
if (s[1] == '"') s += 2; // "" -> "
else { ++s; break; } // terminating "
} else
++s;
}
}
}
}
} else
while (nested || !stb_tokentable[*s]) {
if (stable[*s]) {
if (!*s) break;
if (end ? etable[*s] : nested)
--nested;
else
++nested;
}
++s;
}
if (allow_empty) {
if (*s) ++s;
}
}
// now num has the actual count... malloc our output structure
// need space for all the strings: strings won't be any longer than
// original input, since for every '\0' there's at least one delimiter
result = (char **) malloc(sizeof(*result) * (num+1) + (s-src+1));
if (result == NULL) return result;
out = (char *) (result + (num+1));
// second pass: copy out the data
s = (unsigned char *) src;
num = 0;
nested = 0;
while (*s) {
char *last_nonwhite;
// state: just found delimiter
// skip further delimiters
if (!allow_empty) {
stb_tokentable[0] = 0;
if (stripwhite)
while (stb_tokentable[*s] || isspace(*s))
++s;
else
while (stb_tokentable[*s])
++s;
} else if (stripwhite) {
while (isspace(*s)) ++s;
}
if (!*s) break;
// we're past any leading delimiters and whitespace
result[num] = out;
++num;
// copy non-delimiters
stb_tokentable[0] = 1;
last_nonwhite = out-1;
if (stripwhite == 2) {
while (!stb_tokentable[*s]) {
if (*s != '"') {
if (!isspace(*s)) last_nonwhite = out;
*out++ = *s++;
} else {
++s;
if (*s == '"') {
if (!isspace(*s)) last_nonwhite = out;
*out++ = *s++; // "" -> ", not start string
} else {
// begin a quoted string
while (*s) {
if (s[0] == '"') {
if (s[1] == '"') { *out++ = *s; s += 2; }
else { ++s; break; } // terminating "
} else
*out++ = *s++;
}
last_nonwhite = out-1; // all in quotes counts as non-white
}
}
}
} else {
while (nested || !stb_tokentable[*s]) {
if (!isspace(*s)) last_nonwhite = out;
if (stable[*s]) {
if (!*s) break;
if (end ? etable[*s] : nested)
--nested;
else
++nested;
}
*out++ = *s++;
}
}
if (stripwhite) // rewind to last non-whitespace char
out = last_nonwhite+1;
*out++ = '\0';
if (*s) ++s; // skip delimiter
}
s = (unsigned char *) delimit; while (*s) stb_tokentable[*s++] = 0;
if (start) {
s = (unsigned char *) start; while (*s) stable[*s++] = 1;
s = (unsigned char *) end; if (s) while (*s) stable[*s++] = 1;
s = (unsigned char *) end; if (s) while (*s) etable[*s++] = 1;
}
if (count != NULL) *count = num;
result[num] = 0;
return result;
}
char **stb_tokens(char *src, char *delimit, int *count)
{
return stb_tokens_raw(src,delimit,count,0,0,0,0);
}
char **stb_tokens_nested(char *src, char *delimit, int *count, char *nest_in, char *nest_out)
{
return stb_tokens_raw(src,delimit,count,0,0,nest_in,nest_out);
}
char **stb_tokens_nested_empty(char *src, char *delimit, int *count, char *nest_in, char *nest_out)
{
return stb_tokens_raw(src,delimit,count,0,1,nest_in,nest_out);
}
char **stb_tokens_allowempty(char *src, char *delimit, int *count)
{
return stb_tokens_raw(src,delimit,count,0,1,0,0);
}
char **stb_tokens_stripwhite(char *src, char *delimit, int *count)
{
return stb_tokens_raw(src,delimit,count,1,1,0,0);
}
char **stb_tokens_quoted(char *src, char *delimit, int *count)
{
return stb_tokens_raw(src,delimit,count,2,1,0,0);
}
char *stb_dupreplace(char *src, char *find, char *replace)
{
size_t len_find = strlen(find);
size_t len_replace = strlen(replace);
int count = 0;
char *s,*p,*q;
s = strstr(src, find);
if (s == NULL) return strdup(src);
do {
++count;
s = strstr(s + len_find, find);
} while (s != NULL);
p = (char *) malloc(strlen(src) + count * (len_replace - len_find) + 1);
if (p == NULL) return p;
q = p;
s = src;
for (;;) {
char *t = strstr(s, find);
if (t == NULL) {
strcpy(q,s);
assert(strlen(p) == strlen(src) + count*(len_replace-len_find));
return p;
}
memcpy(q, s, t-s);
q += t-s;
memcpy(q, replace, len_replace);
q += len_replace;
s = t + len_find;
}
}
void stb_replaceinplace(char *src, char *find, char *replace)
{
size_t len_find = strlen(find);
size_t len_replace = strlen(replace);
int delta;
char *s,*p,*q;
delta = len_replace - len_find;
assert(delta <= 0);
if (delta > 0) return;
p = strstr(src, find);
if (p == NULL) return;
s = q = p;
while (*s) {
memcpy(q, replace, len_replace);
p += len_find;
q += len_replace;
s = strstr(p, find);
if (s == NULL) s = p + strlen(p);
memmove(q, p, s-p);
q += s-p;
p = s;
}
*q = 0;
}
void stb_fixpath(char *path)
{
for(; *path; ++path)
if (*path == '\\')
*path = '/';
}
void stb__add_section(char *buffer, char *data, int curlen, int newlen)
{
if (newlen < curlen) {
int z1 = newlen >> 1, z2 = newlen-z1;
memcpy(buffer, data, z1-1);
buffer[z1-1] = '.';
buffer[z1-0] = '.';
memcpy(buffer+z1+1, data+curlen-z2+1, z2-1);
} else
memcpy(buffer, data, curlen);
}
char * stb_shorten_path_readable(char *path, int len)
{
static char buffer[1024];
int n = strlen(path),n1,n2,r1,r2;
char *s;
if (n <= len) return path;
if (len > 1024) return path;
s = stb_strrchr2(path, '/', '\\');
if (s) {
n1 = s - path + 1;
n2 = n - n1;
++s;
} else {
n1 = 0;
n2 = n;
s = path;
}
// now we need to reduce r1 and r2 so that they fit in len
if (n1 < len>>1) {
r1 = n1;
r2 = len - r1;
} else if (n2 < len >> 1) {
r2 = n2;
r1 = len - r2;
} else {
r1 = n1 * len / n;
r2 = n2 * len / n;
if (r1 < len>>2) r1 = len>>2, r2 = len-r1;
if (r2 < len>>2) r2 = len>>2, r1 = len-r2;
}
assert(r1 <= n1 && r2 <= n2);
if (n1)
stb__add_section(buffer, path, n1, r1);
stb__add_section(buffer+r1, s, n2, r2);
buffer[len] = 0;
return buffer;
}
static char *stb__splitpath_raw(char *buffer, char *path, int flag)
{
int len=0,x,y, n = (int) strlen(path), f1,f2;
char *s = stb_strrchr2(path, '/', '\\');
char *t = strrchr(path, '.');
if (s && t && t < s) t = NULL;
if (s) ++s;
if (flag == STB_EXT_NO_PERIOD)
flag |= STB_EXT;
if (!(flag & (STB_PATH | STB_FILE | STB_EXT))) return NULL;
f1 = s == NULL ? 0 : s-path; // start of filename
f2 = t == NULL ? n : t-path; // just past end of filename
if (flag & STB_PATH) {
x = 0; if (f1 == 0 && flag == STB_PATH) len=2;
} else if (flag & STB_FILE) {
x = f1;
} else {
x = f2;
if (flag & STB_EXT_NO_PERIOD)
if (buffer[x] == '.')
++x;
}
if (flag & STB_EXT)
y = n;
else if (flag & STB_FILE)
y = f2;
else
y = f1;
if (buffer == NULL) {
buffer = (char *) malloc(y-x + len + 1);
if (!buffer) return NULL;
}
if (len) { strcpy(buffer, "./"); return buffer; }
strncpy(buffer, path+x, y-x);
buffer[y-x] = 0;
return buffer;
}
char *stb_splitpath(char *output, char *src, int flag)
{
return stb__splitpath_raw(output, src, flag);
}
char *stb_splitpathdup(char *src, int flag)
{
return stb__splitpath_raw(NULL, src, flag);
}
char *stb_replacedir(char *output, char *src, char *dir)
{
char buffer[4096];
stb_splitpath(buffer, src, STB_FILE | STB_EXT);
if (dir)
sprintf(output, "%s/%s", dir, buffer);
else
strcpy(output, buffer);
return output;
}
char *stb_replaceext(char *output, char *src, char *ext)
{
char buffer[4096];
stb_splitpath(buffer, src, STB_PATH | STB_FILE);
if (ext)
sprintf(output, "%s.%s", buffer, ext[0] == '.' ? ext+1 : ext);
else
strcpy(output, buffer);
return output;
}
#endif
//////////////////////////////////////////////////////////////////////////////
//
// stb_alloc - hierarchical allocator
//
// inspired by http://swapped.cc/halloc
//
//
// When you alloc a given block through stb_alloc, you have these choices:
//
// 1. does it have a parent?
// 2. can it have children?
// 3. can it be freed directly?
// 4. is it transferrable?
// 5. what is its alignment?
//
// Here are interesting combinations of those:
//
// children free transfer alignment
// arena Y Y N n/a
// no-overhead, chunked N N N normal
// string pool alloc N N N 1
// parent-ptr, chunked Y N N normal
// low-overhead, unchunked N Y Y normal
// general purpose alloc Y Y Y normal
//
// Unchunked allocations will probably return 16-aligned pointers. If
// we 16-align the results, we have room for 4 pointers. For smaller
// allocations that allow finer alignment, we can reduce the pointers.
//
// The strategy is that given a pointer, assuming it has a header (only
// the no-overhead allocations have no header), we can determine the
// type of the header fields, and the number of them, by stepping backwards
// through memory and looking at the tags in the bottom bits.
//
// Implementation strategy:
// chunked allocations come from the middle of chunks, and can't
// be freed. thefore they do not need to be on a sibling chain.
// they may need child pointers if they have children.
//
// chunked, with-children
// void *parent;
//
// unchunked, no-children -- reduced storage
// void *next_sibling;
// void *prev_sibling_nextp;
//
// unchunked, general
// void *first_child;
// void *next_sibling;
// void *prev_sibling_nextp;
// void *chunks;
//
// so, if we code each of these fields with different bit patterns
// (actually same one for next/prev/child), then we can identify which
// each one is from the last field.
STB_EXTERN void stb_free(void *p);
STB_EXTERN void *stb_malloc_global(size_t size);
STB_EXTERN void *stb_malloc(void *context, size_t size);
STB_EXTERN void *stb_malloc_nofree(void *context, size_t size);
STB_EXTERN void *stb_malloc_leaf(void *context, size_t size);
STB_EXTERN void *stb_malloc_raw(void *context, size_t size);
STB_EXTERN void *stb_realloc(void *ptr, size_t newsize);
STB_EXTERN void stb_reassign(void *new_context, void *ptr);
STB_EXTERN void stb_malloc_validate(void *p, void *parent);
extern int stb_alloc_chunk_size ;
extern int stb_alloc_count_free ;
extern int stb_alloc_count_alloc;
extern int stb_alloc_alignment ;
#ifdef STB_DEFINE
int stb_alloc_chunk_size = 65536;
int stb_alloc_count_free = 0;
int stb_alloc_count_alloc = 0;
int stb_alloc_alignment = -16;
typedef struct stb__chunk
{
struct stb__chunk *next;
int data_left;
int alloc;
} stb__chunk;
typedef struct
{
void * next;
void ** prevn;
} stb__nochildren;
typedef struct
{
void ** prevn;
void * child;
void * next;
stb__chunk *chunks;
} stb__alloc;
typedef struct
{
stb__alloc *parent;
} stb__chunked;
#define STB__PARENT 1
#define STB__CHUNKS 2
typedef enum
{
STB__nochildren = 0,
STB__chunked = STB__PARENT,
STB__alloc = STB__CHUNKS,
STB__chunk_raw = 4,
} stb__alloc_type;
// these functions set the bottom bits of a pointer efficiently
#define STB__DECODE(x,v) ((void *) ((char *) (x) - (v)))
#define STB__ENCODE(x,v) ((void *) ((char *) (x) + (v)))
#define stb__parent(z) (stb__alloc *) STB__DECODE((z)->parent, STB__PARENT)
#define stb__chunks(z) (stb__chunk *) STB__DECODE((z)->chunks, STB__CHUNKS)
#define stb__setparent(z,p) (z)->parent = (stb__alloc *) STB__ENCODE((p), STB__PARENT)
#define stb__setchunks(z,c) (z)->chunks = (stb__chunk *) STB__ENCODE((c), STB__CHUNKS)
static stb__alloc stb__alloc_global =
{
NULL,
NULL,
NULL,
(stb__chunk *) STB__ENCODE(NULL, STB__CHUNKS)
};
static stb__alloc_type stb__identify(void *p)
{
void **q = (void **) p;
return (stb__alloc_type) ((stb_uinta) q[-1] & 3);
}
static void *** stb__prevn(void *p)
{
if (stb__identify(p) == STB__alloc) {
stb__alloc *s = (stb__alloc *) p - 1;
return &s->prevn;
} else {
stb__nochildren *s = (stb__nochildren *) p - 1;
return &s->prevn;
}
}
void stb_free(void *p)
{
if (p == NULL) return;
// count frees so that unit tests can see what's happening
++stb_alloc_count_free;
switch(stb__identify(p)) {
case STB__chunked:
// freeing a chunked-block with children does nothing;
// they only get freed when the parent does
// surely this is wrong, and it should free them immediately?
// otherwise how are they getting put on the right chain?
return;
case STB__nochildren: {
stb__nochildren *s = (stb__nochildren *) p - 1;
// unlink from sibling chain
*(s->prevn) = s->next;
if (s->next)
*stb__prevn(s->next) = s->prevn;
free(s);
return;
}
case STB__alloc: {
stb__alloc *s = (stb__alloc *) p - 1;
stb__chunk *c, *n;
void *q;
// unlink from sibling chain, if any
*(s->prevn) = s->next;
if (s->next)
*stb__prevn(s->next) = s->prevn;
// first free chunks
c = (stb__chunk *) stb__chunks(s);
while (c != NULL) {
n = c->next;
stb_alloc_count_free += c->alloc;
free(c);
c = n;
}
// validating
stb__setchunks(s,NULL);
s->prevn = NULL;
s->next = NULL;
// now free children
while ((q = s->child) != NULL) {
stb_free(q);
}
// now free self
free(s);
return;
}
default:
assert(0); /* NOTREACHED */
}
}
void stb_malloc_validate(void *p, void *parent)
{
if (p == NULL) return;
switch(stb__identify(p)) {
case STB__chunked:
return;
case STB__nochildren: {
stb__nochildren *n = (stb__nochildren *) p - 1;
if (n->prevn)
assert(*n->prevn == p);
if (n->next) {
assert(*stb__prevn(n->next) == &n->next);
stb_malloc_validate(n, parent);
}
return;
}
case STB__alloc: {
stb__alloc *s = (stb__alloc *) p - 1;
if (s->prevn)
assert(*s->prevn == p);
if (s->child) {
assert(*stb__prevn(s->child) == &s->child);
stb_malloc_validate(s->child, p);
}
if (s->next) {
assert(*stb__prevn(s->next) == &s->next);
stb_malloc_validate(s->next, parent);
}
return;
}
default:
assert(0); /* NOTREACHED */
}
}
static void * stb__try_chunk(stb__chunk *c, int size, int align, int pre_align)
{
char *memblock = (char *) (c+1), *q;
stb_inta iq;
int start_offset;
// we going to allocate at the end of the chunk, not the start. confusing,
// but it means we don't need both a 'limit' and a 'cur', just a 'cur'.
// the block ends at: p + c->data_left
// then we move back by size
start_offset = c->data_left - size;
// now we need to check the alignment of that
q = memblock + start_offset;
iq = (stb_inta) q;
assert(sizeof(q) == sizeof(iq));
// suppose align = 2
// then we need to retreat iq far enough that (iq & (2-1)) == 0
// to get (iq & (align-1)) = 0 requires subtracting (iq & (align-1))
start_offset -= iq & (align-1);
assert(((stb_uinta) (memblock+start_offset) & (align-1)) == 0);
// now, if that + pre_align works, go for it!
start_offset -= pre_align;
if (start_offset >= 0) {
c->data_left = start_offset;
return memblock + start_offset;
}
return NULL;
}
static void stb__sort_chunks(stb__alloc *src)
{
// of the first two chunks, put the chunk with more data left in it first
stb__chunk *c = stb__chunks(src), *d;
if (c == NULL) return;
d = c->next;
if (d == NULL) return;
if (c->data_left > d->data_left) return;
c->next = d->next;
d->next = c;
stb__setchunks(src, d);
}
static void * stb__alloc_chunk(stb__alloc *src, int size, int align, int pre_align)
{
void *p;
stb__chunk *c = stb__chunks(src);
if (c && size <= stb_alloc_chunk_size) {
p = stb__try_chunk(c, size, align, pre_align);
if (p) { ++c->alloc; return p; }
// try a second chunk to reduce wastage
if (c->next) {
p = stb__try_chunk(c->next, size, align, pre_align);
if (p) { ++c->alloc; return p; }
// put the bigger chunk first, since the second will get buried
// the upshot of this is that, until it gets allocated from, chunk #2
// is always the largest remaining chunk. (could formalize
// this with a heap!)
stb__sort_chunks(src);
c = stb__chunks(src);
}
}
// allocate a new chunk
{
stb__chunk *n;
int chunk_size = stb_alloc_chunk_size;
// we're going to allocate a new chunk to put this in
if (size > chunk_size)
chunk_size = size;
assert(sizeof(*n) + pre_align <= 16);
// loop trying to allocate a large enough chunk
// the loop is because the alignment may cause problems if it's big...
// and we don't know what our chunk alignment is going to be
while (1) {
n = (stb__chunk *) malloc(16 + chunk_size);
if (n == NULL) return NULL;
n->data_left = chunk_size - sizeof(*n);
p = stb__try_chunk(n, size, align, pre_align);
if (p != NULL) {
n->next = c;
stb__setchunks(src, n);
// if we just used up the whole block immediately,
// move the following chunk up
n->alloc = 1;
if (size == chunk_size)
stb__sort_chunks(src);
return p;
}
free(n);
chunk_size += 16+align;
}
}
}
static stb__alloc * stb__get_context(void *context)
{
if (context == NULL) {
return &stb__alloc_global;
} else {
int u = stb__identify(context);
// if context is chunked, grab parent
if (u == STB__chunked) {
stb__chunked *s = (stb__chunked *) context - 1;
return stb__parent(s);
} else {
return (stb__alloc *) context - 1;
}
}
}
static void stb__insert_alloc(stb__alloc *src, stb__alloc *s)
{
s->prevn = &src->child;
s->next = src->child;
src->child = s+1;
if (s->next)
*stb__prevn(s->next) = &s->next;
}
static void stb__insert_nochild(stb__alloc *src, stb__nochildren *s)
{
s->prevn = &src->child;
s->next = src->child;
src->child = s+1;
if (s->next)
*stb__prevn(s->next) = &s->next;
}
static void * malloc_base(void *context, size_t size, stb__alloc_type t, int align)
{
void *p;
stb__alloc *src = stb__get_context(context);
if (align <= 0) {
// compute worst-case C packed alignment
// e.g. a 24-byte struct is 8-aligned
int align_proposed = 1 << stb_lowbit8(size);
if (align_proposed < 0)
align_proposed = 4;
if (align_proposed == 0) {
if (size == 0)
align_proposed = 1;
else
align_proposed = 256;
}
// a negative alignment means 'don't align any larger
// than this'; so -16 means we align 1,2,4,8, or 16
if (align < 0) {
if (align_proposed > -align)
align_proposed = -align;
}
align = align_proposed;
}
assert(stb_is_pow2(align));
// don't cause misalignment when allocating nochildren
if (t == STB__nochildren && align > 8)
t = STB__alloc;
switch (t) {
case STB__alloc: {
stb__alloc *s = (stb__alloc *) malloc(size + sizeof(*s));
if (s == NULL) return NULL;
p = s+1;
s->child = NULL;
stb__insert_alloc(src, s);
stb__setchunks(s,NULL);
break;
}
case STB__nochildren: {
stb__nochildren *s = (stb__nochildren *) malloc(size + sizeof(*s));
if (s == NULL) return NULL;
p = s+1;
stb__insert_nochild(src, s);
break;
}
case STB__chunk_raw: {
p = stb__alloc_chunk(src, size, align, 0);
if (p == NULL) return NULL;
break;
}
case STB__chunked: {
stb__chunked *s;
if (align < sizeof(stb_uintptr)) align = sizeof(stb_uintptr);
s = (stb__chunked *) stb__alloc_chunk(src, size, align, sizeof(*s));
if (s == NULL) return NULL;
stb__setparent(s, src);
p = s+1;
break;
}
default: p = NULL; assert(0); /* NOTREACHED */
}
++stb_alloc_count_alloc;
return p;
}
void *stb_malloc_global(size_t size)
{
return malloc_base(NULL, size, STB__alloc, stb_alloc_alignment);
}
void *stb_malloc(void *context, size_t size)
{
return malloc_base(context, size, STB__alloc, stb_alloc_alignment);
}
void *stb_malloc_nofree(void *context, size_t size)
{
return malloc_base(context, size, STB__chunked, stb_alloc_alignment);
}
void *stb_malloc_leaf(void *context, size_t size)
{
return malloc_base(context, size, STB__nochildren, stb_alloc_alignment);
}
void *stb_malloc_raw(void *context, size_t size)
{
return malloc_base(context, size, STB__chunk_raw, stb_alloc_alignment);
}
char *stb_malloc_string(void *context, size_t size)
{
return (char *) malloc_base(context, size, STB__chunk_raw, 1);
}
void *stb_realloc(void *ptr, size_t newsize)
{
stb__alloc_type t;
if (ptr == NULL) return stb_malloc(NULL, newsize);
if (newsize == 0) { stb_free(ptr); return NULL; }
t = stb__identify(ptr);
assert(t == STB__alloc || t == STB__nochildren);
if (t == STB__alloc) {
stb__alloc *s = (stb__alloc *) ptr - 1;
s = (stb__alloc *) realloc(s, newsize + sizeof(*s));
if (s == NULL) return NULL;
ptr = s+1;
// update pointers
(*s->prevn) = ptr;
if (s->next)
*stb__prevn(s->next) = &s->next;
if (s->child)
*stb__prevn(s->child) = &s->child;
return ptr;
} else {
stb__nochildren *s = (stb__nochildren *) ptr - 1;
s = (stb__nochildren *) realloc(ptr, newsize + sizeof(s));
if (s == NULL) return NULL;
// update pointers
(*s->prevn) = s+1;
if (s->next)
*stb__prevn(s->next) = &s->next;
return s+1;
}
}
void *stb_realloc_c(void *context, void *ptr, size_t newsize)
{
if (ptr == NULL) return stb_malloc(context, newsize);
if (newsize == 0) { stb_free(ptr); return NULL; }
// @TODO: verify you haven't changed contexts
return stb_realloc(ptr, newsize);
}
void stb_reassign(void *new_context, void *ptr)
{
stb__alloc *src = stb__get_context(new_context);
stb__alloc_type t = stb__identify(ptr);
assert(t == STB__alloc || t == STB__nochildren);
if (t == STB__alloc) {
stb__alloc *s = (stb__alloc *) ptr - 1;
// unlink from old
*(s->prevn) = s->next;
if (s->next)
*stb__prevn(s->next) = s->prevn;
stb__insert_alloc(src, s);
} else {
stb__nochildren *s = (stb__nochildren *) ptr - 1;
// unlink from old
*(s->prevn) = s->next;
if (s->next)
*stb__prevn(s->next) = s->prevn;
stb__insert_nochild(src, s);
}
}
#endif
//////////////////////////////////////////////////////////////////////////////
//
// stb_arr
//
// An stb_arr is directly useable as a pointer (use the actual type in your
// definition), but when it resizes, it returns a new pointer and you can't
// use the old one, so you have to be careful to copy-in-out as necessary.
//
// Use a NULL pointer as a 0-length array.
//
// float *my_array = NULL, *temp;
//
// // add elements on the end one at a time
// stb_arr_push(my_array, 0.0f);
// stb_arr_push(my_array, 1.0f);
// stb_arr_push(my_array, 2.0f);
//
// assert(my_array[1] == 2.0f);
//
// // add an uninitialized element at the end, then assign it
// *stb_arr_add(my_array) = 3.0f;
//
// // add three uninitialized elements at the end
// temp = stb_arr_addn(my_array,3);
// temp[0] = 4.0f;
// temp[1] = 5.0f;
// temp[2] = 6.0f;
//
// assert(my_array[5] == 5.0f);
//
// // remove the last one
// stb_arr_pop(my_array);
//
// assert(stb_arr_len(my_array) == 6);
#ifdef STB_MALLOC_WRAPPER
#define STB__PARAMS , char *file, int line
#define STB__ARGS , file, line
#else
#define STB__PARAMS
#define STB__ARGS
#endif
// calling this function allocates an empty stb_arr attached to p
// (whereas NULL isn't attached to anything)
STB_EXTERN void stb_arr_malloc(void **target, void *context);
// call this function with a non-NULL value to have all successive
// stbs that are created be attached to the associated parent. Note
// that once a given stb_arr is non-empty, it stays attached to its
// current parent, even if you call this function again.
// it turns the previous value, so you can restore it
STB_EXTERN void* stb_arr_malloc_parent(void *p);
// simple functions written on top of other functions
#define stb_arr_empty(a) ( stb_arr_len(a) == 0 )
#define stb_arr_add(a) ( stb_arr_addn((a),1) )
#define stb_arr_push(a,v) ( *stb_arr_add(a)=(v) )
typedef struct
{
int len, limit;
int stb_malloc;
unsigned int signature;
} stb__arr;
#define stb_arr_signature 0x51bada7b // ends with 0123 in decimal
// access the header block stored before the data
#define stb_arrhead(a) /*lint --e(826)*/ (((stb__arr *) (a)) - 1)
#define stb_arrhead2(a) /*lint --e(826)*/ (((stb__arr *) (a)) - 1)
#ifdef STB_DEBUG
#define stb_arr_check(a) assert(!a || stb_arrhead(a)->signature == stb_arr_signature)
#define stb_arr_check2(a) assert(!a || stb_arrhead2(a)->signature == stb_arr_signature)
#else
#define stb_arr_check(a) ((void) 0)
#define stb_arr_check2(a) ((void) 0)
#endif
// ARRAY LENGTH
// get the array length; special case if pointer is NULL
#define stb_arr_len(a) (a ? stb_arrhead(a)->len : 0)
#define stb_arr_len2(a) ((stb__arr *) (a) ? stb_arrhead2(a)->len : 0)
#define stb_arr_lastn(a) (stb_arr_len(a)-1)
// check whether a given index is valid -- tests 0 <= i < stb_arr_len(a)
#define stb_arr_valid(a,i) (a ? (int) (i) < stb_arrhead(a)->len : 0)
// change the array length so is is exactly N entries long, creating
// uninitialized entries as needed
#define stb_arr_setlen(a,n) \
(stb__arr_setlen((void **) &(a), sizeof(a[0]), (n)))
// change the array length so that N is a valid index (that is, so
// it is at least N entries long), creating uninitialized entries as needed
#define stb_arr_makevalid(a,n) \
(stb_arr_len(a) < (n)+1 ? stb_arr_setlen(a,(n)+1),(a) : (a))
// remove the last element of the array, returning it
#define stb_arr_pop(a) ((stb_arr_check(a), (a))[--stb_arrhead(a)->len])
// access the last element in the array
#define stb_arr_last(a) ((stb_arr_check(a), (a))[stb_arr_len(a)-1])
// is iterator at end of list?
#define stb_arr_end(a,i) ((i) >= &(a)[stb_arr_len(a)])
// (internal) change the allocated length of the array
#define stb_arr__grow(a,n) (stb_arr_check(a), stb_arrhead(a)->len += (n))
// add N new unitialized elements to the end of the array
#define stb_arr__addn(a,n) /*lint --e(826)*/ \
((stb_arr_len(a)+(n) > stb_arrcurmax(a)) \
? (stb__arr_addlen((void **) &(a),sizeof(*a),(n)),0) \
: ((stb_arr__grow(a,n), 0)))
// add N new unitialized elements to the end of the array, and return
// a pointer to the first new one
#define stb_arr_addn(a,n) (stb_arr__addn((a),n),(a)+stb_arr_len(a)-(n))
// add N new uninitialized elements starting at index 'i'
#define stb_arr_insertn(a,i,n) (stb__arr_insertn((void **) &(a), sizeof(*a), i, n))
// insert an element at i
#define stb_arr_insert(a,i,v) (stb__arr_insertn((void **) &(a), sizeof(*a), i, 1), ((a)[i] = v))
// delete N elements from the middle starting at index 'i'
#define stb_arr_deleten(a,i,n) (stb__arr_deleten((void **) &(a), sizeof(*a), i, n))
// delete the i'th element
#define stb_arr_delete(a,i) stb_arr_deleten(a,i,1)
// delete the i'th element, swapping down from the end
#define stb_arr_fastdelete(a,i) \
(stb_swap(&a[i], &a[stb_arrhead(a)->len-1], sizeof(*a)), stb_arr_pop(a))
// ARRAY STORAGE
// get the array maximum storage; special case if NULL
#define stb_arrcurmax(a) (a ? stb_arrhead(a)->limit : 0)
#define stb_arrcurmax2(a) (a ? stb_arrhead2(a)->limit : 0)
// set the maxlength of the array to n in anticipation of further growth
#define stb_arr_setsize(a,n) (stb_arr_check(a), stb__arr_setsize((void **) &(a),sizeof((a)[0]),n))
// make sure maxlength is large enough for at least N new allocations
#define stb_arr_atleast(a,n) (stb_arr_len(a)+(n) > stb_arrcurmax(a) \
? stb_arr_setsize((a), (n)) : 0)
// make a copy of a given array (copies contents via 'memcpy'!)
#define stb_arr_copy(a) stb__arr_copy(a, sizeof((a)[0]))
// compute the storage needed to store all the elements of the array
#define stb_arr_storage(a) (stb_arr_len(a) * sizeof((a)[0]))
#define stb_arr_for(v,arr) for((v)=(arr); (v) < (arr)+stb_arr_len(arr); ++(v))
// IMPLEMENTATION
STB_EXTERN void stb_arr_free_(void **p);
STB_EXTERN void *stb__arr_copy_(void *p, int elem_size);
STB_EXTERN void stb__arr_setsize_(void **p, int size, int limit STB__PARAMS);
STB_EXTERN void stb__arr_setlen_(void **p, int size, int newlen STB__PARAMS);
STB_EXTERN void stb__arr_addlen_(void **p, int size, int addlen STB__PARAMS);
STB_EXTERN void stb__arr_deleten_(void **p, int size, int loc, int n STB__PARAMS);
STB_EXTERN void stb__arr_insertn_(void **p, int size, int loc, int n STB__PARAMS);
#define stb_arr_free(p) stb_arr_free_((void **) &(p))
#define stb__arr_copy stb__arr_copy_
#ifndef STB_MALLOC_WRAPPER
#define stb__arr_setsize stb__arr_setsize_
#define stb__arr_setlen stb__arr_setlen_
#define stb__arr_addlen stb__arr_addlen_
#define stb__arr_deleten stb__arr_deleten_
#define stb__arr_insertn stb__arr_insertn_
#else
#define stb__arr_addlen(p,s,n) stb__arr_addlen_(p,s,n,__FILE__,__LINE__)
#define stb__arr_setlen(p,s,n) stb__arr_setlen_(p,s,n,__FILE__,__LINE__)
#define stb__arr_setsize(p,s,n) stb__arr_setsize_(p,s,n,__FILE__,__LINE__)
#define stb__arr_deleten(p,s,i,n) stb__arr_deleten_(p,s,i,n,__FILE__,__LINE__)
#define stb__arr_insertn(p,s,i,n) stb__arr_insertn_(p,s,i,n,__FILE__,__LINE__)
#endif
#ifdef STB_DEFINE
static void *stb__arr_context;
void *stb_arr_malloc_parent(void *p)
{
void *q = stb__arr_context;
stb__arr_context = p;
return q;
}
void stb_arr_malloc(void **target, void *context)
{
stb__arr *q = (stb__arr *) stb_malloc(context, sizeof(*q));
q->len = q->limit = 0;
q->stb_malloc = 1;
q->signature = stb_arr_signature;
*target = (void *) (q+1);
}
static void * stb__arr_malloc(int size)
{
if (stb__arr_context)
return stb_malloc(stb__arr_context, size);
return malloc(size);
}
void * stb__arr_copy_(void *p, int elem_size)
{
stb__arr *q;
if (p == NULL) return p;
q = (stb__arr *) stb__arr_malloc(sizeof(*q) + elem_size * stb_arrhead2(p)->limit);
stb_arr_check2(p);
memcpy(q, stb_arrhead2(p), sizeof(*q) + elem_size * stb_arrhead2(p)->len);
q->stb_malloc = !!stb__arr_context;
return q+1;
}
void stb_arr_free_(void **pp)
{
void *p = *pp;
stb_arr_check2(p);
if (p) {
stb__arr *q = stb_arrhead2(p);
if (q->stb_malloc)
stb_free(q);
else
free(q);
}
*pp = NULL;
}
static void stb__arrsize_(void **pp, int size, int limit, int len STB__PARAMS)
{
void *p = *pp;
stb__arr *a;
stb_arr_check2(p);
if (p == NULL) {
if (len == 0 && size == 0) return;
a = (stb__arr *) stb__arr_malloc(sizeof(*a) + size*limit);
a->limit = limit;
a->len = len;
a->stb_malloc = !!stb__arr_context;
a->signature = stb_arr_signature;
} else {
a = stb_arrhead2(p);
a->len = len;
if (a->limit < limit) {
void *p;
if (a->limit >= 4 && limit < a->limit * 2)
limit = a->limit * 2;
if (a->stb_malloc)
p = stb_realloc(a, sizeof(*a) + limit*size);
else
#ifdef STB_MALLOC_WRAPPER
p = stb__realloc(a, sizeof(*a) + limit*size, file, line);
#else
p = realloc(a, sizeof(*a) + limit*size);
#endif
if (p) {
a = (stb__arr *) p;
a->limit = limit;
} else {
// throw an error!
}
}
}
a->len = stb_min(a->len, a->limit);
*pp = a+1;
}
void stb__arr_setsize_(void **pp, int size, int limit STB__PARAMS)
{
void *p = *pp;
stb_arr_check2(p);
stb__arrsize_(pp, size, limit, stb_arr_len2(p) STB__ARGS);
}
void stb__arr_setlen_(void **pp, int size, int newlen STB__PARAMS)
{
void *p = *pp;
stb_arr_check2(p);
if (stb_arrcurmax2(p) < newlen || p == NULL) {
stb__arrsize_(pp, size, newlen, newlen STB__ARGS);
} else {
stb_arrhead2(p)->len = newlen;
}
}
void stb__arr_addlen_(void **p, int size, int addlen STB__PARAMS)
{
stb__arr_setlen_(p, size, stb_arr_len2(*p) + addlen STB__ARGS);
}
void stb__arr_insertn_(void **pp, int size, int i, int n STB__PARAMS)
{
void *p = *pp;
if (n) {
int z;
if (p == NULL) {
stb__arr_addlen_(pp, size, n STB__ARGS);
return;
}
z = stb_arr_len2(p);
stb__arr_addlen_(&p, size, n STB__ARGS);
memmove((char *) p + (i+n)*size, (char *) p + i*size, size * (z-i));
}
*pp = p;
}
void stb__arr_deleten_(void **pp, int size, int i, int n STB__PARAMS)
{
void *p = *pp;
if (n) {
memmove((char *) p + i*size, (char *) p + (i+n)*size, size * (stb_arr_len2(p)-(i+n)));
stb_arrhead2(p)->len -= n;
}
*pp = p;
}
#endif
//////////////////////////////////////////////////////////////////////////////
//
// Hashing
//
// typical use for this is to make a power-of-two hash table.
//
// let N = size of table (2^n)
// let H = stb_hash(str)
// let S = stb_rehash(H) | 1
//
// then hash probe sequence P(i) for i=0..N-1
// P(i) = (H + S*i) & (N-1)
//
// the idea is that H has 32 bits of hash information, but the
// table has only, say, 2^20 entries so only uses 20 of the bits.
// then by rehashing the original H we get 2^12 different probe
// sequences for a given initial probe location. (So it's optimal
// for 64K tables and its optimality decreases past that.)
//
// ok, so I've added something that generates _two separate_
// 32-bit hashes simultaneously which should scale better to
// very large tables.
STB_EXTERN unsigned int stb_hash(char *str);
STB_EXTERN unsigned int stb_hashptr(void *p);
STB_EXTERN unsigned int stb_hashlen(char *str, int len);
STB_EXTERN unsigned int stb_rehash_improved(unsigned int v);
STB_EXTERN unsigned int stb_hash_fast(void *p, int len);
STB_EXTERN unsigned int stb_hash2(char *str, unsigned int *hash2_ptr);
STB_EXTERN unsigned int stb_hash_number(unsigned int hash);
#define stb_rehash(x) ((x) + ((x) >> 6) + ((x) >> 19))
#ifdef STB_DEFINE
unsigned int stb_hash(char *str)
{
unsigned int hash = 0;
while (*str)
hash = (hash << 7) + (hash >> 25) + *str++;
return hash + (hash >> 16);
}
unsigned int stb_hashlen(char *str, int len)
{
unsigned int hash = 0;
while (len-- > 0 && *str)
hash = (hash << 7) + (hash >> 25) + *str++;
return hash + (hash >> 16);
}
unsigned int stb_hashptr(void *p)
{
unsigned int x = (unsigned int) p;
// typically lacking in low bits and high bits
x = stb_rehash(x);
x += x << 16;
// pearson's shuffle
x ^= x << 3;
x += x >> 5;
x ^= x << 2;
x += x >> 15;
x ^= x << 10;
return stb_rehash(x);
}
unsigned int stb_rehash_improved(unsigned int v)
{
return stb_hashptr((void *)(size_t) v);
}
unsigned int stb_hash2(char *str, unsigned int *hash2_ptr)
{
unsigned int hash1 = 0x3141592c;
unsigned int hash2 = 0x77f044ed;
while (*str) {
hash1 = (hash1 << 7) + (hash1 >> 25) + *str;
hash2 = (hash2 << 11) + (hash2 >> 21) + *str;
++str;
}
*hash2_ptr = hash2 + (hash1 >> 16);
return hash1 + (hash2 >> 16);
}
// Paul Hsieh hash
#define stb__get16_slow(p) ((p)[0] + ((p)[1] << 8))
#if defined(_MSC_VER)
#define stb__get16(p) (*((unsigned short *) (p)))
#else
#define stb__get16(p) stb__get16_slow(p)
#endif
unsigned int stb_hash_fast(void *p, int len)
{
unsigned char *q = (unsigned char *) p;
unsigned int hash = len;
if (len <= 0 || q == NULL) return 0;
/* Main loop */
if (((int) q & 1) == 0) {
for (;len > 3; len -= 4) {
unsigned int val;
hash += stb__get16(q);
val = (stb__get16(q+2) << 11);
hash = (hash << 16) ^ hash ^ val;
q += 4;
hash += hash >> 11;
}
} else {
for (;len > 3; len -= 4) {
unsigned int val;
hash += stb__get16_slow(q);
val = (stb__get16_slow(q+2) << 11);
hash = (hash << 16) ^ hash ^ val;
q += 4;
hash += hash >> 11;
}
}
/* Handle end cases */
switch (len) {
case 3: hash += stb__get16_slow(q);
hash ^= hash << 16;
hash ^= q[2] << 18;
hash += hash >> 11;
break;
case 2: hash += stb__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;
}
unsigned int stb_hash_number(unsigned int hash)
{
hash ^= hash << 3;
hash += hash >> 5;
hash ^= hash << 4;
hash += hash >> 17;
hash ^= hash << 25;
hash += hash >> 6;
return hash;
}
#endif
//////////////////////////////////////////////////////////////////////////////
//
// Perfect hashing for ints/pointers
//
// This is mainly useful for making faster pointer-indexed tables
// that don't change frequently. E.g. for stb_ischar().
//
typedef struct
{
stb_uint32 addend;
stb_uint multiplicand;
stb_uint b_mask;
stb_uint8 small_bmap[16];
stb_uint16 *large_bmap;
stb_uint table_mask;
stb_uint32 *table;
} stb_perfect;
STB_EXTERN int stb_perfect_create(stb_perfect *,unsigned int*,int n);
STB_EXTERN void stb_perfect_destroy(stb_perfect *);
STB_EXTERN int stb_perfect_hash(stb_perfect *, unsigned int x);
extern int stb_perfect_hash_max_failures;
#ifdef STB_DEFINE
int stb_perfect_hash_max_failures;
int stb_perfect_hash(stb_perfect *p, unsigned int x)
{
stb_uint m = x * p->multiplicand;
stb_uint y = x >> 16;
stb_uint bv = (m >> 24) + y;
stb_uint av = (m + y) >> 12;
if (p->table == NULL) return -1; // uninitialized table fails
bv &= p->b_mask;
av &= p->table_mask;
if (p->large_bmap)
av ^= p->large_bmap[bv];
else
av ^= p->small_bmap[bv];
return p->table[av] == x ? av : -1;
}
static void stb__perfect_prehash(stb_perfect *p, stb_uint x, stb_uint16 *a, stb_uint16 *b)
{
stb_uint m = x * p->multiplicand;
stb_uint y = x >> 16;
stb_uint bv = (m >> 24) + y;
stb_uint av = (m + y) >> 12;
bv &= p->b_mask;
av &= p->table_mask;
*b = bv;
*a = av;
}
static unsigned long stb__perfect_rand(void)
{
static unsigned long stb__rand;
stb__rand = stb__rand * 2147001325 + 715136305;
return 0x31415926 ^ ((stb__rand >> 16) + (stb__rand << 16));
}
typedef struct {
unsigned short count;
unsigned short b;
unsigned short map;
unsigned short *entries;
} stb__slot;
static int stb__slot_compare(const void *p, const void *q)
{
stb__slot *a = (stb__slot *) p;
stb__slot *b = (stb__slot *) q;
return a->count > b->count ? -1 : a->count < b->count; // sort large to small
}
int stb_perfect_create(stb_perfect *p, unsigned int *v, int n)
{
unsigned int buffer1[64], buffer2[64], buffer3[64], buffer4[64], buffer5[32];
unsigned short *as = (unsigned short *) stb_temp(buffer1, sizeof(*v)*n);
unsigned short *bs = (unsigned short *) stb_temp(buffer2, sizeof(*v)*n);
unsigned short *entries = (unsigned short *) stb_temp(buffer4, sizeof(*entries) * n);
int size = 1 << stb_log2_ceil(n), bsize=8;
int failure = 0,i,j,k;
assert(n <= 32768);
p->large_bmap = NULL;
for(;;) {
stb__slot *bcount = (stb__slot *) stb_temp(buffer3, sizeof(*bcount) * bsize);
unsigned short *bloc = (unsigned short *) stb_temp(buffer5, sizeof(*bloc) * bsize);
unsigned short *e;
int bad=0;
p->addend = stb__perfect_rand();
p->multiplicand = stb__perfect_rand() | 1;
p->table_mask = size-1;
p->b_mask = bsize-1;
p->table = (stb_uint32 *) malloc(size * sizeof(*p->table));
for (i=0; i < bsize; ++i) {
bcount[i].b = i;
bcount[i].count = 0;
bcount[i].map = 0;
}
for (i=0; i < n; ++i) {
stb__perfect_prehash(p, v[i], as+i, bs+i);
++bcount[bs[i]].count;
}
qsort(bcount, bsize, sizeof(*bcount), stb__slot_compare);
e = entries; // now setup up their entries index
for (i=0; i < bsize; ++i) {
bcount[i].entries = e;
e += bcount[i].count;
bcount[i].count = 0;
bloc[bcount[i].b] = i;
}
// now fill them out
for (i=0; i < n; ++i) {
int b = bs[i];
int w = bloc[b];
bcount[w].entries[bcount[w].count++] = i;
}
stb_tempfree(buffer5,bloc);
// verify
for (i=0; i < bsize; ++i)
for (j=0; j < bcount[i].count; ++j)
assert(bs[bcount[i].entries[j]] == bcount[i].b);
memset(p->table, 0, size*sizeof(*p->table));
// check if any b has duplicate a
for (i=0; i < bsize; ++i) {
if (bcount[i].count > 1) {
for (j=0; j < bcount[i].count; ++j) {
if (p->table[as[bcount[i].entries[j]]])
bad = 1;
p->table[as[bcount[i].entries[j]]] = 1;
}
for (j=0; j < bcount[i].count; ++j) {
p->table[as[bcount[i].entries[j]]] = 0;
}
if (bad) break;
}
}
if (!bad) {
// go through the bs and populate the table, first fit
for (i=0; i < bsize; ++i) {
if (bcount[i].count) {
// go through the candidate table[b] values
for (j=0; j < size; ++j) {
// go through the a values and see if they fit
for (k=0; k < bcount[i].count; ++k) {
int a = as[bcount[i].entries[k]];
if (p->table[(a^j)&p->table_mask]) {
break; // fails
}
}
// if succeeded, accept
if (k == bcount[i].count) {
bcount[i].map = j;
for (k=0; k < bcount[i].count; ++k) {
int a = as[bcount[i].entries[k]];
p->table[(a^j)&p->table_mask] = 1;
}
break;
}
}
if (j == size)
break; // no match for i'th entry, so break out in failure
}
}
if (i == bsize) {
// success... fill out map
if (bsize <= 16 && size <= 256) {
p->large_bmap = NULL;
for (i=0; i < bsize; ++i)
p->small_bmap[bcount[i].b] = (stb_uint8) bcount[i].map;
} else {
p->large_bmap = (unsigned short *) malloc(sizeof(*p->large_bmap) * bsize);
for (i=0; i < bsize; ++i)
p->large_bmap[bcount[i].b] = bcount[i].map;
}
// initialize table to v[0], so empty slots will fail
for (i=0; i < size; ++i)
p->table[i] = v[0];
for (i=0; i < n; ++i)
if (p->large_bmap)
p->table[as[i] ^ p->large_bmap[bs[i]]] = v[i];
else
p->table[as[i] ^ p->small_bmap[bs[i]]] = v[i];
// and now validate that none of them collided
for (i=0; i < n; ++i)
assert(stb_perfect_hash(p, v[i]) >= 0);
stb_tempfree(buffer3, bcount);
break;
}
}
free(p->table);
p->table = NULL;
stb_tempfree(buffer3, bcount);
++failure;
if (failure >= 4 && bsize < size) bsize *= 2;
if (failure >= 8 && (failure & 3) == 0 && size < 4*n) {
size *= 2;
bsize *= 2;
}
if (failure == 6) {
// make sure the input data is unique, so we don't infinite loop
unsigned int *data = (unsigned int *) stb_temp(buffer3, n * sizeof(*data));
memcpy(data, v, sizeof(*data) * n);
qsort(data, n, sizeof(*data), stb_intcmp(0));
for (i=1; i < n; ++i) {
if (data[i] == data[i-1])
size = 0; // size is return value, so 0 it
}
stb_tempfree(buffer3, data);
if (!size) break;
}
}
if (failure > stb_perfect_hash_max_failures)
stb_perfect_hash_max_failures = failure;
stb_tempfree(buffer1, as);
stb_tempfree(buffer2, bs);
stb_tempfree(buffer4, entries);
return size;
}
void stb_perfect_destroy(stb_perfect *p)
{
if (p->large_bmap) free(p->large_bmap);
if (p->table ) free(p->table);
p->large_bmap = NULL;
p->table = NULL;
p->b_mask = 0;
p->table_mask = 0;
}
#endif
//////////////////////////////////////////////////////////////////////////////
//
// Perfect hash clients
STB_EXTERN int stb_ischar(char s, char *set);
#ifdef STB_DEFINE
int stb_ischar(char c, char *set)
{
static unsigned char bit[8] = { 1,2,4,8,16,32,64,128 };
static stb_perfect p;
static unsigned char (*tables)[256];
static char ** sets = NULL;
int z = stb_perfect_hash(&p, (int) set);
if (z < 0) {
int i,k,n,j,f;
// special code that means free all existing data
if (set == NULL) {
stb_arr_free(sets);
free(tables);
tables = NULL;
stb_perfect_destroy(&p);
return 0;
}
stb_arr_push(sets, set);
stb_perfect_destroy(&p);
n = stb_perfect_create(&p, (unsigned int *) (char **) sets, stb_arr_len(sets));
assert(n != 0);
k = (n+7) >> 3;
tables = (unsigned char (*)[256]) realloc(tables, sizeof(*tables) * k);
memset(tables, 0, sizeof(*tables) * k);
for (i=0; i < stb_arr_len(sets); ++i) {
k = stb_perfect_hash(&p, (int) sets[i]);
assert(k >= 0);
n = k >> 3;
f = bit[k&7];
for (j=0; !j || sets[i][j]; ++j) {
tables[n][(unsigned char) sets[i][j]] |= f;
}
}
z = stb_perfect_hash(&p, (int) set);
}
return tables[z >> 3][(unsigned char) c] & bit[z & 7];
}
#endif
//////////////////////////////////////////////////////////////////////////////
//
// Instantiated data structures
//
// This is an attempt to implement a templated data structure.
//
// Hash table: call stb_define_hash(TYPE,N,KEY,K1,K2,HASH,VALUE)
// TYPE -- will define a structure type containing the hash table
// N -- the name, will prefix functions named:
// N create
// N destroy
// N get
// N set, N add, N update,
// N remove
// KEY -- the type of the key. 'x == y' must be valid
// K1,K2 -- keys never used by the app, used as flags in the hashtable
// HASH -- a piece of code ending with 'return' that hashes key 'k'
// VALUE -- the type of the value. 'x = y' must be valid
//
// Note that stb_define_hash_base can be used to define more sophisticated
// hash tables, e.g. those that make copies of the key or use special
// comparisons (e.g. strcmp).
#define STB_(prefix,name) stb__##prefix##name
#define STB__(prefix,name) prefix##name
#define STB__use(x) x
#define STB__skip(x)
#define stb_declare_hash(PREFIX,TYPE,N,KEY,VALUE) \
typedef struct stb__st_##TYPE TYPE;\
PREFIX int STB__(N, init)(TYPE *h, int count);\
PREFIX int STB__(N, memory_usage)(TYPE *h);\
PREFIX TYPE * STB__(N, create)(void);\
PREFIX TYPE * STB__(N, copy)(TYPE *h);\
PREFIX void STB__(N, destroy)(TYPE *h);\
PREFIX int STB__(N,get_flag)(TYPE *a, KEY k, VALUE *v);\
PREFIX VALUE STB__(N,get)(TYPE *a, KEY k);\
PREFIX int STB__(N, set)(TYPE *a, KEY k, VALUE v);\
PREFIX int STB__(N, add)(TYPE *a, KEY k, VALUE v);\
PREFIX int STB__(N, update)(TYPE*a,KEY k,VALUE v);\
PREFIX int STB__(N, remove)(TYPE *a, KEY k, VALUE *v);
#define STB_nocopy(x) (x)
#define STB_nodelete(x) 0
#define STB_nofields
#define STB_nonullvalue(x)
#define STB_nullvalue(x) x
#define STB_safecompare(x) x
#define STB_nosafe(x)
#define STB_noprefix
#ifdef __GNUC__
#define STB__nogcc(x)
#else
#define STB__nogcc(x) x
#endif
#define stb_define_hash_base(PREFIX,TYPE,FIELDS,N,NC,LOAD_FACTOR, \
KEY,EMPTY,DEL,COPY,DISPOSE,SAFE, \
VCOMPARE,CCOMPARE,HASH, \
VALUE,HASVNULL,VNULL) \
\
typedef struct \
{ \
KEY k; \
VALUE v; \
} STB_(N,_hashpair); \
\
STB__nogcc( typedef struct stb__st_##TYPE TYPE; ) \
struct stb__st_##TYPE { \
FIELDS \
STB_(N,_hashpair) *table; \
unsigned int mask; \
int count, limit; \
int deleted; \
\
int delete_threshhold; \
int grow_threshhold; \
int shrink_threshhold; \
unsigned char alloced, has_empty, has_del; \
VALUE ev; VALUE dv; \
}; \
\
static unsigned int STB_(N, hash)(KEY k) \
{ \
HASH \
} \
\
PREFIX int STB__(N, init)(TYPE *h, int count) \
{ \
int i; \
if (count < 4) count = 4; \
h->limit = count; \
h->count = 0; \
h->mask = count-1; \
h->deleted = 0; \
h->grow_threshhold = (int) (count * LOAD_FACTOR); \
h->has_empty = h->has_del = 0; \
h->alloced = 0; \
if (count <= 64) \
h->shrink_threshhold = 0; \
else \
h->shrink_threshhold = (int) (count * (LOAD_FACTOR/2.25)); \
h->delete_threshhold = (int) (count * (1-LOAD_FACTOR)/2); \
h->table = (STB_(N,_hashpair)*) malloc(sizeof(h->table[0]) * count); \
if (h->table == NULL) return 0; \
/* ideally this gets turned into a memset32 automatically */ \
for (i=0; i < count; ++i) \
h->table[i].k = EMPTY; \
return 1; \
} \
\
PREFIX int STB__(N, memory_usage)(TYPE *h) \
{ \
return sizeof(*h) + h->limit * sizeof(h->table[0]); \
} \
\
PREFIX TYPE * STB__(N, create)(void) \
{ \
TYPE *h = (TYPE *) malloc(sizeof(*h)); \
if (h) { \
if (STB__(N, init)(h, 16)) \
h->alloced = 1; \
else { free(h); h=NULL; } \
} \
return h; \
} \
\
PREFIX void STB__(N, destroy)(TYPE *a) \
{ \
int i; \
for (i=0; i < a->limit; ++i) \
if (!CCOMPARE(a->table[i].k,EMPTY) && !CCOMPARE(a->table[i].k, DEL)) \
DISPOSE(a->table[i].k); \
free(a->table); \
if (a->alloced) \
free(a); \
} \
\
static void STB_(N, rehash)(TYPE *a, int count); \
\
PREFIX int STB__(N,get_flag)(TYPE *a, KEY k, VALUE *v) \
{ \
unsigned int h = STB_(N, hash)(k); \
unsigned int n = h & a->mask, s; \
if (CCOMPARE(k,EMPTY)){ if (a->has_empty) *v = a->ev; return a->has_empty;}\
if (CCOMPARE(k,DEL)) { if (a->has_del ) *v = a->dv; return a->has_del; }\
if (CCOMPARE(a->table[n].k,EMPTY)) return 0; \
SAFE(if (!CCOMPARE(a->table[n].k,DEL))) \
if (VCOMPARE(a->table[n].k,k)) { *v = a->table[n].v; return 1; } \
s = stb_rehash(h) | 1; \
for(;;) { \
n = (n + s) & a->mask; \
if (CCOMPARE(a->table[n].k,EMPTY)) return 0; \
SAFE(if (CCOMPARE(a->table[n].k,DEL)) continue;) \
if (VCOMPARE(a->table[n].k,k)) \
{ *v = a->table[n].v; return 1; } \
} \
} \
\
HASVNULL( \
PREFIX VALUE STB__(N,get)(TYPE *a, KEY k) \
{ \
VALUE v; \
if (STB__(N,get_flag)(a,k,&v)) return v; \
else return VNULL; \
} \
) \
\
PREFIX int STB__(N,getkey)(TYPE *a, KEY k, KEY *kout) \
{ \
unsigned int h = STB_(N, hash)(k); \
unsigned int n = h & a->mask, s; \
if (CCOMPARE(k,EMPTY)||CCOMPARE(k,DEL)) return 0; \
if (CCOMPARE(a->table[n].k,EMPTY)) return 0; \
SAFE(if (!CCOMPARE(a->table[n].k,DEL))) \
if (VCOMPARE(a->table[n].k,k)) { *kout = a->table[n].k; return 1; } \
s = stb_rehash(h) | 1; \
for(;;) { \
n = (n + s) & a->mask; \
if (CCOMPARE(a->table[n].k,EMPTY)) return 0; \
SAFE(if (CCOMPARE(a->table[n].k,DEL)) continue;) \
if (VCOMPARE(a->table[n].k,k)) \
{ *kout = a->table[n].k; return 1; } \
} \
} \
\
static int STB_(N,addset)(TYPE *a, KEY k, VALUE v, \
int allow_new, int allow_old, int copy) \
{ \
unsigned int h = STB_(N, hash)(k); \
unsigned int n = h & a->mask; \
int b = -1; \
if (CCOMPARE(k,EMPTY)) { \
if (a->has_empty ? allow_old : allow_new) { \
n=a->has_empty; a->ev = v; a->has_empty = 1; return !n; \
} else return 0; \
} \
if (CCOMPARE(k,DEL)) { \
if (a->has_del ? allow_old : allow_new) { \
n=a->has_del; a->dv = v; a->has_del = 1; return !n; \
} else return 0; \
} \
if (!CCOMPARE(a->table[n].k, EMPTY)) { \
unsigned int s; \
if (CCOMPARE(a->table[n].k, DEL)) \
b = n; \
else if (VCOMPARE(a->table[n].k,k)) { \
if (allow_old) \
a->table[n].v = v; \
return !allow_new; \
} \
s = stb_rehash(h) | 1; \
for(;;) { \
n = (n + s) & a->mask; \
if (CCOMPARE(a->table[n].k, EMPTY)) break; \
if (CCOMPARE(a->table[n].k, DEL)) { \
if (b < 0) b = n; \
} else if (VCOMPARE(a->table[n].k,k)) { \
if (allow_old) \
a->table[n].v = v; \
return !allow_new; \
} \
} \
} \
if (!allow_new) return 0; \
if (b < 0) b = n; else --a->deleted; \
a->table[b].k = copy ? COPY(k) : k; \
a->table[b].v = v; \
++a->count; \
if (a->count > a->grow_threshhold) \
STB_(N,rehash)(a, a->limit*2); \
return 1; \
} \
\
PREFIX int STB__(N, set)(TYPE *a, KEY k, VALUE v){return STB_(N,addset)(a,k,v,1,1,1);}\
PREFIX int STB__(N, add)(TYPE *a, KEY k, VALUE v){return STB_(N,addset)(a,k,v,1,0,1);}\
PREFIX int STB__(N, update)(TYPE*a,KEY k,VALUE v){return STB_(N,addset)(a,k,v,0,1,1);}\
\
PREFIX int STB__(N, remove)(TYPE *a, KEY k, VALUE *v) \
{ \
unsigned int h = STB_(N, hash)(k); \
unsigned int n = h & a->mask, s; \
if (CCOMPARE(k,EMPTY)) { if (a->has_empty) { if(v)*v = a->ev; a->has_empty=0; return 1; } return 0; } \
if (CCOMPARE(k,DEL)) { if (a->has_del ) { if(v)*v = a->dv; a->has_del =0; return 1; } return 0; } \
if (CCOMPARE(a->table[n].k,EMPTY)) return 0; \
if (SAFE(CCOMPARE(a->table[n].k,DEL) || ) !VCOMPARE(a->table[n].k,k)) { \
s = stb_rehash(h) | 1; \
for(;;) { \
n = (n + s) & a->mask; \
if (CCOMPARE(a->table[n].k,EMPTY)) return 0; \
SAFE(if (CCOMPARE(a->table[n].k, DEL)) continue;) \
if (VCOMPARE(a->table[n].k,k)) break; \
} \
} \
DISPOSE(a->table[n].k); \
a->table[n].k = DEL; \
--a->count; \
++a->deleted; \
if (v != NULL) \
*v = a->table[n].v; \
if (a->count < a->shrink_threshhold) \
STB_(N, rehash)(a, a->limit >> 1); \
else if (a->deleted > a->delete_threshhold) \
STB_(N, rehash)(a, a->limit); \
return 1; \
} \
\
PREFIX TYPE * STB__(NC, copy)(TYPE *a) \
{ \
int i; \
TYPE *h = (TYPE *) malloc(sizeof(*h)); \
if (!h) return NULL; \
if (!STB__(N, init)(h, a->limit)) { free(h); return NULL; } \
h->count = a->count; \
h->deleted = a->deleted; \
h->alloced = 1; \
h->ev = a->ev; h->dv = a->dv; \
h->has_empty = a->has_empty; h->has_del = a->has_del; \
memcpy(h->table, a->table, h->limit * sizeof(h->table[0])); \
for (i=0; i < a->limit; ++i) \
if (!CCOMPARE(h->table[i].k,EMPTY) && !CCOMPARE(h->table[i].k,DEL)) \
h->table[i].k = COPY(h->table[i].k); \
return h; \
} \
\
static void STB_(N, rehash)(TYPE *a, int count) \
{ \
int i; \
TYPE b; \
STB__(N, init)(&b, count); \
for (i=0; i < a->limit; ++i) \
if (!CCOMPARE(a->table[i].k,EMPTY) && !CCOMPARE(a->table[i].k,DEL)) \
STB_(N,addset)(&b, a->table[i].k, a->table[i].v,1,1,0); \
free(a->table); \
a->table = b.table; \
a->mask = b.mask; \
a->count = b.count; \
a->limit = b.limit; \
a->deleted = b.deleted; \
a->delete_threshhold = b.delete_threshhold; \
a->grow_threshhold = b.grow_threshhold; \
a->shrink_threshhold = b.shrink_threshhold; \
}
#define STB_equal(a,b) ((a) == (b))
#define stb_define_hash(TYPE,N,KEY,EMPTY,DEL,HASH,VALUE) \
stb_define_hash_base(STB_noprefix, TYPE,STB_nofields,N,NC,0.85f, \
KEY,EMPTY,DEL,STB_nocopy,STB_nodelete,STB_nosafe, \
STB_equal,STB_equal,HASH, \
VALUE,STB_nonullvalue,0)
#define stb_define_hash_vnull(TYPE,N,KEY,EMPTY,DEL,HASH,VALUE,VNULL) \
stb_define_hash_base(STB_noprefix, TYPE,STB_nofields,N,NC,0.85f, \
KEY,EMPTY,DEL,STB_nocopy,STB_nodelete,STB_nosafe, \
STB_equal,STB_equal,HASH, \
VALUE,STB_nullvalue,VNULL)
//////////////////////////////////////////////////////////////////////////////
//
// stb_ptrmap
//
// An stb_ptrmap data structure is an O(1) hash table between pointers. One
// application is to let you store "extra" data associated with pointers,
// which is why it was originally called stb_extra.
stb_declare_hash(STB_EXTERN, stb_ptrmap, stb_ptrmap_, void *, void *)
stb_declare_hash(STB_EXTERN, stb_idict, stb_idict_, stb_int32, stb_int32)
STB_EXTERN void stb_ptrmap_delete(stb_ptrmap *e, void (*free_func)(void *));
STB_EXTERN stb_ptrmap *stb_ptrmap_new(void);
STB_EXTERN stb_idict * stb_idict_new_size(int size);
STB_EXTERN void stb_idict_remove_all(stb_idict *e);
#ifdef STB_DEFINE
#define STB_EMPTY ((void *) 2)
#define STB_EDEL ((void *) 6)
stb_define_hash_base(STB_noprefix,stb_ptrmap, STB_nofields, stb_ptrmap_,stb_ptrmap_,0.85f,
void *,STB_EMPTY,STB_EDEL,STB_nocopy,STB_nodelete,STB_nosafe,
STB_equal,STB_equal,return stb_hashptr(k);,
void *,STB_nullvalue,NULL)
stb_ptrmap *stb_ptrmap_new(void)
{
return stb_ptrmap_create();
}
void stb_ptrmap_delete(stb_ptrmap *e, void (*free_func)(void *))
{
int i;
if (free_func)
for (i=0; i < e->limit; ++i)
if (e->table[i].k != STB_EMPTY && e->table[i].k != STB_EDEL) {
if (free_func == free)
free(e->table[i].v); // allow STB_MALLOC_WRAPPER to operate
else
free_func(e->table[i].v);
}
stb_ptrmap_destroy(e);
}
// extra fields needed for stua_dict
#define STB_IEMPTY ((int) 1)
#define STB_IDEL ((int) 3)
stb_define_hash_base(STB_noprefix, stb_idict, short type; short gc; STB_nofields, stb_idict_,stb_idict_,0.85f,
stb_int32,STB_IEMPTY,STB_IDEL,STB_nocopy,STB_nodelete,STB_nosafe,
STB_equal,STB_equal,
return stb_rehash_improved(k);,stb_int32,STB_nonullvalue,0)
stb_idict * stb_idict_new_size(int size)
{
stb_idict *e = (stb_idict *) malloc(sizeof(*e));
if (e) {
if (!stb_is_pow2(size))
size = 1 << stb_log2_ceil(size);
stb_idict_init(e, size);
e->alloced = 1;
}
return e;
}
void stb_idict_remove_all(stb_idict *e)
{
int n;
for (n=0; n < e->limit; ++n)
e->table[n].k = STB_IEMPTY;
e->has_empty = e->has_del = 0;
}
#endif
//////////////////////////////////////////////////////////////////////////////
//
// stb_sparse_ptr_matrix
//
// An stb_ptrmap data structure is an O(1) hash table storing an arbitrary
// block of data for a given pair of pointers.
//
// If create=0, returns
typedef struct stb__st_stb_spmatrix stb_spmatrix;
STB_EXTERN stb_spmatrix * stb_sparse_ptr_matrix_new(int val_size);
STB_EXTERN void stb_sparse_ptr_matrix_free(stb_spmatrix *z);
STB_EXTERN void * stb_sparse_ptr_matrix_get(stb_spmatrix *z, void *a, void *b, int create);
#ifdef STB_DEFINE
typedef struct
{
void *a;
void *b;
} stb__ptrpair;
static stb__ptrpair stb__ptrpair_empty = { (void *) 1, (void *) 1 };
static stb__ptrpair stb__ptrpair_del = { (void *) 2, (void *) 2 };
#define STB__equal_ptrpair(x,y) ((x).a == (y).a && (x).b == (y).b)
stb_define_hash_base(static, stb_spmatrix, int val_size; void *arena;, stb__spmatrix_,stb__spmatrix_, 0.85,
stb__ptrpair, stb__ptrpair_empty, stb__ptrpair_del,
STB_nocopy, STB_nodelete, STB_nosafe,
STB__equal_ptrpair, STB__equal_ptrpair, return stb_rehash(stb_hashptr(k.a))+stb_hashptr(k.b);,
void *, STB_nullvalue, 0)
stb_spmatrix *stb_sparse_ptr_matrix_new(int val_size)
{
stb_spmatrix *m = stb__spmatrix_create();
if (m) m->val_size = val_size;
if (m) m->arena = stb_malloc_global(1);
return m;
}
void stb_sparse_ptr_matrix_free(stb_spmatrix *z)
{
if (z->arena) stb_free(z->arena);
stb__spmatrix_destroy(z);
}
void *stb_sparse_ptr_matrix_get(stb_spmatrix *z, void *a, void *b, int create)
{
stb__ptrpair t = { a,b };
void *data = stb__spmatrix_get(z, t);
if (!data && create) {
data = stb_malloc_raw(z->arena, z->val_size);
if (!data) return NULL;
memset(data, 0, z->val_size);
stb__spmatrix_add(z, t, data);
}
return data;
}
#endif
//////////////////////////////////////////////////////////////////////////////
//
// SDICT: Hash Table for Strings (symbol table)
//
// if "use_arena=1", then strings will be copied
// into blocks and never freed until the sdict is freed;
// otherwise they're malloc()ed and free()d on the fly.
// (specify use_arena=1 if you never stb_sdict_remove)
stb_declare_hash(STB_EXTERN, stb_sdict, stb_sdict_, char *, void *)
STB_EXTERN stb_sdict * stb_sdict_new(int use_arena);
STB_EXTERN stb_sdict * stb_sdict_copy(stb_sdict*);
STB_EXTERN void stb_sdict_delete(stb_sdict *);
STB_EXTERN void * stb_sdict_change(stb_sdict *, char *str, void *p);
STB_EXTERN int stb_sdict_count(stb_sdict *d);
#define stb_sdict_for(d,i,q,z) \
for(i=0; i < (d)->limit ? q=(d)->table[i].k,z=(d)->table[i].v,1 : 0; ++i) \
if (q==NULL||q==(void *) 1);else // reversed makes macro friendly
#ifdef STB_DEFINE
#define STB_DEL ((void *) 1)
#define STB_SDEL ((char *) 1)
#define stb_sdict__copy(x) \
strcpy(a->arena ? stb_malloc_string(a->arena, strlen(x)+1) \
: (char *) malloc(strlen(x)+1), x)
#define stb_sdict__dispose(x) if (!a->arena) free(x)
stb_define_hash_base(STB_noprefix, stb_sdict, void*arena;, stb_sdict_,stb_sdictinternal_, 0.85f,
char *, NULL, STB_SDEL, stb_sdict__copy, stb_sdict__dispose,
STB_safecompare, !strcmp, STB_equal, return stb_hash(k);,
void *, STB_nullvalue, NULL)
int stb_sdict_count(stb_sdict *a)
{
return a->count;
}
stb_sdict * stb_sdict_new(int use_arena)
{
stb_sdict *d = stb_sdict_create();
if (d == NULL) return NULL;
d->arena = use_arena ? stb_malloc_global(1) : NULL;
return d;
}
stb_sdict* stb_sdict_copy(stb_sdict *old)
{
stb_sdict *n;
void *old_arena = old->arena;
void *new_arena = old_arena ? stb_malloc_global(1) : NULL;
old->arena = new_arena;
n = stb_sdictinternal_copy(old);
old->arena = old_arena;
if (n)
n->arena = new_arena;
else if (new_arena)
stb_free(new_arena);
return n;
}
void stb_sdict_delete(stb_sdict *d)
{
if (d->arena)
stb_free(d->arena);
stb_sdict_destroy(d);
}
void * stb_sdict_change(stb_sdict *d, char *str, void *p)
{
void *q = stb_sdict_get(d, str);
stb_sdict_set(d, str, p);
return q;
}
#endif
//////////////////////////////////////////////////////////////////////////////
//
// Instantiated data structures
//
// This is an attempt to implement a templated data structure.
// What you do is define a struct foo, and then include several
// pointer fields to struct foo in your struct. Then you call
// the instantiator, which creates the functions that implement
// the data structure. This requires massive undebuggable #defines,
// so we limit the cases where we do this.
//
// AA tree is an encoding of a 2-3 tree whereas RB trees encode a 2-3-4 tree;
// much simpler code due to fewer cases.
#define stb__bst_parent(x) x
#define stb__bst_noparent(x)
#define stb_bst_fields(N) \
*STB_(N,left), *STB_(N,right); \
unsigned char STB_(N,level)
#define stb_bst_fields_parent(N) \
*STB_(N,left), *STB_(N,right), *STB_(N,parent); \
unsigned char STB_(N,level)
#define STB__level(N,x) ((x) ? (x)->STB_(N,level) : 0)
#define stb_bst_base(TYPE, N, TREE, M, compare, PAR) \
\
static int STB_(N,_compare)(TYPE *p, TYPE *q) \
{ \
compare \
} \
\
static void STB_(N,setleft)(TYPE *q, TYPE *v) \
{ \
q->STB_(N,left) = v; \
PAR(if (v) v->STB_(N,parent) = q;) \
} \
\
static void STB_(N,setright)(TYPE *q, TYPE *v) \
{ \
q->STB_(N,right) = v; \
PAR(if (v) v->STB_(N,parent) = q;) \
} \
\
static TYPE *STB_(N,skew)(TYPE *q) \
{ \
if (q == NULL) return q; \
if (q->STB_(N,left) \
&& q->STB_(N,left)->STB_(N,level) == q->STB_(N,level)) { \
TYPE *p = q->STB_(N,left); \
STB_(N,setleft)(q, p->STB_(N,right)); \
STB_(N,setright)(p, q); \
return p; \
} \
return q; \
} \
\
static TYPE *STB_(N,split)(TYPE *p) \
{ \
TYPE *q = p->STB_(N,right); \
if (q && q->STB_(N,right) \
&& q->STB_(N,right)->STB_(N,level) == p->STB_(N,level)) { \
STB_(N,setright)(p, q->STB_(N,left)); \
STB_(N,setleft)(q,p); \
++q->STB_(N,level); \
return q; \
} \
return p; \
} \
\
TYPE *STB__(N,insert)(TYPE *tree, TYPE *item) \
{ \
int c; \
if (tree == NULL) { \
item->STB_(N,left) = NULL; \
item->STB_(N,right) = NULL; \
item->STB_(N,level) = 1; \
PAR(item->STB_(N,parent) = NULL;) \
return item; \
} \
c = STB_(N,_compare)(item,tree); \
if (c == 0) { \
if (item != tree) { \
STB_(N,setleft)(item, tree->STB_(N,left)); \
STB_(N,setright)(item, tree->STB_(N,right)); \
item->STB_(N,level) = tree->STB_(N,level); \
PAR(item->STB_(N,parent) = NULL;) \
} \
return item; \
} \
if (c < 0) \
STB_(N,setleft )(tree, STB__(N,insert)(tree->STB_(N,left), item)); \
else \
STB_(N,setright)(tree, STB__(N,insert)(tree->STB_(N,right), item)); \
tree = STB_(N,skew)(tree); \
tree = STB_(N,split)(tree); \
PAR(tree->STB_(N,parent) = NULL;) \
return tree; \
} \
\
TYPE *STB__(N,remove)(TYPE *tree, TYPE *item) \
{ \
static TYPE *delnode, *leaf, *restore; \
if (tree == NULL) return NULL; \
leaf = tree; \
if (STB_(N,_compare)(item, tree) < 0) { \
STB_(N,setleft)(tree, STB__(N,remove)(tree->STB_(N,left), item)); \
} else { \
TYPE *r; \
delnode = tree; \
r = STB__(N,remove)(tree->STB_(N,right), item); \
/* maybe move 'leaf' up to this location */ \
if (restore == tree) { tree = leaf; leaf = restore = NULL; } \
STB_(N,setright)(tree,r); \
assert(tree->STB_(N,right) != tree); \
} \
if (tree == leaf) { \
if (delnode == item) { \
tree = tree->STB_(N,right); \
assert(leaf->STB_(N,left) == NULL); \
/* move leaf (the right sibling) up to delnode */ \
STB_(N,setleft )(leaf, item->STB_(N,left )); \
STB_(N,setright)(leaf, item->STB_(N,right)); \
leaf->STB_(N,level) = item->STB_(N,level); \
if (leaf != item) \
restore = delnode; \
} \
delnode = NULL; \
} else { \
if (STB__level(N,tree->STB_(N,left) ) < tree->STB_(N,level)-1 || \
STB__level(N,tree->STB_(N,right)) < tree->STB_(N,level)-1) { \
--tree->STB_(N,level); \
if (STB__level(N,tree->STB_(N,right)) > tree->STB_(N,level)) \
tree->STB_(N,right)->STB_(N,level) = tree->STB_(N,level); \
tree = STB_(N,skew)(tree); \
STB_(N,setright)(tree, STB_(N,skew)(tree->STB_(N,right))); \
if (tree->STB_(N,right)) \
STB_(N,setright)(tree->STB_(N,right), \
STB_(N,skew)(tree->STB_(N,right)->STB_(N,right))); \
tree = STB_(N,split)(tree); \
if (tree->STB_(N,right)) \
STB_(N,setright)(tree, STB_(N,split)(tree->STB_(N,right))); \
} \
} \
PAR(if (tree) tree->STB_(N,parent) = NULL;) \
return tree; \
} \
\
TYPE *STB__(N,last)(TYPE *tree) \
{ \
if (tree) \
while (tree->STB_(N,right)) tree = tree->STB_(N,right); \
return tree; \
} \
\
TYPE *STB__(N,first)(TYPE *tree) \
{ \
if (tree) \
while (tree->STB_(N,left)) tree = tree->STB_(N,left); \
return tree; \
} \
\
TYPE *STB__(N,next)(TYPE *tree, TYPE *item) \
{ \
TYPE *next = NULL; \
if (item->STB_(N,right)) \
return STB__(N,first)(item->STB_(N,right)); \
PAR( \
while(item->STB_(N,parent)) { \
TYPE *up = item->STB_(N,parent); \
if (up->STB_(N,left) == item) return up; \
item = up; \
} \
return NULL; \
) \
while (tree != item) { \
if (STB_(N,_compare)(item, tree) < 0) { \
next = tree; \
tree = tree->STB_(N,left); \
} else { \
tree = tree->STB_(N,right); \
} \
} \
return next; \
} \
\
TYPE *STB__(N,prev)(TYPE *tree, TYPE *item) \
{ \
TYPE *next = NULL; \
if (item->STB_(N,left)) \
return STB__(N,last)(item->STB_(N,left)); \
PAR( \
while(item->STB_(N,parent)) { \
TYPE *up = item->STB_(N,parent); \
if (up->STB_(N,right) == item) return up; \
item = up; \
} \
return NULL; \
) \
while (tree != item) { \
if (STB_(N,_compare)(item, tree) < 0) { \
tree = tree->STB_(N,left); \
} else { \
next = tree; \
tree = tree->STB_(N,right); \
} \
} \
return next; \
} \
\
STB__DEBUG( \
void STB__(N,_validate)(TYPE *tree, int root) \
{ \
if (tree == NULL) return; \
PAR(if(root) assert(tree->STB_(N,parent) == NULL);) \
assert(STB__level(N,tree->STB_(N,left) ) == tree->STB_(N,level)-1); \
assert(STB__level(N,tree->STB_(N,right)) <= tree->STB_(N,level)); \
assert(STB__level(N,tree->STB_(N,right)) >= tree->STB_(N,level)-1); \
if (tree->STB_(N,right)) { \
assert(STB__level(N,tree->STB_(N,right)->STB_(N,right)) \
!= tree->STB_(N,level)); \
PAR(assert(tree->STB_(N,right)->STB_(N,parent) == tree);) \
} \
PAR(if(tree->STB_(N,left)) assert(tree->STB_(N,left)->STB_(N,parent) == tree);) \
STB__(N,_validate)(tree->STB_(N,left) ,0); \
STB__(N,_validate)(tree->STB_(N,right),0); \
} \
) \
\
typedef struct \
{ \
TYPE *root; \
} TREE; \
\
void STB__(M,Insert)(TREE *tree, TYPE *item) \
{ tree->root = STB__(N,insert)(tree->root, item); } \
void STB__(M,Remove)(TREE *tree, TYPE *item) \
{ tree->root = STB__(N,remove)(tree->root, item); } \
TYPE *STB__(M,Next)(TREE *tree, TYPE *item) \
{ return STB__(N,next)(tree->root, item); } \
TYPE *STB__(M,Prev)(TREE *tree, TYPE *item) \
{ return STB__(N,prev)(tree->root, item); } \
TYPE *STB__(M,First)(TREE *tree) { return STB__(N,first)(tree->root); } \
TYPE *STB__(M,Last) (TREE *tree) { return STB__(N,last) (tree->root); } \
void STB__(M,Init)(TREE *tree) { tree->root = NULL; }
#define stb_bst_find(N,tree,fcompare) \
{ \
int c; \
while (tree != NULL) { \
fcompare \
if (c == 0) return tree; \
if (c < 0) tree = tree->STB_(N,left); \
else tree = tree->STB_(N,right); \
} \
return NULL; \
}
#define stb_bst_raw(TYPE,N,TREE,M,vfield,VTYPE,compare,PAR) \
stb_bst_base(TYPE,N,TREE,M, \
VTYPE a = p->vfield; VTYPE b = q->vfield; return (compare);, PAR ) \
\
TYPE *STB__(N,find)(TYPE *tree, VTYPE a) \
stb_bst_find(N,tree,VTYPE b = tree->vfield; c = (compare);) \
TYPE *STB__(M,Find)(TREE *tree, VTYPE a) \
{ return STB__(N,find)(tree->root, a); }
#define stb_bst(TYPE,N,TREE,M,vfield,VTYPE,compare) \
stb_bst_raw(TYPE,N,TREE,M,vfield,VTYPE,compare,stb__bst_noparent)
#define stb_bst_parent(TYPE,N,TREE,M,vfield,VTYPE,compare) \
stb_bst_raw(TYPE,N,TREE,M,vfield,VTYPE,compare,stb__bst_parent)
//////////////////////////////////////////////////////////////////////////////
//
// Pointer Nulling
//
// This lets you automatically NULL dangling pointers to "registered"
// objects. Note that you have to make sure you call the appropriate
// functions when you free or realloc blocks of memory that contain
// pointers or pointer targets. stb.h can automatically do this for
// stb_arr, or for all frees/reallocs if it's wrapping them.
//
#ifdef STB_NPTR
STB_EXTERN void stb_nptr_set(void *address_of_pointer, void *value_to_write);
STB_EXTERN void stb_nptr_didset(void *address_of_pointer);
STB_EXTERN void stb_nptr_didfree(void *address_being_freed, int len);
STB_EXTERN void stb_nptr_free(void *address_being_freed, int len);
STB_EXTERN void stb_nptr_didrealloc(void *new_address, void *old_address, int len);
STB_EXTERN void stb_nptr_recache(void); // recache all known pointers
// do this after pointer sets outside your control, slow
#ifdef STB_DEFINE
// for fast updating on free/realloc, we need to be able to find
// all the objects (pointers and targets) within a given block;
// this precludes hashing
// we use a three-level hierarchy of memory to minimize storage:
// level 1: 65536 pointers to stb__memory_node (always uses 256 KB)
// level 2: each stb__memory_node represents a 64K block of memory
// with 256 stb__memory_leafs (worst case 64MB)
// level 3: each stb__memory_leaf represents 256 bytes of memory
// using a list of target locations and a list of pointers
// (which are hopefully fairly short normally!)
// this approach won't work in 64-bit, which has a much larger address
// space. need to redesign
#define STB__NPTR_ROOT_LOG2 16
#define STB__NPTR_ROOT_NUM (1 << STB__NPTR_ROOT_LOG2)
#define STB__NPTR_ROOT_SHIFT (32 - STB__NPTR_ROOT_LOG2)
#define STB__NPTR_NODE_LOG2 5
#define STB__NPTR_NODE_NUM (1 << STB__NPTR_NODE_LOG2)
#define STB__NPTR_NODE_MASK (STB__NPTR_NODE_NUM-1)
#define STB__NPTR_NODE_SHIFT (STB__NPTR_ROOT_SHIFT - STB__NPTR_NODE_LOG2)
#define STB__NPTR_NODE_OFFSET(x) (((x) >> STB__NPTR_NODE_SHIFT) & STB__NPTR_NODE_MASK)
typedef struct stb__st_nptr
{
void *ptr; // address of actual pointer
struct stb__st_nptr *next; // next pointer with same target
struct stb__st_nptr **prev; // prev pointer with same target, address of 'next' field (or first)
struct stb__st_nptr *next_in_block;
} stb__nptr;
typedef struct stb__st_nptr_target
{
void *ptr; // address of target
stb__nptr *first; // address of first nptr pointing to this
struct stb__st_nptr_target *next_in_block;
} stb__nptr_target;
typedef struct
{
stb__nptr *pointers;
stb__nptr_target *targets;
} stb__memory_leaf;
typedef struct
{
stb__memory_leaf *children[STB__NPTR_NODE_NUM];
} stb__memory_node;
stb__memory_node *stb__memtab_root[STB__NPTR_ROOT_NUM];
static stb__memory_leaf *stb__nptr_find_leaf(void *mem)
{
stb_uint32 address = (stb_uint32) mem;
stb__memory_node *z = stb__memtab_root[address >> STB__NPTR_ROOT_SHIFT];
if (z)
return z->children[STB__NPTR_NODE_OFFSET(address)];
else
return NULL;
}
static void * stb__nptr_alloc(int size)
{
return stb__realloc_raw(0,size);
}
static void stb__nptr_free(void *p)
{
stb__realloc_raw(p,0);
}
static stb__memory_leaf *stb__nptr_make_leaf(void *mem)
{
stb_uint32 address = (stb_uint32) mem;
stb__memory_node *z = stb__memtab_root[address >> STB__NPTR_ROOT_SHIFT];
stb__memory_leaf *f;
if (!z) {
int i;
z = (stb__memory_node *) stb__nptr_alloc(sizeof(*stb__memtab_root[0]));
stb__memtab_root[address >> STB__NPTR_ROOT_SHIFT] = z;
for (i=0; i < 256; ++i)
z->children[i] = 0;
}
f = (stb__memory_leaf *) stb__nptr_alloc(sizeof(*f));
z->children[STB__NPTR_NODE_OFFSET(address)] = f;
f->pointers = NULL;
f->targets = NULL;
return f;
}
static stb__nptr_target *stb__nptr_find_target(void *target, int force)
{
stb__memory_leaf *p = stb__nptr_find_leaf(target);
if (p) {
stb__nptr_target *t = p->targets;
while (t) {
if (t->ptr == target)
return t;
t = t->next_in_block;
}
}
if (force) {
stb__nptr_target *t = (stb__nptr_target*) stb__nptr_alloc(sizeof(*t));
if (!p) p = stb__nptr_make_leaf(target);
t->ptr = target;
t->first = NULL;
t->next_in_block = p->targets;
p->targets = t;
return t;
} else
return NULL;
}
static stb__nptr *stb__nptr_find_pointer(void *ptr, int force)
{
stb__memory_leaf *p = stb__nptr_find_leaf(ptr);
if (p) {
stb__nptr *t = p->pointers;
while (t) {
if (t->ptr == ptr)
return t;
t = t->next_in_block;
}
}
if (force) {
stb__nptr *t = (stb__nptr *) stb__nptr_alloc(sizeof(*t));
if (!p) p = stb__nptr_make_leaf(ptr);
t->ptr = ptr;
t->next = NULL;
t->prev = NULL;
t->next_in_block = p->pointers;
p->pointers = t;
return t;
} else
return NULL;
}
void stb_nptr_set(void *address_of_pointer, void *value_to_write)
{
if (*(void **)address_of_pointer != value_to_write) {
*(void **) address_of_pointer = value_to_write;
stb_nptr_didset(address_of_pointer);
}
}
void stb_nptr_didset(void *address_of_pointer)
{
// first unlink from old chain
void *new_address;
stb__nptr *p = stb__nptr_find_pointer(address_of_pointer, 1); // force building if doesn't exist
if (p->prev) { // if p->prev is NULL, we just built it, or it was NULL
*(p->prev) = p->next;
if (p->next) p->next->prev = p->prev;
}
// now add to new chain
new_address = *(void **)address_of_pointer;
if (new_address != NULL) {
stb__nptr_target *t = stb__nptr_find_target(new_address, 1);
p->next = t->first;
if (p->next) p->next->prev = &p->next;
p->prev = &t->first;
t->first = p;
} else {
p->prev = NULL;
p->next = NULL;
}
}
void stb__nptr_block(void *address, int len, void (*function)(stb__memory_leaf *f, int datum, void *start, void *end), int datum)
{
void *end_address = (void *) ((char *) address + len - 1);
stb__memory_node *n;
stb_uint32 start = (stb_uint32) address;
stb_uint32 end = start + len - 1;
int b0 = start >> STB__NPTR_ROOT_SHIFT;
int b1 = end >> STB__NPTR_ROOT_SHIFT;
int b=b0,i,e0,e1;
e0 = STB__NPTR_NODE_OFFSET(start);
if (datum <= 0) {
// first block
n = stb__memtab_root[b0];
if (n) {
if (b0 != b1)
e1 = STB__NPTR_NODE_NUM-1;
else
e1 = STB__NPTR_NODE_OFFSET(end);
for (i=e0; i <= e1; ++i)
if (n->children[i])
function(n->children[i], datum, address, end_address);
}
if (b1 > b0) {
// blocks other than the first and last block
for (b=b0+1; b < b1; ++b) {
n = stb__memtab_root[b];
if (n)
for (i=0; i <= STB__NPTR_NODE_NUM-1; ++i)
if (n->children[i])
function(n->children[i], datum, address, end_address);
}
// last block
n = stb__memtab_root[b1];
if (n) {
e1 = STB__NPTR_NODE_OFFSET(end);
for (i=0; i <= e1; ++i)
if (n->children[i])
function(n->children[i], datum, address, end_address);
}
}
} else {
if (b1 > b0) {
// last block
n = stb__memtab_root[b1];
if (n) {
e1 = STB__NPTR_NODE_OFFSET(end);
for (i=e1; i >= 0; --i)
if (n->children[i])
function(n->children[i], datum, address, end_address);
}
// blocks other than the first and last block
for (b=b1-1; b > b0; --b) {
n = stb__memtab_root[b];
if (n)
for (i=STB__NPTR_NODE_NUM-1; i >= 0; --i)
if (n->children[i])
function(n->children[i], datum, address, end_address);
}
}
// first block
n = stb__memtab_root[b0];
if (n) {
if (b0 != b1)
e1 = STB__NPTR_NODE_NUM-1;
else
e1 = STB__NPTR_NODE_OFFSET(end);
for (i=e1; i >= e0; --i)
if (n->children[i])
function(n->children[i], datum, address, end_address);
}
}
}
static void stb__nptr_delete_pointers(stb__memory_leaf *f, int offset, void *start, void *end)
{
stb__nptr **p = &f->pointers;
while (*p) {
stb__nptr *n = *p;
if (n->ptr >= start && n->ptr <= end) {
// unlink
if (n->prev) {
*(n->prev) = n->next;
if (n->next) n->next->prev = n->prev;
}
*p = n->next_in_block;
stb__nptr_free(n);
} else
p = &(n->next_in_block);
}
}
static void stb__nptr_delete_targets(stb__memory_leaf *f, int offset, void *start, void *end)
{
stb__nptr_target **p = &f->targets;
while (*p) {
stb__nptr_target *n = *p;
if (n->ptr >= start && n->ptr <= end) {
// null pointers
stb__nptr *z = n->first;
while (z) {
stb__nptr *y = z->next;
z->prev = NULL;
z->next = NULL;
*(void **) z->ptr = NULL;
z = y;
}
// unlink this target
*p = n->next_in_block;
stb__nptr_free(n);
} else
p = &(n->next_in_block);
}
}
void stb_nptr_didfree(void *address_being_freed, int len)
{
// step one: delete all pointers in this block
stb__nptr_block(address_being_freed, len, stb__nptr_delete_pointers, 0);
// step two: NULL all pointers to this block; do this second to avoid NULLing deleted pointers
stb__nptr_block(address_being_freed, len, stb__nptr_delete_targets, 0);
}
void stb_nptr_free(void *address_being_freed, int len)
{
free(address_being_freed);
stb_nptr_didfree(address_being_freed, len);
}
static void stb__nptr_move_targets(stb__memory_leaf *f, int offset, void *start, void *end)
{
stb__nptr_target **t = &f->targets;
while (*t) {
stb__nptr_target *n = *t;
if (n->ptr >= start && n->ptr <= end) {
stb__nptr *z;
stb__memory_leaf *f;
// unlink n
*t = n->next_in_block;
// update n to new address
n->ptr = (void *) ((char *) n->ptr + offset);
f = stb__nptr_find_leaf(n->ptr);
if (!f) f = stb__nptr_make_leaf(n->ptr);
n->next_in_block = f->targets;
f->targets = n;
// now go through all pointers and make them point here
z = n->first;
while (z) {
*(void**) z->ptr = n->ptr;
z = z->next;
}
} else
t = &(n->next_in_block);
}
}
static void stb__nptr_move_pointers(stb__memory_leaf *f, int offset, void *start, void *end)
{
stb__nptr **p = &f->pointers;
while (*p) {
stb__nptr *n = *p;
if (n->ptr >= start && n->ptr <= end) {
// unlink
*p = n->next_in_block;
n->ptr = (void *) ((int) n->ptr + offset);
// move to new block
f = stb__nptr_find_leaf(n->ptr);
if (!f) f = stb__nptr_make_leaf(n->ptr);
n->next_in_block = f->pointers;
f->pointers = n;
} else
p = &(n->next_in_block);
}
}
void stb_nptr_realloc(void *new_address, void *old_address, int len)
{
if (new_address == old_address) return;
// have to move the pointers first, because moving the targets
// requires writing to the pointers-to-the-targets, and if some of those moved too,
// we need to make sure we don't write to the old memory
// step one: move all pointers within the block
stb__nptr_block(old_address, len, stb__nptr_move_pointers, (char *) new_address - (char *) old_address);
// step two: move all targets within the block
stb__nptr_block(old_address, len, stb__nptr_move_targets, (char *) new_address - (char *) old_address);
}
void stb_nptr_move(void *new_address, void *old_address)
{
stb_nptr_realloc(new_address, old_address, 1);
}
void stb_nptr_recache(void)
{
int i,j;
for (i=0; i < STB__NPTR_ROOT_NUM; ++i)
if (stb__memtab_root[i])
for (j=0; j < STB__NPTR_NODE_NUM; ++j)
if (stb__memtab_root[i]->children[j]) {
stb__nptr *p = stb__memtab_root[i]->children[j]->pointers;
while (p) {
stb_nptr_didset(p->ptr);
p = p->next_in_block;
}
}
}
#endif // STB_DEFINE
#endif // STB_NPTR
//////////////////////////////////////////////////////////////////////////////
//
// File Processing
//
#ifdef _MSC_VER
#define stb_rename(x,y) _wrename((const wchar_t *)stb__from_utf8(x), (const wchar_t *)stb__from_utf8_alt(y))
#define stb_mktemp _mktemp
#else
#define stb_mktemp mktemp
#define stb_rename rename
#endif
STB_EXTERN void stb_fput_varlen64(FILE *f, stb_uint64 v);
STB_EXTERN stb_uint64 stb_fget_varlen64(FILE *f);
STB_EXTERN int stb_size_varlen64(stb_uint64 v);
#define stb_filec (char *) stb_file
#define stb_fileu (unsigned char *) stb_file
STB_EXTERN void * stb_file(char *filename, size_t *length);
STB_EXTERN void * stb_file_max(char *filename, size_t *length);
STB_EXTERN size_t stb_filelen(FILE *f);
STB_EXTERN int stb_filewrite(char *filename, void *data, size_t length);
STB_EXTERN int stb_filewritestr(char *filename, char *data);
STB_EXTERN char ** stb_stringfile(char *filename, int *len);
STB_EXTERN char ** stb_stringfile_trimmed(char *name, int *len, char comm);
STB_EXTERN char * stb_fgets(char *buffer, int buflen, FILE *f);
STB_EXTERN char * stb_fgets_malloc(FILE *f);
STB_EXTERN int stb_fexists(char *filename);
STB_EXTERN int stb_fcmp(char *s1, char *s2);
STB_EXTERN int stb_feq(char *s1, char *s2);
STB_EXTERN time_t stb_ftimestamp(char *filename);
STB_EXTERN int stb_fullpath(char *abs, int abs_size, char *rel);
STB_EXTERN FILE * stb_fopen(char *filename, char *mode);
STB_EXTERN int stb_fclose(FILE *f, int keep);
enum
{
stb_keep_no = 0,
stb_keep_yes = 1,
stb_keep_if_different = 2,
};
STB_EXTERN int stb_copyfile(char *src, char *dest);
STB_EXTERN void stb_fput_varlen64(FILE *f, stb_uint64 v);
STB_EXTERN stb_uint64 stb_fget_varlen64(FILE *f);
STB_EXTERN int stb_size_varlen64(stb_uint64 v);
STB_EXTERN void stb_fwrite32(FILE *f, stb_uint32 datum);
STB_EXTERN void stb_fput_varlen (FILE *f, int v);
STB_EXTERN void stb_fput_varlenu(FILE *f, unsigned int v);
STB_EXTERN int stb_fget_varlen (FILE *f);
STB_EXTERN stb_uint stb_fget_varlenu(FILE *f);
STB_EXTERN void stb_fput_ranged (FILE *f, int v, int b, stb_uint n);
STB_EXTERN int stb_fget_ranged (FILE *f, int b, stb_uint n);
STB_EXTERN int stb_size_varlen (int v);
STB_EXTERN int stb_size_varlenu(unsigned int v);
STB_EXTERN int stb_size_ranged (int b, stb_uint n);
STB_EXTERN int stb_fread(void *data, size_t len, size_t count, void *f);
STB_EXTERN int stb_fwrite(void *data, size_t len, size_t count, void *f);
#if 0
typedef struct
{
FILE *base_file;
char *buffer;
int buffer_size;
int buffer_off;
int buffer_left;
} STBF;
STB_EXTERN STBF *stb_tfopen(char *filename, char *mode);
STB_EXTERN int stb_tfread(void *data, size_t len, size_t count, STBF *f);
STB_EXTERN int stb_tfwrite(void *data, size_t len, size_t count, STBF *f);
#endif
#ifdef STB_DEFINE
#if 0
STBF *stb_tfopen(char *filename, char *mode)
{
STBF *z;
FILE *f = fopen(filename, mode);
if (!f) return NULL;
z = (STBF *) malloc(sizeof(*z));
if (!z) { fclose(f); return NULL; }
z->base_file = f;
if (!strcmp(mode, "rb") || !strcmp(mode, "wb")) {
z->buffer_size = 4096;
z->buffer_off = z->buffer_size;
z->buffer_left = 0;
z->buffer = malloc(z->buffer_size);
if (!z->buffer) { free(z); fclose(f); return NULL; }
} else {
z->buffer = 0;
z->buffer_size = 0;
z->buffer_left = 0;
}
return z;
}
int stb_tfread(void *data, size_t len, size_t count, STBF *f)
{
int total = len*count, done=0;
if (!total) return 0;
if (total <= z->buffer_left) {
memcpy(data, z->buffer + z->buffer_off, total);
z->buffer_off += total;
z->buffer_left -= total;
return count;
} else {
char *out = (char *) data;
// consume all buffered data
memcpy(data, z->buffer + z->buffer_off, z->buffer_left);
done = z->buffer_left;
out += z->buffer_left;
z->buffer_left=0;
if (total-done > (z->buffer_size >> 1)) {
done += fread(out
}
}
}
#endif
void stb_fwrite32(FILE *f, stb_uint32 x)
{
fwrite(&x, 4, 1, f);
}
#if defined(_MSC_VER) || defined(__MINGW32__)
#define stb__stat _stat
#else
#define stb__stat stat
#endif
int stb_fexists(char *filename)
{
struct stb__stat buf;
return stb__windows(
_wstat((const wchar_t *)stb__from_utf8(filename), &buf),
stat(filename,&buf)
) == 0;
}
time_t stb_ftimestamp(char *filename)
{
struct stb__stat buf;
if (stb__windows(
_wstat((const wchar_t *)stb__from_utf8(filename), &buf),
stat(filename,&buf)
) == 0)
{
return buf.st_mtime;
} else {
return 0;
}
}
size_t stb_filelen(FILE *f)
{
size_t len, pos;
pos = ftell(f);
fseek(f, 0, SEEK_END);
len = ftell(f);
fseek(f, pos, SEEK_SET);
return len;
}
void *stb_file(char *filename, size_t *length)
{
FILE *f = stb__fopen(filename, "rb");
char *buffer;
size_t len, len2;
if (!f) return NULL;
len = stb_filelen(f);
buffer = (char *) malloc(len+2); // nul + extra
len2 = fread(buffer, 1, len, f);
if (len2 == len) {
if (length) *length = len;
buffer[len] = 0;
} else {
free(buffer);
buffer = NULL;
}
fclose(f);
return buffer;
}
int stb_filewrite(char *filename, void *data, size_t length)
{
FILE *f = stb_fopen(filename, "wb");
if (f) {
unsigned char *data_ptr = (unsigned char *) data;
size_t remaining = length;
while (remaining > 0) {
size_t len2 = remaining > 65536 ? 65536 : remaining;
size_t len3 = fwrite(data_ptr, 1, len2, f);
if (len2 != len3) {
fprintf(stderr, "Failed while writing %s\n", filename);
break;
}
remaining -= len2;
data_ptr += len2;
}
stb_fclose(f, stb_keep_if_different);
}
return f != NULL;
}
int stb_filewritestr(char *filename, char *data)
{
return stb_filewrite(filename, data, strlen(data));
}
void * stb_file_max(char *filename, size_t *length)
{
FILE *f = stb__fopen(filename, "rb");
char *buffer;
size_t len, maxlen;
if (!f) return NULL;
maxlen = *length;
buffer = (char *) malloc(maxlen+1);
len = fread(buffer, 1, maxlen, f);
buffer[len] = 0;
fclose(f);
*length = len;
return buffer;
}
char ** stb_stringfile(char *filename, int *plen)
{
FILE *f = stb__fopen(filename, "rb");
char *buffer, **list=NULL, *s;
size_t len, count, i;
if (!f) return NULL;
len = stb_filelen(f);
buffer = (char *) malloc(len+1);
len = fread(buffer, 1, len, f);
buffer[len] = 0;
fclose(f);
// two passes through: first time count lines, second time set them
for (i=0; i < 2; ++i) {
s = buffer;
if (i == 1)
list[0] = s;
count = 1;
while (*s) {
if (*s == '\n' || *s == '\r') {
// detect if both cr & lf are together
int crlf = (s[0] + s[1]) == ('\n' + '\r');
if (i == 1) *s = 0;
if (crlf) ++s;
if (s[1]) { // it's not over yet
if (i == 1) list[count] = s+1;
++count;
}
}
++s;
}
if (i == 0) {
list = (char **) malloc(sizeof(*list) * (count+1) + len+1);
if (!list) return NULL;
list[count] = 0;
// recopy the file so there's just a single allocation to free
memcpy(&list[count+1], buffer, len+1);
free(buffer);
buffer = (char *) &list[count+1];
if (plen) *plen = count;
}
}
return list;
}
char ** stb_stringfile_trimmed(char *name, int *len, char comment)
{
int i,n,o=0;
char **s = stb_stringfile(name, &n);
if (s == NULL) return NULL;
for (i=0; i < n; ++i) {
char *p = stb_skipwhite(s[i]);
if (*p && *p != comment)
s[o++] = p;
}
s[o] = NULL;
if (len) *len = o;
return s;
}
char * stb_fgets(char *buffer, int buflen, FILE *f)
{
char *p;
buffer[0] = 0;
p = fgets(buffer, buflen, f);
if (p) {
int n = strlen(p)-1;
if (n >= 0)
if (p[n] == '\n')
p[n] = 0;
}
return p;
}
char * stb_fgets_malloc(FILE *f)
{
// avoid reallocing for small strings
char quick_buffer[800];
quick_buffer[sizeof(quick_buffer)-2] = 0;
if (!fgets(quick_buffer, sizeof(quick_buffer), f))
return NULL;
if (quick_buffer[sizeof(quick_buffer)-2] == 0) {
int n = strlen(quick_buffer);
if (n > 0 && quick_buffer[n-1] == '\n')
quick_buffer[n-1] = 0;
return strdup(quick_buffer);
} else {
char *p;
char *a = strdup(quick_buffer);
int len = sizeof(quick_buffer)-1;
while (!feof(f)) {
if (a[len-1] == '\n') break;
a = (char *) realloc(a, len*2);
p = &a[len];
p[len-2] = 0;
if (!fgets(p, len, f))
break;
if (p[len-2] == 0) {
len += strlen(p);
break;
}
len = len + (len-1);
}
if (a[len-1] == '\n')
a[len-1] = 0;
return a;
}
}
int stb_fullpath(char *abs, int abs_size, char *rel)
{
#ifdef _MSC_VER
return _fullpath(abs, rel, abs_size) != NULL;
#else
if (rel[0] == '/' || rel[0] == '~') {
if ((int) strlen(rel) >= abs_size)
return 0;
strcpy(abs,rel);
return STB_TRUE;
} else {
int n;
getcwd(abs, abs_size);
n = strlen(abs);
if (n+(int) strlen(rel)+2 <= abs_size) {
abs[n] = '/';
strcpy(abs+n+1, rel);
return STB_TRUE;
} else {
return STB_FALSE;
}
}
#endif
}
static int stb_fcmp_core(FILE *f, FILE *g)
{
char buf1[1024],buf2[1024];
int n1,n2, res=0;
while (1) {
n1 = fread(buf1, 1, sizeof(buf1), f);
n2 = fread(buf2, 1, sizeof(buf2), g);
res = memcmp(buf1,buf2,stb_min(n1,n2));
if (res)
break;
if (n1 != n2) {
res = n1 < n2 ? -1 : 1;
break;
}
if (n1 == 0)
break;
}
fclose(f);
fclose(g);
return res;
}
int stb_fcmp(char *s1, char *s2)
{
FILE *f = stb__fopen(s1, "rb");
FILE *g = stb__fopen(s2, "rb");
if (f == NULL || g == NULL) {
if (f) fclose(f);
if (g) {
fclose(g);
return STB_TRUE;
}
return f != NULL;
}
return stb_fcmp_core(f,g);
}
int stb_feq(char *s1, char *s2)
{
FILE *f = stb__fopen(s1, "rb");
FILE *g = stb__fopen(s2, "rb");
if (f == NULL || g == NULL) {
if (f) fclose(f);
if (g) fclose(g);
return f == g;
}
// feq is faster because it shortcuts if they're different length
if (stb_filelen(f) != stb_filelen(g)) {
fclose(f);
fclose(g);
return 0;
}
return !stb_fcmp_core(f,g);
}
static stb_ptrmap *stb__files;
typedef struct
{
char *temp_name;
char *name;
int errors;
} stb__file_data;
FILE * stb_fopen(char *filename, char *mode)
{
FILE *f;
char name_full[4096];
char temp_full[sizeof(name_full) + 12];
int p;
#ifdef _MSC_VER
int j;
#endif
if (mode[0] != 'w' && !strchr(mode, '+'))
return stb__fopen(filename, mode);
// save away the full path to the file so if the program
// changes the cwd everything still works right! unix has
// better ways to do this, but we have to work in windows
name_full[0] = '\0'; // stb_fullpath reads name_full[0]
if (stb_fullpath(name_full, sizeof(name_full), filename)==0)
return 0;
// try to generate a temporary file in the same directory
p = strlen(name_full)-1;
while (p > 0 && name_full[p] != '/' && name_full[p] != '\\'
&& name_full[p] != ':' && name_full[p] != '~')
--p;
++p;
memcpy(temp_full, name_full, p);
#ifdef _MSC_VER
// try multiple times to make a temp file... just in
// case some other process makes the name first
for (j=0; j < 32; ++j) {
strcpy(temp_full+p, "stmpXXXXXX");
if (stb_mktemp(temp_full) == NULL)
return 0;
f = fopen(temp_full, mode);
if (f != NULL)
break;
}
#else
{
strcpy(temp_full+p, "stmpXXXXXX");
#ifdef __MINGW32__
int fd = open(mktemp(temp_full), O_RDWR);
#else
int fd = mkstemp(temp_full);
#endif
if (fd == -1) return NULL;
f = fdopen(fd, mode);
if (f == NULL) {
unlink(temp_full);
close(fd);
return NULL;
}
}
#endif
if (f != NULL) {
stb__file_data *d = (stb__file_data *) malloc(sizeof(*d));
if (!d) { assert(0); /* NOTREACHED */fclose(f); return NULL; }
if (stb__files == NULL) stb__files = stb_ptrmap_create();
d->temp_name = strdup(temp_full);
d->name = strdup(name_full);
d->errors = 0;
stb_ptrmap_add(stb__files, f, d);
return f;
}
return NULL;
}
int stb_fclose(FILE *f, int keep)
{
stb__file_data *d;
int ok = STB_FALSE;
if (f == NULL) return 0;
if (ferror(f))
keep = stb_keep_no;
fclose(f);
if (stb__files && stb_ptrmap_remove(stb__files, f, (void **) &d)) {
if (stb__files->count == 0) {
stb_ptrmap_destroy(stb__files);
stb__files = NULL;
}
} else
return STB_TRUE; // not special
if (keep == stb_keep_if_different) {
// check if the files are identical
if (stb_feq(d->name, d->temp_name)) {
keep = stb_keep_no;
ok = STB_TRUE; // report success if no change
}
}
if (keep != stb_keep_no) {
if (stb_fexists(d->name) && remove(d->name)) {
// failed to delete old, so don't keep new
keep = stb_keep_no;
} else {
if (!stb_rename(d->temp_name, d->name))
ok = STB_TRUE;
else
keep=stb_keep_no;
}
}
if (keep == stb_keep_no)
remove(d->temp_name);
free(d->temp_name);
free(d->name);
free(d);
return ok;
}
int stb_copyfile(char *src, char *dest)
{
char raw_buffer[1024];
char *buffer;
int buf_size = 65536;
FILE *f, *g;
// if file already exists at destination, do nothing
if (stb_feq(src, dest)) return STB_TRUE;
// open file
f = stb__fopen(src, "rb");
if (f == NULL) return STB_FALSE;
// open file for writing
g = stb__fopen(dest, "wb");
if (g == NULL) {
fclose(f);
return STB_FALSE;
}
buffer = (char *) malloc(buf_size);
if (buffer == NULL) {
buffer = raw_buffer;
buf_size = sizeof(raw_buffer);
}
while (!feof(f)) {
int n = fread(buffer, 1, buf_size, f);
if (n != 0)
fwrite(buffer, 1, n, g);
}
fclose(f);
if (buffer != raw_buffer)
free(buffer);
fclose(g);
return STB_TRUE;
}
// varlen:
// v' = (v >> 31) + (v < 0 ? ~v : v)<<1; // small abs(v) => small v'
// output v as big endian v'+k for v' <= k:
// 1 byte : v' <= 0x00000080 ( -64 <= v < 64) 7 bits
// 2 bytes: v' <= 0x00004000 (-8192 <= v < 8192) 14 bits
// 3 bytes: v' <= 0x00200000 21 bits
// 4 bytes: v' <= 0x10000000 28 bits
// the number of most significant 1-bits in the first byte
// equals the number of bytes after the first
#define stb__varlen_xform(v) (v<0 ? (~v << 1)+1 : (v << 1))
int stb_size_varlen(int v) { return stb_size_varlenu(stb__varlen_xform(v)); }
int stb_size_varlenu(unsigned int v)
{
if (v < 0x00000080) return 1;
if (v < 0x00004000) return 2;
if (v < 0x00200000) return 3;
if (v < 0x10000000) return 4;
return 5;
}
void stb_fput_varlen(FILE *f, int v) { stb_fput_varlenu(f, stb__varlen_xform(v)); }
void stb_fput_varlenu(FILE *f, unsigned int z)
{
if (z >= 0x10000000) fputc(0xF0,f);
if (z >= 0x00200000) fputc((z < 0x10000000 ? 0xE0 : 0)+(z>>24),f);
if (z >= 0x00004000) fputc((z < 0x00200000 ? 0xC0 : 0)+(z>>16),f);
if (z >= 0x00000080) fputc((z < 0x00004000 ? 0x80 : 0)+(z>> 8),f);
fputc(z,f);
}
#define stb_fgetc(f) ((unsigned char) fgetc(f))
int stb_fget_varlen(FILE *f)
{
unsigned int z = stb_fget_varlenu(f);
return (z & 1) ? ~(z>>1) : (z>>1);
}
unsigned int stb_fget_varlenu(FILE *f)
{
unsigned int z;
unsigned char d;
d = stb_fgetc(f);
if (d >= 0x80) {
if (d >= 0xc0) {
if (d >= 0xe0) {
if (d == 0xf0) z = stb_fgetc(f) << 24;
else z = (d - 0xe0) << 24;
z += stb_fgetc(f) << 16;
}
else
z = (d - 0xc0) << 16;
z += stb_fgetc(f) << 8;
} else
z = (d - 0x80) << 8;
z += stb_fgetc(f);
} else
z = d;
return z;
}
stb_uint64 stb_fget_varlen64(FILE *f)
{
stb_uint64 z;
unsigned char d;
d = stb_fgetc(f);
if (d >= 0x80) {
if (d >= 0xc0) {
if (d >= 0xe0) {
if (d >= 0xf0) {
if (d >= 0xf8) {
if (d >= 0xfc) {
if (d >= 0xfe) {
if (d >= 0xff)
z = (stb_uint64) stb_fgetc(f) << 56;
else
z = (stb_uint64) (d - 0xfe) << 56;
z |= (stb_uint64) stb_fgetc(f) << 48;
} else z = (stb_uint64) (d - 0xfc) << 48;
z |= (stb_uint64) stb_fgetc(f) << 40;
} else z = (stb_uint64) (d - 0xf8) << 40;
z |= (stb_uint64) stb_fgetc(f) << 32;
} else z = (stb_uint64) (d - 0xf0) << 32;
z |= (stb_uint) stb_fgetc(f) << 24;
} else z = (stb_uint) (d - 0xe0) << 24;
z |= (stb_uint) stb_fgetc(f) << 16;
} else z = (stb_uint) (d - 0xc0) << 16;
z |= (stb_uint) stb_fgetc(f) << 8;
} else z = (stb_uint) (d - 0x80) << 8;
z |= stb_fgetc(f);
} else
z = d;
return (z & 1) ? ~(z >> 1) : (z >> 1);
}
int stb_size_varlen64(stb_uint64 v)
{
if (v < 0x00000080) return 1;
if (v < 0x00004000) return 2;
if (v < 0x00200000) return 3;
if (v < 0x10000000) return 4;
if (v < STB_IMM_UINT64(0x0000000800000000)) return 5;
if (v < STB_IMM_UINT64(0x0000040000000000)) return 6;
if (v < STB_IMM_UINT64(0x0002000000000000)) return 7;
if (v < STB_IMM_UINT64(0x0100000000000000)) return 8;
return 9;
}
void stb_fput_varlen64(FILE *f, stb_uint64 v)
{
stb_uint64 z = stb__varlen_xform(v);
int first=1;
if (z >= STB_IMM_UINT64(0x100000000000000)) {
fputc(0xff,f);
first=0;
}
if (z >= STB_IMM_UINT64(0x02000000000000)) fputc((first ? 0xFE : 0)+(char)(z>>56),f), first=0;
if (z >= STB_IMM_UINT64(0x00040000000000)) fputc((first ? 0xFC : 0)+(char)(z>>48),f), first=0;
if (z >= STB_IMM_UINT64(0x00000800000000)) fputc((first ? 0xF8 : 0)+(char)(z>>40),f), first=0;
if (z >= STB_IMM_UINT64(0x00000010000000)) fputc((first ? 0xF0 : 0)+(char)(z>>32),f), first=0;
if (z >= STB_IMM_UINT64(0x00000000200000)) fputc((first ? 0xE0 : 0)+(char)(z>>24),f), first=0;
if (z >= STB_IMM_UINT64(0x00000000004000)) fputc((first ? 0xC0 : 0)+(char)(z>>16),f), first=0;
if (z >= STB_IMM_UINT64(0x00000000000080)) fputc((first ? 0x80 : 0)+(char)(z>> 8),f), first=0;
fputc((char)z,f);
}
void stb_fput_ranged(FILE *f, int v, int b, stb_uint n)
{
v -= b;
if (n <= (1 << 31))
assert((stb_uint) v < n);
if (n > (1 << 24)) fputc(v >> 24, f);
if (n > (1 << 16)) fputc(v >> 16, f);
if (n > (1 << 8)) fputc(v >> 8, f);
fputc(v,f);
}
int stb_fget_ranged(FILE *f, int b, stb_uint n)
{
unsigned int v=0;
if (n > (1 << 24)) v += stb_fgetc(f) << 24;
if (n > (1 << 16)) v += stb_fgetc(f) << 16;
if (n > (1 << 8)) v += stb_fgetc(f) << 8;
v += stb_fgetc(f);
return b+v;
}
int stb_size_ranged(int b, stb_uint n)
{
if (n > (1 << 24)) return 4;
if (n > (1 << 16)) return 3;
if (n > (1 << 8)) return 2;
return 1;
}
void stb_fput_string(FILE *f, char *s)
{
int len = strlen(s);
stb_fput_varlenu(f, len);
fwrite(s, 1, len, f);
}
// inverse of the above algorithm
char *stb_fget_string(FILE *f, void *p)
{
char *s;
int len = stb_fget_varlenu(f);
if (len > 4096) return NULL;
s = p ? stb_malloc_string(p, len+1) : (char *) malloc(len+1);
fread(s, 1, len, f);
s[len] = 0;
return s;
}
char *stb_strdup(char *str, void *pool)
{
int len = strlen(str);
char *p = stb_malloc_string(pool, len+1);
strcpy(p, str);
return p;
}
// strip the trailing '/' or '\\' from a directory so we can refer to it
// as a file for _stat()
char *stb_strip_final_slash(char *t)
{
if (t[0]) {
char *z = t + strlen(t) - 1;
// *z is the last character
if (*z == '\\' || *z == '/')
if (z != t+2 || t[1] != ':') // but don't strip it if it's e.g. "c:/"
*z = 0;
if (*z == '\\')
*z = '/'; // canonicalize to make sure it matches db
}
return t;
}
char *stb_strip_final_slash_regardless(char *t)
{
if (t[0]) {
char *z = t + strlen(t) - 1;
// *z is the last character
if (*z == '\\' || *z == '/')
*z = 0;
if (*z == '\\')
*z = '/'; // canonicalize to make sure it matches db
}
return t;
}
#endif
//////////////////////////////////////////////////////////////////////////////
//
// Options parsing
//
STB_EXTERN char **stb_getopt_param(int *argc, char **argv, char *param);
STB_EXTERN char **stb_getopt(int *argc, char **argv);
STB_EXTERN void stb_getopt_free(char **opts);
#ifdef STB_DEFINE
void stb_getopt_free(char **opts)
{
int i;
char ** o2 = opts;
for (i=0; i < stb_arr_len(o2); ++i)
free(o2[i]);
stb_arr_free(o2);
}
char **stb_getopt(int *argc, char **argv)
{
return stb_getopt_param(argc, argv, "");
}
char **stb_getopt_param(int *argc, char **argv, char *param)
{
char ** opts=NULL;
int i,j=1;
for (i=1; i < *argc; ++i) {
if (argv[i][0] != '-') {
argv[j++] = argv[i];
} else {
if (argv[i][1] == 0) { // plain - == don't parse further options
++i;
while (i < *argc)
argv[j++] = argv[i++];
break;
} else {
int k;
char *q = argv[i]; // traverse options list
for (k=1; q[k]; ++k) {
char *s;
if (strchr(param, q[k])) { // does it take a parameter?
char *t = &q[k+1], z = q[k];
int len=0;
if (*t == 0) {
if (i == *argc-1) { // takes a parameter, but none found
*argc = 0;
stb_getopt_free(opts);
return NULL;
}
t = argv[++i];
} else
k += strlen(t);
len = strlen(t);
s = (char *) malloc(len+2);
if (!s) return NULL;
s[0] = z;
strcpy(s+1, t);
} else {
// no parameter
s = (char *) malloc(2);
if (!s) return NULL;
s[0] = q[k];
s[1] = 0;
}
stb_arr_push(opts, s);
}
}
}
}
stb_arr_push(opts, NULL);
*argc = j;
return opts;
}
#endif
//////////////////////////////////////////////////////////////////////////////
//
// Portable directory reading
//
STB_EXTERN char **stb_readdir_files (char *dir);
STB_EXTERN char **stb_readdir_files_mask(char *dir, char *wild);
STB_EXTERN char **stb_readdir_subdirs(char *dir);
STB_EXTERN char **stb_readdir_subdirs_mask(char *dir, char *wild);
STB_EXTERN void stb_readdir_free (char **files);
STB_EXTERN char **stb_readdir_recursive(char *dir, char *filespec);
STB_EXTERN void stb_delete_directory_recursive(char *dir);
#ifdef STB_DEFINE
#ifdef _MSC_VER
#include <io.h>
#else
#include <unistd.h>
#include <dirent.h>
#endif
void stb_readdir_free(char **files)
{
char **f2 = files;
int i;
for (i=0; i < stb_arr_len(f2); ++i)
free(f2[i]);
stb_arr_free(f2);
}
static int isdotdirname(char *name)
{
if (name[0] == '.')
return (name[1] == '.') ? !name[2] : !name[1];
return 0;
}
STB_EXTERN int stb_wildmatchi(char *expr, char *candidate);
static char **readdir_raw(char *dir, int return_subdirs, char *mask)
{
char **results = NULL;
char buffer[4096], with_slash[4096];
size_t n;
#ifdef _MSC_VER
stb__wchar *ws;
struct _wfinddata_t data;
#ifdef _WIN64
const intptr_t none = -1;
intptr_t z;
#else
const long none = -1;
long z;
#endif
#else // !_MSC_VER
const DIR *none = NULL;
DIR *z;
#endif
n = stb_strscpy(buffer,dir,sizeof(buffer));
if (!n || n >= sizeof(buffer))
return NULL;
stb_fixpath(buffer);
n--;
if (n > 0 && (buffer[n-1] != '/')) {
buffer[n++] = '/';
}
buffer[n] = 0;
if (!stb_strscpy(with_slash,buffer,sizeof(with_slash)))
return NULL;
#ifdef _MSC_VER
if (!stb_strscpy(buffer+n,"*.*",sizeof(buffer)-n))
return NULL;
ws = stb__from_utf8(buffer);
z = _wfindfirst((const wchar_t *)ws, &data);
#else
z = opendir(dir);
#endif
if (z != none) {
int nonempty = STB_TRUE;
#ifndef _MSC_VER
struct dirent *data = readdir(z);
nonempty = (data != NULL);
#endif
if (nonempty) {
do {
int is_subdir;
#ifdef _MSC_VER
char *name = stb__to_utf8((stb__wchar *)data.name);
if (name == NULL) {
fprintf(stderr, "%s to convert '%S' to %s!\n", "Unable", data.name, "utf8");
continue;
}
is_subdir = !!(data.attrib & _A_SUBDIR);
#else
char *name = data->d_name;
if (!stb_strscpy(buffer+n,name,sizeof(buffer)-n))
break;
// Could follow DT_LNK, but would need to check for recursive links.
is_subdir = !!(data->d_type & DT_DIR);
#endif
if (is_subdir == return_subdirs) {
if (!is_subdir || !isdotdirname(name)) {
if (!mask || stb_wildmatchi(mask, name)) {
char buffer[4096],*p=buffer;
if ( stb_snprintf(buffer, sizeof(buffer), "%s%s", with_slash, name) < 0 )
break;
if (buffer[0] == '.' && buffer[1] == '/')
p = buffer+2;
stb_arr_push(results, strdup(p));
}
}
}
}
#ifdef _MSC_VER
while (0 == _wfindnext(z, &data));
#else
while ((data = readdir(z)) != NULL);
#endif
}
#ifdef _MSC_VER
_findclose(z);
#else
closedir(z);
#endif
}
return results;
}
char **stb_readdir_files (char *dir) { return readdir_raw(dir, 0, NULL); }
char **stb_readdir_subdirs(char *dir) { return readdir_raw(dir, 1, NULL); }
char **stb_readdir_files_mask(char *dir, char *wild) { return readdir_raw(dir, 0, wild); }
char **stb_readdir_subdirs_mask(char *dir, char *wild) { return readdir_raw(dir, 1, wild); }
int stb__rec_max=0x7fffffff;
static char **stb_readdir_rec(char **sofar, char *dir, char *filespec)
{
char **files;
char ** dirs;
char **p;
if (stb_arr_len(sofar) >= stb__rec_max) return sofar;
files = stb_readdir_files_mask(dir, filespec);
stb_arr_for(p, files) {
stb_arr_push(sofar, strdup(*p));
if (stb_arr_len(sofar) >= stb__rec_max) break;
}
stb_readdir_free(files);
if (stb_arr_len(sofar) >= stb__rec_max) return sofar;
dirs = stb_readdir_subdirs(dir);
stb_arr_for(p, dirs)
sofar = stb_readdir_rec(sofar, *p, filespec);
stb_readdir_free(dirs);
return sofar;
}
char **stb_readdir_recursive(char *dir, char *filespec)
{
return stb_readdir_rec(NULL, dir, filespec);
}
void stb_delete_directory_recursive(char *dir)
{
char **list = stb_readdir_subdirs(dir);
int i;
for (i=0; i < stb_arr_len(list); ++i)
stb_delete_directory_recursive(list[i]);
stb_arr_free(list);
list = stb_readdir_files(dir);
for (i=0; i < stb_arr_len(list); ++i)
if (!remove(list[i])) {
// on windows, try again after making it writeable; don't ALWAYS
// do this first since that would be slow in the normal case
#ifdef _MSC_VER
_chmod(list[i], _S_IWRITE);
remove(list[i]);
#endif
}
stb_arr_free(list);
stb__windows(_rmdir,rmdir)(dir);
}
#endif
//////////////////////////////////////////////////////////////////////////////
//
// construct trees from filenames; useful for cmirror summaries
typedef struct stb_dirtree2 stb_dirtree2;
struct stb_dirtree2
{
stb_dirtree2 **subdirs;
// make convenient for stb_summarize_tree
int num_subdir;
float weight;
// actual data
char *fullpath;
char *relpath;
char **files;
};
STB_EXTERN stb_dirtree2 *stb_dirtree2_from_files_relative(char *src, char **filelist, int count);
STB_EXTERN stb_dirtree2 *stb_dirtree2_from_files(char **filelist, int count);
STB_EXTERN int stb_dir_is_prefix(char *dir, int dirlen, char *file);
#ifdef STB_DEFINE
int stb_dir_is_prefix(char *dir, int dirlen, char *file)
{
if (dirlen == 0) return STB_TRUE;
if (stb_strnicmp(dir, file, dirlen)) return STB_FALSE;
if (file[dirlen] == '/' || file[dirlen] == '\\') return STB_TRUE;
return STB_FALSE;
}
stb_dirtree2 *stb_dirtree2_from_files_relative(char *src, char **filelist, int count)
{
char buffer1[1024];
int i;
int dlen = strlen(src), elen;
stb_dirtree2 *d;
char ** descendents = NULL;
char ** files = NULL;
char *s;
if (!count) return NULL;
// first find all the ones that belong here... note this is will take O(NM) with N files and M subdirs
for (i=0; i < count; ++i) {
if (stb_dir_is_prefix(src, dlen, filelist[i])) {
stb_arr_push(descendents, filelist[i]);
}
}
if (descendents == NULL)
return NULL;
elen = dlen;
// skip a leading slash
if (elen == 0 && (descendents[0][0] == '/' || descendents[0][0] == '\\'))
++elen;
else if (elen)
++elen;
// now extract all the ones that have their root here
for (i=0; i < stb_arr_len(descendents);) {
if (!stb_strchr2(descendents[i]+elen, '/', '\\')) {
stb_arr_push(files, descendents[i]);
descendents[i] = descendents[stb_arr_len(descendents)-1];
stb_arr_pop(descendents);
} else
++i;
}
// now create a record
d = (stb_dirtree2 *) malloc(sizeof(*d));
d->files = files;
d->subdirs = NULL;
d->fullpath = strdup(src);
s = stb_strrchr2(d->fullpath, '/', '\\');
if (s)
++s;
else
s = d->fullpath;
d->relpath = s;
// now create the children
qsort(descendents, stb_arr_len(descendents), sizeof(char *), stb_qsort_stricmp(0));
buffer1[0] = 0;
for (i=0; i < stb_arr_len(descendents); ++i) {
char buffer2[1024];
char *s = descendents[i] + elen, *t;
t = stb_strchr2(s, '/', '\\');
assert(t);
stb_strncpy(buffer2, descendents[i], t-descendents[i]+1);
if (stb_stricmp(buffer1, buffer2)) {
stb_dirtree2 *t = stb_dirtree2_from_files_relative(buffer2, descendents, stb_arr_len(descendents));
assert(t != NULL);
strcpy(buffer1, buffer2);
stb_arr_push(d->subdirs, t);
}
}
d->num_subdir = stb_arr_len(d->subdirs);
d->weight = 0;
return d;
}
stb_dirtree2 *stb_dirtree2_from_files(char **filelist, int count)
{
return stb_dirtree2_from_files_relative("", filelist, count);
}
#endif
//////////////////////////////////////////////////////////////////////////////
//
// Checksums: CRC-32, ADLER32, SHA-1
//
// CRC-32 and ADLER32 allow streaming blocks
// SHA-1 requires either a complete buffer, max size 2^32 - 73
// or it can checksum directly from a file, max 2^61
#define STB_ADLER32_SEED 1
#define STB_CRC32_SEED 0 // note that we logical NOT this in the code
STB_EXTERN stb_uint
stb_adler32(stb_uint adler32, stb_uchar *buffer, stb_uint buflen);
STB_EXTERN stb_uint
stb_crc32_block(stb_uint crc32, stb_uchar *buffer, stb_uint len);
STB_EXTERN stb_uint stb_crc32(unsigned char *buffer, stb_uint len);
STB_EXTERN void stb_sha1(
unsigned char output[20], unsigned char *buffer, unsigned int len);
STB_EXTERN int stb_sha1_file(unsigned char output[20], char *file);
STB_EXTERN void stb_sha1_readable(char display[27], unsigned char sha[20]);
#ifdef STB_DEFINE
stb_uint stb_crc32_block(stb_uint crc, unsigned char *buffer, stb_uint len)
{
static stb_uint crc_table[256];
stb_uint i,j,s;
crc = ~crc;
if (crc_table[1] == 0)
for(i=0; i < 256; i++) {
for (s=i, j=0; j < 8; ++j)
s = (s >> 1) ^ (s & 1 ? 0xedb88320 : 0);
crc_table[i] = s;
}
for (i=0; i < len; ++i)
crc = (crc >> 8) ^ crc_table[buffer[i] ^ (crc & 0xff)];
return ~crc;
}
stb_uint stb_crc32(unsigned char *buffer, stb_uint len)
{
return stb_crc32_block(0, buffer, len);
}
stb_uint stb_adler32(stb_uint adler32, stb_uchar *buffer, stb_uint buflen)
{
const unsigned long ADLER_MOD = 65521;
unsigned long s1 = adler32 & 0xffff, s2 = adler32 >> 16;
unsigned long blocklen, i;
blocklen = buflen % 5552;
while (buflen) {
for (i=0; i + 7 < blocklen; i += 8) {
s1 += buffer[0], s2 += s1;
s1 += buffer[1], s2 += s1;
s1 += buffer[2], s2 += s1;
s1 += buffer[3], s2 += s1;
s1 += buffer[4], s2 += s1;
s1 += buffer[5], s2 += s1;
s1 += buffer[6], s2 += s1;
s1 += buffer[7], s2 += s1;
buffer += 8;
}
for (; i < blocklen; ++i)
s1 += *buffer++, s2 += s1;
s1 %= ADLER_MOD, s2 %= ADLER_MOD;
buflen -= blocklen;
blocklen = 5552;
}
return (s2 << 16) + s1;
}
static void stb__sha1(stb_uchar *chunk, stb_uint h[5])
{
int i;
stb_uint a,b,c,d,e;
stb_uint w[80];
for (i=0; i < 16; ++i)
w[i] = stb_big32(&chunk[i*4]);
for (i=16; i < 80; ++i) {
stb_uint t;
t = w[i-3] ^ w[i-8] ^ w[i-14] ^ w[i-16];
w[i] = (t + t) | (t >> 31);
}
a = h[0];
b = h[1];
c = h[2];
d = h[3];
e = h[4];
#define STB__SHA1(k,f) \
{ \
stb_uint temp = (a << 5) + (a >> 27) + (f) + e + (k) + w[i]; \
e = d; \
d = c; \
c = (b << 30) + (b >> 2); \
b = a; \
a = temp; \
}
i=0;
for (; i < 20; ++i) STB__SHA1(0x5a827999, d ^ (b & (c ^ d)) );
for (; i < 40; ++i) STB__SHA1(0x6ed9eba1, b ^ c ^ d );
for (; i < 60; ++i) STB__SHA1(0x8f1bbcdc, (b & c) + (d & (b ^ c)) );
for (; i < 80; ++i) STB__SHA1(0xca62c1d6, b ^ c ^ d );
#undef STB__SHA1
h[0] += a;
h[1] += b;
h[2] += c;
h[3] += d;
h[4] += e;
}
void stb_sha1(stb_uchar output[20], stb_uchar *buffer, stb_uint len)
{
unsigned char final_block[128];
stb_uint end_start, final_len, j;
int i;
stb_uint h[5];
h[0] = 0x67452301;
h[1] = 0xefcdab89;
h[2] = 0x98badcfe;
h[3] = 0x10325476;
h[4] = 0xc3d2e1f0;
// we need to write padding to the last one or two
// blocks, so build those first into 'final_block'
// we have to write one special byte, plus the 8-byte length
// compute the block where the data runs out
end_start = len & ~63;
// compute the earliest we can encode the length
if (((len+9) & ~63) == end_start) {
// it all fits in one block, so fill a second-to-last block
end_start -= 64;
}
final_len = end_start + 128;
// now we need to copy the data in
assert(end_start + 128 >= len+9);
assert(end_start < len || len < 64-9);
j = 0;
if (end_start > len)
j = (stb_uint) - (int) end_start;
for (; end_start + j < len; ++j)
final_block[j] = buffer[end_start + j];
final_block[j++] = 0x80;
while (j < 128-5) // 5 byte length, so write 4 extra padding bytes
final_block[j++] = 0;
// big-endian size
final_block[j++] = len >> 29;
final_block[j++] = len >> 21;
final_block[j++] = len >> 13;
final_block[j++] = len >> 5;
final_block[j++] = len << 3;
assert(j == 128 && end_start + j == final_len);
for (j=0; j < final_len; j += 64) { // 512-bit chunks
if (j+64 >= end_start+64)
stb__sha1(&final_block[j - end_start], h);
else
stb__sha1(&buffer[j], h);
}
for (i=0; i < 5; ++i) {
output[i*4 + 0] = h[i] >> 24;
output[i*4 + 1] = h[i] >> 16;
output[i*4 + 2] = h[i] >> 8;
output[i*4 + 3] = h[i] >> 0;
}
}
#ifdef _MSC_VER
int stb_sha1_file(stb_uchar output[20], char *file)
{
int i;
stb_uint64 length=0;
unsigned char buffer[128];
FILE *f = stb__fopen(file, "rb");
stb_uint h[5];
if (f == NULL) return 0; // file not found
h[0] = 0x67452301;
h[1] = 0xefcdab89;
h[2] = 0x98badcfe;
h[3] = 0x10325476;
h[4] = 0xc3d2e1f0;
for(;;) {
int n = fread(buffer, 1, 64, f);
if (n == 64) {
stb__sha1(buffer, h);
length += n;
} else {
int block = 64;
length += n;
buffer[n++] = 0x80;
// if there isn't enough room for the length, double the block
if (n + 8 > 64)
block = 128;
// pad to end
memset(buffer+n, 0, block-8-n);
i = block - 8;
buffer[i++] = (stb_uchar) (length >> 53);
buffer[i++] = (stb_uchar) (length >> 45);
buffer[i++] = (stb_uchar) (length >> 37);
buffer[i++] = (stb_uchar) (length >> 29);
buffer[i++] = (stb_uchar) (length >> 21);
buffer[i++] = (stb_uchar) (length >> 13);
buffer[i++] = (stb_uchar) (length >> 5);
buffer[i++] = (stb_uchar) (length << 3);
assert(i == block);
stb__sha1(buffer, h);
if (block == 128)
stb__sha1(buffer+64, h);
else
assert(block == 64);
break;
}
}
fclose(f);
for (i=0; i < 5; ++i) {
output[i*4 + 0] = h[i] >> 24;
output[i*4 + 1] = h[i] >> 16;
output[i*4 + 2] = h[i] >> 8;
output[i*4 + 3] = h[i] >> 0;
}
return 1;
}
#endif // _MSC_VER
// client can truncate this wherever they like
void stb_sha1_readable(char display[27], unsigned char sha[20])
{
char encoding[65] = "0123456789abcdefghijklmnopqrstuv"
"wxyzABCDEFGHIJKLMNOPQRSTUVWXYZ%$";
int num_bits = 0, acc=0;
int i=0,o=0;
while (o < 26) {
int v;
// expand the accumulator
if (num_bits < 6) {
assert(i != 20);
acc += sha[i++] << num_bits;
num_bits += 8;
}
v = acc & ((1 << 6) - 1);
display[o++] = encoding[v];
acc >>= 6;
num_bits -= 6;
}
assert(num_bits == 20*8 - 26*6);
display[o++] = encoding[acc];
}
#endif // STB_DEFINE
///////////////////////////////////////////////////////////
//
// simplified WINDOWS registry interface... hopefully
// we'll never actually use this?
#if defined(_WIN32)
STB_EXTERN void * stb_reg_open(char *mode, char *where); // mode: "rHKLM" or "rHKCU" or "w.."
STB_EXTERN void stb_reg_close(void *reg);
STB_EXTERN int stb_reg_read(void *zreg, char *str, void *data, unsigned long len);
STB_EXTERN int stb_reg_read_string(void *zreg, char *str, char *data, int len);
STB_EXTERN void stb_reg_write(void *zreg, char *str, void *data, unsigned long len);
STB_EXTERN void stb_reg_write_string(void *zreg, char *str, char *data);
#if defined(STB_DEFINE) && !defined(STB_NO_REGISTRY)
#define STB_HAS_REGISTRY
#ifndef _WINDOWS_
#define HKEY void *
STB_EXTERN __declspec(dllimport) long __stdcall RegCloseKey ( HKEY hKey );
STB_EXTERN __declspec(dllimport) long __stdcall RegCreateKeyExA ( HKEY hKey, const char * lpSubKey,
int Reserved, char * lpClass, int dwOptions,
int samDesired, void *lpSecurityAttributes, HKEY * phkResult, int * lpdwDisposition );
STB_EXTERN __declspec(dllimport) long __stdcall RegDeleteKeyA ( HKEY hKey, const char * lpSubKey );
STB_EXTERN __declspec(dllimport) long __stdcall RegQueryValueExA ( HKEY hKey, const char * lpValueName,
int * lpReserved, unsigned long * lpType, unsigned char * lpData, unsigned long * lpcbData );
STB_EXTERN __declspec(dllimport) long __stdcall RegSetValueExA ( HKEY hKey, const char * lpValueName,
int Reserved, int dwType, const unsigned char* lpData, int cbData );
STB_EXTERN __declspec(dllimport) long __stdcall RegOpenKeyExA ( HKEY hKey, const char * lpSubKey,
int ulOptions, int samDesired, HKEY * phkResult );
#endif // _WINDOWS_
#define STB__REG_OPTION_NON_VOLATILE 0
#define STB__REG_KEY_ALL_ACCESS 0x000f003f
#define STB__REG_KEY_READ 0x00020019
void *stb_reg_open(char *mode, char *where)
{
long res;
HKEY base;
HKEY zreg;
if (!stb_stricmp(mode+1, "cu") || !stb_stricmp(mode+1, "hkcu"))
base = (HKEY) 0x80000001; // HKCU
else if (!stb_stricmp(mode+1, "lm") || !stb_stricmp(mode+1, "hklm"))
base = (HKEY) 0x80000002; // HKLM
else
return NULL;
if (mode[0] == 'r')
res = RegOpenKeyExA(base, where, 0, STB__REG_KEY_READ, &zreg);
else if (mode[0] == 'w')
res = RegCreateKeyExA(base, where, 0, NULL, STB__REG_OPTION_NON_VOLATILE, STB__REG_KEY_ALL_ACCESS, NULL, &zreg, NULL);
else
return NULL;
return res ? NULL : zreg;
}
void stb_reg_close(void *reg)
{
RegCloseKey((HKEY) reg);
}
#define STB__REG_SZ 1
#define STB__REG_BINARY 3
#define STB__REG_DWORD 4
int stb_reg_read(void *zreg, char *str, void *data, unsigned long len)
{
unsigned long type;
unsigned long alen = len;
if (0 == RegQueryValueExA((HKEY) zreg, str, 0, &type, (unsigned char *) data, &len))
if (type == STB__REG_BINARY || type == STB__REG_SZ || type == STB__REG_DWORD) {
if (len < alen)
*((char *) data + len) = 0;
return 1;
}
return 0;
}
void stb_reg_write(void *zreg, char *str, void *data, unsigned long len)
{
if (zreg)
RegSetValueExA((HKEY) zreg, str, 0, STB__REG_BINARY, (const unsigned char *) data, len);
}
int stb_reg_read_string(void *zreg, char *str, char *data, int len)
{
if (!stb_reg_read(zreg, str, data, len)) return 0;
data[len-1] = 0; // force a 0 at the end of the string no matter what
return 1;
}
void stb_reg_write_string(void *zreg, char *str, char *data)
{
if (zreg)
RegSetValueExA((HKEY) zreg, str, 0, STB__REG_SZ, (const unsigned char *) data, strlen(data)+1);
}
#endif // STB_DEFINE
#endif // _WIN32
//////////////////////////////////////////////////////////////////////////////
//
// stb_cfg - This is like the registry, but the config info
// is all stored in plain old files where we can
// backup and restore them easily. The LOCATION of
// the config files is gotten from... the registry!
#ifndef STB_NO_STB_STRINGS
typedef struct stb_cfg_st stb_cfg;
STB_EXTERN stb_cfg * stb_cfg_open(char *config, char *mode); // mode = "r", "w"
STB_EXTERN void stb_cfg_close(stb_cfg *cfg);
STB_EXTERN int stb_cfg_read(stb_cfg *cfg, char *key, void *value, int len);
STB_EXTERN void stb_cfg_write(stb_cfg *cfg, char *key, void *value, int len);
STB_EXTERN int stb_cfg_read_string(stb_cfg *cfg, char *key, char *value, int len);
STB_EXTERN void stb_cfg_write_string(stb_cfg *cfg, char *key, char *value);
STB_EXTERN int stb_cfg_delete(stb_cfg *cfg, char *key);
STB_EXTERN void stb_cfg_set_directory(char *dir);
#ifdef STB_DEFINE
typedef struct
{
char *key;
void *value;
int value_len;
} stb__cfg_item;
struct stb_cfg_st
{
stb__cfg_item *data;
char *loaded_file; // this needs to be freed
FILE *f; // write the data to this file on close
};
static char *stb__cfg_sig = "sTbCoNfIg!\0\0";
static char stb__cfg_dir[512];
STB_EXTERN void stb_cfg_set_directory(char *dir)
{
strcpy(stb__cfg_dir, dir);
}
STB_EXTERN stb_cfg * stb_cfg_open(char *config, char *mode)
{
size_t len;
stb_cfg *z;
char file[512];
if (mode[0] != 'r' && mode[0] != 'w') return NULL;
if (!stb__cfg_dir[0]) {
#ifdef _WIN32
strcpy(stb__cfg_dir, "c:/stb");
#else
strcpy(stb__cfg_dir, "~/.stbconfig");
#endif
#ifdef STB_HAS_REGISTRY
{
void *reg = stb_reg_open("rHKLM", "Software\\SilverSpaceship\\stb");
if (reg) {
stb_reg_read_string(reg, "config_dir", stb__cfg_dir, sizeof(stb__cfg_dir));
stb_reg_close(reg);
}
}
#endif
}
sprintf(file, "%s/%s.cfg", stb__cfg_dir, config);
z = (stb_cfg *) stb_malloc(0, sizeof(*z));
z->data = NULL;
z->loaded_file = stb_filec(file, &len);
if (z->loaded_file) {
char *s = z->loaded_file;
if (!memcmp(s, stb__cfg_sig, 12)) {
char *s = z->loaded_file + 12;
while (s < z->loaded_file + len) {
stb__cfg_item a;
int n = *(stb_int16 *) s;
a.key = s+2;
s = s+2 + n;
a.value_len = *(int *) s;
s += 4;
a.value = s;
s += a.value_len;
stb_arr_push(z->data, a);
}
assert(s == z->loaded_file + len);
}
}
if (mode[0] == 'w')
z->f = fopen(file, "wb");
else
z->f = NULL;
return z;
}
void stb_cfg_close(stb_cfg *z)
{
if (z->f) {
int i;
// write the file out
fwrite(stb__cfg_sig, 12, 1, z->f);
for (i=0; i < stb_arr_len(z->data); ++i) {
stb_int16 n = strlen(z->data[i].key)+1;
fwrite(&n, 2, 1, z->f);
fwrite(z->data[i].key, n, 1, z->f);
fwrite(&z->data[i].value_len, 4, 1, z->f);
fwrite(z->data[i].value, z->data[i].value_len, 1, z->f);
}
fclose(z->f);
}
stb_arr_free(z->data);
stb_free(z);
}
int stb_cfg_read(stb_cfg *z, char *key, void *value, int len)
{
int i;
for (i=0; i < stb_arr_len(z->data); ++i) {
if (!stb_stricmp(z->data[i].key, key)) {
int n = stb_min(len, z->data[i].value_len);
memcpy(value, z->data[i].value, n);
if (n < len)
*((char *) value + n) = 0;
return 1;
}
}
return 0;
}
void stb_cfg_write(stb_cfg *z, char *key, void *value, int len)
{
int i;
for (i=0; i < stb_arr_len(z->data); ++i)
if (!stb_stricmp(z->data[i].key, key))
break;
if (i == stb_arr_len(z->data)) {
stb__cfg_item p;
p.key = stb_strdup(key, z);
p.value = NULL;
p.value_len = 0;
stb_arr_push(z->data, p);
}
z->data[i].value = stb_malloc(z, len);
z->data[i].value_len = len;
memcpy(z->data[i].value, value, len);
}
int stb_cfg_delete(stb_cfg *z, char *key)
{
int i;
for (i=0; i < stb_arr_len(z->data); ++i)
if (!stb_stricmp(z->data[i].key, key)) {
stb_arr_fastdelete(z->data, i);
return 1;
}
return 0;
}
int stb_cfg_read_string(stb_cfg *z, char *key, char *value, int len)
{
if (!stb_cfg_read(z, key, value, len)) return 0;
value[len-1] = 0;
return 1;
}
void stb_cfg_write_string(stb_cfg *z, char *key, char *value)
{
stb_cfg_write(z, key, value, strlen(value)+1);
}
#endif
//////////////////////////////////////////////////////////////////////////////
//
// stb_dirtree - load a description of a directory tree
// uses a cache and stat()s the directories for changes
// MUCH faster on NTFS, _wrong_ on FAT32, so should
// ignore the db on FAT32
#ifdef _WIN32
typedef struct
{
char * path; // full path from passed-in root
time_t last_modified;
int num_files;
int flag;
} stb_dirtree_dir;
typedef struct
{
char *name; // name relative to path
int dir; // index into dirs[] array
stb_int64 size; // size, max 4GB
time_t last_modified;
int flag;
} stb_dirtree_file;
typedef struct
{
stb_dirtree_dir *dirs;
stb_dirtree_file *files;
// internal use
void * string_pool; // used to free data en masse
} stb_dirtree;
extern void stb_dirtree_free ( stb_dirtree *d );
extern stb_dirtree *stb_dirtree_get ( char *dir);
extern stb_dirtree *stb_dirtree_get_dir ( char *dir, char *cache_dir);
extern stb_dirtree *stb_dirtree_get_with_file ( char *dir, char *cache_file);
// get a list of all the files recursively underneath 'dir'
//
// cache_file is used to store a copy of the directory tree to speed up
// later calls. It must be unique to 'dir' and the current working
// directory! Otherwise who knows what will happen (a good solution
// is to put it _in_ dir, but this API doesn't force that).
//
// Also, it might be possible to break this if you have two different processes
// do a call to stb_dirtree_get() with the same cache file at about the same
// time, but I _think_ it might just work.
// i needed to build an identical data structure representing the state of
// a mirrored copy WITHOUT bothering to rescan it (i.e. we're mirroring to
// it WITHOUT scanning it, e.g. it's over the net), so this requires access
// to all of the innards.
extern void stb_dirtree_db_add_dir(stb_dirtree *active, char *path, time_t last);
extern void stb_dirtree_db_add_file(stb_dirtree *active, char *name, int dir, stb_int64 size, time_t last);
extern void stb_dirtree_db_read(stb_dirtree *target, char *filename, char *dir);
extern void stb_dirtree_db_write(stb_dirtree *target, char *filename, char *dir);
#ifdef STB_DEFINE
static void stb__dirtree_add_dir(char *path, time_t last, stb_dirtree *active)
{
stb_dirtree_dir d;
d.last_modified = last;
d.num_files = 0;
d.path = stb_strdup(path, active->string_pool);
stb_arr_push(active->dirs, d);
}
static void stb__dirtree_add_file(char *name, int dir, stb_int64 size, time_t last, stb_dirtree *active)
{
stb_dirtree_file f;
f.dir = dir;
f.size = size;
f.last_modified = last;
f.name = stb_strdup(name, active->string_pool);
++active->dirs[dir].num_files;
stb_arr_push(active->files, f);
}
// version 02 supports > 4GB files
static char stb__signature[12] = { 's', 'T', 'b', 'D', 'i', 'R', 't', 'R', 'e', 'E', '0', '2' };
static void stb__dirtree_save_db(char *filename, stb_dirtree *data, char *root)
{
int i, num_dirs_final=0, num_files_final;
char *info = root ? root : "";
int *remap;
FILE *f = fopen(filename, "wb");
if (!f) return;
fwrite(stb__signature, sizeof(stb__signature), 1, f);
fwrite(info, strlen(info)+1, 1, f);
// need to be slightly tricky and not write out NULLed directories, nor the root
// build remapping table of all dirs we'll be writing out
remap = (int *) malloc(sizeof(remap[0]) * stb_arr_len(data->dirs));
for (i=0; i < stb_arr_len(data->dirs); ++i) {
if (data->dirs[i].path == NULL || (root && 0==stb_stricmp(data->dirs[i].path, root))) {
remap[i] = -1;
} else {
remap[i] = num_dirs_final++;
}
}
fwrite(&num_dirs_final, 4, 1, f);
for (i=0; i < stb_arr_len(data->dirs); ++i) {
if (remap[i] >= 0) {
fwrite(&data->dirs[i].last_modified, 4, 1, f);
stb_fput_string(f, data->dirs[i].path);
}
}
num_files_final = 0;
for (i=0; i < stb_arr_len(data->files); ++i)
if (remap[data->files[i].dir] >= 0 && data->files[i].name)
++num_files_final;
fwrite(&num_files_final, 4, 1, f);
for (i=0; i < stb_arr_len(data->files); ++i) {
if (remap[data->files[i].dir] >= 0 && data->files[i].name) {
stb_fput_ranged(f, remap[data->files[i].dir], 0, num_dirs_final);
stb_fput_varlen64(f, data->files[i].size);
fwrite(&data->files[i].last_modified, 4, 1, f);
stb_fput_string(f, data->files[i].name);
}
}
fclose(f);
}
// note: stomps any existing data, rather than appending
static void stb__dirtree_load_db(char *filename, stb_dirtree *data, char *dir)
{
char sig[2048];
int i,n;
FILE *f = fopen(filename, "rb");
if (!f) return;
data->string_pool = stb_malloc(0,1);
fread(sig, sizeof(stb__signature), 1, f);
if (memcmp(stb__signature, sig, sizeof(stb__signature))) { fclose(f); return; }
if (!fread(sig, strlen(dir)+1, 1, f)) { fclose(f); return; }
if (stb_stricmp(sig,dir)) { fclose(f); return; }
// we can just read them straight in, because they're guaranteed to be valid
fread(&n, 4, 1, f);
stb_arr_setlen(data->dirs, n);
for(i=0; i < stb_arr_len(data->dirs); ++i) {
fread(&data->dirs[i].last_modified, 4, 1, f);
data->dirs[i].path = stb_fget_string(f, data->string_pool);
if (data->dirs[i].path == NULL) goto bail;
}
fread(&n, 4, 1, f);
stb_arr_setlen(data->files, n);
for (i=0; i < stb_arr_len(data->files); ++i) {
data->files[i].dir = stb_fget_ranged(f, 0, stb_arr_len(data->dirs));
data->files[i].size = stb_fget_varlen64(f);
fread(&data->files[i].last_modified, 4, 1, f);
data->files[i].name = stb_fget_string(f, data->string_pool);
if (data->files[i].name == NULL) goto bail;
}
if (0) {
bail:
stb_arr_free(data->dirs);
stb_arr_free(data->files);
}
fclose(f);
}
static int stb__dircount, stb__dircount_mask, stb__showfile;
static void stb__dirtree_scandir(char *path, time_t last_time, stb_dirtree *active)
{
// this is dumb depth first; theoretically it might be faster
// to fully traverse each directory before visiting its children,
// but it's complicated and didn't seem like a gain in the test app
int n;
struct _wfinddatai64_t c_file;
long hFile;
stb__wchar full_path[1024];
int has_slash;
if (stb__showfile) printf("<");
has_slash = (path[0] && path[strlen(path)-1] == '/');
// @TODO: do this concatenation without using swprintf to avoid this mess:
#if defined(_MSC_VER) && _MSC_VER < 1400
if (has_slash)
swprintf(full_path, L"%s*", stb__from_utf8(path));
else
swprintf(full_path, L"%s/*", stb__from_utf8(path));
#else
if (has_slash)
swprintf(full_path, 1024, L"%s*", stb__from_utf8(path));
else
swprintf(full_path, 1024, L"%s/*", stb__from_utf8(path));
#endif
// it's possible this directory is already present: that means it was in the
// cache, but its parent wasn't... in that case, we're done with it
if (stb__showfile) printf("C[%d]", stb_arr_len(active->dirs));
for (n=0; n < stb_arr_len(active->dirs); ++n)
if (0 == stb_stricmp(active->dirs[n].path, path)) {
if (stb__showfile) printf("D");
return;
}
if (stb__showfile) printf("E");
// otherwise, we need to add it
stb__dirtree_add_dir(path, last_time, active);
n = stb_arr_lastn(active->dirs);
if (stb__showfile) printf("[");
if( (hFile = _wfindfirsti64( full_path, &c_file )) != -1L ) {
do {
if (stb__showfile) printf(")");
if (c_file.attrib & _A_SUBDIR) {
// ignore subdirectories starting with '.', e.g. "." and ".."
if (c_file.name[0] != '.') {
char *new_path = (char *) full_path;
char *temp = stb__to_utf8(c_file.name);
if (has_slash)
sprintf(new_path, "%s%s", path, temp);
else
sprintf(new_path, "%s/%s", path, temp);
if (stb__dircount_mask) {
++stb__dircount;
if (!(stb__dircount & stb__dircount_mask)) {
printf("%s\r", new_path);
}
}
stb__dirtree_scandir(new_path, c_file.time_write, active);
}
} else {
char *temp = stb__to_utf8(c_file.name);
stb__dirtree_add_file(temp, n, c_file.size, c_file.time_write, active);
}
if (stb__showfile) printf("(");
} while( _wfindnexti64( hFile, &c_file ) == 0 );
if (stb__showfile) printf("]");
_findclose( hFile );
}
if (stb__showfile) printf(">\n");
}
// scan the database and see if it's all valid
static int stb__dirtree_update_db(stb_dirtree *db, stb_dirtree *active)
{
int changes_detected = STB_FALSE;
int i;
int *remap;
int *rescan=NULL;
remap = (int *) malloc(sizeof(remap[0]) * stb_arr_len(db->dirs));
memset(remap, 0, sizeof(remap[0]) * stb_arr_len(db->dirs));
rescan = NULL;
for (i=0; i < stb_arr_len(db->dirs); ++i) {
struct _stat info;
if (stb__dircount_mask) {
++stb__dircount;
if (!(stb__dircount & stb__dircount_mask)) {
printf(".");
}
}
if (0 == _stat(db->dirs[i].path, &info)) {
if (info.st_mode & _S_IFDIR) {
// it's still a directory, as expected
int n = abs(info.st_mtime - db->dirs[i].last_modified);
if (n > 1 && n != 3600) { // the 3600 is a hack because sometimes this jumps for no apparent reason, even when no time zone or DST issues are at play
// it's changed! force a rescan
// we don't want to scan it until we've stat()d its
// subdirs, though, so we queue it
if (stb__showfile) printf("Changed: %s - %08x:%08x\n", db->dirs[i].path, db->dirs[i].last_modified, info.st_mtime);
stb_arr_push(rescan, i);
// update the last_mod time
db->dirs[i].last_modified = info.st_mtime;
// ignore existing files in this dir
remap[i] = -1;
changes_detected = STB_TRUE;
} else {
// it hasn't changed, just copy it through unchanged
stb__dirtree_add_dir(db->dirs[i].path, db->dirs[i].last_modified, active);
remap[i] = stb_arr_lastn(active->dirs);
}
} else {
// this path used to refer to a directory, but now it's a file!
// assume that the parent directory is going to be forced to rescan anyway
goto delete_entry;
}
} else {
delete_entry:
// directory no longer exists, so don't copy it
// we don't free it because it's in the string pool now
db->dirs[i].path = NULL;
remap[i] = -1;
changes_detected = STB_TRUE;
}
}
// at this point, we have:
//
// <rescan> holds a list of directory indices that need to be scanned due to being out of date
// <remap> holds the directory index in <active> for each dir in <db>, if it exists; -1 if not
// directories in <rescan> are not in <active> yet
// so we can go ahead and remap all the known files right now
for (i=0; i < stb_arr_len(db->files); ++i) {
int dir = db->files[i].dir;
if (remap[dir] >= 0) {
stb__dirtree_add_file(db->files[i].name, remap[dir], db->files[i].size, db->files[i].last_modified, active);
}
}
// at this point we're done with db->files, and done with remap
free(remap);
// now scan those directories using the standard scan
for (i=0; i < stb_arr_len(rescan); ++i) {
int z = rescan[i];
stb__dirtree_scandir(db->dirs[z].path, db->dirs[z].last_modified, active);
}
stb_arr_free(rescan);
return changes_detected;
}
static void stb__dirtree_free_raw(stb_dirtree *d)
{
stb_free(d->string_pool);
stb_arr_free(d->dirs);
stb_arr_free(d->files);
}
stb_dirtree *stb_dirtree_get_with_file(char *dir, char *cache_file)
{
stb_dirtree *output = (stb_dirtree *) malloc(sizeof(*output));
stb_dirtree db,active;
int prev_dir_count, cache_mismatch;
char *stripped_dir; // store the directory name without a trailing '/' or '\\'
// load the database of last-known state on disk
db.string_pool = NULL;
db.files = NULL;
db.dirs = NULL;
stripped_dir = stb_strip_final_slash(strdup(dir));
if (cache_file != NULL)
stb__dirtree_load_db(cache_file, &db, stripped_dir);
else if (stb__showfile)
printf("No cache file\n");
active.files = NULL;
active.dirs = NULL;
active.string_pool = stb_malloc(0,1); // @TODO: share string pools between both?
// check all the directories in the database; make note if
// anything we scanned had changed, and rescan those things
cache_mismatch = stb__dirtree_update_db(&db, &active);
// check the root tree
prev_dir_count = stb_arr_len(active.dirs); // record how many directories we've seen
stb__dirtree_scandir(stripped_dir, 0, &active); // no last_modified time available for root
if (stb__dircount_mask)
printf(" \r");
// done with the DB; write it back out if any changes, i.e. either
// 1. any inconsistency found between cached information and actual disk
// or 2. if scanning the root found any new directories--which we detect because
// more than one directory got added to the active db during that scan
if (cache_mismatch || stb_arr_len(active.dirs) > prev_dir_count+1)
stb__dirtree_save_db(cache_file, &active, stripped_dir);
free(stripped_dir);
stb__dirtree_free_raw(&db);
*output = active;
return output;
}
stb_dirtree *stb_dirtree_get_dir(char *dir, char *cache_dir)
{
int i;
stb_uint8 sha[20];
char dir_lower[1024];
char cache_file[1024],*s;
if (cache_dir == NULL)
return stb_dirtree_get_with_file(dir, NULL);
strcpy(dir_lower, dir);
stb_tolower(dir_lower);
stb_sha1(sha, (unsigned char *) dir_lower, strlen(dir_lower));
strcpy(cache_file, cache_dir);
s = cache_file + strlen(cache_file);
if (s[-1] != '//' && s[-1] != '\\') *s++ = '/';
strcpy(s, "dirtree_");
s += strlen(s);
for (i=0; i < 8; ++i) {
char *hex = "0123456789abcdef";
stb_uint z = sha[i];
*s++ = hex[z >> 4];
*s++ = hex[z & 15];
}
strcpy(s, ".bin");
return stb_dirtree_get_with_file(dir, cache_file);
}
stb_dirtree *stb_dirtree_get(char *dir)
{
char cache_dir[256];
strcpy(cache_dir, "c:/stb");
#ifdef STB_HAS_REGISTRY
{
void *reg = stb_reg_open("rHKLM", "Software\\SilverSpaceship\\stb");
if (reg) {
stb_reg_read(reg, "dirtree", cache_dir, sizeof(cache_dir));
stb_reg_close(reg);
}
}
#endif
return stb_dirtree_get_dir(dir, cache_dir);
}
void stb_dirtree_free(stb_dirtree *d)
{
stb__dirtree_free_raw(d);
free(d);
}
void stb_dirtree_db_add_dir(stb_dirtree *active, char *path, time_t last)
{
stb__dirtree_add_dir(path, last, active);
}
void stb_dirtree_db_add_file(stb_dirtree *active, char *name, int dir, stb_int64 size, time_t last)
{
stb__dirtree_add_file(name, dir, size, last, active);
}
void stb_dirtree_db_read(stb_dirtree *target, char *filename, char *dir)
{
char *s = stb_strip_final_slash(strdup(dir));
target->dirs = 0;
target->files = 0;
target->string_pool = 0;
stb__dirtree_load_db(filename, target, s);
free(s);
}
void stb_dirtree_db_write(stb_dirtree *target, char *filename, char *dir)
{
stb__dirtree_save_db(filename, target, 0); // don't strip out any directories
}
#endif // STB_DEFINE
#endif // _WIN32
#endif // STB_NO_STB_STRINGS
//////////////////////////////////////////////////////////////////////////////
//
// STB_MALLOC_WRAPPER
//
// you can use the wrapper functions with your own malloc wrapper,
// or define STB_MALLOC_WRAPPER project-wide to have
// malloc/free/realloc/strdup all get vectored to it
// this has too many very specific error messages you could google for and find in stb.h,
// so don't use it if they don't want any stb.h-identifiable strings
#if defined(STB_DEFINE) && !defined(STB_NO_STB_STRINGS)
typedef struct
{
void *p;
char *file;
int line;
int size;
} stb_malloc_record;
#ifndef STB_MALLOC_HISTORY_COUNT
#define STB_MALLOC_HISTORY_COUNT 50 // 800 bytes
#endif
stb_malloc_record *stb__allocations;
static int stb__alloc_size, stb__alloc_limit, stb__alloc_mask;
int stb__alloc_count;
stb_malloc_record stb__alloc_history[STB_MALLOC_HISTORY_COUNT];
int stb__history_pos;
static int stb__hashfind(void *p)
{
stb_uint32 h = stb_hashptr(p);
int s,n = h & stb__alloc_mask;
if (stb__allocations[n].p == p)
return n;
s = stb_rehash(h)|1;
for(;;) {
if (stb__allocations[n].p == NULL)
return -1;
n = (n+s) & stb__alloc_mask;
if (stb__allocations[n].p == p)
return n;
}
}
int stb_wrapper_allocsize(void *p)
{
int n = stb__hashfind(p);
if (n < 0) return 0;
return stb__allocations[n].size;
}
static int stb__historyfind(void *p)
{
int n = stb__history_pos;
int i;
for (i=0; i < STB_MALLOC_HISTORY_COUNT; ++i) {
if (--n < 0) n = STB_MALLOC_HISTORY_COUNT-1;
if (stb__alloc_history[n].p == p)
return n;
}
return -1;
}
static void stb__add_alloc(void *p, int sz, char *file, int line);
static void stb__grow_alloc(void)
{
int i,old_num = stb__alloc_size;
stb_malloc_record *old = stb__allocations;
if (stb__alloc_size == 0)
stb__alloc_size = 64;
else
stb__alloc_size *= 2;
stb__allocations = (stb_malloc_record *) stb__realloc_raw(NULL, stb__alloc_size * sizeof(stb__allocations[0]));
if (stb__allocations == NULL)
stb_fatal("Internal error: couldn't grow malloc wrapper table");
memset(stb__allocations, 0, stb__alloc_size * sizeof(stb__allocations[0]));
stb__alloc_limit = (stb__alloc_size*3)>>2;
stb__alloc_mask = stb__alloc_size-1;
stb__alloc_count = 0;
for (i=0; i < old_num; ++i)
if (old[i].p > STB_DEL) {
stb__add_alloc(old[i].p, old[i].size, old[i].file, old[i].line);
assert(stb__hashfind(old[i].p) >= 0);
}
for (i=0; i < old_num; ++i)
if (old[i].p > STB_DEL)
assert(stb__hashfind(old[i].p) >= 0);
stb__realloc_raw(old, 0);
}
static void stb__add_alloc(void *p, int sz, char *file, int line)
{
stb_uint32 h;
int n;
if (stb__alloc_count >= stb__alloc_limit)
stb__grow_alloc();
h = stb_hashptr(p);
n = h & stb__alloc_mask;
if (stb__allocations[n].p > STB_DEL) {
int s = stb_rehash(h)|1;
do {
n = (n+s) & stb__alloc_mask;
} while (stb__allocations[n].p > STB_DEL);
}
assert(stb__allocations[n].p == NULL || stb__allocations[n].p == STB_DEL);
stb__allocations[n].p = p;
stb__allocations[n].size = sz;
stb__allocations[n].line = line;
stb__allocations[n].file = file;
++stb__alloc_count;
}
static void stb__remove_alloc(int n, char *file, int line)
{
stb__alloc_history[stb__history_pos] = stb__allocations[n];
stb__alloc_history[stb__history_pos].file = file;
stb__alloc_history[stb__history_pos].line = line;
if (++stb__history_pos == STB_MALLOC_HISTORY_COUNT)
stb__history_pos = 0;
stb__allocations[n].p = STB_DEL;
--stb__alloc_count;
}
void stb_wrapper_malloc(void *p, int sz, char *file, int line)
{
if (!p) return;
stb__add_alloc(p,sz,file,line);
}
void stb_wrapper_free(void *p, char *file, int line)
{
int n;
if (p == NULL) return;
n = stb__hashfind(p);
if (n >= 0)
stb__remove_alloc(n, file, line);
else {
// tried to free something we hadn't allocated!
n = stb__historyfind(p);
assert(0); /* NOTREACHED */
if (n >= 0)
stb_fatal("Attempted to free %d-byte block %p at %s:%d previously freed/realloced at %s:%d",
stb__alloc_history[n].size, p,
file, line,
stb__alloc_history[n].file, stb__alloc_history[n].line);
else
stb_fatal("Attempted to free unknown block %p at %s:%d", p, file,line);
}
}
void stb_wrapper_check(void *p)
{
int n;
if (p == NULL) return;
n = stb__hashfind(p);
if (n >= 0) return;
for (n=0; n < stb__alloc_size; ++n)
if (stb__allocations[n].p == p)
stb_fatal("Internal error: pointer %p was allocated, but hash search failed", p);
// tried to free something that wasn't allocated!
n = stb__historyfind(p);
if (n >= 0)
stb_fatal("Checked %d-byte block %p previously freed/realloced at %s:%d",
stb__alloc_history[n].size, p,
stb__alloc_history[n].file, stb__alloc_history[n].line);
stb_fatal("Checked unknown block %p");
}
void stb_wrapper_realloc(void *p, void *q, int sz, char *file, int line)
{
int n;
if (p == NULL) { stb_wrapper_malloc(q, sz, file, line); return; }
if (q == NULL) return; // nothing happened
n = stb__hashfind(p);
if (n == -1) {
// tried to free something we hadn't allocated!
// this is weird, though, because we got past the realloc!
n = stb__historyfind(p);
assert(0); /* NOTREACHED */
if (n >= 0)
stb_fatal("Attempted to realloc %d-byte block %p at %s:%d previously freed/realloced at %s:%d",
stb__alloc_history[n].size, p,
file, line,
stb__alloc_history[n].file, stb__alloc_history[n].line);
else
stb_fatal("Attempted to realloc unknown block %p at %s:%d", p, file,line);
} else {
if (q == p) {
stb__allocations[n].size = sz;
stb__allocations[n].file = file;
stb__allocations[n].line = line;
} else {
stb__remove_alloc(n, file, line);
stb__add_alloc(q,sz,file,line);
}
}
}
void stb_wrapper_listall(void (*func)(void *ptr, int sz, char *file, int line))
{
int i;
for (i=0; i < stb__alloc_size; ++i)
if (stb__allocations[i].p > STB_DEL)
func(stb__allocations[i].p , stb__allocations[i].size,
stb__allocations[i].file, stb__allocations[i].line);
}
void stb_wrapper_dump(char *filename)
{
int i;
FILE *f = fopen(filename, "w");
if (!f) return;
for (i=0; i < stb__alloc_size; ++i)
if (stb__allocations[i].p > STB_DEL)
fprintf(f, "%p %7d - %4d %s\n",
stb__allocations[i].p , stb__allocations[i].size,
stb__allocations[i].line, stb__allocations[i].file);
}
#endif // STB_DEFINE
//////////////////////////////////////////////////////////////////////////////
//
// stb_pointer_set
//
//
// For data structures that support querying by key, data structure
// classes always hand-wave away the issue of what to do if two entries
// have the same key: basically, store a linked list of all the nodes
// which have the same key (a LISP-style list).
//
// The thing is, it's not that trivial. If you have an O(log n)
// lookup data structure, but then n/4 items have the same value,
// you don't want to spend O(n) time scanning that list when
// deleting an item if you already have a pointer to the item.
// (You have to spend O(n) time enumerating all the items with
// a given key, sure, and you can't accelerate deleting a particular
// item if you only have the key, not a pointer to the item.)
//
// I'm going to call this data structure, whatever it turns out to
// be, a "pointer set", because we don't store any associated data for
// items in this data structure, we just answer the question of
// whether an item is in it or not (it's effectively one bit per pointer).
// Technically they don't have to be pointers; you could cast ints
// to (void *) if you want, but you can't store 0 or 1 because of the
// hash table.
//
// Since the fastest data structure we might want to add support for
// identical-keys to is a hash table with O(1)-ish lookup time,
// that means that the conceptual "linked list of all items with
// the same indexed value" that we build needs to have the same
// performance; that way when we index a table we think is arbitrary
// ints, but in fact half of them are 0, we don't get screwed.
//
// Therefore, it needs to be a hash table, at least when it gets
// large. On the other hand, when the data has totally arbitrary ints
// or floats, there won't be many collisions, and we'll have tons of
// 1-item bitmaps. That will be grossly inefficient as hash tables;
// trade-off; the hash table is reasonably efficient per-item when
// it's large, but not when it's small. So we need to do something
// Judy-like and use different strategies depending on the size.
//
// Like Judy, we'll use the bottom bit to encode the strategy:
//
// bottom bits:
// 00 - direct pointer
// 01 - 4-item bucket (16 bytes, no length, NULLs)
// 10 - N-item array
// 11 - hash table
typedef struct stb_ps stb_ps;
STB_EXTERN int stb_ps_find (stb_ps *ps, void *value);
STB_EXTERN stb_ps * stb_ps_add (stb_ps *ps, void *value);
STB_EXTERN stb_ps * stb_ps_remove(stb_ps *ps, void *value);
STB_EXTERN stb_ps * stb_ps_remove_any(stb_ps *ps, void **value);
STB_EXTERN void stb_ps_delete(stb_ps *ps);
STB_EXTERN int stb_ps_count (stb_ps *ps);
STB_EXTERN stb_ps * stb_ps_copy (stb_ps *ps);
STB_EXTERN int stb_ps_subset(stb_ps *bigger, stb_ps *smaller);
STB_EXTERN int stb_ps_eq (stb_ps *p0, stb_ps *p1);
STB_EXTERN void ** stb_ps_getlist (stb_ps *ps, int *count);
STB_EXTERN int stb_ps_writelist(stb_ps *ps, void **list, int size );
// enum and fastlist don't allocate storage, but you must consume the
// list before there's any chance the data structure gets screwed up;
STB_EXTERN int stb_ps_enum (stb_ps *ps, void *data,
int (*func)(void *value, void*data) );
STB_EXTERN void ** stb_ps_fastlist(stb_ps *ps, int *count);
// result:
// returns a list, *count is the length of that list,
// but some entries of the list may be invalid;
// test with 'stb_ps_fastlist_valid(x)'
#define stb_ps_fastlist_valid(x) ((stb_uinta) (x) > 1)
#ifdef STB_DEFINE
enum
{
STB_ps_direct = 0,
STB_ps_bucket = 1,
STB_ps_array = 2,
STB_ps_hash = 3,
};
#define STB_BUCKET_SIZE 4
typedef struct
{
void *p[STB_BUCKET_SIZE];
} stb_ps_bucket;
#define GetBucket(p) ((stb_ps_bucket *) ((char *) (p) - STB_ps_bucket))
#define EncodeBucket(p) ((stb_ps *) ((char *) (p) + STB_ps_bucket))
static void stb_bucket_free(stb_ps_bucket *b)
{
free(b);
}
static stb_ps_bucket *stb_bucket_create2(void *v0, void *v1)
{
stb_ps_bucket *b = (stb_ps_bucket*) malloc(sizeof(*b));
b->p[0] = v0;
b->p[1] = v1;
b->p[2] = NULL;
b->p[3] = NULL;
return b;
}
static stb_ps_bucket * stb_bucket_create3(void **v)
{
stb_ps_bucket *b = (stb_ps_bucket*) malloc(sizeof(*b));
b->p[0] = v[0];
b->p[1] = v[1];
b->p[2] = v[2];
b->p[3] = NULL;
return b;
}
// could use stb_arr, but this will save us memory
typedef struct
{
int count;
void *p[1];
} stb_ps_array;
#define GetArray(p) ((stb_ps_array *) ((char *) (p) - STB_ps_array))
#define EncodeArray(p) ((stb_ps *) ((char *) (p) + STB_ps_array))
static int stb_ps_array_max = 13;
typedef struct
{
int size, mask;
int count, count_deletes;
int grow_threshhold;
int shrink_threshhold;
int rehash_threshhold;
int any_offset;
void *table[1];
} stb_ps_hash;
#define GetHash(p) ((stb_ps_hash *) ((char *) (p) - STB_ps_hash))
#define EncodeHash(p) ((stb_ps *) ((char *) (p) + STB_ps_hash))
#define stb_ps_empty(v) (((stb_uint32) v) <= 1)
static stb_ps_hash *stb_ps_makehash(int size, int old_size, void **old_data)
{
int i;
stb_ps_hash *h = (stb_ps_hash *) malloc(sizeof(*h) + (size-1) * sizeof(h->table[0]));
assert(stb_is_pow2(size));
h->size = size;
h->mask = size-1;
h->shrink_threshhold = (int) (0.3f * size);
h-> grow_threshhold = (int) (0.8f * size);
h->rehash_threshhold = (int) (0.9f * size);
h->count = 0;
h->count_deletes = 0;
h->any_offset = 0;
memset(h->table, 0, size * sizeof(h->table[0]));
for (i=0; i < old_size; ++i)
if (!stb_ps_empty(old_data[i]))
stb_ps_add(EncodeHash(h), old_data[i]);
return h;
}
void stb_ps_delete(stb_ps *ps)
{
switch (3 & (int) ps) {
case STB_ps_direct: break;
case STB_ps_bucket: stb_bucket_free(GetBucket(ps)); break;
case STB_ps_array : free(GetArray(ps)); break;
case STB_ps_hash : free(GetHash(ps)); break;
}
}
stb_ps *stb_ps_copy(stb_ps *ps)
{
int i;
// not a switch: order based on expected performance/power-law distribution
switch (3 & (int) ps) {
case STB_ps_direct: return ps;
case STB_ps_bucket: {
stb_ps_bucket *n = (stb_ps_bucket *) malloc(sizeof(*n));
*n = *GetBucket(ps);
return EncodeBucket(n);
}
case STB_ps_array: {
stb_ps_array *a = GetArray(ps);
stb_ps_array *n = (stb_ps_array *) malloc(sizeof(*n) + stb_ps_array_max * sizeof(n->p[0]));
n->count = a->count;
for (i=0; i < a->count; ++i)
n->p[i] = a->p[i];
return EncodeArray(n);
}
case STB_ps_hash: {
stb_ps_hash *h = GetHash(ps);
stb_ps_hash *n = stb_ps_makehash(h->size, h->size, h->table);
return EncodeHash(n);
}
}
assert(0); /* NOTREACHED */
return NULL;
}
int stb_ps_find(stb_ps *ps, void *value)
{
int i, code = 3 & (int) ps;
assert((3 & (int) value) == STB_ps_direct);
assert(stb_ps_fastlist_valid(value));
// not a switch: order based on expected performance/power-law distribution
if (code == STB_ps_direct)
return value == ps;
if (code == STB_ps_bucket) {
stb_ps_bucket *b = GetBucket(ps);
assert(STB_BUCKET_SIZE == 4);
if (b->p[0] == value || b->p[1] == value ||
b->p[2] == value || b->p[3] == value)
return STB_TRUE;
return STB_FALSE;
}
if (code == STB_ps_array) {
stb_ps_array *a = GetArray(ps);
for (i=0; i < a->count; ++i)
if (a->p[i] == value)
return STB_TRUE;
return STB_FALSE;
} else {
stb_ps_hash *h = GetHash(ps);
stb_uint32 hash = stb_hashptr(value);
stb_uint32 s, n = hash & h->mask;
void **t = h->table;
if (t[n] == value) return STB_TRUE;
if (t[n] == NULL) return STB_FALSE;
s = stb_rehash(hash) | 1;
do {
n = (n + s) & h->mask;
if (t[n] == value) return STB_TRUE;
} while (t[n] != NULL);
return STB_FALSE;
}
}
stb_ps * stb_ps_add (stb_ps *ps, void *value)
{
#ifdef STB_DEBUG
assert(!stb_ps_find(ps,value));
#endif
if (value == NULL) return ps; // ignore NULL adds to avoid bad breakage
assert((3 & (int) value) == STB_ps_direct);
assert(stb_ps_fastlist_valid(value));
assert(value != STB_DEL); // STB_DEL is less likely
switch (3 & (int) ps) {
case STB_ps_direct:
if (ps == NULL) return (stb_ps *) value;
return EncodeBucket(stb_bucket_create2(ps,value));
case STB_ps_bucket: {
stb_ps_bucket *b = GetBucket(ps);
stb_ps_array *a;
assert(STB_BUCKET_SIZE == 4);
if (b->p[0] == NULL) { b->p[0] = value; return ps; }
if (b->p[1] == NULL) { b->p[1] = value; return ps; }
if (b->p[2] == NULL) { b->p[2] = value; return ps; }
if (b->p[3] == NULL) { b->p[3] = value; return ps; }
a = (stb_ps_array *) malloc(sizeof(*a) + 7 * sizeof(a->p[0])); // 8 slots, must be 2^k
memcpy(a->p, b, sizeof(*b));
a->p[4] = value;
a->count = 5;
stb_bucket_free(b);
return EncodeArray(a);
}
case STB_ps_array: {
stb_ps_array *a = GetArray(ps);
if (a->count == stb_ps_array_max) {
// promote from array to hash
stb_ps_hash *h = stb_ps_makehash(2 << stb_log2_ceil(a->count), a->count, a->p);
free(a);
return stb_ps_add(EncodeHash(h), value);
}
// do we need to resize the array? the array doubles in size when it
// crosses a power-of-two
if ((a->count & (a->count-1))==0) {
int newsize = a->count*2;
// clamp newsize to max if:
// 1. it's larger than max
// 2. newsize*1.5 is larger than max (to avoid extra resizing)
if (newsize + a->count > stb_ps_array_max)
newsize = stb_ps_array_max;
a = (stb_ps_array *) realloc(a, sizeof(*a) + (newsize-1) * sizeof(a->p[0]));
}
a->p[a->count++] = value;
return EncodeArray(a);
}
case STB_ps_hash: {
stb_ps_hash *h = GetHash(ps);
stb_uint32 hash = stb_hashptr(value);
stb_uint32 n = hash & h->mask;
void **t = h->table;
// find first NULL or STB_DEL entry
if (!stb_ps_empty(t[n])) {
stb_uint32 s = stb_rehash(hash) | 1;
do {
n = (n + s) & h->mask;
} while (!stb_ps_empty(t[n]));
}
if (t[n] == STB_DEL)
-- h->count_deletes;
t[n] = value;
++ h->count;
if (h->count == h->grow_threshhold) {
stb_ps_hash *h2 = stb_ps_makehash(h->size*2, h->size, t);
free(h);
return EncodeHash(h2);
}
if (h->count + h->count_deletes == h->rehash_threshhold) {
stb_ps_hash *h2 = stb_ps_makehash(h->size, h->size, t);
free(h);
return EncodeHash(h2);
}
return ps;
}
}
return NULL; /* NOTREACHED */
}
stb_ps *stb_ps_remove(stb_ps *ps, void *value)
{
#ifdef STB_DEBUG
assert(stb_ps_find(ps, value));
#endif
assert((3 & (int) value) == STB_ps_direct);
if (value == NULL) return ps; // ignore NULL removes to avoid bad breakage
switch (3 & (int) ps) {
case STB_ps_direct:
return ps == value ? NULL : ps;
case STB_ps_bucket: {
stb_ps_bucket *b = GetBucket(ps);
int count=0;
assert(STB_BUCKET_SIZE == 4);
if (b->p[0] == value) b->p[0] = NULL; else count += (b->p[0] != NULL);
if (b->p[1] == value) b->p[1] = NULL; else count += (b->p[1] != NULL);
if (b->p[2] == value) b->p[2] = NULL; else count += (b->p[2] != NULL);
if (b->p[3] == value) b->p[3] = NULL; else count += (b->p[3] != NULL);
if (count == 1) { // shrink bucket at size 1
value = b->p[0];
if (value == NULL) value = b->p[1];
if (value == NULL) value = b->p[2];
if (value == NULL) value = b->p[3];
assert(value != NULL);
stb_bucket_free(b);
return (stb_ps *) value; // return STB_ps_direct of value
}
return ps;
}
case STB_ps_array: {
stb_ps_array *a = GetArray(ps);
int i;
for (i=0; i < a->count; ++i) {
if (a->p[i] == value) {
a->p[i] = a->p[--a->count];
if (a->count == 3) { // shrink to bucket!
stb_ps_bucket *b = stb_bucket_create3(a->p);
free(a);
return EncodeBucket(b);
}
return ps;
}
}
return ps;
}
case STB_ps_hash: {
stb_ps_hash *h = GetHash(ps);
stb_uint32 hash = stb_hashptr(value);
stb_uint32 s, n = hash & h->mask;
void **t = h->table;
if (t[n] != value) {
s = stb_rehash(hash) | 1;
do {
n = (n + s) & h->mask;
} while (t[n] != value);
}
t[n] = STB_DEL;
-- h->count;
++ h->count_deletes;
// should we shrink down to an array?
if (h->count < stb_ps_array_max) {
int n = 1 << stb_log2_floor(stb_ps_array_max);
if (h->count < n) {
stb_ps_array *a = (stb_ps_array *) malloc(sizeof(*a) + (n-1) * sizeof(a->p[0]));
int i,j=0;
for (i=0; i < h->size; ++i)
if (!stb_ps_empty(t[i]))
a->p[j++] = t[i];
assert(j == h->count);
a->count = j;
free(h);
return EncodeArray(a);
}
}
if (h->count == h->shrink_threshhold) {
stb_ps_hash *h2 = stb_ps_makehash(h->size >> 1, h->size, t);
free(h);
return EncodeHash(h2);
}
return ps;
}
}
return ps; /* NOTREACHED */
}
stb_ps *stb_ps_remove_any(stb_ps *ps, void **value)
{
assert(ps != NULL);
switch (3 & (int) ps) {
case STB_ps_direct:
*value = ps;
return NULL;
case STB_ps_bucket: {
stb_ps_bucket *b = GetBucket(ps);
int count=0, slast=0, last=0;
assert(STB_BUCKET_SIZE == 4);
if (b->p[0]) { ++count; last = 0; }
if (b->p[1]) { ++count; slast = last; last = 1; }
if (b->p[2]) { ++count; slast = last; last = 2; }
if (b->p[3]) { ++count; slast = last; last = 3; }
*value = b->p[last];
b->p[last] = 0;
if (count == 2) {
void *leftover = b->p[slast]; // second to last
stb_bucket_free(b);
return (stb_ps *) leftover;
}
return ps;
}
case STB_ps_array: {
stb_ps_array *a = GetArray(ps);
*value = a->p[a->count-1];
if (a->count == 4)
return stb_ps_remove(ps, *value);
--a->count;
return ps;
}
case STB_ps_hash: {
stb_ps_hash *h = GetHash(ps);
void **t = h->table;
stb_uint32 n = h->any_offset;
while (stb_ps_empty(t[n]))
n = (n + 1) & h->mask;
*value = t[n];
h->any_offset = (n+1) & h->mask;
// check if we need to skip down to the previous type
if (h->count-1 < stb_ps_array_max || h->count-1 == h->shrink_threshhold)
return stb_ps_remove(ps, *value);
t[n] = STB_DEL;
-- h->count;
++ h->count_deletes;
return ps;
}
}
return ps; /* NOTREACHED */
}
void ** stb_ps_getlist(stb_ps *ps, int *count)
{
int i,n=0;
void **p = NULL;
switch (3 & (int) ps) {
case STB_ps_direct:
if (ps == NULL) { *count = 0; return NULL; }
p = (void **) malloc(sizeof(*p) * 1);
p[0] = ps;
*count = 1;
return p;
case STB_ps_bucket: {
stb_ps_bucket *b = GetBucket(ps);
p = (void **) malloc(sizeof(*p) * STB_BUCKET_SIZE);
for (i=0; i < STB_BUCKET_SIZE; ++i)
if (b->p[i] != NULL)
p[n++] = b->p[i];
break;
}
case STB_ps_array: {
stb_ps_array *a = GetArray(ps);
p = (void **) malloc(sizeof(*p) * a->count);
memcpy(p, a->p, sizeof(*p) * a->count);
*count = a->count;
return p;
}
case STB_ps_hash: {
stb_ps_hash *h = GetHash(ps);
p = (void **) malloc(sizeof(*p) * h->count);
for (i=0; i < h->size; ++i)
if (!stb_ps_empty(h->table[i]))
p[n++] = h->table[i];
break;
}
}
*count = n;
return p;
}
int stb_ps_writelist(stb_ps *ps, void **list, int size )
{
int i,n=0;
switch (3 & (int) ps) {
case STB_ps_direct:
if (ps == NULL || size <= 0) return 0;
list[0] = ps;
return 1;
case STB_ps_bucket: {
stb_ps_bucket *b = GetBucket(ps);
for (i=0; i < STB_BUCKET_SIZE; ++i)
if (b->p[i] != NULL && n < size)
list[n++] = b->p[i];
return n;
}
case STB_ps_array: {
stb_ps_array *a = GetArray(ps);
n = stb_min(size, a->count);
memcpy(list, a->p, sizeof(*list) * n);
return n;
}
case STB_ps_hash: {
stb_ps_hash *h = GetHash(ps);
if (size <= 0) return 0;
for (i=0; i < h->count; ++i) {
if (!stb_ps_empty(h->table[i])) {
list[n++] = h->table[i];
if (n == size) break;
}
}
return n;
}
}
return 0; /* NOTREACHED */
}
int stb_ps_enum(stb_ps *ps, void *data, int (*func)(void *value, void *data))
{
int i;
switch (3 & (int) ps) {
case STB_ps_direct:
if (ps == NULL) return STB_TRUE;
return func(ps, data);
case STB_ps_bucket: {
stb_ps_bucket *b = GetBucket(ps);
for (i=0; i < STB_BUCKET_SIZE; ++i)
if (b->p[i] != NULL)
if (!func(b->p[i], data))
return STB_FALSE;
return STB_TRUE;
}
case STB_ps_array: {
stb_ps_array *a = GetArray(ps);
for (i=0; i < a->count; ++i)
if (!func(a->p[i], data))
return STB_FALSE;
return STB_TRUE;
}
case STB_ps_hash: {
stb_ps_hash *h = GetHash(ps);
for (i=0; i < h->count; ++i)
if (!stb_ps_empty(h->table[i]))
if (!func(h->table[i], data))
return STB_FALSE;
return STB_TRUE;
}
}
return STB_TRUE; /* NOTREACHED */
}
int stb_ps_count (stb_ps *ps)
{
switch (3 & (int) ps) {
case STB_ps_direct:
return ps != NULL;
case STB_ps_bucket: {
stb_ps_bucket *b = GetBucket(ps);
return (b->p[0] != NULL) + (b->p[1] != NULL) +
(b->p[2] != NULL) + (b->p[3] != NULL);
}
case STB_ps_array: {
stb_ps_array *a = GetArray(ps);
return a->count;
}
case STB_ps_hash: {
stb_ps_hash *h = GetHash(ps);
return h->count;
}
}
return 0;
}
void ** stb_ps_fastlist(stb_ps *ps, int *count)
{
static void *storage;
switch (3 & (int) ps) {
case STB_ps_direct:
if (ps == NULL) { *count = 0; return NULL; }
storage = ps;
*count = 1;
return &storage;
case STB_ps_bucket: {
stb_ps_bucket *b = GetBucket(ps);
*count = STB_BUCKET_SIZE;
return b->p;
}
case STB_ps_array: {
stb_ps_array *a = GetArray(ps);
*count = a->count;
return a->p;
}
case STB_ps_hash: {
stb_ps_hash *h = GetHash(ps);
*count = h->size;
return h->table;
}
}
return NULL; /* NOTREACHED */
}
int stb_ps_subset(stb_ps *bigger, stb_ps *smaller)
{
int i, listlen;
void **list = stb_ps_fastlist(smaller, &listlen);
for(i=0; i < listlen; ++i)
if (stb_ps_fastlist_valid(list[i]))
if (!stb_ps_find(bigger, list[i]))
return 0;
return 1;
}
int stb_ps_eq(stb_ps *p0, stb_ps *p1)
{
if (stb_ps_count(p0) != stb_ps_count(p1))
return 0;
return stb_ps_subset(p0, p1);
}
#undef GetBucket
#undef GetArray
#undef GetHash
#undef EncodeBucket
#undef EncodeArray
#undef EncodeHash
#endif
//////////////////////////////////////////////////////////////////////////////
//
// Random Numbers via Meresenne Twister or LCG
//
STB_EXTERN unsigned long stb_srandLCG(unsigned long seed);
STB_EXTERN unsigned long stb_randLCG(void);
STB_EXTERN double stb_frandLCG(void);
STB_EXTERN void stb_srand(unsigned long seed);
STB_EXTERN unsigned long stb_rand(void);
STB_EXTERN double stb_frand(void);
STB_EXTERN void stb_shuffle(void *p, size_t n, size_t sz,
unsigned long seed);
STB_EXTERN void stb_reverse(void *p, size_t n, size_t sz);
STB_EXTERN unsigned long stb_randLCG_explicit(unsigned long seed);
#define stb_rand_define(x,y) \
\
unsigned long x(void) \
{ \
static unsigned long stb__rand = y; \
stb__rand = stb__rand * 2147001325 + 715136305; /* BCPL */ \
return 0x31415926 ^ ((stb__rand >> 16) + (stb__rand << 16)); \
}
#ifdef STB_DEFINE
unsigned long stb_randLCG_explicit(unsigned long seed)
{
return seed * 2147001325 + 715136305;
}
static unsigned long stb__rand_seed=0;
unsigned long stb_srandLCG(unsigned long seed)
{
unsigned long previous = stb__rand_seed;
stb__rand_seed = seed;
return previous;
}
unsigned long stb_randLCG(void)
{
stb__rand_seed = stb__rand_seed * 2147001325 + 715136305; // BCPL generator
// shuffle non-random bits to the middle, and xor to decorrelate with seed
return 0x31415926 ^ ((stb__rand_seed >> 16) + (stb__rand_seed << 16));
}
double stb_frandLCG(void)
{
return stb_randLCG() / ((double) (1 << 16) * (1 << 16));
}
void stb_shuffle(void *p, size_t n, size_t sz, unsigned long seed)
{
char *a;
unsigned long old_seed;
int i;
if (seed)
old_seed = stb_srandLCG(seed);
a = (char *) p + (n-1) * sz;
for (i=n; i > 1; --i) {
int j = stb_randLCG() % i;
stb_swap(a, (char *) p + j * sz, sz);
a -= sz;
}
if (seed)
stb_srandLCG(old_seed);
}
void stb_reverse(void *p, size_t n, size_t sz)
{
int i,j = n-1;
for (i=0; i < j; ++i,--j) {
stb_swap((char *) p + i * sz, (char *) p + j * sz, sz);
}
}
// public domain Mersenne Twister by Michael Brundage
#define STB__MT_LEN 624
int stb__mt_index = STB__MT_LEN*sizeof(unsigned long)+1;
unsigned long stb__mt_buffer[STB__MT_LEN];
void stb_srand(unsigned long seed)
{
int i;
unsigned long old = stb_srandLCG(seed);
for (i = 0; i < STB__MT_LEN; i++)
stb__mt_buffer[i] = stb_randLCG();
stb_srandLCG(old);
stb__mt_index = STB__MT_LEN*sizeof(unsigned long);
}
#define STB__MT_IA 397
#define STB__MT_IB (STB__MT_LEN - STB__MT_IA)
#define STB__UPPER_MASK 0x80000000
#define STB__LOWER_MASK 0x7FFFFFFF
#define STB__MATRIX_A 0x9908B0DF
#define STB__TWIST(b,i,j) ((b)[i] & STB__UPPER_MASK) | ((b)[j] & STB__LOWER_MASK)
#define STB__MAGIC(s) (((s)&1)*STB__MATRIX_A)
unsigned long stb_rand()
{
unsigned long * b = stb__mt_buffer;
int idx = stb__mt_index;
unsigned long s,r;
int i;
if (idx >= STB__MT_LEN*sizeof(unsigned long)) {
if (idx > STB__MT_LEN*sizeof(unsigned long))
stb_srand(0);
idx = 0;
i = 0;
for (; i < STB__MT_IB; i++) {
s = STB__TWIST(b, i, i+1);
b[i] = b[i + STB__MT_IA] ^ (s >> 1) ^ STB__MAGIC(s);
}
for (; i < STB__MT_LEN-1; i++) {
s = STB__TWIST(b, i, i+1);
b[i] = b[i - STB__MT_IB] ^ (s >> 1) ^ STB__MAGIC(s);
}
s = STB__TWIST(b, STB__MT_LEN-1, 0);
b[STB__MT_LEN-1] = b[STB__MT_IA-1] ^ (s >> 1) ^ STB__MAGIC(s);
}
stb__mt_index = idx + sizeof(unsigned long);
r = *(unsigned long *)((unsigned char *)b + idx);
r ^= (r >> 11);
r ^= (r << 7) & 0x9D2C5680;
r ^= (r << 15) & 0xEFC60000;
r ^= (r >> 18);
return r;
}
double stb_frand(void)
{
return stb_rand() / ((double) (1 << 16) * (1 << 16));
}
#endif
//////////////////////////////////////////////////////////////////////////////
//
// stb_dupe
//
// stb_dupe is a duplicate-finding system for very, very large data
// structures--large enough that sorting is too slow, but not so large
// that we can't keep all the data in memory. using it works as follows:
//
// 1. create an stb_dupe:
// provide a hash function
// provide an equality function
// provide an estimate for the size
// optionally provide a comparison function
//
// 2. traverse your data, 'adding' pointers to the stb_dupe
//
// 3. finish and ask for duplicates
//
// the stb_dupe will discard its intermediate data and build
// a collection of sorted lists of duplicates, with non-duplicate
// entries omitted entirely
//
//
// Implementation strategy:
//
// while collecting the N items, we keep a hash table of approximate
// size sqrt(N). (if you tell use the N up front, the hash table is
// just that size exactly)
//
// each entry in the hash table is just an stb__arr of pointers (no need
// to use stb_ps, because we don't need to delete from these)
//
// for step 3, for each entry in the hash table, we apply stb_dupe to it
// recursively. once the size gets small enough (or doesn't decrease
// significantly), we switch to either using qsort() on the comparison
// function, or else we just do the icky N^2 gather
typedef struct stb_dupe stb_dupe;
typedef int (*stb_compare_func)(void *a, void *b);
typedef int (*stb_hash_func)(void *a, unsigned int seed);
STB_EXTERN void stb_dupe_free(stb_dupe *sd);
STB_EXTERN stb_dupe *stb_dupe_create(stb_hash_func hash,
stb_compare_func eq, int size, stb_compare_func ineq);
STB_EXTERN void stb_dupe_add(stb_dupe *sd, void *item);
STB_EXTERN void stb_dupe_finish(stb_dupe *sd);
STB_EXTERN int stb_dupe_numsets(stb_dupe *sd);
STB_EXTERN void **stb_dupe_set(stb_dupe *sd, int num);
STB_EXTERN int stb_dupe_set_count(stb_dupe *sd, int num);
struct stb_dupe
{
void ***hash_table;
int hash_size;
int size_log2;
int population;
int hash_shift;
stb_hash_func hash;
stb_compare_func eq;
stb_compare_func ineq;
void ***dupes;
};
#ifdef STB_DEFINE
int stb_dupe_numsets(stb_dupe *sd)
{
assert(sd->hash_table == NULL);
return stb_arr_len(sd->dupes);
}
void **stb_dupe_set(stb_dupe *sd, int num)
{
assert(sd->hash_table == NULL);
return sd->dupes[num];
}
int stb_dupe_set_count(stb_dupe *sd, int num)
{
assert(sd->hash_table == NULL);
return stb_arr_len(sd->dupes[num]);
}
stb_dupe *stb_dupe_create(stb_hash_func hash, stb_compare_func eq, int size,
stb_compare_func ineq)
{
int i, hsize;
stb_dupe *sd = (stb_dupe *) malloc(sizeof(*sd));
sd->size_log2 = 4;
hsize = 1 << sd->size_log2;
while (hsize * hsize < size) {
++sd->size_log2;
hsize *= 2;
}
sd->hash = hash;
sd->eq = eq;
sd->ineq = ineq;
sd->hash_shift = 0;
sd->population = 0;
sd->hash_size = hsize;
sd->hash_table = (void ***) malloc(sizeof(*sd->hash_table) * hsize);
for (i=0; i < hsize; ++i)
sd->hash_table[i] = NULL;
sd->dupes = NULL;
return sd;
}
void stb_dupe_add(stb_dupe *sd, void *item)
{
stb_uint32 hash = sd->hash(item, sd->hash_shift);
int z = hash & (sd->hash_size-1);
stb_arr_push(sd->hash_table[z], item);
++sd->population;
}
void stb_dupe_free(stb_dupe *sd)
{
int i;
for (i=0; i < stb_arr_len(sd->dupes); ++i)
if (sd->dupes[i])
stb_arr_free(sd->dupes[i]);
stb_arr_free(sd->dupes);
free(sd);
}
static stb_compare_func stb__compare;
static int stb__dupe_compare(const void *a, const void *b)
{
void *p = *(void **) a;
void *q = *(void **) b;
return stb__compare(p,q);
}
void stb_dupe_finish(stb_dupe *sd)
{
int i,j,k;
assert(sd->dupes == NULL);
for (i=0; i < sd->hash_size; ++i) {
void ** list = sd->hash_table[i];
if (list != NULL) {
int n = stb_arr_len(list);
// @TODO: measure to find good numbers instead of just making them up!
int thresh = (sd->ineq ? 200 : 20);
// if n is large enough to be worth it, and n is smaller than
// before (so we can guarantee we'll use a smaller hash table);
// and there are enough hash bits left, assuming full 32-bit hash
if (n > thresh && n < (sd->population >> 3) && sd->hash_shift + sd->size_log2*2 < 32) {
// recursively process this row using stb_dupe, O(N log log N)
stb_dupe *d = stb_dupe_create(sd->hash, sd->eq, n, sd->ineq);
d->hash_shift = stb_randLCG_explicit(sd->hash_shift);
for (j=0; j < n; ++j)
stb_dupe_add(d, list[j]);
stb_arr_free(sd->hash_table[i]);
stb_dupe_finish(d);
for (j=0; j < stb_arr_len(d->dupes); ++j) {
stb_arr_push(sd->dupes, d->dupes[j]);
d->dupes[j] = NULL; // take over ownership
}
stb_dupe_free(d);
} else if (sd->ineq) {
// process this row using qsort(), O(N log N)
stb__compare = sd->ineq;
qsort(list, n, sizeof(list[0]), stb__dupe_compare);
// find equal subsequences of the list
for (j=0; j < n-1; ) {
// find a subsequence from j..k
for (k=j; k < n; ++k)
// only use ineq so eq can be left undefined
if (sd->ineq(list[j], list[k]))
break;
// k is the first one not in the subsequence
if (k-j > 1) {
void **mylist = NULL;
stb_arr_setlen(mylist, k-j);
memcpy(mylist, list+j, sizeof(list[j]) * (k-j));
stb_arr_push(sd->dupes, mylist);
}
j = k;
}
stb_arr_free(sd->hash_table[i]);
} else {
// process this row using eq(), O(N^2)
for (j=0; j < n; ++j) {
if (list[j] != NULL) {
void **output = NULL;
for (k=j+1; k < n; ++k) {
if (sd->eq(list[j], list[k])) {
if (output == NULL)
stb_arr_push(output, list[j]);
stb_arr_push(output, list[k]);
list[k] = NULL;
}
}
list[j] = NULL;
if (output)
stb_arr_push(sd->dupes, output);
}
}
stb_arr_free(sd->hash_table[i]);
}
}
}
free(sd->hash_table);
sd->hash_table = NULL;
}
#endif
//////////////////////////////////////////////////////////////////////////////
//
// templatized Sort routine
//
// This is an attempt to implement a templated sorting algorithm.
// To use it, you have to explicitly instantiate it as a _function_,
// then you call that function. This allows the comparison to be inlined,
// giving the sort similar performance to C++ sorts.
//
// It implements quicksort with three-way-median partitioning (generally
// well-behaved), with a final insertion sort pass.
//
// When you define the compare expression, you should assume you have
// elements of your array pointed to by 'a' and 'b', and perform the comparison
// on those. OR you can use one or more statements; first say '0;', then
// write whatever code you want, and compute the result into a variable 'c'.
#define stb_declare_sort(FUNCNAME, TYPE) \
void FUNCNAME(TYPE *p, int n)
#define stb_define_sort(FUNCNAME,TYPE,COMPARE) \
stb__define_sort( void, FUNCNAME,TYPE,COMPARE)
#define stb_define_sort_static(FUNCNAME,TYPE,COMPARE) \
stb__define_sort(static void, FUNCNAME,TYPE,COMPARE)
#define stb__define_sort(MODE, FUNCNAME, TYPE, COMPARE) \
\
static void STB_(FUNCNAME,_ins_sort)(TYPE *p, int n) \
{ \
int i,j; \
for (i=1; i < n; ++i) { \
TYPE t = p[i], *a = &t; \
j = i; \
while (j > 0) { \
TYPE *b = &p[j-1]; \
int c = COMPARE; \
if (!c) break; \
p[j] = p[j-1]; \
--j; \
} \
if (i != j) \
p[j] = t; \
} \
} \
\
static void STB_(FUNCNAME,_quicksort)(TYPE *p, int n) \
{ \
/* threshhold for transitioning to insertion sort */ \
while (n > 12) { \
TYPE *a,*b,t; \
int c01,c12,c,m,i,j; \
\
/* compute median of three */ \
m = n >> 1; \
a = &p[0]; \
b = &p[m]; \
c = COMPARE; \
c01 = c; \
a = &p[m]; \
b = &p[n-1]; \
c = COMPARE; \
c12 = c; \
/* if 0 >= mid >= end, or 0 < mid < end, then use mid */ \
if (c01 != c12) { \
/* otherwise, we'll need to swap something else to middle */ \
int z; \
a = &p[0]; \
b = &p[n-1]; \
c = COMPARE; \
/* 0>mid && mid<n: 0>n => n; 0<n => 0 */ \
/* 0<mid && mid>n: 0>n => 0; 0<n => n */ \
z = (c == c12) ? 0 : n-1; \
t = p[z]; \
p[z] = p[m]; \
p[m] = t; \
} \
/* now p[m] is the median-of-three */ \
/* swap it to the beginning so it won't move around */ \
t = p[0]; \
p[0] = p[m]; \
p[m] = t; \
\
/* partition loop */ \
i=1; \
j=n-1; \
for(;;) { \
/* handling of equality is crucial here */ \
/* for sentinels & efficiency with duplicates */ \
b = &p[0]; \
for (;;++i) { \
a=&p[i]; \
c = COMPARE; \
if (!c) break; \
} \
a = &p[0]; \
for (;;--j) { \
b=&p[j]; \
c = COMPARE; \
if (!c) break; \
} \
/* make sure we haven't crossed */ \
if (i >= j) break; \
t = p[i]; \
p[i] = p[j]; \
p[j] = t; \
\
++i; \
--j; \
} \
/* recurse on smaller side, iterate on larger */ \
if (j < (n-i)) { \
STB_(FUNCNAME,_quicksort)(p,j); \
p = p+i; \
n = n-i; \
} else { \
STB_(FUNCNAME,_quicksort)(p+i, n-i); \
n = j; \
} \
} \
} \
\
MODE FUNCNAME(TYPE *p, int n) \
{ \
STB_(FUNCNAME, _quicksort)(p, n); \
STB_(FUNCNAME, _ins_sort)(p, n); \
} \
//////////////////////////////////////////////////////////////////////////////
//
// stb_bitset an array of booleans indexed by integers
//
typedef stb_uint32 stb_bitset;
STB_EXTERN stb_bitset *stb_bitset_new(int value, int len);
#define stb_bitset_clearall(arr,len) (memset(arr, 0, 4 * (len)))
#define stb_bitset_setall(arr,len) (memset(arr, 255, 4 * (len)))
#define stb_bitset_setbit(arr,n) ((arr)[(n) >> 5] |= (1 << (n & 31)))
#define stb_bitset_clearbit(arr,n) ((arr)[(n) >> 5] &= ~(1 << (n & 31)))
#define stb_bitset_testbit(arr,n) ((arr)[(n) >> 5] & (1 << (n & 31)))
STB_EXTERN stb_bitset *stb_bitset_union(stb_bitset *p0, stb_bitset *p1, int len);
STB_EXTERN int *stb_bitset_getlist(stb_bitset *out, int start, int end);
STB_EXTERN int stb_bitset_eq(stb_bitset *p0, stb_bitset *p1, int len);
STB_EXTERN int stb_bitset_disjoint(stb_bitset *p0, stb_bitset *p1, int len);
STB_EXTERN int stb_bitset_disjoint_0(stb_bitset *p0, stb_bitset *p1, int len);
STB_EXTERN int stb_bitset_subset(stb_bitset *bigger, stb_bitset *smaller, int len);
STB_EXTERN int stb_bitset_unioneq_changed(stb_bitset *p0, stb_bitset *p1, int len);
#ifdef STB_DEFINE
int stb_bitset_eq(stb_bitset *p0, stb_bitset *p1, int len)
{
int i;
for (i=0; i < len; ++i)
if (p0[i] != p1[i]) return 0;
return 1;
}
int stb_bitset_disjoint(stb_bitset *p0, stb_bitset *p1, int len)
{
int i;
for (i=0; i < len; ++i)
if (p0[i] & p1[i]) return 0;
return 1;
}
int stb_bitset_disjoint_0(stb_bitset *p0, stb_bitset *p1, int len)
{
int i;
for (i=0; i < len; ++i)
if ((p0[i] | p1[i]) != 0xffffffff) return 0;
return 1;
}
int stb_bitset_subset(stb_bitset *bigger, stb_bitset *smaller, int len)
{
int i;
for (i=0; i < len; ++i)
if ((bigger[i] & smaller[i]) != smaller[i]) return 0;
return 1;
}
stb_bitset *stb_bitset_union(stb_bitset *p0, stb_bitset *p1, int len)
{
int i;
stb_bitset *d = (stb_bitset *) malloc(sizeof(*d) * len);
for (i=0; i < len; ++i) d[i] = p0[i] | p1[i];
return d;
}
int stb_bitset_unioneq_changed(stb_bitset *p0, stb_bitset *p1, int len)
{
int i, changed=0;
for (i=0; i < len; ++i) {
stb_bitset d = p0[i] | p1[i];
if (d != p0[i]) {
p0[i] = d;
changed = 1;
}
}
return changed;
}
stb_bitset *stb_bitset_new(int value, int len)
{
int i;
stb_bitset *d = (stb_bitset *) malloc(sizeof(*d) * len);
if (value) value = 0xffffffff;
for (i=0; i < len; ++i) d[i] = value;
return d;
}
int *stb_bitset_getlist(stb_bitset *out, int start, int end)
{
int *list = NULL;
int i;
for (i=start; i < end; ++i)
if (stb_bitset_testbit(out, i))
stb_arr_push(list, i);
return list;
}
#endif
//////////////////////////////////////////////////////////////////////////////
//
// stb_wordwrap quality word-wrapping for fixed-width fonts
//
STB_EXTERN int stb_wordwrap(int *pairs, int pair_max, int count, char *str);
STB_EXTERN int *stb_wordwrapalloc(int count, char *str);
#ifdef STB_DEFINE
int stb_wordwrap(int *pairs, int pair_max, int count, char *str)
{
int n=0,i=0, start=0,nonwhite=0;
if (pairs == NULL) pair_max = 0x7ffffff0;
else pair_max *= 2;
// parse
for(;;) {
int s=i; // first whitespace char; last nonwhite+1
int w; // word start
// accept whitespace
while (isspace(str[i])) {
if (str[i] == '\n' || str[i] == '\r') {
if (str[i] + str[i+1] == '\n' + '\r') ++i;
if (n >= pair_max) return -1;
if (pairs) pairs[n] = start, pairs[n+1] = s-start;
n += 2;
nonwhite=0;
start = i+1;
s = start;
}
++i;
}
if (i >= start+count) {
// we've gone off the end using whitespace
if (nonwhite) {
if (n >= pair_max) return -1;
if (pairs) pairs[n] = start, pairs[n+1] = s-start;
n += 2;
start = s = i;
nonwhite=0;
} else {
// output all the whitespace
while (i >= start+count) {
if (n >= pair_max) return -1;
if (pairs) pairs[n] = start, pairs[n+1] = count;
n += 2;
start += count;
}
s = start;
}
}
if (str[i] == 0) break;
// now scan out a word and see if it fits
w = i;
while (str[i] && !isspace(str[i])) {
++i;
}
// wrapped?
if (i > start + count) {
// huge?
if (i-s <= count) {
if (n >= pair_max) return -1;
if (pairs) pairs[n] = start, pairs[n+1] = s-start;
n += 2;
start = w;
} else {
// This word is longer than one line. If we wrap it onto N lines
// there are leftover chars. do those chars fit on the cur line?
// But if we have leading whitespace, we force it to start here.
if ((w-start) + ((i-w) % count) <= count || !nonwhite) {
// output a full line
if (n >= pair_max) return -1;
if (pairs) pairs[n] = start, pairs[n+1] = count;
n += 2;
start += count;
w = start;
} else {
// output a partial line, trimming trailing whitespace
if (s != start) {
if (n >= pair_max) return -1;
if (pairs) pairs[n] = start, pairs[n+1] = s-start;
n += 2;
start = w;
}
}
// now output full lines as needed
while (start + count <= i) {
if (n >= pair_max) return -1;
if (pairs) pairs[n] = start, pairs[n+1] = count;
n += 2;
start += count;
}
}
}
nonwhite=1;
}
if (start < i) {
if (n >= pair_max) return -1;
if (pairs) pairs[n] = start, pairs[n+1] = i-start;
n += 2;
}
return n>>1;
}
int *stb_wordwrapalloc(int count, char *str)
{
int n = stb_wordwrap(NULL,0,count,str);
int *z = NULL;
stb_arr_setlen(z, n*2);
stb_wordwrap(z, n, count, str);
return z;
}
#endif
//////////////////////////////////////////////////////////////////////////////
//
// stb_match: wildcards and regexping
//
STB_EXTERN int stb_wildmatch (char *expr, char *candidate);
STB_EXTERN int stb_wildmatchi(char *expr, char *candidate);
STB_EXTERN int stb_wildfind (char *expr, char *candidate);
STB_EXTERN int stb_wildfindi (char *expr, char *candidate);
STB_EXTERN int stb_regex(char *regex, char *candidate);
typedef struct stb_matcher stb_matcher;
STB_EXTERN stb_matcher *stb_regex_matcher(char *regex);
STB_EXTERN int stb_matcher_match(stb_matcher *m, char *str);
STB_EXTERN int stb_matcher_find(stb_matcher *m, char *str);
STB_EXTERN void stb_matcher_free(stb_matcher *f);
STB_EXTERN stb_matcher *stb_lex_matcher(void);
STB_EXTERN int stb_lex_item(stb_matcher *m, char *str, int result);
STB_EXTERN int stb_lex_item_wild(stb_matcher *matcher, char *regex, int result);
STB_EXTERN int stb_lex(stb_matcher *m, char *str, int *len);
#ifdef STB_DEFINE
static int stb__match_qstring(char *candidate, char *qstring, int qlen, int insensitive)
{
int i;
if (insensitive) {
for (i=0; i < qlen; ++i)
if (qstring[i] == '?') {
if (!candidate[i]) return 0;
} else
if (tolower(qstring[i]) != tolower(candidate[i]))
return 0;
} else {
for (i=0; i < qlen; ++i)
if (qstring[i] == '?') {
if (!candidate[i]) return 0;
} else
if (qstring[i] != candidate[i])
return 0;
}
return 1;
}
static int stb__find_qstring(char *candidate, char *qstring, int qlen, int insensitive)
{
char c;
int offset=0;
while (*qstring == '?') {
++qstring;
--qlen;
++candidate;
if (qlen == 0) return 0;
if (*candidate == 0) return -1;
}
c = *qstring++;
--qlen;
if (insensitive) c = tolower(c);
while (candidate[offset]) {
if (c == (insensitive ? tolower(candidate[offset]) : candidate[offset]))
if (stb__match_qstring(candidate+offset+1, qstring, qlen, insensitive))
return offset;
++offset;
}
return -1;
}
int stb__wildmatch_raw2(char *expr, char *candidate, int search, int insensitive)
{
int where=0;
int start = -1;
if (!search) {
// parse to first '*'
if (*expr != '*')
start = 0;
while (*expr != '*') {
if (!*expr)
return *candidate == 0 ? 0 : -1;
if (*expr == '?') {
if (!*candidate) return -1;
} else {
if (insensitive) {
if (tolower(*candidate) != tolower(*expr))
return -1;
} else
if (*candidate != *expr)
return -1;
}
++candidate, ++expr, ++where;
}
} else {
// 0-length search string
if (!*expr)
return 0;
}
assert(search || *expr == '*');
if (!search)
++expr;
// implicit '*' at this point
while (*expr) {
int o=0;
// combine redundant * characters
while (expr[0] == '*') ++expr;
// ok, at this point, expr[-1] == '*',
// and expr[0] != '*'
if (!expr[0]) return start >= 0 ? start : 0;
// now find next '*'
o = 0;
while (expr[o] != '*') {
if (expr[o] == 0)
break;
++o;
}
// if no '*', scan to end, then match at end
if (expr[o] == 0 && !search) {
int z;
for (z=0; z < o; ++z)
if (candidate[z] == 0)
return -1;
while (candidate[z])
++z;
// ok, now check if they match
if (stb__match_qstring(candidate+z-o, expr, o, insensitive))
return start >= 0 ? start : 0;
return -1;
} else {
// if yes '*', then do stb__find_qmatch on the intervening chars
int n = stb__find_qstring(candidate, expr, o, insensitive);
if (n < 0)
return -1;
if (start < 0)
start = where + n;
expr += o;
candidate += n+o;
}
if (*expr == 0) {
assert(search);
return start;
}
assert(*expr == '*');
++expr;
}
return start >= 0 ? start : 0;
}
int stb__wildmatch_raw(char *expr, char *candidate, int search, int insensitive)
{
char buffer[256];
// handle multiple search strings
char *s = strchr(expr, ';');
char *last = expr;
while (s) {
int z;
// need to allow for non-writeable strings... assume they're small
if (s - last < 256) {
stb_strncpy(buffer, last, s-last+1);
z = stb__wildmatch_raw2(buffer, candidate, search, insensitive);
} else {
*s = 0;
z = stb__wildmatch_raw2(last, candidate, search, insensitive);
*s = ';';
}
if (z >= 0) return z;
last = s+1;
s = strchr(last, ';');
}
return stb__wildmatch_raw2(last, candidate, search, insensitive);
}
int stb_wildmatch(char *expr, char *candidate)
{
return stb__wildmatch_raw(expr, candidate, 0,0) >= 0;
}
int stb_wildmatchi(char *expr, char *candidate)
{
return stb__wildmatch_raw(expr, candidate, 0,1) >= 0;
}
int stb_wildfind(char *expr, char *candidate)
{
return stb__wildmatch_raw(expr, candidate, 1,0);
}
int stb_wildfindi(char *expr, char *candidate)
{
return stb__wildmatch_raw(expr, candidate, 1,1);
}
typedef struct
{
stb_int16 transition[256];
} stb_dfa;
// an NFA node represents a state you're in; it then has
// an arbitrary number of edges dangling off of it
// note this isn't utf8-y
typedef struct
{
stb_int16 match; // character/set to match
stb_uint16 node; // output node to go to
} stb_nfa_edge;
typedef struct
{
stb_int16 goal; // does reaching this win the prize?
stb_uint8 active; // is this in the active list
stb_nfa_edge *out;
stb_uint16 *eps; // list of epsilon closures
} stb_nfa_node;
#define STB__DFA_UNDEF -1
#define STB__DFA_GOAL -2
#define STB__DFA_END -3
#define STB__DFA_MGOAL -4
#define STB__DFA_VALID 0
#define STB__NFA_STOP_GOAL -1
// compiled regexp
struct stb_matcher
{
stb_uint16 start_node;
stb_int16 dfa_start;
stb_uint32 *charset;
int num_charset;
int match_start;
stb_nfa_node *nodes;
int does_lex;
// dfa matcher
stb_dfa * dfa;
stb_uint32 * dfa_mapping;
stb_int16 * dfa_result;
int num_words_per_dfa;
};
static int stb__add_node(stb_matcher *matcher)
{
stb_nfa_node z;
z.active = 0;
z.eps = 0;
z.goal = 0;
z.out = 0;
stb_arr_push(matcher->nodes, z);
return stb_arr_len(matcher->nodes)-1;
}
static void stb__add_epsilon(stb_matcher *matcher, int from, int to)
{
assert(from != to);
if (matcher->nodes[from].eps == NULL)
stb_arr_malloc((void **) &matcher->nodes[from].eps, matcher);
stb_arr_push(matcher->nodes[from].eps, to);
}
static void stb__add_edge(stb_matcher *matcher, int from, int to, int type)
{
stb_nfa_edge z = { type, to };
if (matcher->nodes[from].out == NULL)
stb_arr_malloc((void **) &matcher->nodes[from].out, matcher);
stb_arr_push(matcher->nodes[from].out, z);
}
static char *stb__reg_parse_alt(stb_matcher *m, int s, char *r, stb_uint16 *e);
static char *stb__reg_parse(stb_matcher *matcher, int start, char *regex, stb_uint16 *end)
{
int n;
int last_start = -1;
stb_uint16 last_end = start;
while (*regex) {
switch (*regex) {
case '(':
last_start = last_end;
regex = stb__reg_parse_alt(matcher, last_end, regex+1, &last_end);
if (regex == NULL || *regex != ')')
return NULL;
++regex;
break;
case '|':
case ')':
*end = last_end;
return regex;
case '?':
if (last_start < 0) return NULL;
stb__add_epsilon(matcher, last_start, last_end);
++regex;
break;
case '*':
if (last_start < 0) return NULL;
stb__add_epsilon(matcher, last_start, last_end);
// fall through
case '+':
if (last_start < 0) return NULL;
stb__add_epsilon(matcher, last_end, last_start);
// prevent links back to last_end from chaining to last_start
n = stb__add_node(matcher);
stb__add_epsilon(matcher, last_end, n);
last_end = n;
++regex;
break;
case '{': // not supported!
// @TODO: given {n,m}, clone last_start to last_end m times,
// and include epsilons from start to first m-n blocks
return NULL;
case '\\':
++regex;
if (!*regex) return NULL;
// fallthrough
default: // match exactly this character
n = stb__add_node(matcher);
stb__add_edge(matcher, last_end, n, *regex);
last_start = last_end;
last_end = n;
++regex;
break;
case '$':
n = stb__add_node(matcher);
stb__add_edge(matcher, last_end, n, '\n');
last_start = last_end;
last_end = n;
++regex;
break;
case '.':
n = stb__add_node(matcher);
stb__add_edge(matcher, last_end, n, -1);
last_start = last_end;
last_end = n;
++regex;
break;
case '[': {
stb_uint8 flags[256];
int invert = 0,z;
++regex;
if (matcher->num_charset == 0) {
matcher->charset = (stb_uint *) stb_malloc(matcher, sizeof(*matcher->charset) * 256);
memset(matcher->charset, 0, sizeof(*matcher->charset) * 256);
}
memset(flags,0,sizeof(flags));
// leading ^ is special
if (*regex == '^')
++regex, invert = 1;
// leading ] is special
if (*regex == ']') {
flags[']'] = 1;
++regex;
}
while (*regex != ']') {
stb_uint a;
if (!*regex) return NULL;
a = *regex++;
if (regex[0] == '-' && regex[1] != ']') {
stb_uint i,b = regex[1];
regex += 2;
if (b == 0) return NULL;
if (a > b) return NULL;
for (i=a; i <= b; ++i)
flags[i] = 1;
} else
flags[a] = 1;
}
++regex;
if (invert) {
int i;
for (i=0; i < 256; ++i)
flags[i] = 1-flags[i];
}
// now check if any existing charset matches
for (z=0; z < matcher->num_charset; ++z) {
int i, k[2] = { 0, 1 << z};
for (i=0; i < 256; ++i) {
unsigned int f = k[flags[i]];
if ((matcher->charset[i] & k[1]) != f)
break;
}
if (i == 256) break;
}
if (z == matcher->num_charset) {
int i;
++matcher->num_charset;
if (matcher->num_charset > 32) {
assert(0); /* NOTREACHED */
return NULL; // too many charsets, oops
}
for (i=0; i < 256; ++i)
if (flags[i])
matcher->charset[i] |= (1 << z);
}
n = stb__add_node(matcher);
stb__add_edge(matcher, last_end, n, -2 - z);
last_start = last_end;
last_end = n;
break;
}
}
}
*end = last_end;
return regex;
}
static char *stb__reg_parse_alt(stb_matcher *matcher, int start, char *regex, stb_uint16 *end)
{
stb_uint16 last_end = start;
stb_uint16 main_end;
int head, tail;
head = stb__add_node(matcher);
stb__add_epsilon(matcher, start, head);
regex = stb__reg_parse(matcher, head, regex, &last_end);
if (regex == NULL) return NULL;
if (*regex == 0 || *regex == ')') {
*end = last_end;
return regex;
}
main_end = last_end;
tail = stb__add_node(matcher);
stb__add_epsilon(matcher, last_end, tail);
// start alternatives from the same starting node; use epsilon
// transitions to combine their endings
while(*regex && *regex != ')') {
assert(*regex == '|');
head = stb__add_node(matcher);
stb__add_epsilon(matcher, start, head);
regex = stb__reg_parse(matcher, head, regex+1, &last_end);
if (regex == NULL)
return NULL;
stb__add_epsilon(matcher, last_end, tail);
}
*end = tail;
return regex;
}
static char *stb__wild_parse(stb_matcher *matcher, int start, char *str, stb_uint16 *end)
{
int n;
stb_uint16 last_end;
last_end = stb__add_node(matcher);
stb__add_epsilon(matcher, start, last_end);
while (*str) {
switch (*str) {
// fallthrough
default: // match exactly this character
n = stb__add_node(matcher);
if (toupper(*str) == tolower(*str)) {
stb__add_edge(matcher, last_end, n, *str);
} else {
stb__add_edge(matcher, last_end, n, tolower(*str));
stb__add_edge(matcher, last_end, n, toupper(*str));
}
last_end = n;
++str;
break;
case '?':
n = stb__add_node(matcher);
stb__add_edge(matcher, last_end, n, -1);
last_end = n;
++str;
break;
case '*':
n = stb__add_node(matcher);
stb__add_edge(matcher, last_end, n, -1);
stb__add_epsilon(matcher, last_end, n);
stb__add_epsilon(matcher, n, last_end);
last_end = n;
++str;
break;
}
}
// now require end of string to match
n = stb__add_node(matcher);
stb__add_edge(matcher, last_end, n, 0);
last_end = n;
*end = last_end;
return str;
}
static int stb__opt(stb_matcher *m, int n)
{
for(;;) {
stb_nfa_node *p = &m->nodes[n];
if (p->goal) return n;
if (stb_arr_len(p->out)) return n;
if (stb_arr_len(p->eps) != 1) return n;
n = p->eps[0];
}
}
static void stb__optimize(stb_matcher *m)
{
// if the target of any edge is a node with exactly
// one out-epsilon, shorten it
int i,j;
for (i=0; i < stb_arr_len(m->nodes); ++i) {
stb_nfa_node *p = &m->nodes[i];
for (j=0; j < stb_arr_len(p->out); ++j)
p->out[j].node = stb__opt(m,p->out[j].node);
for (j=0; j < stb_arr_len(p->eps); ++j)
p->eps[j] = stb__opt(m,p->eps[j] );
}
m->start_node = stb__opt(m,m->start_node);
}
void stb_matcher_free(stb_matcher *f)
{
stb_free(f);
}
static stb_matcher *stb__alloc_matcher(void)
{
stb_matcher *matcher = (stb_matcher *) stb_malloc(0,sizeof(*matcher));
matcher->start_node = 0;
stb_arr_malloc((void **) &matcher->nodes, matcher);
matcher->num_charset = 0;
matcher->match_start = 0;
matcher->does_lex = 0;
matcher->dfa_start = STB__DFA_UNDEF;
stb_arr_malloc((void **) &matcher->dfa, matcher);
stb_arr_malloc((void **) &matcher->dfa_mapping, matcher);
stb_arr_malloc((void **) &matcher->dfa_result, matcher);
stb__add_node(matcher);
return matcher;
}
static void stb__lex_reset(stb_matcher *matcher)
{
// flush cached dfa data
stb_arr_setlen(matcher->dfa, 0);
stb_arr_setlen(matcher->dfa_mapping, 0);
stb_arr_setlen(matcher->dfa_result, 0);
matcher->dfa_start = STB__DFA_UNDEF;
}
stb_matcher *stb_regex_matcher(char *regex)
{
char *z;
stb_uint16 end;
stb_matcher *matcher = stb__alloc_matcher();
if (*regex == '^') {
matcher->match_start = 1;
++regex;
}
z = stb__reg_parse_alt(matcher, matcher->start_node, regex, &end);
if (!z || *z) {
stb_free(matcher);
return NULL;
}
((matcher->nodes)[(int) end]).goal = STB__NFA_STOP_GOAL;
return matcher;
}
stb_matcher *stb_lex_matcher(void)
{
stb_matcher *matcher = stb__alloc_matcher();
matcher->match_start = 1;
matcher->does_lex = 1;
return matcher;
}
int stb_lex_item(stb_matcher *matcher, char *regex, int result)
{
char *z;
stb_uint16 end;
z = stb__reg_parse_alt(matcher, matcher->start_node, regex, &end);
if (z == NULL)
return 0;
stb__lex_reset(matcher);
matcher->nodes[(int) end].goal = result;
return 1;
}
int stb_lex_item_wild(stb_matcher *matcher, char *regex, int result)
{
char *z;
stb_uint16 end;
z = stb__wild_parse(matcher, matcher->start_node, regex, &end);
if (z == NULL)
return 0;
stb__lex_reset(matcher);
matcher->nodes[(int) end].goal = result;
return 1;
}
static void stb__clear(stb_matcher *m, stb_uint16 *list)
{
int i;
for (i=0; i < stb_arr_len(list); ++i)
m->nodes[(int) list[i]].active = 0;
}
static int stb__clear_goalcheck(stb_matcher *m, stb_uint16 *list)
{
int i, t=0;
for (i=0; i < stb_arr_len(list); ++i) {
t += m->nodes[(int) list[i]].goal;
m->nodes[(int) list[i]].active = 0;
}
return t;
}
static stb_uint16 * stb__add_if_inactive(stb_matcher *m, stb_uint16 *list, int n)
{
if (!m->nodes[n].active) {
stb_arr_push(list, n);
m->nodes[n].active = 1;
}
return list;
}
static stb_uint16 * stb__eps_closure(stb_matcher *m, stb_uint16 *list)
{
int i,n = stb_arr_len(list);
for(i=0; i < n; ++i) {
stb_uint16 *e = m->nodes[(int) list[i]].eps;
if (e) {
int j,k = stb_arr_len(e);
for (j=0; j < k; ++j)
list = stb__add_if_inactive(m, list, e[j]);
n = stb_arr_len(list);
}
}
return list;
}
int stb_matcher_match(stb_matcher *m, char *str)
{
int result = 0;
int i,j,y,z;
stb_uint16 *previous = NULL;
stb_uint16 *current = NULL;
stb_uint16 *temp;
stb_arr_setsize(previous, 4);
stb_arr_setsize(current, 4);
previous = stb__add_if_inactive(m, previous, m->start_node);
previous = stb__eps_closure(m,previous);
stb__clear(m, previous);
while (*str && stb_arr_len(previous)) {
y = stb_arr_len(previous);
for (i=0; i < y; ++i) {
stb_nfa_node *n = &m->nodes[(int) previous[i]];
z = stb_arr_len(n->out);
for (j=0; j < z; ++j) {
if (n->out[j].match >= 0) {
if (n->out[j].match == *str)
current = stb__add_if_inactive(m, current, n->out[j].node);
} else if (n->out[j].match == -1) {
if (*str != '\n')
current = stb__add_if_inactive(m, current, n->out[j].node);
} else if (n->out[j].match < -1) {
int z = -n->out[j].match - 2;
if (m->charset[(stb_uint8) *str] & (1 << z))
current = stb__add_if_inactive(m, current, n->out[j].node);
}
}
}
stb_arr_setlen(previous, 0);
temp = previous;
previous = current;
current = temp;
previous = stb__eps_closure(m,previous);
stb__clear(m, previous);
++str;
}
// transition to pick up a '$' at the end
y = stb_arr_len(previous);
for (i=0; i < y; ++i)
m->nodes[(int) previous[i]].active = 1;
for (i=0; i < y; ++i) {
stb_nfa_node *n = &m->nodes[(int) previous[i]];
z = stb_arr_len(n->out);
for (j=0; j < z; ++j) {
if (n->out[j].match == '\n')
current = stb__add_if_inactive(m, current, n->out[j].node);
}
}
previous = stb__eps_closure(m,previous);
stb__clear(m, previous);
y = stb_arr_len(previous);
for (i=0; i < y; ++i)
if (m->nodes[(int) previous[i]].goal)
result = 1;
stb_arr_free(previous);
stb_arr_free(current);
return result && *str == 0;
}
stb_int16 stb__get_dfa_node(stb_matcher *m, stb_uint16 *list)
{
stb_uint16 node;
stb_uint32 data[8], *state, *newstate;
int i,j,n;
state = (stb_uint32 *) stb_temp(data, m->num_words_per_dfa * 4);
memset(state, 0, m->num_words_per_dfa*4);
n = stb_arr_len(list);
for (i=0; i < n; ++i) {
int x = list[i];
state[x >> 5] |= 1 << (x & 31);
}
// @TODO use a hash table
n = stb_arr_len(m->dfa_mapping);
i=j=0;
for(; j < n; ++i, j += m->num_words_per_dfa) {
// @TODO special case for <= 32
if (!memcmp(state, m->dfa_mapping + j, m->num_words_per_dfa*4)) {
node = i;
goto done;
}
}
assert(stb_arr_len(m->dfa) == i);
node = i;
newstate = stb_arr_addn(m->dfa_mapping, m->num_words_per_dfa);
memcpy(newstate, state, m->num_words_per_dfa*4);
// set all transitions to 'unknown'
stb_arr_add(m->dfa);
memset(m->dfa[i].transition, -1, sizeof(m->dfa[i].transition));
if (m->does_lex) {
int result = -1;
n = stb_arr_len(list);
for (i=0; i < n; ++i) {
if (m->nodes[(int) list[i]].goal > result)
result = m->nodes[(int) list[i]].goal;
}
stb_arr_push(m->dfa_result, result);
}
done:
stb_tempfree(data, state);
return node;
}
static int stb__matcher_dfa(stb_matcher *m, char *str_c, int *len)
{
stb_uint8 *str = (stb_uint8 *) str_c;
stb_int16 node,prevnode;
stb_dfa *trans;
int match_length = 0;
stb_int16 match_result=0;
if (m->dfa_start == STB__DFA_UNDEF) {
stb_uint16 *list;
m->num_words_per_dfa = (stb_arr_len(m->nodes)+31) >> 5;
stb__optimize(m);
list = stb__add_if_inactive(m, NULL, m->start_node);
list = stb__eps_closure(m,list);
if (m->does_lex) {
m->dfa_start = stb__get_dfa_node(m,list);
stb__clear(m, list);
// DON'T allow start state to be a goal state!
// this allows people to specify regexes that can match 0
// characters without them actually matching (also we don't
// check _before_ advancing anyway
if (m->dfa_start <= STB__DFA_MGOAL)
m->dfa_start = -(m->dfa_start - STB__DFA_MGOAL);
} else {
if (stb__clear_goalcheck(m, list))
m->dfa_start = STB__DFA_GOAL;
else
m->dfa_start = stb__get_dfa_node(m,list);
}
stb_arr_free(list);
}
prevnode = STB__DFA_UNDEF;
node = m->dfa_start;
trans = m->dfa;
if (m->dfa_start == STB__DFA_GOAL)
return 1;
for(;;) {
assert(node >= STB__DFA_VALID);
// fast inner DFA loop; especially if STB__DFA_VALID is 0
do {
prevnode = node;
node = trans[node].transition[*str++];
} while (node >= STB__DFA_VALID);
assert(node >= STB__DFA_MGOAL - stb_arr_len(m->dfa));
assert(node < stb_arr_len(m->dfa));
// special case for lex: need _longest_ match, so notice goal
// state without stopping
if (node <= STB__DFA_MGOAL) {
match_length = str - (stb_uint8 *) str_c;
node = -(node - STB__DFA_MGOAL);
match_result = node;
continue;
}
// slow NFA->DFA conversion
// or we hit the goal or the end of the string, but those
// can only happen once per search...
if (node == STB__DFA_UNDEF) {
// build a list -- @TODO special case <= 32 states
// heck, use a more compact data structure for <= 16 and <= 8 ?!
// @TODO keep states/newstates around instead of reallocating them
stb_uint16 *states = NULL;
stb_uint16 *newstates = NULL;
int i,j,y,z;
stb_uint32 *flags = &m->dfa_mapping[prevnode * m->num_words_per_dfa];
assert(prevnode != STB__DFA_UNDEF);
stb_arr_setsize(states, 4);
stb_arr_setsize(newstates,4);
for (j=0; j < m->num_words_per_dfa; ++j) {
for (i=0; i < 32; ++i) {
if (*flags & (1 << i))
stb_arr_push(states, j*32+i);
}
++flags;
}
// states is now the states we were in in the previous node;
// so now we can compute what node it transitions to on str[-1]
y = stb_arr_len(states);
for (i=0; i < y; ++i) {
stb_nfa_node *n = &m->nodes[(int) states[i]];
z = stb_arr_len(n->out);
for (j=0; j < z; ++j) {
if (n->out[j].match >= 0) {
if (n->out[j].match == str[-1] || (str[-1] == 0 && n->out[j].match == '\n'))
newstates = stb__add_if_inactive(m, newstates, n->out[j].node);
} else if (n->out[j].match == -1) {
if (str[-1] != '\n' && str[-1])
newstates = stb__add_if_inactive(m, newstates, n->out[j].node);
} else if (n->out[j].match < -1) {
int z = -n->out[j].match - 2;
if (m->charset[str[-1]] & (1 << z))
newstates = stb__add_if_inactive(m, newstates, n->out[j].node);
}
}
}
// AND add in the start state!
if (!m->match_start || (str[-1] == '\n' && !m->does_lex))
newstates = stb__add_if_inactive(m, newstates, m->start_node);
// AND epsilon close it
newstates = stb__eps_closure(m, newstates);
// if it's a goal state, then that's all there is to it
if (stb__clear_goalcheck(m, newstates)) {
if (m->does_lex) {
match_length = str - (stb_uint8 *) str_c;
node = stb__get_dfa_node(m,newstates);
match_result = node;
node = -node + STB__DFA_MGOAL;
trans = m->dfa; // could have gotten realloc()ed
} else
node = STB__DFA_GOAL;
} else if (str[-1] == 0 || stb_arr_len(newstates) == 0) {
node = STB__DFA_END;
} else {
node = stb__get_dfa_node(m,newstates);
trans = m->dfa; // could have gotten realloc()ed
}
trans[prevnode].transition[str[-1]] = node;
if (node <= STB__DFA_MGOAL)
node = -(node - STB__DFA_MGOAL);
stb_arr_free(newstates);
stb_arr_free(states);
}
if (node == STB__DFA_GOAL) {
return 1;
}
if (node == STB__DFA_END) {
if (m->does_lex) {
if (match_result) {
if (len) *len = match_length;
return m->dfa_result[(int) match_result];
}
}
return 0;
}
assert(node != STB__DFA_UNDEF);
}
}
int stb_matcher_find(stb_matcher *m, char *str)
{
assert(m->does_lex == 0);
return stb__matcher_dfa(m, str, NULL);
}
int stb_lex(stb_matcher *m, char *str, int *len)
{
assert(m->does_lex);
return stb__matcher_dfa(m, str, len);
}
int stb_regex(char *regex, char *str)
{
static stb_perfect p;
static stb_matcher ** matchers;
static char ** regexps;
static char ** regexp_cache;
static unsigned short *mapping;
int z = stb_perfect_hash(&p, (int) regex);
if (z >= 0) {
if (strcmp(regex, regexp_cache[(int) mapping[z]])) {
int i = mapping[z];
stb_matcher_free(matchers[i]);
free(regexp_cache[i]);
regexps[i] = regex;
regexp_cache[i] = strdup(regex);
matchers[i] = stb_regex_matcher(regex);
}
} else {
int i,n;
if (regex == NULL) {
for (i=0; i < stb_arr_len(matchers); ++i) {
stb_matcher_free(matchers[i]);
free(regexp_cache[i]);
}
stb_arr_free(matchers);
stb_arr_free(regexps);
stb_arr_free(regexp_cache);
stb_perfect_destroy(&p);
free(mapping); mapping = NULL;
return -1;
}
stb_arr_push(regexps, regex);
stb_arr_push(regexp_cache, strdup(regex));
stb_arr_push(matchers, stb_regex_matcher(regex));
stb_perfect_destroy(&p);
n = stb_perfect_create(&p, (unsigned int *) (char **) regexps, stb_arr_len(regexps));
mapping = (unsigned short *) realloc(mapping, n * sizeof(*mapping));
for (i=0; i < stb_arr_len(regexps); ++i)
mapping[stb_perfect_hash(&p, (int) regexps[i])] = i;
z = stb_perfect_hash(&p, (int) regex);
}
return stb_matcher_find(matchers[(int) mapping[z]], str);
}
#endif // STB_DEFINE
#if 0
//////////////////////////////////////////////////////////////////////////////
//
// C source-code introspection
//
// runtime structure
typedef struct
{
char *name;
char *type; // base type
char *comment; // content of comment field
int size; // size of base type
int offset; // field offset
int arrcount[8]; // array sizes; -1 = pointer indirection; 0 = end of list
} stb_info_field;
typedef struct
{
char *structname;
int size;
int num_fields;
stb_info_field *fields;
} stb_info_struct;
extern stb_info_struct stb_introspect_output[];
//
STB_EXTERN void stb_introspect_precompiled(stb_info_struct *compiled);
STB_EXTERN void stb__introspect(char *path, char *file);
#define stb_introspect_ship() stb__introspect(NULL, NULL, stb__introspect_output)
#ifdef STB_SHIP
#define stb_introspect() stb_introspect_ship()
#define stb_introspect_path(p) stb_introspect_ship()
#else
// bootstrapping: define stb_introspect() (or 'path') the first time
#define stb_introspect() stb__introspect(NULL, __FILE__, NULL)
#define stb_introspect_auto() stb__introspect(NULL, __FILE__, stb__introspect_output)
#define stb_introspect_path(p) stb__introspect(p, __FILE__, NULL)
#define stb_introspect_path(p) stb__introspect(p, __FILE__, NULL)
#endif
#ifdef STB_DEFINE
#ifndef STB_INTROSPECT_CPP
#ifdef __cplusplus
#define STB_INTROSPECT_CPP 1
#else
#define STB_INTROSPECT_CPP 0
#endif
#endif
void stb_introspect_precompiled(stb_info_struct *compiled)
{
}
static void stb__introspect_filename(char *buffer, char *path)
{
#if STB_INTROSPECT_CPP
sprintf(buffer, "%s/stb_introspect.cpp", path);
#else
sprintf(buffer, "%s/stb_introspect.c", path);
#endif
}
static void stb__introspect_compute(char *path, char *file)
{
int i;
char ** include_list = NULL;
char ** introspect_list = NULL;
FILE *f;
f = fopen(file, "w");
if (!f) return;
fputs("// if you get compiler errors, change the following 0 to a 1:\n", f);
fputs("#define STB_INTROSPECT_INVALID 0\n\n", f);
fputs("// this will force the code to compile, and force the introspector\n", f);
fputs("// to run and then exit, allowing you to recompile\n\n\n", f);
fputs("#include \"stb.h\"\n\n",f );
fputs("#if STB_INTROSPECT_INVALID\n", f);
fputs(" stb_info_struct stb__introspect_output[] = { (void *) 1 }\n", f);
fputs("#else\n\n", f);
for (i=0; i < stb_arr_len(include_list); ++i)
fprintf(f, " #include \"%s\"\n", include_list[i]);
fputs(" stb_info_struct stb__introspect_output[] =\n{\n", f);
for (i=0; i < stb_arr_len(introspect_list); ++i)
fprintf(f, " stb_introspect_%s,\n", introspect_list[i]);
fputs(" };\n", f);
fputs("#endif\n", f);
fclose(f);
}
static stb_info_struct *stb__introspect_info;
#ifndef STB_SHIP
#endif
void stb__introspect(char *path, char *file, stb_info_struct *compiled)
{
static int first=1;
if (!first) return;
first=0;
stb__introspect_info = compiled;
#ifndef STB_SHIP
if (path || file) {
int bail_flag = compiled && compiled[0].structname == (void *) 1;
int needs_building = bail_flag;
struct stb__stat st;
char buffer[1024], buffer2[1024];
if (!path) {
stb_splitpath(buffer, file, STB_PATH);
path = buffer;
}
// bail if the source path doesn't exist
if (!stb_fexists(path)) return;
stb__introspect_filename(buffer2, path);
// get source/include files timestamps, compare to output-file timestamp;
// if mismatched, regenerate
if (stb__stat(buffer2, &st))
needs_building = STB_TRUE;
{
// find any file that contains an introspection command and is newer
// if needs_building is already true, we don't need to do this test,
// but we still need these arrays, so go ahead and get them
char **all[3];
all[0] = stb_readdir_files_mask(path, "*.h");
all[1] = stb_readdir_files_mask(path, "*.c");
all[2] = stb_readdir_files_mask(path, "*.cpp");
int i,j;
if (needs_building) {
for (j=0; j < 3; ++j) {
for (i=0; i < stb_arr_len(all[j]); ++i) {
struct stb__stat st2;
if (!stb__stat(all[j][i], &st2)) {
if (st.st_mtime < st2.st_mtime) {
char *z = stb_filec(all[j][i], NULL);
int found=STB_FALSE;
while (y) {
y = strstr(y, "//si");
if (y && isspace(y[4])) {
found = STB_TRUE;
break;
}
}
needs_building = STB_TRUE;
goto done;
}
}
}
}
done:;
}
char *z = stb_filec(all[i], NULL), *y = z;
int found=STB_FALSE;
while (y) {
y = strstr(y, "//si");
if (y && isspace(y[4])) {
found = STB_TRUE;
break;
}
}
if (found)
stb_arr_push(introspect_h, strdup(all[i]));
free(z);
}
}
stb_readdir_free(all);
if (!needs_building) {
for (i=0; i < stb_arr_len(introspect_h); ++i) {
struct stb__stat st2;
if (!stb__stat(introspect_h[i], &st2))
if (st.st_mtime < st2.st_mtime)
needs_building = STB_TRUE;
}
}
if (needs_building) {
stb__introspect_compute(path, buffer2);
}
}
}
#endif
}
#endif
#endif
#ifdef STB_INTROSPECT
// compile-time code-generator
#define INTROSPECT(x) int main(int argc, char **argv) { stb__introspect(__FILE__); return 0; }
#define FILE(x)
void stb__introspect(char *filename)
{
char *file = stb_file(filename, NULL);
char *s = file, *t, **p;
char *out_name = "stb_introspect.c";
char *out_path;
STB_ARR(char) filelist = NULL;
int i,n;
if (!file) stb_fatal("Couldn't open %s", filename);
out_path = stb_splitpathdup(filename, STB_PATH);
// search for the macros
while (*s) {
char buffer[256];
while (*s && !isupper(*s)) ++s;
s = stb_strtok_invert(buffer, s, "ABCDEFGHIJKLMNOPQRSTUVWXYZ");
s = stb_skipwhite(s);
if (*s == '(') {
++s;
t = strchr(s, ')');
if (t == NULL) stb_fatal("Error parsing %s", filename);
}
}
}
#endif
//////////////////////////////////////////////////////////////////////////////
//
// STB-C sliding-window dictionary compression
//
// This uses a DEFLATE-style sliding window, but no bitwise entropy.
// Everything is on byte boundaries, so you could then apply a byte-wise
// entropy code, though that's nowhere near as effective.
//
// An STB-C stream begins with a 16-byte header:
// 4 bytes: 0x57 0xBC 0x00 0x00
// 8 bytes: big-endian size of decompressed data, 64-bits
// 4 bytes: big-endian size of window (how far back decompressor may need)
//
// The following symbols appear in the stream (these were determined ad hoc,
// not by analysis):
//
// [dict] 00000100 yyyyyyyy yyyyyyyy yyyyyyyy xxxxxxxx xxxxxxxx
// [END] 00000101 11111010 cccccccc cccccccc cccccccc cccccccc
// [dict] 00000110 yyyyyyyy yyyyyyyy yyyyyyyy xxxxxxxx
// [literals] 00000111 zzzzzzzz zzzzzzzz
// [literals] 00001zzz zzzzzzzz
// [dict] 00010yyy yyyyyyyy yyyyyyyy xxxxxxxx xxxxxxxx
// [dict] 00011yyy yyyyyyyy yyyyyyyy xxxxxxxx
// [literals] 001zzzzz
// [dict] 01yyyyyy yyyyyyyy xxxxxxxx
// [dict] 1xxxxxxx yyyyyyyy
//
// xxxxxxxx: match length - 1
// yyyyyyyy: backwards distance - 1
// zzzzzzzz: num literals - 1
// cccccccc: adler32 checksum of decompressed data
// (all big-endian)
STB_EXTERN stb_uint stb_decompress_length(stb_uchar *input);
STB_EXTERN stb_uint stb_decompress(stb_uchar *out,stb_uchar *in,stb_uint len);
STB_EXTERN stb_uint stb_compress (stb_uchar *out,stb_uchar *in,stb_uint len);
STB_EXTERN void stb_compress_window(int z);
STB_EXTERN void stb_compress_hashsize(unsigned int z);
STB_EXTERN int stb_compress_tofile(char *filename, char *in, stb_uint len);
STB_EXTERN int stb_compress_intofile(FILE *f, char *input, stb_uint len);
STB_EXTERN char *stb_decompress_fromfile(char *filename, stb_uint *len);
STB_EXTERN int stb_compress_stream_start(FILE *f);
STB_EXTERN void stb_compress_stream_end(int close);
STB_EXTERN void stb_write(char *data, int data_len);
#ifdef STB_DEFINE
stb_uint stb_decompress_length(stb_uchar *input)
{
return (input[8] << 24) + (input[9] << 16) + (input[10] << 8) + input[11];
}
//////////////////// decompressor ///////////////////////
// simple implementation that just writes whole thing into big block
static unsigned char *stb__barrier;
static unsigned char *stb__barrier2;
static unsigned char *stb__barrier3;
static unsigned char *stb__barrier4;
static stb_uchar *stb__dout;
static void stb__match(stb_uchar *data, stb_uint length)
{
// INVERSE of memmove... write each byte before copying the next...
assert (stb__dout + length <= stb__barrier);
if (stb__dout + length > stb__barrier) { stb__dout += length; return; }
if (data < stb__barrier4) { stb__dout = stb__barrier+1; return; }
while (length--) *stb__dout++ = *data++;
}
static void stb__lit(stb_uchar *data, stb_uint length)
{
assert (stb__dout + length <= stb__barrier);
if (stb__dout + length > stb__barrier) { stb__dout += length; return; }
if (data < stb__barrier2) { stb__dout = stb__barrier+1; return; }
memcpy(stb__dout, data, length);
stb__dout += length;
}
#define stb__in2(x) ((i[x] << 8) + i[(x)+1])
#define stb__in3(x) ((i[x] << 16) + stb__in2((x)+1))
#define stb__in4(x) ((i[x] << 24) + stb__in3((x)+1))
static stb_uchar *stb_decompress_token(stb_uchar *i)
{
if (*i >= 0x20) { // use fewer if's for cases that expand small
if (*i >= 0x80) stb__match(stb__dout-i[1]-1, i[0] - 0x80 + 1), i += 2;
else if (*i >= 0x40) stb__match(stb__dout-(stb__in2(0) - 0x4000 + 1), i[2]+1), i += 3;
else /* *i >= 0x20 */ stb__lit(i+1, i[0] - 0x20 + 1), i += 1 + (i[0] - 0x20 + 1);
} else { // more ifs for cases that expand large, since overhead is amortized
if (*i >= 0x18) stb__match(stb__dout-(stb__in3(0) - 0x180000 + 1), i[3]+1), i += 4;
else if (*i >= 0x10) stb__match(stb__dout-(stb__in3(0) - 0x100000 + 1), stb__in2(3)+1), i += 5;
else if (*i >= 0x08) stb__lit(i+2, stb__in2(0) - 0x0800 + 1), i += 2 + (stb__in2(0) - 0x0800 + 1);
else if (*i == 0x07) stb__lit(i+3, stb__in2(1) + 1), i += 3 + (stb__in2(1) + 1);
else if (*i == 0x06) stb__match(stb__dout-(stb__in3(1)+1), i[4]+1), i += 5;
else if (*i == 0x04) stb__match(stb__dout-(stb__in3(1)+1), stb__in2(4)+1), i += 6;
}
return i;
}
stb_uint stb_decompress(stb_uchar *output, stb_uchar *i, stb_uint length)
{
stb_uint olen;
if (stb__in4(0) != 0x57bC0000) return 0;
if (stb__in4(4) != 0) return 0; // error! stream is > 4GB
olen = stb_decompress_length(i);
stb__barrier2 = i;
stb__barrier3 = i+length;
stb__barrier = output + olen;
stb__barrier4 = output;
i += 16;
stb__dout = output;
while (1) {
stb_uchar *old_i = i;
i = stb_decompress_token(i);
if (i == old_i) {
if (*i == 0x05 && i[1] == 0xfa) {
assert(stb__dout == output + olen);
if (stb__dout != output + olen) return 0;
if (stb_adler32(1, output, olen) != (stb_uint) stb__in4(2))
return 0;
return olen;
} else {
assert(0); /* NOTREACHED */
return 0;
}
}
assert(stb__dout <= output + olen);
if (stb__dout > output + olen)
return 0;
}
}
char *stb_decompress_fromfile(char *filename, unsigned int *len)
{
unsigned int n;
char *q;
unsigned char *p;
FILE *f = fopen(filename, "rb"); if (f == NULL) return NULL;
fseek(f, 0, SEEK_END);
n = ftell(f);
fseek(f, 0, SEEK_SET);
p = (unsigned char * ) malloc(n); if (p == NULL) return NULL;
fread(p, 1, n, f);
fclose(f);
if (p == NULL) return NULL;
if (p[0] != 0x57 || p[1] != 0xBc || p[2] || p[3]) { free(p); return NULL; }
q = (char *) malloc(stb_decompress_length(p)+1);
if (!q) { free(p); return NULL; }
*len = stb_decompress((unsigned char *) q, p, n);
if (*len) q[*len] = 0;
free(p);
return q;
}
#if 0
// streaming decompressor
static struct
{
stb__uchar *in_buffer;
stb__uchar *match;
stb__uint pending_literals;
stb__uint pending_match;
} xx;
static void stb__match(stb_uchar *data, stb_uint length)
{
// INVERSE of memmove... write each byte before copying the next...
assert (stb__dout + length <= stb__barrier);
if (stb__dout + length > stb__barrier) { stb__dout += length; return; }
if (data < stb__barrier2) { stb__dout = stb__barrier+1; return; }
while (length--) *stb__dout++ = *data++;
}
static void stb__lit(stb_uchar *data, stb_uint length)
{
assert (stb__dout + length <= stb__barrier);
if (stb__dout + length > stb__barrier) { stb__dout += length; return; }
if (data < stb__barrier2) { stb__dout = stb__barrier+1; return; }
memcpy(stb__dout, data, length);
stb__dout += length;
}
static void sx_match(stb_uchar *data, stb_uint length)
{
xx.match = data;
xx.pending_match = length;
}
static void sx_lit(stb_uchar *data, stb_uint length)
{
xx.pending_lit = length;
}
static int stb_decompress_token_state(void)
{
stb__uchar *i = xx.in_buffer;
if (*i >= 0x20) { // use fewer if's for cases that expand small
if (*i >= 0x80) sx_match(stb__dout-i[1]-1, i[0] - 0x80 + 1), i += 2;
else if (*i >= 0x40) sx_match(stb__dout-(stb__in2(0) - 0x4000 + 1), i[2]+1), i += 3;
else /* *i >= 0x20 */ sx_lit(i+1, i[0] - 0x20 + 1), i += 1;
} else { // more ifs for cases that expand large, since overhead is amortized
if (*i >= 0x18) sx_match(stb__dout-(stb__in3(0) - 0x180000 + 1), i[3]+1), i += 4;
else if (*i >= 0x10) sx_match(stb__dout-(stb__in3(0) - 0x100000 + 1), stb__in2(3)+1), i += 5;
else if (*i >= 0x08) sx_lit(i+2, stb__in2(0) - 0x0800 + 1), i += 2;
else if (*i == 0x07) sx_lit(i+3, stb__in2(1) + 1), i += 3;
else if (*i == 0x06) sx_match(stb__dout-(stb__in3(1)+1), i[4]+1), i += 5;
else if (*i == 0x04) sx_match(stb__dout-(stb__in3(1)+1), stb__in2(4)+1), i += 6;
else return 0;
}
xx.in_buffer = i;
return 1;
}
#endif
//////////////////// compressor ///////////////////////
static unsigned int stb_matchlen(stb_uchar *m1, stb_uchar *m2, stb_uint maxlen)
{
stb_uint i;
for (i=0; i < maxlen; ++i)
if (m1[i] != m2[i]) return i;
return i;
}
// simple implementation that just takes the source data in a big block
static stb_uchar *stb__out;
static FILE *stb__outfile;
static stb_uint stb__outbytes;
static void stb__write(unsigned char v)
{
fputc(v, stb__outfile);
++stb__outbytes;
}
#define stb_out(v) (stb__out ? *stb__out++ = (stb_uchar) (v) : stb__write((stb_uchar) (v)))
static void stb_out2(stb_uint v)
{
stb_out(v >> 8);
stb_out(v);
}
static void stb_out3(stb_uint v) { stb_out(v >> 16); stb_out(v >> 8); stb_out(v); }
static void stb_out4(stb_uint v) { stb_out(v >> 24); stb_out(v >> 16);
stb_out(v >> 8 ); stb_out(v); }
static void outliterals(stb_uchar *in, int numlit)
{
while (numlit > 65536) {
outliterals(in,65536);
in += 65536;
numlit -= 65536;
}
if (numlit == 0) ;
else if (numlit <= 32) stb_out (0x000020 + numlit-1);
else if (numlit <= 2048) stb_out2(0x000800 + numlit-1);
else /* numlit <= 65536) */ stb_out3(0x070000 + numlit-1);
if (stb__out) {
memcpy(stb__out,in,numlit);
stb__out += numlit;
} else
fwrite(in, 1, numlit, stb__outfile);
}
static int stb__window = 0x40000; // 256K
void stb_compress_window(int z)
{
if (z >= 0x1000000) z = 0x1000000; // limit of implementation
if (z < 0x100) z = 0x100; // insanely small
stb__window = z;
}
static int stb_not_crap(int best, int dist)
{
return ((best > 2 && dist <= 0x00100)
|| (best > 5 && dist <= 0x04000)
|| (best > 7 && dist <= 0x80000));
}
static stb_uint stb__hashsize = 32768;
void stb_compress_hashsize(unsigned int y)
{
unsigned int z = 1024;
while (z < y) z <<= 1;
stb__hashsize = z >> 2; // pass in bytes, store #pointers
}
// note that you can play with the hashing functions all you
// want without needing to change the decompressor
#define stb__hc(q,h,c) (((h) << 7) + ((h) >> 25) + q[c])
#define stb__hc2(q,h,c,d) (((h) << 14) + ((h) >> 18) + (q[c] << 7) + q[d])
#define stb__hc3(q,c,d,e) ((q[c] << 14) + (q[d] << 7) + q[e])
static stb_uint32 stb__running_adler;
static int stb_compress_chunk(stb_uchar *history,
stb_uchar *start,
stb_uchar *end,
int length,
int *pending_literals,
stb_uchar **chash,
stb_uint mask)
{
int window = stb__window;
stb_uint match_max;
stb_uchar *lit_start = start - *pending_literals;
stb_uchar *q = start;
#define STB__SCRAMBLE(h) (((h) + ((h) >> 16)) & mask)
// stop short of the end so we don't scan off the end doing
// the hashing; this means we won't compress the last few bytes
// unless they were part of something longer
while (q < start+length && q+12 < end) {
int m;
stb_uint h1,h2,h3,h4, h;
stb_uchar *t;
int best = 2, dist=0;
if (q+65536 > end)
match_max = end-q;
else
match_max = 65536;
#define stb__nc(b,d) ((d) <= window && ((b) > 9 || stb_not_crap(b,d)))
#define STB__TRY(t,p) /* avoid retrying a match we already tried */ \
if (p ? dist != q-t : 1) \
if ((m = stb_matchlen(t, q, match_max)) > best) \
if (stb__nc(m,q-(t))) \
best = m, dist = q - (t)
// rather than search for all matches, only try 4 candidate locations,
// chosen based on 4 different hash functions of different lengths.
// this strategy is inspired by LZO; hashing is unrolled here using the
// 'hc' macro
h = stb__hc3(q,0, 1, 2); h1 = STB__SCRAMBLE(h);
t = chash[h1]; if (t) STB__TRY(t,0);
h = stb__hc2(q,h, 3, 4); h2 = STB__SCRAMBLE(h);
h = stb__hc2(q,h, 5, 6); t = chash[h2]; if (t) STB__TRY(t,1);
h = stb__hc2(q,h, 7, 8); h3 = STB__SCRAMBLE(h);
h = stb__hc2(q,h, 9,10); t = chash[h3]; if (t) STB__TRY(t,1);
h = stb__hc2(q,h,11,12); h4 = STB__SCRAMBLE(h);
t = chash[h4]; if (t) STB__TRY(t,1);
// because we use a shared hash table, can only update it
// _after_ we've probed all of them
chash[h1] = chash[h2] = chash[h3] = chash[h4] = q;
if (best > 2)
assert(dist > 0);
// see if our best match qualifies
if (best < 3) { // fast path literals
++q;
} else if (best > 2 && best <= 0x80 && dist <= 0x100) {
outliterals(lit_start, q-lit_start); lit_start = (q += best);
stb_out(0x80 + best-1);
stb_out(dist-1);
} else if (best > 5 && best <= 0x100 && dist <= 0x4000) {
outliterals(lit_start, q-lit_start); lit_start = (q += best);
stb_out2(0x4000 + dist-1);
stb_out(best-1);
} else if (best > 7 && best <= 0x100 && dist <= 0x80000) {
outliterals(lit_start, q-lit_start); lit_start = (q += best);
stb_out3(0x180000 + dist-1);
stb_out(best-1);
} else if (best > 8 && best <= 0x10000 && dist <= 0x80000) {
outliterals(lit_start, q-lit_start); lit_start = (q += best);
stb_out3(0x100000 + dist-1);
stb_out2(best-1);
} else if (best > 9 && dist <= 0x1000000) {
if (best > 65536) best = 65536;
outliterals(lit_start, q-lit_start); lit_start = (q += best);
if (best <= 0x100) {
stb_out(0x06);
stb_out3(dist-1);
stb_out(best-1);
} else {
stb_out(0x04);
stb_out3(dist-1);
stb_out2(best-1);
}
} else { // fallback literals if no match was a balanced tradeoff
++q;
}
}
// if we didn't get all the way, add the rest to literals
if (q-start < length)
q = start+length;
// the literals are everything from lit_start to q
*pending_literals = (q - lit_start);
stb__running_adler = stb_adler32(stb__running_adler, start, q - start);
return q - start;
}
static int stb_compress_inner(stb_uchar *input, stb_uint length)
{
int literals = 0;
stb_uint len,i;
stb_uchar **chash;
chash = (stb_uchar**) malloc(stb__hashsize * sizeof(stb_uchar*));
if (chash == NULL) return 0; // failure
for (i=0; i < stb__hashsize; ++i)
chash[i] = NULL;
// stream signature
stb_out(0x57); stb_out(0xbc);
stb_out2(0);
stb_out4(0); // 64-bit length requires 32-bit leading 0
stb_out4(length);
stb_out4(stb__window);
stb__running_adler = 1;
len = stb_compress_chunk(input, input, input+length, length, &literals, chash, stb__hashsize-1);
assert(len == length);
outliterals(input+length - literals, literals);
free(chash);
stb_out2(0x05fa); // end opcode
stb_out4(stb__running_adler);
return 1; // success
}
stb_uint stb_compress(stb_uchar *out, stb_uchar *input, stb_uint length)
{
stb__out = out;
stb__outfile = NULL;
stb_compress_inner(input, length);
return stb__out - out;
}
int stb_compress_tofile(char *filename, char *input, unsigned int length)
{
//int maxlen = length + 512 + (length >> 2); // total guess
//char *buffer = (char *) malloc(maxlen);
//int blen = stb_compress((stb_uchar*)buffer, (stb_uchar*)input, length);
stb__out = NULL;
stb__outfile = fopen(filename, "wb");
if (!stb__outfile) return 0;
stb__outbytes = 0;
if (!stb_compress_inner((stb_uchar*)input, length))
return 0;
fclose(stb__outfile);
return stb__outbytes;
}
int stb_compress_intofile(FILE *f, char *input, unsigned int length)
{
//int maxlen = length + 512 + (length >> 2); // total guess
//char *buffer = (char*)malloc(maxlen);
//int blen = stb_compress((stb_uchar*)buffer, (stb_uchar*)input, length);
stb__out = NULL;
stb__outfile = f;
if (!stb__outfile) return 0;
stb__outbytes = 0;
if (!stb_compress_inner((stb_uchar*)input, length))
return 0;
return stb__outbytes;
}
////////////////////// streaming I/O version /////////////////////
static size_t stb_out_backpatch_id(void)
{
if (stb__out)
return (size_t) stb__out;
else
return ftell(stb__outfile);
}
static void stb_out_backpatch(size_t id, stb_uint value)
{
stb_uchar data[4] = { value >> 24, value >> 16, value >> 8, value };
if (stb__out) {
memcpy((void *) id, data, 4);
} else {
stb_uint where = ftell(stb__outfile);
fseek(stb__outfile, id, SEEK_SET);
fwrite(data, 4, 1, stb__outfile);
fseek(stb__outfile, where, SEEK_SET);
}
}
// ok, the wraparound buffer was a total failure. let's instead
// use a copying-in-place buffer, which lets us share the code.
// This is way less efficient but it'll do for now.
static struct
{
stb_uchar *buffer;
int size; // physical size of buffer in bytes
int valid; // amount of valid data in bytes
int start; // bytes of data already output
int window;
int fsize;
int pending_literals; // bytes not-quite output but counted in start
int length_id;
stb_uint total_bytes;
stb_uchar **chash;
stb_uint hashmask;
} xtb;
static int stb_compress_streaming_start(void)
{
stb_uint i;
xtb.size = stb__window * 3;
xtb.buffer = (stb_uchar*)malloc(xtb.size);
if (!xtb.buffer) return 0;
xtb.chash = (stb_uchar**)malloc(sizeof(*xtb.chash) * stb__hashsize);
if (!xtb.chash) {
free(xtb.buffer);
return 0;
}
for (i=0; i < stb__hashsize; ++i)
xtb.chash[i] = NULL;
xtb.hashmask = stb__hashsize-1;
xtb.valid = 0;
xtb.start = 0;
xtb.window = stb__window;
xtb.fsize = stb__window;
xtb.pending_literals = 0;
xtb.total_bytes = 0;
// stream signature
stb_out(0x57); stb_out(0xbc); stb_out2(0);
stb_out4(0); // 64-bit length requires 32-bit leading 0
xtb.length_id = stb_out_backpatch_id();
stb_out4(0); // we don't know the output length yet
stb_out4(stb__window);
stb__running_adler = 1;
return 1;
}
static int stb_compress_streaming_end(void)
{
// flush out any remaining data
stb_compress_chunk(xtb.buffer, xtb.buffer+xtb.start, xtb.buffer+xtb.valid,
xtb.valid-xtb.start, &xtb.pending_literals, xtb.chash, xtb.hashmask);
// write out pending literals
outliterals(xtb.buffer + xtb.valid - xtb.pending_literals, xtb.pending_literals);
stb_out2(0x05fa); // end opcode
stb_out4(stb__running_adler);
stb_out_backpatch(xtb.length_id, xtb.total_bytes);
free(xtb.buffer);
free(xtb.chash);
return 1;
}
void stb_write(char *data, int data_len)
{
stb_uint i;
// @TODO: fast path for filling the buffer and doing nothing else
// if (xtb.valid + data_len < xtb.size)
xtb.total_bytes += data_len;
while (data_len) {
// fill buffer
if (xtb.valid < xtb.size) {
int amt = xtb.size - xtb.valid;
if (data_len < amt) amt = data_len;
memcpy(xtb.buffer + xtb.valid, data, amt);
data_len -= amt;
data += amt;
xtb.valid += amt;
}
if (xtb.valid < xtb.size)
return;
// at this point, the buffer is full
// if we can process some data, go for it; make sure
// we leave an 'fsize's worth of data, though
if (xtb.start + xtb.fsize < xtb.valid) {
int amount = (xtb.valid - xtb.fsize) - xtb.start;
int n;
assert(amount > 0);
n = stb_compress_chunk(xtb.buffer, xtb.buffer + xtb.start, xtb.buffer + xtb.valid,
amount, &xtb.pending_literals, xtb.chash, xtb.hashmask);
xtb.start += n;
}
assert(xtb.start + xtb.fsize >= xtb.valid);
// at this point, our future size is too small, so we
// need to flush some history. we, in fact, flush exactly
// one window's worth of history
{
int flush = xtb.window;
assert(xtb.start >= flush);
assert(xtb.valid >= flush);
// if 'pending literals' extends back into the shift region,
// write them out
if (xtb.start - xtb.pending_literals < flush) {
outliterals(xtb.buffer + xtb.start - xtb.pending_literals, xtb.pending_literals);
xtb.pending_literals = 0;
}
// now shift the window
memmove(xtb.buffer, xtb.buffer + flush, xtb.valid - flush);
xtb.start -= flush;
xtb.valid -= flush;
for (i=0; i <= xtb.hashmask; ++i)
if (xtb.chash[i] < xtb.buffer + flush)
xtb.chash[i] = NULL;
else
xtb.chash[i] -= flush;
}
// and now that we've made room for more data, go back to the top
}
}
int stb_compress_stream_start(FILE *f)
{
stb__out = NULL;
stb__outfile = f;
if (f == NULL)
return 0;
if (!stb_compress_streaming_start())
return 0;
return 1;
}
void stb_compress_stream_end(int close)
{
stb_compress_streaming_end();
if (close && stb__outfile) {
fclose(stb__outfile);
}
}
#endif // STB_DEFINE
//////////////////////////////////////////////////////////////////////////////
//
// File abstraction... tired of not having this... we can write
// compressors to be layers over these that auto-close their children.
typedef struct stbfile
{
int (*getbyte)(struct stbfile *); // -1 on EOF
unsigned int (*getdata)(struct stbfile *, void *block, unsigned int len);
int (*putbyte)(struct stbfile *, int byte);
unsigned int (*putdata)(struct stbfile *, void *block, unsigned int len);
unsigned int (*size)(struct stbfile *);
unsigned int (*tell)(struct stbfile *);
void (*backpatch)(struct stbfile *, unsigned int tell, void *block, unsigned int len);
void (*close)(struct stbfile *);
FILE *f; // file to fread/fwrite
unsigned char *buffer; // input/output buffer
unsigned char *indata, *inend; // input buffer
union {
int various;
void *ptr;
};
} stbfile;
STB_EXTERN unsigned int stb_getc(stbfile *f); // read
STB_EXTERN int stb_putc(stbfile *f, int ch); // write
STB_EXTERN unsigned int stb_getdata(stbfile *f, void *buffer, unsigned int len); // read
STB_EXTERN unsigned int stb_putdata(stbfile *f, void *buffer, unsigned int len); // write
STB_EXTERN unsigned int stb_tell(stbfile *f); // read
STB_EXTERN unsigned int stb_size(stbfile *f); // read/write
STB_EXTERN void stb_backpatch(stbfile *f, unsigned int tell, void *buffer, unsigned int len); // write
#ifdef STB_DEFINE
unsigned int stb_getc(stbfile *f) { return f->getbyte(f); }
int stb_putc(stbfile *f, int ch) { return f->putbyte(f, ch); }
unsigned int stb_getdata(stbfile *f, void *buffer, unsigned int len)
{
return f->getdata(f, buffer, len);
}
unsigned int stb_putdata(stbfile *f, void *buffer, unsigned int len)
{
return f->putdata(f, buffer, len);
}
void stb_close(stbfile *f)
{
f->close(f);
free(f);
}
unsigned int stb_tell(stbfile *f) { return f->tell(f); }
unsigned int stb_size(stbfile *f) { return f->size(f); }
void stb_backpatch(stbfile *f, unsigned int tell, void *buffer, unsigned int len)
{
f->backpatch(f,tell,buffer,len);
}
// FILE * implementation
static int stb__fgetbyte(stbfile *f) { return fgetc(f->f); }
static int stb__fputbyte(stbfile *f, int ch) { return fputc(ch, f->f)==0; }
static unsigned int stb__fgetdata(stbfile *f, void *buffer, unsigned int len) { return fread(buffer,1,len,f->f); }
static unsigned int stb__fputdata(stbfile *f, void *buffer, unsigned int len) { return fwrite(buffer,1,len,f->f); }
static unsigned int stb__fsize(stbfile *f) { return stb_filelen(f->f); }
static unsigned int stb__ftell(stbfile *f) { return ftell(f->f); }
static void stb__fbackpatch(stbfile *f, unsigned int where, void *buffer, unsigned int len)
{
fseek(f->f, where, SEEK_SET);
fwrite(buffer, 1, len, f->f);
fseek(f->f, 0, SEEK_END);
}
static void stb__fclose(stbfile *f) { fclose(f->f); }
stbfile *stb_openf(FILE *f)
{
stbfile m = { stb__fgetbyte, stb__fgetdata,
stb__fputbyte, stb__fputdata,
stb__fsize, stb__ftell, stb__fbackpatch, stb__fclose,
0,0,0, };
stbfile *z = (stbfile *) malloc(sizeof(*z));
if (z) {
*z = m;
z->f = f;
}
return z;
}
static int stb__nogetbyte(stbfile *f) { assert(0); return -1; }
static unsigned int stb__nogetdata(stbfile *f, void *buffer, unsigned int len) { assert(0); return 0; }
static int stb__noputbyte(stbfile *f, int ch) { assert(0); return 0; }
static unsigned int stb__noputdata(stbfile *f, void *buffer, unsigned int len) { assert(0); return 0; }
static void stb__nobackpatch(stbfile *f, unsigned int where, void *buffer, unsigned int len) { assert(0); }
static int stb__bgetbyte(stbfile *s)
{
if (s->indata < s->inend)
return *s->indata++;
else
return -1;
}
static unsigned int stb__bgetdata(stbfile *s, void *buffer, unsigned int len)
{
if (s->indata + len > s->inend)
len = s->inend - s->indata;
memcpy(buffer, s->indata, len);
s->indata += len;
return len;
}
static unsigned int stb__bsize(stbfile *s) { return s->inend - s->buffer; }
static unsigned int stb__btell(stbfile *s) { return s->indata - s->buffer; }
static void stb__bclose(stbfile *s)
{
if (s->various)
free(s->buffer);
}
stbfile *stb_open_inbuffer(void *buffer, unsigned int len)
{
stbfile m = { stb__bgetbyte, stb__bgetdata,
stb__noputbyte, stb__noputdata,
stb__bsize, stb__btell, stb__nobackpatch, stb__bclose };
stbfile *z = (stbfile *) malloc(sizeof(*z));
if (z) {
*z = m;
z->buffer = (unsigned char *) buffer;
z->indata = z->buffer;
z->inend = z->indata + len;
}
return z;
}
stbfile *stb_open_inbuffer_free(void *buffer, unsigned int len)
{
stbfile *z = stb_open_inbuffer(buffer, len);
if (z)
z->various = 1; // free
return z;
}
#ifndef STB_VERSION
// if we've been cut-and-pasted elsewhere, you get a limited
// version of stb_open, without the 'k' flag and utf8 support
static void stb__fclose2(stbfile *f)
{
fclose(f->f);
}
stbfile *stb_open(char *filename, char *mode)
{
FILE *f = fopen(filename, mode);
stbfile *s;
if (f == NULL) return NULL;
s = stb_openf(f);
if (s)
s->close = stb__fclose2;
return s;
}
#else
// the full version depends on some code in stb.h; this
// also includes the memory buffer output format implemented with stb_arr
static void stb__fclose2(stbfile *f)
{
stb_fclose(f->f, f->various);
}
stbfile *stb_open(char *filename, char *mode)
{
FILE *f = stb_fopen(filename, mode[0] == 'k' ? mode+1 : mode);
stbfile *s;
if (f == NULL) return NULL;
s = stb_openf(f);
if (s) {
s->close = stb__fclose2;
s->various = mode[0] == 'k' ? stb_keep_if_different : stb_keep_yes;
}
return s;
}
static int stb__aputbyte(stbfile *f, int ch)
{
stb_arr_push(f->buffer, ch);
return 1;
}
static unsigned int stb__aputdata(stbfile *f, void *data, unsigned int len)
{
memcpy(stb_arr_addn(f->buffer, (int) len), data, len);
return len;
}
static unsigned int stb__asize(stbfile *f) { return stb_arr_len(f->buffer); }
static void stb__abackpatch(stbfile *f, unsigned int where, void *data, unsigned int len)
{
memcpy(f->buffer+where, data, len);
}
static void stb__aclose(stbfile *f)
{
*(unsigned char **) f->ptr = f->buffer;
}
stbfile *stb_open_outbuffer(unsigned char **update_on_close)
{
stbfile m = { stb__nogetbyte, stb__nogetdata,
stb__aputbyte, stb__aputdata,
stb__asize, stb__asize, stb__abackpatch, stb__aclose };
stbfile *z = (stbfile *) malloc(sizeof(*z));
if (z) {
z->ptr = update_on_close;
*z = m;
}
return z;
}
#endif
#endif
//////////////////////////////////////////////////////////////////////////////
//
// Arithmetic coder... based on cbloom's notes on the subject, should be
// less code than a huffman code.
typedef struct
{
unsigned int range_low;
unsigned int range_high;
unsigned int code, range; // decode
int buffered_u8;
int pending_ffs;
stbfile *output;
} stb_arith;
STB_EXTERN void stb_arith_init_encode(stb_arith *a, stbfile *out);
STB_EXTERN void stb_arith_init_decode(stb_arith *a, stbfile *in);
STB_EXTERN stbfile *stb_arith_encode_close(stb_arith *a);
STB_EXTERN stbfile *stb_arith_decode_close(stb_arith *a);
STB_EXTERN void stb_arith_encode(stb_arith *a, unsigned int totalfreq, unsigned int freq, unsigned int cumfreq);
STB_EXTERN void stb_arith_encode_log2(stb_arith *a, unsigned int totalfreq2, unsigned int freq, unsigned int cumfreq);
STB_EXTERN unsigned int stb_arith_decode_value(stb_arith *a, unsigned int totalfreq);
STB_EXTERN void stb_arith_decode_advance(stb_arith *a, unsigned int totalfreq, unsigned int freq, unsigned int cumfreq);
STB_EXTERN unsigned int stb_arith_decode_value_log2(stb_arith *a, unsigned int totalfreq2);
STB_EXTERN void stb_arith_decode_advance_log2(stb_arith *a, unsigned int totalfreq2, unsigned int freq, unsigned int cumfreq);
STB_EXTERN void stb_arith_encode_byte(stb_arith *a, int byte);
STB_EXTERN int stb_arith_decode_byte(stb_arith *a);
// this is a memory-inefficient way of doing things, but it's
// fast(?) and simple
typedef struct
{
unsigned short cumfreq;
unsigned short samples;
} stb_arith_symstate_item;
typedef struct
{
int num_sym;
unsigned int pow2;
int countdown;
stb_arith_symstate_item data[1];
} stb_arith_symstate;
#ifdef STB_DEFINE
void stb_arith_init_encode(stb_arith *a, stbfile *out)
{
a->range_low = 0;
a->range_high = 0xffffffff;
a->pending_ffs = -1; // means no buffered character currently, to speed up normal case
a->output = out;
}
static void stb__arith_carry(stb_arith *a)
{
int i;
assert(a->pending_ffs != -1); // can't carry with no data
stb_putc(a->output, a->buffered_u8);
for (i=0; i < a->pending_ffs; ++i)
stb_putc(a->output, 0);
}
static void stb__arith_putbyte(stb_arith *a, int byte)
{
if (a->pending_ffs) {
if (a->pending_ffs == -1) { // means no buffered data; encoded for fast path efficiency
if (byte == 0xff)
stb_putc(a->output, byte); // just write it immediately
else {
a->buffered_u8 = byte;
a->pending_ffs = 0;
}
} else if (byte == 0xff) {
++a->pending_ffs;
} else {
int i;
stb_putc(a->output, a->buffered_u8);
for (i=0; i < a->pending_ffs; ++i)
stb_putc(a->output, 0xff);
}
} else if (byte == 0xff) {
++a->pending_ffs;
} else {
// fast path
stb_putc(a->output, a->buffered_u8);
a->buffered_u8 = byte;
}
}
static void stb__arith_flush(stb_arith *a)
{
if (a->pending_ffs >= 0) {
int i;
stb_putc(a->output, a->buffered_u8);
for (i=0; i < a->pending_ffs; ++i)
stb_putc(a->output, 0xff);
}
}
static void stb__renorm_encoder(stb_arith *a)
{
stb__arith_putbyte(a, a->range_low >> 24);
a->range_low <<= 8;
a->range_high = (a->range_high << 8) | 0xff;
}
static void stb__renorm_decoder(stb_arith *a)
{
int c = stb_getc(a->output);
a->code = (a->code << 8) + (c >= 0 ? c : 0); // if EOF, insert 0
}
void stb_arith_encode(stb_arith *a, unsigned int totalfreq, unsigned int freq, unsigned int cumfreq)
{
unsigned int range = a->range_high - a->range_low;
unsigned int old = a->range_low;
range /= totalfreq;
a->range_low += range * cumfreq;
a->range_high = a->range_low + range*freq;
if (a->range_low < old)
stb__arith_carry(a);
while (a->range_high - a->range_low < 0x1000000)
stb__renorm_encoder(a);
}
void stb_arith_encode_log2(stb_arith *a, unsigned int totalfreq2, unsigned int freq, unsigned int cumfreq)
{
unsigned int range = a->range_high - a->range_low;
unsigned int old = a->range_low;
range >>= totalfreq2;
a->range_low += range * cumfreq;
a->range_high = a->range_low + range*freq;
if (a->range_low < old)
stb__arith_carry(a);
while (a->range_high - a->range_low < 0x1000000)
stb__renorm_encoder(a);
}
unsigned int stb_arith_decode_value(stb_arith *a, unsigned int totalfreq)
{
unsigned int freqsize = a->range / totalfreq;
unsigned int z = a->code / freqsize;
return z >= totalfreq ? totalfreq-1 : z;
}
void stb_arith_decode_advance(stb_arith *a, unsigned int totalfreq, unsigned int freq, unsigned int cumfreq)
{
unsigned int freqsize = a->range / totalfreq; // @OPTIMIZE, share with above divide somehow?
a->code -= freqsize * cumfreq;
a->range = freqsize * freq;
while (a->range < 0x1000000)
stb__renorm_decoder(a);
}
unsigned int stb_arith_decode_value_log2(stb_arith *a, unsigned int totalfreq2)
{
unsigned int freqsize = a->range >> totalfreq2;
unsigned int z = a->code / freqsize;
return z >= (1U<<totalfreq2) ? (1U<<totalfreq2)-1 : z;
}
void stb_arith_decode_advance_log2(stb_arith *a, unsigned int totalfreq2, unsigned int freq, unsigned int cumfreq)
{
unsigned int freqsize = a->range >> totalfreq2;
a->code -= freqsize * cumfreq;
a->range = freqsize * freq;
while (a->range < 0x1000000)
stb__renorm_decoder(a);
}
stbfile *stb_arith_encode_close(stb_arith *a)
{
// put exactly as many bytes as we'll read, so we can turn on/off arithmetic coding in a stream
stb__arith_putbyte(a, a->range_low >> 24);
stb__arith_putbyte(a, a->range_low >> 16);
stb__arith_putbyte(a, a->range_low >> 8);
stb__arith_putbyte(a, a->range_low >> 0);
stb__arith_flush(a);
return a->output;
}
stbfile *stb_arith_decode_close(stb_arith *a)
{
return a->output;
}
// this is a simple power-of-two based model -- using
// power of two means we need one divide per decode,
// not two.
#define POW2_LIMIT 12
stb_arith_symstate *stb_arith_state_create(int num_sym)
{
stb_arith_symstate *s = (stb_arith_symstate *) malloc(sizeof(*s) + (num_sym-1) * sizeof(s->data[0]));
if (s) {
int i, cf, cf_next, next;
int start_freq, extra;
s->num_sym = num_sym;
s->pow2 = 4;
while (s->pow2 < 15 && (1 << s->pow2) < 3*num_sym) {
++s->pow2;
}
start_freq = (1 << s->pow2) / num_sym;
assert(start_freq >= 1);
extra = (1 << s->pow2) % num_sym;
// now set up the initial stats
if (s->pow2 < POW2_LIMIT)
next = 0;
else
next = 1;
cf = cf_next = 0;
for (i=0; i < extra; ++i) {
s->data[i].cumfreq = cf;
s->data[i].samples = next;
cf += start_freq+1;
cf_next += next;
}
for (; i < num_sym; ++i) {
s->data[i].cumfreq = cf;
s->data[i].samples = next;
cf += start_freq;
cf_next += next;
}
assert(cf == (1 << s->pow2));
// now, how long should we go until we have 2 << s->pow2 samples?
s->countdown = (2 << s->pow2) - cf - cf_next;
}
return s;
}
static void stb_arith_state_rescale(stb_arith_symstate *s)
{
if (s->pow2 < POW2_LIMIT) {
int pcf, cf, cf_next, next, i;
++s->pow2;
if (s->pow2 < POW2_LIMIT)
next = 0;
else
next = 1;
cf = cf_next = 0;
pcf = 0;
for (i=0; i < s->num_sym; ++i) {
int sample = s->data[i].cumfreq - pcf + s->data[i].samples;
s->data[i].cumfreq = cf;
cf += sample;
s->data[i].samples = next;
cf_next += next;
}
assert(cf == (1 << s->pow2));
s->countdown = (2 << s->pow2) - cf - cf_next;
} else {
int pcf, cf, cf_next, i;
cf = cf_next = 0;
pcf = 0;
for (i=0; i < s->num_sym; ++i) {
int sample = (s->data[i].cumfreq - pcf + s->data[i].samples) >> 1;
s->data[i].cumfreq = cf;
cf += sample;
s->data[i].samples = 1;
cf_next += 1;
}
assert(cf == (1 << s->pow2)); // this isn't necessarily true, due to rounding down!
s->countdown = (2 << s->pow2) - cf - cf_next;
}
}
void stb_arith_encode_byte(stb_arith *a, int byte)
{
}
int stb_arith_decode_byte(stb_arith *a)
{
return -1;
}
#endif
//////////////////////////////////////////////////////////////////////////////
//
// Threads
//
#ifndef _WIN32
#ifdef STB_THREADS
#error "threads not implemented except for Windows"
#endif
#endif
// call this function to free any global variables for memory testing
STB_EXTERN void stb_thread_cleanup(void);
typedef void * (*stb_thread_func)(void *);
// do not rely on these types, this is an implementation detail.
// compare against STB_THREAD_NULL and ST_SEMAPHORE_NULL
typedef void *stb_thread;
typedef void *stb_semaphore;
typedef void *stb_mutex;
typedef struct stb__sync *stb_sync;
#define STB_SEMAPHORE_NULL NULL
#define STB_THREAD_NULL NULL
#define STB_MUTEX_NULL NULL
#define STB_SYNC_NULL NULL
// get the number of processors (limited to those in the affinity mask for this process).
STB_EXTERN int stb_processor_count(void);
// force to run on a single core -- needed for RDTSC to work, e.g. for iprof
STB_EXTERN void stb_force_uniprocessor(void);
// stb_work functions: queue up work to be done by some worker threads
// set number of threads to serve the queue; you can change this on the fly,
// but if you decrease it, it won't decrease until things currently on the
// queue are finished
STB_EXTERN void stb_work_numthreads(int n);
// set maximum number of units in the queue; you can only set this BEFORE running any work functions
STB_EXTERN int stb_work_maxunits(int n);
// enqueue some work to be done (can do this from any thread, or even from a piece of work);
// return value of f is stored in *return_code if non-NULL
STB_EXTERN int stb_work(stb_thread_func f, void *d, volatile void **return_code);
// as above, but stb_sync_reach is called on 'rel' after work is complete
STB_EXTERN int stb_work_reach(stb_thread_func f, void *d, volatile void **return_code, stb_sync rel);
// necessary to call this when using volatile to order writes/reads
STB_EXTERN void stb_barrier(void);
// support for independent queues with their own threads
typedef struct stb__workqueue stb_workqueue;
STB_EXTERN stb_workqueue*stb_workq_new(int numthreads, int max_units);
STB_EXTERN stb_workqueue*stb_workq_new_flags(int numthreads, int max_units, int no_add_mutex, int no_remove_mutex);
STB_EXTERN void stb_workq_delete(stb_workqueue *q);
STB_EXTERN void stb_workq_numthreads(stb_workqueue *q, int n);
STB_EXTERN int stb_workq(stb_workqueue *q, stb_thread_func f, void *d, volatile void **return_code);
STB_EXTERN int stb_workq_reach(stb_workqueue *q, stb_thread_func f, void *d, volatile void **return_code, stb_sync rel);
STB_EXTERN int stb_workq_length(stb_workqueue *q);
STB_EXTERN stb_thread stb_create_thread (stb_thread_func f, void *d);
STB_EXTERN stb_thread stb_create_thread2(stb_thread_func f, void *d, volatile void **return_code, stb_semaphore rel);
STB_EXTERN void stb_destroy_thread(stb_thread t);
STB_EXTERN stb_semaphore stb_sem_new(int max_val);
STB_EXTERN stb_semaphore stb_sem_new_extra(int max_val, int start_val);
STB_EXTERN void stb_sem_delete (stb_semaphore s);
STB_EXTERN void stb_sem_waitfor(stb_semaphore s);
STB_EXTERN void stb_sem_release(stb_semaphore s);
STB_EXTERN stb_mutex stb_mutex_new(void);
STB_EXTERN void stb_mutex_delete(stb_mutex m);
STB_EXTERN void stb_mutex_begin(stb_mutex m);
STB_EXTERN void stb_mutex_end(stb_mutex m);
STB_EXTERN stb_sync stb_sync_new(void);
STB_EXTERN void stb_sync_delete(stb_sync s);
STB_EXTERN int stb_sync_set_target(stb_sync s, int count);
STB_EXTERN void stb_sync_reach_and_wait(stb_sync s); // wait for 'target' reachers
STB_EXTERN int stb_sync_reach(stb_sync s);
typedef struct stb__threadqueue stb_threadqueue;
#define STB_THREADQ_DYNAMIC 0
STB_EXTERN stb_threadqueue *stb_threadq_new(int item_size, int num_items, int many_add, int many_remove);
STB_EXTERN void stb_threadq_delete(stb_threadqueue *tq);
STB_EXTERN int stb_threadq_get(stb_threadqueue *tq, void *output);
STB_EXTERN void stb_threadq_get_block(stb_threadqueue *tq, void *output);
STB_EXTERN int stb_threadq_add(stb_threadqueue *tq, void *input);
// can return FALSE if STB_THREADQ_DYNAMIC and attempt to grow fails
STB_EXTERN int stb_threadq_add_block(stb_threadqueue *tq, void *input);
#ifdef STB_THREADS
#ifdef STB_DEFINE
typedef struct
{
stb_thread_func f;
void *d;
volatile void **return_val;
stb_semaphore sem;
} stb__thread;
// this is initialized along all possible paths to create threads, therefore
// it's always initialized before any other threads are create, therefore
// it's free of races AS LONG AS you only create threads through stb_*
static stb_mutex stb__threadmutex, stb__workmutex;
static void stb__threadmutex_init(void)
{
if (stb__threadmutex == STB_SEMAPHORE_NULL) {
stb__threadmutex = stb_mutex_new();
stb__workmutex = stb_mutex_new();
}
}
#ifdef STB_THREAD_TEST
volatile float stb__t1=1, stb__t2;
static void stb__wait(int n)
{
float z = 0;
int i;
for (i=0; i < n; ++i)
z += 1 / (stb__t1+i);
stb__t2 = z;
}
#else
#define stb__wait(x)
#endif
#ifdef _WIN32
// avoid including windows.h -- note that our definitions aren't
// exactly the same (we don't define the security descriptor struct)
// so if you want to include windows.h, make sure you do it first.
#include <process.h>
#ifndef _WINDOWS_ // check windows.h guard
#define STB__IMPORT STB_EXTERN __declspec(dllimport)
#define STB__DW unsigned long
STB__IMPORT int __stdcall TerminateThread(void *, STB__DW);
STB__IMPORT void * __stdcall CreateSemaphoreA(void *sec, long,long,char*);
STB__IMPORT int __stdcall CloseHandle(void *);
STB__IMPORT STB__DW __stdcall WaitForSingleObject(void *, STB__DW);
STB__IMPORT int __stdcall ReleaseSemaphore(void *, long, long *);
STB__IMPORT void __stdcall Sleep(STB__DW);
#endif
// necessary to call this when using volatile to order writes/reads
void stb_barrier(void)
{
#ifdef MemoryBarrier
MemoryBarrier();
#else
long temp;
__asm xchg temp,eax;
#endif
}
static void stb__thread_run(void *t)
{
void *res;
stb__thread info = * (stb__thread *) t;
free(t);
res = info.f(info.d);
if (info.return_val)
*info.return_val = res;
if (info.sem != STB_SEMAPHORE_NULL)
stb_sem_release(info.sem);
}
static stb_thread stb_create_thread_raw(stb_thread_func f, void *d, volatile void **return_code, stb_semaphore rel)
{
#ifdef _MT
#if defined(STB_FASTMALLOC) && !defined(STB_FASTMALLOC_ITS_OKAY_I_ONLY_MALLOC_IN_ONE_THREAD)
stb_fatal("Error! Cannot use STB_FASTMALLOC with threads.\n");
return STB_THREAD_NULL;
#else
unsigned long id;
stb__thread *data = (stb__thread *) malloc(sizeof(*data));
if (!data) return NULL;
stb__threadmutex_init();
data->f = f;
data->d = d;
data->return_val = return_code;
data->sem = rel;
id = _beginthread(stb__thread_run, 0, data);
if (id == -1) return NULL;
return (void *) id;
#endif
#else
#ifdef STB_NO_STB_STRINGS
stb_fatal("Invalid compilation");
#else
stb_fatal("Must compile mult-threaded to use stb_thread/stb_work.");
#endif
return NULL;
#endif
}
// trivial win32 wrappers
void stb_destroy_thread(stb_thread t) { TerminateThread(t,0); }
stb_semaphore stb_sem_new(int maxv) {return CreateSemaphoreA(NULL,0,maxv,NULL); }
stb_semaphore stb_sem_new_extra(int maxv,int start){return CreateSemaphoreA(NULL,start,maxv,NULL); }
void stb_sem_delete(stb_semaphore s) { if (s != NULL) CloseHandle(s); }
void stb_sem_waitfor(stb_semaphore s) { WaitForSingleObject(s, 0xffffffff); } // INFINITE
void stb_sem_release(stb_semaphore s) { ReleaseSemaphore(s,1,NULL); }
static void stb__thread_sleep(int ms) { Sleep(ms); }
#ifndef _WINDOWS_
STB__IMPORT int __stdcall GetProcessAffinityMask(void *, STB__DW *, STB__DW *);
STB__IMPORT void * __stdcall GetCurrentProcess(void);
STB__IMPORT int __stdcall SetProcessAffinityMask(void *, STB__DW);
#endif
int stb_processor_count(void)
{
unsigned long proc,sys;
GetProcessAffinityMask(GetCurrentProcess(), &proc, &sys);
return stb_bitcount(proc);
}
void stb_force_uniprocessor(void)
{
unsigned long proc,sys;
GetProcessAffinityMask(GetCurrentProcess(), &proc, &sys);
if (stb_bitcount(proc) > 1) {
int z;
for (z=0; z < 32; ++z)
if (proc & (1 << z))
break;
if (z < 32) {
proc = 1 << z;
SetProcessAffinityMask(GetCurrentProcess(), proc);
}
}
}
#ifdef _WINDOWS_
#define STB_MUTEX_NATIVE
void *stb_mutex_new(void)
{
CRITICAL_SECTION *p = (CRITICAL_SECTION *) malloc(sizeof(*p));
if (p)
#if _WIN32_WINNT >= 0x0500
InitializeCriticalSectionAndSpinCount(p, 500);
#else
InitializeCriticalSection(p);
#endif
return p;
}
void stb_mutex_delete(void *p)
{
if (p) {
DeleteCriticalSection((CRITICAL_SECTION *) p);
free(p);
}
}
void stb_mutex_begin(void *p)
{
stb__wait(500);
if (p)
EnterCriticalSection((CRITICAL_SECTION *) p);
}
void stb_mutex_end(void *p)
{
if (p)
LeaveCriticalSection((CRITICAL_SECTION *) p);
stb__wait(500);
}
#endif // _WINDOWS_
#if 0
// for future reference,
// InterlockedCompareExchange for x86:
int cas64_mp(void * dest, void * xcmp, void * xxchg) {
__asm
{
mov esi, [xxchg] ; exchange
mov ebx, [esi + 0]
mov ecx, [esi + 4]
mov esi, [xcmp] ; comparand
mov eax, [esi + 0]
mov edx, [esi + 4]
mov edi, [dest] ; destination
lock cmpxchg8b [edi]
jz yyyy;
mov [esi + 0], eax;
mov [esi + 4], edx;
yyyy:
xor eax, eax;
setz al;
};
inline unsigned __int64 _InterlockedCompareExchange64(volatile unsigned __int64 *dest
,unsigned __int64 exchange
,unsigned __int64 comperand)
{
//value returned in eax::edx
__asm {
lea esi,comperand;
lea edi,exchange;
mov eax,[esi];
mov edx,4[esi];
mov ebx,[edi];
mov ecx,4[edi];
mov esi,dest;
lock CMPXCHG8B [esi];
}
#endif // #if 0
#endif // _WIN32
stb_thread stb_create_thread2(stb_thread_func f, void *d, volatile void **return_code, stb_semaphore rel)
{
return stb_create_thread_raw(f,d,return_code,rel);
}
stb_thread stb_create_thread(stb_thread_func f, void *d)
{
return stb_create_thread2(f,d,NULL,STB_SEMAPHORE_NULL);
}
// mutex implemented by wrapping semaphore
#ifndef STB_MUTEX_NATIVE
stb_mutex stb_mutex_new(void) { return stb_sem_new_extra(1,1); }
void stb_mutex_delete(stb_mutex m) { stb_sem_delete (m); }
void stb_mutex_begin(stb_mutex m) { stb__wait(500); if (m) stb_sem_waitfor(m); }
void stb_mutex_end(stb_mutex m) { if (m) stb_sem_release(m); stb__wait(500); }
#endif
// thread merge operation
struct stb__sync
{
int target; // target number of threads to hit it
int sofar; // total threads that hit it
int waiting; // total threads waiting
stb_mutex start; // mutex to prevent starting again before finishing previous
stb_mutex mutex; // mutex while tweaking state
stb_semaphore release; // semaphore wake up waiting threads
// we have to wake them up one at a time, rather than using a single release
// call, because win32 semaphores don't let you dynamically change the max count!
};
stb_sync stb_sync_new(void)
{
stb_sync s = (stb_sync) malloc(sizeof(*s));
if (!s) return s;
s->target = s->sofar = s->waiting = 0;
s->mutex = stb_mutex_new();
s->start = stb_mutex_new();
s->release = stb_sem_new(1);
if (s->mutex == STB_MUTEX_NULL || s->release == STB_SEMAPHORE_NULL || s->start == STB_MUTEX_NULL) {
stb_mutex_delete(s->mutex);
stb_mutex_delete(s->mutex);
stb_sem_delete(s->release);
free(s);
return NULL;
}
return s;
}
void stb_sync_delete(stb_sync s)
{
if (s->waiting) {
// it's bad to delete while there are threads waiting!
// shall we wait for them to reach, or just bail? just bail
assert(0);
}
stb_mutex_delete(s->mutex);
stb_mutex_delete(s->release);
free(s);
}
int stb_sync_set_target(stb_sync s, int count)
{
// don't allow setting a target until the last one is fully released;
// note that this can lead to inefficient pipelining, and maybe we'd
// be better off ping-ponging between two internal syncs?
// I tried seeing how often this happened using TryEnterCriticalSection
// and could _never_ get it to happen in imv(stb), even with more threads
// than processors. So who knows!
stb_mutex_begin(s->start);
// this mutex is pointless, since it's not valid for threads
// to call reach() before anyone calls set_target() anyway
stb_mutex_begin(s->mutex);
assert(s->target == 0); // enforced by start mutex
s->target = count;
s->sofar = 0;
s->waiting = 0;
stb_mutex_end(s->mutex);
return STB_TRUE;
}
void stb__sync_release(stb_sync s)
{
if (s->waiting)
stb_sem_release(s->release);
else {
s->target = 0;
stb_mutex_end(s->start);
}
}
int stb_sync_reach(stb_sync s)
{
int n;
stb_mutex_begin(s->mutex);
assert(s->sofar < s->target);
n = ++s->sofar; // record this value to avoid possible race if we did 'return s->sofar';
if (s->sofar == s->target)
stb__sync_release(s);
stb_mutex_end(s->mutex);
return n;
}
void stb_sync_reach_and_wait(stb_sync s)
{
stb_mutex_begin(s->mutex);
assert(s->sofar < s->target);
++s->sofar;
if (s->sofar == s->target) {
stb__sync_release(s);
stb_mutex_end(s->mutex);
} else {
++s->waiting; // we're waiting, so one more waiter
stb_mutex_end(s->mutex); // release the mutex to other threads
stb_sem_waitfor(s->release); // wait for merge completion
stb_mutex_begin(s->mutex); // on merge completion, grab the mutex
--s->waiting; // we're done waiting
stb__sync_release(s); // restart the next waiter
stb_mutex_end(s->mutex); // and now we're done
// this ends the same as the first case, but it's a lot
// clearer to understand without sharing the code
}
}
struct stb__threadqueue
{
stb_mutex add, remove;
stb_semaphore nonempty, nonfull;
int head_blockers; // number of threads blocking--used to know whether to release(avail)
int tail_blockers;
int head, tail, array_size, growable;
int item_size;
char *data;
};
static int stb__tq_wrap(volatile stb_threadqueue *z, int p)
{
if (p == z->array_size)
return p - z->array_size;
else
return p;
}
int stb__threadq_get_raw(stb_threadqueue *tq2, void *output, int block)
{
volatile stb_threadqueue *tq = (volatile stb_threadqueue *) tq2;
if (tq->head == tq->tail && !block) return 0;
stb_mutex_begin(tq->remove);
while (tq->head == tq->tail) {
if (!block) {
stb_mutex_end(tq->remove);
return 0;
}
++tq->head_blockers;
stb_mutex_end(tq->remove);
stb_sem_waitfor(tq->nonempty);
stb_mutex_begin(tq->remove);
--tq->head_blockers;
}
memcpy(output, tq->data + tq->head*tq->item_size, tq->item_size);
stb_barrier();
tq->head = stb__tq_wrap(tq, tq->head+1);
stb_sem_release(tq->nonfull);
if (tq->head_blockers) // can't check if actually non-empty due to race?
stb_sem_release(tq->nonempty); // if there are other blockers, wake one
stb_mutex_end(tq->remove);
return STB_TRUE;
}
int stb__threadq_grow(volatile stb_threadqueue *tq)
{
int n;
char *p;
assert(tq->remove != STB_MUTEX_NULL); // must have this to allow growth!
stb_mutex_begin(tq->remove);
n = tq->array_size * 2;
p = (char *) realloc(tq->data, n * tq->item_size);
if (p == NULL) {
stb_mutex_end(tq->remove);
stb_mutex_end(tq->add);
return STB_FALSE;
}
if (tq->tail < tq->head) {
memcpy(p + tq->array_size * tq->item_size, p, tq->tail * tq->item_size);
tq->tail += tq->array_size;
}
tq->data = p;
tq->array_size = n;
stb_mutex_end(tq->remove);
return STB_TRUE;
}
int stb__threadq_add_raw(stb_threadqueue *tq2, void *input, int block)
{
int tail,pos;
volatile stb_threadqueue *tq = (volatile stb_threadqueue *) tq2;
stb_mutex_begin(tq->add);
for(;;) {
pos = tq->tail;
tail = stb__tq_wrap(tq, pos+1);
if (tail != tq->head) break;
// full
if (tq->growable) {
if (!stb__threadq_grow(tq)) {
stb_mutex_end(tq->add);
return STB_FALSE; // out of memory
}
} else if (!block) {
stb_mutex_end(tq->add);
return STB_FALSE;
} else {
++tq->tail_blockers;
stb_mutex_end(tq->add);
stb_sem_waitfor(tq->nonfull);
stb_mutex_begin(tq->add);
--tq->tail_blockers;
}
}
memcpy(tq->data + tq->item_size * pos, input, tq->item_size);
stb_barrier();
tq->tail = tail;
stb_sem_release(tq->nonempty);
if (tq->tail_blockers) // can't check if actually non-full due to race?
stb_sem_release(tq->nonfull);
stb_mutex_end(tq->add);
return STB_TRUE;
}
int stb_threadq_length(stb_threadqueue *tq2)
{
int a,b,n;
volatile stb_threadqueue *tq = (volatile stb_threadqueue *) tq2;
stb_mutex_begin(tq->add);
a = tq->head;
b = tq->tail;
n = tq->array_size;
stb_mutex_end(tq->add);
if (a > b) b += n;
return b-a;
}
int stb_threadq_get(stb_threadqueue *tq, void *output)
{
return stb__threadq_get_raw(tq, output, STB_FALSE);
}
void stb_threadq_get_block(stb_threadqueue *tq, void *output)
{
stb__threadq_get_raw(tq, output, STB_TRUE);
}
int stb_threadq_add(stb_threadqueue *tq, void *input)
{
return stb__threadq_add_raw(tq, input, STB_FALSE);
}
int stb_threadq_add_block(stb_threadqueue *tq, void *input)
{
return stb__threadq_add_raw(tq, input, STB_TRUE);
}
void stb_threadq_delete(stb_threadqueue *tq)
{
if (tq) {
free(tq->data);
stb_mutex_delete(tq->add);
stb_mutex_delete(tq->remove);
stb_sem_delete(tq->nonempty);
stb_sem_delete(tq->nonfull);
free(tq);
}
}
#define STB_THREADQUEUE_DYNAMIC 0
stb_threadqueue *stb_threadq_new(int item_size, int num_items, int many_add, int many_remove)
{
int error=0;
stb_threadqueue *tq = (stb_threadqueue *) malloc(sizeof(*tq));
if (tq == NULL) return NULL;
if (num_items == STB_THREADQUEUE_DYNAMIC) {
tq->growable = STB_TRUE;
num_items = 32;
} else
tq->growable = STB_FALSE;
tq->item_size = item_size;
tq->array_size = num_items+1;
tq->add = tq->remove = STB_MUTEX_NULL;
tq->nonempty = tq->nonfull = STB_SEMAPHORE_NULL;
tq->data = NULL;
if (many_add)
{ tq->add = stb_mutex_new(); if (tq->add == STB_MUTEX_NULL) goto error; }
if (many_remove || tq->growable)
{ tq->remove = stb_mutex_new(); if (tq->remove == STB_MUTEX_NULL) goto error; }
tq->nonempty = stb_sem_new(1); if (tq->nonempty == STB_SEMAPHORE_NULL) goto error;
tq->nonfull = stb_sem_new(1); if (tq->nonfull == STB_SEMAPHORE_NULL) goto error;
tq->data = (char *) malloc(tq->item_size * tq->array_size);
if (tq->data == NULL) goto error;
tq->head = tq->tail = 0;
tq->head_blockers = tq->tail_blockers = 0;
return tq;
error:
stb_threadq_delete(tq);
return NULL;
}
typedef struct
{
stb_thread_func f;
void *d;
volatile void **retval;
stb_sync sync;
} stb__workinfo;
//static volatile stb__workinfo *stb__work;
struct stb__workqueue
{
int numthreads;
stb_threadqueue *tq;
};
static stb_workqueue *stb__work_global;
static void *stb__thread_workloop(void *p)
{
volatile stb_workqueue *q = (volatile stb_workqueue *) p;
for(;;) {
void *z;
stb__workinfo w;
stb_threadq_get_block(q->tq, &w);
if (w.f == NULL) // null work is a signal to end the thread
return NULL;
z = w.f(w.d);
if (w.retval) { stb_barrier(); *w.retval = z; }
if (w.sync != STB_SYNC_NULL) stb_sync_reach(w.sync);
}
}
stb_workqueue *stb_workq_new(int num_threads, int max_units)
{
return stb_workq_new_flags(num_threads, max_units, 0,0);
}
stb_workqueue *stb_workq_new_flags(int numthreads, int max_units, int no_add_mutex, int no_remove_mutex)
{
stb_workqueue *q = (stb_workqueue *) malloc(sizeof(*q));
if (q == NULL) return NULL;
q->tq = stb_threadq_new(sizeof(stb__workinfo), max_units, !no_add_mutex, !no_remove_mutex);
if (q->tq == NULL) { free(q); return NULL; }
q->numthreads = 0;
stb_workq_numthreads(q, numthreads);
return q;
}
void stb_workq_delete(stb_workqueue *q)
{
while (stb_workq_length(q) != 0)
stb__thread_sleep(1);
stb_threadq_delete(q->tq);
free(q);
}
static int stb__work_maxitems = STB_THREADQUEUE_DYNAMIC;
static void stb_work_init(int num_threads)
{
if (stb__work_global == NULL) {
stb__threadmutex_init();
stb_mutex_begin(stb__workmutex);
stb_barrier();
if (*(stb_workqueue * volatile *) &stb__work_global == NULL)
stb__work_global = stb_workq_new(num_threads, stb__work_maxitems);
stb_mutex_end(stb__workmutex);
}
}
static int stb__work_raw(stb_workqueue *q, stb_thread_func f, void *d, volatile void **return_code, stb_sync rel)
{
stb__workinfo w;
if (q == NULL) {
stb_work_init(1);
q = stb__work_global;
}
w.f = f;
w.d = d;
w.retval = return_code;
w.sync = rel;
return stb_threadq_add(q->tq, &w);
}
int stb_workq_length(stb_workqueue *q)
{
return stb_threadq_length(q->tq);
}
int stb_workq(stb_workqueue *q, stb_thread_func f, void *d, volatile void **return_code)
{
if (f == NULL) return 0;
return stb_workq_reach(q, f, d, return_code, NULL);
}
int stb_workq_reach(stb_workqueue *q, stb_thread_func f, void *d, volatile void **return_code, stb_sync rel)
{
if (f == NULL) return 0;
return stb__work_raw(q, f, d, return_code, rel);
}
static void stb__workq_numthreads(stb_workqueue *q, int n)
{
while (q->numthreads < n) {
stb_create_thread(stb__thread_workloop, q);
++q->numthreads;
}
while (q->numthreads > n) {
stb__work_raw(q, NULL, NULL, NULL, NULL);
--q->numthreads;
}
}
void stb_workq_numthreads(stb_workqueue *q, int n)
{
stb_mutex_begin(stb__threadmutex);
stb__workq_numthreads(q,n);
stb_mutex_end(stb__threadmutex);
}
int stb_work_maxunits(int n)
{
if (stb__work_global == NULL) {
stb__work_maxitems = n;
stb_work_init(1);
}
return stb__work_maxitems;
}
int stb_work(stb_thread_func f, void *d, volatile void **return_code)
{
return stb_workq(stb__work_global, f,d,return_code);
}
int stb_work_reach(stb_thread_func f, void *d, volatile void **return_code, stb_sync rel)
{
return stb_workq_reach(stb__work_global, f,d,return_code,rel);
}
void stb_work_numthreads(int n)
{
if (stb__work_global == NULL)
stb_work_init(n);
else
stb_workq_numthreads(stb__work_global, n);
}
#endif // STB_DEFINE
//////////////////////////////////////////////////////////////////////////////
//
// Background disk I/O
//
//
#define STB_BGIO_READ_ALL (-1)
STB_EXTERN int stb_bgio_read (char *filename, int offset, int len, stb_uchar **result, int *olen);
STB_EXTERN int stb_bgio_readf (FILE *f , int offset, int len, stb_uchar **result, int *olen);
STB_EXTERN int stb_bgio_read_to (char *filename, int offset, int len, stb_uchar *buffer, int *olen);
STB_EXTERN int stb_bgio_readf_to(FILE *f , int offset, int len, stb_uchar *buffer, int *olen);
typedef struct
{
int have_data;
int is_valid;
int is_dir;
time_t filetime;
stb_int64 filesize;
} stb_bgstat;
STB_EXTERN int stb_bgio_stat (char *filename, stb_bgstat *result);
#ifdef STB_DEFINE
static stb_workqueue *stb__diskio;
static stb_mutex stb__diskio_mutex;
void stb_thread_cleanup(void)
{
if (stb__work_global) stb_workq_delete(stb__work_global); stb__work_global = NULL;
if (stb__threadmutex) stb_mutex_delete(stb__threadmutex); stb__threadmutex = NULL;
if (stb__workmutex) stb_mutex_delete(stb__workmutex); stb__workmutex = NULL;
if (stb__diskio) stb_workq_delete(stb__diskio); stb__diskio = NULL;
if (stb__diskio_mutex)stb_mutex_delete(stb__diskio_mutex);stb__diskio_mutex= NULL;
}
typedef struct
{
char *filename;
FILE *f;
int offset;
int len;
stb_bgstat *stat_out;
stb_uchar *output;
stb_uchar **result;
int *len_output;
int *flag;
} stb__disk_command;
#define STB__MAX_DISK_COMMAND 100
static stb__disk_command stb__dc_queue[STB__MAX_DISK_COMMAND];
static int stb__dc_offset;
void stb__io_init(void)
{
if (!stb__diskio) {
stb__threadmutex_init();
stb_mutex_begin(stb__threadmutex);
stb_barrier();
if (*(stb_thread * volatile *) &stb__diskio == NULL) {
stb__diskio_mutex = stb_mutex_new();
// use many threads so OS can try to schedule seeks
stb__diskio = stb_workq_new_flags(16,STB__MAX_DISK_COMMAND,STB_FALSE,STB_FALSE);
}
stb_mutex_end(stb__threadmutex);
}
}
static void * stb__io_error(stb__disk_command *dc)
{
if (dc->len_output) *dc->len_output = 0;
if (dc->result) *dc->result = NULL;
if (dc->flag) *dc->flag = -1;
return NULL;
}
static void * stb__io_task(void *p)
{
stb__disk_command *dc = (stb__disk_command *) p;
int len;
FILE *f;
stb_uchar *buf;
if (dc->stat_out) {
struct _stati64 s;
if (!_stati64(dc->filename, &s)) {
dc->stat_out->filesize = s.st_size;
dc->stat_out->filetime = s.st_mtime;
dc->stat_out->is_dir = s.st_mode & _S_IFDIR;
dc->stat_out->is_valid = (s.st_mode & _S_IFREG) || dc->stat_out->is_dir;
} else
dc->stat_out->is_valid = 0;
stb_barrier();
dc->stat_out->have_data = 1;
free(dc->filename);
return 0;
}
if (dc->f) {
#ifdef WIN32
f = _fdopen(_dup(_fileno(dc->f)), "rb");
#else
f = fdopen(dup(fileno(dc->f)), "rb");
#endif
if (!f)
return stb__io_error(dc);
} else {
f = fopen(dc->filename, "rb");
free(dc->filename);
if (!f)
return stb__io_error(dc);
}
len = dc->len;
if (len < 0) {
fseek(f, 0, SEEK_END);
len = ftell(f) - dc->offset;
}
if (fseek(f, dc->offset, SEEK_SET)) {
fclose(f);
return stb__io_error(dc);
}
if (dc->output)
buf = dc->output;
else {
buf = (stb_uchar *) malloc(len);
if (buf == NULL) {
fclose(f);
return stb__io_error(dc);
}
}
len = fread(buf, 1, len, f);
fclose(f);
if (dc->len_output) *dc->len_output = len;
if (dc->result) *dc->result = buf;
if (dc->flag) *dc->flag = 1;
return NULL;
}
int stb__io_add(char *fname, FILE *f, int off, int len, stb_uchar *out, stb_uchar **result, int *olen, int *flag, stb_bgstat *stat)
{
int res;
stb__io_init();
// do memory allocation outside of mutex
if (fname) fname = strdup(fname);
stb_mutex_begin(stb__diskio_mutex);
{
stb__disk_command *dc = &stb__dc_queue[stb__dc_offset];
dc->filename = fname;
dc->f = f;
dc->offset = off;
dc->len = len;
dc->output = out;
dc->result = result;
dc->len_output = olen;
dc->flag = flag;
dc->stat_out = stat;
res = stb_workq(stb__diskio, stb__io_task, dc, NULL);
if (res)
stb__dc_offset = (stb__dc_offset + 1 == STB__MAX_DISK_COMMAND ? 0 : stb__dc_offset+1);
}
stb_mutex_end(stb__diskio_mutex);
return res;
}
int stb_bgio_read(char *filename, int offset, int len, stb_uchar **result, int *olen)
{
return stb__io_add(filename,NULL,offset,len,NULL,result,olen,NULL,NULL);
}
int stb_bgio_readf(FILE *f, int offset, int len, stb_uchar **result, int *olen)
{
return stb__io_add(NULL,f,offset,len,NULL,result,olen,NULL,NULL);
}
int stb_bgio_read_to(char *filename, int offset, int len, stb_uchar *buffer, int *olen)
{
return stb__io_add(filename,NULL,offset,len,buffer,NULL,olen,NULL,NULL);
}
int stb_bgio_readf_to(FILE *f, int offset, int len, stb_uchar *buffer, int *olen)
{
return stb__io_add(NULL,f,offset,len,buffer,NULL,olen,NULL,NULL);
}
STB_EXTERN int stb_bgio_stat (char *filename, stb_bgstat *result)
{
result->have_data = 0;
return stb__io_add(filename,NULL,0,0,0,NULL,0,NULL, result);
}
#endif
#endif
//////////////////////////////////////////////////////////////////////////////
//
// Fast malloc implementation
//
// This is a clone of TCMalloc, but without the thread support.
// 1. large objects are allocated directly, page-aligned
// 2. small objects are allocated in homogeonous heaps, 0 overhead
//
// We keep an allocation table for pages a la TCMalloc. This would
// require 4MB for the entire address space, but we only allocate
// the parts that are in use. The overhead from using homogenous heaps
// everywhere is 3MB. (That is, if you allocate 1 object of each size,
// you'll use 3MB.)
#if defined(STB_DEFINE) && (defined(_WIN32) || defined(STB_FASTMALLOC))
#ifdef _WIN32
#ifndef _WINDOWS_
#ifndef STB__IMPORT
#define STB__IMPORT STB_EXTERN __declspec(dllimport)
#define STB__DW unsigned long
#endif
STB__IMPORT void * __stdcall VirtualAlloc(void *p, unsigned long size, unsigned long type, unsigned long protect);
STB__IMPORT int __stdcall VirtualFree(void *p, unsigned long size, unsigned long freetype);
#endif
#define stb__alloc_pages_raw(x) (stb_uint32) VirtualAlloc(NULL, (x), 0x3000, 0x04)
#define stb__dealloc_pages_raw(p) VirtualFree((void *) p, 0, 0x8000)
#else
#error "Platform not currently supported"
#endif
typedef struct stb__span
{
int start, len;
struct stb__span *next, *prev;
void *first_free;
unsigned short list; // 1..256 free; 257..511 sizeclass; 0=large block
short allocations; // # outstanding allocations for sizeclass
} stb__span; // 24
static stb__span **stb__span_for_page;
static int stb__firstpage, stb__lastpage;
static void stb__update_page_range(int first, int last)
{
stb__span **sfp;
int i, f,l;
if (first >= stb__firstpage && last <= stb__lastpage) return;
if (stb__span_for_page == NULL) {
f = first;
l = f+stb_max(last-f, 16384);
l = stb_min(l, 1<<20);
} else if (last > stb__lastpage) {
f = stb__firstpage;
l = f + (stb__lastpage - f) * 2;
l = stb_clamp(last, l,1<<20);
} else {
l = stb__lastpage;
f = l - (l - stb__firstpage) * 2;
f = stb_clamp(f, 0,first);
}
sfp = (stb__span **) stb__alloc_pages_raw(sizeof(void *) * (l-f));
for (i=f; i < stb__firstpage; ++i) sfp[i - f] = NULL;
for ( ; i < stb__lastpage ; ++i) sfp[i - f] = stb__span_for_page[i - stb__firstpage];
for ( ; i < l ; ++i) sfp[i - f] = NULL;
if (stb__span_for_page) stb__dealloc_pages_raw(stb__span_for_page);
stb__firstpage = f;
stb__lastpage = l;
stb__span_for_page = sfp;
}
static stb__span *stb__span_free=NULL;
static stb__span *stb__span_first, *stb__span_end;
static stb__span *stb__span_alloc(void)
{
stb__span *s = stb__span_free;
if (s)
stb__span_free = s->next;
else {
if (!stb__span_first) {
stb__span_first = (stb__span *) stb__alloc_pages_raw(65536);
if (stb__span_first == NULL) return NULL;
stb__span_end = stb__span_first + (65536 / sizeof(stb__span));
}
s = stb__span_first++;
if (stb__span_first == stb__span_end) stb__span_first = NULL;
}
return s;
}
static stb__span *stb__spanlist[512];
static void stb__spanlist_unlink(stb__span *s)
{
if (s->prev)
s->prev->next = s->next;
else {
int n = s->list;
assert(stb__spanlist[n] == s);
stb__spanlist[n] = s->next;
}
if (s->next)
s->next->prev = s->prev;
s->next = s->prev = NULL;
s->list = 0;
}
static void stb__spanlist_add(int n, stb__span *s)
{
s->list = n;
s->next = stb__spanlist[n];
s->prev = NULL;
stb__spanlist[n] = s;
if (s->next) s->next->prev = s;
}
#define stb__page_shift 12
#define stb__page_size (1 << stb__page_shift)
#define stb__page_number(x) ((x) >> stb__page_shift)
#define stb__page_address(x) ((x) << stb__page_shift)
static void stb__set_span_for_page(stb__span *s)
{
int i;
for (i=0; i < s->len; ++i)
stb__span_for_page[s->start + i - stb__firstpage] = s;
}
static stb__span *stb__coalesce(stb__span *a, stb__span *b)
{
assert(a->start + a->len == b->start);
if (a->list) stb__spanlist_unlink(a);
if (b->list) stb__spanlist_unlink(b);
a->len += b->len;
b->len = 0;
b->next = stb__span_free;
stb__span_free = b;
stb__set_span_for_page(a);
return a;
}
static void stb__free_span(stb__span *s)
{
stb__span *n = NULL;
if (s->start > stb__firstpage) {
n = stb__span_for_page[s->start-1 - stb__firstpage];
if (n && n->allocations == -2 && n->start + n->len == s->start) s = stb__coalesce(n,s);
}
if (s->start + s->len < stb__lastpage) {
n = stb__span_for_page[s->start + s->len - stb__firstpage];
if (n && n->allocations == -2 && s->start + s->len == n->start) s = stb__coalesce(s,n);
}
s->allocations = -2;
stb__spanlist_add(s->len > 256 ? 256 : s->len, s);
}
static stb__span *stb__alloc_pages(int num)
{
stb__span *s = stb__span_alloc();
int p;
if (!s) return NULL;
p = stb__alloc_pages_raw(num << stb__page_shift);
if (p == 0) { s->next = stb__span_free; stb__span_free = s; return 0; }
assert(stb__page_address(stb__page_number(p)) == p);
p = stb__page_number(p);
stb__update_page_range(p, p+num);
s->start = p;
s->len = num;
s->next = NULL;
s->prev = NULL;
stb__set_span_for_page(s);
return s;
}
static stb__span *stb__alloc_span(int pagecount)
{
int i;
stb__span *p = NULL;
for(i=pagecount; i < 256; ++i)
if (stb__spanlist[i]) {
p = stb__spanlist[i];
break;
}
if (!p) {
p = stb__spanlist[256];
while (p && p->len < pagecount)
p = p->next;
}
if (!p) {
p = stb__alloc_pages(pagecount < 16 ? 16 : pagecount);
if (p == NULL) return 0;
} else
stb__spanlist_unlink(p);
if (p->len > pagecount) {
stb__span *q = stb__span_alloc();
if (q) {
q->start = p->start + pagecount;
q->len = p->len - pagecount;
p->len = pagecount;
for (i=0; i < q->len; ++i)
stb__span_for_page[q->start+i - stb__firstpage] = q;
stb__spanlist_add(q->len > 256 ? 256 : q->len, q);
}
}
return p;
}
#define STB__MAX_SMALL_SIZE 32768
#define STB__MAX_SIZE_CLASSES 256
static unsigned char stb__class_base[32];
static unsigned char stb__class_shift[32];
static unsigned char stb__pages_for_class[STB__MAX_SIZE_CLASSES];
static int stb__size_for_class[STB__MAX_SIZE_CLASSES];
stb__span *stb__get_nonempty_sizeclass(int c)
{
int s = c + 256, i, size, tsize; // remap to span-list index
char *z;
void *q;
stb__span *p = stb__spanlist[s];
if (p) {
if (p->first_free) return p; // fast path: it's in the first one in list
for (p=p->next; p; p=p->next)
if (p->first_free) {
// move to front for future queries
stb__spanlist_unlink(p);
stb__spanlist_add(s, p);
return p;
}
}
// no non-empty ones, so allocate a new one
p = stb__alloc_span(stb__pages_for_class[c]);
if (!p) return NULL;
// create the free list up front
size = stb__size_for_class[c];
tsize = stb__pages_for_class[c] << stb__page_shift;
i = 0;
z = (char *) stb__page_address(p->start);
q = NULL;
while (i + size <= tsize) {
* (void **) z = q; q = z;
z += size;
i += size;
}
p->first_free = q;
p->allocations = 0;
stb__spanlist_add(s,p);
return p;
}
static int stb__sizeclass(size_t sz)
{
int z = stb_log2_floor(sz); // -1 below to group e.g. 13,14,15,16 correctly
return stb__class_base[z] + ((sz-1) >> stb__class_shift[z]);
}
static void stb__init_sizeclass(void)
{
int i, size, overhead;
int align_shift = 2; // allow 4-byte and 12-byte blocks as well, vs. TCMalloc
int next_class = 1;
int last_log = 0;
for (i = 0; i < align_shift; i++) {
stb__class_base [i] = next_class;
stb__class_shift[i] = align_shift;
}
for (size = 1 << align_shift; size <= STB__MAX_SMALL_SIZE; size += 1 << align_shift) {
i = stb_log2_floor(size);
if (i > last_log) {
if (size == 16) ++align_shift; // switch from 4-byte to 8-byte alignment
else if (size >= 128 && align_shift < 8) ++align_shift;
stb__class_base[i] = next_class - ((size-1) >> align_shift);
stb__class_shift[i] = align_shift;
last_log = i;
}
stb__size_for_class[next_class++] = size;
}
for (i=1; i <= STB__MAX_SMALL_SIZE; ++i)
assert(i <= stb__size_for_class[stb__sizeclass(i)]);
overhead = 0;
for (i = 1; i < next_class; i++) {
int s = stb__size_for_class[i];
size = stb__page_size;
while (size % s > size >> 3)
size += stb__page_size;
stb__pages_for_class[i] = (unsigned char) (size >> stb__page_shift);
overhead += size;
}
assert(overhead < (4 << 20)); // make sure it's under 4MB of overhead
}
#ifdef STB_DEBUG
#define stb__smemset(a,b,c) memset((void *) a, b, c)
#elif defined(STB_FASTMALLOC_INIT)
#define stb__smemset(a,b,c) memset((void *) a, b, c)
#else
#define stb__smemset(a,b,c)
#endif
void *stb_smalloc(size_t sz)
{
stb__span *s;
if (sz == 0) return NULL;
if (stb__size_for_class[1] == 0) stb__init_sizeclass();
if (sz > STB__MAX_SMALL_SIZE) {
s = stb__alloc_span((sz + stb__page_size - 1) >> stb__page_shift);
if (s == NULL) return NULL;
s->list = 0;
s->next = s->prev = NULL;
s->allocations = -32767;
stb__smemset(stb__page_address(s->start), 0xcd, (sz+3)&~3);
return (void *) stb__page_address(s->start);
} else {
void *p;
int c = stb__sizeclass(sz);
s = stb__spanlist[256+c];
if (!s || !s->first_free)
s = stb__get_nonempty_sizeclass(c);
if (s == NULL) return NULL;
p = s->first_free;
s->first_free = * (void **) p;
++s->allocations;
stb__smemset(p,0xcd, sz);
return p;
}
}
int stb_ssize(void *p)
{
stb__span *s;
if (p == NULL) return 0;
s = stb__span_for_page[stb__page_number((stb_uint) p) - stb__firstpage];
if (s->list >= 256) {
return stb__size_for_class[s->list - 256];
} else {
assert(s->list == 0);
return s->len << stb__page_shift;
}
}
void stb_sfree(void *p)
{
stb__span *s;
if (p == NULL) return;
s = stb__span_for_page[stb__page_number((stb_uint) p) - stb__firstpage];
if (s->list >= 256) {
stb__smemset(p, 0xfe, stb__size_for_class[s->list-256]);
* (void **) p = s->first_free;
s->first_free = p;
if (--s->allocations == 0) {
stb__spanlist_unlink(s);
stb__free_span(s);
}
} else {
assert(s->list == 0);
stb__smemset(p, 0xfe, stb_ssize(p));
stb__free_span(s);
}
}
void *stb_srealloc(void *p, size_t sz)
{
size_t cur_size;
if (p == NULL) return stb_smalloc(sz);
if (sz == 0) { stb_sfree(p); return NULL; }
cur_size = stb_ssize(p);
if (sz > cur_size || sz <= (cur_size >> 1)) {
void *q;
if (sz > cur_size && sz < (cur_size << 1)) sz = cur_size << 1;
q = stb_smalloc(sz); if (q == NULL) return NULL;
memcpy(q, p, sz < cur_size ? sz : cur_size);
stb_sfree(p);
return q;
}
return p;
}
void *stb_scalloc(size_t n, size_t sz)
{
void *p;
if (n == 0 || sz == 0) return NULL;
if (stb_log2_ceil(n) + stb_log2_ceil(n) >= 32) return NULL;
p = stb_smalloc(n*sz);
if (p) memset(p, 0, n*sz);
return p;
}
char *stb_sstrdup(char *s)
{
int n = strlen(s);
char *p = (char *) stb_smalloc(n+1);
if (p) strcpy(p,s);
return p;
}
#endif // STB_DEFINE
//////////////////////////////////////////////////////////////////////////////
//
// Source code constants
//
// This is a trivial system to let you specify constants in source code,
// then while running you can change the constants.
//
// Note that you can't wrap the #defines, because we need to know their
// names. So we provide a pre-wrapped version without 'STB_' for convenience;
// to request it, #define STB_CONVENIENT_H, yielding:
// KI -- integer
// KU -- unsigned integer
// KF -- float
// KD -- double
// KS -- string constant
//
// Defaults to functioning in debug build, not in release builds.
// To force on, define STB_ALWAYS_H
#ifdef STB_CONVENIENT_H
#define KI(x) STB_I(x)
#define KU(x) STB_UI(x)
#define KF(x) STB_F(x)
#define KD(x) STB_D(x)
#define KS(x) STB_S(x)
#endif
STB_EXTERN void stb_source_path(char *str);
#ifdef STB_DEFINE
char *stb__source_path;
void stb_source_path(char *path)
{
stb__source_path = path;
}
char *stb__get_sourcefile_path(char *file)
{
static char filebuf[512];
if (stb__source_path) {
sprintf(filebuf, "%s/%s", stb__source_path, file);
if (stb_fexists(filebuf)) return filebuf;
}
if (stb_fexists(file)) return file;
sprintf(filebuf, "../%s", file);
if (!stb_fexists(filebuf)) return filebuf;
return file;
}
#endif
#define STB_F(x) ((float) STB_H(x))
#define STB_UI(x) ((unsigned int) STB_I(x))
#if !defined(STB_DEBUG) && !defined(STB_ALWAYS_H)
#define STB_D(x) ((double) (x))
#define STB_I(x) ((int) (x))
#define STB_S(x) ((char *) (x))
#else
#define STB_D(x) stb__double_constant(__FILE__, __LINE__-1, (x))
#define STB_I(x) stb__int_constant(__FILE__, __LINE__-1, (x))
#define STB_S(x) stb__string_constant(__FILE__, __LINE__-1, (x))
STB_EXTERN double stb__double_constant(char *file, int line, double x);
STB_EXTERN int stb__int_constant(char *file, int line, int x);
STB_EXTERN char * stb__string_constant(char *file, int line, char *str);
#ifdef STB_DEFINE
enum
{
STB__CTYPE_int,
STB__CTYPE_uint,
STB__CTYPE_float,
STB__CTYPE_double,
STB__CTYPE_string,
};
typedef struct
{
int line;
int type;
union {
int ival;
double dval;
char *sval;
};
} stb__Entry;
typedef struct
{
stb__Entry *entries;
char *filename;
time_t timestamp;
char **file_data;
int file_len;
unsigned short *line_index;
} stb__FileEntry;
static void stb__constant_parse(stb__FileEntry *f, int i)
{
char *s;
int n;
if (!stb_arr_valid(f->entries, i)) return;
n = f->entries[i].line;
if (n >= f->file_len) return;
s = f->file_data[n];
switch (f->entries[i].type) {
case STB__CTYPE_float:
while (*s) {
if (!strncmp(s, "STB_D(", 6)) { s+=6; goto matched_float; }
if (!strncmp(s, "STB_F(", 6)) { s+=6; goto matched_float; }
if (!strncmp(s, "KD(", 3)) { s+=3; goto matched_float; }
if (!strncmp(s, "KF(", 3)) { s+=3; goto matched_float; }
++s;
}
break;
matched_float:
f->entries[i].dval = strtod(s, NULL);
break;
case STB__CTYPE_int:
while (*s) {
if (!strncmp(s, "STB_I(", 6)) { s+=6; goto matched_int; }
if (!strncmp(s, "STB_UI(", 7)) { s+=7; goto matched_int; }
if (!strncmp(s, "KI(", 3)) { s+=3; goto matched_int; }
if (!strncmp(s, "KU(", 3)) { s+=3; goto matched_int; }
++s;
}
break;
matched_int: {
int neg=0;
s = stb_skipwhite(s);
while (*s == '-') { neg = !neg; s = stb_skipwhite(s+1); } // handle '- - 5', pointlessly
if (s[0] == '0' && tolower(s[1]) == 'x')
f->entries[i].ival = strtol(s, NULL, 16);
else if (s[0] == '0')
f->entries[i].ival = strtol(s, NULL, 8);
else
f->entries[i].ival = strtol(s, NULL, 10);
if (neg) f->entries[i].ival = -f->entries[i].ival;
break;
}
case STB__CTYPE_string:
// @TODO
break;
}
}
static stb_sdict *stb__constant_file_hash;
stb__Entry *stb__constant_get_entry(char *filename, int line, int type)
{
int i;
stb__FileEntry *f;
if (stb__constant_file_hash == NULL)
stb__constant_file_hash = stb_sdict_new(STB_TRUE);
f = (stb__FileEntry*) stb_sdict_get(stb__constant_file_hash, filename);
if (f == NULL) {
char *s = stb__get_sourcefile_path(filename);
if (s == NULL || !stb_fexists(s)) return 0;
f = (stb__FileEntry *) malloc(sizeof(*f));
f->timestamp = stb_ftimestamp(s);
f->file_data = stb_stringfile(s, &f->file_len);
f->filename = strdup(s); // cache the full path
f->entries = NULL;
f->line_index = 0;
stb_arr_setlen(f->line_index, f->file_len);
memset(f->line_index, 0xff, stb_arr_storage(f->line_index));
} else {
time_t t = stb_ftimestamp(f->filename);
if (f->timestamp != t) {
f->timestamp = t;
free(f->file_data);
f->file_data = stb_stringfile(f->filename, &f->file_len);
stb_arr_setlen(f->line_index, f->file_len);
for (i=0; i < stb_arr_len(f->entries); ++i)
stb__constant_parse(f, i);
}
}
if (line >= f->file_len) return 0;
if (f->line_index[line] >= stb_arr_len(f->entries)) {
// need a new entry
int n = stb_arr_len(f->entries);
stb__Entry e;
e.line = line;
if (line < f->file_len)
f->line_index[line] = n;
e.type = type;
stb_arr_push(f->entries, e);
stb__constant_parse(f, n);
}
return f->entries + f->line_index[line];
}
double stb__double_constant(char *file, int line, double x)
{
stb__Entry *e = stb__constant_get_entry(file, line, STB__CTYPE_float);
if (!e) return x;
return e->dval;
}
int stb__int_constant(char *file, int line, int x)
{
stb__Entry *e = stb__constant_get_entry(file, line, STB__CTYPE_int);
if (!e) return x;
return e->ival;
}
char * stb__string_constant(char *file, int line, char *x)
{
stb__Entry *e = stb__constant_get_entry(file, line, STB__CTYPE_string);
if (!e) return x;
return e->sval;
}
#endif // STB_DEFINE
#endif // !STB_DEBUG && !STB_ALWAYS_H
#ifdef STB_STUA
//////////////////////////////////////////////////////////////////////////
//
// stua: little scripting language
//
// define STB_STUA to compile it
//
// see http://nothings.org/stb/stb_stua.html for documentation
//
// basic parsing model:
//
// lexical analysis
// use stb_lex() to parse tokens; keywords get their own tokens
//
// parsing:
// recursive descent parser. too much of a hassle to make an unambiguous
// LR(1) grammar, and one-pass generation is clumsier (recursive descent
// makes it easier to e.g. compile nested functions). on the other hand,
// dictionary syntax required hackery to get extra lookahead.
//
// codegen:
// output into an evaluation tree, using array indices as 'pointers'
//
// run:
// traverse the tree; support for 'break/continue/return' is tricky
//
// garbage collection:
// stu__mark and sweep; explicit stack with non-stu__compile_global_scope roots
typedef stb_int32 stua_obj;
typedef stb_idict stua_dict;
STB_EXTERN void stua_run_script(char *s);
STB_EXTERN void stua_uninit(void);
extern stua_obj stua_globals;
STB_EXTERN double stua_number(stua_obj z);
STB_EXTERN stua_obj stua_getnil(void);
STB_EXTERN stua_obj stua_getfalse(void);
STB_EXTERN stua_obj stua_gettrue(void);
STB_EXTERN stua_obj stua_string(char *z);
STB_EXTERN stua_obj stua_make_number(double d);
STB_EXTERN stua_obj stua_box(int type, void *data, int size);
enum
{
STUA_op_negate=129,
STUA_op_shl, STUA_op_ge,
STUA_op_shr, STUA_op_le,
STUA_op_shru,
STUA_op_last
};
#define STUA_NO_VALUE 2 // equivalent to a tagged NULL
STB_EXTERN stua_obj (*stua_overload)(int op, stua_obj a, stua_obj b, stua_obj c);
STB_EXTERN stua_obj stua_error(char *err, ...);
STB_EXTERN stua_obj stua_pushroot(stua_obj o);
STB_EXTERN void stua_poproot ( void );
#ifdef STB_DEFINE
// INTERPRETER
// 31-bit floating point implementation
// force the (1 << 30) bit (2nd highest bit) to be zero by re-biasing the exponent;
// then shift and set the bottom bit
static stua_obj stu__floatp(float *f)
{
unsigned int n = *(unsigned int *) f;
unsigned int e = n & (0xff << 23);
assert(sizeof(int) == 4 && sizeof(float) == 4);
if (!e) // zero?
n = n; // no change
else if (e < (64 << 23)) // underflow of the packed encoding?
n = (n & 0x80000000); // signed 0
else if (e > (190 << 23)) // overflow of the encoding? (or INF or NAN)
n = (n & 0x80000000) + (127 << 23); // new INF encoding
else
n -= 0x20000000;
// now we need to shuffle the bits so that the spare bit is at the bottom
assert((n & 0x40000000) == 0);
return (n & 0x80000000) + (n << 1) + 1;
}
static unsigned char stu__getfloat_addend[256];
static float stu__getfloat(stua_obj v)
{
unsigned int n;
unsigned int e = ((unsigned int) v) >> 24;
n = (int) v >> 1; // preserve high bit
n += stu__getfloat_addend[e] << 24;
return *(float *) &n;
}
stua_obj stua_float(float f)
{
return stu__floatp(&f);
}
static void stu__float_init(void)
{
int i;
stu__getfloat_addend[0] = 0; // do nothing to biased exponent of 0
for (i=1; i < 127; ++i)
stu__getfloat_addend[i] = 32; // undo the -0x20000000
stu__getfloat_addend[127] = 64; // convert packed INF to INF (0x3f -> 0x7f)
for (i=0; i < 128; ++i) // for signed floats, remove the bit we just shifted down
stu__getfloat_addend[128+i] = stu__getfloat_addend[i] - 64;
}
// Tagged data type implementation
// TAGS:
#define stu__int_tag 0 // of 2 bits // 00 int
#define stu__float_tag 1 // of 1 bit // 01 float
#define stu__ptr_tag 2 // of 2 bits // 10 boxed
// 11 float
#define stu__tag(x) ((x) & 3)
#define stu__number(x) (stu__tag(x) != stu__ptr_tag)
#define stu__isint(x) (stu__tag(x) == stu__int_tag)
#define stu__int(x) ((x) >> 2)
#define stu__float(x) (stu__getfloat(x))
#define stu__makeint(v) ((v)*4+stu__int_tag)
// boxed data, and tag support for boxed data
enum
{
STU___float = 1, STU___int = 2,
STU___number = 3, STU___string = 4,
STU___function = 5, STU___dict = 6,
STU___boolean = 7, STU___error = 8,
};
// boxed data
#define STU__BOX short type, stua_gc
typedef struct stu__box { STU__BOX; } stu__box;
stu__box stu__nil = { 0, 1 };
stu__box stu__true = { STU___boolean, 1, };
stu__box stu__false = { STU___boolean, 1, };
#define stu__makeptr(v) ((stua_obj) (v) + stu__ptr_tag)
#define stua_nil stu__makeptr(&stu__nil)
#define stua_true stu__makeptr(&stu__true)
#define stua_false stu__makeptr(&stu__false)
stua_obj stua_getnil(void) { return stua_nil; }
stua_obj stua_getfalse(void) { return stua_false; }
stua_obj stua_gettrue(void) { return stua_true; }
#define stu__ptr(x) ((stu__box *) ((x) - stu__ptr_tag))
#define stu__checkt(t,x) ((t) == STU___float ? ((x) & 1) == stu__float_tag : \
(t) == STU___int ? stu__isint(x) : \
(t) == STU___number ? stu__number(x) : \
stu__tag(x) == stu__ptr_tag && stu__ptr(x)->type == (t))
typedef struct
{
STU__BOX;
void *ptr;
} stu__wrapper;
// implementation of a 'function' or function + closure
typedef struct stu__func
{
STU__BOX;
stua_obj closure_source; // 0 - regular function; 4 - C function
// if closure, pointer to source function
union {
stua_obj closure_data; // partial-application data
void *store; // pointer to free that holds 'code'
stua_obj (*func)(stua_dict *context);
} f;
// closure ends here
short *code;
int num_param;
stua_obj *param; // list of parameter strings
} stu__func;
// apply this to 'short *code' to get at data
#define stu__const(f) ((stua_obj *) (f))
static void stu__free_func(stu__func *f)
{
if (f->closure_source == 0) free(f->f.store);
if ((stb_uint) f->closure_source <= 4) free(f->param);
free(f);
}
#define stu__pd(x) ((stua_dict *) stu__ptr(x))
#define stu__pw(x) ((stu__wrapper *) stu__ptr(x))
#define stu__pf(x) ((stu__func *) stu__ptr(x))
// garbage-collection
static stu__box ** stu__gc_ptrlist;
static stua_obj * stu__gc_root_stack;
stua_obj stua_pushroot(stua_obj o) { stb_arr_push(stu__gc_root_stack, o); return o; }
void stua_poproot ( void ) { stb_arr_pop(stu__gc_root_stack); }
static stb_sdict *stu__strings;
static void stu__mark(stua_obj z)
{
int i;
stu__box *p = stu__ptr(z);
if (p->stua_gc == 1) return; // already marked
assert(p->stua_gc == 0);
p->stua_gc = 1;
switch(p->type) {
case STU___function: {
stu__func *f = (stu__func *) p;
if ((stb_uint) f->closure_source <= 4) {
if (f->closure_source == 0) {
for (i=1; i <= f->code[0]; ++i)
if (!stu__number(((stua_obj *) f->code)[-i]))
stu__mark(((stua_obj *) f->code)[-i]);
}
for (i=0; i < f->num_param; ++i)
stu__mark(f->param[i]);
} else {
stu__mark(f->closure_source);
stu__mark(f->f.closure_data);
}
break;
}
case STU___dict: {
stua_dict *e = (stua_dict *) p;
for (i=0; i < e->limit; ++i)
if (e->table[i].k != STB_IEMPTY && e->table[i].k != STB_IDEL) {
if (!stu__number(e->table[i].k)) stu__mark((int) e->table[i].k);
if (!stu__number(e->table[i].v)) stu__mark((int) e->table[i].v);
}
break;
}
}
}
static int stu__num_allocs, stu__size_allocs;
static stua_obj stu__flow_val = stua_nil; // used for break & return
static void stua_gc(int force)
{
int i;
if (!force && stu__num_allocs == 0 && stu__size_allocs == 0) return;
stu__num_allocs = stu__size_allocs = 0;
//printf("[gc]\n");
// clear marks
for (i=0; i < stb_arr_len(stu__gc_ptrlist); ++i)
stu__gc_ptrlist[i]->stua_gc = 0;
// stu__mark everything reachable
stu__nil.stua_gc = stu__true.stua_gc = stu__false.stua_gc = 1;
stu__mark(stua_globals);
if (!stu__number(stu__flow_val))
stu__mark(stu__flow_val);
for (i=0; i < stb_arr_len(stu__gc_root_stack); ++i)
if (!stu__number(stu__gc_root_stack[i]))
stu__mark(stu__gc_root_stack[i]);
// sweep unreachables
for (i=0; i < stb_arr_len(stu__gc_ptrlist);) {
stu__box *z = stu__gc_ptrlist[i];
if (!z->stua_gc) {
switch (z->type) {
case STU___dict: stb_idict_destroy((stua_dict *) z); break;
case STU___error: free(((stu__wrapper *) z)->ptr); break;
case STU___string: stb_sdict_remove(stu__strings, (char*) ((stu__wrapper *) z)->ptr, NULL); free(z); break;
case STU___function: stu__free_func((stu__func *) z); break;
}
// swap in the last item over this, and repeat
z = stb_arr_pop(stu__gc_ptrlist);
stu__gc_ptrlist[i] = z;
} else
++i;
}
}
static void stu__consider_gc(stua_obj x)
{
if (stu__size_allocs < 100000) return;
if (stu__num_allocs < 10 && stu__size_allocs < 1000000) return;
stb_arr_push(stu__gc_root_stack, x);
stua_gc(0);
stb_arr_pop(stu__gc_root_stack);
}
static stua_obj stu__makeobj(int type, void *data, int size, int safe_to_gc)
{
stua_obj x = stu__makeptr(data);
((stu__box *) data)->type = type;
stb_arr_push(stu__gc_ptrlist, (stu__box *) data);
stu__num_allocs += 1;
stu__size_allocs += size;
if (safe_to_gc) stu__consider_gc(x);
return x;
}
stua_obj stua_box(int type, void *data, int size)
{
stu__wrapper *p = (stu__wrapper *) malloc(sizeof(*p));
p->ptr = data;
return stu__makeobj(type, p, size, 0);
}
// a stu string can be directly compared for equality, because
// they go into a hash table
stua_obj stua_string(char *z)
{
stu__wrapper *b = (stu__wrapper *) stb_sdict_get(stu__strings, z);
if (b == NULL) {
int o = stua_box(STU___string, NULL, strlen(z) + sizeof(*b));
b = stu__pw(o);
stb_sdict_add(stu__strings, z, b);
stb_sdict_getkey(stu__strings, z, (char **) &b->ptr);
}
return stu__makeptr(b);
}
// stb_obj dictionary is just an stb_idict
static void stu__set(stua_dict *d, stua_obj k, stua_obj v)
{ if (stb_idict_set(d, k, v)) stu__size_allocs += 8; }
static stua_obj stu__get(stua_dict *d, stua_obj k, stua_obj res)
{
stb_idict_get_flag(d, k, &res);
return res;
}
static stua_obj make_string(char *z, int len)
{
stua_obj s;
char temp[256], *q = (char *) stb_temp(temp, len+1), *p = q;
while (len > 0) {
if (*z == '\\') {
if (z[1] == 'n') *p = '\n';
else if (z[1] == 'r') *p = '\r';
else if (z[1] == 't') *p = '\t';
else *p = z[1];
p += 1; z += 2; len -= 2;
} else {
*p++ = *z++; len -= 1;
}
}
*p = 0;
s = stua_string(q);
stb_tempfree(temp, q);
return s;
}
enum token_names
{
T__none=128,
ST_shl = STUA_op_shl, ST_ge = STUA_op_ge,
ST_shr = STUA_op_shr, ST_le = STUA_op_le,
ST_shru = STUA_op_shru, STU__negate = STUA_op_negate,
ST__reset_numbering = STUA_op_last,
ST_white,
ST_id, ST_float, ST_decimal, ST_hex, ST_char,ST_string, ST_number,
// make sure the keywords come _AFTER_ ST_id, so stb_lex prefer them
ST_if, ST_while, ST_for, ST_eq, ST_nil,
ST_then, ST_do, ST_in, ST_ne, ST_true,
ST_else, ST_break, ST_let, ST_and, ST_false,
ST_elseif, ST_continue, ST_into, ST_or, ST_repeat,
ST_end, ST_as, ST_return, ST_var, ST_func,
ST_catch, ST__frame,
ST__max_terminals,
STU__defaultparm, STU__seq,
};
static stua_dict * stu__globaldict;
stua_obj stua_globals;
static enum
{
FLOW_normal, FLOW_continue, FLOW_break, FLOW_return, FLOW_error,
} stu__flow;
stua_obj stua_error(char *z, ...)
{
stua_obj a;
char temp[4096], *x;
va_list v; va_start(v,z); vsprintf(temp, z, v); va_end(v);
x = strdup(temp);
a = stua_box(STU___error, x, strlen(x));
stu__flow = FLOW_error;
stu__flow_val = a;
return stua_nil;
}
double stua_number(stua_obj z)
{
return stu__tag(z) == stu__int_tag ? stu__int(z) : stu__float(z);
}
stua_obj stua_make_number(double d)
{
double e = floor(d);
if (e == d && e < (1 << 29) && e >= -(1 << 29))
return stu__makeint((int) e);
else
return stua_float((float) d);
}
stua_obj (*stua_overload)(int op, stua_obj a, stua_obj b, stua_obj c) = NULL;
static stua_obj stu__op(int op, stua_obj a, stua_obj b, stua_obj c)
{
stua_obj r = STUA_NO_VALUE;
if (op == '+') {
if (stu__checkt(STU___string, a) && stu__checkt(STU___string, b)) {
;// @TODO: string concatenation
} else if (stu__checkt(STU___function, a) && stu__checkt(STU___dict, b)) {
stu__func *f = (stu__func *) malloc(12);
assert(offsetof(stu__func, code)==12);
f->closure_source = a;
f->f.closure_data = b;
return stu__makeobj(STU___function, f, 16, 1);
}
}
if (stua_overload) r = stua_overload(op,a,b,c);
if (stu__flow != FLOW_error && r == STUA_NO_VALUE)
stua_error("Typecheck for operator %d", op), r=stua_nil;
return r;
}
#define STU__EVAL2(a,b) \
a = stu__eval(stu__f[n+1]); if (stu__flow) break; stua_pushroot(a); \
b = stu__eval(stu__f[n+2]); stua_poproot(); if (stu__flow) break;
#define STU__FB(op) \
STU__EVAL2(a,b) \
if (stu__tag(a) == stu__int_tag && stu__tag(b) == stu__int_tag) \
return ((a) op (b)); \
if (stu__number(a) && stu__number(b)) \
return stua_make_number(stua_number(a) op stua_number(b)); \
return stu__op(stu__f[n], a,b, stua_nil)
#define STU__F(op) \
STU__EVAL2(a,b) \
if (stu__number(a) && stu__number(b)) \
return stua_make_number(stua_number(a) op stua_number(b)); \
return stu__op(stu__f[n], a,b, stua_nil)
#define STU__I(op) \
STU__EVAL2(a,b) \
if (stu__tag(a) == stu__int_tag && stu__tag(b) == stu__int_tag) \
return stu__makeint(stu__int(a) op stu__int(b)); \
return stu__op(stu__f[n], a,b, stua_nil)
#define STU__C(op) \
STU__EVAL2(a,b) \
if (stu__number(a) && stu__number(b)) \
return (stua_number(a) op stua_number(b)) ? stua_true : stua_false; \
return stu__op(stu__f[n], a,b, stua_nil)
#define STU__CE(op) \
STU__EVAL2(a,b) \
return (a op b) ? stua_true : stua_false
static short *stu__f;
static stua_obj stu__f_obj;
static stua_dict *stu__c;
static stua_obj stu__funceval(stua_obj fo, stua_obj co);
static int stu__cond(stua_obj x)
{
if (stu__flow) return 0;
if (!stu__checkt(STU___boolean, x))
x = stu__op('!', x, stua_nil, stua_nil);
if (x == stua_true ) return 1;
if (x == stua_false) return 0;
stu__flow = FLOW_error;
return 0;
}
// had to manually eliminate tailcall recursion for debugging complex stuff
#define TAILCALL(x) n = (x); goto top;
static stua_obj stu__eval(int n)
{
top:
if (stu__flow >= FLOW_return) return stua_nil; // is this needed?
if (n < 0) return stu__const(stu__f)[n];
assert(n != 0 && n != 1);
switch (stu__f[n]) {
stua_obj a,b,c;
case ST_catch: a = stu__eval(stu__f[n+1]);
if (stu__flow == FLOW_error) { a=stu__flow_val; stu__flow = FLOW_normal; }
return a;
case ST_var: b = stu__eval(stu__f[n+2]); if (stu__flow) break;
stu__set(stu__c, stu__const(stu__f)[stu__f[n+1]], b);
return b;
case STU__seq: stu__eval(stu__f[n+1]); if (stu__flow) break;
TAILCALL(stu__f[n+2]);
case ST_if: if (!stu__cond(stu__eval(stu__f[n+1]))) return stua_nil;
TAILCALL(stu__f[n+2]);
case ST_else: a = stu__cond(stu__eval(stu__f[n+1]));
TAILCALL(stu__f[n + 2 + !a]);
#define STU__HANDLE_BREAK \
if (stu__flow >= FLOW_break) { \
if (stu__flow == FLOW_break) { \
a = stu__flow_val; \
stu__flow = FLOW_normal; \
stu__flow_val = stua_nil; \
return a; \
} \
return stua_nil; \
}
case ST_as: stu__eval(stu__f[n+3]);
STU__HANDLE_BREAK
// fallthrough!
case ST_while: a = stua_nil; stua_pushroot(a);
while (stu__cond(stu__eval(stu__f[n+1]))) {
stua_poproot();
a = stu__eval(stu__f[n+2]);
STU__HANDLE_BREAK
stu__flow = FLOW_normal; // clear 'continue' flag
stua_pushroot(a);
if (stu__f[n+3]) stu__eval(stu__f[n+3]);
STU__HANDLE_BREAK
stu__flow = FLOW_normal; // clear 'continue' flag
}
stua_poproot();
return a;
case ST_break: stu__flow = FLOW_break; stu__flow_val = stu__eval(stu__f[n+1]); break;
case ST_continue:stu__flow = FLOW_continue; break;
case ST_return: stu__flow = FLOW_return; stu__flow_val = stu__eval(stu__f[n+1]); break;
case ST__frame: return stu__f_obj;
case '[': STU__EVAL2(a,b);
if (stu__checkt(STU___dict, a))
return stu__get(stu__pd(a), b, stua_nil);
return stu__op(stu__f[n], a, b, stua_nil);
case '=': a = stu__eval(stu__f[n+2]); if (stu__flow) break;
n = stu__f[n+1];
if (stu__f[n] == ST_id) {
if (!stb_idict_update(stu__c, stu__const(stu__f)[stu__f[n+1]], a))
if (!stb_idict_update(stu__globaldict, stu__const(stu__f)[stu__f[n+1]], a))
return stua_error("Assignment to undefined variable");
} else if (stu__f[n] == '[') {
stua_pushroot(a);
b = stu__eval(stu__f[n+1]); if (stu__flow) { stua_poproot(); break; }
stua_pushroot(b);
c = stu__eval(stu__f[n+2]); stua_poproot(); stua_poproot();
if (stu__flow) break;
if (!stu__checkt(STU___dict, b)) return stua_nil;
stu__set(stu__pd(b), c, a);
} else {
return stu__op(stu__f[n], stu__eval(n), a, stua_nil);
}
return a;
case STU__defaultparm:
a = stu__eval(stu__f[n+2]);
stu__flow = FLOW_normal;
if (stb_idict_add(stu__c, stu__const(stu__f)[stu__f[n+1]], a))
stu__size_allocs += 8;
return stua_nil;
case ST_id: a = stu__get(stu__c, stu__const(stu__f)[stu__f[n+1]], STUA_NO_VALUE); // try local variable
return a != STUA_NO_VALUE // else try stu__compile_global_scope variable
? a : stu__get(stu__globaldict, stu__const(stu__f)[stu__f[n+1]], stua_nil);
case STU__negate:a = stu__eval(stu__f[n+1]); if (stu__flow) break;
return stu__isint(a) ? -a : stu__op(stu__f[n], a, stua_nil, stua_nil);
case '~': a = stu__eval(stu__f[n+1]); if (stu__flow) break;
return stu__isint(a) ? (~a)&~3 : stu__op(stu__f[n], a, stua_nil, stua_nil);
case '!': a = stu__eval(stu__f[n+1]); if (stu__flow) break;
a = stu__cond(a); if (stu__flow) break;
return a ? stua_true : stua_false;
case ST_eq: STU__CE(==); case ST_le: STU__C(<=); case '<': STU__C(<);
case ST_ne: STU__CE(!=); case ST_ge: STU__C(>=); case '>': STU__C(>);
case '+' : STU__FB(+); case '*': STU__F(*); case '&': STU__I(&); case ST_shl: STU__I(<<);
case '-' : STU__FB(-); case '/': STU__F(/); case '|': STU__I(|); case ST_shr: STU__I(>>);
case '%': STU__I(%); case '^': STU__I(^);
case ST_shru: STU__EVAL2(a,b);
if (stu__tag(a) == stu__int_tag && stu__tag(b) == stu__int_tag)
return stu__makeint((unsigned) stu__int(a) >> stu__int(b));
return stu__op(stu__f[n], a,b, stua_nil);
case ST_and: a = stu__eval(stu__f[n+1]); b = stu__cond(a); if (stu__flow) break;
return a ? stu__eval(stu__f[n+2]) : a;
case ST_or : a = stu__eval(stu__f[n+1]); b = stu__cond(a); if (stu__flow) break;
return a ? b : stu__eval(stu__f[n+2]);
case'(':case':': STU__EVAL2(a,b);
if (!stu__checkt(STU___function, a))
return stu__op(stu__f[n], a,b, stua_nil);
if (!stu__checkt(STU___dict, b))
return stua_nil;
if (stu__f[n] == ':')
b = stu__makeobj(STU___dict, stb_idict_copy(stu__pd(b)), stb_idict_memory_usage(stu__pd(b)), 0);
a = stu__funceval(a,b);
return a;
case '{' : {
stua_dict *d;
d = stb_idict_new_size(stu__f[n+1] > 40 ? 64 : 16);
if (d == NULL)
return stua_nil; // breakpoint fodder
c = stu__makeobj(STU___dict, d, 32, 1);
stua_pushroot(c);
a = stu__f[n+1];
for (b=0; b < a; ++b) {
stua_obj x = stua_pushroot(stu__eval(stu__f[n+2 + b*2 + 0]));
stua_obj y = stu__eval(stu__f[n+2 + b*2 + 1]);
stua_poproot();
if (stu__flow) { stua_poproot(); return stua_nil; }
stu__set(d, x, y);
}
stua_poproot();
return c;
}
default: if (stu__f[n] < 0) return stu__const(stu__f)[stu__f[n]];
assert(0); /* NOTREACHED */ // internal error!
}
return stua_nil;
}
int stb__stua_nesting;
static stua_obj stu__funceval(stua_obj fo, stua_obj co)
{
stu__func *f = stu__pf(fo);
stua_dict *context = stu__pd(co);
int i,j;
stua_obj p;
short *tf = stu__f; // save previous function
stua_dict *tc = stu__c;
if (stu__flow == FLOW_error) return stua_nil;
assert(stu__flow == FLOW_normal);
stua_pushroot(fo);
stua_pushroot(co);
stu__consider_gc(stua_nil);
while ((stb_uint) f->closure_source > 4) {
// add data from closure to context
stua_dict *e = (stua_dict *) stu__pd(f->f.closure_data);
for (i=0; i < e->limit; ++i)
if (e->table[i].k != STB_IEMPTY && e->table[i].k != STB_IDEL)
if (stb_idict_add(context, e->table[i].k, e->table[i].v))
stu__size_allocs += 8;
// use add so if it's already defined, we don't override it; that way
// explicit parameters win over applied ones, and most recent applications
// win over previous ones
f = stu__pf(f->closure_source);
}
for (j=0, i=0; i < f->num_param; ++i)
// if it doesn't already exist, add it from the numbered parameters
if (stb_idict_add(context, f->param[i], stu__get(context, stu__int(j), stua_nil)))
++j;
// @TODO: if (stu__get(context, stu__int(f->num_param+1)) != STUA_NO_VALUE) // error: too many parameters
// @TODO: ditto too few parameters
if (f->closure_source == 4)
p = f->f.func(context);
else {
stu__f = f->code, stu__c = context;
stu__f_obj = co;
++stb__stua_nesting;
if (stu__f[1])
p = stu__eval(stu__f[1]);
else
p = stua_nil;
--stb__stua_nesting;
stu__f = tf, stu__c = tc; // restore previous function
if (stu__flow == FLOW_return) {
stu__flow = FLOW_normal;
p = stu__flow_val;
stu__flow_val = stua_nil;
}
}
stua_poproot();
stua_poproot();
return p;
}
// Parser
static int stu__tok;
static stua_obj stu__tokval;
static char *stu__curbuf, *stu__bufstart;
static stb_matcher *stu__lex_matcher;
static unsigned char stu__prec[ST__max_terminals], stu__end[ST__max_terminals];
static void stu__nexttoken(void)
{
int len;
retry:
stu__tok = stb_lex(stu__lex_matcher, stu__curbuf, &len);
if (stu__tok == 0)
return;
switch(stu__tok) {
case ST_white : stu__curbuf += len; goto retry;
case T__none : stu__tok = *stu__curbuf; break;
case ST_string: stu__tokval = make_string(stu__curbuf+1, len-2); break;
case ST_id : stu__tokval = make_string(stu__curbuf, len); break;
case ST_hex : stu__tokval = stu__makeint(strtol(stu__curbuf+2,NULL,16)); stu__tok = ST_number; break;
case ST_decimal: stu__tokval = stu__makeint(strtol(stu__curbuf ,NULL,10)); stu__tok = ST_number; break;
case ST_float : stu__tokval = stua_float((float) atof(stu__curbuf)) ; stu__tok = ST_number; break;
case ST_char : stu__tokval = stu__curbuf[2] == '\\' ? stu__curbuf[3] : stu__curbuf[2];
if (stu__curbuf[3] == 't') stu__tokval = '\t';
if (stu__curbuf[3] == 'n') stu__tokval = '\n';
if (stu__curbuf[3] == 'r') stu__tokval = '\r';
stu__tokval = stu__makeint(stu__tokval);
stu__tok = ST_number;
break;
}
stu__curbuf += len;
}
static struct { int stu__tok; char *regex; } stu__lexemes[] =
{
ST_white , "([ \t\n\r]|/\\*(.|\n)*\\*/|//[^\r\n]*([\r\n]|$))+",
ST_id , "[_a-zA-Z][_a-zA-Z0-9]*",
ST_hex , "0x[0-9a-fA-F]+",
ST_decimal, "[0-9]+[0-9]*",
ST_float , "[0-9]+\\.?[0-9]*([eE][-+]?[0-9]+)?",
ST_float , "\\.[0-9]+([eE][-+]?[0-9]+)?",
ST_char , "c'(\\\\.|[^\\'])'",
ST_string , "\"(\\\\.|[^\\\"\n\r])*\"",
ST_string , "\'(\\\\.|[^\\\'\n\r])*\'",
#define stua_key4(a,b,c,d) ST_##a, #a, ST_##b, #b, ST_##c, #c, ST_##d, #d,
stua_key4(if,then,else,elseif) stua_key4(while,do,for,in)
stua_key4(func,var,let,break) stua_key4(nil,true,false,end)
stua_key4(return,continue,as,repeat) stua_key4(_frame,catch,catch,catch)
ST_shl, "<<", ST_and, "&&", ST_eq, "==", ST_ge, ">=",
ST_shr, ">>", ST_or , "||", ST_ne, "!=", ST_le, "<=",
ST_shru,">>>", ST_into, "=>",
T__none, ".",
};
typedef struct
{
stua_obj *data; // constants being compiled
short *code; // code being compiled
stua_dict *locals;
short *non_local_refs;
} stu__comp_func;
static stu__comp_func stu__pfunc;
static stu__comp_func *func_stack = NULL;
static void stu__push_func_comp(void)
{
stb_arr_push(func_stack, stu__pfunc);
stu__pfunc.data = NULL;
stu__pfunc.code = NULL;
stu__pfunc.locals = stb_idict_new_size(16);
stu__pfunc.non_local_refs = NULL;
stb_arr_push(stu__pfunc.code, 0); // number of data items
stb_arr_push(stu__pfunc.code, 1); // starting execution address
}
static void stu__pop_func_comp(void)
{
stb_arr_free(stu__pfunc.code);
stb_arr_free(stu__pfunc.data);
stb_idict_destroy(stu__pfunc.locals);
stb_arr_free(stu__pfunc.non_local_refs);
stu__pfunc = stb_arr_pop(func_stack);
}
// if an id is a reference to an outer lexical scope, this
// function returns the "name" of it, and updates the stack
// structures to make sure the names are propogated in.
static int stu__nonlocal_id(stua_obj var_obj)
{
stua_obj dummy, var = var_obj;
int i, n = stb_arr_len(func_stack), j,k;
if (stb_idict_get_flag(stu__pfunc.locals, var, &dummy)) return 0;
for (i=n-1; i > 1; --i) {
if (stb_idict_get_flag(func_stack[i].locals, var, &dummy))
break;
}
if (i <= 1) return 0; // stu__compile_global_scope
j = i; // need to access variable from j'th frame
for (i=0; i < stb_arr_len(stu__pfunc.non_local_refs); ++i)
if (stu__pfunc.non_local_refs[i] == j) return j-n;
stb_arr_push(stu__pfunc.non_local_refs, j-n);
// now make sure all the parents propogate it down
for (k=n-1; k > 1; --k) {
if (j-k >= 0) return j-n; // comes direct from this parent
for(i=0; i < stb_arr_len(func_stack[k].non_local_refs); ++i)
if (func_stack[k].non_local_refs[i] == j-k)
return j-n;
stb_arr_push(func_stack[k].non_local_refs, j-k);
}
assert (k != 1);
return j-n;
}
static int stu__off(void) { return stb_arr_len(stu__pfunc.code); }
static void stu__cc(int a)
{
assert(a >= -2000 && a < 5000);
stb_arr_push(stu__pfunc.code, a);
}
static int stu__cc1(int a) { stu__cc(a); return stu__off()-1; }
static int stu__cc2(int a, int b) { stu__cc(a); stu__cc(b); return stu__off()-2; }
static int stu__cc3(int a, int b, int c) {
if (a == '=') assert(c != 0);
stu__cc(a); stu__cc(b); stu__cc(c); return stu__off()-3; }
static int stu__cc4(int a, int b, int c, int d) { stu__cc(a); stu__cc(b); stu__cc(c); stu__cc(d); return stu__off()-4; }
static int stu__cdv(stua_obj p)
{
int i;
assert(p != STUA_NO_VALUE);
for (i=0; i < stb_arr_len(stu__pfunc.data); ++i)
if (stu__pfunc.data[i] == p)
break;
if (i == stb_arr_len(stu__pfunc.data))
stb_arr_push(stu__pfunc.data, p);
return ~i;
}
static int stu__cdt(void)
{
int z = stu__cdv(stu__tokval);
stu__nexttoken();
return z;
}
static int stu__seq(int a, int b)
{
return !a ? b : !b ? a : stu__cc3(STU__seq, a,b);
}
static char stu__comp_err_str[1024];
static int stu__comp_err_line;
static int stu__err(char *str, ...)
{
va_list v;
char *s = stu__bufstart;
stu__comp_err_line = 1;
while (s < stu__curbuf) {
if (s[0] == '\n' || s[0] == '\r') {
if (s[0]+s[1] == '\n' + '\r') ++s;
++stu__comp_err_line;
}
++s;
}
va_start(v, str);
vsprintf(stu__comp_err_str, str, v);
va_end(v);
return 0;
}
static int stu__accept(int p)
{
if (stu__tok != p) return 0;
stu__nexttoken();
return 1;
}
static int stu__demand(int p)
{
if (stu__accept(p)) return 1;
return stu__err("Didn't find expected stu__tok");
}
static int stu__demandv(int p, stua_obj *val)
{
if (stu__tok == p || p==0) {
*val = stu__tokval;
stu__nexttoken();
return 1;
} else
return 0;
}
static int stu__expr(int p);
int stu__nexpr(int p) { stu__nexttoken(); return stu__expr(p); }
static int stu__statements(int once, int as);
static int stu__parse_if(void) // parse both ST_if and ST_elseif
{
int b,c,a;
a = stu__nexpr(1); if (!a) return 0;
if (!stu__demand(ST_then)) return stu__err("expecting THEN");
b = stu__statements(0,0); if (!b) return 0;
if (b == 1) b = -1;
if (stu__tok == ST_elseif) {
return stu__parse_if();
} else if (stu__accept(ST_else)) {
c = stu__statements(0,0); if (!c) return 0;
if (!stu__demand(ST_end)) return stu__err("expecting END after else clause");
return stu__cc4(ST_else, a, b, c);
} else {
if (!stu__demand(ST_end)) return stu__err("expecting END in if statement");
return stu__cc3(ST_if, a, b);
}
}
int stu__varinit(int z, int in_globals)
{
int a,b;
stu__nexttoken();
while (stu__demandv(ST_id, &b)) {
if (!stb_idict_add(stu__pfunc.locals, b, 1))
if (!in_globals) return stu__err("Redefined variable %s.", stu__pw(b)->ptr);
if (stu__accept('=')) {
a = stu__expr(1); if (!a) return 0;
} else
a = stu__cdv(stua_nil);
z = stu__seq(z, stu__cc3(ST_var, stu__cdv(b), a));
if (!stu__accept(',')) break;
}
return z;
}
static int stu__compile_unary(int z, int outparm, int require_inparm)
{
int op = stu__tok, a, b;
stu__nexttoken();
if (outparm) {
if (require_inparm || (stu__tok && stu__tok != ST_end && stu__tok != ST_else && stu__tok != ST_elseif && stu__tok !=';')) {
a = stu__expr(1); if (!a) return 0;
} else
a = stu__cdv(stua_nil);
b = stu__cc2(op, a);
} else
b = stu__cc1(op);
return stu__seq(z,b);
}
static int stu__assign(void)
{
int z;
stu__accept(ST_let);
z = stu__expr(1); if (!z) return 0;
if (stu__accept('=')) {
int y,p = (z >= 0 ? stu__pfunc.code[z] : 0);
if (z < 0 || (p != ST_id && p != '[')) return stu__err("Invalid lvalue in assignment");
y = stu__assign(); if (!y) return 0;
z = stu__cc3('=', z, y);
}
return z;
}
static int stu__statements(int once, int stop_while)
{
int a,b, c, z=0;
for(;;) {
switch (stu__tok) {
case ST_if : a = stu__parse_if(); if (!a) return 0;
z = stu__seq(z, a);
break;
case ST_while : if (stop_while) return (z ? z:1);
a = stu__nexpr(1); if (!a) return 0;
if (stu__accept(ST_as)) c = stu__statements(0,0); else c = 0;
if (!stu__demand(ST_do)) return stu__err("expecting DO");
b = stu__statements(0,0); if (!b) return 0;
if (!stu__demand(ST_end)) return stu__err("expecting END");
if (b == 1) b = -1;
z = stu__seq(z, stu__cc4(ST_while, a, b, c));
break;
case ST_repeat : stu__nexttoken();
c = stu__statements(0,1); if (!c) return 0;
if (!stu__demand(ST_while)) return stu__err("expecting WHILE");
a = stu__expr(1); if (!a) return 0;
if (!stu__demand(ST_do)) return stu__err("expecting DO");
b = stu__statements(0,0); if (!b) return 0;
if (!stu__demand(ST_end)) return stu__err("expecting END");
if (b == 1) b = -1;
z = stu__seq(z, stu__cc4(ST_as, a, b, c));
break;
case ST_catch : a = stu__nexpr(1); if (!a) return 0;
z = stu__seq(z, stu__cc2(ST_catch, a));
break;
case ST_var : z = stu__varinit(z,0); break;
case ST_return : z = stu__compile_unary(z,1,1); break;
case ST_continue:z = stu__compile_unary(z,0,0); break;
case ST_break : z = stu__compile_unary(z,1,0); break;
case ST_into : if (z == 0 && !once) return stu__err("=> cannot be first statement in block");
a = stu__nexpr(99);
b = (a >= 0? stu__pfunc.code[a] : 0);
if (a < 0 || (b != ST_id && b != '[')) return stu__err("Invalid lvalue on right side of =>");
z = stu__cc3('=', a, z);
break;
default : if (stu__end[stu__tok]) return once ? 0 : (z ? z:1);
a = stu__assign(); if (!a) return 0;
stu__accept(';');
if (stu__tok && !stu__end[stu__tok]) {
if (a < 0)
return stu__err("Constant has no effect");
if (stu__pfunc.code[a] != '(' && stu__pfunc.code[a] != '=')
return stu__err("Expression has no effect");
}
z = stu__seq(z, a);
break;
}
if (!z) return 0;
stu__accept(';');
if (once && stu__tok != ST_into) return z;
}
}
static int stu__postexpr(int z, int p);
static int stu__dictdef(int end, int *count)
{
int z,n=0,i,flags=0;
short *dict=NULL;
stu__nexttoken();
while (stu__tok != end) {
if (stu__tok == ST_id) {
stua_obj id = stu__tokval;
stu__nexttoken();
if (stu__tok == '=') {
flags |= 1;
stb_arr_push(dict, stu__cdv(id));
z = stu__nexpr(1); if (!z) return 0;
} else {
z = stu__cc2(ST_id, stu__cdv(id));
z = stu__postexpr(z,1); if (!z) return 0;
flags |= 2;
stb_arr_push(dict, stu__cdv(stu__makeint(n++)));
}
} else {
z = stu__expr(1); if (!z) return 0;
flags |= 2;
stb_arr_push(dict, stu__cdv(stu__makeint(n++)));
}
if (end != ')' && flags == 3) { z=stu__err("can't mix initialized and uninitialized defs"); goto done;}
stb_arr_push(dict, z);
if (!stu__accept(',')) break;
}
if (!stu__demand(end))
return stu__err(end == ')' ? "Expecting ) at end of function call"
: "Expecting } at end of dictionary definition");
z = stu__cc2('{', stb_arr_len(dict)/2);
for (i=0; i < stb_arr_len(dict); ++i)
stu__cc(dict[i]);
if (count) *count = n;
done:
stb_arr_free(dict);
return z;
}
static int stu__comp_id(void)
{
int z,d;
d = stu__nonlocal_id(stu__tokval);
if (d == 0)
return z = stu__cc2(ST_id, stu__cdt());
// access a non-local frame by naming it with the appropriate int
assert(d < 0);
z = stu__cdv(d); // relative frame # is the 'variable' in our local frame
z = stu__cc2(ST_id, z); // now access that dictionary
return stu__cc3('[', z, stu__cdt()); // now access the variable from that dir
}
static stua_obj stu__funcdef(stua_obj *id, stua_obj *func);
static int stu__expr(int p)
{
int z;
// unary
switch (stu__tok) {
case ST_number: z = stu__cdt(); break;
case ST_string: z = stu__cdt(); break; // @TODO - string concatenation like C
case ST_id : z = stu__comp_id(); break;
case ST__frame: z = stu__cc1(ST__frame); stu__nexttoken(); break;
case ST_func : z = stu__funcdef(NULL,NULL); break;
case ST_if : z = stu__parse_if(); break;
case ST_nil : z = stu__cdv(stua_nil); stu__nexttoken(); break;
case ST_true : z = stu__cdv(stua_true); stu__nexttoken(); break;
case ST_false : z = stu__cdv(stua_false); stu__nexttoken(); break;
case '-' : z = stu__nexpr(99); if (z) z=stu__cc2(STU__negate,z); else return z; break;
case '!' : z = stu__nexpr(99); if (z) z=stu__cc2('!',z); else return z; break;
case '~' : z = stu__nexpr(99); if (z) z=stu__cc2('~',z); else return z; break;
case '{' : z = stu__dictdef('}', NULL); break;
default : return stu__err("Unexpected token");
case '(' : stu__nexttoken(); z = stu__statements(0,0); if (!stu__demand(')')) return stu__err("Expecting )");
}
return stu__postexpr(z,p);
}
static int stu__postexpr(int z, int p)
{
int q;
// postfix
while (stu__tok == '(' || stu__tok == '[' || stu__tok == '.') {
if (stu__accept('.')) {
// MUST be followed by a plain identifier! use [] for other stuff
if (stu__tok != ST_id) return stu__err("Must follow . with plain name; try [] instead");
z = stu__cc3('[', z, stu__cdv(stu__tokval));
stu__nexttoken();
} else if (stu__accept('[')) {
while (stu__tok != ']') {
int r = stu__expr(1); if (!r) return 0;
z = stu__cc3('[', z, r);
if (!stu__accept(',')) break;
}
if (!stu__demand(']')) return stu__err("Expecting ]");
} else {
int n, p = stu__dictdef(')', &n); if (!p) return 0;
#if 0 // this is incorrect!
if (z > 0 && stu__pfunc.code[z] == ST_id) {
stua_obj q = stu__get(stu__globaldict, stu__pfunc.data[-stu__pfunc.code[z+1]-1], stua_nil);
if (stu__checkt(STU___function, q))
if ((stu__pf(q))->num_param != n)
return stu__err("Incorrect number of parameters");
}
#endif
z = stu__cc3('(', z, p);
}
}
// binop - this implementation taken from lcc
for (q=stu__prec[stu__tok]; q >= p; --q) {
while (stu__prec[stu__tok] == q) {
int o = stu__tok, y = stu__nexpr(p+1); if (!y) return 0;
z = stu__cc3(o,z,y);
}
}
return z;
}
static stua_obj stu__finish_func(stua_obj *param, int start)
{
int n, size;
stu__func *f = (stu__func *) malloc(sizeof(*f));
f->closure_source = 0;
f->num_param = stb_arr_len(param);
f->param = (int *) stb_copy(param, f->num_param * sizeof(*f->param));
size = stb_arr_storage(stu__pfunc.code) + stb_arr_storage(stu__pfunc.data) + sizeof(*f) + 8;
f->f.store = malloc(stb_arr_storage(stu__pfunc.code) + stb_arr_storage(stu__pfunc.data));
f->code = (short *) ((char *) f->f.store + stb_arr_storage(stu__pfunc.data));
memcpy(f->code, stu__pfunc.code, stb_arr_storage(stu__pfunc.code));
f->code[1] = start;
f->code[0] = stb_arr_len(stu__pfunc.data);
for (n=0; n < f->code[0]; ++n)
((stua_obj *) f->code)[-1-n] = stu__pfunc.data[n];
return stu__makeobj(STU___function, f, size, 0);
}
static int stu__funcdef(stua_obj *id, stua_obj *result)
{
int n,z=0,i,q;
stua_obj *param = NULL;
short *nonlocal;
stua_obj v,f=stua_nil;
assert(stu__tok == ST_func);
stu__nexttoken();
if (id) {
if (!stu__demandv(ST_id, id)) return stu__err("Expecting function name");
} else
stu__accept(ST_id);
if (!stu__demand('(')) return stu__err("Expecting ( for function parameter");
stu__push_func_comp();
while (stu__tok != ')') {
if (!stu__demandv(ST_id, &v)) { z=stu__err("Expecting parameter name"); goto done; }
stb_idict_add(stu__pfunc.locals, v, 1);
if (stu__tok == '=') {
n = stu__nexpr(1); if (!n) { z=0; goto done; }
z = stu__seq(z, stu__cc3(STU__defaultparm, stu__cdv(v), n));
} else
stb_arr_push(param, v);
if (!stu__accept(',')) break;
}
if (!stu__demand(')')) { z=stu__err("Expecting ) at end of parameter list"); goto done; }
n = stu__statements(0,0); if (!n) { z=0; goto done; }
if (!stu__demand(ST_end)) { z=stu__err("Expecting END at end of function"); goto done; }
if (n == 1) n = 0;
n = stu__seq(z,n);
f = stu__finish_func(param, n);
if (result) { *result = f; z=1; stu__pop_func_comp(); }
else {
nonlocal = stu__pfunc.non_local_refs;
stu__pfunc.non_local_refs = NULL;
stu__pop_func_comp();
z = stu__cdv(f);
if (nonlocal) { // build a closure with references to the needed frames
short *initcode = NULL;
for (i=0; i < stb_arr_len(nonlocal); ++i) {
int k = nonlocal[i], p;
stb_arr_push(initcode, stu__cdv(k));
if (k == -1) p = stu__cc1(ST__frame);
else { p = stu__cdv(stu__makeint(k+1)); p = stu__cc2(ST_id, p); }
stb_arr_push(initcode, p);
}
q = stu__cc2('{', stb_arr_len(nonlocal));
for (i=0; i < stb_arr_len(initcode); ++i)
stu__cc(initcode[i]);
z = stu__cc3('+', z, q);
stb_arr_free(initcode);
}
stb_arr_free(nonlocal);
}
done:
stb_arr_free(param);
if (!z) stu__pop_func_comp();
return z;
}
static int stu__compile_global_scope(void)
{
stua_obj o;
int z=0;
stu__push_func_comp();
while (stu__tok != 0) {
if (stu__tok == ST_func) {
stua_obj id, f;
if (!stu__funcdef(&id,&f))
goto error;
stu__set(stu__globaldict, id, f);
} else if (stu__tok == ST_var) {
z = stu__varinit(z,1); if (!z) goto error;
} else {
int y = stu__statements(1,0); if (!y) goto error;
z = stu__seq(z,y);
}
stu__accept(';');
}
o = stu__finish_func(NULL, z);
stu__pop_func_comp();
o = stu__funceval(o, stua_globals); // initialize stu__globaldict
if (stu__flow == FLOW_error)
printf("Error: %s\n", ((stu__wrapper *) stu__ptr(stu__flow_val))->ptr);
return 1;
error:
stu__pop_func_comp();
return 0;
}
stua_obj stu__myprint(stua_dict *context)
{
stua_obj x = stu__get(context, stua_string("x"), stua_nil);
if ((x & 1) == stu__float_tag) printf("%f", stu__getfloat(x));
else if (stu__tag(x) == stu__int_tag) printf("%d", stu__int(x));
else {
stu__wrapper *s = stu__pw(x);
if (s->type == STU___string || s->type == STU___error)
printf("%s", s->ptr);
else if (s->type == STU___dict) printf("{{dictionary}}");
else if (s->type == STU___function) printf("[[function]]");
else
printf("[[ERROR:%s]]", s->ptr);
}
return x;
}
void stua_init(void)
{
if (!stu__globaldict) {
int i;
stua_obj s;
stu__func *f;
stu__prec[ST_and] = stu__prec[ST_or] = 1;
stu__prec[ST_eq ] = stu__prec[ST_ne] = stu__prec[ST_le] =
stu__prec[ST_ge] = stu__prec['>' ] = stu__prec['<'] = 2;
stu__prec[':'] = 3;
stu__prec['&'] = stu__prec['|'] = stu__prec['^'] = 4;
stu__prec['+'] = stu__prec['-'] = 5;
stu__prec['*'] = stu__prec['/'] = stu__prec['%'] =
stu__prec[ST_shl]= stu__prec[ST_shr]= stu__prec[ST_shru]= 6;
stu__end[')'] = stu__end[ST_end] = stu__end[ST_else] = 1;
stu__end[ST_do] = stu__end[ST_elseif] = 1;
stu__float_init();
stu__lex_matcher = stb_lex_matcher();
for (i=0; i < sizeof(stu__lexemes)/sizeof(stu__lexemes[0]); ++i)
stb_lex_item(stu__lex_matcher, stu__lexemes[i].regex, stu__lexemes[i].stu__tok);
stu__globaldict = stb_idict_new_size(64);
stua_globals = stu__makeobj(STU___dict, stu__globaldict, 0,0);
stu__strings = stb_sdict_new(0);
stu__curbuf = stu__bufstart = "func _print(x) end\n"
"func print()\n var x=0 while _frame[x] != nil as x=x+1 do _print(_frame[x]) end end\n";
stu__nexttoken();
if (!stu__compile_global_scope())
printf("Compile error in line %d: %s\n", stu__comp_err_line, stu__comp_err_str);
s = stu__get(stu__globaldict, stua_string("_print"), stua_nil);
if (stu__tag(s) == stu__ptr_tag && stu__ptr(s)->type == STU___function) {
f = stu__pf(s);
free(f->f.store);
f->closure_source = 4;
f->f.func = stu__myprint;
f->code = NULL;
}
}
}
void stua_uninit(void)
{
if (stu__globaldict) {
stb_idict_remove_all(stu__globaldict);
stb_arr_setlen(stu__gc_root_stack, 0);
stua_gc(1);
stb_idict_destroy(stu__globaldict);
stb_sdict_delete(stu__strings);
stb_matcher_free(stu__lex_matcher);
stb_arr_free(stu__gc_ptrlist);
stb_arr_free(func_stack);
stb_arr_free(stu__gc_root_stack);
stu__globaldict = NULL;
}
}
void stua_run_script(char *s)
{
stua_init();
stu__curbuf = stu__bufstart = s;
stu__nexttoken();
stu__flow = FLOW_normal;
if (!stu__compile_global_scope())
printf("Compile error in line %d: %s\n", stu__comp_err_line, stu__comp_err_str);
stua_gc(1);
}
#endif // STB_DEFINE
#endif // STB_STUA
#undef STB_EXTERN
#endif // STB_INCLUDE_STB_H
/*
------------------------------------------------------------------------------
This software is available under 2 licenses -- choose whichever you prefer.
------------------------------------------------------------------------------
ALTERNATIVE A - MIT License
Copyright (c) 2017 Sean Barrett
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.
------------------------------------------------------------------------------
ALTERNATIVE B - Public Domain (www.unlicense.org)
This is free and unencumbered software released into the public domain.
Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
software, either in source code form or as a compiled binary, for any purpose,
commercial or non-commercial, and by any means.
In jurisdictions that recognize copyright laws, the author or authors of this
software dedicate any and all copyright interest in the software to the public
domain. We make this dedication for the benefit of the public at large and to
the detriment of our heirs and successors. We intend this dedication to be an
overt act of relinquishment in perpetuity of all present and future rights to
this software under copyright law.
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 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.
------------------------------------------------------------------------------
*/
Reference in New Issue View Git Blame Copy Permalink