`TRANSMUTE()`: Fix input type size not being properly checked.

Fortune for naka's current commit: Blessing − 吉

include/macros.h

@@ -18,11 +18,13 @@
 
 #define _cold __attribute__((cold))
 #define _hot __attribute__((hot))
+#define _dead __attribute__((unused))
 
 #ifndef __cplusplus
 #define noreturn __attribute__((noreturn))
-#define deprecated __attribute__((deprecated))
+#define _deprecated __attribute__((deprecated))
-#define deprecated_message(str) __attribute__((deprecated(str))) 
+#define deprecated_message(str) __attribute__((deprecated(str)))
+#define _deprecated_msg(str) deprecated_message(str)
 #endif
 
 #define noinline __attribute__((noinline))
@@ -42,6 +44,31 @@
 #define restrict __restrict__
 #endif
 
+//  Function conventions
+
+#define _cconv__mixin _mixin
+#define _cconv__pure _pure
+#define _cconv__readonly _readonly
+#define _cconv__cold _cold
+#define _cconv__dead _dead
+#define _cconv__unused _dead
+#define _cconv__hot _hot
+#define _cconv__entry __attribute__((constructor))
+#define _cconv__exit __attribute__((destructor))
+
+// Allocates
+#define _cconv__alloc __attribute__((malloc))
+// Infallible alloc
+#define _cconv__ialloc __attribute__((malloc)) __attribute__((returns_nonnull))
+#define _cconv__nonnull __attribute__((returns_nonnull))
+
+#define _callcv(name) _cconv__ ## name
+#define _callconv(name) _callcv(name)
+
+#define _callat_entry _callcv(entry)
+#define _callat_exit  _callcv(exit)
+#define _callat(when) _callat_ ## when
+
 // Argument attribute
 
 // Used like: `int *pOUT output, const int *pIN input`
@@ -108,6 +135,8 @@ _mixin void _drain_val(void* x, ...) { IGNORE(x); } // This compiles to no-op on
 // Allocation macros
 
 #define box(t) aligned_alloc(_Alignof(t), sizeof(t))
+#define box_value(v) ({ let _box = box(var(v)); *_box = (v); _box; })
+#define unbox_value(v) ({ let _v = (v); let _res = *_v; free(_v); _res; })
 #define stackalloc(t) __builtin_alloca_with_align(sizeof(t), _Alignof(t))
 
 // Function macros
@@ -177,6 +206,15 @@ static_assert_eq(bswap(128lu), 9223372036854775808lu, "bswap128 (lu) failed (1)"
 static_assert_eq(128lu, bswap(9223372036854775808lu), "bswap128 (lu) failed (2)");
 static_assert_eq(bswap(bswap(128lu)), 128, "bswap128 (lu) failed (3)");
 
+// Transmute
+
+#define TRANSMUTE(val, type) ({ union _trans { var(val) input; type output; }; \
+				_Static_assert(sizeof(var(val)) == sizeof(type), "Cannot transmute values of different sizes"); \
+				_Static_assert(sizeof(union _trans) == sizeof(type), "Cannot transmute values of different sizes"); \
+				/* XXX: Do we need do check this for equality? Can we re-word it or do we even need it at all? _Static_assert(_Alignof(union _trans) == _Alignof(type), "Cannot transmute values of different alignments");*/ \
+				union _trans _trans__value = { .input = (val), }; \
+				_trans__value.output; })
+
 //  Trace message output
 
 #include "trace.h"
@@ -234,4 +272,9 @@ static_assert_eq(bswap(bswap(128lu)), 128, "bswap128 (lu) failed (3)");
 #define VERSION_REV(ver) _AS_u32(_AS_u32(ver) & 0xffu)
 _Static_assert( (VERSION_COMP(VERSION(1,2,3,4), VER_COMP_MIN) >> VER_COMP_MIN) == 2u, "invalid native version spec");
 
+// Misc.
+
+#define PTR_ASSIGN(ptr, val) ( (ptr) ? (*(ptr) = (val), (ptr)) : (ptr) )
+#define PTR_ASSIGNv(ptr, val) ({ let _ptr = (ptr); let _val = (val); PTR_ASSIGN(_ptr, _val); })
+
 #endif /* _MACROS_H */

include/str.h

@@ -0,0 +1,45 @@
+//! Better string handling
+#ifndef _STR_H
+#define _STR_H
+
+#include <macros.h>
+#include <ints.h>
+
+#define STRF_OWNED	AS(1ul << 5, int)
+#define STRF_DERRIVED 	AS(1ul << 6, int)
+enum str_ownership {
+	STR_NULL = 0,
+
+	STR_OWNED = STRF_OWNED,
+	STR_OWNED_STATIC,
+	STR_OWNED_MALLOC,
+	STR_OWNED_STACK,
+
+	STR_DERRIVED = STRF_DERRIVED,
+	STR_DERRIVED_STATIC,
+	STR_DERRIVED_MALLOC,
+	STR_DERRIVED_STACK,
+};
+
+//TODO: Complete rework
+typedef struct string {
+	usize len, cap;
+	struct str_meta {
+		struct string* _shared derrived;
+		_Atomic usize refs;
+		void (*m_free)(void*);
+
+		enum str_ownership owned;
+	} meta;
+	union {
+		char* slice;
+		char str[];
+	};
+} *str_t;
+
+str_t* str_alloc(usize cap) _cconv(alloc);
+char* str_new(const char* pIN cstr) _cconv(alloc);
+
+void str_free(str_t* restrict str);
+
+#endif /* _STR_H */

src/display.c

@@ -11,8 +11,101 @@
 #define FLAGSET(f, flag) (( (f) & (flag) ) == (flag))
 #define DFLAGSET(f, flagname) FLAGSET(f, DISPF_SHOW_ ## flagname)
 
-//TODO: This probably won't work. Write wrappers for strncpy(), strncat() that return number of bytes written isntead of useless pointer that we already have.
+#define CMP(x,cmp,y)  ( (x) cmp (y) ? (x) : (y) )
-static usize _display_get_fmt(dispflags_t flags, bool matched, usize _len, char str[pOUT _len])
+#define CMPv(x,cmp,y) ({ let _x = (x); let _y = (y); CMP(_x, cmp, _y); })
+#define MIN(x, y) CMP((x), <, (y))
+#define MINv(x, y) CMPv((x), <, (y))
+#define MAX(x, y) CMP((x), >, (y))
+#define MAXv(x, y) CMPv((x), >, (y))
+
+// Returns number of bytes written to `dest`. Otherwise same as `strncpy()`.
+static usize strncpy_n(char*pOUT dest, const char* restrict src, usize n)
+{
+	usize i;
+	for(i=0;i<n;i++)
+		if(! (*dest++ = *src++)) return i;
+	dest[i] = 0;
+	return i;
+}
+
+// Will not write past `dn` bytes of `dest`, will not read past `sn` bytes of `src`. Otherwise, same as `strncpy_n()`.
+static usize s_strncpy_n(usize sn, usize dn; char dest[static pOUT dn], usize dn, const char src[static restrict sn], usize sn)
+{
+	usize i;
+	usize n = MIN(sn,dn); 
+	for(i=0;i<n;i++)
+		if(! (*dest++ = *src++)) return i;
+	if(i<dn) dest[i] = 0;
+	return i;
+}
+
+// Will not write past `dn` bytes of `dest`, will not read past `sn` bytes of `src`. Otherwise, same as `strncat_n()`.
+static inline usize s_strncat_n(usize sn, usize dn; char dest[static pOUT dn], usize dn, const char src[static restrict sn], usize sn)
+{
+	usize dl = MINv(strlen(dest), dn);
+	return s_strncpy_n(dest + dl, dn - dl, src, sn);
+}
+
+// Returns number of bytes written to (dest+strlen(dest)). Otherwise same as `strncat()`.
+static inline usize strncat_n(char*pOUT dest, const char* restrict src, usize n)
+{
+	usize dl = strlen(dest);
+	return strncpy_n(dest+dl, src, n);
+}
+
+//TODO: This isn't working at all...
+#ifdef _DEBUG_USE_UNSAFE_DISPLAY_FMT_ARGS
+_dead
+#endif
+static usize _display_get_fmt_n(dispflags_t flags, bool matched, usize _n, char str[pOUT _n])
+{
+	register usize n = _n, fw=0;
+	const char* fmts[] = { 
+				DFLAGSET(flags, FAILURES) 
+				? "failure: " 
+				: "",  
+
+				"match: ", 
+				"%lu: ", 
+				SLICE_FORMAT, 
+				" (len %lu)", 
+				(const char*)NULL,
+	};
+	usize   w = s_strncpy_n(str, n, fmts[!!matched], n); // SAFETY: Will never read past `fmts[x]` nul-terminator, so setting n as both dest and src length here is safe.
+//TODO: Fix this... It isn't working...
+#define ADDSTR(s) do { \
+		debug_assert((s)); \
+		w = MINv(s_strncat_n(str, n, (s), n), n); \
+		/* Remove written from `n` */ \
+		n -= w; \
+		/* Check if we have written into the limit (if so, w will be equal to n above, since w is high-bounded to n by `MINv()` above. So if n is 0, we have hit the limit. */ \
+		ifU(!n) { \
+			/*XXX: Should this be `str[w-1]?` If this assert fails then yes it should. */ \
+			debug_assert(w < _n); \
+			str[w] = 0; \
+			return fw + w; \
+		} \
+		/* Increase `str` pointer by written */ \
+		str += w; \
+		/* Increase return value by written. */ \
+		fw += w; \
+	} while(0)
+
+	if(DFLAGSET(flags, NUMBER)) ADDSTR(fmts[2]);
+	if(DFLAGSET(flags, SLICE)) ADDSTR(fmts[3]);
+	if(DFLAGSET(flags, LENGTH)) ADDSTR(fmts[4]);
+	ADDSTR("\n");
+	TRACE("Output string written: %lu, (rlen %lu)", fw, n);
+#undef ADDSTR
+	return fw;
+}
+
+
+//XXX: This works, but seems inherantly unsafe. Rewrite to use the above `strn*_n()` functions for better length tracking.
+#ifndef _DEBUG_USE_UNSAFE_DISPLAY_FMT_ARGS
+_dead deprecated_message("this is unsafe, use `_display_get_fmt_n`") 
+#endif
+static usize _display_get_fmt0(dispflags_t flags, bool matched, usize _len, char str[pOUT _len])
 {
 	register usize len = _len;
 	static const char* fmts[] = { "match: ", "%lu: ", SLICE_FORMAT, " (len %lu)", "failure: ", (const char*)NULL };
@@ -30,6 +123,12 @@ static usize _display_get_fmt(dispflags_t flags, bool matched, usize _len, char
 #undef ADDSTR
 }
 
+#ifdef _DEBUG_USE_UNSAFE_DISPLAY_FMT_ARGS
+#define _display_get_fmt(...) _display_get_fmt0(__VA_ARGS__)
+#else
+#define _display_get_fmt(...) _display_get_fmt_n(__VA_ARGS__)
+#endif
+
 static void _display_normal(FILE* output, dispin_t*pIN input, dispflags_t flags)
 {
 	bool matched = input->matched;
@@ -49,9 +148,14 @@ static void _display_normal(FILE* output, dispin_t*pIN input, dispflags_t flags)
 #endif
 	INFO("Mapped region slice for %lu, pre-transform (at %p): " SLICE_FORMAT ", len: %lu", i+1, base, SLICE_FORMAT_ARGS(&cslice), cslice.len);
 
-	//Honour `flags`
+	// --- get format string from `flags` ---
 	char fmt[200]; //TODO: Find the realistic max for this.
-	fmt[_display_get_fmt(flags, matched, 100, fmt)] = 0;
+	usize fmtw = _display_get_fmt(flags, matched, sizeof(fmt)-1, fmt);
+	assert(fmtw+1 < sizeof(fmt));
+	fmt[fmtw+1] = 0;
+	// ---
+	TRACE("Format string get: `%s' (%lu)", fmt, fmtw);
+
 	fprintf(output, fmt, i+1, pos.start, pos.end, pos.end-pos.start);
 } 
 

src/str.c

@@ -0,0 +1,66 @@
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include <str.h>
+
+static str_t _str_alloc_new(usize reserve)
+{
+	return aligned_alloc(_Alignof(struct string), sizeof(struct string) + reserve + 1);
+}
+
+inline static str_t _str_unbox(str_t* restrict boxed)
+{
+	str_t unboxed = *boxed;
+	free(boxed);
+	return unboxed;
+}
+
+_cconv(alloc) str_t* str_alloc(usize cap)
+{
+	str_t unboxed = _str_alloc_new(cap);
+	unboxed->cap = cap;
+	unboxed->len = 0;
+	unboxed->meta = (struct str_meta){
+		.derrived = NULL,
+		.refs = 0,
+		.m_free = &free,
+		.owned = STR_OWNED_MALLOC,
+	};
+	memset(unboxed->str, 0, cap+1);
+
+	return box_value(unboxed);
+}
+
+void str_free(str_t* restrict str)
+{
+	str_t ub = _str_unbox(str);
+
+	void* to_free = (void*)ub;
+	let _cont[] = { &&_done, &&_finish_free_derrived };
+	usize cont = 0;
+	switch(ub->meta.owned) {
+		case STR_DERRIVED_MALLOC:
+			ub->meta.derrived->meta.refs -=1;
+			to_free = NULL;
+			cont = 1;
+		case STR_OWNED_MALLOC:
+			//TODO: How to handle this refcounting?
+			if(ub->meta.refs > 0) WARN("Freeing referenced string");
+			//if(ub->meta.refs == 0)
+			if(to_free)
+				(ub->meta.m_free ?: &free)(to_free);
+			/*else { 
+				ub->meta.refs -=1;
+				break;
+			}*/
+			goto _cont[cont];
+		_finish_free_derrived:
+			free(ub);
+		default:
+		_done:
+			break;
+	}
+		
+}

src/tests/transmute.c

@@ -0,0 +1,23 @@
+
+#include <string.h>
+
+#include <ints.h>
+#include <macros.h>
+#include <tests.h>
+
+DEFTEST(transmute_copy)
+{
+	static const u64 EXPECTED = 18446743474098365025lu;
+	struct { char i[4]; i32 u; } input = { .i = {'a','b','c','d'}, .u = -140 };
+	let output = TRANSMUTE(input, u64);
+	TRACE("Transmute test, expected 0x%lx, got 0x%lx", EXPECTED, output);
+	//XXX: TODO: This test will fail on Big Endian machines.
+	TEST_ASSERT(output == EXPECTED);
+	TRACE("Alignment of output: %lu, alignment of input: %lu", _Alignof(output), _Alignof(input));
+	let input2 = TRANSMUTE(output, var(input));
+	TRACE("Transmute output passed, trying to transmute back");
+	TEST_ASSERT( memcmp(&input2, &input, sizeof(input)) == 0 );
+
+	return TEST_OK;
+}
+RUNTEST_DEBUG(transmute_copy);