
#include <string.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <ctype.h>

#include "WUtil.h"
#include "wconfig.h"

typedef enum {
	WPLString = 0x57504c01,
	WPLData = 0x57504c02,
	WPLArray = 0x57504c03,
	WPLDictionary = 0x57504c04
} WPLType;

typedef struct W_PropList {
	WPLType type;

	union {
		char *string;
		WMData *data;
		WMArray *array;
		WMHashTable *dict;
	} d;

	int retainCount;
} W_PropList;

typedef struct PLData {
	char *ptr;
	int pos;
	char *filename;
	int lineNumber;
} PLData;

typedef struct StringBuffer {
	char *str;
	int size;
} StringBuffer;

static unsigned hashPropList(WMPropList * plist);
static WMPropList *getPLString(PLData * pldata);
static WMPropList *getPLQString(PLData * pldata);
static WMPropList *getPLData(PLData * pldata);
static WMPropList *getPLArray(PLData * pldata);
static WMPropList *getPLDictionary(PLData * pldata);
static WMPropList *getPropList(PLData * pldata);

typedef unsigned (*hashFunc) (const void *);
typedef Bool(*isEqualFunc) (const void *, const void *);
typedef void *(*retainFunc) (const void *);
typedef void (*releaseFunc) (const void *);

static const WMHashTableCallbacks WMPropListHashCallbacks = {
	(hashFunc) hashPropList,
	(isEqualFunc) WMIsPropListEqualTo,
	(retainFunc) NULL,
	(releaseFunc) NULL
};

static Bool caseSensitive = True;

#define BUFFERSIZE           8192
#define BUFFERSIZE_INCREMENT 1024

#if 0
# define DPUT(s) puts(s)
#else
# define DPUT(s)
#endif

#define COMPLAIN(pld, msg) wwarning(_("syntax error in %s %s, line %i: %s"),\
    (pld)->filename ? "file" : "PropList",\
    (pld)->filename ? (pld)->filename : "description",\
    (pld)->lineNumber, msg)

#define ISSTRINGABLE(c) (isalnum(c) || (c)=='.' || (c)=='_' || (c)=='/' \
    || (c)=='+')

#define CHECK_BUFFER_SIZE(buf, ptr) \
    if ((ptr) >= (buf).size-1) {\
    (buf).size += BUFFERSIZE_INCREMENT;\
    (buf).str = wrealloc((buf).str, (buf).size);\
    }

#define inrange(ch, min, max) ((ch)>=(min) && (ch)<=(max))
#define noquote(ch) (inrange(ch, 'a', 'z') || inrange(ch, 'A', 'Z') || inrange(ch, '0', '9') || ((ch)=='_') || ((ch)=='.') || ((ch)=='$'))
#define charesc(ch) (inrange(ch, 0x07, 0x0c) || ((ch)=='"') || ((ch)=='\\'))
#define numesc(ch) (((ch)<=0x06) || inrange(ch, 0x0d, 0x1f) || ((ch)>0x7e))
#define ishexdigit(ch) (inrange(ch, 'a', 'f') || inrange(ch, 'A', 'F') || inrange(ch, '0', '9'))
#define char2num(ch) (inrange(ch,'0','9') ? ((ch)-'0') : (inrange(ch,'a','f') ? ((ch)-0x57) : ((ch)-0x37)))
#define num2char(num) ((num) < 0xa ? ((num)+'0') : ((num)+0x57))

#define MaxHashLength 64

static unsigned hashPropList(WMPropList * plist)
{
	unsigned ret = 0;
	unsigned ctr = 0;
	const char *key;
	int i, len;

	switch (plist->type) {
	case WPLString:
		key = plist->d.string;
		len = WMIN(strlen(key), MaxHashLength);
		for (i = 0; i < len; i++) {
			ret ^= tolower(key[i]) << ctr;
			ctr = (ctr + 1) % sizeof(char *);
		}
		/*while (*key) {
		   ret ^= tolower(*key++) << ctr;
		   ctr = (ctr + 1) % sizeof (char *);
		   } */
		break;

	case WPLData:
		key = WMDataBytes(plist->d.data);
		len = WMIN(WMGetDataLength(plist->d.data), MaxHashLength);
		for (i = 0; i < len; i++) {
			ret ^= key[i] << ctr;
			ctr = (ctr + 1) % sizeof(char *);
		}
		break;

	default:
		wwarning(_("Only string or data is supported for a proplist dictionary key"));
		wassertrv(False, 0);
		break;
	}

	return ret;
}

static WMPropList *retainPropListByCount(WMPropList * plist, int count)
{
	WMPropList *key, *value;
	WMHashEnumerator e;
	int i;

	plist->retainCount += count;

	switch (plist->type) {
	case WPLString:
	case WPLData:
		break;
	case WPLArray:
		for (i = 0; i < WMGetArrayItemCount(plist->d.array); i++) {
			retainPropListByCount(WMGetFromArray(plist->d.array, i), count);
		}
		break;
	case WPLDictionary:
		e = WMEnumerateHashTable(plist->d.dict);
		while (WMNextHashEnumeratorItemAndKey(&e, (void **)&value, (void **)&key)) {
			retainPropListByCount(key, count);
			retainPropListByCount(value, count);
		}
		break;
	default:
		wwarning(_("Used proplist functions on non-WMPropLists objects"));
		wassertrv(False, NULL);
		break;
	}

	return plist;
}

static void releasePropListByCount(WMPropList * plist, int count)
{
	WMPropList *key, *value;
	WMHashEnumerator e;
	int i;

	plist->retainCount -= count;

	switch (plist->type) {
	case WPLString:
		if (plist->retainCount < 1) {
			wfree(plist->d.string);
			wfree(plist);
		}
		break;
	case WPLData:
		if (plist->retainCount < 1) {
			WMReleaseData(plist->d.data);
			wfree(plist);
		}
		break;
	case WPLArray:
		for (i = 0; i < WMGetArrayItemCount(plist->d.array); i++) {
			releasePropListByCount(WMGetFromArray(plist->d.array, i), count);
		}
		if (plist->retainCount < 1) {
			WMFreeArray(plist->d.array);
			wfree(plist);
		}
		break;
	case WPLDictionary:
		e = WMEnumerateHashTable(plist->d.dict);
		while (WMNextHashEnumeratorItemAndKey(&e, (void **)&value, (void **)&key)) {
			releasePropListByCount(key, count);
			releasePropListByCount(value, count);
		}
		if (plist->retainCount < 1) {
			WMFreeHashTable(plist->d.dict);
			wfree(plist);
		}
		break;
	default:
		wwarning(_("Used proplist functions on non-WMPropLists objects"));
		wassertr(False);
		break;
	}
}

static char *dataDescription(WMPropList * plist)
{
	const unsigned char *data;
	char *retVal;
	int i, j, length;

	data = WMDataBytes(plist->d.data);
	length = WMGetDataLength(plist->d.data);

	retVal = (char *)wmalloc(2 * length + length / 4 + 3);

	retVal[0] = '<';
	for (i = 0, j = 1; i < length; i++) {
		retVal[j++] = num2char((data[i] >> 4) & 0x0f);
		retVal[j++] = num2char(data[i] & 0x0f);
		if ((i & 0x03) == 3 && i != length - 1) {
			/* if we've just finished a 32-bit int, add a space */
			retVal[j++] = ' ';
		}
	}
	retVal[j++] = '>';
	retVal[j] = '\0';

	return retVal;
}

static char *stringDescription(WMPropList * plist)
{
	const char *str;
	char *retVal, *sPtr, *dPtr;
	int len, quote;
	unsigned char ch;

	str = plist->d.string;

	if (strlen(str) == 0) {
		return wstrdup("\"\"");
	}

	/* FIXME: make this work with unichars. */

	quote = 0;
	sPtr = (char *)str;
	len = 0;
	while ((ch = *sPtr)) {
		if (!noquote(ch)) {
			quote = 1;
			if (charesc(ch))
				len++;
			else if (numesc(ch))
				len += 3;
		}
		sPtr++;
		len++;
	}

	if (quote)
		len += 2;

	retVal = (char *)wmalloc(len + 1);

	sPtr = (char *)str;
	dPtr = retVal;

	if (quote)
		*dPtr++ = '"';

	while ((ch = *sPtr)) {
		if (charesc(ch)) {
			*(dPtr++) = '\\';
			switch (ch) {
			case '\a':
				*dPtr = 'a';
				break;
			case '\b':
				*dPtr = 'b';
				break;
			case '\t':
				*dPtr = 't';
				break;
			case '\n':
				*dPtr = 'n';
				break;
			case '\v':
				*dPtr = 'v';
				break;
			case '\f':
				*dPtr = 'f';
				break;
			default:
				*dPtr = ch;	/* " or \ */
			}
		} else if (numesc(ch)) {
			*(dPtr++) = '\\';
			*(dPtr++) = '0' + ((ch >> 6) & 07);
			*(dPtr++) = '0' + ((ch >> 3) & 07);
			*dPtr = '0' + (ch & 07);
		} else {
			*dPtr = ch;
		}
		sPtr++;
		dPtr++;
	}

	if (quote)
		*dPtr++ = '"';

	*dPtr = '\0';

	return retVal;
}

static char *description(WMPropList * plist)
{
	WMPropList *key, *val;
	char *retstr = NULL;
	char *str, *tmp, *skey, *sval;
	WMHashEnumerator e;
	int i;

	switch (plist->type) {
	case WPLString:
		retstr = stringDescription(plist);
		break;
	case WPLData:
		retstr = dataDescription(plist);
		break;
	case WPLArray:
		retstr = wstrdup("(");
		for (i = 0; i < WMGetArrayItemCount(plist->d.array); i++) {
			str = description(WMGetFromArray(plist->d.array, i));
			if (i == 0) {
				retstr = wstrappend(retstr, str);
			} else {
				tmp = (char *)wmalloc(strlen(retstr) + strlen(str) + 3);
				sprintf(tmp, "%s, %s", retstr, str);
				wfree(retstr);
				retstr = tmp;
			}
			wfree(str);
		}
		retstr = wstrappend(retstr, ")");
		break;
	case WPLDictionary:
		retstr = wstrdup("{");
		e = WMEnumerateHashTable(plist->d.dict);
		while (WMNextHashEnumeratorItemAndKey(&e, (void **)&val, (void **)&key)) {
			skey = description(key);
			sval = description(val);
			tmp = (char *)wmalloc(strlen(retstr) + strlen(skey) + strlen(sval) + 5);
			sprintf(tmp, "%s%s = %s;", retstr, skey, sval);
			wfree(skey);
			wfree(sval);
			wfree(retstr);
			retstr = tmp;
		}
		retstr = wstrappend(retstr, "}");
		break;
	default:
		wwarning(_("Used proplist functions on non-WMPropLists objects"));
		wassertrv(False, NULL);
		break;
	}

	return retstr;
}

static char *indentedDescription(WMPropList * plist, int level)
{
	WMPropList *key, *val;
	char *retstr = NULL;
	char *str, *tmp, *skey, *sval;
	WMHashEnumerator e;
	int i;

	if (plist->type == WPLArray /* || plist->type==WPLDictionary */ ) {
		retstr = description(plist);

		if (retstr && ((2 * (level + 1) + strlen(retstr)) <= 77)) {
			return retstr;
		} else if (retstr) {
			wfree(retstr);
			retstr = NULL;
		}
	}

	switch (plist->type) {
	case WPLString:
		retstr = stringDescription(plist);
		break;
	case WPLData:
		retstr = dataDescription(plist);
		break;
	case WPLArray:
		retstr = wstrdup("(\n");
		for (i = 0; i < WMGetArrayItemCount(plist->d.array); i++) {
			str = indentedDescription(WMGetFromArray(plist->d.array, i), level + 1);
			if (i == 0) {
				tmp = (char *)wmalloc(2 * (level + 1) + strlen(retstr) + strlen(str) + 1);
				sprintf(tmp, "%s%*s%s", retstr, 2 * (level + 1), "", str);
				wfree(retstr);
				retstr = tmp;
			} else {
				tmp = (char *)wmalloc(2 * (level + 1) + strlen(retstr) + strlen(str) + 3);
				sprintf(tmp, "%s,\n%*s%s", retstr, 2 * (level + 1), "", str);
				wfree(retstr);
				retstr = tmp;
			}
			wfree(str);
		}
		tmp = (char *)wmalloc(strlen(retstr) + 2 * level + 3);
		sprintf(tmp, "%s\n%*s)", retstr, 2 * level, "");
		wfree(retstr);
		retstr = tmp;
		break;
	case WPLDictionary:
		retstr = wstrdup("{\n");
		e = WMEnumerateHashTable(plist->d.dict);
		while (WMNextHashEnumeratorItemAndKey(&e, (void **)&val, (void **)&key)) {
			skey = indentedDescription(key, level + 1);
			sval = indentedDescription(val, level + 1);
			tmp = (char *)wmalloc(2 * (level + 1) + strlen(retstr) + strlen(skey)
					      + strlen(sval) + 6);
			sprintf(tmp, "%s%*s%s = %s;\n", retstr, 2 * (level + 1), "", skey, sval);
			wfree(skey);
			wfree(sval);
			wfree(retstr);
			retstr = tmp;
		}
		tmp = (char *)wmalloc(strlen(retstr) + 2 * level + 2);
		sprintf(tmp, "%s%*s}", retstr, 2 * level, "");
		wfree(retstr);
		retstr = tmp;
		break;
	default:
		wwarning(_("Used proplist functions on non-WMPropLists objects"));
		wassertrv(False, NULL);
		break;
	}

	return retstr;
}

static INLINE int getChar(PLData * pldata)
{
	int c;

	c = pldata->ptr[pldata->pos];
	if (c == 0) {
		return 0;
	}

	pldata->pos++;

	if (c == '\n')
		pldata->lineNumber++;

	return c;
}

static INLINE int getNonSpaceChar(PLData * pldata)
{
	int c;

	while (1) {
		c = pldata->ptr[pldata->pos];
		if (c == 0) {
			break;
		}
		pldata->pos++;
		if (c == '\n') {
			pldata->lineNumber++;
		} else if (!isspace(c)) {
			break;
		}
	}

	return c;
}

static char *unescapestr(char *src)
{
	char *dest = wmalloc(strlen(src) + 1);
	char *sPtr, *dPtr;
	char ch;

	for (sPtr = src, dPtr = dest; *sPtr; sPtr++, dPtr++) {
		if (*sPtr != '\\') {
			*dPtr = *sPtr;
		} else {
			ch = *(++sPtr);
			if ((ch >= '0') && (ch <= '3')) {
				/* assume next 2 chars are octal too */
				*dPtr = ((ch & 07) << 6);
				*dPtr |= ((*(++sPtr) & 07) << 3);
				*dPtr |= *(++sPtr) & 07;
			} else {
				switch (ch) {
				case 'a':
					*dPtr = '\a';
					break;
				case 'b':
					*dPtr = '\b';
					break;
				case 't':
					*dPtr = '\t';
					break;
				case 'r':
					*dPtr = '\r';
					break;
				case 'n':
					*dPtr = '\n';
					break;
				case 'v':
					*dPtr = '\v';
					break;
				case 'f':
					*dPtr = '\f';
					break;
				default:
					*dPtr = *sPtr;
				}
			}
		}
	}

	*dPtr = 0;

	return dest;
}

static WMPropList *getPLString(PLData * pldata)
{
	WMPropList *plist;
	StringBuffer sBuf;
	int ptr = 0;
	int c;

	sBuf.str = wmalloc(BUFFERSIZE);
	sBuf.size = BUFFERSIZE;

	while (1) {
		c = getChar(pldata);
		if (ISSTRINGABLE(c)) {
			CHECK_BUFFER_SIZE(sBuf, ptr);
			sBuf.str[ptr++] = c;
		} else {
			if (c != 0) {
				pldata->pos--;
			}
			break;
		}
	}

	sBuf.str[ptr] = 0;

	if (ptr == 0) {
		plist = NULL;
	} else {
		char *tmp = unescapestr(sBuf.str);
		plist = WMCreatePLString(tmp);
		wfree(tmp);
	}

	wfree(sBuf.str);

	return plist;
}

static WMPropList *getPLQString(PLData * pldata)
{
	WMPropList *plist;
	int ptr = 0, escaping = 0, ok = 1;
	int c;
	StringBuffer sBuf;

	sBuf.str = wmalloc(BUFFERSIZE);
	sBuf.size = BUFFERSIZE;

	while (1) {
		c = getChar(pldata);
		if (!escaping) {
			if (c == '\\') {
				escaping = 1;
				continue;
			} else if (c == '"') {
				break;
			}
		} else {
			CHECK_BUFFER_SIZE(sBuf, ptr);
			sBuf.str[ptr++] = '\\';
			escaping = 0;
		}

		if (c == 0) {
			COMPLAIN(pldata, _("unterminated PropList string"));
			ok = 0;
			break;
		} else {
			CHECK_BUFFER_SIZE(sBuf, ptr);
			sBuf.str[ptr++] = c;
		}
	}

	sBuf.str[ptr] = 0;

	if (!ok) {
		plist = NULL;
	} else {
		char *tmp = unescapestr(sBuf.str);
		plist = WMCreatePLString(tmp);
		wfree(tmp);
	}

	wfree(sBuf.str);

	return plist;
}

static WMPropList *getPLData(PLData * pldata)
{
	int ok = 1;
	int len = 0;
	int c1, c2;
	unsigned char buf[BUFFERSIZE], byte;
	WMPropList *plist;
	WMData *data;

	data = WMCreateDataWithCapacity(0);

	while (1) {
		c1 = getNonSpaceChar(pldata);
		if (c1 == 0) {
			COMPLAIN(pldata, _("unterminated PropList data"));
			ok = 0;
			break;
		} else if (c1 == '>') {
			break;
		} else if (ishexdigit(c1)) {
			c2 = getNonSpaceChar(pldata);
			if (c2 == 0 || c2 == '>') {
				COMPLAIN(pldata, _("unterminated PropList data (missing hexdigit)"));
				ok = 0;
				break;
			} else if (ishexdigit(c2)) {
				byte = char2num(c1) << 4;
				byte |= char2num(c2);
				buf[len++] = byte;
				if (len == sizeof(buf)) {
					WMAppendDataBytes(data, buf, len);
					len = 0;
				}
			} else {
				COMPLAIN(pldata, _("non hexdigit character in PropList data"));
				ok = 0;
				break;
			}
		} else {
			COMPLAIN(pldata, _("non hexdigit character in PropList data"));
			ok = 0;
			break;
		}
	}

	if (!ok) {
		WMReleaseData(data);
		return NULL;
	}

	if (len > 0)
		WMAppendDataBytes(data, buf, len);

	plist = WMCreatePLData(data);
	WMReleaseData(data);

	return plist;
}

static WMPropList *getPLArray(PLData * pldata)
{
	Bool first = True;
	int ok = 1;
	int c;
	WMPropList *array, *obj;

	array = WMCreatePLArray(NULL);

	while (1) {
		c = getNonSpaceChar(pldata);
		if (c == 0) {
			COMPLAIN(pldata, _("unterminated PropList array"));
			ok = 0;
			break;
		} else if (c == ')') {
			break;
		} else if (c == ',') {
			/* continue normally */
		} else if (!first) {
			COMPLAIN(pldata, _("missing or unterminated PropList array"));
			ok = 0;
			break;
		} else {
			pldata->pos--;
		}
		first = False;

		obj = getPropList(pldata);
		if (!obj) {
			COMPLAIN(pldata, _("could not get PropList array element"));
			ok = 0;
			break;
		}
		WMAddToPLArray(array, obj);
		WMReleasePropList(obj);
	}

	if (!ok) {
		WMReleasePropList(array);
		array = NULL;
	}

	return array;
}

static WMPropList *getPLDictionary(PLData * pldata)
{
	int ok = 1;
	int c;
	WMPropList *dict, *key, *value;

	dict = WMCreatePLDictionary(NULL, NULL);

	while (1) {
		c = getNonSpaceChar(pldata);
		if (c == 0) {
			COMPLAIN(pldata, _("unterminated PropList dictionary"));
			ok = 0;
			break;
		} else if (c == '}') {
			break;
		}

		DPUT("getting PropList dictionary key");
		if (c == '<') {
			key = getPLData(pldata);
		} else if (c == '"') {
			key = getPLQString(pldata);
		} else if (ISSTRINGABLE(c)) {
			pldata->pos--;
			key = getPLString(pldata);
		} else {
			if (c == '=') {
				COMPLAIN(pldata, _("missing PropList dictionary key"));
			} else {
				COMPLAIN(pldata, _("missing PropList dictionary entry key "
						   "or unterminated dictionary"));
			}
			ok = 0;
			break;
		}

		if (!key) {
			COMPLAIN(pldata, _("error parsing PropList dictionary key"));
			ok = 0;
			break;
		}

		c = getNonSpaceChar(pldata);
		if (c != '=') {
			WMReleasePropList(key);
			COMPLAIN(pldata, _("missing = in PropList dictionary entry"));
			ok = 0;
			break;
		}

		DPUT("getting PropList dictionary entry value for key");
		value = getPropList(pldata);
		if (!value) {
			COMPLAIN(pldata, _("error parsing PropList dictionary entry value"));
			WMReleasePropList(key);
			ok = 0;
			break;
		}

		c = getNonSpaceChar(pldata);
		if (c != ';') {
			COMPLAIN(pldata, _("missing ; in PropList dictionary entry"));
			WMReleasePropList(key);
			WMReleasePropList(value);
			ok = 0;
			break;
		}

		WMPutInPLDictionary(dict, key, value);
		WMReleasePropList(key);
		WMReleasePropList(value);
	}

	if (!ok) {
		WMReleasePropList(dict);
		dict = NULL;
	}

	return dict;
}

static WMPropList *getPropList(PLData * pldata)
{
	WMPropList *plist;
	int c;

	c = getNonSpaceChar(pldata);

	switch (c) {
	case 0:
		DPUT("End of PropList");
		plist = NULL;
		break;

	case '{':
		DPUT("Getting PropList dictionary");
		plist = getPLDictionary(pldata);
		break;

	case '(':
		DPUT("Getting PropList array");
		plist = getPLArray(pldata);
		break;

	case '<':
		DPUT("Getting PropList data");
		plist = getPLData(pldata);
		break;

	case '"':
		DPUT("Getting PropList quoted string");
		plist = getPLQString(pldata);
		break;

	default:
		if (ISSTRINGABLE(c)) {
			DPUT("Getting PropList string");
			pldata->pos--;
			plist = getPLString(pldata);
		} else {
			COMPLAIN(pldata, _("was expecting a string, data, array or "
					   "dictionary. If it's a string, try enclosing " "it with \"."));
			if (c == '#' || c == '/') {
				wwarning(_("Comments are not allowed inside WindowMaker owned" " domain files."));
			}
			plist = NULL;
		}
		break;
	}

	return plist;
}

void WMPLSetCaseSensitive(Bool caseSensitiveness)
{
	caseSensitive = caseSensitiveness;
}

WMPropList *WMCreatePLString(char *str)
{
	WMPropList *plist;

	wassertrv(str != NULL, NULL);

	plist = (WMPropList *) wmalloc(sizeof(W_PropList));

	plist->type = WPLString;
	plist->d.string = wstrdup(str);
	plist->retainCount = 1;

	return plist;
}

WMPropList *WMCreatePLData(WMData * data)
{
	WMPropList *plist;

	wassertrv(data != NULL, NULL);

	plist = (WMPropList *) wmalloc(sizeof(W_PropList));

	plist->type = WPLData;
	plist->d.data = WMRetainData(data);
	plist->retainCount = 1;

	return plist;
}

WMPropList *WMCreatePLDataWithBytes(unsigned char *bytes, unsigned int length)
{
	WMPropList *plist;

	wassertrv(bytes != NULL, NULL);

	plist = (WMPropList *) wmalloc(sizeof(W_PropList));

	plist->type = WPLData;
	plist->d.data = WMCreateDataWithBytes(bytes, length);
	plist->retainCount = 1;

	return plist;
}

WMPropList *WMCreatePLDataWithBytesNoCopy(unsigned char *bytes, unsigned int length, WMFreeDataProc * destructor)
{
	WMPropList *plist;

	wassertrv(bytes != NULL, NULL);

	plist = (WMPropList *) wmalloc(sizeof(W_PropList));

	plist->type = WPLData;
	plist->d.data = WMCreateDataWithBytesNoCopy(bytes, length, destructor);
	plist->retainCount = 1;

	return plist;
}

WMPropList *WMCreatePLArray(WMPropList * elem, ...)
{
	WMPropList *plist, *nelem;
	va_list ap;

	plist = (WMPropList *) wmalloc(sizeof(W_PropList));
	plist->type = WPLArray;
	plist->d.array = WMCreateArray(4);
	plist->retainCount = 1;

	if (!elem)
		return plist;

	WMAddToArray(plist->d.array, WMRetainPropList(elem));

	va_start(ap, elem);

	while (1) {
		nelem = va_arg(ap, WMPropList *);
		if (!nelem) {
			va_end(ap);
			return plist;
		}
		WMAddToArray(plist->d.array, WMRetainPropList(nelem));
	}
}

WMPropList *WMCreatePLDictionary(WMPropList * key, WMPropList * value, ...)
{
	WMPropList *plist, *nkey, *nvalue, *k, *v;
	va_list ap;

	plist = (WMPropList *) wmalloc(sizeof(W_PropList));
	plist->type = WPLDictionary;
	plist->d.dict = WMCreateHashTable(WMPropListHashCallbacks);
	plist->retainCount = 1;

	if (!key || !value)
		return plist;

	WMHashInsert(plist->d.dict, WMRetainPropList(key), WMRetainPropList(value));

	va_start(ap, value);

	while (1) {
		nkey = va_arg(ap, WMPropList *);
		if (!nkey) {
			va_end(ap);
			return plist;
		}
		nvalue = va_arg(ap, WMPropList *);
		if (!nvalue) {
			va_end(ap);
			return plist;
		}
		if (WMHashGetItemAndKey(plist->d.dict, nkey, (void **)&v, (void **)&k)) {
			WMHashRemove(plist->d.dict, k);
			WMReleasePropList(k);
			WMReleasePropList(v);
		}
		WMHashInsert(plist->d.dict, WMRetainPropList(nkey), WMRetainPropList(nvalue));
	}
}

WMPropList *WMRetainPropList(WMPropList * plist)
{
	WMPropList *key, *value;
	WMHashEnumerator e;
	int i;

	plist->retainCount++;

	switch (plist->type) {
	case WPLString:
	case WPLData:
		break;
	case WPLArray:
		for (i = 0; i < WMGetArrayItemCount(plist->d.array); i++) {
			WMRetainPropList(WMGetFromArray(plist->d.array, i));
		}
		break;
	case WPLDictionary:
		e = WMEnumerateHashTable(plist->d.dict);
		while (WMNextHashEnumeratorItemAndKey(&e, (void **)&value, (void **)&key)) {
			WMRetainPropList(key);
			WMRetainPropList(value);
		}
		break;
	default:
		wwarning(_("Used proplist functions on non-WMPropLists objects"));
		wassertrv(False, NULL);
		break;
	}

	return plist;
}

void WMReleasePropList(WMPropList * plist)
{
	WMPropList *key, *value;
	WMHashEnumerator e;
	int i;

	plist->retainCount--;

	switch (plist->type) {
	case WPLString:
		if (plist->retainCount < 1) {
			wfree(plist->d.string);
			wfree(plist);
		}
		break;
	case WPLData:
		if (plist->retainCount < 1) {
			WMReleaseData(plist->d.data);
			wfree(plist);
		}
		break;
	case WPLArray:
		for (i = 0; i < WMGetArrayItemCount(plist->d.array); i++) {
			WMReleasePropList(WMGetFromArray(plist->d.array, i));
		}
		if (plist->retainCount < 1) {
			WMFreeArray(plist->d.array);
			wfree(plist);
		}
		break;
	case WPLDictionary:
		e = WMEnumerateHashTable(plist->d.dict);
		while (WMNextHashEnumeratorItemAndKey(&e, (void **)&value, (void **)&key)) {
			WMReleasePropList(key);
			WMReleasePropList(value);
		}
		if (plist->retainCount < 1) {
			WMFreeHashTable(plist->d.dict);
			wfree(plist);
		}
		break;
	default:
		wwarning(_("Used proplist functions on non-WMPropLists objects"));
		wassertr(False);
		break;
	}
}

void WMInsertInPLArray(WMPropList * plist, int index, WMPropList * item)
{
	wassertr(plist->type == WPLArray);

	retainPropListByCount(item, plist->retainCount);
	WMInsertInArray(plist->d.array, index, item);
}

void WMAddToPLArray(WMPropList * plist, WMPropList * item)
{
	wassertr(plist->type == WPLArray);

	retainPropListByCount(item, plist->retainCount);
	WMAddToArray(plist->d.array, item);
}

void WMDeleteFromPLArray(WMPropList * plist, int index)
{
	WMPropList *item;

	wassertr(plist->type == WPLArray);

	item = WMGetFromArray(plist->d.array, index);
	if (item != NULL) {
		WMDeleteFromArray(plist->d.array, index);
		releasePropListByCount(item, plist->retainCount);
	}
}

void WMRemoveFromPLArray(WMPropList * plist, WMPropList * item)
{
	WMPropList *iPtr;
	int i;

	wassertr(plist->type == WPLArray);

	for (i = 0; i < WMGetArrayItemCount(plist->d.array); i++) {
		iPtr = WMGetFromArray(plist->d.array, i);
		if (WMIsPropListEqualTo(item, iPtr)) {
			WMDeleteFromArray(plist->d.array, i);
			releasePropListByCount(iPtr, plist->retainCount);
			break;
		}
	}
}

void WMPutInPLDictionary(WMPropList * plist, WMPropList * key, WMPropList * value)
{
	wassertr(plist->type == WPLDictionary);

	/*WMRetainPropList(key); */
	WMRemoveFromPLDictionary(plist, key);
	retainPropListByCount(key, plist->retainCount);
	retainPropListByCount(value, plist->retainCount);
	WMHashInsert(plist->d.dict, key, value);
	/*WMReleasePropList(key); */
}

void WMRemoveFromPLDictionary(WMPropList * plist, WMPropList * key)
{
	WMPropList *k, *v;

	wassertr(plist->type == WPLDictionary);

	if (WMHashGetItemAndKey(plist->d.dict, key, (void **)&v, (void **)&k)) {
		WMHashRemove(plist->d.dict, k);
		releasePropListByCount(k, plist->retainCount);
		releasePropListByCount(v, plist->retainCount);
	}
}

WMPropList *WMMergePLDictionaries(WMPropList * dest, WMPropList * source, Bool recursive)
{
	WMPropList *key, *value, *dvalue;
	WMHashEnumerator e;

	wassertr(source->type == WPLDictionary && dest->type == WPLDictionary);

	if (source == dest)
		return dest;

	e = WMEnumerateHashTable(source->d.dict);
	while (WMNextHashEnumeratorItemAndKey(&e, (void **)&value, (void **)&key)) {
		if (recursive && value->type == WPLDictionary) {
			dvalue = WMHashGet(dest->d.dict, key);
			if (dvalue && dvalue->type == WPLDictionary) {
				WMMergePLDictionaries(dvalue, value, True);
			} else {
				WMPutInPLDictionary(dest, key, value);
			}
		} else {
			WMPutInPLDictionary(dest, key, value);
		}
	}

	return dest;
}

WMPropList *WMSubtractPLDictionaries(WMPropList * dest, WMPropList * source, Bool recursive)
{
	WMPropList *key, *value, *dvalue;
	WMHashEnumerator e;

	wassertr(source->type == WPLDictionary && dest->type == WPLDictionary);

	if (source == dest) {
		WMPropList *keys = WMGetPLDictionaryKeys(dest);
		int i;

		for (i = 0; i < WMGetArrayItemCount(keys->d.array); i++) {
			WMRemoveFromPLDictionary(dest, WMGetFromArray(keys->d.array, i));
		}
		return dest;
	}

	e = WMEnumerateHashTable(source->d.dict);
	while (WMNextHashEnumeratorItemAndKey(&e, (void **)&value, (void **)&key)) {
		dvalue = WMHashGet(dest->d.dict, key);
		if (!dvalue)
			continue;
		if (WMIsPropListEqualTo(value, dvalue)) {
			WMRemoveFromPLDictionary(dest, key);
		} else if (recursive && value->type == WPLDictionary && dvalue->type == WPLDictionary) {
			WMSubtractPLDictionaries(dvalue, value, True);
		}
	}

	return dest;
}

int WMGetPropListItemCount(WMPropList * plist)
{
	switch (plist->type) {
	case WPLString:
	case WPLData:
		return 0;	/* should this be 1 instead? */
	case WPLArray:
		return WMGetArrayItemCount(plist->d.array);
	case WPLDictionary:
		return (int)WMCountHashTable(plist->d.dict);
	default:
		wwarning(_("Used proplist functions on non-WMPropLists objects"));
		wassertrv(False, 0);
		break;
	}

	return 0;
}

Bool WMIsPLString(WMPropList * plist)
{
	return (plist->type == WPLString);
}

Bool WMIsPLData(WMPropList * plist)
{
	return (plist->type == WPLData);
}

Bool WMIsPLArray(WMPropList * plist)
{
	return (plist->type == WPLArray);
}

Bool WMIsPLDictionary(WMPropList * plist)
{
	return (plist->type == WPLDictionary);
}

Bool WMIsPropListEqualTo(WMPropList * plist, WMPropList * other)
{
	WMPropList *key1, *item1, *item2;
	WMHashEnumerator enumerator;
	int n, i;

	if (plist->type != other->type)
		return False;

	switch (plist->type) {
	case WPLString:
		if (caseSensitive) {
			return (strcmp(plist->d.string, other->d.string) == 0);
		} else {
			return (strcasecmp(plist->d.string, other->d.string) == 0);
		}
	case WPLData:
		return WMIsDataEqualToData(plist->d.data, other->d.data);
	case WPLArray:
		n = WMGetArrayItemCount(plist->d.array);
		if (n != WMGetArrayItemCount(other->d.array))
			return False;
		for (i = 0; i < n; i++) {
			item1 = WMGetFromArray(plist->d.array, i);
			item2 = WMGetFromArray(other->d.array, i);
			if (!WMIsPropListEqualTo(item1, item2))
				return False;
		}
		return True;
	case WPLDictionary:
		if (WMCountHashTable(plist->d.dict) != WMCountHashTable(other->d.dict))
			return False;
		enumerator = WMEnumerateHashTable(plist->d.dict);
		while (WMNextHashEnumeratorItemAndKey(&enumerator, (void **)&item1, (void **)&key1)) {
			item2 = WMHashGet(other->d.dict, key1);
			if (!item2 || !item1 || !WMIsPropListEqualTo(item1, item2))
				return False;
		}
		return True;
	default:
		wwarning(_("Used proplist functions on non-WMPropLists objects"));
		wassertrv(False, False);
		break;
	}

	return False;
}

char *WMGetFromPLString(WMPropList * plist)
{
	wassertrv(plist->type == WPLString, NULL);

	return plist->d.string;
}

WMData *WMGetFromPLData(WMPropList * plist)
{
	wassertrv(plist->type == WPLData, NULL);

	return plist->d.data;
}

const unsigned char *WMGetPLDataBytes(WMPropList * plist)
{
	wassertrv(plist->type == WPLData, NULL);

	return WMDataBytes(plist->d.data);
}

int WMGetPLDataLength(WMPropList * plist)
{
	wassertrv(plist->type == WPLData, 0);

	return WMGetDataLength(plist->d.data);
}

WMPropList *WMGetFromPLArray(WMPropList * plist, int index)
{
	wassertrv(plist->type == WPLArray, NULL);

	return WMGetFromArray(plist->d.array, index);
}

WMPropList *WMGetFromPLDictionary(WMPropList * plist, WMPropList * key)
{
	wassertrv(plist->type == WPLDictionary, NULL);

	return WMHashGet(plist->d.dict, key);
}

WMPropList *WMGetPLDictionaryKeys(WMPropList * plist)
{
	WMPropList *array, *key;
	WMHashEnumerator enumerator;

	wassertrv(plist->type == WPLDictionary, NULL);

	array = (WMPropList *) wmalloc(sizeof(W_PropList));
	array->type = WPLArray;
	array->d.array = WMCreateArray(WMCountHashTable(plist->d.dict));
	array->retainCount = 1;

	enumerator = WMEnumerateHashTable(plist->d.dict);
	while ((key = WMNextHashEnumeratorKey(&enumerator))) {
		WMAddToArray(array->d.array, WMRetainPropList(key));
	}

	return array;
}

WMPropList *WMShallowCopyPropList(WMPropList * plist)
{
	WMPropList *ret = NULL;
	WMPropList *key, *item;
	WMHashEnumerator e;
	WMData *data;
	int i;

	switch (plist->type) {
	case WPLString:
		ret = WMCreatePLString(plist->d.string);
		break;
	case WPLData:
		data = WMCreateDataWithData(plist->d.data);
		ret = WMCreatePLData(data);
		WMReleaseData(data);
		break;
	case WPLArray:
		ret = (WMPropList *) wmalloc(sizeof(W_PropList));
		ret->type = WPLArray;
		ret->d.array = WMCreateArrayWithArray(plist->d.array);
		ret->retainCount = 1;

		for (i = 0; i < WMGetArrayItemCount(ret->d.array); i++)
			WMRetainPropList(WMGetFromArray(ret->d.array, i));

		break;
	case WPLDictionary:
		ret = WMCreatePLDictionary(NULL, NULL);
		e = WMEnumerateHashTable(plist->d.dict);
		while (WMNextHashEnumeratorItemAndKey(&e, (void **)&item, (void **)&key)) {
			WMPutInPLDictionary(ret, key, item);
		}
		break;
	default:
		wwarning(_("Used proplist functions on non-WMPropLists objects"));
		wassertrv(False, NULL);
		break;
	}

	return ret;
}

WMPropList *WMDeepCopyPropList(WMPropList * plist)
{
	WMPropList *ret = NULL;
	WMPropList *key, *item;
	WMHashEnumerator e;
	WMData *data;
	int i;

	switch (plist->type) {
	case WPLString:
		ret = WMCreatePLString(plist->d.string);
		break;
	case WPLData:
		data = WMCreateDataWithData(plist->d.data);
		ret = WMCreatePLData(data);
		WMReleaseData(data);
		break;
	case WPLArray:
		ret = WMCreatePLArray(NULL);
		for (i = 0; i < WMGetArrayItemCount(plist->d.array); i++) {
			item = WMDeepCopyPropList(WMGetFromArray(plist->d.array, i));
			WMAddToArray(ret->d.array, item);
		}
		break;
	case WPLDictionary:
		ret = WMCreatePLDictionary(NULL, NULL);
		e = WMEnumerateHashTable(plist->d.dict);
		/* While we copy an existing dictionary there is no way that we can
		 * have duplicate keys, so we don't need to first remove a key/value
		 * pair before inserting the new key/value.
		 */
		while (WMNextHashEnumeratorItemAndKey(&e, (void **)&item, (void **)&key)) {
			WMHashInsert(ret->d.dict, WMDeepCopyPropList(key), WMDeepCopyPropList(item));
		}
		break;
	default:
		wwarning(_("Used proplist functions on non-WMPropLists objects"));
		wassertrv(False, NULL);
		break;
	}

	return ret;
}

WMPropList *WMCreatePropListFromDescription(char *desc)
{
	WMPropList *plist = NULL;
	PLData *pldata;

	pldata = (PLData *) wmalloc(sizeof(PLData));
	memset(pldata, 0, sizeof(PLData));
	pldata->ptr = desc;
	pldata->lineNumber = 1;

	plist = getPropList(pldata);

	if (getNonSpaceChar(pldata) != 0 && plist) {
		COMPLAIN(pldata, _("extra data after end of property list"));
		/*
		 * We can't just ignore garbage after the end of the description
		 * (especially if the description was read from a file), because
		 * the "garbage" can be the real data and the real garbage is in
		 * fact in the beginning of the file (which is now inside plist)
		 */
		WMReleasePropList(plist);
		plist = NULL;
	}

	wfree(pldata);

	return plist;
}

char *WMGetPropListDescription(WMPropList * plist, Bool indented)
{
	return (indented ? indentedDescription(plist, 0) : description(plist));
}

WMPropList *WMReadPropListFromFile(char *file)
{
	WMPropList *plist = NULL;
	PLData *pldata;
	FILE *f;
	struct stat stbuf;
	size_t length;

	f = fopen(file, "rb");
	if (!f) {
		/* let the user print the error message if he really needs to */
		/*wsyserror(_("could not open domain file '%s' for reading"), file); */
		return NULL;
	}

	if (stat(file, &stbuf) == 0) {
		length = (size_t) stbuf.st_size;
	} else {
		wsyserror(_("could not get size for file '%s'"), file);
		fclose(f);
		return NULL;
	}

	pldata = (PLData *) wmalloc(sizeof(PLData));
	memset(pldata, 0, sizeof(PLData));
	pldata->ptr = (char *)wmalloc(length + 1);
	pldata->filename = file;
	pldata->lineNumber = 1;

	if (fread(pldata->ptr, length, 1, f) != 1) {
		if (ferror(f)) {
			wsyserror(_("error reading from file '%s'"), file);
		}
		plist = NULL;
		goto cleanup;
	}

	pldata->ptr[length] = 0;

	plist = getPropList(pldata);

	if (getNonSpaceChar(pldata) != 0 && plist) {
		COMPLAIN(pldata, _("extra data after end of property list"));
		/*
		 * We can't just ignore garbage after the end of the description
		 * (especially if the description was read from a file), because
		 * the "garbage" can be the real data and the real garbage is in
		 * fact in the beginning of the file (which is now inside plist)
		 */
		WMReleasePropList(plist);
		plist = NULL;
	}

 cleanup:
	wfree(pldata->ptr);
	wfree(pldata);
	fclose(f);

	return plist;
}

/* TODO: review this function's code */

Bool WMWritePropListToFile(WMPropList * plist, char *path, Bool atomically)
{
	char *thePath = NULL;
	char *desc;
	FILE *theFile;

	if (atomically) {
#ifdef	HAVE_MKSTEMP
		int fd, mask;
#endif

		/* Use the path name of the destination file as a prefix for the
		 * mkstemp() call so that we can be sure that both files are on
		 * the same filesystem and the subsequent rename() will work. */
		thePath = wstrconcat(path, ".XXXXXX");

#ifdef  HAVE_MKSTEMP
		if ((fd = mkstemp(thePath)) < 0) {
			wsyserror(_("mkstemp (%s) failed"), thePath);
			goto failure;
		}
		mask = umask(0);
		umask(mask);
		fchmod(fd, 0644 & ~mask);
		if ((theFile = fdopen(fd, "wb")) == NULL) {
			close(fd);
		}
#else
		if (mktemp(thePath) == NULL) {
			wsyserror(_("mktemp (%s) failed"), thePath);
			goto failure;
		}
		theFile = fopen(thePath, "wb");
#endif
	} else {
		thePath = wstrdup(path);
		theFile = fopen(thePath, "wb");
	}

	if (theFile == NULL) {
		wsyserror(_("open (%s) failed"), thePath);
		goto failure;
	}

	desc = indentedDescription(plist, 0);

	if (fprintf(theFile, "%s\n", desc) != strlen(desc) + 1) {
		wsyserror(_("writing to file: %s failed"), thePath);
		wfree(desc);
		goto failure;
	}

	wfree(desc);

	if (fclose(theFile) != 0) {
		wsyserror(_("fclose (%s) failed"), thePath);
		goto failure;
	}

	/* If we used a temporary file, we still need to rename() it be the
	 * real file.  Also, we need to try to retain the file attributes of
	 * the original file we are overwriting (if we are) */
	if (atomically) {
		if (rename(thePath, path) != 0) {
			wsyserror(_("rename ('%s' to '%s') failed"), thePath, path);
			goto failure;
		}
	}

	wfree(thePath);
	return True;

 failure:
	if (atomically) {
		unlink(thePath);
		wfree(thePath);
	}

	return False;
}
