Define WAppIcon struct in Rust.

.gitignore

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

Makefile.am

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

WINGs/Makefile.am

@@ -10,17 +10,14 @@ 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 $(wraster) $(wutilrs) @INTLIBS@
-libWINGs_la_LIBADD = libWUtil.la $(wraster) $(wutilrs) @XLIBS@ @XFT_LIBS@ @FCLIBS@ @LIBM@ @PANGO_LIBS@
-libWUtil_la_LIBADD = @LIBBSD@ $(wutilrs)
+LDADD= libWUtil.la libWINGs.la $(top_builddir)/wrlib/libwraster.la @INTLIBS@
+libWINGs_la_LIBADD = libWUtil.la $(top_builddir)/wrlib/libwraster.la @XLIBS@ @XFT_LIBS@ @FCLIBS@ @LIBM@ @PANGO_LIBS@
+libWUtil_la_LIBADD = @LIBBSD@
 
 EXTRA_DIST = BUGS make-rgb Examples Extras Tests
 
 
-
 # wbutton.c
 libWINGs_la_SOURCES = 	\
 	configuration.c \
@@ -65,11 +62,15 @@ libWINGs_la_SOURCES = 	\
 	wwindow.c
 
 libWUtil_la_SOURCES = 	\
+	array.c \
 	bagtree.c \
+	data.c \
 	error.c \
 	error.h \
 	findfile.c \
 	handlers.c \
+	hashtable.c \
+	memory.c \
 	menuparser.c \
 	menuparser.h \
 	menuparser_macros.c \

WINGs/WINGs/WUtil.h

@@ -169,6 +169,10 @@ 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;
 
 
@@ -209,6 +213,10 @@ void wfree(void *ptr);
 void wrelease(void *ptr);
 void* wretain(void *ptr);
 
+typedef void waborthandler(int);
+
+waborthandler* wsetabort(waborthandler* handler);
+
 /* ---[ WINGs/error.c ]--------------------------------------------------- */
 
 enum {
@@ -240,14 +248,11 @@ char* wexpandpath(const char *path);
 
 int wcopy_file(const char *toPath, const char *srcFile, const char *destFile);
 
-/* You must free the returned string! */
-char* wgethomedir(void);
+/* don't free the returned string */
+const char* wgethomedir(void);
 
 /* ---[ WINGs/proplist.c ]------------------------------------------------ */
 
-/*
- * Creates the directory path and all its parents.
- */
 int wmkdirhier(const char *path);
 int wrmdirhier(const char *path);
 
@@ -337,8 +342,7 @@ void WHandleEvents(void);
 /* ---[ WINGs/hashtable.c ]----------------------------------------------- */
 
 
-WMHashTable* WMCreateIdentityHashTable();
-WMHashTable* WMCreateStringHashTable();
+WMHashTable* WMCreateHashTable(const WMHashTableCallbacks callbacks);
 
 void WMFreeHashTable(WMHashTable *table);
 
@@ -388,11 +392,15 @@ 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 */
 
 
-/* ---[ wutil-rs/src/array.rs ]--------------------------------------------------- */
+/* ---[ WINGs/array.c ]--------------------------------------------------- */
 
 /*
  * WMArray use an array to store the elements.
@@ -414,22 +422,29 @@ WMArray* WMCreateArrayWithDestructor(int initialSize, WMFreeDataProc *destructor
 
 WMArray* WMCreateArrayWithArray(WMArray *array);
 
+#define WMDuplicateArray(array) WMCreateArrayWithArray(array)
+
 void WMEmptyArray(WMArray *array);
 
 void WMFreeArray(WMArray *array);
 
 int WMGetArrayItemCount(WMArray *array);
 
+/* appends other to array. other remains unchanged */
+void WMAppendArray(WMArray *array, WMArray *other);
+
 /* add will place the element at the end of the array */
 void WMAddToArray(WMArray *array, void *item);
 
 /* insert will increment the index of elements after it by 1 */
 void WMInsertInArray(WMArray *array, int index, void *item);
 
-/* set returns the old item WITHOUT calling the
+/* replace and set will return the old item WITHOUT calling the
  * destructor on it even if its available. Free the returned item yourself.
  */
-void* WMSetInArray(WMArray *array, int index, void *item);
+void* WMReplaceInArray(WMArray *array, int index, void *item);
+
+#define WMSetInArray(array, index, item) WMReplaceInArray(array, index, item)
 
 /* delete and remove will remove the elements and cause the elements
  * after them to decrement their indexes by 1. Also will call the
@@ -437,21 +452,20 @@ void* WMSetInArray(WMArray *array, int index, void *item);
  */
 int WMDeleteFromArray(WMArray *array, int index);
 
-int WMRemoveFromArray(WMArray *array, void *item);
+#define WMRemoveFromArray(array, item) WMRemoveFromArrayMatching(array, NULL, item)
 
 int WMRemoveFromArrayMatching(WMArray *array, WMMatchDataProc *match, void *cdata);
 
 void* WMGetFromArray(WMArray *array, int index);
 
+#define WMGetFirstInArray(array, item) WMFindInArray(array, NULL, item)
+
 /* pop will return the last element from the array, also removing it
  * from the array. The destructor is NOT called, even if available.
  * Free the returned element if needed by yourself
  */
 void* WMPopFromArray(WMArray *array);
 
-/* Like WMFindInArray(array, NULL, item) */
-int WMGetFirstInArray(WMArray *array, void *item);
-
 int WMFindInArray(WMArray *array, WMMatchDataProc *match, void *cdata);
 
 int WMCountInArray(WMArray *array, void *item);
@@ -465,6 +479,8 @@ void WMSortArray(WMArray *array, WMCompareDataProc *comparer);
 
 void WMMapArray(WMArray *array, void (*function)(void*, void*), void *data);
 
+WMArray* WMGetSubarrayWithRange(WMArray* array, WMRange aRange);
+
 void* WMArrayFirst(WMArray *array, WMArrayIterator *iter);
 
 void* WMArrayLast(WMArray *array, WMArrayIterator *iter);
@@ -588,16 +604,37 @@ WMData* WMCreateDataWithLength(unsigned length);
 
 WMData* WMCreateDataWithBytes(const void *bytes, unsigned length);
 
+/* destructor is a function called to free the data when releasing the data
+ * object, or NULL if no freeing of data is necesary. */
+WMData* WMCreateDataWithBytesNoCopy(void *bytes, unsigned length,
+                                    WMFreeDataProc *destructor);
+
 WMData* WMCreateDataWithData(WMData *aData);
 
 WMData* WMRetainData(WMData *aData);
 
 void WMReleaseData(WMData *aData);
 
+/* Adjusting capacity */
+
+void WMSetDataCapacity(WMData *aData, unsigned capacity);
+
+void WMSetDataLength(WMData *aData, unsigned length);
+
+void WMIncreaseDataLengthBy(WMData *aData, unsigned extraLength);
+
 /* Accessing data */
 
 const void* WMDataBytes(WMData *aData);
 
+void WMGetDataBytes(WMData *aData, void *buffer);
+
+void WMGetDataBytesWithLength(WMData *aData, void *buffer, unsigned length);
+
+void WMGetDataBytesWithRange(WMData *aData, void *buffer, WMRange aRange);
+
+WMData* WMGetSubdataWithRange(WMData *aData, WMRange aRange);
+
 /* Testing data */
 
 Bool WMIsDataEqualToData(WMData *aData, WMData *anotherData);
@@ -612,6 +649,10 @@ void WMAppendData(WMData *aData, WMData *anotherData);
 
 /* Modifying data */
 
+void WMReplaceDataBytesInRange(WMData *aData, WMRange aRange, const void *bytes);
+
+void WMResetDataBytesInRange(WMData *aData, WMRange aRange);
+
 void WMSetData(WMData *aData, WMData *anotherData);
 
 
@@ -715,23 +756,25 @@ void WMEnqueueCoalesceNotification(WMNotificationQueue *queue,
                                    unsigned coalesceMask);
 
 
-/* Property Lists handling */
-
 /* ---[ WINGs/proplist.c ]------------------------------------------------ */
 
-WMPropList* WMCreatePLArray(WMPropList *elem, ...);
+/* Property Lists handling */
 
-/* ---[ wutil-rs/src/prop_list.rs ]--------------------------------------- */
+void WMPLSetCaseSensitive(Bool caseSensitive);
 
 WMPropList* WMCreatePLString(const char *str);
 
-WMPropList* WMCreatePLArrayFromSlice(WMPropList *elems, unsigned int length);
+WMPropList* WMCreatePLData(WMData *data);
 
-WMPropList* WMCreateEmptyPLArray();
+WMPropList* WMCreatePLDataWithBytes(const unsigned char *bytes, unsigned int length);
 
-WMPropList* WMCreatePLDictionary(WMPropList *key, WMPropList *value);
+WMPropList* WMCreatePLDataWithBytesNoCopy(unsigned char *bytes,
+                                          unsigned int length,
+                                          WMFreeDataProc *destructor);
 
-WMPropList* WMCreateEmptyPLDictionary();
+WMPropList* WMCreatePLArray(WMPropList *elem, ...);
+
+WMPropList* WMCreatePLDictionary(WMPropList *key, WMPropList *value, ...);
 
 WMPropList* WMRetainPropList(WMPropList *plist);
 
@@ -769,6 +812,8 @@ int WMGetPropListItemCount(WMPropList *plist);
 
 Bool WMIsPLString(WMPropList *plist);
 
+Bool WMIsPLData(WMPropList *plist);
+
 Bool WMIsPLArray(WMPropList *plist);
 
 Bool WMIsPLDictionary(WMPropList *plist);
@@ -778,6 +823,14 @@ Bool WMIsPropListEqualTo(WMPropList *plist, WMPropList *other);
 /* Returns a reference. Do not free it! */
 char* WMGetFromPLString(WMPropList *plist);
 
+/* Returns a reference. Do not free it! */
+WMData* WMGetFromPLData(WMPropList *plist);
+
+/* Returns a reference. Do not free it! */
+const unsigned char* WMGetPLDataBytes(WMPropList *plist);
+
+int WMGetPLDataLength(WMPropList *plist);
+
 /* Returns a reference. */
 WMPropList* WMGetFromPLArray(WMPropList *plist, int index);
 
@@ -785,9 +838,14 @@ WMPropList* WMGetFromPLArray(WMPropList *plist, int index);
 WMPropList* WMGetFromPLDictionary(WMPropList *plist, WMPropList *key);
 
 /* Returns a PropList array with all the dictionary keys. Release it when
- * you're done. */
+ * you're done. Keys in array are retained from the original dictionary
+ * not copied and need NOT to be released individually. */
 WMPropList* WMGetPLDictionaryKeys(WMPropList *plist);
 
+/* Creates only the first level deep object. All the elements inside are
+ * retained from the original */
+WMPropList* WMShallowCopyPropList(WMPropList *plist);
+
 /* Makes a completely separate replica of the original proplist */
 WMPropList* WMDeepCopyPropList(WMPropList *plist);
 

WINGs/array.c

@@ -0,0 +1,363 @@
+/*
+ * Dynamically Resized Array
+ *
+ * Authors: Alfredo K. Kojima <kojima@windowmaker.info>
+ *          Dan Pascu         <dan@windowmaker.info>
+ *
+ * This code is released to the Public Domain, but
+ * proper credit is always appreciated :)
+ */
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "WUtil.h"
+
+#define INITIAL_SIZE 8
+#define RESIZE_INCREMENT 8
+
+typedef struct W_Array {
+	void **items;		/* the array data */
+	int itemCount;		/* # of items in array */
+	int allocSize;		/* allocated size of array */
+	WMFreeDataProc *destructor;	/* the destructor to free elements */
+} W_Array;
+
+WMArray *WMCreateArray(int initialSize)
+{
+	return WMCreateArrayWithDestructor(initialSize, NULL);
+}
+
+WMArray *WMCreateArrayWithDestructor(int initialSize, WMFreeDataProc * destructor)
+{
+	WMArray *array;
+
+	array = wmalloc(sizeof(WMArray));
+
+	if (initialSize <= 0) {
+		initialSize = INITIAL_SIZE;
+	}
+
+	array->items = wmalloc(sizeof(void *) * initialSize);
+
+	array->itemCount = 0;
+	array->allocSize = initialSize;
+	array->destructor = destructor;
+
+	return array;
+}
+
+WMArray *WMCreateArrayWithArray(WMArray * array)
+{
+	WMArray *newArray;
+
+	newArray = wmalloc(sizeof(WMArray));
+
+	newArray->items = wmalloc(sizeof(void *) * array->allocSize);
+	memcpy(newArray->items, array->items, sizeof(void *) * array->itemCount);
+
+	newArray->itemCount = array->itemCount;
+	newArray->allocSize = array->allocSize;
+	newArray->destructor = NULL;
+
+	return newArray;
+}
+
+void WMEmptyArray(WMArray * array)
+{
+	if (array->destructor) {
+		while (array->itemCount > 0) {
+			array->itemCount--;
+			array->destructor(array->items[array->itemCount]);
+		}
+	}
+	/*memset(array->items, 0, array->itemCount * sizeof(void*)); */
+	array->itemCount = 0;
+}
+
+void WMFreeArray(WMArray * array)
+{
+	if (array == NULL)
+		return;
+
+	WMEmptyArray(array);
+	wfree(array->items);
+	wfree(array);
+}
+
+int WMGetArrayItemCount(WMArray * array)
+{
+	if (array == NULL)
+		return 0;
+
+	return array->itemCount;
+}
+
+void WMAppendArray(WMArray * array, WMArray * other)
+{
+	if (array == NULL || other == NULL)
+		return;
+
+	if (other->itemCount == 0)
+		return;
+
+	if (array->itemCount + other->itemCount > array->allocSize) {
+		array->allocSize += other->allocSize;
+		array->items = wrealloc(array->items, sizeof(void *) * array->allocSize);
+	}
+
+	memcpy(array->items + array->itemCount, other->items, sizeof(void *) * other->itemCount);
+	array->itemCount += other->itemCount;
+}
+
+void WMAddToArray(WMArray * array, void *item)
+{
+	if (array == NULL)
+		return;
+
+	if (array->itemCount >= array->allocSize) {
+		array->allocSize += RESIZE_INCREMENT;
+		array->items = wrealloc(array->items, sizeof(void *) * array->allocSize);
+	}
+	array->items[array->itemCount] = item;
+
+	array->itemCount++;
+}
+
+void WMInsertInArray(WMArray * array, int index, void *item)
+{
+	if (array == NULL)
+		return;
+
+	wassertr(index >= 0 && index <= array->itemCount);
+
+	if (array->itemCount >= array->allocSize) {
+		array->allocSize += RESIZE_INCREMENT;
+		array->items = wrealloc(array->items, sizeof(void *) * array->allocSize);
+	}
+	if (index < array->itemCount) {
+		memmove(array->items + index + 1, array->items + index,
+			sizeof(void *) * (array->itemCount - index));
+	}
+	array->items[index] = item;
+
+	array->itemCount++;
+}
+
+void *WMReplaceInArray(WMArray * array, int index, void *item)
+{
+	void *old;
+
+	if (array == NULL)
+		return NULL;
+
+	wassertrv(index >= 0 && index <= array->itemCount, NULL);
+
+	/* is it really useful to perform append if index == array->itemCount ? -Dan */
+	if (index == array->itemCount) {
+		WMAddToArray(array, item);
+		return NULL;
+	}
+
+	old = array->items[index];
+	array->items[index] = item;
+
+	return old;
+}
+
+int WMDeleteFromArray(WMArray * array, int index)
+{
+	if (array == NULL)
+		return 0;
+
+	wassertrv(index >= 0 && index < array->itemCount, 0);
+
+	if (array->destructor) {
+		array->destructor(array->items[index]);
+	}
+
+	if (index < array->itemCount - 1) {
+		memmove(array->items + index, array->items + index + 1,
+			sizeof(void *) * (array->itemCount - index - 1));
+	}
+
+	array->itemCount--;
+
+	return 1;
+}
+
+int WMRemoveFromArrayMatching(WMArray * array, WMMatchDataProc * match, void *cdata)
+{
+	int i;
+
+	if (array == NULL)
+		return 1;
+
+	if (match != NULL) {
+		for (i = 0; i < array->itemCount; i++) {
+			if ((*match) (array->items[i], cdata)) {
+				WMDeleteFromArray(array, i);
+				return 1;
+			}
+		}
+	} else {
+		for (i = 0; i < array->itemCount; i++) {
+			if (array->items[i] == cdata) {
+				WMDeleteFromArray(array, i);
+				return 1;
+			}
+		}
+	}
+
+	return 0;
+}
+
+void *WMGetFromArray(WMArray * array, int index)
+{
+	if (index < 0 || array == NULL || index >= array->itemCount)
+		return NULL;
+
+	return array->items[index];
+}
+
+void *WMPopFromArray(WMArray * array)
+{
+	if (array == NULL || array->itemCount <= 0)
+		return NULL;
+
+	array->itemCount--;
+
+	return array->items[array->itemCount];
+}
+
+int WMFindInArray(WMArray * array, WMMatchDataProc * match, void *cdata)
+{
+	int i;
+
+	if (array == NULL)
+		return WANotFound;
+
+	if (match != NULL) {
+		for (i = 0; i < array->itemCount; i++) {
+			if ((*match) (array->items[i], cdata))
+				return i;
+		}
+	} else {
+		for (i = 0; i < array->itemCount; i++) {
+			if (array->items[i] == cdata)
+				return i;
+		}
+	}
+
+	return WANotFound;
+}
+
+int WMCountInArray(WMArray * array, void *item)
+{
+	int i, count;
+
+	if (array == NULL)
+		return 0;
+
+	for (i = 0, count = 0; i < array->itemCount; i++) {
+		if (array->items[i] == item)
+			count++;
+	}
+
+	return count;
+}
+
+void WMSortArray(WMArray * array, WMCompareDataProc * comparer)
+{
+	if (array == NULL)
+		return;
+
+	if (array->itemCount > 1) {	/* Don't sort empty or single element arrays */
+		qsort(array->items, array->itemCount, sizeof(void *), comparer);
+	}
+}
+
+void WMMapArray(WMArray * array, void (*function) (void *, void *), void *data)
+{
+	int i;
+
+	if (array == NULL)
+		return;
+
+	for (i = 0; i < array->itemCount; i++) {
+		(*function) (array->items[i], data);
+	}
+}
+
+WMArray *WMGetSubarrayWithRange(WMArray * array, WMRange aRange)
+{
+	WMArray *newArray;
+
+	if (aRange.count <= 0 || array == NULL)
+		return WMCreateArray(0);
+
+	if (aRange.position < 0)
+		aRange.position = 0;
+	if (aRange.position >= array->itemCount)
+		aRange.position = array->itemCount - 1;
+	if (aRange.position + aRange.count > array->itemCount)
+		aRange.count = array->itemCount - aRange.position;
+
+	newArray = WMCreateArray(aRange.count);
+	memcpy(newArray->items, array->items + aRange.position, sizeof(void *) * aRange.count);
+	newArray->itemCount = aRange.count;
+
+	return newArray;
+}
+
+void *WMArrayFirst(WMArray * array, WMArrayIterator * iter)
+{
+	if (array == NULL || array->itemCount == 0) {
+		*iter = WANotFound;
+		return NULL;
+	} else {
+		*iter = 0;
+		return array->items[0];
+	}
+}
+
+void *WMArrayLast(WMArray * array, WMArrayIterator * iter)
+{
+	if (array == NULL || array->itemCount == 0) {
+		*iter = WANotFound;
+		return NULL;
+	} else {
+		*iter = array->itemCount - 1;
+		return array->items[*iter];
+	}
+}
+
+void *WMArrayNext(WMArray * array, WMArrayIterator * iter)
+{
+	if (array == NULL) {
+		*iter = WANotFound;
+		return NULL;
+	}
+
+	if (*iter >= 0 && *iter < array->itemCount - 1) {
+		return array->items[++(*iter)];
+	} else {
+		*iter = WANotFound;
+		return NULL;
+	}
+}
+
+void *WMArrayPrevious(WMArray * array, WMArrayIterator * iter)
+{
+	if (array == NULL) {
+		*iter = WANotFound;
+		return NULL;
+	}
+
+	if (*iter > 0 && *iter < array->itemCount) {
+		return array->items[--(*iter)];
+	} else {
+		*iter = WANotFound;
+		return NULL;
+	}
+}

WINGs/data.c

@@ -0,0 +1,289 @@
+/*
+ *  WINGs WMData function library
+ *
+ *  Copyright (c) 1999-2003 Dan Pascu
+ *
+ *  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 <string.h>
+#include "WUtil.h"
+
+typedef struct W_Data {
+	unsigned length;	/* How many bytes we have */
+	unsigned capacity;	/* How many bytes it can hold */
+	unsigned growth;	/* How much to grow */
+	void *bytes;		/* Actual data */
+	unsigned retainCount;
+	WMFreeDataProc *destructor;
+	int format;		/* 0, 8, 16 or 32 */
+} W_Data;
+
+/* Creating and destroying data objects */
+
+WMData *WMCreateDataWithCapacity(unsigned capacity)
+{
+	WMData *aData;
+
+	aData = (WMData *) wmalloc(sizeof(WMData));
+
+	if (capacity > 0)
+		aData->bytes = wmalloc(capacity);
+	else
+		aData->bytes = NULL;
+
+	aData->capacity = capacity;
+	aData->growth = capacity / 2 > 0 ? capacity / 2 : 1;
+	aData->length = 0;
+	aData->retainCount = 1;
+	aData->format = 0;
+	aData->destructor = wfree;
+
+	return aData;
+}
+
+WMData *WMCreateDataWithLength(unsigned length)
+{
+	WMData *aData;
+
+	aData = WMCreateDataWithCapacity(length);
+	if (length > 0) {
+		aData->length = length;
+	}
+
+	return aData;
+}
+
+WMData *WMCreateDataWithBytes(const void *bytes, unsigned length)
+{
+	WMData *aData;
+
+	aData = WMCreateDataWithCapacity(length);
+	aData->length = length;
+	memcpy(aData->bytes, bytes, length);
+
+	return aData;
+}
+
+WMData *WMCreateDataWithBytesNoCopy(void *bytes, unsigned length, WMFreeDataProc * destructor)
+{
+	WMData *aData;
+
+	aData = (WMData *) wmalloc(sizeof(WMData));
+	aData->length = length;
+	aData->capacity = length;
+	aData->growth = length / 2 > 0 ? length / 2 : 1;
+	aData->bytes = bytes;
+	aData->retainCount = 1;
+	aData->format = 0;
+	aData->destructor = destructor;
+
+	return aData;
+}
+
+WMData *WMCreateDataWithData(WMData * aData)
+{
+	WMData *newData;
+
+	if (aData->length > 0) {
+		newData = WMCreateDataWithBytes(aData->bytes, aData->length);
+	} else {
+		newData = WMCreateDataWithCapacity(0);
+	}
+	newData->format = aData->format;
+
+	return newData;
+}
+
+WMData *WMRetainData(WMData * aData)
+{
+	aData->retainCount++;
+	return aData;
+}
+
+void WMReleaseData(WMData * aData)
+{
+	aData->retainCount--;
+	if (aData->retainCount > 0)
+		return;
+	if (aData->bytes != NULL && aData->destructor != NULL) {
+		aData->destructor(aData->bytes);
+	}
+	wfree(aData);
+}
+
+/* Adjusting capacity */
+
+void WMSetDataCapacity(WMData * aData, unsigned capacity)
+{
+	if (aData->capacity != capacity) {
+		aData->bytes = wrealloc(aData->bytes, capacity);
+		aData->capacity = capacity;
+		aData->growth = capacity / 2 > 0 ? capacity / 2 : 1;
+	}
+	if (aData->length > capacity) {
+		aData->length = capacity;
+	}
+}
+
+void WMSetDataLength(WMData * aData, unsigned length)
+{
+	if (length > aData->capacity) {
+		WMSetDataCapacity(aData, length);
+	}
+	if (length > aData->length) {
+		memset((unsigned char *)aData->bytes + aData->length, 0, length - aData->length);
+	}
+	aData->length = length;
+}
+
+void WMSetDataFormat(WMData * aData, unsigned format)
+{
+	aData->format = format;
+}
+
+void WMIncreaseDataLengthBy(WMData * aData, unsigned extraLength)
+{
+	WMSetDataLength(aData, aData->length + extraLength);
+}
+
+/* Accessing data */
+
+const void *WMDataBytes(WMData * aData)
+{
+	return aData->bytes;
+}
+
+void WMGetDataBytes(WMData * aData, void *buffer)
+{
+	wassertr(aData->length > 0);
+
+	memcpy(buffer, aData->bytes, aData->length);
+}
+
+unsigned WMGetDataFormat(WMData * aData)
+{
+	return aData->format;
+}
+
+void WMGetDataBytesWithLength(WMData * aData, void *buffer, unsigned length)
+{
+	wassertr(aData->length > 0);
+	wassertr(length <= aData->length);
+
+	memcpy(buffer, aData->bytes, length);
+}
+
+void WMGetDataBytesWithRange(WMData * aData, void *buffer, WMRange aRange)
+{
+	wassertr(aRange.position < aData->length);
+	wassertr(aRange.count <= aData->length - aRange.position);
+
+	memcpy(buffer, (unsigned char *)aData->bytes + aRange.position, aRange.count);
+}
+
+WMData *WMGetSubdataWithRange(WMData * aData, WMRange aRange)
+{
+	void *buffer;
+	WMData *newData;
+
+	if (aRange.count <= 0)
+		return WMCreateDataWithCapacity(0);
+
+	buffer = wmalloc(aRange.count);
+	WMGetDataBytesWithRange(aData, buffer, aRange);
+	newData = WMCreateDataWithBytesNoCopy(buffer, aRange.count, wfree);
+	newData->format = aData->format;
+
+	return newData;
+}
+
+/* Testing data */
+
+Bool WMIsDataEqualToData(WMData * aData, WMData * anotherData)
+{
+	if (aData->length != anotherData->length)
+		return False;
+	else if (!aData->bytes && !anotherData->bytes)	/* both are empty */
+		return True;
+	else if (!aData->bytes || !anotherData->bytes)	/* one of them is empty */
+		return False;
+	return (memcmp(aData->bytes, anotherData->bytes, aData->length) == 0);
+}
+
+unsigned WMGetDataLength(WMData * aData)
+{
+	return aData->length;
+}
+
+/* Adding data */
+void WMAppendDataBytes(WMData * aData, const void *bytes, unsigned length)
+{
+	unsigned oldLength = aData->length;
+	unsigned newLength = oldLength + length;
+
+	if (newLength > aData->capacity) {
+		unsigned nextCapacity = aData->capacity + aData->growth;
+		unsigned nextGrowth = aData->capacity ? aData->capacity : 1;
+
+		while (nextCapacity < newLength) {
+			unsigned tmp = nextCapacity + nextGrowth;
+
+			nextGrowth = nextCapacity;
+			nextCapacity = tmp;
+		}
+		WMSetDataCapacity(aData, nextCapacity);
+		aData->growth = nextGrowth;
+	}
+	memcpy((unsigned char *)aData->bytes + oldLength, bytes, length);
+	aData->length = newLength;
+}
+
+void WMAppendData(WMData * aData, WMData * anotherData)
+{
+	if (anotherData->length > 0)
+		WMAppendDataBytes(aData, anotherData->bytes, anotherData->length);
+}
+
+/* Modifying data */
+
+void WMReplaceDataBytesInRange(WMData * aData, WMRange aRange, const void *bytes)
+{
+	wassertr(aRange.position < aData->length);
+	wassertr(aRange.count <= aData->length - aRange.position);
+
+	memcpy((unsigned char *)aData->bytes + aRange.position, bytes, aRange.count);
+}
+
+void WMResetDataBytesInRange(WMData * aData, WMRange aRange)
+{
+	wassertr(aRange.position < aData->length);
+	wassertr(aRange.count <= aData->length - aRange.position);
+
+	memset((unsigned char *)aData->bytes + aRange.position, 0, aRange.count);
+}
+
+void WMSetData(WMData * aData, WMData * anotherData)
+{
+	unsigned length = anotherData->length;
+
+	WMSetDataCapacity(aData, length);
+	if (length > 0)
+		memcpy(aData->bytes, anotherData->bytes, length);
+	aData->length = length;
+}
+
+/* Storing data */

WINGs/findfile.c

@@ -34,6 +34,331 @@
 #include <pwd.h>
 #include <limits.h>
 
+#ifndef PATH_MAX
+#define PATH_MAX  1024
+#endif
+
+
+const char *wgethomedir(void)
+{
+	static char *home = NULL;
+	char *tmp;
+	struct passwd *user;
+
+	if (home)
+		return home;
+
+	tmp = GETENV("HOME");
+	if (tmp) {
+		home = wstrdup(tmp);
+		return home;
+	}
+
+	user = getpwuid(getuid());
+	if (!user) {
+		werror(_("could not get password entry for UID %i"), getuid());
+		home = "/";
+		return home;
+	}
+
+	if (!user->pw_dir)
+		home = "/";
+	else
+		home = wstrdup(user->pw_dir);
+
+	return home;
+}
+
+/*
+ * Return the home directory for the specified used
+ *
+ * If user not found, returns NULL, otherwise always returns a path that is
+ * statically stored.
+ *
+ * Please note you must use the path before any other call to 'getpw*' or it
+ * may be erased. This is a design choice to avoid duplication considering
+ * the use case for this function.
+ */
+static const char *getuserhomedir(const char *username)
+{
+	static const char default_home[] = "/";
+	struct passwd *user;
+
+	user = getpwnam(username);
+	if (!user) {
+		werror(_("could not get password entry for user %s"), username);
+		return NULL;
+	}
+	if (!user->pw_dir)
+		return default_home;
+	else
+		return user->pw_dir;
+
+}
+
+char *wexpandpath(const char *path)
+{
+	const char *origpath = path;
+	char buffer2[PATH_MAX + 2];
+	char buffer[PATH_MAX + 2];
+	int i;
+
+	memset(buffer, 0, PATH_MAX + 2);
+
+	if (*path == '~') {
+		const char *home;
+
+		path++;
+		if (*path == '/' || *path == 0) {
+			home = wgethomedir();
+			if (strlen(home) > PATH_MAX ||
+			    wstrlcpy(buffer, home, sizeof(buffer)) >= sizeof(buffer))
+				goto error;
+		} else {
+			int j;
+			j = 0;
+			while (*path != 0 && *path != '/') {
+				if (j > PATH_MAX)
+					goto error;
+				buffer2[j++] = *path;
+				buffer2[j] = 0;
+				path++;
+			}
+			home = getuserhomedir(buffer2);
+			if (!home || wstrlcat(buffer, home, sizeof(buffer)) >= sizeof(buffer))
+				goto error;
+		}
+	}
+
+	i = strlen(buffer);
+
+	while (*path != 0 && i <= PATH_MAX) {
+		char *tmp;
+
+		if (*path == '$') {
+			int j;
+
+			path++;
+			/* expand $(HOME) or $HOME style environment variables */
+			if (*path == '(') {
+				path++;
+				j = 0;
+				while (*path != 0 && *path != ')') {
+					if (j > PATH_MAX)
+						goto error;
+					buffer2[j++] = *(path++);
+				}
+				buffer2[j] = 0;
+				if (*path == ')') {
+					path++;
+					tmp = getenv(buffer2);
+				} else {
+					tmp = NULL;
+				}
+				if (!tmp) {
+					if ((i += strlen(buffer2) + 2) > PATH_MAX)
+						goto error;
+					buffer[i] = 0;
+					if (wstrlcat(buffer, "$(", sizeof(buffer)) >= sizeof(buffer) ||
+					    wstrlcat(buffer, buffer2, sizeof(buffer)) >= sizeof(buffer))
+						goto error;
+					if (*(path-1)==')') {
+						if (++i > PATH_MAX ||
+						    wstrlcat(buffer, ")", sizeof(buffer)) >= sizeof(buffer))
+							goto error;
+					}
+				} else {
+					if ((i += strlen(tmp)) > PATH_MAX ||
+					    wstrlcat(buffer, tmp, sizeof(buffer)) >= sizeof(buffer))
+						goto error;
+				}
+			} else {
+				j = 0;
+				while (*path != 0 && *path != '/') {
+					if (j > PATH_MAX)
+						goto error;
+					buffer2[j++] = *(path++);
+				}
+				buffer2[j] = 0;
+				tmp = getenv(buffer2);
+				if (!tmp) {
+					if ((i += strlen(buffer2) + 1) > PATH_MAX ||
+					    wstrlcat(buffer, "$", sizeof(buffer)) >= sizeof(buffer) ||
+					    wstrlcat(buffer, buffer2, sizeof(buffer)) >= sizeof(buffer))
+						goto error;
+				} else {
+					if ((i += strlen(tmp)) > PATH_MAX ||
+					    wstrlcat(buffer, tmp, sizeof(buffer)) >= sizeof(buffer))
+						goto error;
+				}
+			}
+		} else {
+			buffer[i++] = *path;
+			path++;
+		}
+	}
+
+	if (*path!=0)
+		goto error;
+
+	return wstrdup(buffer);
+
+error:
+	errno = ENAMETOOLONG;
+	werror(_("could not expand %s"), origpath);
+
+	return NULL;
+}
+
+/* return address of next char != tok or end of string whichever comes first */
+static const char *skipchar(const char *string, char tok)
+{
+	while (*string != 0 && *string == tok)
+		string++;
+
+	return string;
+}
+
+/* return address of next char == tok or end of string whichever comes first */
+static const char *nextchar(const char *string, char tok)
+{
+	while (*string != 0 && *string != tok)
+		string++;
+
+	return string;
+}
+
+/*
+ *----------------------------------------------------------------------
+ * findfile--
+ * 	Finds a file in a : separated list of paths. ~ expansion is also
+ * done.
+ *
+ * Returns:
+ * 	The complete path for the file (in a newly allocated string) or
+ * NULL if the file was not found.
+ *
+ * Side effects:
+ * 	A new string is allocated. It must be freed later.
+ *
+ *----------------------------------------------------------------------
+ */
+char *wfindfile(const char *paths, const char *file)
+{
+	char *path;
+	const char *tmp, *tmp2;
+	int len, flen;
+	char *fullpath;
+
+	if (!file)
+		return NULL;
+
+	if (*file == '/' || *file == '~' || *file == '$' || !paths || *paths == 0) {
+		if (access(file, F_OK) < 0) {
+			fullpath = wexpandpath(file);
+			if (!fullpath)
+				return NULL;
+
+			if (access(fullpath, F_OK) < 0) {
+				wfree(fullpath);
+				return NULL;
+			} else {
+				return fullpath;
+			}
+		} else {
+			return wstrdup(file);
+		}
+	}
+
+	flen = strlen(file);
+	tmp = paths;
+	while (*tmp) {
+		tmp = skipchar(tmp, ':');
+		if (*tmp == 0)
+			break;
+		tmp2 = nextchar(tmp, ':');
+		len = tmp2 - tmp;
+		path = wmalloc(len + flen + 2);
+		path = memcpy(path, tmp, len);
+		path[len] = 0;
+		if (path[len - 1] != '/' &&
+		    wstrlcat(path, "/", len + flen + 2) >= len + flen + 2) {
+			wfree(path);
+			return NULL;
+		}
+
+		if (wstrlcat(path, file, len + flen + 2) >= len + flen + 2) {
+			wfree(path);
+			return NULL;
+		}
+
+		fullpath = wexpandpath(path);
+		wfree(path);
+
+		if (fullpath) {
+			if (access(fullpath, F_OK) == 0) {
+				return fullpath;
+			}
+			wfree(fullpath);
+		}
+		tmp = tmp2;
+	}
+
+	return NULL;
+}
+
+char *wfindfileinlist(char *const *path_list, const char *file)
+{
+	int i;
+	char *path;
+	int len, flen;
+	char *fullpath;
+
+	if (!file)
+		return NULL;
+
+	if (*file == '/' || *file == '~' || !path_list) {
+		if (access(file, F_OK) < 0) {
+			fullpath = wexpandpath(file);
+			if (!fullpath)
+				return NULL;
+
+			if (access(fullpath, F_OK) < 0) {
+				wfree(fullpath);
+				return NULL;
+			} else {
+				return fullpath;
+			}
+		} else {
+			return wstrdup(file);
+		}
+	}
+
+	flen = strlen(file);
+	for (i = 0; path_list[i] != NULL; i++) {
+		len = strlen(path_list[i]);
+		path = wmalloc(len + flen + 2);
+		path = memcpy(path, path_list[i], len);
+		path[len] = 0;
+		if (wstrlcat(path, "/", len + flen + 2) >= len + flen + 2 ||
+		    wstrlcat(path, file, len + flen + 2) >= len + flen + 2) {
+			wfree(path);
+			return NULL;
+		}
+		/* expand tilde */
+		fullpath = wexpandpath(path);
+		wfree(path);
+		if (fullpath) {
+			/* check if file exists */
+			if (access(fullpath, F_OK) == 0) {
+				return fullpath;
+			}
+			wfree(fullpath);
+		}
+	}
+
+	return NULL;
+}
 
 char *wfindfileinarray(WMPropList *array, const char *file)
 {
@@ -94,3 +419,105 @@ char *wfindfileinarray(WMPropList *array, const char *file)
 	}
 	return NULL;
 }
+
+int wcopy_file(const char *dest_dir, const char *src_file, const char *dest_file)
+{
+	char *path_dst;
+	int fd_src, fd_dst;
+	struct stat stat_src;
+	mode_t permission_dst;
+	const size_t buffer_size = 2 * 1024 * 1024;	/* 4MB is a decent start choice to allow the OS to take advantage of modern disk's performance */
+	char *buffer;	/* The buffer is not created on the stack to avoid possible stack overflow as our buffer is big */
+
+ try_again_src:
+	fd_src = open(src_file, O_RDONLY | O_NOFOLLOW);
+	if (fd_src == -1) {
+		if (errno == EINTR)
+			goto try_again_src;
+		werror(_("Could not open input file \"%s\": %s"), src_file, strerror(errno));
+		return -1;
+	}
+
+	/* Only accept to copy regular files */
+	if (fstat(fd_src, &stat_src) != 0 || !S_ISREG(stat_src.st_mode)) {
+		close(fd_src);
+		return -1;
+	}
+
+	path_dst = wstrconcat(dest_dir, dest_file);
+ try_again_dst:
+	fd_dst = open(path_dst, O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR);
+	if (fd_dst == -1) {
+		if (errno == EINTR)
+			goto try_again_dst;
+		werror(_("Could not create target file \"%s\": %s"), path_dst, strerror(errno));
+		wfree(path_dst);
+		close(fd_src);
+		return -1;
+	}
+
+	buffer = malloc(buffer_size);	/* Don't use wmalloc to avoid the memset(0) we don't need */
+	if (buffer == NULL) {
+		werror(_("could not allocate memory for the copy buffer"));
+		close(fd_dst);
+		goto cleanup_and_return_failure;
+	}
+
+	for (;;) {
+		ssize_t size_data;
+		const char *write_ptr;
+		size_t write_remain;
+
+	try_again_read:
+		size_data = read(fd_src, buffer, buffer_size);
+		if (size_data == 0)
+			break; /* End of File have been reached */
+		if (size_data < 0) {
+			if (errno == EINTR)
+				goto try_again_read;
+			werror(_("could not read from file \"%s\": %s"), src_file, strerror(errno));
+			close(fd_dst);
+			goto cleanup_and_return_failure;
+		}
+
+		write_ptr = buffer;
+		write_remain = size_data;
+		while (write_remain > 0) {
+			ssize_t write_done;
+
+		try_again_write:
+			write_done = write(fd_dst, write_ptr, write_remain);
+			if (write_done < 0) {
+				if (errno == EINTR)
+					goto try_again_write;
+				werror(_("could not write data to file \"%s\": %s"), path_dst, strerror(errno));
+				close(fd_dst);
+				goto cleanup_and_return_failure;
+			}
+			write_ptr    += write_done;
+			write_remain -= write_done;
+		}
+	}
+
+	/* Keep only the permission-related part of the field: */
+	permission_dst = stat_src.st_mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
+	if (fchmod(fd_dst, permission_dst) != 0)
+		wwarning(_("could not set permission 0%03o on file \"%s\": %s"),
+		         permission_dst, path_dst, strerror(errno));
+
+	if (close(fd_dst) != 0) {
+		werror(_("could not close the file \"%s\": %s"), path_dst, strerror(errno));
+	cleanup_and_return_failure:
+		free(buffer);
+		close(fd_src);
+		unlink(path_dst);
+		wfree(path_dst);
+		return -1;
+	}
+
+	free(buffer);
+	wfree(path_dst);
+	close(fd_src);
+
+	return 0;
+}

WINGs/handlers.c

@@ -279,7 +279,7 @@ Bool W_CheckIdleHandlers(void)
 		return (idleHandler != NULL && WMGetArrayItemCount(idleHandler) > 0);
 	}
 
-	handlerCopy = WMCreateArrayWithArray(idleHandler);
+	handlerCopy = WMDuplicateArray(idleHandler);
 
 	WM_ITERATE_ARRAY(handlerCopy, handler, iter) {
 		/* check if the handler still exist or was removed by a callback */
@@ -429,7 +429,7 @@ Bool W_HandleInputEvents(Bool waitForInput, int inputfd)
 	count = poll(fds, nfds + extrafd, timeout);
 
 	if (count > 0 && nfds > 0) {
-		WMArray *handlerCopy = WMCreateArrayWithArray(inputHandler);
+		WMArray *handlerCopy = WMDuplicateArray(inputHandler);
 		int mask;
 
 		/* use WM_ITERATE_ARRAY() here */
@@ -527,7 +527,7 @@ Bool W_HandleInputEvents(Bool waitForInput, int inputfd)
 	count = select(1 + maxfd, &rset, &wset, &eset, timeoutPtr);
 
 	if (count > 0 && nfds > 0) {
-		WMArray *handlerCopy = WMCreateArrayWithArray(inputHandler);
+		WMArray *handlerCopy = WMDuplicateArray(inputHandler);
 		int mask;
 
 		/* use WM_ITERATE_ARRAY() here */

WINGs/hashtable.c

@@ -0,0 +1,422 @@
+#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

@@ -0,0 +1,223 @@
+/*
+ *  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/menuparser.c

@@ -536,14 +536,12 @@ found_end_define_fname:
 			while (*src != '\0') {
 				idx = 0;
 				if (*src == '~') {
-					char *home_head = wgethomedir();
-					char *home = home_head;;
+					const char *home = wgethomedir();
 					while (*home != '\0') {
 						if (idx < sizeof(buffer) - 2)
 							buffer[idx++] = *home;
 						home++;
 					}
-					wfree(home_head);
 					src++;
 				}
 

WINGs/notification.c

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

WINGs/selection.c

@@ -237,7 +237,7 @@ static void handleRequestEvent(XEvent * event)
 	}
 
 	/* delete handlers */
-	copy = WMCreateArrayWithArray(selHandlers);
+	copy = WMDuplicateArray(selHandlers);
 	WM_ITERATE_ARRAY(copy, handler, iter) {
 		if (handler && handler->flags.delete_pending) {
 			WMDeleteSelectionHandler(handler->view, handler->selection, handler->timestamp);
@@ -261,9 +261,8 @@ static WMData *getSelectionData(Display * dpy, Window win, Atom where)
 
 	bpi = bits / 8;
 
-	wdata = WMCreateDataWithBytes(data, len * bpi);
+	wdata = WMCreateDataWithBytesNoCopy(data, len * bpi, (void *) XFree);
 	WMSetDataFormat(wdata, bits);
-	XFree(data);
 
 	return wdata;
 }
@@ -301,7 +300,7 @@ static void handleNotifyEvent(XEvent * event)
 	}
 
 	/* delete callbacks */
-	copy = WMCreateArrayWithArray(selCallbacks);
+	copy = WMDuplicateArray(selCallbacks);
 	WM_ITERATE_ARRAY(copy, handler, iter) {
 		if (handler && handler->flags.delete_pending) {
 			WMDeleteSelectionCallback(handler->view, handler->selection, handler->timestamp);

WINGs/userdefaults.c

@@ -46,6 +46,40 @@ static void synchronizeUserDefaults(void *foo);
 #define UD_SYNC_INTERVAL	2000
 #endif
 
+const char *wusergnusteppath(void)
+{
+	static const char subdir[] = "/" GSUSER_SUBDIR;
+	static char *path = NULL;
+	char *gspath;
+	const char *h;
+	int pathlen;
+
+	if (path)
+		/* Value have been already computed, re-use it */
+		return path;
+
+	gspath = GETENV("WMAKER_USER_ROOT");
+	if (gspath) {
+		gspath = wexpandpath(gspath);
+		if (gspath) {
+			path = gspath;
+			return path;
+		}
+		wwarning(_("variable WMAKER_USER_ROOT defined with invalid path, not used"));
+	}
+
+	h = wgethomedir();
+	if (!h)
+		return NULL;
+
+	pathlen = strlen(h);
+	path = wmalloc(pathlen + sizeof(subdir));
+	strcpy(path, h);
+	strcpy(path + pathlen, subdir);
+
+	return path;
+}
+
 const char *wuserdatapath(void)
 {
 	static char *path = NULL;
@@ -297,7 +331,7 @@ WMUserDefaults *WMGetStandardUserDefaults(void)
 	/* terminate list */
 	defaults->searchList[2] = NULL;
 
-	defaults->searchListArray = WMCreateEmptyPLArray();
+	defaults->searchListArray = WMCreatePLArray(NULL, NULL);
 
 	i = 0;
 	while (defaults->searchList[i]) {
@@ -370,7 +404,7 @@ WMUserDefaults *WMGetDefaultsFromPath(const char *path)
 	/* terminate list */
 	defaults->searchList[1] = NULL;
 
-	defaults->searchListArray = WMCreateEmptyPLArray();
+	defaults->searchListArray = WMCreatePLArray(NULL, NULL);
 
 	i = 0;
 	while (defaults->searchList[i]) {

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 = WMCreateIdentityHashTable();
+	bPtr->table = WMCreateHashTable(WMIntHashCallbacks);
 
 	bPtr->delay = DEFAULT_DELAY;
 

WINGs/wcolorpanel.c

@@ -2994,13 +2994,10 @@ static void customPaletteMenuNewFromFile(W_ColorPanel * panel)
 	int i;
 	RImage *tmpImg = NULL;
 
-	if ((!panel->lastBrowseDir) || (strcmp(panel->lastBrowseDir, "\0") == 0)) {
-		char *homedir = wgethomedir();
-		spath = wexpandpath(homedir);
-		wfree(homedir);
-	} else {
+	if ((!panel->lastBrowseDir) || (strcmp(panel->lastBrowseDir, "\0") == 0))
+		spath = wexpandpath(wgethomedir());
+	else
 		spath = wexpandpath(panel->lastBrowseDir);
-	}
 
 	browseP = WMGetOpenPanel(scr);
 	WMSetFilePanelCanChooseDirectories(browseP, 0);

WINGs/wfilepanel.c

@@ -761,15 +761,17 @@ static void goFloppy(WMWidget *widget, void *p_panel)
 static void goHome(WMWidget *widget, void *p_panel)
 {
 	WMFilePanel *panel = p_panel;
-	char *home;
+	const char *home;
 
 	/* Parameter not used, but tell the compiler that it is ok */
 	(void) widget;
 
+	/* home is statically allocated. Don't free it! */
 	home = wgethomedir();
+	if (!home)
+		return;
 
 	WMSetFilePanelDirectory(panel, home);
-	wfree(home);
 }
 
 static void handleEvents(XEvent * event, void *data)

WINGs/wfont.c

@@ -51,15 +51,12 @@ static char *xlfdToFcName(const char *xlfd)
 {
 	FcPattern *pattern;
 	char *fname;
-	char *result;
 
 	pattern = xlfdToFcPattern(xlfd);
 	fname = (char *)FcNameUnparse(pattern);
-	result = wstrdup(fname);
-	free(fname);
 	FcPatternDestroy(pattern);
 
-	return result;
+	return fname;
 }
 
 static Bool hasProperty(FcPattern * pattern, const char *property)
@@ -95,7 +92,6 @@ static Bool hasPropertyWithStringValue(FcPattern * pattern, const char *object,
 static char *makeFontOfSize(const char *font, int size, const char *fallback)
 {
 	FcPattern *pattern;
-	char *name;
 	char *result;
 
 	if (font[0] == '-') {
@@ -119,9 +115,7 @@ static char *makeFontOfSize(const char *font, int size, const char *fallback)
 
 	/*FcPatternPrint(pattern); */
 
-	name = (char *)FcNameUnparse(pattern);
-	result = wstrdup(name);
-	free(name);
+	result = (char *)FcNameUnparse(pattern);
 	FcPatternDestroy(pattern);
 
 	return result;
@@ -427,7 +421,7 @@ WMFont *WMCopyFontWithStyle(WMScreen * scrPtr, WMFont * font, WMFontStyle style)
 	name = (char *)FcNameUnparse(pattern);
 	copy = WMCreateFont(scrPtr, name);
 	FcPatternDestroy(pattern);
-	free(name);
+	wfree(name);
 
 	return copy;
 }

WINGs/wfontpanel.c

@@ -535,7 +535,7 @@ static void listFamilies(WMScreen * scr, WMFontPanel * panel)
 	if (pat)
 		FcPatternDestroy(pat);
 
-	families = WMCreateStringHashTable();
+	families = WMCreateHashTable(WMStringPointerHashCallbacks);
 
 	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 = WMCreateStringHashTable();
+	scrPtr->fontCache = WMCreateHashTable(WMStringPointerHashCallbacks);
 
 	scrPtr->xftdraw = XftDrawCreate(scrPtr->display, W_DRAWABLE(scrPtr), scrPtr->visual, scrPtr->colormap);
 

WPrefs.app/Appearance.c

@@ -1110,7 +1110,7 @@ static void deleteTexture(WMWidget * w, void *data)
 static void extractTexture(WMWidget * w, void *data)
 {
 	_Panel *panel = (_Panel *) data;
-	char *path, *homedir;
+	char *path;
 	WMOpenPanel *opanel;
 	WMScreen *scr = WMWidgetScreen(w);
 
@@ -1118,17 +1118,13 @@ static void extractTexture(WMWidget * w, void *data)
 	WMSetFilePanelCanChooseDirectories(opanel, False);
 	WMSetFilePanelCanChooseFiles(opanel, True);
 
-	homedir = wgethomedir();
-	if (WMRunModalFilePanelForDirectory(opanel, panel->parent, homedir, _("Select File"), NULL)) {
+	if (WMRunModalFilePanelForDirectory(opanel, panel->parent, wgethomedir(), _("Select File"), NULL)) {
 		path = WMGetFilePanelFileName(opanel);
 
 		OpenExtractPanelFor(panel);
 
 		wfree(path);
 	}
-	if (homedir) {
-		wfree(homedir);
-	}
 }
 
 static void changePage(WMWidget * w, void *data)
@@ -2228,7 +2224,7 @@ static void prepareForClose(_Panel * panel)
 	WMUserDefaults *udb = WMGetStandardUserDefaults();
 	int i;
 
-	textureList = WMCreateEmptyPLArray();
+	textureList = WMCreatePLArray(NULL, NULL);
 
 	/* store list of textures */
 	for (i = 8; i < WMGetListNumberOfRows(panel->texLs); i++) {
@@ -2250,7 +2246,7 @@ static void prepareForClose(_Panel * panel)
 	WMReleasePropList(textureList);
 
 	/* store list of colors */
-	textureList = WMCreateEmptyPLArray();
+	textureList = WMCreatePLArray(NULL, NULL);
 	for (i = 0; i < wlengthof(sample_colors); i++) {
 		WMColor *color;
 		char *str;

WPrefs.app/FontSimple.c

@@ -288,7 +288,6 @@ static char *getSelectedFont(_Panel * panel, FcChar8 * curfont)
 	WMListItem *item;
 	FcPattern *pat;
 	char *name;
-	char *result;
 
 	if (curfont)
 		pat = FcNameParse(curfont);
@@ -322,12 +321,9 @@ static char *getSelectedFont(_Panel * panel, FcChar8 * curfont)
 	}
 
 	name = (char *)FcNameUnparse(pat);
-	result = wstrdup(name);
-	free(name);
 	FcPatternDestroy(pat);
 
-
-	return result;
+	return name;
 }
 
 static void updateSampleFont(_Panel * panel)

WPrefs.app/HotCornerShortcuts.c

@@ -151,7 +151,7 @@ static void storeData(_Panel * panel)
 
 	SetIntegerForKey(WMGetSliderValue(panel->hceS), "HotCornerEdge");	
 
-	list = WMCreateEmptyPLArray();
+	list = WMCreatePLArray(NULL, NULL);
 	for (i = 0; i < sizeof(panel->hcactionsT) / sizeof(WMTextField *); i++) {
 		str = WMGetTextFieldText(panel->hcactionsT[i]);
 		if (strlen(str) == 0)

WPrefs.app/Makefile.am

@@ -66,8 +66,6 @@ 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/Paths.c

@@ -203,7 +203,7 @@ static void storeData(_Panel * panel)
 	int i;
 	char *p;
 
-	list = WMCreateEmptyPLArray();
+	list = WMCreatePLArray(NULL, NULL);
 	for (i = 0; i < WMGetListNumberOfRows(panel->icoL); i++) {
 		p = WMGetListItem(panel->icoL, i)->text;
 		tmp = WMCreatePLString(p);
@@ -211,7 +211,7 @@ static void storeData(_Panel * panel)
 	}
 	SetObjectForKey(list, "IconPath");
 
-	list = WMCreateEmptyPLArray();
+	list = WMCreatePLArray(NULL, NULL);
 	for (i = 0; i < WMGetListNumberOfRows(panel->pixL); i++) {
 		p = WMGetListItem(panel->pixL, i)->text;
 		tmp = WMCreatePLString(p);

WPrefs.app/TexturePanel.c

@@ -627,7 +627,7 @@ static void browseImageCallback(WMWidget *w, void *data)
 	WMSetFilePanelCanChooseFiles(opanel, True);
 
 	if (!ipath)
-		ipath = wgethomedir();
+		ipath = wstrdup(wgethomedir());
 
 	if (WMRunModalFilePanelForDirectory(opanel, panel->win, ipath, _("Open Image"), NULL)) {
 		char *path, *fullpath;

WPrefs.app/WPrefs.c

@@ -705,10 +705,10 @@ static void loadConfigurations(WMScreen * scr, WMWindow * mainw)
 	}
 
 	if (!db) {
-		db = WMCreateEmptyPLDictionary();
+		db = WMCreatePLDictionary(NULL, NULL);
 	}
 	if (!gdb) {
-		gdb = WMCreateEmptyPLDictionary();
+		gdb = WMCreatePLDictionary(NULL, NULL);
 	}
 
 	GlobalDB = gdb;

WPrefs.app/main.c

@@ -47,6 +47,14 @@ 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);
@@ -79,6 +87,8 @@ int main(int argc, char **argv)
 	int i;
 	char *display_name = "";
 
+	wsetabort(wAbort);
+
 	memset(DeadHandlers, 0, sizeof(DeadHandlers));
 
 	WMInitializeApplication("WPrefs", &argc, argv);
@@ -145,12 +155,7 @@ int main(int argc, char **argv)
 		exit(0);
 	}
 
-        /*
-         * Rust rewrite note: this API surface has been removed, but we leave in
-         * a record of where it was invoked to set a value other than the
-         * default, in case it helps to track down bugs in the future.
-         */
-	/* WMPLSetCaseSensitive(False); */
+	WMPLSetCaseSensitive(False);
 
 	Initialize(scr);
 

configure.ac

@@ -49,17 +49,6 @@ 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_SUBST(CARGO, [cargo])
-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/])
-)
-AC_SUBST(RUSTC, [rustc])
 
 dnl libtool library versioning
 dnl ==========================
@@ -353,6 +342,24 @@ 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
@@ -957,17 +964,11 @@ 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,6 +253,14 @@ 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
 
 
@@ -460,6 +468,8 @@ 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,7 +6,13 @@ 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 \
@@ -134,7 +140,7 @@ else
 nodist_wmaker_SOURCES = misc.hack_nf.c \
 	xmodifier.hack_nf.c
 
-CLEANFILES = $(nodist_wmaker_SOURCES)
+CLEANFILES = $(nodist_wmaker_SOURCES) ../wmakerlib/target
 
 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 \
@@ -160,8 +166,7 @@ wmaker_LDADD = \
 	$(top_builddir)/WINGs/libWINGs.la\
 	$(top_builddir)/WINGs/libWUtil.la\
 	$(top_builddir)/wrlib/libwraster.la\
-	$(top_builddir)/wutil-rs/target/debug/libwutil_rs.a\
-	$(top_builddir)/wmaker-rs/target/debug/libwmaker_rs.a\
+	$(wmakerlib)\
 	@XLFLAGS@ \
 	@LIBXRANDR@ \
 	@LIBXINERAMA@ \

src/appicon.c

@@ -75,24 +75,24 @@ struct WAppIcon {
 	Window main_window;
 	struct WDock *dock;		 /* In which dock is docked. */
 	struct _AppSettingsPanel *panel; /* Settings Panel */
-	unsigned int docked:1;
-	unsigned int omnipresent:1;	 /* If omnipresent when
+	unsigned int docked;
+	unsigned int omnipresent;	 /* If omnipresent when
 					  * docked in clip */
-	unsigned int attracted:1;	 /* If it was attracted by the clip */
-	unsigned int launching:1;
-	unsigned int running:1;		 /* application is already running */
-	unsigned int relaunching:1;	 /* launching 2nd instance */
-	unsigned int forced_dock:1;
-	unsigned int auto_launch:1;	 /* launch app on startup */
-	unsigned int remote_start:1;
-	unsigned int updated:1;
-	unsigned int editing:1;		 /* editing docked icon */
-	unsigned int drop_launch:1;	 /* launching from drop action */
-	unsigned int paste_launch:1;	 /* launching from paste action */
-	unsigned int destroyed:1;	 /* appicon was destroyed */
-	unsigned int buggy_app:1;	 /* do not make dock rely on hints
+	unsigned int attracted;	 /* If it was attracted by the clip */
+	unsigned int launching;
+	unsigned int running;		 /* application is already running */
+	unsigned int relaunching;	 /* launching 2nd instance */
+	unsigned int forced_dock;
+	unsigned int auto_launch;	 /* launch app on startup */
+	unsigned int remote_start;
+	unsigned int updated;
+	unsigned int editing;		 /* editing docked icon */
+	unsigned int drop_launch;	 /* launching from drop action */
+	unsigned int paste_launch;	 /* launching from paste action */
+	unsigned int destroyed;	 /* appicon was destroyed */
+	unsigned int buggy_app;	 /* do not make dock rely on hints
 					  * set by app */
-	unsigned int lock:1;		 /* do not allow to be destroyed */
+	unsigned int lock;		 /* do not allow to be destroyed */
 };
 
 /******** Accessors/mutators ********/
@@ -1360,7 +1360,7 @@ static void wApplicationSaveIconPathFor(const char *iconPath, const char *wm_ins
 		val = WMGetFromPLDictionary(adict, iconk);
 	} else {
 		/* no dictionary for app, so create one */
-		adict = WMCreateEmptyPLDictionary();
+		adict = WMCreatePLDictionary(NULL, NULL);
 		WMPutInPLDictionary(dict, key, adict);
 		WMReleasePropList(adict);
 		val = NULL;

src/appmenu.c

@@ -139,7 +139,7 @@ static WMenu *parseMenuCommand(WScreen * scr, Window win, char **slist, int coun
 				}
 				wstrlcpy(title, &slist[*index][pos], sizeof(title));
 			}
-			data = wmalloc(sizeof(WAppMenuData));
+			data = malloc(sizeof(WAppMenuData));
 			if (data == NULL) {
 				wwarning(_("appmenu: out of memory creating menu for window %lx"), win);
 				wMenuDestroy(menu, True);
@@ -152,7 +152,7 @@ static WMenu *parseMenuCommand(WScreen * scr, Window win, char **slist, int coun
 			if (!entry) {
 				wMenuDestroy(menu, True);
 				wwarning(_("appmenu: out of memory creating menu for window %lx"), win);
-				wfree(data);
+				free(data);
 				return NULL;
 			}
 			if (rtext[0] != 0)

src/client.c

@@ -307,7 +307,7 @@ void wClientCheckProperty(WWindow * wwin, XPropertyEvent * event)
 				wWindowUpdateName(wwin, tmp);
 			}
 			if (tmp)
-				wfree(tmp);
+				XFree(tmp);
 		}
 		break;
 
@@ -616,7 +616,7 @@ void wClientCheckProperty(WWindow * wwin, XPropertyEvent * event)
 
 			wWindowUpdateGNUstepAttr(wwin, attr);
 
-			wfree(attr);
+			XFree(attr);
 		} else {
 			wNETWMCheckClientHintChange(wwin, event);
 		}

src/defaults.c

@@ -862,12 +862,7 @@ static void initDefaults(void)
 	unsigned int i;
 	WDefaultEntry *entry;
 
-        /*
-         * Rust rewrite note: this API surface has been removed, but we leave in
-         * a record of where it was invoked to set a value other than the
-         * default, in case it helps to track down bugs in the future.
-         */
-	/* WMPLSetCaseSensitive(False); */
+	WMPLSetCaseSensitive(False);
 
 	for (i = 0; i < wlengthof(optionList); i++) {
 		entry = &optionList[i];

src/dialog.c

@@ -250,7 +250,7 @@ static void SaveHistory(WMArray * history, const char *filename)
 	int i;
 	WMPropList *plhistory;
 
-	plhistory = WMCreateEmptyPLArray();
+	plhistory = WMCreatePLArray(NULL);
 
 	for (i = 0; i < WMGetArrayItemCount(history); ++i)
 		WMAddToPLArray(plhistory, WMCreatePLString(WMGetFromArray(history, i)));
@@ -367,7 +367,7 @@ static void handleHistoryKeyPress(XEvent * event, void *clientData)
 	case XK_Up:
 		if (p->histpos < WMGetArrayItemCount(p->history) - 1) {
 			if (p->histpos == 0)
-				wfree(WMSetInArray(p->history, 0, WMGetTextFieldText(p->panel->text)));
+				wfree(WMReplaceInArray(p->history, 0, WMGetTextFieldText(p->panel->text)));
 			p->histpos++;
 			WMSetTextFieldText(p->panel->text, WMGetFromArray(p->history, p->histpos));
 		}
@@ -468,7 +468,7 @@ int wAdvancedInputDialog(WScreen *scr, const char *title, const char *message, c
 
 	if (p->panel->result == WAPRDefault) {
 		result = WMGetTextFieldText(p->panel->text);
-		wfree(WMSetInArray(p->history, 0, wstrdup(result)));
+		wfree(WMReplaceInArray(p->history, 0, wstrdup(result)));
 		SaveHistory(p->history, filename);
 	} else
 		result = NULL;

src/dock.c

@@ -1603,13 +1603,11 @@ static WMPropList *make_icon_state(WAppIcon *btn)
 			snprintf(buffer, sizeof(buffer), "%hi,%hi", wAppIconGetXIndex(btn), wAppIconGetYIndex(btn));
 		position = WMCreatePLString(buffer);
 
-		node = WMCreatePLDictionary(dCommand, command);
-		WMPutInPLDictionary(node, dName, name);
-		WMPutInPLDictionary(node, dAutoLaunch, autolaunch);
-		WMPutInPLDictionary(node, dLock, lock);
-		WMPutInPLDictionary(node, dForced, forced);
-		WMPutInPLDictionary(node, dBuggyApplication, buggy);
-		WMPutInPLDictionary(node, dPosition, position);
+		node = WMCreatePLDictionary(dCommand, command,
+					    dName, name,
+					    dAutoLaunch, autolaunch,
+					    dLock, lock,
+					    dForced, forced, dBuggyApplication, buggy, dPosition, position, NULL);
 		WMReleasePropList(command);
 		WMReleasePropList(name);
 		WMReleasePropList(position);
@@ -1644,7 +1642,7 @@ static WMPropList *dockSaveState(WDock *dock)
 	WMPropList *value, *key;
 	char buffer[256];
 
-	list = WMCreateEmptyPLArray();
+	list = WMCreatePLArray(NULL);
 
 	for (i = (dock->type == WM_DOCK ? 0 : 1); i < dock->max_icons; i++) {
 		WAppIcon *btn = dock->icon_array[i];
@@ -1659,7 +1657,7 @@ static WMPropList *dockSaveState(WDock *dock)
 		}
 	}
 
-	dock_state = WMCreatePLDictionary(dApplications, list);
+	dock_state = WMCreatePLDictionary(dApplications, list, NULL);
 
 	if (dock->type == WM_DOCK) {
 		snprintf(buffer, sizeof(buffer), "Applications%i", dock->screen_ptr->scr_height);
@@ -5074,7 +5072,7 @@ static WMPropList *drawerSaveState(WDock *drawer)
 	ai = drawer->icon_array[0];
 	/* Store its name */
 	pstr = WMCreatePLString(wAppIconGetWmInstance(ai));
-	drawer_state = WMCreatePLDictionary(dName, pstr);
+	drawer_state = WMCreatePLDictionary(dName, pstr, NULL); /* we need this final NULL */
 	WMReleasePropList(pstr);
 
 	/* Store its position */
@@ -5116,7 +5114,7 @@ void wDrawersSaveState(WScreen *scr)
 
 	make_keys();
 
-	all_drawers = WMCreateEmptyPLArray();
+	all_drawers = WMCreatePLArray(NULL);
 	for (i=0, dc = scr->drawers;
 	     i < scr->drawer_count;
 	     i++, dc = dc->next) {

src/event.c

@@ -1796,7 +1796,7 @@ static void handleKeyPress(XEvent * event)
 			}
 
 			if (wwin->flags.selected && scr->selected_windows) {
-				scr->shortcutWindows[widx] = WMCreateArrayWithArray(scr->selected_windows);
+				scr->shortcutWindows[widx] = WMDuplicateArray(scr->selected_windows);
 				/*WMRemoveFromArray(scr->shortcutWindows[index], wwin);
 				   WMInsertInArray(scr->shortcutWindows[index], 0, wwin); */
 			} else {
@@ -1816,7 +1816,7 @@ static void handleKeyPress(XEvent * event)
 				if (scr->shortcutWindows[widx]) {
 					WMFreeArray(scr->shortcutWindows[widx]);
 				}
-				scr->shortcutWindows[widx] = WMCreateArrayWithArray(scr->selected_windows);
+				scr->shortcutWindows[widx] = WMDuplicateArray(scr->selected_windows);
 			}
 		}
 

src/main.c

@@ -624,6 +624,7 @@ 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);

src/menu.c

@@ -2309,8 +2309,7 @@ static void saveMenuInfo(WMPropList * dict, WMenu * menu, WMPropList * key)
 
 	snprintf(buffer, sizeof(buffer), "%i,%i", menu->frame_x, menu->frame_y);
 	value = WMCreatePLString(buffer);
-	list = WMCreateEmptyPLArray();
-        WMAddToPLArray(list, value);
+	list = WMCreatePLArray(value, NULL);
 	if (menu->flags.lowered)
 		WMAddToPLArray(list, WMCreatePLString("lowered"));
 	WMPutInPLDictionary(dict, key, list);
@@ -2323,7 +2322,7 @@ void wMenuSaveState(WScreen * scr)
 	WMPropList *menus, *key;
 	int save_menus = 0;
 
-	menus = WMCreateEmptyPLDictionary();
+	menus = WMCreatePLDictionary(NULL, NULL);
 
 	if (scr->switch_menu && scr->switch_menu->flags.buttoned) {
 		key = WMCreatePLString("SwitchMenu");

src/misc.c

@@ -520,7 +520,7 @@ char *ExpandOptions(WScreen *scr, const char *cmdline)
 
 	len = strlen(cmdline);
 	olen = len + 1;
-	out = wmalloc(olen);
+	out = malloc(olen);
 	if (!out) {
 		wwarning(_("out of memory during expansion of \"%s\""), cmdline);
 		return NULL;
@@ -573,7 +573,7 @@ char *ExpandOptions(WScreen *scr, const char *cmdline)
 						 (unsigned int)scr->focused_window->client_win);
 					slen = strlen(tmpbuf);
 					olen += slen;
-					nout = wrealloc(out, olen);
+					nout = realloc(out, olen);
 					if (!nout) {
 						wwarning(_("out of memory during expansion of '%s' for command \"%s\""), "%w", cmdline);
 						goto error;
@@ -590,7 +590,7 @@ char *ExpandOptions(WScreen *scr, const char *cmdline)
 				snprintf(tmpbuf, sizeof(tmpbuf), "0x%x", (unsigned int)scr->current_workspace + 1);
 				slen = strlen(tmpbuf);
 				olen += slen;
-				nout = wrealloc(out, olen);
+				nout = realloc(out, olen);
 				if (!nout) {
 					wwarning(_("out of memory during expansion of '%s' for command \"%s\""), "%W", cmdline);
 					goto error;
@@ -607,7 +607,7 @@ char *ExpandOptions(WScreen *scr, const char *cmdline)
 				if (user_input) {
 					slen = strlen(user_input);
 					olen += slen;
-					nout = wrealloc(out, olen);
+					nout = realloc(out, olen);
 					if (!nout) {
 						wwarning(_("out of memory during expansion of '%s' for command \"%s\""), "%a", cmdline);
 						goto error;
@@ -630,7 +630,7 @@ char *ExpandOptions(WScreen *scr, const char *cmdline)
 				}
 				slen = strlen(scr->xdestring);
 				olen += slen;
-				nout = wrealloc(out, olen);
+				nout = realloc(out, olen);
 				if (!nout) {
 					wwarning(_("out of memory during expansion of '%s' for command \"%s\""), "%d", cmdline);
 					goto error;
@@ -651,7 +651,7 @@ char *ExpandOptions(WScreen *scr, const char *cmdline)
 				}
 				slen = strlen(selection);
 				olen += slen;
-				nout = wrealloc(out, olen);
+				nout = realloc(out, olen);
 				if (!nout) {
 					wwarning(_("out of memory during expansion of '%s' for command \"%s\""), "%s", cmdline);
 					goto error;

src/properties.c

@@ -133,7 +133,7 @@ int PropGetGNUstepWMAttr(Window window, GNUstepWMAttributes ** attr)
 	if (!data)
 		return False;
 
-	*attr = wmalloc(sizeof(GNUstepWMAttributes));
+	*attr = malloc(sizeof(GNUstepWMAttributes));
 	if (!*attr) {
 		XFree(data);
 		return False;
@@ -183,7 +183,7 @@ void PropSetIconTileHint(WScreen * scr, RImage * image)
 		imageAtom = XInternAtom(dpy, "_RGBA_IMAGE", False);
 	}
 
-	tmp = wmalloc(image->width * image->height * 4 + 4);
+	tmp = malloc(image->width * image->height * 4 + 4);
 	if (!tmp) {
 		wwarning("could not allocate memory to set _WINDOWMAKER_ICON_TILE hint");
 		return;

src/screen.c

@@ -968,6 +968,8 @@ void wScreenSaveState(WScreen * scr)
 	old_state = scr->session_state;
 	scr->session_state = WMCreatePLDictionary(NULL, NULL);
 
+	WMPLSetCaseSensitive(True);
+
 	/* save dock state to file */
 	if (!wPreferences.flags.nodock) {
 		wDockSaveState(scr, old_state);
@@ -1007,13 +1009,8 @@ void wScreenSaveState(WScreen * scr)
 			WMPutInPLDictionary(scr->session_state, dWorkspace, foo);
 	}
 
-        /*
-         * Rust rewrite note: this API surface has been removed, but we leave in
-         * a record of where it was invoked to set a value other than the
-         * default, in case it helps to track down bugs in the future.
-         */
 	/* clean up */
-	/* WMPLSetCaseSensitive(False); */
+	WMPLSetCaseSensitive(False);
 
 	wMenuSaveState(scr);
 

src/session.c

@@ -241,15 +241,14 @@ static WMPropList *makeWindowState(WWindow * wwin, WApplication * wapp)
 		snprintf(buffer, sizeof(buffer), "%u", mask);
 		shortcut = WMCreatePLString(buffer);
 
-		win_state = WMCreatePLDictionary(sName, name);
-		WMPutInPLDictionary(win_state, sCommand, cmd);
-		WMPutInPLDictionary(win_state, sWorkspace, workspace);
-		WMPutInPLDictionary(win_state, sShaded, shaded);
-		WMPutInPLDictionary(win_state, sMiniaturized, miniaturized);
-		WMPutInPLDictionary(win_state, sMaximized, maximized);
-		WMPutInPLDictionary(win_state, sHidden, hidden);
-		WMPutInPLDictionary(win_state, sShortcutMask, shortcut);
-		WMPutInPLDictionary(win_state, sGeometry, geometry);
+		win_state = WMCreatePLDictionary(sName, name,
+						 sCommand, cmd,
+						 sWorkspace, workspace,
+						 sShaded, shaded,
+						 sMiniaturized, miniaturized,
+						 sMaximized, maximized,
+						 sHidden, hidden,
+						 sShortcutMask, shortcut, sGeometry, geometry, NULL);
 
 		WMReleasePropList(name);
 		WMReleasePropList(cmd);
@@ -314,7 +313,7 @@ void wSessionSaveState(WScreen * scr)
 			return;
 	}
 
-	list = WMCreateEmptyPLArray();
+	list = WMCreatePLArray(NULL);
 
 	wapp_list = WMCreateArray(16);
 
@@ -488,6 +487,8 @@ void wSessionRestoreState(WScreen *scr)
 	if (!scr->session_state)
 		return;
 
+	WMPLSetCaseSensitive(True);
+
 	apps = WMGetFromPLDictionary(scr->session_state, sApplications);
 	if (!apps)
 		return;
@@ -578,13 +579,8 @@ void wSessionRestoreState(WScreen *scr)
 		if (class)
 			wfree(class);
 	}
-        /*
-         * Rust rewrite note: this API surface has been removed, but we leave in
-         * a record of where it was invoked to set a value other than the
-         * default, in case it helps to track down bugs in the future.
-         */
 	/* clean up */
-	/* WMPLSetCaseSensitive(False); */
+	WMPLSetCaseSensitive(False);
 }
 
 void wSessionRestoreLastWorkspace(WScreen * scr)
@@ -598,6 +594,8 @@ void wSessionRestoreLastWorkspace(WScreen * scr)
 	if (!scr->session_state)
 		return;
 
+	WMPLSetCaseSensitive(True);
+
 	wks = WMGetFromPLDictionary(scr->session_state, sWorkspace);
 	if (!wks || !WMIsPLString(wks))
 		return;
@@ -607,13 +605,8 @@ void wSessionRestoreLastWorkspace(WScreen * scr)
 	if (!value)
 		return;
 
-        /*
-         * Rust rewrite note: this API surface has been removed, but we leave in
-         * a record of where it was invoked to set a value other than the
-         * default, in case it helps to track down bugs in the future.
-         */
 	/* clean up */
-	/* WMPLSetCaseSensitive(False); */
+	WMPLSetCaseSensitive(False);
 
 	/* Get the workspace number for the workspace name */
 	w = wGetWorkspaceNumber(scr, value);

src/switchpanel.c

@@ -132,7 +132,7 @@ static void changeImage(WSwitchPanel *panel, int idecks, int selected, Bool dim,
 	if (flags == desired && !force)
 		return;
 
-	WMSetInArray(panel->flags, idecks, (void *) (uintptr_t) desired);
+	WMReplaceInArray(panel->flags, idecks, (void *) (uintptr_t) desired);
 
 	if (!panel->bg && !panel->tile && !selected)
 		WMSetFrameRelief(icon, WRFlat);

src/wdefaults.c

@@ -174,18 +174,15 @@ static WMPropList *get_value_from_instanceclass(const char *value)
 
 	key = WMCreatePLString(value);
 
+	WMPLSetCaseSensitive(True);
+
 	if (w_global.domain.window_attr->dictionary)
 		val = key ? WMGetFromPLDictionary(w_global.domain.window_attr->dictionary, key) : NULL;
 
 	if (key)
 		WMReleasePropList(key);
 
-        /*
-         * Rust rewrite note: this API surface has been removed, but we leave in
-         * a record of where it was invoked to set a value other than the
-         * default, in case it helps to track down bugs in the future.
-         */
-	/* WMPLSetCaseSensitive(False); */
+	WMPLSetCaseSensitive(False);
 
 	return val;
 }
@@ -222,6 +219,8 @@ void wDefaultFillAttributes(const char *instance, const char *class,
 	dn = get_value_from_instanceclass(instance);
 	dc = get_value_from_instanceclass(class);
 
+	WMPLSetCaseSensitive(True);
+
 	if ((w_global.domain.window_attr->dictionary) && (useGlobalDefault))
 		da = WMGetFromPLDictionary(w_global.domain.window_attr->dictionary, AnyWindow);
 
@@ -312,13 +311,8 @@ void wDefaultFillAttributes(const char *instance, const char *class,
 	APPLY_VAL(value, no_language_button, ANoLanguageButton);
 #endif
 
-        /*
-         * Rust rewrite note: this API surface has been removed, but we leave in
-         * a record of where it was invoked to set a value other than the
-         * default, in case it helps to track down bugs in the future.
-         */
 	/* clean up */
-	/* WMPLSetCaseSensitive(False); */
+	WMPLSetCaseSensitive(False);
 }
 
 static WMPropList *get_generic_value(const char *instance, const char *class,
@@ -328,6 +322,8 @@ static WMPropList *get_generic_value(const char *instance, const char *class,
 
 	value = NULL;
 
+	WMPLSetCaseSensitive(True);
+
 	/* Search the icon name using class and instance */
 	if (class && instance) {
 		char *buffer;
@@ -375,12 +371,7 @@ static WMPropList *get_generic_value(const char *instance, const char *class,
 			value = WMGetFromPLDictionary(dict, option);
 	}
 
-        /*
-         * Rust rewrite note: this API surface has been removed, but we leave in
-         * a record of where it was invoked to set a value other than the
-         * default, in case it helps to track down bugs in the future.
-         */
-	/* WMPLSetCaseSensitive(False); */
+	WMPLSetCaseSensitive(False);
 
 	return value;
 }
@@ -554,13 +545,15 @@ void wDefaultChangeIcon(const char *instance, const char *class, const char *fil
 	int same = 0;
 
 	if (!dict) {
-		dict = WMCreateEmptyPLDictionary();
+		dict = WMCreatePLDictionary(NULL, NULL);
 		if (dict)
 			db->dictionary = dict;
 		else
 			return;
 	}
 
+	WMPLSetCaseSensitive(True);
+
 	if (instance && class) {
 		char *buffer;
 
@@ -577,7 +570,7 @@ void wDefaultChangeIcon(const char *instance, const char *class, const char *fil
 
 	if (file) {
 		value = WMCreatePLString(file);
-		icon_value = WMCreatePLDictionary(AIcon, value);
+		icon_value = WMCreatePLDictionary(AIcon, value, NULL);
 		WMReleasePropList(value);
 
 		def_win = WMGetFromPLDictionary(dict, AnyWindow);
@@ -607,12 +600,7 @@ void wDefaultChangeIcon(const char *instance, const char *class, const char *fil
 	if (icon_value)
 		WMReleasePropList(icon_value);
 
-        /*
-         * Rust rewrite note: this API surface has been removed, but we leave in
-         * a record of where it was invoked to set a value other than the
-         * default, in case it helps to track down bugs in the future.
-         */
-	/* WMPLSetCaseSensitive(False); */
+	WMPLSetCaseSensitive(False);
 }
 
 void wDefaultPurgeInfo(const char *instance, const char *class)
@@ -624,6 +612,8 @@ void wDefaultPurgeInfo(const char *instance, const char *class)
 		init_wdefaults();
 	}
 
+	WMPLSetCaseSensitive(True);
+
 	buffer = wmalloc(strlen(class) + strlen(instance) + 2);
 	sprintf(buffer, "%s.%s", instance, class);
 	key = WMCreatePLString(buffer);
@@ -641,12 +631,7 @@ void wDefaultPurgeInfo(const char *instance, const char *class)
 
 	wfree(buffer);
 	WMReleasePropList(key);
-        /*
-         * Rust rewrite note: this API surface has been removed, but we leave in
-         * a record of where it was invoked to set a value other than the
-         * default, in case it helps to track down bugs in the future.
-         */
-	/* WMPLSetCaseSensitive(False); */
+	WMPLSetCaseSensitive(False);
 }
 
 /* --------------------------- Local ----------------------- */

src/window.c

@@ -1413,7 +1413,7 @@ WWindow *wManageWindow(WScreen *scr, Window window)
 	/* Update name must come after WApplication stuff is done */
 	wWindowUpdateName(wwin, title);
 	if (title)
-		wfree(title);
+		XFree(title);
 
 	XUngrabServer(dpy);
 

src/winmenu.c

@@ -346,7 +346,7 @@ static void makeShortcutCommand(WMenu * menu, WMenuEntry * entry)
 	}
 
 	if (wwin->flags.selected && scr->selected_windows) {
-		scr->shortcutWindows[index] = WMCreateArrayWithArray(scr->selected_windows);
+		scr->shortcutWindows[index] = WMDuplicateArray(scr->selected_windows);
 		/*WMRemoveFromArray(scr->shortcutWindows[index], wwin);
 		   WMInsertInArray(scr->shortcutWindows[index], 0, wwin); */
 	} else {

src/winspector.c

@@ -597,7 +597,7 @@ static void saveSettings(WMWidget *button, void *client_data)
 
 	dict = db->dictionary;
 	if (!dict) {
-		dict = WMCreateEmptyPLDictionary();
+		dict = WMCreatePLDictionary(NULL, NULL);
 		if (dict) {
 			db->dictionary = dict;
 		} else {
@@ -609,8 +609,10 @@ static void saveSettings(WMWidget *button, void *client_data)
 	if (showIconFor(WMWidgetScreen(button), panel, NULL, NULL, USE_TEXT_FIELD) < 0)
 		return;
 
-	winDic = WMCreateEmptyPLDictionary();
-	appDic = WMCreateEmptyPLDictionary();
+	WMPLSetCaseSensitive(True);
+
+	winDic = WMCreatePLDictionary(NULL, NULL);
+	appDic = WMCreatePLDictionary(NULL, NULL);
 
 	/* Save the icon info */
 	/* The flag "Ignore client suplied icon is not selected" */
@@ -707,13 +709,8 @@ static void saveSettings(WMWidget *button, void *client_data)
 
 	UpdateDomainFile(db);
 
-        /*
-         * Rust rewrite note: this API surface has been removed, but we leave in
-         * a record of where it was invoked to set a value other than the
-         * default, in case it helps to track down bugs in the future.
-         */
 	/* clean up */
-	/* WMPLSetCaseSensitive(False); */
+	WMPLSetCaseSensitive(False);
 }
 
 static void applySettings(WMWidget *button, void *client_data)

src/workspace.c

@@ -852,10 +852,10 @@ void wWorkspaceSaveState(WScreen * scr, WMPropList * old_state)
 	make_keys();
 
 	old_wks_state = WMGetFromPLDictionary(old_state, dWorkspaces);
-	parr = WMCreateEmptyPLArray();
+	parr = WMCreatePLArray(NULL);
 	for (i = 0; i < scr->workspace_count; i++) {
 		pstr = WMCreatePLString(scr->workspaces[i]->name);
-		wks_state = WMCreatePLDictionary(dName, pstr);
+		wks_state = WMCreatePLDictionary(dName, pstr, NULL);
 		WMReleasePropList(pstr);
 		if (!wPreferences.flags.noclip) {
 			pstr = wClipSaveWorkspaceState(scr, i);

start-captive-wmaker.sh

@@ -1,86 +0,0 @@
-#!/bin/sh
-
-set -e
-
-project_base="$(dirname $0)"
-
-export WMAKER_USER_ROOT="$HOME/tmp/GNUstep"
-gs_base="$WMAKER_USER_ROOT"
-gs_defaults="$gs_base/Defaults"
-gs_system_defaults="$project_base"/WindowMaker/Defaults
-wm_base="$gs_base/Library/WindowMaker"
-wm_backgrounds="$wm_base/Backgrounds"
-wm_iconsets="$wm_base/IconSets"
-wm_pixmaps="$wm_base/Pixmaps"
-gs_icons="$gs_base/Library/Icons"
-wm_style="$wm_base/Style"
-wm_styles="$wm_base/Styles"
-wm_themes="$wm_base/Themes"
-WindowMaker="$project_base/src/.libs/wmaker"
-convertfonts="$project_base/util/convertfonts"
-
-make_dir_if_needed ()
-{
-    if [ ! -d "$1" ] ; then
-        install -m 0755 -d "$1"
-    fi
-}
-
-rename_dir_if_possible ()
-{
-    if [ ! -d "$2" ] ; then
-       if [ -d "$1" ] ; then
-          mv "$1" "$2"
-       fi
-    fi
-}
-
-copy_defaults_if_needed ()
-{
-    file="$gs_defaults/$1"
-    system_file="$gs_system_defaults/$1"
-    if [ ! -f "$file" ] ; then
-        install -m 0644 "$system_file" "$file"
-    fi
-}
-
-make_dir_if_needed     "$gs_defaults"
-make_dir_if_needed     "$wm_base"
-make_dir_if_needed     "$wm_backgrounds"
-make_dir_if_needed     "$wm_iconsets"
-make_dir_if_needed     "$wm_pixmaps"
-make_dir_if_needed     "$gs_icons"
-rename_dir_if_possible "$wm_style"        "$wm_styles"
-make_dir_if_needed     "$wm_styles"
-make_dir_if_needed     "$wm_themes"
-
-export LD_LIBRARY_PATH="$project_base/wrlib/.libs:$project_base/WINGs/.libs:$LD_LIBRARY_PATH" 
-
-copy_defaults_if_needed WindowMaker
-copy_defaults_if_needed WMRootMenu
-copy_defaults_if_needed WMState
-#copy_defaults_if_needed WMWindowAttributes
-
-if [ -x $convertfonts -a ! -e "$wm_base/.fonts_converted" ] ; then
-# --keep-xlfd is used in order to preserve the original information
-    $convertfonts --keep-xlfd "$gs_defaults/WindowMaker"
-    if [ -f "$gs_defaults/WMGLOBAL" ] ; then
-        $convertfonts --keep-xlfd "$gs_defaults/WMGLOBAL"
-    fi
-    find "$wm_styles" -mindepth 1 -maxdepth 1 -type f -print0 |
-    xargs -0 -r -n 1 $convertfonts --keep-xlfd
-    touch "$wm_base/.fonts_converted"
-fi
-
-if [ -n "$1" -a -x "$WindowMaker$1" ] ; then
-    WindowMaker="$WindowMaker$1"
-    shift
-fi
-
-Xephyr -screen 1080x760 :1 &
-xephyr_pid=$!
-DISPLAY=:1 gdb \
-           --directory "$project_base" \
-           --quiet \
-           --args "$WindowMaker" -display :1 --for-real "$@"
-kill $xephyr_pid

util/Makefile.am

@@ -18,50 +18,31 @@ AM_CPPFLAGS = \
 
 liblist= @LIBRARY_SEARCH_PATH@ @INTLIBS@
 
-wdwrite_LDADD = \
-	$(top_builddir)/WINGs/libWUtil.la \
-	$(top_builddir)/wutil-rs/target/debug/libwutil_rs.a \
-	$(liblist)
+wdwrite_LDADD = $(top_builddir)/WINGs/libWUtil.la $(liblist)
 
-wdread_LDADD = \
-	$(top_builddir)/WINGs/libWUtil.la \
-	$(top_builddir)/wutil-rs/target/debug/libwutil_rs.a \
-	$(liblist)
+wdread_LDADD = $(top_builddir)/WINGs/libWUtil.la $(liblist)
 
 wxcopy_LDADD = @XLFLAGS@ @XLIBS@
 
 wxpaste_LDADD = @XLFLAGS@ @XLIBS@
 
-getstyle_LDADD = \
-	$(top_builddir)/WINGs/libWUtil.la \
-	 $(top_builddir)/wutil-rs/target/debug/libwutil_rs.a \
-	$(liblist)
+getstyle_LDADD = $(top_builddir)/WINGs/libWUtil.la $(liblist)
 
 getstyle_SOURCES = getstyle.c fontconv.c common.h
 
 setstyle_LDADD = \
 	$(top_builddir)/WINGs/libWUtil.la \
-	 $(top_builddir)/wutil-rs/target/debug/libwutil_rs.a \
 	@XLFLAGS@ @XLIBS@ $(liblist)
 
 setstyle_SOURCES = setstyle.c fontconv.c common.h
 
-convertfonts_LDADD = \
-	$(top_builddir)/WINGs/libWUtil.la \
-	$(top_builddir)/wutil-rs/target/debug/libwutil_rs.a \
-	$(liblist)
+convertfonts_LDADD = $(top_builddir)/WINGs/libWUtil.la $(liblist)
 
 convertfonts_SOURCES = convertfonts.c fontconv.c common.h
 
-seticons_LDADD= \
-	$(top_builddir)/WINGs/libWUtil.la \
-	 $(top_builddir)/wutil-rs/target/debug/libwutil_rs.a \
-	$(liblist)
+seticons_LDADD= $(top_builddir)/WINGs/libWUtil.la $(liblist)
 
-geticonset_LDADD= \
-	$(top_builddir)/WINGs/libWUtil.la \
-	 $(top_builddir)/wutil-rs/target/debug/libwutil_rs.a \
-	$(liblist)
+geticonset_LDADD= $(top_builddir)/WINGs/libWUtil.la $(liblist)
 
 wmagnify_LDADD = \
 	$(top_builddir)/WINGs/libWINGs.la \
@@ -71,21 +52,18 @@ wmagnify_LDADD = \
 
 wmsetbg_LDADD = \
 	$(top_builddir)/WINGs/libWINGs.la \
-	$(top_builddir)/wutil-rs/target/debug/libwutil_rs.a \
 	$(top_builddir)/WINGs/libWUtil.la \
 	$(top_builddir)/wrlib/libwraster.la \
 	@XLFLAGS@ @LIBXINERAMA@ @XLIBS@ @INTLIBS@
 
 wmgenmenu_LDADD = \
 	$(top_builddir)/WINGs/libWUtil.la \
-	$(top_builddir)/wutil-rs/target/debug/libwutil_rs.a \
 	@INTLIBS@
 
 wmgenmenu_SOURCES = wmgenmenu.c wmgenmenu.h
 
 wmmenugen_LDADD = \
 	$(top_builddir)/WINGs/libWUtil.la \
-	$(top_builddir)/wutil-rs/target/debug/libwutil_rs.a \
 	@INTLIBS@
 
 wmmenugen_SOURCES = wmmenugen.c wmmenugen.h wmmenugen_misc.c \
@@ -97,7 +75,6 @@ wmiv_CFLAGS = @PANGO_CFLAGS@ @PTHREAD_CFLAGS@
 wmiv_LDADD = \
 	$(top_builddir)/wrlib/libwraster.la \
 	$(top_builddir)/WINGs/libWINGs.la \
-	$(top_builddir)/wutil-rs/target/debug/libwutil_rs.a \
 	@XLFLAGS@ @XLIBS@ @GFXLIBS@ \
 	@PANGO_LIBS@ @PTHREAD_LIBS@ @LIBEXIF@
 

util/convertfonts.c

@@ -131,12 +131,7 @@ int main(int argc, char **argv)
 	/* this contradicts big time with getstyle */
 	setlocale(LC_ALL, "");
 
-        /*
-         * Rust rewrite note: this API surface has been removed, but we leave in
-         * a record of where it was invoked to set a value other than the
-         * default, in case it helps to track down bugs in the future.
-         */
-	/* WMPLSetCaseSensitive(False); */
+	WMPLSetCaseSensitive(False);
 
 	style = WMReadPropListFromFile(file);
 	if (!style) {

util/geticonset.c

@@ -109,7 +109,7 @@ int main(int argc, char **argv)
 		if (window_attrs && WMIsPLDictionary(window_attrs)) {
 			icon_value = WMGetFromPLDictionary(window_attrs, icon_key);
 			if (icon_value) {
-				icondic = WMCreatePLDictionary(icon_key, icon_value);
+				icondic = WMCreatePLDictionary(icon_key, icon_value, NULL);
 				WMPutInPLDictionary(iconset, window_name, icondic);
 			}
 		}

util/getstyle.c

@@ -337,12 +337,7 @@ int main(int argc, char **argv)
 		return 1;
 	}
 
-        /*
-         * Rust rewrite note: this API surface has been removed, but we leave in
-         * a record of where it was invoked to set a value other than the
-         * default, in case it helps to track down bugs in the future.
-         */
-	/* WMPLSetCaseSensitive(False); */
+	WMPLSetCaseSensitive(False);
 
 	path = wdefaultspathfordomain("WindowMaker");
 
@@ -362,7 +357,7 @@ int main(int argc, char **argv)
 		prop = val;
 	}
 
-	style = WMCreateEmptyPLDictionary();
+	style = WMCreatePLDictionary(NULL, NULL);
 
 	for (i = 0; options[i] != NULL; i++) {
 		key = WMCreatePLString(options[i]);

util/setstyle.c

@@ -427,12 +427,7 @@ int main(int argc, char **argv)
 
 	file = argv[0];
 
-        /*
-         * Rust rewrite note: this API surface has been removed, but we leave in
-         * a record of where it was invoked to set a value other than the
-         * default, in case it helps to track down bugs in the future.
-         */
-	/* WMPLSetCaseSensitive(False); */
+	WMPLSetCaseSensitive(False);
 
 	path = wdefaultspathfordomain("WindowMaker");
 
@@ -470,7 +465,7 @@ int main(int argc, char **argv)
 		}
 
 		buf[strlen(buf) - 6 /* strlen("/style") */] = '\0';
-		homedir = wgethomedir();
+		homedir = wstrdup(wgethomedir());
 		if (strlen(homedir) > 1	&&	/* this is insane, wgethomedir() returns `/' on error */
 		    strncmp(homedir, buf, strlen(homedir)) == 0) {
 			/* theme pack is under ${HOME}; exchange ${HOME} part

util/wdwrite.c

@@ -103,7 +103,7 @@ int main(int argc, char **argv)
 
 	dict = WMReadPropListFromFile(path);
 	if (!dict) {
-		dict = WMCreatePLDictionary(key, value);
+		dict = WMCreatePLDictionary(key, value, NULL);
 	} else {
 		WMPutInPLDictionary(dict, key, value);
 	}

util/wmsetbg.c

@@ -1199,14 +1199,14 @@ static void changeTextureForWorkspace(const char *domain, char *texture, int wor
 	array = getValueForKey("WindowMaker", "WorkspaceSpecificBack");
 
 	if (!array) {
-		array = WMCreateEmptyPLArray();
+		array = WMCreatePLArray(NULL, NULL);
 	}
 
 	j = WMGetPropListItemCount(array);
 	if (workspace >= j) {
 		WMPropList *empty;
 
-		empty = WMCreateEmptyPLArray();
+		empty = WMCreatePLArray(NULL, NULL);
 
 		while (j++ < workspace - 1) {
 			WMAddToPLArray(array, empty);

wmaker-rs/Makefile.am

@@ -1,33 +0,0 @@
-# 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

wmaker-rs/src/app_icon.rs

@@ -1,25 +0,0 @@
-use std::ffi::c_void;
-
-pub type AppIcon = c_void;
-
-pub mod ffi {
-    use super::AppIcon;
-    use std::ffi::c_int;
-
-    unsafe extern "C" {
-        pub fn wAppIconIsDocked(app_icon: *mut AppIcon) -> c_int;
-
-        pub fn wAppIconIsRelaunching(app_icon: *mut AppIcon) -> c_int;
-
-        pub fn wAppIconGetIcon(app_icon: *mut AppIcon) -> *mut crate::icon::Icon;
-
-        pub fn wAppIconPaint(app_icon: *mut AppIcon);
-
-        pub fn create_appicon_for_application(
-            app: *mut crate::application::Application,
-            wwin: *mut crate::window::Window,
-        );
-
-        pub fn removeAppIconFor(app: *mut crate::application::Application);
-    }
-}

wmakerlib/Cargo.toml

@@ -1,5 +1,5 @@
 [package]
-name = "wmaker-rs"
+name = "wmakerlib"
 version = "0.1.0"
 edition = "2024"
 
@@ -7,4 +7,5 @@ edition = "2024"
 crate-type = ["staticlib"]
 
 [dependencies]
+libc = "0.2"
 x11 = "2.21.0"

wmakerlib/src/app_icon.rs

@@ -0,0 +1,59 @@
+use std::ffi::{c_char, c_int, c_short};
+
+#[repr(C)]
+pub struct AppIcon {
+    xindex: c_short,
+    yindex: c_short,
+    next: *mut AppIcon,
+    prev: *mut AppIcon,
+    icon: *mut crate::icon::Icon,
+    x_pos: c_int,
+    y_pos: c_int,
+    command: *mut c_char,
+    dnd_command: *mut c_char,
+    paste_command: *mut c_char,
+    wm_class: *mut c_char,
+    wm_instance: *mut c_char,
+    pid: libc::pid_t,
+    main_window: x11::xlib::Window,
+    dock: *mut crate::dock::Dock,
+    panel: *mut crate::app_settings_panel::AppSettingsPanel,
+    docked: c_int,
+    omnipresent: c_int,
+    attracted: c_int,
+    launched: c_int,
+    running: c_int,
+    relaunching: c_int,
+    forced_dock: c_int,
+    auto_launch: c_int,
+    remote_start: c_int,
+    updated: c_int,
+    editing: c_int,
+    drop_launch: c_int,
+    paste_launch: c_int,
+    destroyed: c_int,
+    buggy_app: c_int,
+    lock: c_int,
+}
+
+pub mod ffi {
+    use super::AppIcon;
+    use std::ffi::c_int;
+
+    unsafe extern "C" {
+        pub fn wAppIconIsDocked(app_icon: *mut AppIcon) -> c_int;
+
+        pub fn wAppIconIsRelaunching(app_icon: *mut AppIcon) -> c_int;
+
+        pub fn wAppIconGetIcon(app_icon: *mut AppIcon) -> *mut crate::icon::Icon;
+
+        pub fn wAppIconPaint(app_icon: *mut AppIcon);
+
+        pub fn create_appicon_for_application(
+            app: *mut crate::application::Application,
+            wwin: *mut crate::window::Window,
+        );
+
+        pub fn removeAppIconFor(app: *mut crate::application::Application);
+    }
+}

wmakerlib/src/app_settings_panel.rs

@@ -0,0 +1,3 @@
+use std::ffi::c_void;
+
+pub type AppSettingsPanel = c_void;

wmakerlib/src/dock.rs

@@ -1,3 +1,7 @@
+use std::ffi::c_void;
+
+pub type Dock = c_void;
+
 pub mod ffi {
     unsafe extern "C" {
         pub fn wDockFinishLaunch(app_icon: *mut crate::app_icon::AppIcon);

wmakerlib/src/lib.rs

@@ -1,6 +1,7 @@
 pub mod application;
 pub mod app_icon;
 pub mod app_menu;
+pub mod app_settings_panel;
 pub mod defaults;
 pub mod dock;
 pub mod global;

wrlib/tests/testgrad.c

@@ -38,7 +38,7 @@ int main(int argc, char **argv)
 	else
 		ProgName++;
 
-	color_name = (char **)wmalloc(sizeof(char *) * argc);
+	color_name = (char **)malloc(sizeof(char *) * argc);
 	if (color_name == NULL) {
 		fprintf(stderr, "Cannot allocate memory!\n");
 		exit(1);
@@ -106,13 +106,13 @@ int main(int argc, char **argv)
 		exit(1);
 	}
 
-	colors = wmalloc(sizeof(RColor *) * (ncolors + 1));
+	colors = malloc(sizeof(RColor *) * (ncolors + 1));
 	for (i = 0; i < ncolors; i++) {
 		if (!XParseColor(dpy, ctx->cmap, color_name[i], &color)) {
 			printf("could not parse color \"%s\"\n", color_name[i]);
 			exit(1);
 		} else {
-			colors[i] = wmalloc(sizeof(RColor));
+			colors[i] = malloc(sizeof(RColor));
 			colors[i]->red = color.red >> 8;
 			colors[i]->green = color.green >> 8;
 			colors[i]->blue = color.blue >> 8;

wutil-rs/Cargo.toml

@@ -1,18 +0,0 @@
-[package]
-name = "wutil-rs"
-version = "0.1.0"
-edition = "2024"
-
-[lib]
-crate-type = ["staticlib"]
-
-[build-dependencies]
-cc = "1.0"
-
-[dependencies]
-atomic-write-file = "0.3"
-hashbrown = "0.16.0"
-libc = "0.2.175"
-nom = "8.0"
-nom-language = "0.1"
-x11 = "2.21.0"

wutil-rs/Makefile.am

@@ -1,27 +0,0 @@
-AUTOMAKE_OPTIONS =
-
-RUST_SOURCES = \
-	src/array.rs \
-	src/data.rs \
-	src/defines.c \
-	src/defines.rs \
-	src/find_file.rs \
-	src/hash_table.rs \
-	src/lib.rs \
-	src/memory.rs \
-	src/prop_list.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/build.rs

@@ -1,8 +0,0 @@
-use cc;
-
-fn main() {
-    cc::Build::new()
-        .file("src/defines.c")
-        .compile("defines");
-    println!("cargo::rerun-if-changed=src/defines.c");
-}

wutil-rs/src/array.rs

@@ -1,449 +0,0 @@
-use std::{ffi::c_void, ptr::NonNull};
-
-pub struct Array {
-    items: Vec<NonNull<c_void>>,
-    destructor: Option<unsafe extern "C" fn(x: *mut c_void)>,
-}
-
-pub mod ffi {
-    use super::Array;
-
-    use std::{
-        ffi::{c_int, c_void},
-        ptr::{self, NonNull},
-    };
-
-    pub const NOT_FOUND: c_int = -1;
-
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn WMCreateArray(initial_size: c_int) -> *mut Array {
-        let cap = if initial_size < 0 {
-            0
-        } else {
-            initial_size as usize
-        };
-        Box::leak(Box::new(Array {
-            items: Vec::with_capacity(cap),
-            destructor: None,
-        }))
-    }
-
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn WMCreateArrayWithDestructor(
-        initial_size: c_int,
-        destructor: unsafe extern "C" fn(x: *mut c_void),
-    ) -> *mut Array {
-        let cap = if initial_size < 0 {
-            0
-        } else {
-            initial_size as usize
-        };
-        Box::leak(Box::new(Array {
-            items: Vec::with_capacity(cap),
-            destructor: Some(destructor),
-        }))
-    }
-
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn WMCreateArrayWithArray(array: *mut Array) -> *mut Array {
-        if array.is_null() {
-            return ptr::null_mut();
-        }
-        let array = unsafe { &*array };
-        Box::leak(Box::new(Array {
-            items: array.items.clone(),
-            destructor: array.destructor,
-        }))
-    }
-
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn WMEmptyArray(array: *mut Array) {
-        if array.is_null() {
-            return;
-        }
-        let array = unsafe { &mut *array };
-        if let Some(f) = array.destructor {
-            for item in &mut array.items {
-                unsafe { (f)(item.as_ptr()) }
-            }
-        }
-        array.items.clear();
-    }
-
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn WMFreeArray(array: *mut Array) {
-        if array.is_null() {
-            return;
-        }
-        unsafe {
-            WMEmptyArray(array);
-            let _ = ptr::read(array);
-        }
-    }
-
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn WMGetArrayItemCount(array: *mut Array) -> c_int {
-        if array.is_null() {
-            return 0;
-        }
-        unsafe { (*array).items.len() as c_int }
-    }
-
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn WMAddToArray(array: *mut Array, item: *mut c_void) {
-        if array.is_null() {
-            return;
-        }
-        if let Some(item) = NonNull::new(item) {
-            unsafe {
-                (*array).items.push(item);
-            }
-        }
-    }
-
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn WMInsertInArray(array: *mut Array, index: c_int, item: *mut c_void) {
-        if array.is_null() {
-            return;
-        }
-        if index < 0 {
-            return;
-        }
-        let array = unsafe { &mut (*array).items };
-        let index = index as usize;
-        if index >= array.len() {
-            return;
-        }
-        if let Some(item) = NonNull::new(item) {
-            array.insert(index, item);
-        }
-    }
-
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn WMSetInArray(
-        array: *mut Array,
-        index: c_int,
-        item: *mut c_void,
-    ) -> *mut c_void {
-        if array.is_null() {
-            return ptr::null_mut();
-        }
-        if index < 0 {
-            return ptr::null_mut();
-        }
-        let index = index as usize;
-
-        /* is it really useful to perform append if index == array->itemCount ? -Dan */
-        if index == unsafe { (*array).items.len() } {
-            unsafe {
-                WMAddToArray(array, item);
-            }
-            return ptr::null_mut();
-        }
-
-        let item = match NonNull::new(item) {
-            Some(x) => x,
-            None => return ptr::null_mut(),
-        };
-        let array = unsafe { &mut (*array).items };
-
-        let old = array[index];
-        array[index] = item;
-        old.as_ptr()
-    }
-
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn WMDeleteFromArray(array: *mut Array, index: c_int) -> c_int {
-        if array.is_null() {
-            return 0;
-        }
-        let array = unsafe { &mut *array };
-        if index < 0 {
-            return 0;
-        }
-        let index = index as usize;
-        if index >= array.items.len() {
-            0
-        } else {
-            let old = array.items.remove(index);
-            if let Some(f) = array.destructor {
-                unsafe {
-                    (f)(old.as_ptr());
-                }
-            }
-            1
-        }
-    }
-
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn WMRemoveFromArray(array: *mut Array, item: *mut c_void) -> c_int {
-        unsafe { WMRemoveFromArrayMatching(array, None, item) }
-    }
-
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn WMRemoveFromArrayMatching(
-        array: *mut Array,
-        pred: Option<unsafe extern "C" fn(item: *const c_void, cdata: *mut c_void) -> c_int>,
-        cdata: *mut c_void,
-    ) -> c_int {
-        if array.is_null() {
-            return 1;
-        }
-        let array = unsafe { &mut *array };
-        let original_len = array.items.len();
-        match pred {
-            Some(f) => array.items.retain(|x| unsafe { f(x.as_ptr(), cdata) != 0 }),
-            None => array.items.retain(|x| ptr::eq(x.as_ptr(), cdata)),
-        }
-        (original_len - array.items.len()) as c_int
-    }
-
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn WMGetFromArray(array: *mut Array, index: c_int) -> *mut c_void {
-        if array.is_null() || index < 0 {
-            return ptr::null_mut();
-        }
-        unsafe {
-            (*array)
-                .items
-                .get(index as usize)
-                .map(|p| p.as_ptr())
-                .unwrap_or(ptr::null_mut())
-        }
-    }
-
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn WMGetFirstInArray(array: *mut Array, item: *mut c_void) -> c_int {
-        unsafe { WMFindInArray(array, None, item) }
-    }
-
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn WMPopFromArray(array: *mut Array) -> *mut c_void {
-        if array.is_null() {
-            return ptr::null_mut();
-        }
-        unsafe {
-            (*array)
-                .items
-                .pop()
-                .map(|p| p.as_ptr())
-                .unwrap_or(ptr::null_mut())
-        }
-    }
-
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn WMFindInArray(
-        array: *mut Array,
-        pred: Option<unsafe extern "C" fn(item: *const c_void, cdata: *mut c_void) -> c_int>,
-        cdata: *mut c_void,
-    ) -> c_int {
-        if array.is_null() {
-            return NOT_FOUND;
-        }
-        let array = unsafe { &*array };
-        if let Some(f) = pred {
-            array
-                .items
-                .iter()
-                .enumerate()
-                .find(|(_, item)| unsafe { f(item.as_ptr(), cdata) != 0 })
-                .map(|(i, _)| i as c_int)
-                .unwrap_or(NOT_FOUND)
-        } else {
-            array
-                .items
-                .iter()
-                .enumerate()
-                .find(|(_, item)| ptr::eq(item.as_ptr(), cdata))
-                .map(|(i, _)| i as c_int)
-                .unwrap_or(NOT_FOUND)
-        }
-    }
-
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn WMCountInArray(array: *mut Array, item: *const c_void) -> c_int {
-        if array.is_null() {
-            return 0;
-        }
-        let array = unsafe { &*array };
-        array
-            .items
-            .iter()
-            .filter(|x| ptr::eq(x.as_ptr(), item))
-            .count() as c_int
-    }
-
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn WMSortArray(
-        array: *mut Array,
-        comparator: unsafe extern "C" fn(a: *const c_void, b: *const c_void) -> c_int,
-    ) {
-        if array.is_null() {
-            return;
-        }
-        unsafe {
-            (*array)
-                .items
-                .sort_by(|&a, &b| match comparator(a.as_ptr(), b.as_ptr()).signum() {
-                    -1 => std::cmp::Ordering::Less,
-                    0 => std::cmp::Ordering::Equal,
-                    1 => std::cmp::Ordering::Greater,
-                    _ => unreachable!(),
-                })
-        }
-    }
-
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn WMMapArray(
-        array: *mut Array,
-        f: unsafe extern "C" fn(*mut c_void, *mut c_void),
-        data: *mut c_void,
-    ) {
-        if array.is_null() {
-            return;
-        }
-        unsafe {
-            for a in &mut (*array).items {
-                (f)(a.as_ptr(), data);
-            }
-        }
-    }
-
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn WMArrayFirst(array: *mut Array, iter: *mut c_int) -> *mut c_void {
-        if array.is_null() || iter.is_null() {
-            return ptr::null_mut();
-        }
-        let array = unsafe { &*array };
-        match array.items.get(0) {
-            None => {
-                unsafe {
-                    *iter = NOT_FOUND;
-                }
-                ptr::null_mut()
-            }
-            Some(x) => {
-                unsafe {
-                    *iter = 0;
-                }
-                x.as_ptr()
-            }
-        }
-    }
-
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn WMArrayLast(array: *mut Array, iter: *mut c_int) -> *mut c_void {
-        if array.is_null() || iter.is_null() {
-            return ptr::null_mut();
-        }
-        let array = unsafe { &*array };
-        match array.items.last() {
-            None => {
-                unsafe {
-                    *iter = NOT_FOUND;
-                }
-                ptr::null_mut()
-            }
-            Some(x) => {
-                unsafe {
-                    *iter = (array.items.len() - 1) as c_int;
-                }
-                x.as_ptr()
-            }
-        }
-    }
-
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn WMArrayNext(array: *mut Array, iter: *mut c_int) -> *mut c_void {
-        if array.is_null() || iter.is_null() {
-            return ptr::null_mut();
-        }
-        let array = unsafe { &*array };
-        let index = unsafe { *iter };
-        if index < 0 {
-            return ptr::null_mut();
-        }
-        match array.items.get(index as usize) {
-            Some(i) => {
-                unsafe {
-                    *iter += 1;
-                }
-                i.as_ptr()
-            }
-            None => {
-                unsafe {
-                    *iter = NOT_FOUND;
-                }
-                ptr::null_mut()
-            }
-        }
-    }
-
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn WMArrayPrevious(array: *mut Array, iter: *mut c_int) -> *mut c_void {
-        if array.is_null() || iter.is_null() {
-            return ptr::null_mut();
-        }
-        let array = unsafe { &*array };
-        let index = unsafe { *iter };
-        if index < 0 {
-            return ptr::null_mut();
-        }
-        match array.items.get(index as usize) {
-            Some(i) => {
-                unsafe {
-                    *iter -= 1;
-                }
-                i.as_ptr()
-            }
-            None => {
-                unsafe {
-                    *iter = NOT_FOUND;
-                }
-                ptr::null_mut()
-            }
-        }
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use std::{ffi::c_void, ptr};
-
-    use super::ffi::*;
-
-    #[test]
-    fn create_destroy_with_size() {
-        unsafe {
-            let array = WMCreateArray(10);
-            assert_eq!((*array).items.len(), 0);
-            assert!((*array).items.capacity() >= 10);
-            WMFreeArray(array);
-        }
-    }
-
-    #[test]
-    fn create_push_clear_destroy() {
-        static mut SENTINEL: *mut c_void = ptr::null_mut();
-        unsafe extern "C" fn destructor(item: *mut c_void) {
-            unsafe {
-                SENTINEL = item;
-            }
-        }
-        unsafe {
-            let array = WMCreateArrayWithDestructor(10, destructor);
-            assert!(SENTINEL.is_null());
-
-            let mut x = 0xdeadbeefu32;
-            WMAddToArray(array, (&mut x as *mut u32).cast::<c_void>());
-            assert_eq!(WMGetArrayItemCount(array), 1);
-            WMEmptyArray(array);
-            assert!(ptr::eq(SENTINEL, (&x as *const u32).cast::<c_void>()));
-            assert_eq!(0xdeadbeefu32, *SENTINEL.cast::<u32>());
-
-            SENTINEL = ptr::null_mut();
-            WMFreeArray(array);
-            assert!(SENTINEL.is_null());
-        }
-    }
-}

wutil-rs/src/data.rs

@@ -1,209 +0,0 @@
-//! Self-owning shared data segment.
-
-use std::{cell::RefCell, rc::Rc};
-
-#[derive(Clone, Copy, Debug)]
-pub enum Format {
-    Z = 0,
-    E = 8,
-    S = 16,
-    T = 32,
-}
-
-/// Reference-counted, self-owned, dynamically sized chunk of bytes.
-///
-/// In the original WINGs, this type either owned or borrowed a data buffer and
-/// had some associated metadata. In Rust, this is little more than a thin
-/// wrapper around an `Rc<RefCell<Vec<u8>>>`. It is mostly used by proplists,
-/// and it should be done away with once its dependents have been ported to
-/// Rust.
-pub struct Data(Rc<RefCell<Inner>>);
-
-impl Data {
-    /// Runs `f` on a borrow of `self`'s data, returning whatever `f` does.
-    ///
-    /// This is provided because the internal structure of `Data` does not make
-    /// it easy to borrow its contents directly. As we migrate away from the
-    /// original C interfaces to WINGs data structures, we may be able to
-    /// provide a direct borrow, which would make this method obsolete. (That
-    /// would be a good thing.)
-    pub fn with_bytes<R>(&self, f: impl FnOnce(&[u8]) -> R) -> R {
-        f(&self.0.borrow().bytes)
-    }
-}
-
-struct Inner {
-    bytes: Vec<u8>,
-    format: Format,
-}
-
-pub mod ffi {
-    use super::{Data, Format, Inner};
-
-    use std::{
-        cell::RefCell,
-        ffi::{c_int, c_uint, c_void},
-        ptr,
-        rc::Rc,
-    };
-
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn WMCreateDataWithCapacity(capacity: c_uint) -> *mut Data {
-        Box::leak(Box::new(Data(Rc::new(RefCell::new(Inner {
-            bytes: Vec::with_capacity(capacity as usize),
-            format: Format::Z,
-        })))))
-    }
-
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn WMCreateDataWithLength(length: c_uint) -> *mut Data {
-        Box::leak(Box::new(Data(Rc::new(RefCell::new(Inner {
-            bytes: vec![0; length as usize],
-            format: Format::Z,
-        })))))
-    }
-
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn WMCreateDataWithBytes(
-        bytes: *const c_void,
-        length: c_uint,
-    ) -> *mut Data {
-        let bytes = unsafe { &*ptr::slice_from_raw_parts(bytes.cast::<u8>(), length as usize) };
-        let bytes = Vec::from(bytes);
-        Box::leak(Box::new(Data(Rc::new(RefCell::new(Inner {
-            bytes,
-            format: Format::Z,
-        })))))
-    }
-
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn WMCreateDataWithData(data: *mut Data) -> *mut Data {
-        if data.is_null() {
-            return ptr::null_mut();
-        }
-        let data = unsafe { &*data };
-        Box::leak(Box::new(Data(Rc::new(RefCell::new(Inner {
-            bytes: data.0.borrow().bytes.clone(),
-            format: data.0.borrow().format,
-        })))))
-    }
-
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn WMRetainData(data: *mut Data) -> *mut Data {
-        if data.is_null() {
-            return ptr::null_mut();
-        }
-        let data = unsafe { &*data };
-        Box::leak(Box::new(Data(data.0.clone())))
-    }
-
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn WMReleaseData(data: *mut Data) {
-        if data.is_null() {
-            return;
-        }
-        let _ = unsafe { ptr::read(data) };
-    }
-
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn WMDataBytes(data: *mut Data) -> *const c_void {
-        if data.is_null() {
-            return ptr::null();
-        }
-
-        unsafe { (*data).0.borrow().bytes.as_ptr().cast::<c_void>() }
-    }
-
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn WMIsDataEqualToData(a: *mut Data, b: *mut Data) -> c_int {
-        if a.is_null() || b.is_null() {
-            return 0;
-        }
-        if ptr::eq(a, b) {
-            return 1;
-        }
-        let a = unsafe { &*a };
-        let b = unsafe { &*b };
-        (a.0.borrow().bytes == b.0.borrow().bytes) as c_int
-    }
-
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn WMGetDataLength(data: *mut Data) -> c_uint {
-        if data.is_null() {
-            return 0;
-        }
-        unsafe { (*data).0.borrow().bytes.len() as c_uint }
-    }
-
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn WMAppendDataBytes(
-        data: *mut Data,
-        bytes: *const c_void,
-        length: c_uint,
-    ) {
-        if data.is_null() || bytes.is_null() || length == 0 {
-            return;
-        }
-        let data = unsafe { &mut *data };
-        let bytes = unsafe { &*ptr::slice_from_raw_parts(bytes.cast::<u8>(), length as usize) };
-        data.0.borrow_mut().bytes.extend_from_slice(bytes);
-    }
-
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn WMAppendData(data: *mut Data, ext: *mut Data) {
-        if data.is_null() || ext.is_null() {
-            return;
-        }
-        let data = unsafe { &mut *data };
-        let ext = unsafe { &*ext };
-        data.0
-            .borrow_mut()
-            .bytes
-            .extend_from_slice(&ext.0.borrow().bytes);
-    }
-
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn WMSetData(data: *mut Data, other: *mut Data) {
-        if data.is_null() || other.is_null() {
-            return;
-        }
-        let data = unsafe { &mut *data };
-        let other = unsafe { &*other };
-        data.0
-            .borrow_mut()
-            .bytes
-            .copy_from_slice(&other.0.borrow().bytes);
-    }
-
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn WMGetDataFormat(data: *mut Data) -> c_uint {
-        if data.is_null() {
-            return 0;
-        }
-        return unsafe {
-            match (*data).0.borrow().format {
-                Format::Z => 0,
-                Format::E => 8,
-                Format::S => 16,
-                Format::T => 32,
-            }
-        };
-    }
-
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn WMSetDataFormat(data: *mut Data, format: c_uint) {
-        if data.is_null() {
-            return;
-        }
-        let format = match format {
-            0 => Format::Z,
-            8 => Format::E,
-            16 => Format::S,
-            32 => Format::T,
-            _ => return,
-        };
-        unsafe {
-            (*data).0.borrow_mut().format = format;
-        }
-    }
-}

wutil-rs/src/defines.c

@@ -1,5 +0,0 @@
-#include "../../config-paths.h"
-
-const char *get_GSUSER_SUBDIR() {
-  return GSUSER_SUBDIR;
-}

wutil-rs/src/defines.rs

@@ -1,45 +0,0 @@
-//! Lookup functions for preprocessor symbols.
-//!
-//! Functions in this module may be called to get the value of various
-//! preprocessor symbols that are available on the C side of things.
-//!
-//! ## Rust rewrite notes
-//!
-//! Until we move away from autootols entirely, we might be stuck with this as
-//! along as it makes sense to keep the configure script as the main entrypoint
-//! for compile-time configuration.
-
-use std::ffi::{c_char, CStr};
-
-// Functions defined in src/defines.c.
-unsafe extern "C" {
-    fn get_GSUSER_SUBDIR() -> *const c_char;
-}
-
-/// Returns the value of the GSUSER_SUBDIR preprocessor symbol defined at
-/// Autotools configuration time prior to compilation. This is the final
-/// component of the root path where user data files are stored (usually
-/// `GNUstep`, as in `$HOME/GNUstep`). Returns `None` if this value cannot be
-/// determined or is empty.
-pub fn gsuser_subdir() -> Option<String> {
-    let s = unsafe { get_GSUSER_SUBDIR() };
-    if s.is_null() {
-        return None;
-    }
-    let s = unsafe { CStr::from_ptr(s) };
-    if s.is_empty() {
-        return None;
-    }
-    String::from_utf8(s.to_bytes().iter().copied().collect()).ok()
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-
-    #[test]
-    fn gsuser_subdir_is_set() {
-        let s = gsuser_subdir().unwrap();
-        assert!(!s.is_empty());
-    }
-}

wutil-rs/src/find_file.rs

@@ -1,395 +0,0 @@
-//! This module provides approximate reimplementations of file-finding routines
-//! from the original WINGs utilities.
-//!
-//! The [`ffi`] submodule provides functions which may be called directly from C
-//! that has not yet been ported to Rust.
-//!
-//! The original utilities expanded environment variables in path names
-//! (expanding `$FOO/bar/baz` to use the value of the environment variable
-//! `FOO`) and respected Unix-style denotations of user home directories
-//! (resolving `~someuser/foo.txt` to `(home directory of
-//! someuser)/foo.txt`. These behaviors have not been preserved. But a path
-//! whose first component is `~` will still be resolved relatively to the
-//! current user's home directory.
-//!
-//! ## Rust rewrite notes
-//!
-//! Many of these utilities are not strictly correct as originally designed: a
-//! file path that appears valid when it is checked in a subroutine may become
-//! invalid if the file is deleted between when the path is checked and when
-//! downstream code attempts to open the file. (This is a TOCTOU issue.) A
-//! better design would open the file and return a live file pointer instead of
-//! simply returning a path that is likely to work. Future work should redesign
-//! this module to avoid this issue.
-
-use crate::defines;
-
-use std::{
-    env,
-    ffi::{CStr, OsStr},
-    fs::File,
-    io,
-    path::{Component, Path, PathBuf},
-};
-
-/// Tries to interpret `s` as a UTF-8 path. Returns `None` if decoding `s`
-/// fails.
-pub fn path_from_cstr(s: &CStr) -> Option<PathBuf> {
-    s.to_str().ok().map(PathBuf::from)
-}
-
-/// If `file` is an absolute path can be opened, returns that path. Paths
-/// starting with `~` are treated as absolute, and the user's home directory is
-/// substituted for `~` (so `~/foo` becomes `(users's home directory)/foo`). If
-/// the user's home directory cannot be determined, `/` is used instead.
-///
-/// Returns `None` otherwise.
-pub fn absolute(file: &Path) -> Option<PathBuf> {
-    if file.is_absolute() {
-        return Some(file.to_path_buf());
-    } else {
-        let mut components = file.components();
-        if components.next() == Some(Component::Normal(OsStr::new("~"))) {
-            let mut path = env::home_dir().unwrap_or_else(|| PathBuf::from("/"));
-            for c in components {
-                path.push(c);
-            }
-            Some(path)
-        } else {
-            None
-        }
-    }
-}
-
-/// Resolves `file` to a path that can be opened relative to an element of
-/// `paths`, or `None` if it cannot be found. If `paths` is empty, an attempt to
-/// resolve `file` relative to the current working directory will be made.
-pub fn in_paths<'a>(paths: impl Iterator<Item = &'a Path>, file: &Path) -> Option<PathBuf> {
-    if file.file_name().map(|f| f.is_empty()).unwrap_or(false) {
-        return None;
-    }
-    let mut paths = paths.peekable();
-
-    if paths.peek().is_none() {
-        if let Ok(_) = File::open(file) {
-            return Some(file.to_path_buf());
-        }
-        return None;
-    }
-
-    let mut buf = PathBuf::new();
-    for parent in paths {
-        buf.clear();
-        buf.push(parent);
-        buf.push(file);
-        if let Ok(_) = File::open(&buf) {
-            return Some(buf);
-        }
-    }
-    None
-}
-
-/// Returns the root path that user data will be stored at. This is probably
-/// `$HOME/GNUstep` (or some other default if a different path was specified for
-/// [`defaults::gsuser_subdir`] at compilation time), unless the environment
-/// variable `WMAKER_USER_ROOT` is defined, in which case it's that.
-pub fn user_gnustep_path() -> Option<PathBuf> {
-    match env::var("WMAKER_USER_ROOT") {
-        Ok(path) => {
-            if let Some(path) = absolute(&PathBuf::from(&path)) {
-                return Some(path);
-            }
-        }
-        Err(env::VarError::NotUnicode(_)) => {
-            // TODO: warn.
-        }
-        Err(env::VarError::NotPresent) => (),
-    }
-
-    match (env::home_dir(), defines::gsuser_subdir()) {
-        (None, _) => {
-            // TODO: warn.
-            None
-        }
-        (Some(mut parent), Some(subdir)) => {
-            parent.push(subdir);
-            Some(parent)
-        }
-        (Some(_), None) => {
-            // TODO: warn.
-            None
-        }
-    }
-}
-
-/// Creates the directory at `p` and all of its parents, respecting the current
-/// umask as much as possible. Only allows creation of paths under
-/// [`user_gnustep_path`].
-pub fn create_path_hierarchy<P: AsRef<Path>>(p: P) -> io::Result<()> {
-    let p = p.as_ref();
-    let Ok(canonical_p) = p.canonicalize() else {
-        return Err(io::Error::other("cannot canonicalize requested path"));
-    };
-    let Some(wmaker_user_root) = user_gnustep_path() else {
-        return Err(io::Error::other("cannot determine WMAKER_USER_ROOT. try setting the environment variable WMAKER_USER_ROOT."));
-    };
-    let Ok(wmaker_user_root) = Path::new(&wmaker_user_root).canonicalize() else {
-        return Err(io::Error::other(
-            "cannot canonicalize path for WMAKER_USER_ROOT",
-        ));
-    };
-
-    if !canonical_p.starts_with(&wmaker_user_root) {
-        return Err(io::Error::other(
-            "requested path is not under WMAKER_USER_ROOT",
-        ));
-    }
-
-    create_path_hierarchy_impl(&canonical_p)
-}
-
-/// Removes the file at `p` (and anything under it, if `p` is a directory). Only
-/// allows deletion of files under [`user_gnustep_path`]`/Defaults` or
-/// [`user_gnustep_path`]`/Library`.
-pub fn remove_path_hierarchy<P: AsRef<Path>>(p: P) -> io::Result<()> {
-    let p = p.as_ref();
-    let Ok(canonical_p) = p.canonicalize() else {
-        return Err(io::Error::other("cannot canonicalize requested path"));
-    };
-    let Some(wmaker_user_root) = user_gnustep_path() else {
-        return Err(io::Error::other("cannot determine WMAKER_USER_ROOT. try setting the environment variable WMAKER_USER_ROOT."));
-    };
-    let Ok(wmaker_user_root) = Path::new(&wmaker_user_root).canonicalize() else {
-        return Err(io::Error::other(
-            "cannot canonicalize path for WMAKER_USER_ROOT",
-        ));
-    };
-
-    let mut defaults = wmaker_user_root.clone();
-    defaults.push("Defaults");
-    let mut library = wmaker_user_root;
-    library.push("Library");
-    if !canonical_p.starts_with(&defaults) && !canonical_p.starts_with(&library) {
-        return Err(io::Error::other(
-            "requested path is not under WMAKER_USER_ROOT/Defaults or WMAKER_USER_ROOT/Library",
-        ));
-    }
-
-    std::fs::remove_dir_all(canonical_p)
-}
-
-#[cfg(target_family = "unix")]
-fn create_path_hierarchy_impl(p: &Path) -> io::Result<()> {
-    use std::os::unix::fs::DirBuilderExt;
-    std::fs::DirBuilder::new()
-        .recursive(true)
-        .mode(0o777)
-        .create(p)
-}
-
-#[cfg(not(target_family = "unix"))]
-fn create_path_hierarchy_impl(p: &Path) -> io::Result<()> {
-    std::fs::DirBuilder::new().recursive(true).create(p)
-}
-
-pub mod ffi {
-    use super::{absolute, create_path_hierarchy, in_paths, path_from_cstr, remove_path_hierarchy, user_gnustep_path};
-    use crate::memory::alloc_bytes;
-
-    use std::{
-        env,
-        ffi::{c_char, c_int, CStr, OsStr},
-        iter,
-        os::unix::ffi::OsStrExt,
-        path::{Path, PathBuf},
-        ptr,
-    };
-
-    fn split_paths(paths: &CStr) -> impl Iterator<Item = &[u8]> {
-        paths.to_bytes().split(|b| *b == b':')
-    }
-
-    fn to_c_str(p: &Path) -> *mut c_char {
-        let os_bytes = p.as_os_str().as_encoded_bytes();
-        let buf = alloc_bytes(os_bytes.len() + 1);
-        unsafe {
-            ptr::copy_nonoverlapping(os_bytes.as_ptr(), buf, os_bytes.len());
-        }
-        buf.cast::<c_char>()
-    }
-
-    /// Attempts to find `file` under colon-separated `paths`. Checks if `file`
-    /// is absolute or prefixed with `~` before attempting to resolve it
-    /// relatively. If no file can be found, returns NULL. Non-NULL return
-    /// values must be freed with [`crate::memory::free_bytes`] or
-    /// [`crate::memory::ffi::wfree`].
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn wfindfile(paths: *const c_char, file: *const c_char) -> *mut c_char {
-        if file.is_null() {
-            return ptr::null_mut();
-        }
-        let file = unsafe { CStr::from_ptr(file) };
-        let file = Path::new(OsStr::from_bytes(file.to_bytes()));
-        if let Some(path) = absolute(&file) {
-            return to_c_str(&path);
-        }
-        let path = if paths.is_null() {
-            in_paths(iter::empty(), file)
-        } else {
-            let paths = unsafe { CStr::from_ptr(paths) };
-            in_paths(
-                split_paths(paths).map(|p| Path::new(OsStr::from_bytes(p))),
-                file,
-            )
-        };
-        path.map(|x| to_c_str(x.as_ref()))
-            .unwrap_or(ptr::null_mut())
-    }
-
-    /// Attempts to find `file` under an element of NULL-terminated
-    /// `path_list`. Checks if `file` is absolute or prefixed with `~` before
-    /// attempting to resolve it relatively. If no file can be found, returns
-    /// NULL. Non-NULL return values must be freed with
-    /// [`crate::memory::free_bytes`] or [`crate::memory::ffi::wfree`].
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn wfindfileinlist(
-        path_list: *const *const c_char,
-        file: *const c_char,
-    ) -> *mut c_char {
-        if file.is_null() {
-            return ptr::null_mut();
-        }
-        let file = unsafe { CStr::from_ptr(file) };
-        let file = Path::new(OsStr::from_bytes(file.to_bytes()));
-        if let Some(path) = absolute(&file) {
-            return to_c_str(&path);
-        }
-
-        let path = if path_list.is_null() {
-            in_paths(iter::empty(), file)
-        } else {
-            let paths = (0usize..)
-                .map(|offset| unsafe { path_list.add(offset) })
-                .take_while(|&p| unsafe { !(*p).is_null() })
-                .map(|p| Path::new(OsStr::from_bytes(unsafe { CStr::from_ptr(*p).to_bytes() })));
-            in_paths(paths, file)
-        };
-
-        path.map(|x| to_c_str(x.as_ref()))
-            .unwrap_or(ptr::null_mut())
-    }
-
-    /// Attempts to expand `path` if it starts with `~` by replacing the first
-    /// path element with the user's home directory. Returns NULL if `path` is
-    /// NULL. Non-NULL return values must be freed with
-    /// [`crate::memory::free_bytes`] or [`crate::memory::ffi::wfree`].
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn wexpandpath(path: *const c_char) -> *mut c_char {
-        if path.is_null() {
-            return ptr::null_mut();
-        }
-        let path = unsafe { CStr::from_ptr(path) };
-        let path = Path::new(OsStr::from_bytes(path.to_bytes()));
-        absolute(path)
-            .map(|p| to_c_str(&p))
-            .unwrap_or_else(|| to_c_str(&path))
-    }
-
-    /// Returns the home directory of the current user, or `"/"` if it cannot be
-    /// determined. The returned value must be freed with
-    /// [`crate::memory::free_bytes`] or [`crate::memory::ffi::wfree`].
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn wgethomedir() -> *mut c_char {
-        match env::home_dir() {
-            Some(x) => to_c_str(x.as_ref()),
-            None => to_c_str(Path::new("/")),
-        }
-    }
-
-    /// Copies `src_file` into `dest_dir/dest_file`. Returns 0 on success, or -1
-    /// on error.
-    ///
-    /// This is provided solely to support code that has not yet been ported to
-    /// Rust. Prefer `std::fs::copy` or another utility if you can.
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn wcopy_file(
-        dest_dir: *const c_char,
-        src_file: *const c_char,
-        dest_file: *const c_char,
-    ) -> c_int {
-        if dest_dir.is_null() || src_file.is_null() || dest_file.is_null() {
-            return -1;
-        }
-        let src_file = unsafe { CStr::from_ptr(src_file) };
-        let dest_dir = unsafe { CStr::from_ptr(dest_dir) };
-        let dest_file = unsafe { CStr::from_ptr(dest_file) };
-        let src = Path::new(OsStr::from_bytes(src_file.to_bytes()));
-        let mut dest = PathBuf::from(OsStr::from_bytes(dest_dir.to_bytes()));
-        dest.push(OsStr::from_bytes(dest_file.to_bytes()));
-        if std::fs::copy(src, dest).is_ok() {
-            return 0;
-        } else {
-            return -1;
-        }
-    }
-
-    /// Delegates to [`create_path_hierarchy`].
-    ///
-    /// ## Rust rewrite notes
-    ///
-    /// The original C implementation of this function stripped the last path
-    /// component if it did not end in a `'/'` (i.e., it looked like a regular
-    /// file instead of a directory). This behavior does not appear to be relied
-    /// upon by any existing callers except for `WMWritePropListToFile`, which
-    /// has been rewritten, and it is not super portable (and annoying because
-    /// it adds weird edge cases). So each component of `path` is treated as a
-    /// directory to be made.
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn wmkdirhier(path: *const c_char) -> c_int {
-        if path.is_null() {
-            return 0;
-        }
-        let path = unsafe { CStr::from_ptr(path) };
-        let Some(path) = path_from_cstr(path) else {
-            return 0;
-        };
-        if create_path_hierarchy(path).is_ok() {
-            return 1;
-        } else {
-            return 0;
-        }
-    }
-
-    /// Delegates to [`remove_path_hierarchy`].
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn wrmdirhier(path: *const c_char) -> c_int {
-        if path.is_null() {
-            return 0;
-        }
-        let path = unsafe { CStr::from_ptr(path) };
-        let Some(path) = path_from_cstr(path) else {
-            return 0;
-        };
-        if remove_path_hierarchy(path).is_ok() {
-            return 1;
-        } else {
-            return 0;
-        }
-    }
-
-    /// Delegates to [`user_gnustep_path`]. Returns the path, which must be The
-    /// returned value must be freed with [`crate::memory::free_bytes`] or
-    /// [`crate::memory::ffi::wfree`], path cannot be determined.
-    ///
-    /// ## Rust rewrite notes
-    ///
-    /// This was originally in `WINGs/userdefaults.c`.
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn wusergnusteppath() -> *mut c_char {
-        if let Some(path) = user_gnustep_path() {
-            to_c_str(&path)
-        } else {
-            ptr::null_mut()
-        }
-    }
-}

wutil-rs/src/hash_table.rs

@@ -1,328 +0,0 @@
-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

@@ -1,7 +0,0 @@
-pub mod array;
-pub mod data;
-pub mod defines;
-pub mod find_file;
-pub mod hash_table;
-pub mod memory;
-pub mod prop_list;

wutil-rs/src/memory.rs

@@ -1,283 +0,0 @@
-//! 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, ffi::{c_char, CStr}, mem, ptr::{self, NonNull}};
-
-/// Tracks the layout and reference count of an allocated chunk of memory.
-#[derive(Clone, Copy)]
-struct Header {
-    ptr: NonNull<u8>,
-    payload_size: usize,
-    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 Ok(header_layout) = alloc::Layout::from_size_align(mem::size_of::<Header>(), 8) else {
-        return ptr::null_mut();
-    };
-
-    let Ok(layout) = alloc::Layout::from_size_align(size, 8) else {
-        return ptr::null_mut();
-    };
-    let Ok((full_layout, result_offset)) = header_layout.extend(layout) else {
-        return ptr::null_mut();
-    };
-
-    let full_segment = unsafe { alloc::alloc_zeroed(full_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),
-            payload_size: size,
-            layout: full_layout,
-            refcount: 0,
-        });
-    }
-
-    result
-}
-
-/// Allocates a segment with [`alloc_bytes`] and fills it with the contents of
-/// `s`. The resulting string should be free'd by passing it to [`free_bytes`].
-pub fn alloc_string(s: &CStr) -> *mut c_char {
-    let len = s.count_bytes() + 1;
-    let result = alloc_bytes(len).cast::<c_char>();
-    unsafe { ptr::copy_nonoverlapping(s.as_ptr().cast::<c_char>(), result, len); }
-    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 `size` is 0. Data will be
-    /// initialized but have an arbitrary value.
-    #[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. If `newsize` is larger than `ptr`'s segment,
-    /// data in the new space will be initialized but have an arbitrary value.
-    ///
-    /// ## Safety
-    ///
-    /// If `ptr` is non-null, callers must ensure that it came from from
-    /// [`wmalloc`] or [`wrealloc`].
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn wrealloc(ptr: *mut c_void, newsize: usize) -> *mut c_void {
-        if ptr.is_null() {
-            unsafe {
-                return wmalloc(newsize);
-            }
-        }
-        unsafe {
-            let result = wmalloc(newsize);
-            let result_header = ptr::read_unaligned(Header::for_alloc_bytes(result.cast()));
-            let ptr_header = ptr::read_unaligned(Header::for_alloc_bytes(ptr.cast()));
-            let copy_size = usize::min(
-                ptr_header.payload_size,
-                result_header.payload_size,
-            );
-            ptr::copy_nonoverlapping(ptr, result, copy_size);
-            wfree(ptr);
-            result
-        }
-    }
-
-    /// 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, alloc_string, ffi::{wfree, wmalloc, wrealloc}, free_bytes, Header};
-
-    use std::{ffi::CStr, mem, os::raw::c_void, ptr, slice};
-
-    #[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 multiple_allocs() {
-        unsafe {
-            let x = wmalloc(mem::size_of::<i64>());
-            *x.cast::<i64>() = 30;
-            let y = wmalloc(mem::size_of::<i32>());
-            *y.cast::<i32>() = 5;
-            let z = wmalloc(48);
-            *z.cast::<f32>() = 1.0;
-            wfree(x);
-            wfree(y);
-            wfree(z);
-        }
-    }
-
-    #[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>()); }
-    }
-
-    #[test]
-    fn realloc_retains_data() {
-        let x: *mut u8 = unsafe { wmalloc(10).cast() };
-        unsafe {
-            let xs = slice::from_raw_parts_mut(&mut *x, 10);
-            // We know that xs should be zeroed.
-            assert_eq!(xs, &[0u8; 10]);
-            for i in 0u8..10 {
-                xs[i as usize] = i;
-            }
-            assert_eq!(xs, (0..10).collect::<Vec::<u8>>());
-        }
-    }
-
-    #[test]
-    fn alloc_free_string() {
-        let s = alloc_string(c"hello");
-        assert!(!s.is_null());
-        assert_eq!(unsafe { CStr::from_ptr(s) }, c"hello");
-        unsafe { free_bytes(s.cast::<u8>()); }
-    }
-}

wutil-rs/src/prop_list.rs

@@ -1,863 +0,0 @@
-//! Property lists: shared, tree-structured data.
-//!
-//! ## Rust rewrite notes
-//!
-//! This implementation should be good enough to facilitate migrating from C to
-//! Rust and trasitioning away from using property lists everywhere instead of
-//! proper structs. `PropList`s are a really cool general-purpose tool for
-//! attaching data to objects and persisting it to disk. But in Rust, it is
-//! easier to use proper structs with typed fields and appropriate `#[derive]`
-//! declarations to generate code for serialization and deserialization
-//! (presumably using Serde).
-//!
-//! As code that uses `PropList`s is rewritte in Rust, we should work on
-//! migrating away from use of `PropList`s. Objects whose fields that can be
-//! statically typed should be represented as structs. They may still be
-//! persisted by cramming them into `PropList`s and writing those to disk, but
-//! it would be better still to implement Serde-based serialization to and from
-//! the property list format.
-//!
-//! The `PropList` implementation itself can also be improved substantially. See
-//! [`PropList`] for thoughts on this.
-
-use atomic_write_file::unix::OpenOptionsExt;
-
-use std::{
-    cell::RefCell,
-    collections::{hash_map, HashMap},
-    ffi::{CString, OsStr, OsString},
-    fmt, hash,
-    io::{self, BufWriter, Write},
-    path::Path,
-    process::Command,
-    ptr,
-    rc::Rc,
-};
-
-use crate::find_file;
-
-pub mod parser;
-pub mod writer;
-
-/// Payload of a [`PropList`].
-#[derive(Eq, PartialEq)]
-pub enum Node {
-    /// Text data. This is UTF-8 encoded and null-safe.
-    ///
-    /// ## Rust rewrite notes
-    ///
-    /// It would be better for this to be a `String`, but the C interface
-    /// requires borrows of C-style strings.
-    String(CString),
-    /// Array of child `PropList`s.
-    Array(Vec<PropList>),
-    /// `PropList`-keyed table of child `PropList`s. Keys should only have
-    /// `Node::String` or `Node::Data` payloads, although there is almost no
-    /// enforcement of this.
-    Dictionary(HashMap<PropList, PropList>),
-}
-
-impl hash::Hash for Node {
-    fn hash<H: hash::Hasher>(&self, h: &mut H) {
-        match self {
-            Node::String(s) => s.hash(h),
-            Node::Array(a) => {
-                for p in a {
-                    p.hash(h);
-                }
-            }
-            Node::Dictionary(d) => {
-                for (k, v) in d {
-                    k.hash(h);
-                    v.hash(h);
-                }
-            }
-        }
-    }
-}
-
-impl fmt::Debug for Node {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(
-            f,
-            "{}",
-            writer::Display {
-                inline: writer::Inline::Soft,
-                clear_left: false,
-                indentation: 0,
-                increment: 2,
-                node: self,
-            }
-        )
-    }
-}
-
-fn merge_shallow(dest: PropList, source: PropList) {
-    if ptr::eq(dest.0.as_ref(), source.0.as_ref()) {
-        return;
-    }
-    let Node::Dictionary(ref mut dest_items) = *dest.0.borrow_mut() else {
-        return;
-    };
-    let Node::Dictionary(ref source) = *source.0.borrow() else {
-        return;
-    };
-    for (k, v) in source {
-        if ptr::eq(dest.0.as_ptr(), k.0.as_ptr()) {
-            // Don't borrow k if it is already borrowed as dest.
-            continue;
-        }
-        dest_items.insert(k.clone(), v.clone());
-    }
-}
-
-fn merge_deep(dest: PropList, source: PropList) {
-    if ptr::eq(dest.0.as_ptr(), source.0.as_ptr()) {
-        return;
-    }
-    let Node::Dictionary(dest_items) = &mut *dest.0.borrow_mut() else {
-        return;
-    };
-    let Node::Dictionary(source_items) = &*source.0.borrow() else {
-        return;
-    };
-
-    for (key, value) in source_items {
-        if key.0.try_borrow().is_err() || value.0.try_borrow().is_err() {
-            // Something has already borrowed key or value. This may happen if
-            // source contains pointers that are also in dest, or if dest is
-            // cyclic. This is bad, but we just bail out.
-            continue;
-        }
-        match dest_items.entry(key.clone()) {
-            hash_map::Entry::Vacant(v) => {
-                // Dest has nothing at key. Insert value from source.
-                v.insert(value.clone());
-            }
-            hash_map::Entry::Occupied(mut o) => {
-                let recur = match *o.get().0.borrow() {
-                    Node::Dictionary(_) => true,
-                    _ => false,
-                };
-                if recur {
-                    // dest[key] is a dictionary. Recur on dest[key] and value from source.
-                    merge_deep(o.get().clone(), value.clone());
-                } else {
-                    // dest[key] is not a dictionary. Overwrite with value from source.
-                    o.insert(value.clone());
-                }
-            }
-        }
-    }
-}
-
-fn subtract_shallow(dest: PropList, source: PropList) {
-    if ptr::eq(dest.0.as_ptr(), source.0.as_ptr()) {
-        if let Node::Dictionary(ref mut items) = *dest.0.borrow_mut() {
-            items.clear();
-        }
-        return;
-    }
-
-    let Node::Dictionary(ref mut dest_items) = *dest.0.borrow_mut() else {
-        return;
-    };
-    let Node::Dictionary(ref source_items) = *source.0.borrow() else {
-        return;
-    };
-    for (k, v) in source_items.iter() {
-        if ptr::eq(dest.0.as_ptr(), k.0.as_ptr()) {
-            continue;
-        }
-        if let hash_map::Entry::Occupied(o) = dest_items.entry(k.clone()) {
-            if o.get() == v {
-                o.remove();
-            }
-        }
-    }
-}
-
-fn subtract_deep(dest: PropList, source: PropList) {
-    if ptr::eq(dest.0.as_ptr(), source.0.as_ptr()) {
-        if let Node::Dictionary(ref mut items) = *dest.0.borrow_mut() {
-            items.clear();
-        }
-        return;
-    }
-
-    let Node::Dictionary(ref mut dest_items) = *dest.0.borrow_mut() else {
-        return;
-    };
-    let Node::Dictionary(ref source_items) = *source.0.borrow() else {
-        return;
-    };
-    for (k, v) in source_items.iter() {
-        if ptr::eq(dest.0.as_ptr(), k.0.as_ptr()) {
-            continue;
-        }
-        if let hash_map::Entry::Occupied(o) = dest_items.entry(k.clone()) {
-            if o.get() == v {
-                o.remove();
-                continue;
-            }
-            let recur = match (&*o.get().0.borrow(), &*v.0.borrow()) {
-                (Node::Dictionary(_), Node::Dictionary(_)) => true,
-                _ => false,
-            };
-            if recur {
-                subtract_deep(o.get().clone(), v.clone());
-            }
-        }
-    }
-}
-
-/// Data graph with convenient (de)serialization to/from the [property
-/// list](https://en.wikipedia.org/wiki/Property_list) format.
-///
-/// ## Rust rewrite notes
-///
-/// The original WUtils `PropList` was a reference-counted pointer, so it
-/// supported shallow copy and shared-memory semantics that we have continued to
-/// try to support in the Rust implementation. As a result, `PropList` is a thin
-/// wrapper around an `Rc<RefCell<Node>>`. There are several reasons why this is
-/// probably unnecessary and something we should migrate away from:
-///
-/// * It allows for the creation of non-tree structures, which was probably
-///   never intended. (A degenerate `PropList` could even have itself as a child.)
-/// * It complicates recursive operations on `PropList`s (equality checks,
-///   merging, or taking differences) because a given `PropList` may occur
-///   multiple times when traversing two `PropList`s, but `Rc` only allows it to be
-///   mutably borrowed once.
-/// * Allowing subtrees to be shared between two different `PropList`s
-///   may lead to spooky action at a distance and may not actually be taken
-///   advantage of by any client code.
-///
-/// As client code is migrated into Rust, it would be great to move away from
-/// this implementation to a simpler one. As discussed in the module-level
-/// rewrite notes, we may even be able to do away with `PropList` itself
-/// (perhaps in favor of using Serde to write to and from property list files on
-/// disk).
-#[derive(Clone)]
-pub struct PropList(Rc<RefCell<Node>>);
-
-impl PropList {
-    pub fn new(node: Node) -> Self {
-        PropList(Rc::new(RefCell::new(node)))
-    }
-
-    /// Reads `r` to the end and tries to parse it into a `PropList`.
-    pub fn from_file<P: AsRef<Path>>(path: P) -> Result<PropList, String> {
-        let path = path.as_ref().to_path_buf();
-        let buf = std::fs::read_to_string(&path).map_err(|e| format!("{}", e))?;
-        parser::from_str(buf.as_str())
-    }
-
-    // Runs `command` and tries to parse a PropList from its standard output.
-    pub fn from_command<S: AsRef<OsStr>>(command: S) -> Result<PropList, String> {
-        let command: OsString = command.as_ref().to_os_string();
-        let output = Command::new("/bin/sh")
-            .arg("-c")
-            .arg(command.clone())
-            .output()
-            .map_err(|e| format!("{}", e))?;
-        let output = str::from_utf8(&output.stdout).map_err(|e| format!("{}", e))?;
-        parser::from_str(&output)
-    }
-
-    pub fn display_indented<'s>(&'s self) -> impl fmt::Display + 's {
-        writer::Display {
-            inline: writer::Inline::Soft,
-            clear_left: false,
-            indentation: 0,
-            increment: 2,
-            node: self.0.borrow(),
-        }
-    }
-
-    pub fn display_unindented<'s>(&'s self) -> impl fmt::Display + 's {
-        writer::Display {
-            inline: writer::Inline::Hard,
-            clear_left: false,
-            indentation: 0,
-            increment: 0,
-            node: self.0.borrow(),
-        }
-    }
-}
-
-impl Eq for PropList {}
-
-impl PartialEq for PropList {
-    fn eq(&self, other: &Self) -> bool {
-        *self.0.borrow() == *other.0.borrow()
-    }
-}
-
-impl hash::Hash for PropList {
-    fn hash<H: hash::Hasher>(&self, h: &mut H) {
-        self.0.borrow().hash(h)
-    }
-}
-
-impl fmt::Debug for PropList {
-    fn fmt(&self, out: &mut fmt::Formatter) -> fmt::Result {
-        write!(out, "{:?}", self.0.borrow())?;
-        Ok(())
-    }
-}
-
-impl PropList {
-    pub fn deep_clone(&self) -> Self {
-        match &*self.0.borrow() {
-            Node::String(s) => PropList::new(Node::String(s.clone())),
-            Node::Array(items) => {
-                PropList::new(Node::Array(items.iter().map(|x| x.deep_clone()).collect()))
-            }
-            Node::Dictionary(items) => PropList::new(Node::Dictionary(
-                items
-                    .iter()
-                    .map(|(k, v)| (k.deep_clone(), v.deep_clone()))
-                    .collect(),
-            )),
-        }
-    }
-
-    /// Atomically serialize this `PropList` to `path`, creating any necessary
-    /// parent directories.
-    ///
-    /// `path` is written to atomically: either the serialized `PropList` will
-    /// be completely written to `path`, or the operation will fail and any
-    /// existing file at `path` will not be modified.
-    ///
-    /// ## Rust rewrite notes
-    ///
-    /// As originally noted in `proplist.c`, a Coverity security bug report
-    /// flagged the need to preserve the permissions on the file being written
-    /// to. This should be respected in the rewritten code under Unix-like
-    /// operataing systems.
-    pub fn write_to_file<P: AsRef<Path>>(&self, path: &P) -> io::Result<()> {
-        self.write_to_file_impl(path.as_ref())
-    }
-
-    fn write_to_file_impl(&self, path: &Path) -> io::Result<()> {
-        if let Some(parent) = path.parent() {
-            find_file::create_path_hierarchy(parent)?;
-        }
-        let file = atomic_write_file::AtomicWriteFile::options()
-            .preserve_mode(true)
-            .open(&path)?;
-        let mut out = BufWriter::new(file);
-        writeln!(&mut out, "{}", self.display_indented())?;
-        out.into_inner()?.commit()
-    }
-}
-
-pub mod ffi {
-    use crate::{find_file::path_from_cstr, memory};
-
-    use super::{
-        merge_deep, merge_shallow, parser, subtract_deep, subtract_shallow, Node, PropList,
-    };
-
-    use std::{
-        collections::HashMap, ffi::{c_char, c_int, c_uint, CStr, CString, OsString}, ptr, str::FromStr
-    };
-
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn WMCreatePLString(s: *const c_char) -> *mut PropList {
-        if s.is_null() {
-            return ptr::null_mut();
-        }
-        let s = unsafe { CStr::from_ptr(s) };
-        Box::leak(Box::new(PropList::new(Node::String(s.into()))))
-    }
-
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn WMCreatePLArrayFromSlice(
-        elems: *mut PropList,
-        length: c_uint,
-    ) -> *mut PropList {
-        if elems.is_null() {
-            return ptr::null_mut();
-        }
-        let elems = unsafe { &*ptr::slice_from_raw_parts(elems, length as usize) };
-        Box::leak(Box::new(PropList::new(Node::Array(
-            elems.iter().cloned().collect(),
-        ))))
-    }
-
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn WMCreateEmptyPLArray() -> *mut PropList {
-        Box::leak(Box::new(PropList::new(Node::Array(Vec::new()))))
-    }
-
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn WMCreatePLDictionary(
-        key: *mut PropList,
-        value: *mut PropList,
-    ) -> *mut PropList {
-        if key.is_null() || value.is_null() {
-            return Box::leak(Box::new(PropList::new(Node::Dictionary(HashMap::new()))));
-        }
-        let key = unsafe { (*key).clone() };
-        let value = unsafe { (*value).clone() };
-        Box::leak(Box::new(PropList::new(Node::Dictionary(
-            [(key, value)].into(),
-        ))))
-    }
-
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn WMCreateEmptyPLDictionary() -> *mut PropList {
-        Box::leak(Box::new(PropList::new(Node::Dictionary(HashMap::new()))))
-    }
-
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn WMRetainPropList(plist: *mut PropList) -> *mut PropList {
-        if plist.is_null() {
-            return ptr::null_mut();
-        }
-        unsafe { Box::leak(Box::new((*plist).clone())) }
-    }
-
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn WMReleasePropList(plist: *mut PropList) {
-        if plist.is_null() {
-            return;
-        }
-        let _ = unsafe { ptr::read(plist) };
-    }
-
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn WMInsertInPLArray(
-        plist: *mut PropList,
-        index: c_int,
-        item: *mut PropList,
-    ) {
-        if plist.is_null() || index < 0 || item.is_null() {
-            return;
-        }
-        let plist = unsafe { &mut *plist };
-        if let Node::Array(ref mut items) = *plist.0.borrow_mut() {
-            let item = unsafe { (*item).clone() };
-            items.insert(index as usize, item);
-        }
-    }
-
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn WMAddToPLArray(plist: *mut PropList, item: *mut PropList) {
-        if plist.is_null() || item.is_null() {
-            return;
-        }
-        let plist = unsafe { &mut *plist };
-        if let Node::Array(ref mut items) = *plist.0.borrow_mut() {
-            let item = unsafe { (*item).clone() };
-            items.push(item);
-        }
-    }
-
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn WMDeleteFromPLArray(plist: *mut PropList, index: c_int) {
-        if plist.is_null() || index < 0 {
-            return;
-        }
-        let plist = unsafe { &mut *plist };
-        if let Node::Array(ref mut items) = *plist.0.borrow_mut() {
-            items.remove(index as usize);
-        }
-    }
-
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn WMRemoveFromPLArray(plist: *mut PropList, item: *mut PropList) {
-        if plist.is_null() || item.is_null() {
-            return;
-        }
-        let plist = unsafe { &mut *plist };
-        let item = unsafe { &*item };
-        if let Node::Array(ref mut items) = *plist.0.borrow_mut() {
-            if let Some((i, _)) = items.iter().enumerate().find(|(_, x)| *x == item) {
-                items.remove(i);
-            }
-        }
-    }
-
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn WMPutInPLDictionary(
-        plist: *mut PropList,
-        key: *mut PropList,
-        value: *mut PropList,
-    ) {
-        if plist.is_null() || key.is_null() || value.is_null() {
-            return;
-        }
-        let plist = unsafe { &mut *plist };
-        if let Node::Dictionary(ref mut items) = *plist.0.borrow_mut() {
-            let key = unsafe { (*key).clone() };
-            let value = unsafe { (*value).clone() };
-            items.insert(key, value);
-        }
-    }
-
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn WMRemoveFromPLDictionary(plist: *mut PropList, key: *mut PropList) {
-        if plist.is_null() || key.is_null() {
-            return;
-        }
-        let plist = unsafe { &mut *plist };
-        let key = unsafe { &*key };
-        if let Node::Dictionary(ref mut items) = *plist.0.borrow_mut() {
-            items.remove(key);
-        }
-    }
-
-    /// If `dest` and `source` are both dictionaries, overwrites entries in
-    /// `dest` with corresponding entries in `source`.
-    ///
-    /// If `recursive` is non-zero, this is done recursively for values in
-    /// `dest` and `source` that are both dictionaries.
-    ///
-    /// ## Rust rewrite notes
-    ///
-    /// This operation is used a few times. It may be worth keeping around
-    /// longer-term, although it might be hard to express if we do transition
-    /// away from `PropList`s to statically typed struct trees.
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn WMMergePLDictionaries(
-        dest: *mut PropList,
-        source: *mut PropList,
-        recursive: c_int,
-    ) -> *mut PropList {
-        if dest.is_null() || ptr::eq(dest, source) || source.is_null() {
-            return dest;
-        }
-
-        let dest = unsafe { (*dest).clone() };
-        let source = unsafe { (*source).clone() };
-
-        if recursive == 0 {
-            merge_shallow(dest.clone(), source);
-        } else {
-            merge_deep(dest.clone(), source);
-        }
-
-        return Box::leak(Box::new(dest));
-    }
-
-    /// If `dest` and `source` are both dictionaries, removes from `dest` any
-    /// `(k, v)` pairs where `dest[k] == source[k]`.
-    ///
-    /// If `recursive` is non-zero, this is done recursively over subtrees of
-    /// `dest` and `source` when both `dest` and `source` are dictionaries for
-    /// keys of `source` that are also keys of `dest`.
-    ///
-    /// ## Rust rewrite notes
-    ///
-    /// This operation is only used in one place. It may be better to implement
-    /// this behavior as a one-off closer to where it is used, or with a
-    /// different API differently (e.g., as a function of a more general
-    /// proplist diff).
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn WMSubtractPLDictionaries(
-        dest: *mut PropList,
-        source: *mut PropList,
-        recursive: c_int,
-    ) -> *mut PropList {
-        if dest.is_null() {
-            return ptr::null_mut();
-        }
-        if source.is_null() {
-            return dest;
-        }
-
-        let dest = unsafe { (*dest).clone() };
-        let source = unsafe { (*source).clone() };
-
-        if recursive == 0 {
-            subtract_shallow(dest.clone(), source);
-        } else {
-            subtract_deep(dest.clone(), source);
-        }
-
-        Box::leak(Box::new(dest))
-    }
-
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn WMGetPropListItemCount(plist: *mut PropList) -> c_int {
-        if plist.is_null() {
-            return 0;
-        }
-        let plist = unsafe { &*plist };
-        match &*plist.0.borrow() {
-            Node::Array(xs) => xs.len() as c_int,
-            Node::Dictionary(xs) => xs.len() as c_int,
-            _ => 0,
-        }
-    }
-
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn WMIsPLString(plist: *mut PropList) -> c_int {
-        if plist.is_null() {
-            return 0;
-        }
-        let plist = unsafe { &*plist };
-        match &*plist.0.borrow() {
-            Node::String(_) => 1,
-            _ => 0,
-        }
-    }
-
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn WMIsPLArray(plist: *mut PropList) -> c_int {
-        if plist.is_null() {
-            return 0;
-        }
-        let plist = unsafe { &*plist };
-        match &*plist.0.borrow() {
-            Node::Array(_) => 1,
-            _ => 0,
-        }
-    }
-
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn WMIsPLDictionary(plist: *mut PropList) -> c_int {
-        if plist.is_null() {
-            return 0;
-        }
-        let plist = unsafe { &*plist };
-        match &*plist.0.borrow() {
-            Node::Dictionary(_) => 1,
-            _ => 0,
-        }
-    }
-
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn WMIsPropListEqualTo(a: *mut PropList, b: *mut PropList) -> c_int {
-        if ptr::eq(a, b) {
-            return 1;
-        }
-        if a.is_null() {
-            return 0;
-        }
-        let a = unsafe { &*a };
-        let b = unsafe { &*b };
-        if a == b {
-            1
-        } else {
-            0
-        }
-    }
-
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn WMGetFromPLString(plist: *mut PropList) -> *const c_char {
-        if plist.is_null() {
-            return ptr::null_mut();
-        }
-        let plist = unsafe { &*plist };
-        if let Node::String(ref s) = *plist.0.borrow() {
-            s.as_ref().as_ptr().cast::<c_char>()
-        } else {
-            ptr::null()
-        }
-    }
-
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn WMGetFromPLArray(plist: *mut PropList, index: c_int) -> *mut PropList {
-        if plist.is_null() || index < 0 {
-            return ptr::null_mut();
-        }
-        let plist = unsafe { &*plist };
-        if let Node::Array(ref items) = *plist.0.borrow() {
-            if let Some(x) = items.get(index as usize) {
-                return Box::leak(Box::new(x.clone()));
-            }
-        }
-        ptr::null_mut()
-    }
-
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn WMGetFromPLDictionary(plist: *mut PropList, key: *mut PropList) -> *mut PropList {
-        if plist.is_null() || key.is_null() {
-            return ptr::null_mut();
-        }
-        let plist = unsafe { &*plist };
-        let key = unsafe { &*key };
-        if let Node::Dictionary(ref items) = *plist.0.borrow() {
-            if let Some(item) = items.get(key) {
-                return Box::leak(Box::new(item.clone()));
-            }
-        }
-        ptr::null_mut()
-    }
-
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn WMGetPLDictionaryKeys(plist: *mut PropList) -> *mut PropList {
-        if plist.is_null() {
-            return ptr::null_mut();
-        }
-        let plist = unsafe { &*plist };
-
-        if let Node::Dictionary(ref items) = *plist.0.borrow() {
-            return Box::leak(Box::new(PropList::new(Node::Array(items.keys().cloned().collect()))));
-        }
-        ptr::null_mut()
-    }
-
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn WMDeepCopyPropList(plist: *mut PropList) -> *mut PropList {
-        if plist.is_null() {
-            return ptr::null_mut();
-        }
-        let plist = unsafe { &*plist };
-        Box::leak(Box::new(plist.deep_clone()))
-    }
-
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn WMCreatePropListFromDescription(desc: *const c_char) -> *mut PropList {
-        if desc.is_null() {
-            return ptr::null_mut();
-        }
-        let desc = unsafe { CStr::from_ptr(desc) };
-        let Ok(desc) = desc.to_str() else {
-            return ptr::null_mut();
-        };
-
-        match parser::from_str(desc) {
-            Ok(plist) => Box::leak(Box::new(plist)),
-            Err(_) => ptr::null_mut(),
-        }
-    }
-
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn WMGetPropListDescription(
-        plist: *mut PropList,
-        indented: c_int,
-    ) -> *mut c_char {
-        use std::io::Write;
-
-        if plist.is_null() {
-            return ptr::null_mut();
-        }
-        let plist = unsafe { &*plist };
-        let mut buf = Vec::new();
-        if indented != 0 {
-            if let Err(_) = write!(&mut buf, "{}", plist.display_indented()) {
-                return ptr::null_mut();
-            }
-        } else {
-            if let Err(_) = write!(&mut buf, "{}", plist.display_unindented()) {
-                return ptr::null_mut();
-            }
-        }
-        match CString::new(buf) {
-            Ok(s) => memory::alloc_string(s.as_c_str()),
-            Err(_) => ptr::null_mut(),
-        }
-    }
-
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn WMReadPropListFromFile(path: *const c_char) -> *mut PropList {
-        if path.is_null() {
-            return ptr::null_mut();
-        }
-        let path = unsafe { CStr::from_ptr(path) };
-        let Ok(path) = path.to_str() else {
-            return ptr::null_mut();
-        };
-        match PropList::from_file(path) {
-            Ok(plist) => Box::leak(Box::new(plist)),
-            Err(_) => {
-                // TODO: print error message.
-                ptr::null_mut()
-            }
-        }
-    }
-
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn WMReadPropListFromPipe(command: *const c_char) -> *mut PropList {
-        if command.is_null() {
-            return ptr::null_mut();
-        }
-
-        let command = unsafe { CStr::from_ptr(command) };
-        let Ok(command) = command.to_str() else {
-            return ptr::null_mut();
-        };
-        let command = OsString::from_str(command).unwrap();
-
-        let Ok(output) = std::process::Command::new("/bin/sh")
-            .arg("-c")
-            .arg(command)
-            .output()
-        else {
-            // TODO: print error message.
-            return ptr::null_mut();
-        };
-        let Ok(output) = String::from_utf8(output.stdout) else {
-            // TODO: print error message.
-            return ptr::null_mut();
-        };
-        match parser::from_str(&output) {
-            Ok(plist) => Box::leak(Box::new(plist)),
-            Err(_) => {
-                // TODO: print error message.
-                ptr::null_mut()
-            }
-        }
-    }
-
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn WMWritePropListToFile(
-        plist: *mut PropList,
-        path: *const c_char,
-    ) -> c_int {
-        if plist.is_null() || path.is_null() {
-            return 0;
-        }
-        let plist = unsafe {
-            &*plist
-        };
-
-        let path = unsafe {
-            CStr::from_ptr(path)
-        };
-        let Some(path) = path_from_cstr(path) else {
-            // TODO: complain.
-            return 0;
-        };
-
-        match plist.write_to_file(&path) {
-            Ok(_) => return 1,
-            Err(_) => {
-                // TODO: complain.
-                return 0;
-            }
-        }
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use std::ffi::CString;
-
-    use crate::memory;
-
-    use super::{Node, PropList, ffi};
-
-    #[test]
-    fn free_proplist_description() {
-        let mut plist = PropList::new(Node::Array(vec![PropList::new(Node::String(CString::from(c"hello"))),
-                                                   PropList::new(Node::String(CString::from(c"world!")))]));
-        let desc = unsafe { ffi::WMGetPropListDescription(&mut plist, 1) };
-        assert!(!desc.is_null());
-
-        unsafe { memory::ffi::wfree(desc.cast()); }
-    }
-
-    #[test]
-    fn oob_array_access_returns_null() {
-        // This is the original WMArray behavior. I don't like it, but a bunch
-        // of existing code relies on it.
-        let mut list = PropList::new(Node::Array(vec![PropList::new(Node::String(CString::from(c"hello"))),
-                                                      PropList::new(Node::String(CString::from(c"world!")))]));
-        assert!(unsafe { ffi::WMGetFromPLArray(&mut list, 3) }.is_null());
-    }
-}

wutil-rs/src/prop_list/writer.rs

@@ -1,667 +0,0 @@
-//! Rendering of [`super::PropList`]s to text.
-//!
-//! To use this module, call [`super::PropList::display_indented`] or
-//! [`super::PropList::display_unindented`].
-//!
-//! ## Rust rewrite notes
-//!
-//! This should work well enough for writing Window Maker state to disk, but it
-//! is not a perfect reimplementation of the behavior of classic WUtils PropList
-//! serialization. In particular, the WUtils hashtable has a different key
-//! iteration order than Rust's `HashMap`, so this library may write dictionary
-//! entries to disk in a different order.
-
-use super::{parser, Node};
-
-use std::{
-    fmt::{self, Write},
-    ops::Deref,
-};
-
-/// Maximum width for a chunk of text being rendered with `Inline::Soft` before
-/// falling back to `Inline::No`.
-const SOFT_LINEBREAK_WIDTH: usize = 77;
-
-/// Describes the line-breaking strategy for rendering a `Node`.
-#[derive(Clone, Copy, Eq, PartialEq)]
-pub(crate) enum Inline {
-    /// Do not attempt to render with no linebreaks.
-    No,
-    /// Attempt to render with no linebreaks, but fall back to `Inline::No` if
-    /// the result is too wide.
-    Soft,
-    /// Render with no linebreaks, regardless of output width.
-    Hard,
-}
-
-/// Bundles a reference to a `Node` with rendering instructions.
-pub(crate) struct Display<N: Deref<Target = Node>> {
-    /// Line-breaking strategy.
-    pub(crate) inline: Inline,
-    /// Whether to render `node` as if it is the first item on a new line.
-    pub(crate) clear_left: bool,
-    /// Indentation level to render `node` at.
-    pub(crate) indentation: u32,
-    /// Amount by which `indentation` should increase when rendering children of
-    /// `node`.
-    pub(crate) increment: u32,
-    /// The `Node` to render.
-    pub(crate) node: N,
-}
-
-impl<N: Deref<Target = Node>> Display<N> {
-    /// Writes whitespace to `f` for the current level of indentation.
-    fn write_indent(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        for _ in 0..self.indentation {
-            f.write_char(' ')?;
-        }
-        Ok(())
-    }
-}
-
-/// Writes `s` to `f`, backslash-escaping special characters as appropriate for
-/// a quoted property list string.
-fn write_escaped_string(s: &str, f: &mut fmt::Formatter) -> fmt::Result {
-    for c in s.chars() {
-        match c {
-            '\x07' => f.write_str(r#"\a"#)?,
-            '\x08' => f.write_str(r#"\b"#)?,
-            '\t' => f.write_str(r#"\t"#)?,
-            '\n' => f.write_str(r#"\n"#)?,
-            '\x0B' => f.write_str(r#"\v"#)?,
-            '\x0D' => f.write_str(r#"\f"#)?,
-            '\\' => f.write_str(r#"\\"#)?,
-            '"' => f.write_str(r#"\\""#)?,
-            c => f.write_char(c)?,
-        }
-    }
-    Ok(())
-}
-
-impl<N: Deref<Target = Node>> fmt::Display for Display<N> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        if self.clear_left {
-            writeln!(f, "")?;
-            self.write_indent(f)?;
-        }
-        match &*self.node {
-            Node::Array(items) if self.inline != Inline::No => {
-                // Try to fit everything in one line.
-                let mut buf = String::new();
-                buf.push('(');
-                let mut items = items.iter();
-                if let Some(first) = items.next() {
-                    write!(
-                        &mut buf,
-                        "{}",
-                        Display {
-                            inline: self.inline,
-                            clear_left: false,
-                            indentation: self.indentation,
-                            increment: self.increment,
-                            node: first.0.borrow(),
-                        }
-                    )?;
-                }
-                for next in items {
-                    write!(
-                        &mut buf,
-                        ", {}",
-                        Display {
-                            inline: self.inline,
-                            clear_left: false,
-                            indentation: self.indentation,
-                            increment: self.increment,
-                            node: next.0.borrow(),
-                        }
-                    )?;
-                }
-                buf.push(')');
-                if self.inline == Inline::Soft && buf.chars().count() > SOFT_LINEBREAK_WIDTH {
-                    write!(
-                        f,
-                        "{}",
-                        Display {
-                            inline: Inline::No,
-                            clear_left: false,
-                            indentation: self.indentation,
-                            increment: self.increment,
-                            node: &*self.node,
-                        }
-                    )?;
-                } else {
-                    f.write_str(&buf)?;
-                }
-            }
-            Node::Array(items) if items.is_empty() => f.write_str("()")?,
-            Node::Array(items) => {
-                f.write_char('(')?;
-                let mut items = items.iter();
-                if let Some(first) = items.next() {
-                    write!(
-                        f,
-                        "{}",
-                        Display {
-                            inline: Inline::Soft,
-                            clear_left: true,
-                            indentation: self.indentation + self.increment,
-                            increment: self.increment,
-                            node: first.0.borrow(),
-                        }
-                    )?;
-                }
-                for next in items {
-                    f.write_char(',')?;
-                    write!(
-                        f,
-                        "{}",
-                        Display {
-                            inline: Inline::Soft,
-                            clear_left: true,
-                            indentation: self.indentation + self.increment,
-                            increment: self.increment,
-                            node: next.0.borrow(),
-                        }
-                    )?;
-                }
-                writeln!(f, "")?;
-                self.write_indent(f)?;
-                f.write_char(')')?;
-            }
-            Node::Dictionary(items) if items.is_empty() => write!(f, "{{}}")?,
-            Node::Dictionary(items) if self.inline != Inline::No => {
-                // Try to fit everything in one line.
-                let mut buf = String::new();
-                buf.push('{');
-                for (k, v) in items {
-                    write!(
-                        &mut buf,
-                        " {} = {};",
-                        Display {
-                            inline: self.inline,
-                            clear_left: false,
-                            indentation: self.indentation,
-                            increment: self.increment,
-                            node: k.0.borrow(),
-                        },
-                        Display {
-                            inline: self.inline,
-                            clear_left: false,
-                            indentation: self.indentation,
-                            increment: self.increment,
-                            node: v.0.borrow(),
-                        }
-                    )?;
-                }
-                write!(&mut buf, " }}")?;
-                if self.inline == Inline::Soft && buf.chars().count() > SOFT_LINEBREAK_WIDTH {
-                    write!(
-                        f,
-                        "{}",
-                        Display {
-                            inline: Inline::No,
-                            clear_left: false,
-                            indentation: self.indentation,
-                            increment: self.increment,
-                            node: &*self.node,
-                        }
-                    )?;
-                } else {
-                    f.write_str(&buf)?;
-                }
-            }
-            Node::Dictionary(items) => {
-                write!(f, "{{")?;
-                for (k, v) in items {
-                    write!(
-                        f,
-                        "{} = {};",
-                        Display {
-                            inline: Inline::Soft,
-                            clear_left: true,
-                            indentation: self.indentation + self.increment,
-                            increment: self.increment,
-                            node: k.0.borrow(),
-                        },
-                        Display {
-                            inline: Inline::Soft,
-                            clear_left: false,
-                            indentation: self.indentation + self.increment,
-                            increment: self.increment,
-                            node: v.0.borrow(),
-                        }
-                    )?;
-                }
-                writeln!(f, "")?;
-                self.write_indent(f)?;
-                f.write_char('}')?;
-            }
-            Node::String(s) => {
-                let mut unquoted = !s.is_empty();
-                for c in s.as_bytes() {
-                    if !parser::is_unquoted_char(*c as char) {
-                        unquoted = false;
-                        break;
-                    }
-                }
-                if unquoted {
-                    write!(f, "{}", s.to_string_lossy())?;
-                } else {
-                    f.write_char('"')?;
-                    write_escaped_string(&s.to_string_lossy(), f)?;
-                    f.write_char('"')?;
-                }
-            }
-        }
-        Ok(())
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use crate::prop_list::{Node, PropList};
-
-    use std::ffi::CString;
-
-    fn pl_array(xs: Vec<PropList>) -> PropList {
-        PropList::new(Node::Array(xs))
-    }
-
-    fn pl_string(s: &str) -> PropList {
-        PropList::new(Node::String(CString::new(s.as_bytes()).unwrap()))
-    }
-
-    #[test]
-    fn write_empty_string() {
-        let serialized = format!("{:?}", pl_string(""));
-        assert_eq!(serialized, r#""""#);
-    }
-
-    #[test]
-    fn write_unquoted_string() {
-        let serialized = format!("{:?}", pl_string("hello"));
-        assert_eq!(serialized, r#"hello"#);
-    }
-
-    #[test]
-    fn write_quoted_string() {
-        let serialized = format!("{:?}", pl_string("hello, world!"));
-        assert_eq!(serialized, r#""hello, world!""#);
-    }
-
-    #[test]
-    fn write_flat_array() {
-        let serialized = format!(
-            "{:?}",
-            pl_array(vec![pl_string("hello"), pl_string("world")])
-        );
-        assert_eq!(serialized, r#"(hello, world)"#);
-    }
-
-    #[test]
-    fn write_empty_array() {
-        let serialized = format!("{:?}", pl_array(vec![]));
-        assert_eq!(serialized, r#"()"#);
-    }
-
-    #[test]
-    fn write_nested_array() {
-        let serialized = format!(
-            "{:?}",
-            pl_array(vec![
-                pl_array(vec![pl_string("hello"), pl_string("world")]),
-                pl_string("baz"),
-                pl_string("quux plugh")
-            ])
-        );
-        assert_eq!(serialized, r#"((hello, world), baz, "quux plugh")"#);
-    }
-
-    #[test]
-    fn write_long_nested_array() {
-        let serialized = format!(
-            "{:?}",
-            pl_array(vec![
-                pl_array(vec![pl_string("hello"), pl_string("world")]),
-                pl_string("baz"),
-                pl_string("quux plugh"),
-                pl_string("etc"),
-                pl_array(vec![
-                    pl_string("lots"),
-                    pl_string("of"),
-                    pl_string("words"),
-                    pl_string("go"),
-                    pl_array(vec![
-                        pl_string("here"),
-                        pl_string("and"),
-                        pl_string("stuff"),
-                        pl_string("blah"),
-                        pl_string("blah"),
-                        pl_string("blah"),
-                    ])
-                ])
-            ])
-        );
-        assert_eq!(
-            serialized,
-            r#"(
-  (hello, world),
-  baz,
-  "quux plugh",
-  etc,
-  (lots, of, words, go, (here, and, stuff, blah, blah, blah))
-)"#
-        );
-    }
-
-    #[test]
-    fn roundtrip_wm_state() {
-        let original = r#"{
-  Dock = {
-    AutoRaiseLower = No;
-    Applications = (
-      {
-        Forced = No;
-        Name = Logo.WMDock;
-        BuggyApplication = No;
-        AutoLaunch = No;
-        Position = "0,0";
-        Lock = Yes;
-        Command = "/usr/bin/WPrefs";
-      },
-      {
-        Forced = No;
-        Name = wmweather.wmweather;
-        DropCommand = "wmweather -s KBOS %d";
-        BuggyApplication = No;
-        AutoLaunch = Yes;
-        Position = "0,4";
-        Lock = Yes;
-        PasteCommand = "wmweather -s KBOS %s";
-        Command = "wmweather -s KBOS";
-      },
-      {
-        Forced = No;
-        Name = wmclock.WMClock;
-        DropCommand = "wmclock %d";
-        BuggyApplication = No;
-        AutoLaunch = Yes;
-        Position = "0,3";
-        Lock = Yes;
-        PasteCommand = "wmclock %s";
-        Command = wmclock;
-      },
-      {
-        Forced = No;
-        Name = emacs.Emacs;
-        DropCommand = "emacsclient -c %d";
-        BuggyApplication = No;
-        AutoLaunch = No;
-        Position = "0,2";
-        Lock = Yes;
-        PasteCommand = "emacsclient -c %s";
-        Command = "emacsclient -";
-      },
-      {
-        Forced = No;
-        Name = wmfire.wmfire;
-        DropCommand = "wmfire -m %d";
-        BuggyApplication = No;
-        AutoLaunch = Yes;
-        Position = "0,5";
-        Lock = Yes;
-        PasteCommand = "wmfire -m %s";
-        Command = "wmfire -m";
-      },
-      {
-        Forced = No;
-        Name = wmnet.WMNET;
-        DropCommand = "wmnet -W enp0s31f6 %d";
-        BuggyApplication = No;
-        AutoLaunch = Yes;
-        Position = "0,7";
-        Lock = Yes;
-        PasteCommand = "wmnet -W enp0s31f6 %s";
-        Command = "wmnet -W enp0s31f6";
-      },
-      {
-        Forced = No;
-        Name = wmtemp.DockApp;
-        DropCommand = "wmtemp -f %d";
-        BuggyApplication = No;
-        AutoLaunch = Yes;
-        Position = "0,6";
-        Lock = Yes;
-        PasteCommand = "wmtemp -f %s";
-        Command = "wmtemp -f";
-      },
-      {
-        Forced = No;
-        Name = firefox.Firefox;
-        DropCommand = "firefox %d";
-        BuggyApplication = No;
-        AutoLaunch = No;
-        Position = "0,1";
-        Lock = Yes;
-        PasteCommand = "firefox %s";
-        Command = firefox;
-      },
-      {
-        Forced = No;
-        Name = "org\\.gnome\\.Weather.org\\.gnome\\.Weather";
-        DropCommand = "org.gnome.Weather %d";
-        BuggyApplication = No;
-        AutoLaunch = No;
-        Position = "0,8";
-        Lock = Yes;
-        PasteCommand = "org.gnome.Weather %s";
-        Command = "/usr/bin/gnome-weather";
-      },
-      {
-        Forced = No;
-        Name = Zotero.Zotero;
-        DropCommand = "/home/stu/bin/zotero %d";
-        BuggyApplication = No;
-        AutoLaunch = No;
-        Position = "0,9";
-        Lock = Yes;
-        PasteCommand = "/home/stu/bin/zotero %s";
-        Command = "/home/stu/bin/zotero";
-      }
-    );
-    Lowered = Yes;
-    Position = "2496,0";
-    Applications1440 = (
-      {
-        Forced = No;
-        Name = Logo.WMDock;
-        BuggyApplication = No;
-        AutoLaunch = No;
-        Position = "0,0";
-        Lock = Yes;
-        Command = "/usr/bin/WPrefs";
-      },
-      {
-        Forced = No;
-        Name = wmweather.wmweather;
-        DropCommand = "wmweather -s KBOS %d";
-        BuggyApplication = No;
-        AutoLaunch = Yes;
-        Position = "0,4";
-        Lock = Yes;
-        PasteCommand = "wmweather -s KBOS %s";
-        Command = "wmweather -s KBOS";
-      },
-      {
-        Forced = No;
-        Name = wmclock.WMClock;
-        DropCommand = "wmclock %d";
-        BuggyApplication = No;
-        AutoLaunch = Yes;
-        Position = "0,3";
-        Lock = Yes;
-        PasteCommand = "wmclock %s";
-        Command = wmclock;
-      },
-      {
-        Forced = No;
-        Name = emacs.Emacs;
-        DropCommand = "emacsclient -c %d";
-        BuggyApplication = No;
-        AutoLaunch = No;
-        Position = "0,2";
-        Lock = Yes;
-        PasteCommand = "emacsclient -c %s";
-        Command = "emacsclient -";
-      },
-      {
-        Forced = No;
-        Name = wmfire.wmfire;
-        DropCommand = "wmfire -m %d";
-        BuggyApplication = No;
-        AutoLaunch = Yes;
-        Position = "0,5";
-        Lock = Yes;
-        PasteCommand = "wmfire -m %s";
-        Command = "wmfire -m";
-      },
-      {
-        Forced = No;
-        Name = wmnet.WMNET;
-        DropCommand = "wmnet -W enp0s31f6 %d";
-        BuggyApplication = No;
-        AutoLaunch = Yes;
-        Position = "0,7";
-        Lock = Yes;
-        PasteCommand = "wmnet -W enp0s31f6 %s";
-        Command = "wmnet -W enp0s31f6";
-      },
-      {
-        Forced = No;
-        Name = wmtemp.DockApp;
-        DropCommand = "wmtemp -f %d";
-        BuggyApplication = No;
-        AutoLaunch = Yes;
-        Position = "0,6";
-        Lock = Yes;
-        PasteCommand = "wmtemp -f %s";
-        Command = "wmtemp -f";
-      },
-      {
-        Forced = No;
-        Name = firefox.Firefox;
-        DropCommand = "firefox %d";
-        BuggyApplication = No;
-        AutoLaunch = No;
-        Position = "0,1";
-        Lock = Yes;
-        PasteCommand = "firefox %s";
-        Command = firefox;
-      },
-      {
-        Forced = No;
-        Name = "org\\.gnome\\.Weather.org\\.gnome\\.Weather";
-        DropCommand = "org.gnome.Weather %d";
-        BuggyApplication = No;
-        AutoLaunch = No;
-        Position = "0,8";
-        Lock = Yes;
-        PasteCommand = "org.gnome.Weather %s";
-        Command = "/usr/bin/gnome-weather";
-      },
-      {
-        Forced = No;
-        Name = Zotero.Zotero;
-        DropCommand = "/home/stu/bin/zotero %d";
-        BuggyApplication = No;
-        AutoLaunch = No;
-        Position = "0,9";
-        Lock = Yes;
-        PasteCommand = "/home/stu/bin/zotero %s";
-        Command = "/home/stu/bin/zotero";
-      }
-    );
-  };
-  Clip = {
-    Forced = No;
-    Name = Logo.WMClip;
-    DropCommand = "wmsetbg -u -t %d";
-    BuggyApplication = No;
-    AutoLaunch = No;
-    Position = "2496,1376";
-    Lock = No;
-    Command = "-";
-  };
-  Drawers = ();
-  Workspaces = (
-    {
-      Clip = {
-        AutoRaiseLower = No;
-        AutoCollapse = No;
-        Applications = (
-          {
-            Forced = No;
-            Name = xsnow.Xsnow;
-            DropCommand = "xsnow %d";
-            BuggyApplication = No;
-            AutoLaunch = No;
-            Position = "-2,0";
-            Lock = No;
-            PasteCommand = "xsnow %s";
-            Command = xsnow;
-            Omnipresent = No;
-          },
-          {
-            Forced = No;
-            Name = "thunderbird.Thunderbird-default";
-            DropCommand = "thunderbird %d";
-            BuggyApplication = No;
-            AutoLaunch = No;
-            Position = "-1,0";
-            Lock = No;
-            PasteCommand = "thunderbird %s";
-            Command = thunderbird;
-            Omnipresent = No;
-          }
-        );
-        Collapsed = No;
-        AutoAttractIcons = No;
-        Lowered = Yes;
-      };
-      Name = Mail;
-    },
-    {
-      Clip = {
-        AutoRaiseLower = No;
-        AutoCollapse = No;
-        Applications = ();
-        Collapsed = No;
-        AutoAttractIcons = No;
-        Lowered = Yes;
-      };
-      Name = Plans;
-    },
-    {
-      Clip = {
-        AutoRaiseLower = No;
-        AutoCollapse = No;
-        Applications = ();
-        Collapsed = No;
-        AutoAttractIcons = No;
-        Lowered = Yes;
-      };
-      Name = Misc;
-    },
-  );
-}"#;
-
-        // We do (original serialized) -> plist -> (serialized) -> plist and
-        // compare the two plists because Rust's hashtable ordering (which is
-        // reflected in the serialized output) does not match the original
-        // WUtils hashtable ordering.
-        let original_plist = super::parser::from_str(original).unwrap();
-        let serialized = format!("{}", original_plist.display_indented());
-        let deserialized = super::parser::from_str(&serialized).unwrap();
-        assert_eq!(original_plist, deserialized);
-    }
-}