mo7sen/evol-headers
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: mo7sen:map
Branches Tags
mo7sen:master mo7sen:map mo7sen:abandoned_changes mo7sen:types
..
compare: mo7sen:abandoned_changes
Branches Tags
mo7sen:master mo7sen:map mo7sen:abandoned_changes mo7sen:types

1 Commits
map ... abandoned_

Author SHA1 Message Date
Robear Selwans
d0ff4170be Added some abandoned changes to the typesystem 
Signed-off-by: Robear Selwans <robear.selwans@outlook.com>
 2022-02-06 15:55:03 +00:00
16 changed files with 302 additions and 766 deletions
Expand all files Collapse all files

12
README.md
View File

@@ -1,11 +1 @@
# evol headers # evol-headers
Project Initialization
```
meson setup --native-file=meson-native-clang --wipe build
```
Build:
```
meson compile -C build
```

2
buildfiles/ev_helpers.c
View File

@@ -1,2 +0,0 @@
#define EV_HELPERS_IMPLEMENTATION
#include "../ev_helpers.h"

4
defines.h
View File

@@ -78,10 +78,6 @@
# endif # endif
#endif #endif
#if !defined(EV_BUILDTYPE_DEBUG) && !defined(EV_BUILDTYPE_DEBUG_OPT) && !defined(EV_BUILDTYPE_RELEASE)
#define EV_BUILDTYPE_RELEASE 1
#endif
#ifndef EV_BUILDTYPE_DEBUG #ifndef EV_BUILDTYPE_DEBUG
# define EV_BUILDTYPE_DEBUG 0 # define EV_BUILDTYPE_DEBUG 0
#endif #endif

1
ev_hash.h
View File

@@ -44,6 +44,7 @@ static inline u64 rotl64 ( u64 x, i8 r )
#endif // EV_CC_MSVC #endif // EV_CC_MSVC
#include "ev_macros.h"
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Block read - if your platform needs to do endian-swapping or can only // Block read - if your platform needs to do endian-swapping or can only

47
ev_helpers.h
View File

@@ -1,47 +0,0 @@
/*!
* \file ev_helpers.h
*/
#ifndef EV_HELPERS_HEADER
#define EV_HELPERS_HEADER
#include "ev_macros.h"
#include "ev_str.h"
#if defined(EV_HELPERS_SHARED)
# if defined (EV_HELPERS_IMPL)
# define EV_HELPERS_API EV_EXPORT
# else
# define EV_HELPERS_API EV_IMPORT
# endif
#else
# define EV_HELPERS_API
#endif
EV_HELPERS_API evstring
evstring_readFile(
evstring filePath);
#ifdef EV_HELPERS_IMPLEMENTATION
#undef EV_HELPERS_IMPLEMENTATION
evstring
evstring_readFile(
evstring filePath)
{
FILE* f = fopen(filePath, "rb");
if(f == NULL) return EV_INVALID(evstring);
fseek(f, 0, SEEK_END);
u32 buflen = ftell(f);
fseek(f, 0, SEEK_SET);
evstring res = evstring_new("");
evstring_setLength(&res, buflen);
fread(res, 1, buflen, f);
fclose(f);
return res;
}
#endif
#endif

2
ev_internal.h
View File

@@ -14,11 +14,9 @@ typedef unsigned long long int u64;
typedef float f32; typedef float f32;
typedef double f64; typedef double f64;
#if !defined(__cplusplus) && __STDC_VERSION__ < 202311L
typedef _Bool bool; typedef _Bool bool;
#define true 1 #define true 1
#define false 0 #define false 0
#endif
#define i8_const(v) (i8){v} #define i8_const(v) (i8){v}
#define i16_const(v) (i16){v} #define i16_const(v) (i16){v}

208
ev_macros.h
View File

@@ -11,7 +11,6 @@
#define __EV_MACRO_IF_0_ELSE(...) __VA_ARGS__ #define __EV_MACRO_IF_0_ELSE(...) __VA_ARGS__
#define __EV_MACRO_SECOND(a,b,...) b #define __EV_MACRO_SECOND(a,b,...) b
#define __EV_MACRO_SECOND_INDIRECT() __EV_MACRO_SECOND
#define __EV_MACRO_IS_PROBE(...) __EV_MACRO_SECOND(__VA_ARGS__,0) #define __EV_MACRO_IS_PROBE(...) __EV_MACRO_SECOND(__VA_ARGS__,0)
#define __EV_MACRO_PROBE() ~,1 #define __EV_MACRO_PROBE() ~,1
@@ -20,9 +19,6 @@
#define __EV_MACRO_NOT_0 __EV_MACRO_PROBE() #define __EV_MACRO_NOT_0 __EV_MACRO_PROBE()
#define __EV_MACRO_BOOL(x) __EV_MACRO_NOT(__EV_MACRO_NOT(x)) #define __EV_MACRO_BOOL(x) __EV_MACRO_NOT(__EV_MACRO_NOT(x))
#define __EV_MACRO_NOP(...)
#define __EV_MACRO_NOP_INDIRECT() __EV_MACRO_NOP
// End Of: Internal Usage // End Of: Internal Usage
/*! /*!
@@ -53,13 +49,11 @@
# define EV_IMPORT __declspec(dllimport) # define EV_IMPORT __declspec(dllimport)
# define EV_UNUSED # define EV_UNUSED
# define EV_FORCEINLINE __forceinline # define EV_FORCEINLINE __forceinline
# define EV_ALIGN(x) __declspec(align(x))
#elif ( EV_CC_GCC || EV_CC_CLANG ) #elif ( EV_CC_GCC || EV_CC_CLANG )
# define EV_EXPORT __attribute__((visibility("default"))) # define EV_EXPORT __attribute__((visibility("default")))
# define EV_IMPORT # define EV_IMPORT
# define EV_UNUSED __attribute__((unused)) # define EV_UNUSED __attribute__((unused))
# define EV_FORCEINLINE inline __attribute__((always_inline)) # define EV_FORCEINLINE inline __attribute__((always_inline))
# define EV_ALIGN(x) __attribute__((aligned(x)))
# if ( EV_CC_GCC ) # if ( EV_CC_GCC )
# define EV_PRAGMA_CC_NAME GCC # define EV_PRAGMA_CC_NAME GCC
# define EV_WARNING_DISABLE_GCC(w) EV_PRAGMA(EV_PRAGMA_CC_NAME diagnostic ignored "-W"w) # define EV_WARNING_DISABLE_GCC(w) EV_PRAGMA(EV_PRAGMA_CC_NAME diagnostic ignored "-W"w)
@@ -104,7 +98,6 @@
* \brief Macro to get the size of a compile-time array. * \brief Macro to get the size of a compile-time array.
*/ */
#define EV_ARRSIZE(...) (sizeof(__VA_ARGS__)/sizeof((__VA_ARGS__)[0])) #define EV_ARRSIZE(...) (sizeof(__VA_ARGS__)/sizeof((__VA_ARGS__)[0]))
#define EV_ARRSIZE_LITERAL(...) EV_EXPAND(EV_DEFER(EV_VA_ARGS_NARG)(EV_FILTER_EMPTY(__VA_ARGS__)))
/*! /*!
* \brief Macro to concatenate two tokens together. * \brief Macro to concatenate two tokens together.
@@ -112,11 +105,6 @@
#define EV_CAT(a, ...) EV_CAT_IMPL(a, __VA_ARGS__) #define EV_CAT(a, ...) EV_CAT_IMPL(a, __VA_ARGS__)
#define EV_CAT_IMPL(a, ...) a##__VA_ARGS__ #define EV_CAT_IMPL(a, ...) a##__VA_ARGS__
/*!
* \brief Macro to concatenate multiple tokens together
*/
#define EV_CATN(...) EV_REDUCE(EV_CAT, __VA_ARGS__)
/*! /*!
* \brief Macro to wrap tokens in double quotations. (") * \brief Macro to wrap tokens in double quotations. (")
*/ */
@@ -148,27 +136,6 @@
#define EV_VA_ARGS_ARG_N(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, N, ...) N #define EV_VA_ARGS_ARG_N(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, N, ...) N
#define EV_VA_ARGS_RSEQ_N() 64, 63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 #define EV_VA_ARGS_RSEQ_N() 64, 63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0
#define EV_EVAL(...) __EV_INTERNAL_EVAL1(__EV_INTERNAL_EVAL1(__EV_INTERNAL_EVAL1(__EV_INTERNAL_EVAL1(__VA_ARGS__))))
#define __EV_INTERNAL_EVAL1(...) __EV_INTERNAL_EVAL2(__EV_INTERNAL_EVAL2(__EV_INTERNAL_EVAL2(__EV_INTERNAL_EVAL2(__VA_ARGS__))))
#define __EV_INTERNAL_EVAL2(...) __EV_INTERNAL_EVAL3(__EV_INTERNAL_EVAL3(__EV_INTERNAL_EVAL3(__EV_INTERNAL_EVAL3(__VA_ARGS__))))
#define __EV_INTERNAL_EVAL3(...) __EV_INTERNAL_EVAL4(__EV_INTERNAL_EVAL4(__EV_INTERNAL_EVAL4(__EV_INTERNAL_EVAL4(__VA_ARGS__))))
#define __EV_INTERNAL_EVAL4(...) __VA_ARGS__
// #define __EV_INTERNAL_EVAL4(...) __EV_INTERNAL_EVAL5(__EV_INTERNAL_EVAL5(__EV_INTERNAL_EVAL5(__EV_INTERNAL_EVAL5(__VA_ARGS__))))
// #define __EV_INTERNAL_EVAL5(...) __EV_INTERNAL_EVAL6(__EV_INTERNAL_EVAL6(__EV_INTERNAL_EVAL6(__EV_INTERNAL_EVAL6(__VA_ARGS__))))
// #define __EV_INTERNAL_EVAL6(...) __VA_ARGS__
#define EV_INDIRECT_OP_ELSE_NOP(OP_INDIRECT,...) \
EV_DEFER \
( \
EV_VA_OPT_ELSE(__VA_ARGS__) \
( \
OP_INDIRECT \
) \
( \
__EV_MACRO_NOP_INDIRECT \
) \
)()
/*! /*!
* \brief Similar functionality to `__VA_OPT__` * \brief Similar functionality to `__VA_OPT__`
* Used as follows: * Used as follows:
@@ -181,53 +148,142 @@
/*! /*!
* \brief Calls the passed macro for each element. * \brief Calls the passed macro for each element.
* \note Maximum number of elements to iterate over is 64 elements.
*/ */
#define EV_FOREACH(OP, ...) \ #define EV_FOREACH(OP, ...) EV_CAT(__EV_INTERNAL_FOREACH, EV_VA_ARGS_NARG(__VA_ARGS__))(OP, __VA_ARGS__)
EV_VA_OPT(__VA_ARGS__)(EV_EVAL(__EV_INTERNAL_FOREACH_IMPL(OP, __VA_ARGS__))) #define __EV_INTERNAL_FOREACH1( OP, a ) OP(a)
#define __EV_INTERNAL_FOREACH_IMPL(OP, a, ...) \ #define __EV_INTERNAL_FOREACH2( OP, a, ...) OP(a) __EV_INTERNAL_FOREACH1( OP, __VA_ARGS__)
OP(a) EV_INDIRECT_OP_ELSE_NOP(__EV_INTERNAL_FOREACH_IMPL_INDIRECT, __VA_ARGS__)(OP, __VA_ARGS__) #define __EV_INTERNAL_FOREACH3( OP, a, ...) OP(a) __EV_INTERNAL_FOREACH2( OP, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH_IMPL_INDIRECT() __EV_INTERNAL_FOREACH_IMPL #define __EV_INTERNAL_FOREACH4( OP, a, ...) OP(a) __EV_INTERNAL_FOREACH3( OP, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH5( OP, a, ...) OP(a) __EV_INTERNAL_FOREACH4( OP, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH6( OP, a, ...) OP(a) __EV_INTERNAL_FOREACH5( OP, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH7( OP, a, ...) OP(a) __EV_INTERNAL_FOREACH6( OP, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH8( OP, a, ...) OP(a) __EV_INTERNAL_FOREACH7( OP, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH9( OP, a, ...) OP(a) __EV_INTERNAL_FOREACH8( OP, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH10(OP, a, ...) OP(a) __EV_INTERNAL_FOREACH9( OP, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH11(OP, a, ...) OP(a) __EV_INTERNAL_FOREACH10(OP, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH12(OP, a, ...) OP(a) __EV_INTERNAL_FOREACH11(OP, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH13(OP, a, ...) OP(a) __EV_INTERNAL_FOREACH12(OP, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH14(OP, a, ...) OP(a) __EV_INTERNAL_FOREACH13(OP, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH15(OP, a, ...) OP(a) __EV_INTERNAL_FOREACH14(OP, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH16(OP, a, ...) OP(a) __EV_INTERNAL_FOREACH15(OP, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH17(OP, a, ...) OP(a) __EV_INTERNAL_FOREACH16(OP, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH18(OP, a, ...) OP(a) __EV_INTERNAL_FOREACH17(OP, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH19(OP, a, ...) OP(a) __EV_INTERNAL_FOREACH18(OP, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH20(OP, a, ...) OP(a) __EV_INTERNAL_FOREACH19(OP, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH21(OP, a, ...) OP(a) __EV_INTERNAL_FOREACH20(OP, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH22(OP, a, ...) OP(a) __EV_INTERNAL_FOREACH21(OP, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH23(OP, a, ...) OP(a) __EV_INTERNAL_FOREACH22(OP, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH24(OP, a, ...) OP(a) __EV_INTERNAL_FOREACH23(OP, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH25(OP, a, ...) OP(a) __EV_INTERNAL_FOREACH24(OP, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH26(OP, a, ...) OP(a) __EV_INTERNAL_FOREACH25(OP, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH27(OP, a, ...) OP(a) __EV_INTERNAL_FOREACH26(OP, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH28(OP, a, ...) OP(a) __EV_INTERNAL_FOREACH27(OP, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH29(OP, a, ...) OP(a) __EV_INTERNAL_FOREACH28(OP, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH30(OP, a, ...) OP(a) __EV_INTERNAL_FOREACH29(OP, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH31(OP, a, ...) OP(a) __EV_INTERNAL_FOREACH30(OP, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH32(OP, a, ...) OP(a) __EV_INTERNAL_FOREACH31(OP, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH33(OP, a, ...) OP(a) __EV_INTERNAL_FOREACH32(OP, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH34(OP, a, ...) OP(a) __EV_INTERNAL_FOREACH33(OP, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH35(OP, a, ...) OP(a) __EV_INTERNAL_FOREACH34(OP, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH36(OP, a, ...) OP(a) __EV_INTERNAL_FOREACH35(OP, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH37(OP, a, ...) OP(a) __EV_INTERNAL_FOREACH36(OP, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH38(OP, a, ...) OP(a) __EV_INTERNAL_FOREACH37(OP, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH39(OP, a, ...) OP(a) __EV_INTERNAL_FOREACH38(OP, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH40(OP, a, ...) OP(a) __EV_INTERNAL_FOREACH39(OP, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH41(OP, a, ...) OP(a) __EV_INTERNAL_FOREACH40(OP, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH42(OP, a, ...) OP(a) __EV_INTERNAL_FOREACH41(OP, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH43(OP, a, ...) OP(a) __EV_INTERNAL_FOREACH42(OP, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH44(OP, a, ...) OP(a) __EV_INTERNAL_FOREACH43(OP, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH45(OP, a, ...) OP(a) __EV_INTERNAL_FOREACH44(OP, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH46(OP, a, ...) OP(a) __EV_INTERNAL_FOREACH45(OP, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH47(OP, a, ...) OP(a) __EV_INTERNAL_FOREACH46(OP, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH48(OP, a, ...) OP(a) __EV_INTERNAL_FOREACH47(OP, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH49(OP, a, ...) OP(a) __EV_INTERNAL_FOREACH48(OP, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH50(OP, a, ...) OP(a) __EV_INTERNAL_FOREACH49(OP, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH51(OP, a, ...) OP(a) __EV_INTERNAL_FOREACH50(OP, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH52(OP, a, ...) OP(a) __EV_INTERNAL_FOREACH51(OP, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH53(OP, a, ...) OP(a) __EV_INTERNAL_FOREACH52(OP, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH54(OP, a, ...) OP(a) __EV_INTERNAL_FOREACH53(OP, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH55(OP, a, ...) OP(a) __EV_INTERNAL_FOREACH54(OP, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH56(OP, a, ...) OP(a) __EV_INTERNAL_FOREACH55(OP, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH57(OP, a, ...) OP(a) __EV_INTERNAL_FOREACH56(OP, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH58(OP, a, ...) OP(a) __EV_INTERNAL_FOREACH57(OP, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH59(OP, a, ...) OP(a) __EV_INTERNAL_FOREACH58(OP, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH60(OP, a, ...) OP(a) __EV_INTERNAL_FOREACH59(OP, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH61(OP, a, ...) OP(a) __EV_INTERNAL_FOREACH60(OP, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH62(OP, a, ...) OP(a) __EV_INTERNAL_FOREACH61(OP, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH63(OP, a, ...) OP(a) __EV_INTERNAL_FOREACH62(OP, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH64(OP, a, ...) OP(a) __EV_INTERNAL_FOREACH63(OP, __VA_ARGS__)
/*! /*!
* \brief Same as EV_FOREACH but allows passing a UDATA token * \brief Same as EV_FOREACH but allows passing a UDATA token
* \note Maximum number of elements to iterate over is 64 elements.
*/ */
#define EV_FOREACH_UDATA(OP, UDATA,...) \ #define EV_FOREACH_UDATA(OP, UDATA, ...) EV_CAT(EV_CAT(__EV_INTERNAL_FOREACH, EV_VA_ARGS_NARG(__VA_ARGS__)),_UDATA)(OP, UDATA, __VA_ARGS__)
EV_VA_OPT(__VA_ARGS__)(EV_EVAL(__EV_INTERNAL_FOREACH_UDATA_IMPL(OP, UDATA, __VA_ARGS__))) #define __EV_INTERNAL_FOREACH1_UDATA( OP, UDATA, a ) OP(UDATA, a)
#define __EV_INTERNAL_FOREACH_UDATA_IMPL(OP, UDATA, a, ...) \ #define __EV_INTERNAL_FOREACH2_UDATA( OP, UDATA, a, ...) OP(UDATA, a) __EV_INTERNAL_FOREACH1_UDATA( OP, UDATA, __VA_ARGS__)
OP(UDATA, a) EV_INDIRECT_OP_ELSE_NOP(__EV_INTERNAL_FOREACH_UDATA_IMPL_INDIRECT, __VA_ARGS__)(OP, UDATA, __VA_ARGS__) #define __EV_INTERNAL_FOREACH3_UDATA( OP, UDATA, a, ...) OP(UDATA, a) __EV_INTERNAL_FOREACH2_UDATA( OP, UDATA, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH_UDATA_IMPL_INDIRECT() __EV_INTERNAL_FOREACH_UDATA_IMPL #define __EV_INTERNAL_FOREACH4_UDATA( OP, UDATA, a, ...) OP(UDATA, a) __EV_INTERNAL_FOREACH3_UDATA( OP, UDATA, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH5_UDATA( OP, UDATA, a, ...) OP(UDATA, a) __EV_INTERNAL_FOREACH4_UDATA( OP, UDATA, __VA_ARGS__)
#define EV_JOIN(...) \ #define __EV_INTERNAL_FOREACH6_UDATA( OP, UDATA, a, ...) OP(UDATA, a) __EV_INTERNAL_FOREACH5_UDATA( OP, UDATA, __VA_ARGS__)
EV_JOIN_W_DELIM((,),__VA_ARGS__) #define __EV_INTERNAL_FOREACH7_UDATA( OP, UDATA, a, ...) OP(UDATA, a) __EV_INTERNAL_FOREACH6_UDATA( OP, UDATA, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH8_UDATA( OP, UDATA, a, ...) OP(UDATA, a) __EV_INTERNAL_FOREACH7_UDATA( OP, UDATA, __VA_ARGS__)
#define EV_JOIN_W_DELIM(delim, ...) \ #define __EV_INTERNAL_FOREACH9_UDATA( OP, UDATA, a, ...) OP(UDATA, a) __EV_INTERNAL_FOREACH8_UDATA( OP, UDATA, __VA_ARGS__)
EV_VA_OPT(__VA_ARGS__)(EV_EVAL(__EV_INTERNAL_JOIN_W_DELIM_IMPL(delim, __VA_ARGS__))) #define __EV_INTERNAL_FOREACH10_UDATA(OP, UDATA, a, ...) OP(UDATA, a) __EV_INTERNAL_FOREACH9_UDATA( OP, UDATA, __VA_ARGS__)
#define __EV_INTERNAL_JOIN_W_DELIM_IMPL(delim, a, ...) \ #define __EV_INTERNAL_FOREACH11_UDATA(OP, UDATA, a, ...) OP(UDATA, a) __EV_INTERNAL_FOREACH10_UDATA(OP, UDATA, __VA_ARGS__)
a EV_INDIRECT_OP_ELSE_NOP(EV_EXPAND delim __EV_INTERNAL_JOIN_W_DELIM_IMPL_INDIRECT, __VA_ARGS__)(delim, __VA_ARGS__) #define __EV_INTERNAL_FOREACH12_UDATA(OP, UDATA, a, ...) OP(UDATA, a) __EV_INTERNAL_FOREACH11_UDATA(OP, UDATA, __VA_ARGS__)
#define __EV_INTERNAL_JOIN_W_DELIM_IMPL_INDIRECT() __EV_INTERNAL_JOIN_W_DELIM_IMPL #define __EV_INTERNAL_FOREACH13_UDATA(OP, UDATA, a, ...) OP(UDATA, a) __EV_INTERNAL_FOREACH12_UDATA(OP, UDATA, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH14_UDATA(OP, UDATA, a, ...) OP(UDATA, a) __EV_INTERNAL_FOREACH13_UDATA(OP, UDATA, __VA_ARGS__)
#define DEFAULT_ZIP_OP(a, b) (a, b) #define __EV_INTERNAL_FOREACH15_UDATA(OP, UDATA, a, ...) OP(UDATA, a) __EV_INTERNAL_FOREACH14_UDATA(OP, UDATA, __VA_ARGS__)
#define EV_ZIP(list1, list2) \ #define __EV_INTERNAL_FOREACH16_UDATA(OP, UDATA, a, ...) OP(UDATA, a) __EV_INTERNAL_FOREACH15_UDATA(OP, UDATA, __VA_ARGS__)
EV_ZIP_W_OP(DEFAULT_ZIP_OP, list1, list2) #define __EV_INTERNAL_FOREACH17_UDATA(OP, UDATA, a, ...) OP(UDATA, a) __EV_INTERNAL_FOREACH16_UDATA(OP, UDATA, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH18_UDATA(OP, UDATA, a, ...) OP(UDATA, a) __EV_INTERNAL_FOREACH17_UDATA(OP, UDATA, __VA_ARGS__)
#define EV_ZIP_W_OP(OP, list1, list2) \ #define __EV_INTERNAL_FOREACH19_UDATA(OP, UDATA, a, ...) OP(UDATA, a) __EV_INTERNAL_FOREACH18_UDATA(OP, UDATA, __VA_ARGS__)
EV_VA_OPT(EV_EXPAND list1)(EV_EVAL(__EV_INTERNAL_ZIP_W_OP_IMPL(OP, list1, list2))) #define __EV_INTERNAL_FOREACH20_UDATA(OP, UDATA, a, ...) OP(UDATA, a) __EV_INTERNAL_FOREACH19_UDATA(OP, UDATA, __VA_ARGS__)
#define __EV_INTERNAL_ZIP_W_OP_IMPL(OP, list1, list2) \ #define __EV_INTERNAL_FOREACH21_UDATA(OP, UDATA, a, ...) OP(UDATA, a) __EV_INTERNAL_FOREACH20_UDATA(OP, UDATA, __VA_ARGS__)
OP(EV_HEAD list1, EV_HEAD list2) EV_INDIRECT_OP_ELSE_NOP(__EV_INTERNAL_ZIP_W_OP_IMPL_INDIRECT, EV_TAIL list1)(OP, (EV_TAIL list1), (EV_TAIL list2)) #define __EV_INTERNAL_FOREACH22_UDATA(OP, UDATA, a, ...) OP(UDATA, a) __EV_INTERNAL_FOREACH21_UDATA(OP, UDATA, __VA_ARGS__)
#define __EV_INTERNAL_ZIP_W_OP_IMPL_INDIRECT() , __EV_INTERNAL_ZIP_W_OP_IMPL #define __EV_INTERNAL_FOREACH23_UDATA(OP, UDATA, a, ...) OP(UDATA, a) __EV_INTERNAL_FOREACH22_UDATA(OP, UDATA, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH24_UDATA(OP, UDATA, a, ...) OP(UDATA, a) __EV_INTERNAL_FOREACH23_UDATA(OP, UDATA, __VA_ARGS__)
#define EV_REDUCE(OP, ...) \ #define __EV_INTERNAL_FOREACH25_UDATA(OP, UDATA, a, ...) OP(UDATA, a) __EV_INTERNAL_FOREACH24_UDATA(OP, UDATA, __VA_ARGS__)
EV_VA_OPT(__VA_ARGS__)(EV_EVAL(EV_INDIRECT_OP_ELSE_NOP(__EV_INTERNAL_REDUCE_IMPL_INDIRECT, __VA_ARGS__)(OP, EV_HEAD(__VA_ARGS__), EV_TAIL(__VA_ARGS__)))) #define __EV_INTERNAL_FOREACH26_UDATA(OP, UDATA, a, ...) OP(UDATA, a) __EV_INTERNAL_FOREACH25_UDATA(OP, UDATA, __VA_ARGS__)
#define __EV_INTERNAL_REDUCE_IMPL(OP, last, ...) \ #define __EV_INTERNAL_FOREACH27_UDATA(OP, UDATA, a, ...) OP(UDATA, a) __EV_INTERNAL_FOREACH26_UDATA(OP, UDATA, __VA_ARGS__)
EV_DEFER(EV_VA_OPT_ELSE(__VA_ARGS__)(__EV_INTERNAL_REDUCE_IMPL_INDIRECT)(__EV_MACRO_SECOND_INDIRECT))()(OP, EV_VA_OPT_ELSE(__VA_ARGS__)(OP(last, EV_HEAD(__VA_ARGS__)))(last) EV_VA_OPT(__VA_ARGS__)(,EV_TAIL(__VA_ARGS__))) #define __EV_INTERNAL_FOREACH28_UDATA(OP, UDATA, a, ...) OP(UDATA, a) __EV_INTERNAL_FOREACH27_UDATA(OP, UDATA, __VA_ARGS__)
#define __EV_INTERNAL_REDUCE_IMPL_INDIRECT() __EV_INTERNAL_REDUCE_IMPL #define __EV_INTERNAL_FOREACH29_UDATA(OP, UDATA, a, ...) OP(UDATA, a) __EV_INTERNAL_FOREACH28_UDATA(OP, UDATA, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH30_UDATA(OP, UDATA, a, ...) OP(UDATA, a) __EV_INTERNAL_FOREACH29_UDATA(OP, UDATA, __VA_ARGS__)
/*! #define __EV_INTERNAL_FOREACH31_UDATA(OP, UDATA, a, ...) OP(UDATA, a) __EV_INTERNAL_FOREACH30_UDATA(OP, UDATA, __VA_ARGS__)
* \brief Macro to get a the hex value of a 4-number as a character #define __EV_INTERNAL_FOREACH32_UDATA(OP, UDATA, a, ...) OP(UDATA, a) __EV_INTERNAL_FOREACH31_UDATA(OP, UDATA, __VA_ARGS__)
*/ #define __EV_INTERNAL_FOREACH33_UDATA(OP, UDATA, a, ...) OP(UDATA, a) __EV_INTERNAL_FOREACH32_UDATA(OP, UDATA, __VA_ARGS__)
#define EV_TOHEX_CHAR(c) (("0123456789abcdef")[c]) #define __EV_INTERNAL_FOREACH34_UDATA(OP, UDATA, a, ...) OP(UDATA, a) __EV_INTERNAL_FOREACH33_UDATA(OP, UDATA, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH35_UDATA(OP, UDATA, a, ...) OP(UDATA, a) __EV_INTERNAL_FOREACH34_UDATA(OP, UDATA, __VA_ARGS__)
#define __EV_FILTER_EMPTY_OP(x) EV_VA_OPT_ELSE(x)(,x)() #define __EV_INTERNAL_FOREACH36_UDATA(OP, UDATA, a, ...) OP(UDATA, a) __EV_INTERNAL_FOREACH35_UDATA(OP, UDATA, __VA_ARGS__)
#define EV_FILTER_EMPTY(x,...) x EV_FOREACH(__EV_FILTER_EMPTY_OP, __VA_ARGS__) #define __EV_INTERNAL_FOREACH37_UDATA(OP, UDATA, a, ...) OP(UDATA, a) __EV_INTERNAL_FOREACH36_UDATA(OP, UDATA, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH38_UDATA(OP, UDATA, a, ...) OP(UDATA, a) __EV_INTERNAL_FOREACH37_UDATA(OP, UDATA, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH39_UDATA(OP, UDATA, a, ...) OP(UDATA, a) __EV_INTERNAL_FOREACH38_UDATA(OP, UDATA, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH40_UDATA(OP, UDATA, a, ...) OP(UDATA, a) __EV_INTERNAL_FOREACH39_UDATA(OP, UDATA, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH41_UDATA(OP, UDATA, a, ...) OP(UDATA, a) __EV_INTERNAL_FOREACH40_UDATA(OP, UDATA, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH42_UDATA(OP, UDATA, a, ...) OP(UDATA, a) __EV_INTERNAL_FOREACH41_UDATA(OP, UDATA, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH43_UDATA(OP, UDATA, a, ...) OP(UDATA, a) __EV_INTERNAL_FOREACH42_UDATA(OP, UDATA, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH44_UDATA(OP, UDATA, a, ...) OP(UDATA, a) __EV_INTERNAL_FOREACH43_UDATA(OP, UDATA, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH45_UDATA(OP, UDATA, a, ...) OP(UDATA, a) __EV_INTERNAL_FOREACH44_UDATA(OP, UDATA, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH46_UDATA(OP, UDATA, a, ...) OP(UDATA, a) __EV_INTERNAL_FOREACH45_UDATA(OP, UDATA, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH47_UDATA(OP, UDATA, a, ...) OP(UDATA, a) __EV_INTERNAL_FOREACH46_UDATA(OP, UDATA, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH48_UDATA(OP, UDATA, a, ...) OP(UDATA, a) __EV_INTERNAL_FOREACH47_UDATA(OP, UDATA, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH49_UDATA(OP, UDATA, a, ...) OP(UDATA, a) __EV_INTERNAL_FOREACH48_UDATA(OP, UDATA, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH50_UDATA(OP, UDATA, a, ...) OP(UDATA, a) __EV_INTERNAL_FOREACH49_UDATA(OP, UDATA, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH51_UDATA(OP, UDATA, a, ...) OP(UDATA, a) __EV_INTERNAL_FOREACH50_UDATA(OP, UDATA, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH52_UDATA(OP, UDATA, a, ...) OP(UDATA, a) __EV_INTERNAL_FOREACH51_UDATA(OP, UDATA, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH53_UDATA(OP, UDATA, a, ...) OP(UDATA, a) __EV_INTERNAL_FOREACH52_UDATA(OP, UDATA, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH54_UDATA(OP, UDATA, a, ...) OP(UDATA, a) __EV_INTERNAL_FOREACH53_UDATA(OP, UDATA, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH55_UDATA(OP, UDATA, a, ...) OP(UDATA, a) __EV_INTERNAL_FOREACH54_UDATA(OP, UDATA, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH56_UDATA(OP, UDATA, a, ...) OP(UDATA, a) __EV_INTERNAL_FOREACH55_UDATA(OP, UDATA, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH57_UDATA(OP, UDATA, a, ...) OP(UDATA, a) __EV_INTERNAL_FOREACH56_UDATA(OP, UDATA, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH58_UDATA(OP, UDATA, a, ...) OP(UDATA, a) __EV_INTERNAL_FOREACH57_UDATA(OP, UDATA, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH59_UDATA(OP, UDATA, a, ...) OP(UDATA, a) __EV_INTERNAL_FOREACH58_UDATA(OP, UDATA, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH60_UDATA(OP, UDATA, a, ...) OP(UDATA, a) __EV_INTERNAL_FOREACH59_UDATA(OP, UDATA, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH61_UDATA(OP, UDATA, a, ...) OP(UDATA, a) __EV_INTERNAL_FOREACH60_UDATA(OP, UDATA, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH62_UDATA(OP, UDATA, a, ...) OP(UDATA, a) __EV_INTERNAL_FOREACH61_UDATA(OP, UDATA, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH63_UDATA(OP, UDATA, a, ...) OP(UDATA, a) __EV_INTERNAL_FOREACH62_UDATA(OP, UDATA, __VA_ARGS__)
#define __EV_INTERNAL_FOREACH64_UDATA(OP, UDATA, a, ...) OP(UDATA, a) __EV_INTERNAL_FOREACH63_UDATA(OP, UDATA, __VA_ARGS__)
#endif // EV_HEADERS_MACROS_H #endif // EV_HEADERS_MACROS_H

248
ev_map.h
View File

@@ -1,248 +0,0 @@
/*!
* \file ev_map.h
*/
#ifndef EV_MAP_HEADER
#define EV_MAP_HEADER
#include "ev_internal.h"
#include "ev_types.h"
#include "ev_numeric.h"
#include "ev_vec.h"
#define EV_MAP_MAGIC (0x65765F6D61705F74)
#if defined(EV_MAP_SHARED)
# if defined (EV_MAP_IMPL)
# define EV_MAP_API EV_EXPORT
# else
# define EV_MAP_API EV_IMPORT
# endif
#else
# define EV_MAP_API
#endif
#ifndef EV_MAP_INIT_CAP
/*!
* \brief Initial capacity that is first reserved when a map is initialized
*/
#define EV_MAP_INIT_CAP 32
#endif
#ifndef EV_MAP_GROWTH_RATE
/*!
* \brief Rate at which a map grows whenever a resize is needed
*/
#define EV_MAP_GROWTH_RATE 3 / 2
#endif
typedef struct {
u64 _magic;
u64 length;
u64 capacity;
u64 seed;
EvTypeData keyTypeData;
EvTypeData valTypeData;
ev_vec_t keys;
ev_vec_t vals;
} ev_map_t;
typedef enum {
EV_MAP_ERR_NONE = 0,
EV_MAP_ERR_OOM = 1
} ev_map_error_t;
TYPEDATA_GEN(ev_map_error_t, DEFAULT(EV_MAP_ERR_NONE));
#if defined(EV_MAP_SHORTNAMES)
# define map_t ev_map_t
# define map_error_t ev_map_error_t
# define map(K,V) ev_map(K,V)
# define map_init ev_map_init
/* # define vec_iter_begin ev_vec_iter_begin */
/* # define vec_iter_end ev_vec_iter_end */
/* # define vec_iter_next ev_vec_iter_next */
/* # define vec_fini ev_vec_fini */
/* # define vec_push ev_vec_push */
/* # define vec_append ev_vec_append */
/* # define vec_last ev_vec_last */
/* # define vec_len ev_vec_len */
/* # define vec_capacity ev_vec_capacity */
/* # define vec_clear ev_vec_clear */
/* # define vec_setlen ev_vec_setlen */
/* # define vec_setcapacity ev_vec_setcapacity */
/* # define vec_grow ev_vec_grow */
#endif
/*!
* \brief For the sake of readability
* \details Sample usage:
* ```
* ev_map(int,int) v = ev_map_init(int,int);
* ```
*/
#define ev_map(K,V) struct { \
u64 _magic; \
u64 length; \
u64 capacity; \
u64 seed; \
EvTypeData keyTypeData; \
EvTypeData valTypeData; \
ev_vec(K) keys; \
ev_vec(V) vals; \
}
/*!
* \param typeData The EvTypeData for the element that the vector will contain
*
* \returns A vector object
*/
EV_MAP_API ev_map_t*
ev_map_init_impl(
EvTypeData keyTypeData,
EvTypeData valTypeData);
/*!
* \brief Syntactic sugar for `ev_map_init_impl()`
* \details Sample usage:
* ```
* ev_map_init(i32,i64); // ev_map_init_impl(TypeData(i32),TypeData(i64));
* ```
*/
#define ev_map_init(K,V) (void*)ev_map_init_impl(TypeData(K), TypeData(V))
/*!
* \brief Syntactic sugar for `ev_vec_push_impl()` that allows multiple pushed in the same statement.
* \details Sample usage:
* ```
* ev_vec_t v;
* i32 x = 1;
* i32 y = 2;
* ev_vec_push(&v, &x); // ev_vec_push_impl(&v, &x);
* ev_vec_push(&v, &x, &y); // ev_vec_push_impl(&v, &x); ev_vec_push_impl(&v, &y);
* ```
*
* *Note* This is possibly replaceable with a variadic function.
*/
#define ev_map_add(m, ...) \
EV_FOREACH_UDATA(__ev_map_internal_add, m, __VA_ARGS__);
#define __ev_map_internal_add(m, entry) ev_map_add_impl((ev_map_t*)m, EV_HEAD entry, EV_TAIL entry);
/*!
* \brief A function that destroys a vector object. If the element type has a
* destructor function, then this function is called on every element before
* all reserved memory is freed.
*
* *Note*: For stack-allocated vectors (`svec`), destructors are called for
* elements but no memory is freed.
*
* \param v A pointer to the vector that is being destroyed
*/
EV_MAP_API void
ev_map_fini(
ev_map_t* m);
EV_MAP_API void
ev_map_add_impl(
ev_map_t* m,
void* key,
void* val
);
/*!
* \brief Calls the free operation (if exists) on every entry, then sets
* the length to 0.
*
* \param v A pointer to the map object
*
* \returns 0 on success
*/
EV_MAP_API u32
ev_map_clear(
ev_map_t* m);
TYPEDATA_GEN(
ev_map_t,
INVALID(
._magic = ~0ULL
),
);
#define EV_MAP_IMPLEMENTATION
#ifdef EV_MAP_IMPLEMENTATION
#undef EV_MAP_IMPLEMENTATION
#ifdef EV_MAP_API_CHECK
#define EV_VEC_CHECK(x) do { x; } while (0)
#else
#define EV_MAP_CHECK(x)
#endif
#include <stdlib.h>
#include <string.h>
ev_map_t*
ev_map_init_impl(
EvTypeData keyTypeData,
EvTypeData valTypeData)
{
ev_map_t* m = malloc(sizeof(ev_map_t));
if(!m) return &EV_INVALID(ev_map_t);
m->_magic = EV_MAP_MAGIC;
m->keyTypeData = keyTypeData;
m->valTypeData = valTypeData;
m->keys = ev_vec_init_impl(keyTypeData, EV_DEFAULT(ev_vec_overrides_t));
m->vals = ev_vec_init_impl(valTypeData, EV_DEFAULT(ev_vec_overrides_t));
m->length = 0;
assert(ev_vec_capacity(&m->keys) == ev_vec_capacity(&m->vals));
m->capacity = ev_vec_capacity(&m->keys);
return m;
}
void
ev_map_fini(
ev_map_t* m)
{
ev_vec_fini(&m->keys);
ev_vec_fini(&m->vals);
free(m);
}
u64
_ev_map_hash(
ev_map_t* m,
void* key)
{
u64 clipMask = 0xFFFFFFFFFFFF;
if(m->keyTypeData.hash_fn != NULL)
return m->keyTypeData.hash_fn(key, m->seed) & clipMask;
return ev_hash_murmur3(key, m->keyTypeData.size, m->seed) & clipMask;
}
void
ev_map_add_impl(
ev_map_t* m,
void* key,
void* val)
{
u64 hash = _ev_map_hash(m, key);
}
u32
ev_map_clear(
ev_map_t* m)
{
m->length = 0;
return ev_vec_clear(m->keys) | ev_vec_clear(m->vals);
}
#endif
#endif

15
ev_str.h
View File

@@ -44,6 +44,7 @@
#endif #endif
typedef char *evstring; typedef char *evstring;
TYPEDATA_GEN(evstring);
typedef enum { typedef enum {
EV_STR_ERR_NONE = 0, EV_STR_ERR_NONE = 0,
@@ -192,16 +193,6 @@ evstring_findLastChar(
const evstring text, const evstring text,
const char c); const char c);
DEFINE_EQUAL_FUNCTION(evstring, Default)
{
return evstring_cmp(*(evstring*)self, *(evstring*)other) == 0;
}
TYPEDATA_GEN(evstring,
EQUAL(Default)
);
#if defined(EV_STR_IMPLEMENTATION) #if defined(EV_STR_IMPLEMENTATION)
#if EV_OS_WINDOWS #if EV_OS_WINDOWS
@@ -438,7 +429,7 @@ evstring_push_impl(
} }
memcpy((*s) + meta->length, data, sz); memcpy((*s) + meta->length, data, sz);
// printf("Memcpy: dst = (*s {%p}) + meta->length {%llu}, src = data {%p}, size = sz {%llu}\n", *s, meta->length, data, sz); printf("Memcpy: dst = (*s {%p}) + meta->length {%llu}, src = data {%p}, size = sz {%llu}\n", *s, meta->length, data, sz);
meta->length += sz; meta->length += sz;
(*s)[meta->length] = '\0'; (*s)[meta->length] = '\0';
@@ -615,7 +606,7 @@ evstring_pushFmt_v(
size_t old_len = evstring_getLength(*s); size_t old_len = evstring_getLength(*s);
evstring_error_t res = evstring_setLength(s, old_len + fmt_len); evstring_error_t res = evstring_setLength(s, old_len + fmt_len);
if(res == EV_STR_ERR_NONE) { if(res == EV_STR_ERR_NONE) {
int write_res = vsnprintf((*s) + old_len, fmt_len+1, fmt, args); int write_res = vsnprintf((*s) + old_len, fmt_len, fmt, args);
assert(write_res > 0); assert(write_res > 0);
assert(write_res == fmt_len); assert(write_res == fmt_len);
} }

156
ev_types.h
View File

@@ -8,10 +8,7 @@
typedef void(*ev_copy_fn)(void *dst, void *src); typedef void(*ev_copy_fn)(void *dst, void *src);
typedef void(*ev_free_fn)(void *self); typedef void(*ev_free_fn)(void *self);
typedef u64(*ev_hash_fn)(void *self, u64 seed); typedef u64(*ev_hash_fn)(void *self, u64 seed);
typedef bool(*ev_equal_fn)(void *self, void *other); typedef i32(*ev_cmp_fn)(void *self, void *other);
typedef void(*ev_tostr_fn)(void *self, char *out);
typedef u32(*ev_tostrlen_fn)();
typedef struct { typedef struct {
EV_DEBUG(const char *name;) EV_DEBUG(const char *name;)
@@ -22,108 +19,108 @@ typedef struct {
ev_copy_fn copy_fn; ev_copy_fn copy_fn;
ev_free_fn free_fn; ev_free_fn free_fn;
ev_hash_fn hash_fn; ev_hash_fn hash_fn;
ev_equal_fn equal_fn; ev_cmp_fn cmp_fn;
ev_tostr_fn tostr_fn;
ev_tostrlen_fn tostrlen_fn;
void *default_val; void *default_val;
void *invalid_val; void *invalid_val;
} EvTypeData; } EvTypeData;
#define COPY_FUNCTION(T,name) EV_CATN(EV_COPY_FUNCTION_,T,_,name) #define COPY_FUNCTION(T,name) EV_CAT(EV_CAT(EV_CAT(EV_COPY_FUNCTION_,T),_),name)
#define FREE_FUNCTION(T,name) EV_CATN(EV_FREE_FUNCTION_,T,_,name) #define FREE_FUNCTION(T,name) EV_CAT(EV_CAT(EV_CAT(EV_FREE_FUNCTION_,T),_),name)
#define HASH_FUNCTION(T,name) EV_CATN(EV_HASH_FUNCTION_,T,_,name) #define HASH_FUNCTION(T,name) EV_CAT(EV_CAT(EV_CAT(EV_HASH_FUNCTION_,T),_),name)
#define EQUAL_FUNCTION(T,name) EV_CATN(EV_EQUAL_FUNCTION_,T,_,name) #define CMP_FUNCTION(T,name) EV_CAT(EV_CAT(EV_CAT(EV_CMP_FUNCTION_ ,T),_),name)
#define TOSTR_FUNCTION(T,name) EV_CATN(EV_TOSTR_FUNCTION_,T,_,name)
#define TOSTRLEN_FUNCTION(T,name) EV_CATN(EV_TOSTRLEN_FUNCTION_,T,_,name)
#define DEFINE_COPY_FUNCTION(T,name) static inline void COPY_FUNCTION(T,name)(T *dst, T *src) #include <string.h>
#define DEFINE_DEFAULT_COPY_FUNCTION(T) \ #define DEFINE_COPY_FUNCTION(T,name) void COPY_FUNCTION(T,name)(T *dst, T *src)
DEFINE_COPY_FUNCTION(T,DEFAULT) { *dst = *src; } #define DEFINE_DEFAULT_INTERNAL_COPY_FUNCTION(T) \
static inline DEFINE_COPY_FUNCTION(T,__EV_INTERNAL) { memcpy(dst, src, sizeof(T)); }
#define DEFINE_FREE_FUNCTION(T,name) static inline void FREE_FUNCTION(T,name)(T *self) #define DEFINE_FREE_FUNCTION(T,name) void FREE_FUNCTION(T,name)(T *self)
#define DEFINE_DEFAULT_FREE_FUNCTION(T) \ #define DEFINE_DEFAULT_INTERNAL_FREE_FUNCTION(T) \
DEFINE_FREE_FUNCTION(T,DEFAULT) { (void)self; } static inline DEFINE_FREE_FUNCTION(T,__EV_INTERNAL) { (void)self; }
#define DEFINE_HASH_FUNCTION(T,name) static inline void HASH_FUNCTION(T,name)(T *self, u64 seed) #define DEFINE_HASH_FUNCTION(T,name) u64 HASH_FUNCTION(T,name)(T *self, u64 seed)
#define DEFINE_DEFAULT_HASH_FUNCTION(T) \ #define DEFINE_DEFAULT_INTERNAL_HASH_FUNCTION(T) \
DEFINE_HASH_FUNCTION(T,DEFAULT) { ev_hash_murmur3(self, sizeof(T), seed); } static inline DEFINE_HASH_FUNCTION(T,__EV_INTERNAL) { return ev_hash_murmur3(self, sizeof(T), seed); }
#define DEFINE_EQUAL_FUNCTION(T,name) static inline bool EQUAL_FUNCTION(T,name)(T *self, T *other) #define DEFINE_CMP_FUNCTION(T,name) i32 CMP_FUNCTION(T,name)(T *self, T *other)
// NOTE: This shouldn't be used for non-arithmetic types. #define DEFINE_DEFAULT_INTERNAL_CMP_FUNCTION(T) \
#define DEFINE_DEFAULT_EQUAL_FUNCTION(T) \ static inline DEFINE_CMP_FUNCTION(T,__EV_INTERNAL) { return memcmp(self, other, sizeof(T)); }
DEFINE_EQUAL_FUNCTION(T,DEFAULT) { return memcmp(self, other, sizeof(T)) == 0; }
#define DEFINE_TOSTR_FUNCTION(T,name) static inline void TOSTR_FUNCTION(T,name)(T *self, char* out)
#define DEFINE_DEFAULT_TOSTR_FUNCTION(T) \
DEFINE_TOSTR_FUNCTION(T,DEFAULT) \
{ \
for(int i = 0; i < sizeof(T); i++) \
{ \
u8 byte = ((u8*)self)[i];\
out[i*2] = EV_TOHEX_CHAR((u32)(byte >> 4) & 0xf); \
out[i*2+1] = EV_TOHEX_CHAR((u32)byte & 0xf); \
} \
}
#define DEFINE_TOSTRLEN_FUNCTION(T,name) static inline u32 TOSTRLEN_FUNCTION(T,name)()
#define DEFINE_DEFAULT_TOSTRLEN_FUNCTION(T) \
DEFINE_TOSTRLEN_FUNCTION(T,DEFAULT) { return sizeof(T) * 2; }
#define DECLARE_COPY_FUNCTION(T,name) DEFINE_COPY_FUNCTION(T,name); #define DECLARE_COPY_FUNCTION(T,name) DEFINE_COPY_FUNCTION(T,name);
#define DECLARE_FREE_FUNCTION(T,name) DEFINE_FREE_FUNCTION(T,name); #define DECLARE_FREE_FUNCTION(T,name) DEFINE_FREE_FUNCTION(T,name);
#define DECLARE_HASH_FUNCTION(T,name) DEFINE_HASH_FUNCTION(T,name); #define DECLARE_HASH_FUNCTION(T,name) DEFINE_HASH_FUNCTION(T,name);
#define DECLARE_EQUAL_FUNCTION(T,name) DEFINE_EQUAL_FUNCTION(T,name); #define DECLARE_CMP_FUNCTION(T,name) DEFINE_CMP_FUNCTION(T,name);
#define DECLARE_TOSTR_FUNCTION(T,name) DEFINE_TOSTR_FUNCTION(T,name);
#define DECLARE_TOSTRLEN_FUNCTION(T,name) DEFINE_TOSTRLEN_FUNCTION(T,name); #define ACTIVE_COPY_FUNCTION(T) __EV_TYPE_INTERNAL_##T##_ACTIVE_COPY_FN
#define ACTIVE_FREE_FUNCTION(T) __EV_TYPE_INTERNAL_##T##_ACTIVE_FREE_FN
#define ACTIVE_HASH_FUNCTION(T) __EV_TYPE_INTERNAL_##T##_ACTIVE_HASH_FN
#define ACTIVE_CMP_FUNCTION(T) __EV_TYPE_INTERNAL_##T##_ACTIVE_CMP_FN
#define COPY_FUNCTION_TYPE(T) __EV_TYPE_INTERNAL_##T##_COPY_FN_TYPE
#define FREE_FUNCTION_TYPE(T) __EV_TYPE_INTERNAL_##T##_FREE_FN_TYPE
#define HASH_FUNCTION_TYPE(T) __EV_TYPE_INTERNAL_##T##_HASH_FN_TYPE
#define CMP_FUNCTION_TYPE(T) __EV_TYPE_INTERNAL_##T##_CMP_FN_TYPE
#define DEFINE_FUNCTION_TYPES(T) \
typedef void(*COPY_FUNCTION_TYPE(T))(T*,T*); \
typedef void(*FREE_FUNCTION_TYPE(T))(T*); \
typedef u64(*HASH_FUNCTION_TYPE(T))(T*,u64); \
typedef i32(*CMP_FUNCTION_TYPE(T))(T*,T*)
#define DEFINE_DEFAULT_INTERNAL_FUNCTIONS(T) \
DEFINE_DEFAULT_INTERNAL_COPY_FUNCTION(T) \
DEFINE_DEFAULT_INTERNAL_FREE_FUNCTION(T) \
DEFINE_DEFAULT_INTERNAL_HASH_FUNCTION(T) \
DEFINE_DEFAULT_INTERNAL_CMP_FUNCTION(T)
#define EV_OVERRIDE_VAR(T) EV_CAT(__ev_internal_override_var_,T) #define EV_OVERRIDE_VAR(T) EV_CAT(__ev_internal_override_var_,T)
#define TypeData(T) EV_CAT(EV_TYPEDATA_,T) #define TypeData(T) EV_CAT(EV_TYPEDATA_,T)
#define TYPEDATA_GEN(T, ...) \ #define TYPEDATA_GEN(T, ...) \
DEFINE_FUNCTION_TYPES(T); \
DEFINE_DEFAULT_INTERNAL_FUNCTIONS(T); \
static const COPY_FUNCTION_TYPE(T) ACTIVE_COPY_FUNCTION(T) = COPY_FUNCTION(T,__EV_INTERNAL); \
static const FREE_FUNCTION_TYPE(T) ACTIVE_FREE_FUNCTION(T) = FREE_FUNCTION(T,__EV_INTERNAL); \
static const HASH_FUNCTION_TYPE(T) ACTIVE_HASH_FUNCTION(T) = HASH_FUNCTION(T,__EV_INTERNAL); \
static const CMP_FUNCTION_TYPE(T) ACTIVE_CMP_FUNCTION(T) = CMP_FUNCTION(T,__EV_INTERNAL); \
EV_VA_OPT(__VA_ARGS__)(EV_FOREACH_UDATA(__EV_STRUCT_METHOD_DEF, T, __VA_ARGS__)) \
EV_WARNING_PUSH(); \ EV_WARNING_PUSH(); \
EV_WARNING_DISABLE_GCC("override-init"); \ EV_WARNING_DISABLE_GCC("override-init"); \
EV_WARNING_DISABLE_CLANG("initializer-overrides"); \ EV_WARNING_DISABLE_CLANG("override-init"); \
EV_UNUSED static const EvTypeData TypeData(T) = { \ EV_UNUSED static const EvTypeData TypeData(T) = { \
EV_DEBUG(.name = EV_STRINGIZE(T),) \ EV_DEBUG(.name = EV_STRINGIZE(T),) \
.size = sizeof(T), \ .size = sizeof(T), \
.alignment = EV_ALIGNOF(T), \ .alignment = EV_ALIGNOF(T), \
.default_val = (void*)&(T){0}, \ .default_val = (void*)&(T){0}, \
.invalid_val = (void*)&(T){0}, \ .invalid_val = (void*)&(T){0}, \
EV_VA_OPT(__VA_ARGS__)(EV_FOREACH_UDATA(__EV_STRUCT_METHOD_DEF, T, __VA_ARGS__)) \ .copy_fn = (ev_copy_fn)ACTIVE_COPY_FUNCTION(T), \
.free_fn = (ev_free_fn)ACTIVE_FREE_FUNCTION(T), \
.hash_fn = (ev_hash_fn)ACTIVE_HASH_FUNCTION(T), \
.cmp_fn = (ev_cmp_fn) ACTIVE_CMP_FUNCTION(T) \
}; \ }; \
EV_WARNING_POP(); \ EV_WARNING_POP(); \
EV_UNUSED static T EV_OVERRIDE_VAR(T) EV_UNUSED static T EV_OVERRIDE_VAR(T)
#define __EV_STRUCT_METHOD_DEF(T, ...) EV_CATN(__EV_,EV_HEAD __VA_ARGS__,_FN)(T, EV_TAIL __VA_ARGS__)
#define COPY(...) (COPY , __VA_ARGS__) #define COPY(...) (COPY , __VA_ARGS__)
#define FREE(...) (FREE , __VA_ARGS__) #define FREE(...) (FREE , __VA_ARGS__)
#define HASH(...) (HASH , __VA_ARGS__) #define HASH(...) (HASH , __VA_ARGS__)
#define EQUAL(...) (EQUAL , __VA_ARGS__) #define CMP(...) (CMP , __VA_ARGS__)
#define TOSTR(...) (TOSTR , __VA_ARGS__) #define DEFAULT(...) (DEFAULT, __VA_ARGS__)
#define TOSTRLEN(...) (TOSTRLEN , __VA_ARGS__) #define INVALID(...) (INVALID, __VA_ARGS__)
#define DEFAULT(...) (DEFAULT , __VA_ARGS__)
#define INVALID(...) (INVALID , __VA_ARGS__)
#define __EV_COPY_FN(T,name) .copy_fn = (ev_copy_fn) COPY_FUNCTION(T,name), #define __EV_STRUCT_METHOD_DEF(T, ...) EV_CAT(__EV_,EV_CAT(EV_HEAD __VA_ARGS__,_FN))(T, EV_TAIL __VA_ARGS__)
#define __EV_FREE_FN(T,name) .free_fn = (ev_free_fn) FREE_FUNCTION(T,name), #define __EV_COPY_FN(T,name) ACTIVE_COPY_FUNCTION(T) = (COPY_FUNCTION_TYPE(T)) COPY_FUNCTION(T,name);
#define __EV_HASH_FN(T,name) .hash_fn = (ev_hash_fn) HASH_FUNCTION(T,name), #define __EV_FREE_FN(T,name) ACTIVE_FREE_FUNCTION(T) = (FREE_FUNCTION_TYPE(T)) FREE_FUNCTION(T,name);
#define __EV_EQUAL_FN(T,name) .equal_fn = (ev_equal_fn) EQUAL_FUNCTION(T,name), #define __EV_HASH_FN(T,name) ACTIVE_HASH_FUNCTION(T) = (HASH_FUNCTION_TYPE(T)) HASH_FUNCTION(T,name);
#define __EV_TOSTR_FN(T,name) .tostr_fn = (ev_tostr_fn) TOSTR_FUNCTION(T,name), #define __EV_CMP_FN(T,name) ACTIVE_CMP_FUNCTION(T) = (CMP_FUNCTION_TYPE(T)) CMP_FUNCTION(T,name);
#define __EV_TOSTRLEN_FN(T,name) .tostrlen_fn = (ev_tostrlen_fn) TOSTRLEN_FUNCTION(T,name),
#define __EV_DEFAULT_FN(T, ...) .default_val = (void*)&(T){ __VA_ARGS__ }, #define __EV_DEFAULT_FN(T, ...) .default_val = (void*)&(T){ __VA_ARGS__ },
#define __EV_INVALID_FN(T, ...) .invalid_val = (void*)&(T){ __VA_ARGS__ }, #define __EV_INVALID_FN(T, ...) .invalid_val = (void*)&(T){ __VA_ARGS__ },
[[maybe_unused]] #define EV_COPY(T) TypeData(T).copy_fn
static void nop() {} #define EV_FREE(T) TypeData(T).free_fn
#define METHOD_CHECK(T, ...) (__VA_ARGS__ EV_DEBUG(?__VA_ARGS__:(assert(!EV_STRINGIZE(__VA_ARGS__)"not defined"),(T)nop))) #define EV_HASH(T) TypeData(T).hash_fn
#define EV_CMP(T) TypeData(T).cmp_fn
#define EV_COPY(T) METHOD_CHECK(ev_copy_fn, TypeData(T).copy_fn)
#define EV_FREE(T) METHOD_CHECK(ev_free_fn, TypeData(T).free_fn)
#define EV_HASH(T) METHOD_CHECK(ev_hash_fn, TypeData(T).hash_fn)
#define EV_EQUAL(T) METHOD_CHECK(ev_equal_fn, TypeData(T).equal_fn)
#define EV_TOSTR(T) METHOD_CHECK(ev_tostr_fn, TypeData(T).tostr_fn)
#define EV_TOSTRLEN(T) METHOD_CHECK(ev_tostrlen_fn, TypeData(T).tostrlen_fn)
#define __EV_OVERRIDE_DEFAULT(T, ...) EV_OVERRIDE_VAR(T).__VA_ARGS__, #define __EV_OVERRIDE_DEFAULT(T, ...) EV_OVERRIDE_VAR(T).__VA_ARGS__,
#define __EV_DEFAULT_INTERNAL(T) (*(T*)TypeData(T).default_val) #define __EV_DEFAULT_INTERNAL(T) (*(T*)TypeData(T).default_val)
#define EV_DEFAULT(T, ...) EV_VA_OPT_ELSE(__VA_ARGS__) \ #define EV_DEFAULT(T, ...) EV_VA_OPT_ELSE(__VA_ARGS__) \
@@ -133,25 +130,4 @@ static void nop() {}
(__EV_DEFAULT_INTERNAL(T)) (__EV_DEFAULT_INTERNAL(T))
#define EV_INVALID(T) (*(T*)TypeData(T).invalid_val) #define EV_INVALID(T) (*(T*)TypeData(T).invalid_val)
#if defined(EV_BUILDTYPE_DEBUG) || defined(EV_BUILDTYPE_DEBUGOPT)
#include <stdio.h>
#endif
DEFINE_TOSTR_FUNCTION(EvTypeData, EvTypeDataStringize)
{
EV_DEBUG(
sprintf(out,
"TypeData:\n"
EV_DEBUG("\t name: %s\n")
"\t size: %u\n"
"\t alig: %u\n",
EV_DEBUG(self->name),
self->size,
self->alignment
);
)
}
TYPEDATA_GEN(EvTypeData,
TOSTR(EvTypeDataStringize));
#endif // EV_HEADERS_TYPES_H #endif // EV_HEADERS_TYPES_H

256
ev_vec.h
View File

@@ -37,7 +37,9 @@
#endif #endif
typedef void *ev_vec_t; typedef void *ev_vec_t;
TYPEDATA_GEN(ev_vec_t);
typedef void *ev_svec_t; typedef void *ev_svec_t;
TYPEDATA_GEN(ev_svec_t);
typedef enum { typedef enum {
EV_VEC_ERR_NONE = 0, EV_VEC_ERR_NONE = 0,
@@ -45,19 +47,11 @@ typedef enum {
} ev_vec_error_t; } ev_vec_error_t;
TYPEDATA_GEN(ev_vec_error_t, DEFAULT(EV_VEC_ERR_NONE)); TYPEDATA_GEN(ev_vec_error_t, DEFAULT(EV_VEC_ERR_NONE));
typedef struct {
ev_copy_fn copy;
ev_equal_fn equal;
ev_free_fn free;
ev_tostr_fn tostr;
} ev_vec_overrides_t;
TYPEDATA_GEN(ev_vec_overrides_t);
#if defined(EV_VEC_SHORTNAMES) #if defined(EV_VEC_SHORTNAMES)
# define vec_t ev_vec_t #define vec_t ev_vec_t
# define svec_t ev_svec_t #define svec_t ev_svec_t
# define vec_error_t ev_vec_error_t #define vec_error_t ev_vec_error_t
# define vec(T) ev_vec(T) # define vec(T) ev_vec(T)
# define svec(T) ev_svec(T) # define svec(T) ev_svec(T)
@@ -65,10 +59,10 @@ TYPEDATA_GEN(ev_vec_overrides_t);
# define vec_init ev_vec_init # define vec_init ev_vec_init
# define svec_init ev_svec_init # define svec_init ev_svec_init
# define svec_init_w_cap ev_svec_init_w_cap # define svec_init_w_cap ev_svec_init_w_cap
# define svec_init_w_len ev_svec_init_w_len
# define vec_iter_begin ev_vec_iter_begin # define vec_iter_begin ev_vec_iter_begin
# define vec_iter_end ev_vec_iter_end # define vec_iter_end ev_vec_iter_end
# define vec_iter_next ev_vec_iter_next # define vec_iter_next ev_vec_iter_next
# define vec_foreach ev_vec_foreach
# define vec_fini ev_vec_fini # define vec_fini ev_vec_fini
# define vec_push ev_vec_push # define vec_push ev_vec_push
# define vec_append ev_vec_append # define vec_append ev_vec_append
@@ -85,7 +79,7 @@ TYPEDATA_GEN(ev_vec_overrides_t);
* \brief For the sake of readability * \brief For the sake of readability
* \details Sample usage: * \details Sample usage:
* ``` * ```
* ev_vec(int) v = ev_vec_init(int); * ev_vec(int) v = ev_vec_init(int, 0, 0);
* ``` * ```
*/ */
#define ev_vec(T) T* #define ev_vec(T) T*
@@ -122,115 +116,100 @@ struct ev_vec_meta_t {
*/ */
EV_VEC_API ev_vec_t EV_VEC_API ev_vec_t
ev_vec_init_impl( ev_vec_init_impl(
EvTypeData typeData, EvTypeData typeData);
ev_vec_overrides_t overrides);
/*! /*!
* \brief Syntactic sugar for `ev_vec_init_impl()` * \brief Syntactic sugar for `ev_vec_init_impl()`
* \details Sample usage: * \details Sample usage:
* ``` * ```
* ev_vec_init(i32); // ev_vec_init_impl(TypeData(i32)); * ev_vec_init(int); // ev_vec_init_impl(sizeof(int), NULL, NULL);
* ev_vec_init(int, fn_destr); // ev_vec_init_impl(sizeof(int), NULL, fn_destr);
* ev_vec_init(int, fn_cpy, fn_destr); // ev_vec_init_impl(sizeof(int), fn_cpy, fn_destr);
* ``` * ```
*/ */
#define ev_vec_init(T, ...) ev_vec_init_impl(TypeData(T), EV_DEFAULT(ev_vec_overrides_t,__VA_ARGS__)) #define ev_vec_init(T) ev_vec_init_impl(TypeData(T))
#define ev_svec_init(T, ...) __ev_svec_init_impl(T, EV_ARRSIZE((T[])__VA_ARGS__), EV_ARRSIZE((T[])__VA_ARGS__), __VA_ARGS__) #define ev_svec_init(T, ...) __ev_svec_init_impl(T, EV_ARRSIZE((T[])__VA_ARGS__), __VA_ARGS__)
#define ev_svec_init_w_cap(T, cap) __ev_svec_init_impl(T, 0, cap) #define ev_svec_init_w_cap(T, cap) __ev_svec_init_w_cap_impl(T, cap)
#define ev_svec_init_w_len(T, len) __ev_svec_init_impl(T, len, len)
static struct ev_vec_meta_t *__svec_interm_md; #define __ev_svec_init_impl(T, len, ...) \
#define __ev_svec_init_impl(T, len, cap, ...) ( \ (ev_svec(T))&((struct { \
__svec_interm_md = (u8[sizeof(T)*cap + sizeof(struct ev_vec_meta_t)]){}, \ struct ev_vec_meta_t meta; \
*__svec_interm_md = (struct ev_vec_meta_t){ \ EV_ALIGNAS(EV_ALIGNOF(T)) T data[len]; \
.length = len, \ }) { \
.capacity = cap, \ .meta.length = len, \
.typeData = TypeData(T), \ .meta.capacity = len, \
.allocationType = EV_VEC_ALLOCATION_TYPE_STACK, \ .meta.typeData.size = sizeof(T), \
}, \ .meta.typeData.alignment = EV_ALIGNOF(T), \
EV_VA_OPT(__VA_ARGS__)(memcpy(&__svec_interm_md[1], (T[])__VA_ARGS__, sizeof((T[])__VA_ARGS__)),) \ .meta.allocationType = EV_VEC_ALLOCATION_TYPE_STACK, \
&(__svec_interm_md[1]) \ .data = __VA_ARGS__ \
) }).data
#define __ev_svec_init_w_cap_impl(T, cap) \
(ev_svec(T))&((struct { \
struct ev_vec_meta_t meta; \
EV_ALIGNAS(EV_ALIGNOF(T)) T data[cap]; \
}) { \
.meta.length = 0, \
.meta.capacity = cap, \
.meta.typeData.size = sizeof(T), \
.meta.typeData.alignment = EV_ALIGNOF(T), \
.meta.allocationType = EV_VEC_ALLOCATION_TYPE_STACK, \
.data = __EV_VEC_EMPTY_ARRAY \
}).data
#define ev_vec_push(v, x) ev_vec_push_impl((ev_vec_t*)&v,&x);
/*! /*!
* \brief Syntactic sugar for `ev_vec_push_impl()` that allows multiple pushed in the same statement. * \param v The vector that we want an iterator for
* \details Sample usage:
* ```
* ev_vec_t v;
* i32 x = 1;
* i32 y = 2;
* ev_vec_push(&v, &x); // ev_vec_push_impl(&v, &x);
* ev_vec_push(&v, &x, &y); // ev_vec_push_impl(&v, &x); ev_vec_push_impl(&v, &y);
* ```
*
* *Note* This is possibly replaceable with a variadic function.
*/
#define ev_vec_push(v, ...) \
EV_FOREACH_UDATA(__ev_vec_internal_push, v, __VA_ARGS__);
#define __ev_vec_internal_push(v, var) ev_vec_push_impl((ev_vec_t*)v, var);
/*!
* \param v A pointer to the vector that we want an iterator for
* *
* \returns A pointer to the first element in a vector * \returns A pointer to the first element in a vector
*/ */
EV_VEC_API void * EV_VEC_API void *
ev_vec_iter_begin( ev_vec_iter_begin(
const ev_vec_t* v); ev_vec_t v);
/*! /*!
* \param v A pointer to the vector that we want an iterator for * \param v The vector that we want an iterator for
* *
* \returns A pointer to the memory block right after the last element in the vector * \returns A pointer to the memory block right after the last element in the vector
*/ */
EV_VEC_API void * EV_VEC_API void *
ev_vec_iter_end( ev_vec_iter_end(
const ev_vec_t* v); ev_vec_t v);
/*! /*!
* \brief A function that increments an iterator to make it point to the next * \brief A function that increments an iterator to make it point to the next
* element in the vector * element in the vector
* *
* \param v A pointer to the vector that is being iterated over * \param v The vector that is being iterated over
* \param iter Reference to the iterator that is being incremented * \param iter Reference to the iterator that is being incremented
*/ */
EV_VEC_API void EV_VEC_API void
ev_vec_iter_next( ev_vec_iter_next(
const ev_vec_t* v, ev_vec_t v,
void **iter); void **iter);
/*! /*!
* \brief A function that looks for the index of `val` in `v` * \brief A function that destroys a vector object. If a destructor function was
* * passed while initializing the vector, then this function is called on every
* \param v A pointer to the vector that is being iterated over * element before all reserved memory is freed.
* \param val A pointer to the object that will be compared with vector elements
*
* \returns If found, index of element in vector. Otherwise, -1.
*/
EV_VEC_API i32
ev_vec_find(
const ev_vec_t* v,
void* val);
/*!
* \brief A function that destroys a vector object. If the element type has a
* destructor function, then this function is called on every element before
* all reserved memory is freed.
* *
* *Note*: For stack-allocated vectors (`svec`), destructors are called for * *Note*: For stack-allocated vectors (`svec`), destructors are called for
* elements but no memory is freed. * elements but no memory is freed.
* *
* \param v A pointer to the vector that is being destroyed * \param v The vector that is being destroyed
*/ */
EV_VEC_API void EV_VEC_API void
ev_vec_fini( ev_vec_fini(
ev_vec_t* v); ev_vec_t v);
/*! /*!
* \brief A function that copies a value to the end of a vector. If the element * \brief A function that copies a value to the end of a vector. If a copy
* type has a copy function, then this function is called to copy the new element * function was passed while initializing the vector, then this function is
* into the vector. Otherwise, memcpy is used with a the element type size as a * called to copy the new element into the vector. Otherwise, memcpy is used
* copy length. If a resize is needed but fails due to 'OOM' issues, then the * with a length of `vec_meta.elemsize`. If a resize is needed but fails due to
* vector is left unchanged and VEC_ERR_OOM is returned. * 'OOM' issues, then the vector is left unchanged and VEC_ERR_OOM is returned.
* *
* For `svec`, as long as the capacity is more than the current size, a push * For `svec`, as long as the capacity is more than the current size, a push
* operation is permitted. Otherwise, the operation is treated as an OOM. * operation is permitted. Otherwise, the operation is treated as an OOM.
@@ -256,7 +235,7 @@ ev_vec_push_impl(
* desired amount, an append operation is permitted. Otherwise, the operation * desired amount, an append operation is permitted. Otherwise, the operation
* is treated as an OOM. * is treated as an OOM.
* *
* *NOTE* The type's copy function is not used; this is merely a memcpy * *NOTE* The vector's copy function is not used; this is merely a memcpy
* operation. If a deep copy is needed, individually pushing the elements of * operation. If a deep copy is needed, individually pushing the elements of
* the array is the way to go. * the array is the way to go.
* *
@@ -297,48 +276,48 @@ ev_vec_pop(
/*! /*!
* \brief A function that returns the last element in the vector. * \brief A function that returns the last element in the vector.
* *
* \param v A pointer to the vector object * \param v Reference to the vector object
* *
* \returns Pointer to the last element in the vector. NULL if the vector is * \returns Pointer to the last element in the vector. NULL if the vector is
* empty. * empty.
*/ */
EV_VEC_API void * EV_VEC_API void *
ev_vec_last( ev_vec_last(
const ev_vec_t* v); ev_vec_t v);
/*! /*!
* \brief A function that returns the length of a vector * \brief A function that returns the length of a vector
* *
* \param v A pointer to the vector object * \param v The vector object
* *
* \returns Current length of the vector * \returns Current length of the vector
*/ */
EV_VEC_API u64 EV_VEC_API u64
ev_vec_len( ev_vec_len(
const ev_vec_t* v); ev_vec_t v);
/*! /*!
* \brief A function that returns the capacity of a vector * \brief A function that returns the capacity of a vector
* *
* \param v A pointer to the vector object * \param v The vector object
* *
* \returns Current capacity of the vector * \returns Current capacity of the vector
*/ */
EV_VEC_API u64 EV_VEC_API u64
ev_vec_capacity( ev_vec_capacity(
const ev_vec_t* v); ev_vec_t v);
/*! /*!
* \brief Calls the free operation (if exists) on every element, then sets * \brief Calls the free operation (if exists) on every element, then sets
* the length to 0. * the length to 0.
* *
* \param v A pointer to the vector object * \param v The vector object
* *
* \returns 0 on success * \returns 0 on success
*/ */
EV_VEC_API u32 EV_VEC_API u32
ev_vec_clear( ev_vec_clear(
const ev_vec_t* v); ev_vec_t v);
/*! /*!
* \brief Sets the length of the vector to `len`. * \brief Sets the length of the vector to `len`.
@@ -386,34 +365,11 @@ EV_VEC_API ev_vec_error_t
ev_vec_grow( ev_vec_grow(
ev_vec_t *v); ev_vec_t *v);
static const ev_vec_t EV_VEC_EMPTY =
(ev_vec(i32))&((struct {
struct ev_vec_meta_t meta;
EV_ALIGNAS(EV_ALIGNOF(i32)) i32 data[0];
}) {
.meta.length = 0,
.meta.capacity = 0,
.meta.typeData = TypeData(i32),
.meta.allocationType = EV_VEC_ALLOCATION_TYPE_STACK,
.data = __EV_VEC_EMPTY_ARRAY
}).data;
TYPEDATA_GEN(
ev_vec_t,
INVALID(EV_VEC_EMPTY)
);
TYPEDATA_GEN(
ev_svec_t,
INVALID(EV_VEC_EMPTY)
);
#ifdef EV_VEC_IMPLEMENTATION #ifdef EV_VEC_IMPLEMENTATION
#undef EV_VEC_IMPLEMENTATION #undef EV_VEC_IMPLEMENTATION
#ifdef EV_VEC_API_CHECK #ifdef EV_VEC_API_CHECK
#define EV_VEC_CHECK(x) do { x; } while (0) #define EV_VEC_CHECK(x) do { x; } while(0)
#else #else
#define EV_VEC_CHECK(x) #define EV_VEC_CHECK(x)
#endif #endif
@@ -432,22 +388,12 @@ TYPEDATA_GEN(
ev_vec_t ev_vec_t
ev_vec_init_impl( ev_vec_init_impl(
EvTypeData typeData, EvTypeData typeData)
ev_vec_overrides_t overrides)
{ {
void *v = malloc(sizeof(struct ev_vec_meta_t) + (EV_VEC_INIT_CAP * typeData.size)); void *v = malloc(sizeof(struct ev_vec_meta_t) + (EV_VEC_INIT_CAP * typeData.size));
if (!v) if (!v)
return NULL; return NULL;
if(overrides.copy)
typeData.copy_fn = overrides.copy;
if(overrides.equal)
typeData.equal_fn = overrides.equal;
if(overrides.free)
typeData.free_fn = overrides.free;
if(overrides.tostr)
typeData.tostr_fn = overrides.tostr;
struct ev_vec_meta_t *metadata = (struct ev_vec_meta_t *)v; struct ev_vec_meta_t *metadata = (struct ev_vec_meta_t *)v;
*metadata = (struct ev_vec_meta_t){ *metadata = (struct ev_vec_meta_t){
.length = 0, .length = 0,
@@ -459,36 +405,11 @@ ev_vec_init_impl(
return metadata + 1; return metadata + 1;
} }
i32
ev_vec_find(
const ev_vec_t* v,
void *val)
{
__ev_vec_getmeta(*v)
if(metadata->typeData.equal_fn) {
for (void *elem = ev_vec_iter_begin(v); elem != ev_vec_iter_end(v); ev_vec_iter_next(v, &elem)) {
if(metadata->typeData.equal_fn(elem, val))
{
return (elem - *v) / metadata->typeData.size;
}
}
}
else {
for (void *elem = ev_vec_iter_begin(v); elem != ev_vec_iter_end(v); ev_vec_iter_next(v, &elem)) {
if(memcmp(elem, val, metadata->typeData.size) == 0)
{
return (elem - *v) / metadata->typeData.size;
}
}
}
return -1;
}
void void
ev_vec_fini( ev_vec_fini(
ev_vec_t* v) ev_vec_t v)
{ {
__ev_vec_getmeta(*v) __ev_vec_getmeta(v)
if (metadata->typeData.free_fn) { if (metadata->typeData.free_fn) {
for (void *elem = ev_vec_iter_begin(v); elem != ev_vec_iter_end(v); for (void *elem = ev_vec_iter_begin(v); elem != ev_vec_iter_end(v);
@@ -499,8 +420,6 @@ ev_vec_fini(
if(metadata->allocationType == EV_VEC_ALLOCATION_TYPE_HEAP) { if(metadata->allocationType == EV_VEC_ALLOCATION_TYPE_HEAP) {
free(metadata); free(metadata);
} }
*v = EV_INVALID(ev_vec_t);
} }
int int
@@ -531,26 +450,26 @@ ev_vec_push_impl(
void * void *
ev_vec_iter_begin( ev_vec_iter_begin(
const ev_vec_t* v) ev_vec_t v)
{ {
return *v; return v;
} }
void * void *
ev_vec_iter_end( ev_vec_iter_end(
const ev_vec_t* v) ev_vec_t v)
{ {
__ev_vec_getmeta(*v) __ev_vec_getmeta(v)
return ((char *)*v) + (metadata->typeData.size * metadata->length); return ((char *)v) + (metadata->typeData.size * metadata->length);
} }
void void
ev_vec_iter_next( ev_vec_iter_next(
const ev_vec_t* v, ev_vec_t v,
void **iter) void **iter)
{ {
__ev_vec_getmeta(*v) __ev_vec_getmeta(v)
*iter = ((char*)*iter) + metadata->typeData.size; *iter = ((char*)*iter) + metadata->typeData.size;
} }
@@ -604,38 +523,38 @@ ev_vec_pop(
void * void *
ev_vec_last( ev_vec_last(
const ev_vec_t* v) ev_vec_t v)
{ {
__ev_vec_getmeta(*v) __ev_vec_getmeta(v)
if(metadata->length == 0) { if(metadata->length == 0) {
return NULL; return NULL;
} }
return ((char *)*v) + ((metadata->length-1) * metadata->typeData.size); return ((char *)v) + ((metadata->length-1) * metadata->typeData.size);
} }
u64 u64
ev_vec_len( ev_vec_len(
const ev_vec_t* v) ev_vec_t v)
{ {
__ev_vec_getmeta(*v) __ev_vec_getmeta(v)
return metadata->length; return metadata->length;
} }
u64 u64
ev_vec_capacity( ev_vec_capacity(
const ev_vec_t* v) ev_vec_t v)
{ {
__ev_vec_getmeta(*v) __ev_vec_getmeta(v)
return metadata->capacity; return metadata->capacity;
} }
u32 u32
ev_vec_clear( ev_vec_clear(
const ev_vec_t* v) ev_vec_t v)
{ {
__ev_vec_getmeta(*v) __ev_vec_getmeta(v)
if (metadata->typeData.free_fn) { if (metadata->typeData.free_fn) {
for (void *elem = ev_vec_iter_begin(v); elem != ev_vec_iter_end(v); for (void *elem = ev_vec_iter_begin(v); elem != ev_vec_iter_end(v);
@@ -663,6 +582,9 @@ ev_vec_setlen(
__ev_vec_syncmeta(*v) __ev_vec_syncmeta(*v)
} }
// TODO if new_len < old_len:
// vec_pop(old_len - new_len)
metadata->length = len; metadata->length = len;
return EV_VEC_ERR_NONE; return EV_VEC_ERR_NONE;
} }

22
map_test.c
View File

@@ -1,22 +0,0 @@
#include <stdio.h>
#define EV_MAP_IMPLEMENTATION
#include "ev_map.h"
int main()
{
int x = 10;
int y = 100;
int x2 = 300;
int y2 = 123;
ev_map(i32, i32)* m = ev_map_init(i32, i32);
ev_map_add(m, (&x, &y), (&x2, &y2));
i32 out;
ev_map_get(m, &x, &out);
ev_map_fini(m);
return 0;
}

4
meson-native-clang
View File

@@ -1,4 +0,0 @@
[binaries]
c = 'clang.exe'
c_ld = 'lld'
cpp = 'clang++.exe'

12
meson.build
View File

@@ -1,5 +1,5 @@
project('evol-headers', 'c', project('evol-headers', 'c',
default_options : [ 'c_std=gnu23' ]) default_options : [ 'c_std=gnu17' ])
headers_include = include_directories('.') headers_include = include_directories('.')
@@ -16,34 +16,24 @@ endif
cc = meson.get_compiler('c') cc = meson.get_compiler('c')
if cc.get_id() == 'msvc' if cc.get_id() == 'msvc'
evh_c_args += '/Zc:preprocessor' evh_c_args += '/Zc:preprocessor'
elif cc.get_id() == 'clang'
evh_c_args += '-DEV_CC_CLANG=1'
endif endif
# All other targets should follow the same template # All other targets should follow the same template
str_lib = static_library('ev_str', files('buildfiles/ev_str.c'), c_args: evh_c_args) str_lib = static_library('ev_str', files('buildfiles/ev_str.c'), c_args: evh_c_args)
vec_lib = static_library('ev_vec', files('buildfiles/ev_vec.c'), c_args: evh_c_args) vec_lib = static_library('ev_vec', files('buildfiles/ev_vec.c'), c_args: evh_c_args)
helpers_lib = static_library('ev_helpers', files('buildfiles/ev_helpers.c'), c_args: evh_c_args)
str_dep = declare_dependency(link_with: str_lib, include_directories: headers_include) str_dep = declare_dependency(link_with: str_lib, include_directories: headers_include)
vec_dep = declare_dependency(link_with: vec_lib, include_directories: headers_include) vec_dep = declare_dependency(link_with: vec_lib, include_directories: headers_include)
helpers_dep = declare_dependency(link_with: helpers_lib, include_directories: headers_include)
headers_dep = declare_dependency( headers_dep = declare_dependency(
dependencies: [ dependencies: [
str_dep, str_dep,
vec_dep, vec_dep,
helpers_dep,
] ]
) )
# Tests
str_test = executable('str_test', 'str_test.c', dependencies: [str_dep], c_args: evh_c_args)
test('evstr', str_test)
if meson.version().version_compare('>= 0.54.0') if meson.version().version_compare('>= 0.54.0')
meson.override_dependency('ev_vec', vec_dep) meson.override_dependency('ev_vec', vec_dep)
meson.override_dependency('ev_str', str_dep) meson.override_dependency('ev_str', str_dep)
meson.override_dependency('ev_helpers', helpers_dep)
meson.override_dependency('evol-headers', headers_dep) meson.override_dependency('evol-headers', headers_dep)
endif endif

21
str_test.c
View File

@@ -56,26 +56,5 @@ int main()
assert(search_results[1].offset == 26); assert(search_results[1].offset == 26);
assert(search_results[2].offset == 56); assert(search_results[2].offset == 56);
{ // PushFmt Bug
printf("PushFmt Bug");
evstring heap_str = evstring_new("Heap 'Hello, World!'");
printf("Heap String: %s, Length: %llu\n", heap_str, evstring_getLength(heap_str));
evstring_error_t res = evstring_push(&heap_str, "%.05f", 1.0f);
printf("Push Fmt #1: %s, New Length: %llu\n", heap_str, evstring_getLength(heap_str));
assert(evstring_getLength(heap_str) == 27);
assert(strcmp(heap_str, "Heap 'Hello, World!'1.00000") == 0);
assert(res == EV_STR_ERR_NONE);
/*evstring_push(&heap_str, "%.05f, %.05f, %.05f", 1.0f, 2.0f, 3.0f);*/
res = evstring_push(&heap_str, "Something");
printf("Push Fmt #2: %s, New Length: %llu\n", heap_str, evstring_getLength(heap_str));
assert(evstring_getLength(heap_str) == 36);
assert(strcmp(heap_str, "Heap 'Hello, World!'1.00000Something") == 0);
assert(res == EV_STR_ERR_NONE);
evstring_free(heap_str);
}
return 0; return 0;
} }

40
tostr_test.c
View File

@@ -1,40 +0,0 @@
#include <stdio.h>
#include "ev_types.h"
#include "ev_numeric.h"
typedef struct {
char *name;
int age;
char *desc;
} Person;
DEFINE_TOSTR_FUNCTION(Person, PERSON_PRINT)
{
sprintf(out, "%s:\n\tage: %d\n\tdesc: %s", self->name, self->age, self->desc);
}
TYPEDATA_GEN(Person,
TOSTR(PERSON_PRINT),
DEFAULT(
.name = "sisyphus",
.age = 9999,
.desc = "One can only imagine him happy"
),
INVALID(
.name = NULL,
.age = -1,
.desc = NULL
)
);
int main()
{
puts("");
char out[256] = {};
Person sisyphue = EV_DEFAULT(Person);
EV_TOSTR(Person)(&sisyphue, out);
puts(out);
return 0;
}