gdjn  Diff

/* [ʞ] util.h
 *  ~ lexi hale <lexi@hale.su>
 *  🄯 AGPLv3
 *  ? encapsulate annoying operations (read: pitiful, fragile blast
 *    shield over the most indefensibly psychotic pieces of the godot
 *    "type" "system")
 *
 *    if you want to use this outside gdjn, redefine the macro _t
 *    from gdjn.h appropriately.
 *
 *    (honestly tho you should use c-bind-gen.janet too)
 */

#pragma once
#include "gdjn.h"
#include <string.h>


static inline gd_string
gdu_string_of_stringName(const gd_stringName* const s) {
	gd_string r;
	_t(string).fromStringName(&r, (void*)&s);
	return r;
}
................................................................................
#define _refMut(x) typeof(typeof(x)      * const)
#define _with(T, k, v, ...) ({\
	typeof(gd_##T) k = v; \
	do { __VA_ARGS__; } while (0); \
	_t(T).dtor(&k); \
})

#define _withSym(k, v, ...) \
	_with(stringName, k, gdu_intern(v), __VA_ARGS__)
#define _withSym0(k, ...) \
	_with(stringName, k, {}, __VA_ARGS__)
#define _withStr(k, v, ...) \
	_with(string, k, gdu_str(v), __VA_ARGS__)
#define _withStr0(k, v, ...) \
	_with(string, k, {}, __VA_ARGS__)

#define _typeEq(a, b) \
	__builtin_classify_type(typeof(a)) == _builtin_classify_type(typeof(b))


#define _refVal   0
#define _refPtr   1
#define _refArray 2


#define _indirect(a) \
		__builtin_types_compatible_p(typeof(a), void*)

#define _refKind(a) \
	__builtin_choose( _typeEq(typeof_unqual(a), \
	                          typeof_unqual(a[0]) []), _refArray \
		/* false */ __builtin_choose(_typeEq(a, (typeof_unqual(a[0]) *)), _refPtr ))

#define _szElse(a, zero) \
	__builtin_choose(_refKind(a) == _refArray, \
		/* true */ _sz(a), \
		/* false */ __builtin_choose(_refKind(a) == _refPtr, \
			/* true */ (__builtin_counted_by(ptr) != nullptr ? \
			            *__builtin_counted_by(ptr) : (zero)) \
			/* false */ (void)0 /* bad type */ ))
#define _sz0(a)   _szElse(a,0)
#define _szStr(a) \
	__builtin_choose(_typeEq((a), pstr), (a).sz, _szElse(a, strlen(a)))

#define _array(t) struct {t* v; size_t sz;}
typedef _array(char) pstr;

#define _strWithSz(a) (a), _strLen(a)

static inline bool
gdu_symIs
(	gd_stringName const* const a,
	gd_stringName const* const b
) {
	bool res;
................................................................................
	char* buf = _alloc(char, len);
	gdu_string_emit(s, buf, len - 1);
	return (pstr){buf,len};
}

static inline gd_string
gdu_string_dup (_ref(gd_string) s) {
	gd_string cp;






	_t(string).copy(&cp, (void const*[]) {s});



	return cp;
}

#define _cat(x,y) x##y
#define __cat(x,y) _cat(x,y)
#define _gensym __cat(_sym_,__COUNTER__)

#define __gdu_string_auto(szid, name, str) \
................................................................................
static inline GDExtensionObjectPtr
gdu_cast
(	GDExtensionConstObjectPtr what,
	_ref(char)                to
) {
	return _t(object).castTo(what, gdu_classTag(to));
}

/* [ʞ] src/util-gd.h
 *  ~ lexi hale <lexi@hale.su>
 *  🄯 AGPLv3
 *  ? encapsulate annoying godot operations (read: pitiful,
 *    fragile blast shield over the most indefensibly psychotic
 *    pieces of the godot "type" "system")





 */

#pragma once
#include "gdjn.h"
#include <string.h>
#include "type.h"

static inline gd_string
gdu_string_of_stringName(const gd_stringName* const s) {
	gd_string r;
	_t(string).fromStringName(&r, (void*)&s);
	return r;
}
................................................................................
#define _refMut(x) typeof(typeof(x)      * const)
#define _with(T, k, v, ...) ({\
	typeof(gd_##T) k = v; \
	do { __VA_ARGS__; } while (0); \
	_t(T).dtor(&k); \
})

#define _withSym0(k, ...) \
	_with(stringName, k, {}, __VA_ARGS__)
#define _withSymSz(k, v, sz, ...) \
	_with(stringName, k, gdu_intern_sz(v, sz), __VA_ARGS__)
#define _withSym(k, v, ...) \
	_withSymSz(k, _strDynMem(v), _strDynSz(v), __VA_ARGS__)
#define _withSymLit(k, v, ...) \
	_withSymSz(k, _litSz(v), __VA_ARGS__)

#define _withStr0(k, ...) \
	_with(string, k, {}, __VA_ARGS__)

#define _withStrSz(k, v, sz, ...) \
	_with(string, k, gdu_str_sz(v, sz), __VA_ARGS__)
#define _withStr(k, v, ...) \
	_withStrSz(k, _strDynMem(v), _strDynSz(v), __VA_ARGS__)

#define _withStrLit(k, v, ...) \
	_withStrSz(k, _litSz(v), __VA_ARGS__)























static inline bool
gdu_symIs
(	gd_stringName const* const a,
	gd_stringName const* const b
) {
	bool res;
................................................................................
	char* buf = _alloc(char, len);
	gdu_string_emit(s, buf, len - 1);
	return (pstr){buf,len};
}

static inline gd_string
gdu_string_dup (_ref(gd_string) s) {
	/* the godot copy method seems to be broken somehow,
	 * probably for reasons that have to do with the
	 * hypercomplicated CoW implementation that i think
	 * is meant to be handled on this end somehow? we
	 * can seemingly avoid crashes and memory corruption
	 * if we copy the string through C, forcing a clean
	 * new string to be generated on the godot side. */
	// _t(string).copy(&cp, (void const*[]) {s});
	auto cstr = gdu_string_pdup(s);
	auto copied = gdu_str_sz(cstr.v, cstr.sz);
	_drop(cstr);
	return copied;
}

#define _cat(x,y) x##y
#define __cat(x,y) _cat(x,y)
#define _gensym __cat(_sym_,__COUNTER__)

#define __gdu_string_auto(szid, name, str) \
................................................................................
static inline GDExtensionObjectPtr
gdu_cast
(	GDExtensionConstObjectPtr what,
	_ref(char)                to
) {
	return _t(object).castTo(what, gdu_classTag(to));
}

static inline void
gdu_setKey
(	gd_dictionary* const dict,
	pstr           const key,
	_ref(gd_variant)     val
) {
	gd_variant v = gd_variant_of_dictionary(*dict);
	_withSym(keyName, key, {
		uint8_t ok = false;
		_t(variant).setNamed(&v, &keyName, val, &ok);
	});
}