Drop unused wAbort function from WPrefs.app.

This tweaks the hashtable API, and it is incomplete because the WUtil proplist
impl depends heavily on a feature of the old API that is being discontinued.

Moving the proplist code into Rust is our next objective.

.gitignore

@@ -142,4 +142,4 @@ WPrefs.app/WPrefs.desktop
 .pc
 
 # Rust stuff.
-/wmakerlib/target/**
+/*/target/**

Makefile.am

@@ -39,7 +39,7 @@ ACLOCAL_AMFLAGS = -I m4
 AM_DISTCHECK_CONFIGURE_FLAGS = --enable-silent-rules LINGUAS='*'
 
 
-SUBDIRS = wrlib WINGs src util po WindowMaker wmlib WPrefs.app doc
+SUBDIRS = wrlib wutil-rs WINGs wmaker-rs src util po WindowMaker wmlib WPrefs.app doc
 DIST_SUBDIRS = $(SUBDIRS) test
 
 EXTRA_DIST = TODO BUGS BUGFORM FAQ INSTALL \

WINGs/Makefile.am

@@ -10,14 +10,17 @@ libWUtil_la_LDFLAGS = -version-info @WUTIL_VERSION@
 
 lib_LTLIBRARIES = libWUtil.la libWINGs.la
 
+wutilrs = $(top_builddir)/wutil-rs/target/debug/libwutil_rs.a
+wraster = $(top_builddir)/wrlib/libwraster.la
 
-LDADD= libWUtil.la libWINGs.la $(top_builddir)/wrlib/libwraster.la @INTLIBS@
+LDADD= libWUtil.la libWINGs.la $(wraster) $(wutilrs) @INTLIBS@
-libWINGs_la_LIBADD = libWUtil.la $(top_builddir)/wrlib/libwraster.la @XLIBS@ @XFT_LIBS@ @FCLIBS@ @LIBM@ @PANGO_LIBS@
+libWINGs_la_LIBADD = libWUtil.la $(wraster) $(wutilrs) @XLIBS@ @XFT_LIBS@ @FCLIBS@ @LIBM@ @PANGO_LIBS@
-libWUtil_la_LIBADD = @LIBBSD@
+libWUtil_la_LIBADD = @LIBBSD@ $(wutilrs)
 
 EXTRA_DIST = BUGS make-rgb Examples Extras Tests
 
 
+
 # wbutton.c
 libWINGs_la_SOURCES = 	\
 	configuration.c \
@@ -69,8 +72,6 @@ libWUtil_la_SOURCES = 	\
 	error.h \
 	findfile.c \
 	handlers.c \
-	hashtable.c \
-	memory.c \
 	menuparser.c \
 	menuparser.h \
 	menuparser_macros.c \

WINGs/WINGs/WUtil.h

@@ -169,10 +169,6 @@ typedef struct {
     unsigned 	(*hash)(const void *);
     /* NULL is pointer compare */
     Bool	(*keyIsEqual)(const void *, const void *);
-    /* NULL does nothing */
-    void*	(*retainKey)(const void *);
-    /* NULL does nothing */
-    void	(*releaseKey)(const void *);
 } WMHashTableCallbacks;
 
 
@@ -213,10 +209,6 @@ void wfree(void *ptr);
 void wrelease(void *ptr);
 void* wretain(void *ptr);
 
-typedef void waborthandler(int);
-
-waborthandler* wsetabort(waborthandler* handler);
-
 /* ---[ WINGs/error.c ]--------------------------------------------------- */
 
 enum {
@@ -342,7 +334,8 @@ void WHandleEvents(void);
 /* ---[ WINGs/hashtable.c ]----------------------------------------------- */
 
 
-WMHashTable* WMCreateHashTable(const WMHashTableCallbacks callbacks);
+WMHashTable* WMCreateIdentityHashTable();
+WMHashTable* WMCreateStringHashTable();
 
 void WMFreeHashTable(WMHashTable *table);
 
@@ -392,10 +385,6 @@ Bool WMNextHashEnumeratorItemAndKey(WMHashEnumerator *enumerator,
 extern const WMHashTableCallbacks WMIntHashCallbacks;
 /* sizeof(keys) are <= sizeof(void*) */
 
-extern const WMHashTableCallbacks WMStringHashCallbacks;
-/* keys are strings. Strings will be copied with wstrdup()
- * and freed with wfree() */
-
 extern const WMHashTableCallbacks WMStringPointerHashCallbacks;
 /* keys are strings, but they are not copied */
 

WINGs/hashtable.c

@@ -1,422 +0,0 @@
-#include <config.h>
-
-#include <sys/types.h>
-#include <string.h>
-#include <stdlib.h>
-#include <stdio.h>
-
-#include "WUtil.h"
-
-#define INITIAL_CAPACITY	23
-
-
-typedef struct HashItem {
-	const void *key;
-	const void *data;
-
-	struct HashItem *next;	/* collided item list */
-} HashItem;
-
-typedef struct W_HashTable {
-	WMHashTableCallbacks callbacks;
-
-	unsigned itemCount;
-	unsigned size;		/* table size */
-
-	HashItem **table;
-} HashTable;
-
-#define HASH(table, key)  (((table)->callbacks.hash ? \
-    (*(table)->callbacks.hash)(key) : hashPtr(key)) % (table)->size)
-
-#define DUPKEY(table, key) ((table)->callbacks.retainKey ? \
-    (*(table)->callbacks.retainKey)(key) : (key))
-
-#define RELKEY(table, key) if ((table)->callbacks.releaseKey) \
-    (*(table)->callbacks.releaseKey)(key)
-
-static inline unsigned hashString(const void *param)
-{
-	const char *key = param;
-	unsigned ret = 0;
-	unsigned ctr = 0;
-
-	while (*key) {
-		ret ^= *key++ << ctr;
-		ctr = (ctr + 1) % sizeof(char *);
-	}
-
-	return ret;
-}
-
-static inline unsigned hashPtr(const void *key)
-{
-	return ((size_t) key / sizeof(char *));
-}
-
-static void rellocateItem(WMHashTable * table, HashItem * item)
-{
-	unsigned h;
-
-	h = HASH(table, item->key);
-
-	item->next = table->table[h];
-	table->table[h] = item;
-}
-
-static void rebuildTable(WMHashTable * table)
-{
-	HashItem *next;
-	HashItem **oldArray;
-	int i;
-	int oldSize;
-	int newSize;
-
-	oldArray = table->table;
-	oldSize = table->size;
-
-	newSize = table->size * 2;
-
-	table->table = wmalloc(sizeof(char *) * newSize);
-	table->size = newSize;
-
-	for (i = 0; i < oldSize; i++) {
-		while (oldArray[i] != NULL) {
-			next = oldArray[i]->next;
-			rellocateItem(table, oldArray[i]);
-			oldArray[i] = next;
-		}
-	}
-	wfree(oldArray);
-}
-
-WMHashTable *WMCreateHashTable(const WMHashTableCallbacks callbacks)
-{
-	HashTable *table;
-
-	table = wmalloc(sizeof(HashTable));
-
-	table->callbacks = callbacks;
-
-	table->size = INITIAL_CAPACITY;
-
-	table->table = wmalloc(sizeof(HashItem *) * table->size);
-
-	return table;
-}
-
-void WMResetHashTable(WMHashTable * table)
-{
-	HashItem *item, *tmp;
-	int i;
-
-	for (i = 0; i < table->size; i++) {
-		item = table->table[i];
-		while (item) {
-			tmp = item->next;
-			RELKEY(table, item->key);
-			wfree(item);
-			item = tmp;
-		}
-	}
-
-	table->itemCount = 0;
-
-	if (table->size > INITIAL_CAPACITY) {
-		wfree(table->table);
-		table->size = INITIAL_CAPACITY;
-		table->table = wmalloc(sizeof(HashItem *) * table->size);
-	} else {
-		memset(table->table, 0, sizeof(HashItem *) * table->size);
-	}
-}
-
-void WMFreeHashTable(WMHashTable * table)
-{
-	HashItem *item, *tmp;
-	int i;
-
-	for (i = 0; i < table->size; i++) {
-		item = table->table[i];
-		while (item) {
-			tmp = item->next;
-			RELKEY(table, item->key);
-			wfree(item);
-			item = tmp;
-		}
-	}
-	wfree(table->table);
-	wfree(table);
-}
-
-unsigned WMCountHashTable(WMHashTable * table)
-{
-	return table->itemCount;
-}
-
-static HashItem *hashGetItem(WMHashTable *table, const void *key)
-{
-	unsigned h;
-	HashItem *item;
-
-	h = HASH(table, key);
-	item = table->table[h];
-
-	if (table->callbacks.keyIsEqual) {
-		while (item) {
-			if ((*table->callbacks.keyIsEqual) (key, item->key)) {
-				break;
-			}
-			item = item->next;
-		}
-	} else {
-		while (item) {
-			if (key == item->key) {
-				break;
-			}
-			item = item->next;
-		}
-	}
-	return item;
-}
-
-void *WMHashGet(WMHashTable * table, const void *key)
-{
-	HashItem *item;
-
-	item = hashGetItem(table, key);
-	if (!item)
-		return NULL;
-	return (void *)item->data;
-}
-
-Bool WMHashGetItemAndKey(WMHashTable * table, const void *key, void **retItem, void **retKey)
-{
-	HashItem *item;
-
-	item = hashGetItem(table, key);
-	if (!item)
-		return False;
-
-	if (retKey)
-		*retKey = (void *)item->key;
-	if (retItem)
-		*retItem = (void *)item->data;
-	return True;
-}
-
-void *WMHashInsert(WMHashTable * table, const void *key, const void *data)
-{
-	unsigned h;
-	HashItem *item;
-	int replacing = 0;
-
-	h = HASH(table, key);
-	/* look for the entry */
-	item = table->table[h];
-	if (table->callbacks.keyIsEqual) {
-		while (item) {
-			if ((*table->callbacks.keyIsEqual) (key, item->key)) {
-				replacing = 1;
-				break;
-			}
-			item = item->next;
-		}
-	} else {
-		while (item) {
-			if (key == item->key) {
-				replacing = 1;
-				break;
-			}
-			item = item->next;
-		}
-	}
-
-	if (replacing) {
-		const void *old;
-
-		old = item->data;
-		item->data = data;
-		RELKEY(table, item->key);
-		item->key = DUPKEY(table, key);
-
-		return (void *)old;
-	} else {
-		HashItem *nitem;
-
-		nitem = wmalloc(sizeof(HashItem));
-		nitem->key = DUPKEY(table, key);
-		nitem->data = data;
-		nitem->next = table->table[h];
-		table->table[h] = nitem;
-
-		table->itemCount++;
-	}
-
-	/* OPTIMIZE: put this in an idle handler. */
-	if (table->itemCount > table->size) {
-#ifdef DEBUG0
-		printf("rebuilding hash table...\n");
-#endif
-		rebuildTable(table);
-#ifdef DEBUG0
-		printf("finished rebuild.\n");
-#endif
-	}
-
-	return NULL;
-}
-
-static HashItem *deleteFromList(HashTable * table, HashItem * item, const void *key)
-{
-	HashItem *next;
-
-	if (item == NULL)
-		return NULL;
-
-	if ((table->callbacks.keyIsEqual && (*table->callbacks.keyIsEqual) (key, item->key))
-	    || (!table->callbacks.keyIsEqual && key == item->key)) {
-
-		next = item->next;
-		RELKEY(table, item->key);
-		wfree(item);
-
-		table->itemCount--;
-
-		return next;
-	}
-
-	item->next = deleteFromList(table, item->next, key);
-
-	return item;
-}
-
-void WMHashRemove(WMHashTable * table, const void *key)
-{
-	unsigned h;
-
-	h = HASH(table, key);
-
-	table->table[h] = deleteFromList(table, table->table[h], key);
-}
-
-WMHashEnumerator WMEnumerateHashTable(WMHashTable * table)
-{
-	WMHashEnumerator enumerator;
-
-	enumerator.table = table;
-	enumerator.index = 0;
-	enumerator.nextItem = table->table[0];
-
-	return enumerator;
-}
-
-void *WMNextHashEnumeratorItem(WMHashEnumerator * enumerator)
-{
-	const void *data = NULL;
-
-	/* this assumes the table doesn't change between
-	 * WMEnumerateHashTable() and WMNextHashEnumeratorItem() calls */
-
-	if (enumerator->nextItem == NULL) {
-		HashTable *table = enumerator->table;
-		while (++enumerator->index < table->size) {
-			if (table->table[enumerator->index] != NULL) {
-				enumerator->nextItem = table->table[enumerator->index];
-				break;
-			}
-		}
-	}
-
-	if (enumerator->nextItem) {
-		data = ((HashItem *) enumerator->nextItem)->data;
-		enumerator->nextItem = ((HashItem *) enumerator->nextItem)->next;
-	}
-
-	return (void *)data;
-}
-
-void *WMNextHashEnumeratorKey(WMHashEnumerator * enumerator)
-{
-	const void *key = NULL;
-
-	/* this assumes the table doesn't change between
-	 * WMEnumerateHashTable() and WMNextHashEnumeratorKey() calls */
-
-	if (enumerator->nextItem == NULL) {
-		HashTable *table = enumerator->table;
-		while (++enumerator->index < table->size) {
-			if (table->table[enumerator->index] != NULL) {
-				enumerator->nextItem = table->table[enumerator->index];
-				break;
-			}
-		}
-	}
-
-	if (enumerator->nextItem) {
-		key = ((HashItem *) enumerator->nextItem)->key;
-		enumerator->nextItem = ((HashItem *) enumerator->nextItem)->next;
-	}
-
-	return (void *)key;
-}
-
-Bool WMNextHashEnumeratorItemAndKey(WMHashEnumerator * enumerator, void **item, void **key)
-{
-	/* this assumes the table doesn't change between
-	 * WMEnumerateHashTable() and WMNextHashEnumeratorItemAndKey() calls */
-
-	if (enumerator->nextItem == NULL) {
-		HashTable *table = enumerator->table;
-		while (++enumerator->index < table->size) {
-			if (table->table[enumerator->index] != NULL) {
-				enumerator->nextItem = table->table[enumerator->index];
-				break;
-			}
-		}
-	}
-
-	if (enumerator->nextItem) {
-		if (item)
-			*item = (void *)((HashItem *) enumerator->nextItem)->data;
-		if (key)
-			*key = (void *)((HashItem *) enumerator->nextItem)->key;
-		enumerator->nextItem = ((HashItem *) enumerator->nextItem)->next;
-
-		return True;
-	}
-
-	return False;
-}
-
-static Bool compareStrings(const void *param1, const void *param2)
-{
-	const char *key1 = param1;
-	const char *key2 = param2;
-
-	return strcmp(key1, key2) == 0;
-}
-
-typedef void *(*retainFunc) (const void *);
-typedef void (*releaseFunc) (const void *);
-
-const WMHashTableCallbacks WMIntHashCallbacks = {
-	NULL,
-	NULL,
-	NULL,
-	NULL
-};
-
-const WMHashTableCallbacks WMStringHashCallbacks = {
-	hashString,
-	compareStrings,
-	(retainFunc) wstrdup,
-	(releaseFunc) wfree
-};
-
-const WMHashTableCallbacks WMStringPointerHashCallbacks = {
-	hashString,
-	compareStrings,
-	NULL,
-	NULL
-};

WINGs/memory.c

@@ -1,223 +0,0 @@
-/*
- *  Window Maker miscelaneous function library
- *
- *  Copyright (c) 1997-2003 Alfredo K. Kojima
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
- *  MA 02110-1301, USA.
- */
-
-#include "wconfig.h"
-#include "WUtil.h"
-
-#include <stdlib.h>
-#include <sys/types.h>
-#include <unistd.h>
-#include <stdio.h>
-#include <string.h>
-#include <assert.h>
-#include <signal.h>
-
-#ifdef HAVE_STDNORETURN
-#include <stdnoreturn.h>
-#endif
-
-#ifdef USE_BOEHM_GC
-#ifndef GC_DEBUG
-#define GC_DEBUG
-#endif /* !GC_DEBUG */
-#include <gc/gc.h>
-#endif /* USE_BOEHM_GC */
-
-#ifndef False
-# define False 0
-#endif
-#ifndef True
-# define True 1
-#endif
-
-static void defaultHandler(int bla)
-{
-	if (bla)
-		kill(getpid(), SIGABRT);
-	else
-		exit(1);
-}
-
-static waborthandler *aborthandler = defaultHandler;
-
-static inline noreturn void wAbort(int bla)
-{
-	(*aborthandler)(bla);
-	exit(-1);
-}
-
-waborthandler *wsetabort(waborthandler * handler)
-{
-	waborthandler *old = aborthandler;
-
-	aborthandler = handler;
-
-	return old;
-}
-
-static int Aborting = 0;	/* if we're in the middle of an emergency exit */
-
-static WMHashTable *table = NULL;
-
-void *wmalloc(size_t size)
-{
-	void *tmp;
-
-	assert(size > 0);
-
-#ifdef USE_BOEHM_GC
-	tmp = GC_MALLOC(size);
-#else
-	tmp = malloc(size);
-#endif
-	if (tmp == NULL) {
-		wwarning("malloc() failed. Retrying after 2s.");
-		sleep(2);
-#ifdef USE_BOEHM_GC
-		tmp = GC_MALLOC(size);
-#else
-		tmp = malloc(size);
-#endif
-		if (tmp == NULL) {
-			if (Aborting) {
-				fputs("Really Bad Error: recursive malloc() failure.", stderr);
-				exit(-1);
-			} else {
-				wfatal("virtual memory exhausted");
-				Aborting = 1;
-				wAbort(False);
-			}
-		}
-	}
-	if (tmp != NULL)
-		memset(tmp, 0, size);
-	return tmp;
-}
-
-void *wrealloc(void *ptr, size_t newsize)
-{
-	void *nptr;
-
-	if (!ptr) {
-		nptr = wmalloc(newsize);
-	} else if (newsize == 0) {
-		wfree(ptr);
-		nptr = NULL;
-	} else {
-#ifdef USE_BOEHM_GC
-		nptr = GC_REALLOC(ptr, newsize);
-#else
-		nptr = realloc(ptr, newsize);
-#endif
-		if (nptr == NULL) {
-			wwarning("realloc() failed. Retrying after 2s.");
-			sleep(2);
-#ifdef USE_BOEHM_GC
-			nptr = GC_REALLOC(ptr, newsize);
-#else
-			nptr = realloc(ptr, newsize);
-#endif
-			if (nptr == NULL) {
-				if (Aborting) {
-					fputs("Really Bad Error: recursive realloc() failure.", stderr);
-					exit(-1);
-				} else {
-					wfatal("virtual memory exhausted");
-					Aborting = 1;
-					wAbort(False);
-				}
-			}
-		}
-	}
-	return nptr;
-}
-
-void *wretain(void *ptr)
-{
-	int *refcount;
-
-	if (!table) {
-		table = WMCreateHashTable(WMIntHashCallbacks);
-	}
-
-	refcount = WMHashGet(table, ptr);
-	if (!refcount) {
-		refcount = wmalloc(sizeof(int));
-		*refcount = 1;
-		WMHashInsert(table, ptr, refcount);
-#ifdef VERBOSE
-		printf("== %i (%p)\n", *refcount, ptr);
-#endif
-	} else {
-		(*refcount)++;
-#ifdef VERBOSE
-		printf("+ %i (%p)\n", *refcount, ptr);
-#endif
-	}
-
-	return ptr;
-}
-
-void wfree(void *ptr)
-{
-	if (ptr)
-#ifdef USE_BOEHM_GC
-		/* This should eventually be removed, once the criss-cross
-		 * of wmalloc()d memory being free()d, malloc()d memory being
-		 * wfree()d, various misuses of calling wfree() on objects
-		 * allocated by libc malloc() and calling libc free() on
-		 * objects allocated by Boehm GC (think external libraries)
-		 * is cleaned up.
-		 */
-		if (GC_base(ptr) != 0)
-			GC_FREE(ptr);
-		else
-			free(ptr);
-#else
-		free(ptr);
-#endif
-	ptr = NULL;
-}
-
-void wrelease(void *ptr)
-{
-	int *refcount;
-
-	refcount = WMHashGet(table, ptr);
-	if (!refcount) {
-		wwarning("trying to release unexisting data %p", ptr);
-	} else {
-		(*refcount)--;
-		if (*refcount < 1) {
-#ifdef VERBOSE
-			printf("RELEASING %p\n", ptr);
-#endif
-			WMHashRemove(table, ptr);
-			wfree(refcount);
-			wfree(ptr);
-		}
-#ifdef VERBOSE
-		else {
-			printf("- %i (%p)\n", *refcount, ptr);
-		}
-#endif
-	}
-}

WINGs/notification.c

@@ -88,10 +88,10 @@ static NotificationCenter *notificationCenter = NULL;
 void W_InitNotificationCenter(void)
 {
 	notificationCenter = wmalloc(sizeof(NotificationCenter));
-	notificationCenter->nameTable = WMCreateHashTable(WMStringPointerHashCallbacks);
+	notificationCenter->nameTable = WMCreateStringHashTable();
-	notificationCenter->objectTable = WMCreateHashTable(WMIntHashCallbacks);
+	notificationCenter->objectTable = WMCreateIdentityHashTable();
 	notificationCenter->nilList = NULL;
-	notificationCenter->observerTable = WMCreateHashTable(WMIntHashCallbacks);
+	notificationCenter->observerTable = WMCreateIdentityHashTable();
 }
 
 void W_ReleaseNotificationCenter(void)

WINGs/proplist.c

@@ -60,8 +60,6 @@ typedef Bool(*isEqualFunc) (const void *, const void *);
 static const WMHashTableCallbacks WMPropListHashCallbacks = {
 	hashPropList,
 	(isEqualFunc) WMIsPropListEqualTo,
-	NULL,
-	NULL
 };
 
 static Bool caseSensitive = True;
@@ -990,7 +988,7 @@ WMPropList *WMCreatePLDictionary(WMPropList * key, WMPropList * value, ...)
 
 	plist = (WMPropList *) wmalloc(sizeof(W_PropList));
 	plist->type = WPLDictionary;
-	plist->d.dict = WMCreateHashTable(WMPropListHashCallbacks);
+	plist->d.dict = WMCreatePropListHashTable();
 	plist->retainCount = 1;
 
 	if (!key || !value)

WINGs/wballoon.c

@@ -65,7 +65,7 @@ struct W_Balloon *W_CreateBalloon(WMScreen * scr)
 	W_ResizeView(bPtr->view, DEFAULT_WIDTH, DEFAULT_HEIGHT);
 	bPtr->flags.alignment = DEFAULT_ALIGNMENT;
 
-	bPtr->table = WMCreateHashTable(WMIntHashCallbacks);
+	bPtr->table = WMCreateIdentityHashTable();
 
 	bPtr->delay = DEFAULT_DELAY;
 

WINGs/wfontpanel.c

@@ -535,7 +535,7 @@ static void listFamilies(WMScreen * scr, WMFontPanel * panel)
 	if (pat)
 		FcPatternDestroy(pat);
 
-	families = WMCreateHashTable(WMStringPointerHashCallbacks);
+	families = WMCreateStringHashTable();
 
 	if (fs) {
 		for (i = 0; i < fs->nfont; i++) {

WINGs/widgets.c

@@ -630,7 +630,7 @@ WMScreen *WMCreateScreenWithRContext(Display * display, int screen, RContext * c
 
 	scrPtr->rootWin = RootWindow(display, screen);
 
-	scrPtr->fontCache = WMCreateHashTable(WMStringPointerHashCallbacks);
+	scrPtr->fontCache = WMCreateStringHashTable();
 
 	scrPtr->xftdraw = XftDrawCreate(scrPtr->display, W_DRAWABLE(scrPtr), scrPtr->visual, scrPtr->colormap);
 

WPrefs.app/Makefile.am

@@ -66,6 +66,8 @@ AM_CPPFLAGS = -DRESOURCE_PATH=\"$(wpdatadir)\" -DWMAKER_RESOURCE_PATH=\"$(pkgdat
 WPrefs_DEPENDENCIES = $(top_builddir)/WINGs/libWINGs.la
 
 WPrefs_LDADD = \
+	$(top_builddir)/wutil-rs/target/debug/libwutil_rs.a\
+	$(top_builddir)/wings-rs/target/debug/libwings_rs.la\
 	$(top_builddir)/WINGs/libWINGs.la\
 	$(top_builddir)/WINGs/libWUtil.la\
 	$(top_builddir)/wrlib/libwraster.la \

WPrefs.app/main.c

@@ -47,14 +47,6 @@ struct {
 static pid_t DeadChildren[MAX_DEATHS];
 static int DeadChildrenCount = 0;
 
-static noreturn void wAbort(Bool foo)
-{
-	/* Parameter not used, but tell the compiler that it is ok */
-	(void) foo;
-
-	exit(1);
-}
-
 static void print_help(const char *progname)
 {
 	printf(_("usage: %s [options]\n"), progname);
@@ -87,8 +79,6 @@ int main(int argc, char **argv)
 	int i;
 	char *display_name = "";
 
-	wsetabort(wAbort);
-
 	memset(DeadHandlers, 0, sizeof(DeadHandlers));
 
 	WMInitializeApplication("WPrefs", &argc, argv);

configure.ac

@@ -49,6 +49,15 @@ AC_CONFIG_SRCDIR([src/WindowMaker.h])
 dnl Include at the end of 'config.h', this file is generated by top-level Makefile
 AH_BOTTOM([@%:@include "config-paths.h"])
 
+dnl Rust support
+AC_CHECK_PROG(CARGO, [cargo], [yes], [no])
+AS_IF(test x$CARGO = xno,
+    AC_MSG_ERROR([cargo is required.  Please set the CARGO environment variable or install the Rust toolchain from https://www.rust-lang.org/])
+)
+AC_CHECK_PROG(RUSTC, [rustc], [yes], [no])
+AS_IF(test x$RUSTC = xno,
+    AC_MSG_ERROR([rustc is required.  Please set the RUSTC environment variable or install the Rust toolchain from https://www.rust-lang.org/])
+)
 
 dnl libtool library versioning
 dnl ==========================
@@ -342,24 +351,6 @@ AS_IF([test "x$enable_mwm_hints" = "xno"],
 AM_CONDITIONAL([USE_MWM_HINTS], [test "x$enable_mwm_hints" != "xno"])
 
 
-dnl Boehm GC
-dnl ========
-m4_divert_push([INIT_PREPARE])dnl
-AC_ARG_ENABLE([boehm-gc],
-    [AS_HELP_STRING([--enable-boehm-gc], [use Boehm GC instead of the default libc malloc() [default=no]])],
-    [AS_CASE(["$enableval"],
-        [yes], [with_boehm_gc=yes],
-        [no],  [with_boehm_gc=no],
-        [AC_MSG_ERROR([bad value $enableval for --enable-boehm-gc])] )],
-    [with_boehm_gc=no])
-m4_divert_pop([INIT_PREPARE])dnl
-
-AS_IF([test "x$with_boehm_gc" = "xyes"],
-    AC_SEARCH_LIBS([GC_malloc], [gc],
-        [AC_DEFINE(USE_BOEHM_GC, 1, [Define if Boehm GC is to be used])],
-        [AC_MSG_FAILURE([--enable-boehm-gc specified but test for libgc failed])]))
-
-
 dnl LCOV
 dnl ====
 m4_divert_push([INIT_PREPARE])dnl
@@ -964,11 +955,17 @@ AC_CONFIG_FILES(
     wrlib/Makefile wrlib/po/Makefile
     wrlib/tests/Makefile
 
+    dnl Rust implementation of WINGs libraries
+    wutil-rs/Makefile
+
     dnl WINGs toolkit
     WINGs/Makefile WINGs/WINGs/Makefile WINGs/po/Makefile
     WINGs/Documentation/Makefile WINGs/Resources/Makefile WINGs/Extras/Makefile
     WINGs/Examples/Makefile WINGs/Tests/Makefile
 
+    dnl Rust implementation of Window Maker core
+    wmaker-rs/Makefile
+
     dnl Window Maker's core
     src/Makefile src/wconfig.h po/Makefile
     doc/Makefile doc/build/Makefile

doc/build/Compilation.texi

@@ -253,14 +253,6 @@ If found, then the library @emph{WRaster} can use the @emph{ImageMagick} library
 @sc{Window Maker} support more image formats, like @emph{SVG}, @emph{BMP}, @emph{TGA}, ...
 You can get it from @uref{http://www.imagemagick.org/}
 
-@item @emph{Boehm GC}
-
-This library can be used by the @emph{WINGs} utility toolkit to use a
-@cite{Boehm-Demers-Weiser Garbage Collector} instead of the traditional
-@command{malloc}/@command{free} functions from the @emph{libc}.
-You have to explicitly ask for its support though (@pxref{Configure Options}).
-You can get it from @uref{http://www.hboehm.info/gc/}
-
 @end itemize
 
 
@@ -468,8 +460,6 @@ You can find more information about the libraries in the
 @ref{Optional Dependencies}.
 
 @table @option
-@item --enable-boehm-gc
-Never enabled by default, use Boehm GC instead of the default @emph{libc} @command{malloc()}
 
 @item --disable-gif
 Disable GIF support in @emph{WRaster} library; when enabled use @file{libgif} or @file{libungif}.

src/Makefile.am

@@ -6,13 +6,7 @@ bin_PROGRAMS = wmaker
 
 EXTRA_DIST =
 
-wmakerlib = $(top_builddir)/wmakerlib/target/debug/libwmakerlib.a
-
-$(wmakerlib):
-	@(cd $(top_builddir)/wmakerlib && cargo build)
-
 wmaker_SOURCES = 	\
-	$(wmakerlib) \
 	GNUstep.h \
 	WindowMaker.h \
 	actions.c \
@@ -140,7 +134,7 @@ else
 nodist_wmaker_SOURCES = misc.hack_nf.c \
 	xmodifier.hack_nf.c
 
-CLEANFILES = $(nodist_wmaker_SOURCES) ../wmakerlib/target
+CLEANFILES = $(nodist_wmaker_SOURCES)
 
 misc.hack_nf.c: misc.c $(top_srcdir)/script/nested-func-to-macro.sh
 	$(AM_V_GEN)$(top_srcdir)/script/nested-func-to-macro.sh \
@@ -166,7 +160,8 @@ wmaker_LDADD = \
 	$(top_builddir)/WINGs/libWINGs.la\
 	$(top_builddir)/WINGs/libWUtil.la\
 	$(top_builddir)/wrlib/libwraster.la\
-	$(wmakerlib)\
+	$(top_builddir)/wutil-rs/target/debug/libwutil_rs.a\
+	$(top_builddir)/wmaker-rs/target/debug/libwmaker_rs.a\
 	@XLFLAGS@ \
 	@LIBXRANDR@ \
 	@LIBXINERAMA@ \

src/main.c

@@ -624,7 +624,6 @@ static int real_main(int argc, char **argv)
 	int d, s;
 
 	setlocale(LC_ALL, "");
-	wsetabort(wAbort);
 
 	/* for telling WPrefs what's the name of the wmaker binary being ran */
 	setenv("WMAKER_BIN_NAME", argv[0], 1);

wmaker-rs/Cargo.toml

@@ -1,5 +1,5 @@
 [package]
-name = "wmakerlib"
+name = "wmaker-rs"
 version = "0.1.0"
 edition = "2024"
 

wmaker-rs/Makefile.am

@@ -0,0 +1,33 @@
+# automake input file for wmaker-rs
+
+AUTOMAKE_OPTIONS =
+
+RUST_SOURCES = \
+	src/app_icon.rs \
+	src/application.rs \
+	src/app_menu.rs \
+	src/defaults.rs \
+	src/dock.rs \
+	src/global.rs \
+	src/icon.rs \
+	src/lib.rs \
+	src/menu.rs \
+	src/properties.rs \
+	src/screen.rs \
+	src/window.rs \
+	src/wings.rs \
+	src/wrlib.rs
+
+RUST_EXTRA = \
+	Cargo.lock
+
+target/debug/libwmaker_rs.a: $(RUST_SOURCES) $(RUST_EXTRA)
+	$(CARGO) build
+
+check-local:
+	$(CARGO) test
+
+clean-local:
+	$(CARGO) clean
+
+all: target/debug/libwmaker_rs.a

wutil-rs/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "wutil-rs"
+version = "0.1.0"
+edition = "2024"
+
+[lib]
+crate-type = ["staticlib"]
+
+[dependencies]
+hashbrown = "0.16.0"
+libc = "0.2.175"
+x11 = "2.21.0"

wutil-rs/Makefile.am

@@ -0,0 +1,21 @@
+AUTOMAKE_OPTIONS =
+
+RUST_SOURCES = \
+	src/hash_table.rs \
+	src/lib.rs \
+	src/memory.rs
+
+RUST_EXTRA = \
+	Cargo.lock \
+	Cargo.toml
+
+target/debug/libwutil_rs.a: $(RUST_SOURCES) $(RUST_EXTRA)
+	$(CARGO) build
+
+check-local:
+	$(CARGO) test
+
+clean-local:
+	$(CARGO) clean
+
+all: target/debug/libwutil_rs.a

wutil-rs/src/hash_table.rs

@@ -0,0 +1,328 @@
+use hashbrown::hash_map::{self, HashMap};
+
+use std::{
+    borrow::Borrow,
+    ffi::{CStr, c_void},
+    hash::{Hash, Hasher},
+    mem,
+};
+
+pub enum HashTable {
+    PointerKeyed(HashMap<VoidPointer, VoidPointer>),
+    StringKeyed(HashMap<StringPointer, VoidPointer>),
+}
+
+impl HashTable {
+    pub fn new_pointer_keyed() -> Self {
+        HashTable::PointerKeyed(HashMap::new())
+    }
+
+    pub fn new_string_keyed() -> Self {
+        HashTable::StringKeyed(HashMap::new())
+    }
+
+    pub fn clear(&mut self) {
+        match self {
+            HashTable::PointerKeyed(m) => m.clear(),
+            HashTable::StringKeyed(m) => m.clear(),
+        }
+    }
+
+    pub fn len(&self) -> usize {
+        match self {
+            HashTable::PointerKeyed(m) => m.len(),
+            HashTable::StringKeyed(m) => m.len(),
+        }
+    }
+
+    pub unsafe fn get(&self, key: *const i8) -> Option<*mut i8> {
+        match self {
+            HashTable::PointerKeyed(m) => {
+                let key = key.cast_mut();
+                m.get(&key).map(|x| x.0)
+            }
+            HashTable::StringKeyed(m) => {
+                let key = StringPointer(key.cast_mut());
+                let v = m.get(&key).map(|x| x.0);
+                mem::forget(key);
+                v
+            }
+        }
+    }
+
+    pub unsafe fn insert(&mut self, key: *mut i8, data: VoidPointer) -> Option<VoidPointer> {
+        match self {
+            HashTable::PointerKeyed(m) => m.insert(VoidPointer(key), data),
+            HashTable::StringKeyed(m) => m.insert(StringPointer(key), data),
+        }
+    }
+
+    pub unsafe fn remove(&mut self, key: *const i8) {
+        match self {
+            HashTable::PointerKeyed(m) => {
+                let key = key.cast_mut();
+                m.remove(&key);
+            }
+            HashTable::StringKeyed(m) => {
+                let key = StringPointer(key.cast_mut());
+                m.remove(&key);
+                mem::forget(key);
+            }
+        }
+    }
+}
+
+#[derive(Debug, Eq, PartialEq, Hash)]
+#[repr(transparent)]
+pub struct VoidPointer(*mut i8);
+
+impl Drop for VoidPointer {
+    fn drop(&mut self) {
+        unsafe { libc::free(self.0.cast::<c_void>()) }
+    }
+}
+
+impl Borrow<*mut i8> for VoidPointer {
+    fn borrow(&self) -> &*mut i8 {
+        &self.0
+    }
+}
+
+#[derive(Debug)]
+#[repr(transparent)]
+pub struct StringPointer(*mut i8);
+
+impl PartialEq for StringPointer {
+    fn eq(&self, other: &Self) -> bool {
+        match (self.0.is_null(), other.0.is_null()) {
+            (true, true) => true,
+            (true, false) => false,
+            (false, true) => false,
+            (false, false) => unsafe { CStr::from_ptr(self.0) == CStr::from_ptr(other.0) },
+        }
+    }
+}
+
+impl Eq for StringPointer {}
+
+impl Hash for StringPointer {
+    fn hash<H: Hasher>(&self, h: &mut H) {
+        if self.0.is_null() {
+            h.write_usize(0)
+        } else {
+            unsafe { CStr::from_ptr(self.0).hash(h) }
+        }
+    }
+}
+
+impl Drop for StringPointer {
+    fn drop(&mut self) {
+        unsafe {
+            libc::free(self.0.cast::<c_void>());
+        }
+    }
+}
+
+pub enum Enumerator<'a> {
+    PointerKeyed(hash_map::IterMut<'a, VoidPointer, VoidPointer>),
+    StringKeyed(hash_map::IterMut<'a, StringPointer, VoidPointer>),
+}
+
+pub mod ffi {
+    use std::{
+        ffi::{c_int, c_uint, c_void},
+        mem, ptr,
+    };
+
+    use super::{Enumerator, HashTable, StringPointer, VoidPointer};
+
+    #[unsafe(no_mangle)]
+    #[allow(non_snake_case)]
+    pub unsafe extern "C" fn WMCreateIdentityHashTable() -> *mut HashTable {
+        Box::leak(Box::new(HashTable::new_pointer_keyed()))
+    }
+
+    #[unsafe(no_mangle)]
+    #[allow(non_snake_case)]
+    pub unsafe extern "C" fn WMCreateStringHashTable() -> *mut HashTable {
+        Box::leak(Box::new(HashTable::new_string_keyed()))
+    }
+
+    #[unsafe(no_mangle)]
+    #[allow(non_snake_case)]
+    pub unsafe extern "C" fn WMFreeHashTable(table: *mut HashTable) {
+        if !table.is_null() {
+            let _ = unsafe { Box::from_raw(table) };
+        }
+    }
+
+    #[unsafe(no_mangle)]
+    #[allow(non_snake_case)]
+    pub unsafe extern "C" fn WMResetHashTable(table: *mut HashTable) {
+        if !table.is_null() {
+            unsafe {
+                (*table).clear();
+            }
+        }
+    }
+
+    #[unsafe(no_mangle)]
+    #[allow(non_snake_case)]
+    pub unsafe extern "C" fn WMCountHashTable(table: *mut HashTable) -> c_uint {
+        if table.is_null() {
+            0
+        } else {
+            (unsafe { (*table).len() }) as c_uint
+        }
+    }
+
+    #[unsafe(no_mangle)]
+    #[allow(non_snake_case)]
+    pub unsafe extern "C" fn WMHashGet(table: *mut HashTable, key: *const c_void) -> *mut c_void {
+        if table.is_null() {
+            return ptr::null_mut();
+        }
+        let key = key.cast::<i8>();
+        (unsafe { (*table).get(key) })
+            .map(|v| v.cast::<c_void>())
+            .unwrap_or(ptr::null_mut())
+    }
+
+    #[unsafe(no_mangle)]
+    pub unsafe extern "C" fn WMHashGetItemAndKey(
+        table: *mut HashTable,
+        key: *const c_void,
+        value_dest: *mut *mut c_void,
+        key_dest: *mut *const c_void,
+    ) -> c_int {
+        if table.is_null() {
+            return 0;
+        }
+        let table = unsafe { &mut *table };
+        match table {
+            HashTable::PointerKeyed(m) => {
+                let key = VoidPointer(key.cast::<i8>().cast_mut());
+                let result = match m.get_key_value_mut(&key) {
+                    Some((k, v)) => {
+                        unsafe {
+                            *key_dest = k.0.cast::<c_void>();
+                            *value_dest = v.0.cast::<c_void>();
+                        }
+                        1
+                    }
+                    None => 0,
+                };
+                mem::forget(key);
+                result
+            }
+            HashTable::StringKeyed(m) => {
+                let key = StringPointer(key.cast::<i8>().cast_mut());
+                let result = match m.get_key_value_mut(&key) {
+                    Some((k, v)) => {
+                        unsafe {
+                            *key_dest = k.0.cast::<c_void>();
+                            *value_dest = v.0.cast::<c_void>();
+                        }
+                        1
+                    }
+                    None => 0,
+                };
+                mem::forget(key);
+                return result;
+            }
+        }
+    }
+
+    #[unsafe(no_mangle)]
+    #[allow(non_snake_case)]
+    pub unsafe extern "C" fn WMHashInsert(
+        table: *mut HashTable,
+        key: *mut c_void,
+        data: *mut c_void,
+    ) -> *mut c_void {
+        if table.is_null() {
+            return ptr::null_mut();
+        }
+        match unsafe { (*table).insert(key.cast::<i8>(), VoidPointer(data.cast::<i8>())) } {
+            Some(v) => {
+                let raw = v.0;
+                mem::forget(v);
+                raw.cast::<c_void>()
+            }
+            None => ptr::null_mut(),
+        }
+    }
+
+    #[unsafe(no_mangle)]
+    #[allow(non_snake_case)]
+    pub unsafe extern "C" fn WMHashRemove(table: *mut HashTable, key: *mut c_void) {
+        if table.is_null() {
+            return;
+        }
+        unsafe {
+            (*table).remove(key.cast::<i8>());
+        }
+    }
+
+    /// Important note: this may leak memory if you don't pass the enumerator
+    /// back to [`WMFreeHashEnumerator`]. This is a breaking change from the
+    /// original C implementation, which did not require any resource cleanup.
+    #[unsafe(no_mangle)]
+    pub unsafe extern "C" fn WMEnumerateHashTable(
+        table: *mut HashTable,
+    ) -> *mut Enumerator<'static> {
+        if table.is_null() {
+            return ptr::null_mut();
+        }
+        let table = unsafe { &mut *table };
+        match table {
+            HashTable::PointerKeyed(m) => {
+                Box::leak(Box::new(Enumerator::PointerKeyed(m.iter_mut())))
+            }
+            HashTable::StringKeyed(m) => Box::leak(Box::new(Enumerator::StringKeyed(m.iter_mut()))),
+        }
+    }
+
+    #[unsafe(no_mangle)]
+    pub unsafe extern "C" fn WMFreeHashEnumerator(e: *mut Enumerator<'static>) {
+        if !e.is_null() {
+            let _ = unsafe { Box::from_raw(e) };
+        }
+    }
+
+    #[unsafe(no_mangle)]
+    pub unsafe extern "C" fn WMNextHashEnumeratorItem(e: *mut Enumerator<'static>) -> *mut c_void {
+        if e.is_null() {
+            return ptr::null_mut();
+        }
+        let e = unsafe { &mut *e };
+        match e {
+            Enumerator::PointerKeyed(i) => match i.next() {
+                Some((_, v)) => v.0.cast::<c_void>(),
+                None => ptr::null_mut(),
+            },
+            Enumerator::StringKeyed(i) => match i.next() {
+                Some((_, v)) => v.0.cast::<c_void>(),
+                None => ptr::null_mut(),
+            },
+        }
+    }
+
+    #[unsafe(no_mangle)]
+    pub unsafe extern "C" fn WMNextHashEnumeratorKey(e: *mut Enumerator<'static>) -> *mut c_void {
+        if e.is_null() {
+            return ptr::null_mut();
+        }
+        let e = unsafe { &mut *e };
+        match e {
+            Enumerator::PointerKeyed(i) => match i.next() {
+                Some((k, _)) => k.0.cast::<c_void>(),
+                None => ptr::null_mut(),
+            },
+            Enumerator::StringKeyed(i) => match i.next() {
+                Some((k, _)) => k.0.cast::<c_void>(),
+                None => ptr::null_mut(),
+            },
+        }
+    }
+}

wutil-rs/src/lib.rs

@@ -0,0 +1,2 @@
+pub mod hash_table;
+pub mod memory;

wutil-rs/src/memory.rs

@@ -0,0 +1,222 @@
+//! Custom implementations of malloc/free/realloc.
+//!
+//! These are intended for use by C functions that need to allocate. Window
+//! Maker originally provided [`wmalloc`], [`wfree`], and [`wrealloc`] for
+//! customizable handling of memory exhaustion (to save workspace state before
+//! aborting) and to allow optional use of the Boehm GC library. It also tracked
+//! reference counts, via [`wretain`] and [`wrelease`].
+//!
+//! If everything gets rewritten in Rust, we won't need this module anymore. For
+//! now, it helps to move our allocations into Rust so that it is more
+//! straightforward to store Rust objects in heap memory that was allocated from
+//! C. (Rust may have stricter requirements for heap-allocated segments than are
+//! provided by arbitrary C allocators).
+//!
+//! TODO: We may want to restore handling of OOM errors. This would require
+//! installing a customized Rust allocator, which isn't something you can do yet
+//! in stable Rust. And, unless our rewrite ends up taking up obscenely more
+//! memory than the baseline Window Maker code, it isn't really necessary in
+//! this day and age.
+
+use std::{alloc, mem, ptr::{self, NonNull}};
+
+/// Tracks the layout and reference count of an allocated chunk of memory.
+#[derive(Clone, Copy)]
+struct Header {
+    ptr: NonNull<u8>,
+    layout: alloc::Layout,
+    refcount: u16,
+}
+
+impl Header {
+    /// Recovers the `Header` for the allocated memory chunk `b`.
+    ///
+    /// ## Safety
+    ///
+    /// Callers must ensure that `b` is a live allocation from [`wmalloc`] or [`wrealloc`].
+    unsafe fn for_alloc_bytes(b: *mut u8) -> *mut Header {
+        unsafe {
+            b.sub(mem::size_of::<Header>())
+                .cast::<Header>()
+        }
+    }
+}
+
+/// Allocates at least `size` bytes and returns a pointer to them.
+///
+/// Returns null if `size` is 0.
+pub fn alloc_bytes(size: usize) -> *mut u8 {
+    if size == 0 {
+        return ptr::null_mut();
+    }
+    let header_layout = match alloc::Layout::from_size_align(mem::size_of::<Header>(), 8) {
+        Ok(x) => x,
+        Err(_) => return ptr::null_mut(),
+    };
+
+    let layout = match alloc::Layout::from_size_align(size, 8) {
+        Ok(x) => x,
+        Err(_) => return ptr::null_mut(),
+    };
+    let (layout, result_offset) = match header_layout.extend(layout) {
+        Ok(x) => x,
+        Err(_) => return ptr::null_mut(),
+    };
+
+    let full_segment = unsafe { alloc::alloc_zeroed(layout) };
+    if full_segment.is_null() {
+        return ptr::null_mut();
+    }
+    let result = unsafe { full_segment.add(result_offset) };
+    if result.is_null() {
+        return ptr::null_mut();
+    }
+
+    unsafe {
+        let header = result.sub(mem::size_of::<Header>()).cast::<Header>();
+        header.write_unaligned(Header {
+            ptr: NonNull::new_unchecked(full_segment),
+            layout: header_layout,
+            refcount: 0,
+        });
+    }
+
+    result
+}
+
+/// Frees the bytes pointed to by `b`.
+///
+/// ## Safety
+///
+/// Callers must ensure that `b` is a live allocation from [`wmalloc`] or [`wrealloc`].
+pub unsafe fn free_bytes(b: *mut u8) {
+    if b.is_null() {
+        return;
+    }
+    unsafe {
+        let header = &*Header::for_alloc_bytes(b);
+        alloc::dealloc(header.ptr.as_ptr(), header.layout);
+    }
+}
+
+/// Functions to be called from C.
+pub mod ffi {
+    use super::{alloc_bytes, free_bytes, Header};
+
+    use std::{ffi::c_void, ptr};
+
+    /// Allocates `size` bytes. Returns null if `sizes is 0.
+    #[unsafe(no_mangle)]
+    pub unsafe extern "C" fn wmalloc(size: usize) -> *mut c_void {
+        alloc_bytes(size).cast::<c_void>()
+    }
+
+    /// Frees `ptr`, which must have come from [`wmalloc`] or [`wrealloc`].
+    #[unsafe(no_mangle)]
+    pub unsafe extern "C" fn wfree(ptr: *mut c_void) {
+        unsafe { free_bytes(ptr.cast::<u8>()); }
+    }
+
+    /// Resizes `ptr` to be at least `newsize` bytes in size, returning the
+    /// start of the new segment.
+    ///
+    /// ## Safety
+    ///
+    /// Callers must ensure that `ptr` is a live allocation from [`wmalloc`] or [`wrealloc`].
+    #[unsafe(no_mangle)]
+    pub unsafe extern "C" fn wrealloc(ptr: *mut c_void, newsize: usize) -> *mut c_void {
+        unsafe {
+            wfree(ptr);
+            wmalloc(newsize).cast::<c_void>()
+        }
+    }
+
+    /// Bumps the refcount for `ptr`.
+    ///
+    /// ## Safety
+    ///
+    /// Callers must ensure that `b` is a live allocation from [`wmalloc`] or [`wrealloc`].
+    #[unsafe(no_mangle)]
+    pub unsafe extern "C" fn wretain(ptr: *mut c_void) -> *mut c_void {
+        if ptr.is_null() {
+            return ptr::null_mut();
+        }
+        unsafe {
+            let header = Header::for_alloc_bytes(ptr.cast::<u8>());
+            (*header).refcount += 1;
+        }
+        ptr
+    }
+
+    /// Decrements the refcount for `ptr`. If this brings the refcount to 0,
+    /// frees `ptr`.
+    ///
+    /// ## Safety
+    ///
+    /// Callers must ensure that `ptr` is a live allocation from [`wmalloc`] or [`wrealloc`].
+    #[unsafe(no_mangle)]
+    pub unsafe extern "C" fn wrelease(ptr: *mut c_void) {
+        let ptr = ptr.cast::<u8>();
+        if ptr.is_null() {
+            return;
+        }
+        let header = unsafe { &mut *Header::for_alloc_bytes(ptr) };
+        match header.refcount {
+            0 | 1 => unsafe { free_bytes(ptr) },
+            _ => header.refcount -= 1,
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::{alloc_bytes, free_bytes, ffi::wrealloc, Header};
+
+    use std::{mem, os::raw::c_void, ptr};
+
+    #[test]
+    fn recover_header() {
+        unsafe {
+            let x = alloc_bytes(mem::size_of::<i64>());
+            let header = Header::for_alloc_bytes(x);
+            assert_eq!(header.cast::<u8>().add(mem::size_of::<Header>()), x);
+            // This may be allocator-dependent, but it's a reasonable sanity check for now.
+            assert!((*header).ptr.as_ptr() <= header.cast::<u8>());
+        }
+    }
+    
+    #[test]
+    fn alloc_zero_returns_null() {
+        assert!(alloc_bytes(0).is_null());
+    }
+
+    #[test]
+    fn free_null() {
+        unsafe { free_bytes(ptr::null_mut()); }
+    }
+
+    #[test]
+    fn realloc_null() {
+        unsafe { assert!(wrealloc(ptr::null_mut(), 0).is_null()); }
+    }
+
+    #[test]
+    fn alloc_free_nonzero() {
+        let x = alloc_bytes(mem::size_of::<i64>()).cast::<i64>();
+        assert!(!x.is_null());
+        unsafe { *x = 42; }
+        assert_eq!(unsafe { *x }, 42);
+        unsafe { free_bytes(x.cast::<u8>()); }
+    }
+
+    #[test]
+    fn realloc_nonzero() {
+        let x = alloc_bytes(mem::size_of::<i64>()).cast::<c_void>();
+        assert!(!x.is_null());
+        let y = unsafe { wrealloc(x, mem::size_of::<i32>()).cast::<i32>() };
+        assert!(!y.is_null());
+        unsafe { *y = 17; }
+        assert_eq!(unsafe { *y }, 17);
+        unsafe { free_bytes(y.cast::<u8>()); }
+    }
+}