Skip to content

Instantly share code, notes, and snippets.

@dwilliamson

dwilliamson/TinyCRT.h

Last active Apr 17, 2020
Embed
What would you like to do?
//
// TinyCRT, revamp and TinyWin support by Don Williamson, 2011
// Based on http://www.codeproject.com/KB/library/tlibc.aspx and LIBCTINY by Matt Pietrek
//
#pragma once
#ifdef USE_DEFAULT_CRT
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <stdarg.h>
#include <float.h>
#include <cctype>
#define srandom srand
#define snprintf _snprintf
#else
#if defined(__clcpp_parse__) || (TINYCRT_NODLL)
#define TINYCRT_API
#else
#ifdef TINYCRT_IMPL
#define TINYCRT_API __declspec(dllexport)
#else
#define TINYCRT_API __declspec(dllimport)
#endif
#endif
#define NULL 0
#define TCRT_RESTRICT __declspec(restrict)
#define TCRT_NOALIAS __declspec(noalias)
#define TCRT_INTRINSIC(fn) __pragma(intrinsic(fn))
#define TCRT_GLOBAL
#ifdef __clang__
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#define offsetof(type,member) __builtin_offsetof(type, member)
#else
#define offsetof(type,member) ((size_t) &(((type*)0)->member))
#endif
// ------------------------------------------------------------------------------------------------
// Standard types
// ------------------------------------------------------------------------------------------------
// stdint.h
typedef signed __int8 int8_t;
typedef signed __int16 int16_t;
typedef signed __int32 int32_t;
typedef signed __int64 int64_t;
typedef unsigned __int8 uint8_t;
typedef unsigned __int16 uint16_t;
typedef unsigned __int32 uint32_t;
typedef unsigned __int64 uint64_t;
// POSIX extensions
typedef unsigned char uchar_t;
typedef unsigned short ushort_t;
typedef unsigned int uint_t;
typedef unsigned long ulong_t;
// Wide types
typedef unsigned short wint_t;
typedef unsigned short wctype_t;
// The size of time_t is "unspecified" by the standard
// GCC defines it like this
typedef long int time_t;
#ifdef _WIN64
typedef unsigned __int64 size_t;
typedef signed __int64 intptr_t;
typedef unsigned __int64 uintptr_t;
typedef __int64 ptrdiff_t;
#else
typedef __w64 unsigned int size_t;
typedef signed int intptr_t;
typedef unsigned int uintptr_t;
typedef __w64 int ptrdiff_t;
#endif
// printf-style macros
#define PRIx8 "x" // uint8_t
#define PRIx16 "x" // uint16_t
#define PRIx32 "x" // uint32_t
#define PRIx64 "llx" // uint64_t
// For isinf that aren't really in C library anyway
#ifndef __cplusplus
typedef unsigned int bool;
#endif
#ifdef __cplusplus
extern "C"
{
#endif
// ------------------------------------------------------------------------------------------------
// C atexit shutdown
// ------------------------------------------------------------------------------------------------
typedef void(__cdecl *_PVFV)();
int __cdecl atexit(_PVFV func);
void exit(int code);
TINYCRT_API char** _get_argv();
// ------------------------------------------------------------------------------------------------
// File handling
// ------------------------------------------------------------------------------------------------
// File and seek constants
#define EOF (-1)
#define SEEK_CUR 1
#define SEEK_END 2
#define SEEK_SET 0
// stdin/stdio/stderr access macros
#ifndef _STDSTREAM_DEFINED
#define stdin (&__iob_func()[0])
#define stdout (&__iob_func()[1])
#define stderr (&__iob_func()[2])
#define _STDSTREAM_DEFINED
#endif
// The standard stdio.h FILE structure
#ifndef _FILE_DEFINED
struct _iobuf {
char *_ptr;
int _cnt;
char *_base;
int _flag;
int _file;
int _charbuf;
int _bufsiz;
char *_tmpfname;
};
typedef struct _iobuf FILE;
#define _FILE_DEFINED
#endif
// stdio.h file access functions
TINYCRT_API FILE* __iob_func();
TINYCRT_API FILE* fopen(const char* path, const char* attrs);
TINYCRT_API int fclose(FILE* fp);
TINYCRT_API int feof(FILE* fp);
TINYCRT_API int fprintf(FILE* fp, const char* format, ...);
TINYCRT_API int fseek(FILE* str, long offset, int origin);
TINYCRT_API long ftell(FILE* fp);
TINYCRT_API size_t fread(void* buffer, size_t size, size_t count, FILE* str);
TINYCRT_API size_t fwrite(const void* buffer, size_t size, size_t count, FILE* str);
TINYCRT_API char *fgets(char* str, int n, FILE* s);
TINYCRT_API int fgetc(FILE* s);
TINYCRT_API int fflush(FILE* fp);
// MSVC "safe" alternatives
TINYCRT_API int fopen_s(FILE** fp, const char* path, const char* attrs);
// Environment variable management
TINYCRT_API const char* getenv(const char* name);
TINYCRT_API void putenv(const char* name, const char* value);
// ------------------------------------------------------------------------------------------------
// Maths
// ------------------------------------------------------------------------------------------------
#define RAND_MAX ((1UL << 31) - 1)
#define DBL_DIG 15 /* # of decimal digits of precision */
#define DBL_EPSILON 2.2204460492503131e-016 /* smallest such that 1.0+DBL_EPSILON != 1.0 */
#define DBL_MANT_DIG 53 /* # of bits in mantissa */
#define DBL_MAX 1.7976931348623158e+308 /* max value */
#define DBL_MAX_10_EXP 308 /* max decimal exponent */
#define DBL_MAX_EXP 1024 /* max binary exponent */
#define DBL_MIN 2.2250738585072014e-308 /* min positive value */
#define DBL_MIN_10_EXP (-307) /* min decimal exponent */
#define DBL_MIN_EXP (-1021) /* min binary exponent */
#define DBL_MIN_10_UNIT 1e-307
#define _DBL_RADIX 2 /* exponent radix */
#define _DBL_ROUNDS 1 /* addition rounding: near */
#define FLT_DIG 6 /* # of decimal digits of precision */
#define FLT_EPSILON 1.192092896e-07F /* smallest such that 1.0+FLT_EPSILON != 1.0 */
#define FLT_GUARD 0
#define FLT_MANT_DIG 24 /* # of bits in mantissa */
#define FLT_MAX 3.402823466e+38F /* max value */
#define FLT_MAX_10_EXP 38 /* max decimal exponent */
#define FLT_MAX_EXP 128 /* max binary exponent */
#define FLT_MIN 1.175494351e-38F /* min positive value */
#define FLT_MIN_10_EXP (-37) /* min decimal exponent */
#define FLT_MIN_EXP (-125) /* min binary exponent */
#define FLT_NORMALIZE 0
#define FLT_RADIX 2 /* exponent radix */
#define FLT_ROUNDS 1 /* addition rounding: near */
#define FLT_MIN_10_UNIT 1e-37f
#define MB_LEN_MAX 5 /* max. # bytes in multibyte char */
#define SHRT_MIN (-32768) /* minimum (signed) short value */
#define SHRT_MAX 32767 /* maximum (signed) short value */
#define USHRT_MAX 0xffff /* maximum unsigned short value */
#define INT_MIN (-2147483647 - 1) /* minimum (signed) int value */
#define INT_MAX 2147483647 /* maximum (signed) int value */
#define UINT_MAX 0xffffffff /* maximum unsigned int value */
#define LONG_MIN (-2147483647L - 1) /* minimum (signed) long value */
#define LONG_MAX 2147483647L /* maximum (signed) long value */
#define ULONG_MAX 0xffffffffUL /* maximum unsigned long value */
#define LLONG_MAX 9223372036854775807i64 /* maximum signed long long int value */
#define LLONG_MIN (-9223372036854775807i64 - 1) /* minimum signed long long int value */
#define ULLONG_MAX 0xffffffffffffffffui64 /* maximum unsigned long long int value */
#define I16_MIN SHRT_MIN
#define I16_MAX SHRT_MAX
#define U16_MIN 0
#define U16_MAX USHRT_MAX
#define I32_MIN INT_MIN
#define I32_MAX INT_MAX
#define U32_MIN 0
#define U32_MAX UINT_MAX
TINYCRT_API int abs(int n);
TINYCRT_API long strtol(const char* str, char** endptr, int base);
TINYCRT_API long long strtoll(const char* str, char** endptr, int base);
TINYCRT_API long atol(const char *str);
TINYCRT_API int atoi(const char *str);
TINYCRT_API void srandom(unsigned long seed);
TINYCRT_API unsigned long rand();
TINYCRT_API double frexp(double value, int* eptr);
TINYCRT_API float frexpf(float value, int* eptr);
TINYCRT_API double ldexp(double x, int exp);
TINYCRT_API float ldexpf(float x, int exp);
TINYCRT_API double modf(double value, double* iptr);
TINYCRT_API float modff(float value, float* iptr);
TINYCRT_API double fmod(double x, double y);
TINYCRT_API float fmodf(float x, float y);
TINYCRT_API float floorf(float x);
TINYCRT_API float ceilf(float x);
TINYCRT_API double round(double x);
TINYCRT_API float roundf(float x);
TINYCRT_API double truncate(double x);
TINYCRT_API float truncatef(float x);
TINYCRT_API bool isinf(double value);
TINYCRT_API bool isinff(float value);
TINYCRT_API bool isnan(double value);
TINYCRT_API bool isnanf(float value);
TINYCRT_API double fabs(double val);
TINYCRT_API float fabsf(float val);
TINYCRT_API double sin(double angle);
TINYCRT_API float sinf(float angle);
TINYCRT_API double cos(double angle);
TINYCRT_API float cosf(float angle);
TINYCRT_API double tan(double angle);
TINYCRT_API float tanf(float angle);
TINYCRT_API double asin(double val);
TINYCRT_API float asinf(float val);
TINYCRT_API double acos(double val);
TINYCRT_API float acosf(float val);
TINYCRT_API double atan(double val);
TINYCRT_API float atanf(float val);
TINYCRT_API double atan2(double y, double x);
TINYCRT_API float atan2f(float y, float x);
float powf(float x, float y);
float expf(float x);
float sqrtf(float val);
TINYCRT_API int float_as_int(float f);
TINYCRT_API float int_as_float(int i);
TINYCRT_API uint32_t log2i(uint32_t x);
TINYCRT_API float logEf(float a);
TINYCRT_API float logf(float a, float b);
TINYCRT_API float log2f(float a);
TINYCRT_API float log10f(float a);
TINYCRT_API double cbrt(double val);
TINYCRT_API float cbrtf(float val);
TINYCRT_API int cbrti(int val);
// Visual C bit rotate functions
unsigned int _rotl(unsigned int value, int shift); TCRT_INTRINSIC(_rotl);
unsigned int _rotr(unsigned int value, int shift); TCRT_INTRINSIC(_rotr);
unsigned long _lrotl(unsigned long value, int shift); TCRT_INTRINSIC(_lrotl);
unsigned long _lrotr(unsigned long value, int shift); TCRT_INTRINSIC(_lrotr);
double floor(double x);
double ceil(double x);
double pow(double x, double y); TCRT_INTRINSIC(pow);
double exp(double x); TCRT_INTRINSIC(exp);
double sqrt(double val); TCRT_INTRINSIC(sqrt);
unsigned char _BitScanForward(unsigned long* Index, unsigned long Mask); TCRT_INTRINSIC(_BitScanForward);
__inline unsigned char bsf(unsigned long* Index, unsigned long Mask)
{
return _BitScanForward(Index, Mask);
}
// ------------------------------------------------------------------------------------------------
// Float/string conversion
// ------------------------------------------------------------------------------------------------
char* dtoa_simple(double value, char* dest, int size);
TINYCRT_API double strtod(const char* s00, char** se);
TINYCRT_API char* dtoa(double d, int mode, int ndigits, int* decpt, int* sign, char** rve);
TINYCRT_API void freedtoa(char *s);
// ------------------------------------------------------------------------------------------------
// Memory manipulation
// ------------------------------------------------------------------------------------------------
TINYCRT_API int __cdecl memcmp(const void *b1, const void *b2, size_t n);
TINYCRT_API void * __cdecl memmove(void *dst, const void *src, size_t count);
void* __cdecl memset(void *dst, int val, size_t size); TCRT_INTRINSIC(memset);
void* __cdecl memcpy(void *dst, const void *src, size_t size); TCRT_INTRINSIC(memcpy);
// ------------------------------------------------------------------------------------------------
// Variable argument support
// ------------------------------------------------------------------------------------------------
// Standard vaarg stack pointer
typedef char * va_list;
// Variable argument macros
#define _ADDRESSOF(v) ( &(v) )
#define _INTSIZEOF(n) ( (sizeof(n) + sizeof(int) - 1) & ~(sizeof(int) - 1) )
#define va_start(ap,v) ( ap = (va_list)_ADDRESSOF(v) + _INTSIZEOF(v) )
#define va_arg(ap,t) ( *(t *)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)) )
#define va_end(ap) ( ap = (va_list)0 )
// Variable argument formatted printing
TINYCRT_API int vsnprintf(char* dest, size_t n, const char* format, va_list args);
TINYCRT_API int vsprintf(char* dest, const char* format, va_list args); // UNSAFE
TINYCRT_API int _snprintf(char* dest, size_t n, const char* fmt, ...);
TINYCRT_API int sprintf_s(char* dest, size_t n, const char* fmt, ...);
TINYCRT_API int sprintf(char* buffer, const char* format, ...); // UNSAFE
TINYCRT_API int vprintf(const char* format, va_list args);
TINYCRT_API int printf(const char* format, ...);
// TODO: Prefix underscore is the MSVC version (snprintf is non-standard). Do the same for the others...
#define snprintf _snprintf
// Unimplemented
__inline int sscanf(const char* src, const char* format, ...)
{
return 0;
}
// ------------------------------------------------------------------------------------------------
// String manipulation
// ------------------------------------------------------------------------------------------------
TINYCRT_API int strcmp(const char *s1, const char *s2);
TINYCRT_API int strcmpi(const char *s1, const char *s2);
TINYCRT_API int stricmp(const char *s1, const char *s2);
TINYCRT_API int _stricmp(const char *s1, const char *s2);
TINYCRT_API int strncmp(const char *s1, const char *s2, size_t n);
TINYCRT_API int strnicmp(const char *s1, const char *s2, size_t n);
TINYCRT_API char* strcpy(char *dest, const char *src);
TINYCRT_API char *strncpy(char *dest, const char *src, size_t n);
TINYCRT_API size_t strlen(const char *str);
TINYCRT_API char *strchr(const char *str, int ch);
TINYCRT_API char *strrchr(const char *str, int ch);
TINYCRT_API char *strcat(char *dst, const char *src);
TINYCRT_API const char *strstr(const char *str, const char *substr);
TINYCRT_API char *_strupr(char *s);
TINYCRT_API char *_strlwr(char *s);
TINYCRT_API int toupper(int c);
TINYCRT_API int tolower(int c);
TINYCRT_API int isspace(int c);
TINYCRT_API int isupper(int c);
TINYCRT_API int islower(int c);
TINYCRT_API int isalpha(int c);
TINYCRT_API int isdigit(int c);
TINYCRT_API int isxdigit(int c);
TINYCRT_API int isalnum(int c);
TINYCRT_API int isprint(int c);
// ------------------------------------------------------------------------------------------------
// Sorting
// ------------------------------------------------------------------------------------------------
TINYCRT_API void qsort(void *a, size_t n, size_t es, int(*cmp)(const void *, const void *));
TINYCRT_API void qsort_r(void *a, size_t n, size_t es, int(*cmp)(void*, const void *, const void *));
// ------------------------------------------------------------------------------------------------
// Assert
// ------------------------------------------------------------------------------------------------
// Expressed as a macro so that the debugger breaks on the line of assertion
#define assert(expression) do { if (!(expression)) { pre_assert(#expression); __debugbreak(); post_assert(); } } while(0)
TINYCRT_API void set_assert_callback(void(*assert_callback)(const char*));
TINYCRT_API void pre_assert(const char* expression_text);
TINYCRT_API void post_assert(void);
TINYCRT_API void assert_fn(int expression);
// Very simple implementation
TINYCRT_API uint64_t time(uint64_t* timer);
#ifdef __cplusplus
}
#endif
#ifdef __cplusplus
// min/max/swap unwrapped by std
template <typename TYPE> inline TYPE min(TYPE a, TYPE b) { return a < b ? a : b; }
template <typename TYPE> inline TYPE max(TYPE a, TYPE b) { return a > b ? a : b; }
template <typename TYPE> inline void swap(TYPE& a, TYPE& b)
{
TYPE tmp;
tmp = a;
a = b;
b = tmp;
}
// Typed C++ wrappers around C stdlib functions
inline unsigned int abs(unsigned int val) { return val; }
inline float abs(float val) { return fabsf(val); }
inline double abs(double val) { return fabs(val); }
inline float fabs(float val) { return fabsf(val); }
inline float sin(float val) { return sinf(val); }
inline float cos(float val) { return cosf(val); }
inline float tan(float val) { return tanf(val); }
inline float asin(float val) { return asinf(val); }
inline float acos(float val) { return acosf(val); }
inline float atan(float val) { return atanf(val); }
inline float atan2(float y, float x) { return atan2f(y, x); }
inline int sqrt(int val) { return (int)sqrtf((float)val); }
inline unsigned int sqrt(unsigned int val) { return (unsigned int)sqrtf((float)val); }
inline float sqrt(float val) { return sqrtf(val); }
inline float floor(float val) { return floorf(val); }
inline float ceil(float val) { return ceilf(val); }
inline float pow(float x, float y) { return powf(x, y); }
inline float exp(float x) { return expf(x); }
inline float fmod(float x, float y) { return fmodf(x, y); }
// Custom implementation of C++ Standard Library list initialiser.
namespace std
{
template <typename Type>
class initializer_list
{
public:
#ifdef _MSC_VER
initializer_list(const Type* first, const Type* last)
: m_begin(first)
, m_end(last)
{
}
#else
initializer_list(const Type* first, size_t len)
: m_begin(first)
, m_end(first + len)
{
}
#endif
const Type* begin() const
{
return m_begin;
}
const Type* end() const
{
return m_end;
}
size_t size() const
{
return m_end - m_begin;
}
private:
const Type* m_begin = nullptr;
const Type* m_end = nullptr;
};
}
#endif
#endif // USE_DEFAULT_CRT
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
You can’t perform that action at this time.