r8400: separate out the mpr code, as it is in the upstream appweb sources

(This used to be commit 0e30b6e4cc9e70975d3179cfeddc4bfcc8c8fbb7)

1 files changed, 2197 insertions, 0 deletions

diff --git a/source4/lib/appweb/mpr/var.c b/source4/lib/appweb/mpr/var.c
new file mode 100644
index 0000000000..9d2afe5306
--- /dev/null
+++ b/source4/lib/appweb/mpr/var.c
@@ -0,0 +1,2197 @@
+/*
+ *	@file 	var.c
+ *	@brief 	MPR Universal Variable Type
+ *	@overview
+ *
+ *	@copy	default.m
+ *	
+ *	Copyright (c) Mbedthis Software LLC, 2003-2005. All Rights Reserved.
+ *	Copyright (c) Michael O'Brien, 1994-1995. All Rights Reserved.
+ *	
+ *	This software is distributed under commercial and open source licenses.
+ *	You may use the GPL open source license described below or you may acquire 
+ *	a commercial license from Mbedthis Software. You agree to be fully bound 
+ *	by the terms of either license. Consult the LICENSE.TXT distributed with 
+ *	this software for full details.
+ *	
+ *	This software is open source; 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. See the GNU General Public License for more 
+ *	details at: http://www.mbedthis.com/downloads/gplLicense.html
+ *	
+ *	This program is distributed WITHOUT ANY WARRANTY; without even the 
+ *	implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 
+ *	
+ *	This GPL license does NOT permit incorporating this software into 
+ *	proprietary programs. If you are unable to comply with the GPL, you must
+ *	acquire a commercial license to use this software. Commercial licenses 
+ *	for this software and support services are available from Mbedthis 
+ *	Software at http://www.mbedthis.com 
+ *	
+ *	@end
+ */
+
+/******************************* Documentation ********************************/
+
+/*
+ *	This module is NOT multithreaded. 
+ *
+ *	Properties are variables that are stored in an object type variable.
+ *	Properties can be primitive data types, other objects or functions.
+ *	Properties are indexed by a character name.
+ */
+
+/********************************** Includes **********************************/
+
+#include	"var.h"
+
+/*********************************** Locals ***********************************/
+#if VAR_DEBUG
+
+static MprProperties	objectList;			/* Dummy head of objects list */
+static int				objectCount = -1;	/* Count of objects */
+
+#endif
+/***************************** Forward Declarations ***************************/
+
+static int 		adjustRefCount(MprProperties *pp, int adj);
+static int		adjustVarRefCount(MprVar *vp, int adj);
+static MprVar 	*allocProperty(const char *propertyName);
+static void 	copyVarCore(MprVar *dest, MprVar *src, int copyDepth);
+static MprProperties 
+				*createProperties(const char *name, int hashSize);
+static bool 	freeVar(MprVar *vp, int force);
+static bool 	freeVarStorage(MprVar *vp, int force);
+static MprVar	*getObjChain(MprProperties *pp, const char *property);
+static int		hash(MprProperties *pp, const char *property);
+static bool		releaseProperties(MprProperties *pp, int force);
+
+/*********************************** Code *************************************/
+/*
+ *	Destroy a variable and all referenced variables. Release any referenced 
+ *	object regardless of whether other users still have references. Be VERY
+ *	careful using this routine. 
+ *
+ *	Return TRUE if the underlying data is freed. Objects may not be freed if 
+ *	there are other users of the object.
+ */
+
+bool mprDestroyAllVars(MprVar *vp)
+{
+	mprAssert(vp);
+
+	if (vp->trigger) {
+		if ((vp->trigger)(MPR_VAR_DELETE, vp->parentProperties, vp, 0, 0) 
+				== MPR_TRIGGER_ABORT) {
+			return 0;
+		}
+	}
+
+	/*
+	 *	Free the actual value. If this var refers to an object, we will 
+	 *	recurse through all the properties freeing all vars.
+	 */
+	return freeVar(vp, 1);
+}
+
+/******************************************************************************/
+/*
+ *	Destroy a variable. Release any referenced object (destroy if no other
+ *	users are referencing).
+ *
+ *	Return TRUE if the underlying data is freed. Objects may not be freed if 
+ *	there are other users of the object.
+ */
+
+bool mprDestroyVar(MprVar *vp)
+{
+	mprAssert(vp);
+
+	if (vp->trigger) {
+		if ((vp->trigger)(MPR_VAR_DELETE, vp->parentProperties, vp, 0, 0) 
+				== MPR_TRIGGER_ABORT) {
+			return 0;
+		}
+	}
+
+	/*
+	 *	Free the actual value. If this var refers to an object, we will 
+	 *	recurse through all the properties freeing all that have no other
+	 *	references.
+	 */
+	return freeVar(vp, 0);
+}
+
+/******************************************************************************/
+/*
+ *	Free the value in a variable for primitive types. Release objects.
+ *
+ *	Return TRUE if the underlying data is freed. Objects may not be freed if 
+ *	there are other users of the object.
+ */
+
+static bool freeVar(MprVar *vp, int force)
+{
+	bool	freed;
+
+	mprAssert(vp);
+
+	freed = freeVarStorage(vp, force);
+
+	mprFree(vp->name);
+	mprFree(vp->fullName);
+
+	if (vp->allocatedVar) {
+		mprFree(vp);
+	} else {
+		vp->name = 0;
+		vp->fullName = 0;
+		vp->type = MPR_TYPE_UNDEFINED;
+	}
+	return freed;
+}
+
+/******************************************************************************/
+/*
+ *	Free the value in a variable for primitive types. Release objects.
+ *
+ *	Return TRUE if the underlying data is freed. Objects may not be freed if 
+ *	there are other users of the object.
+ */
+
+static bool freeVarStorage(MprVar *vp, int force)
+{
+	MprArray	*argList;
+	bool		freed;
+	int			i;
+
+	freed = 1;
+	mprAssert(vp);
+
+	switch (vp->type) {
+	default:
+		break;
+
+	case MPR_TYPE_STRING:
+		if (vp->allocatedData && vp->string != 0) {
+			mprFree(vp->string);
+			vp->string = 0;
+			vp->allocatedData = 0;
+		}
+		break;
+
+	case MPR_TYPE_OBJECT:
+#if VAR_DEBUG
+		/*
+		 *	Recurse through all properties and release / delete. Release the 
+		 *	properties hash table.
+		 */
+		if (vp->properties->refCount > 1) {
+			mprLog(7, "freeVar: ACT \"%s\", 0x%x, ref %d, force %d\n", 
+				vp->name, vp->properties, vp->properties->refCount, force);
+		} else {
+			mprLog(7, "freeVar: DEL \"%s\", 0x%x, ref %d, force %d\n", 
+				vp->name, vp->properties, vp->properties->refCount, force);
+		}
+#endif
+		if (vp->allocatedData) {
+			freed = releaseProperties(vp->properties, force);
+		}
+		vp->properties = 0;
+		break;
+
+	case MPR_TYPE_FUNCTION:
+		if (vp->allocatedData) {
+			argList = vp->function.args;
+			for (i = 0; i < argList->max; i++) {
+				if (argList->handles[i] != 0) {
+					mprFree(argList->handles[i]);
+				}
+			}
+			mprDestroyArray(argList);
+			vp->function.args = 0;
+			mprFree(vp->function.body);
+			vp->function.body = 0;
+		}
+		break;
+	}
+
+	vp->type = MPR_TYPE_UNDEFINED;
+	return freed;
+}
+
+/******************************************************************************/
+/*
+ *	Adjust the object reference count and return the currrent count of 
+ *	users.
+ */
+
+static int adjustVarRefCount(MprVar *vp, int adj)
+{
+	mprAssert(vp);
+
+	if (vp->type != MPR_TYPE_OBJECT) {
+		mprAssert(vp->type == MPR_TYPE_OBJECT);
+		return 0;
+	}
+	return adjustRefCount(vp->properties, adj);
+}
+
+/******************************************************************************/
+/*
+ *	Get the object reference count 
+ */
+
+int mprGetVarRefCount(MprVar *vp)
+{
+	mprAssert(vp);
+
+	if (vp->type != MPR_TYPE_OBJECT) {
+		mprAssert(vp->type == MPR_TYPE_OBJECT);
+		return 0;
+	}
+	return adjustRefCount(vp->properties, 0);
+}
+
+/******************************************************************************/
+/*
+ *	Update the variable's name
+ */
+
+void mprSetVarName(MprVar *vp, char *name)
+{
+	mprAssert(vp);
+
+	mprFree(vp->name);
+	vp->name = mprStrdup(name);
+}
+
+/******************************************************************************/
+/*
+ *	Append to the variable's full name
+ */
+
+void mprSetVarFullName(MprVar *vp, char *name)
+{
+#if VAR_DEBUG
+	mprAssert(vp);
+
+	mprFree(vp->fullName);
+	vp->fullName = mprStrdup(name);
+	if (vp->type == MPR_TYPE_OBJECT) {
+		if (strcmp(vp->properties->name, "this") == 0) {
+			mprStrcpy(vp->properties->name, sizeof(vp->properties->name), name);
+		}
+	}
+#endif
+}
+
+/******************************************************************************/
+/*
+ *	Make a var impervious to recursive forced deletes. 
+ */
+
+void mprSetVarDeleteProtect(MprVar *vp, int deleteProtect)
+{
+	mprAssert(vp);
+
+	if (vp->type == MPR_TYPE_OBJECT && vp->properties) {
+		vp->properties->deleteProtect = deleteProtect;
+	}
+}
+
+/******************************************************************************/
+/*
+ *	Make a variable readonly. Can still be deleted.
+ */
+
+void mprSetVarReadonly(MprVar *vp, int readonly)
+{
+	mprAssert(vp);
+
+	vp->readonly = readonly;
+}
+
+/******************************************************************************/
+
+MprVarTrigger mprAddVarTrigger(MprVar *vp, MprVarTrigger fn)
+{
+	MprVarTrigger oldTrigger;
+
+	mprAssert(vp);
+	mprAssert(fn);
+
+	oldTrigger = vp->trigger;
+	vp->trigger = fn;
+	return oldTrigger;
+}
+
+/******************************************************************************/
+
+MprType mprGetVarType(MprVar *vp)
+{
+	mprAssert(vp);
+
+	return vp->type;
+}
+
+/******************************************************************************/
+/********************************** Properties ********************************/
+/******************************************************************************/
+/*
+ *	Create a property in an object with a defined value. If the property 
+ *	already exists in the object, then just write its value.
+ */
+
+MprVar *mprCreateProperty(MprVar *obj, const char *propertyName, 
+	MprVar *newValue)
+{
+	MprVar	*prop, *last;
+	int		bucketIndex;
+
+	mprAssert(obj);
+	mprAssert(propertyName && *propertyName);
+
+	if (obj->type != MPR_TYPE_OBJECT) {
+		mprAssert(obj->type == MPR_TYPE_OBJECT);
+		return 0;
+	}
+
+	/*
+	 *	See if property already exists and locate the bucket to hold the
+	 *	property reference.
+	 */
+	last = 0;
+	bucketIndex = hash(obj->properties, propertyName);
+	prop = obj->properties->buckets[bucketIndex];
+
+	/*
+	 *	Find the property in the hash chain if it exists
+ 	 */
+	for (last = 0; prop; last = prop, prop = prop->forw) {
+		if (prop->name[0] == propertyName[0] && 
+				strcmp(prop->name, propertyName) == 0) {
+			break;
+		}
+	}
+
+	if (prop) {
+		/*	FUTURE -- remove. Just for debug. */
+		mprAssert(prop == 0);
+		mprLog(0, "Attempting to create property %s in object %s\n",
+			propertyName, obj->name);
+		return 0;
+	}
+
+	if (obj->trigger) {
+		if ((obj->trigger)(MPR_VAR_CREATE_PROPERTY, obj->properties, prop, 
+				newValue, 0) == MPR_TRIGGER_ABORT) {
+			return 0;
+		}
+	}
+
+	/*
+ 	 *	Create a new property
+	 */
+	prop = allocProperty(propertyName);
+	if (prop == 0) {
+		mprAssert(prop);
+		return 0;
+	}
+
+	copyVarCore(prop, newValue, MPR_SHALLOW_COPY);
+
+	prop->bucketIndex = bucketIndex;
+	if (last) {
+		last->forw = prop;
+	} else {
+		obj->properties->buckets[bucketIndex] = prop;
+	}
+	prop->parentProperties = obj->properties;
+
+	/*
+ 	 *	Update the item counts 
+	 */
+	obj->properties->numItems++;
+	if (! mprVarIsFunction(prop->type)) {
+		obj->properties->numDataItems++;
+	}
+
+	return prop;
+}
+
+/******************************************************************************/
+/*
+ *	Create a property in an object with a defined value. If the property 
+ *	already exists in the object, then just write its value. Same as 
+ *	mprCreateProperty except that the new value is passed by value rather than
+ *	by pointer.
+ */
+
+MprVar *mprCreatePropertyValue(MprVar *obj, const char *propertyName, 
+	MprVar newValue)
+{
+	return mprCreateProperty(obj, propertyName, &newValue);
+}
+
+/******************************************************************************/
+/*
+ *	Create a new property
+ */
+
+static MprVar *allocProperty(const char *propertyName)
+{
+	MprVar		*prop;
+
+	prop = (MprVar*) mprMalloc(sizeof(MprVar));
+	if (prop == 0) {
+		mprAssert(prop);
+		return 0;
+	}
+	memset(prop, 0, sizeof(MprVar));
+	prop->allocatedVar = 1;
+	prop->name = mprStrdup(propertyName);
+	prop->forw = (MprVar*) 0;
+
+	return prop;
+}
+
+/******************************************************************************/
+/*
+ *	Update a property in an object with a defined value. Create the property
+ *	if it doesn not already exist.
+ */
+
+MprVar *mprSetProperty(MprVar *obj, const char *propertyName, MprVar *newValue)
+{
+	MprVar	*prop, triggerValue;
+	int		rc;
+
+	mprAssert(obj);
+	mprAssert(propertyName && *propertyName);
+	mprAssert(obj->type == MPR_TYPE_OBJECT);
+
+	if (obj->type != MPR_TYPE_OBJECT) {
+		mprAssert(0);
+		return 0;
+	}
+
+	prop = mprGetProperty(obj, propertyName, 0);
+	if (prop == 0) {
+		return mprCreateProperty(obj, propertyName, newValue);
+	}
+
+	if (obj->trigger) {
+		/* 
+		 *	Call the trigger before the update and pass it the new value.
+		 */
+		triggerValue = *newValue;
+		triggerValue.allocatedVar = 0;
+		triggerValue.allocatedData = 0;
+		rc = (obj->trigger)(MPR_VAR_WRITE, obj->properties, obj, 
+				&triggerValue, 0);
+		if (rc == MPR_TRIGGER_ABORT) {
+			return 0;
+
+		} else if (rc == MPR_TRIGGER_USE_NEW_VALUE) {
+			/*
+			 *	Trigger must copy to triggerValue a variable that is not
+			 *	a structure copy of the existing data.
+			 */
+			copyVarCore(prop, &triggerValue, MPR_SHALLOW_COPY);
+			mprDestroyVar(&triggerValue);
+			return prop;
+		}
+	}
+	copyVarCore(prop, newValue, MPR_SHALLOW_COPY);
+	return prop;
+}
+
+/******************************************************************************/
+/*
+ *	Update a property in an object with a defined value. Create the property
+ *	if it does not already exist. Same as mprSetProperty except that the 
+ *	new value is passed by value rather than by pointer.
+ */
+
+MprVar *mprSetPropertyValue(MprVar *obj, const char *propertyName, 
+	MprVar newValue)
+{
+	return mprSetProperty(obj, propertyName, &newValue);
+}
+
+/******************************************************************************/
+/*
+ *	Delete a property from this object
+ */
+
+int mprDeleteProperty(MprVar *obj, const char *property)
+{
+	MprVar		*prop, *last;
+	char		*cp;
+	int			bucketIndex;
+
+	mprAssert(obj);
+	mprAssert(property && *property);
+	mprAssert(obj->type == MPR_TYPE_OBJECT);
+
+	if (obj->type != MPR_TYPE_OBJECT) {
+		mprAssert(obj->type == MPR_TYPE_OBJECT);
+		return 0;
+	}
+
+	last = 0;
+	bucketIndex = hash(obj->properties, property);
+	if ((prop = obj->properties->buckets[bucketIndex]) != 0) {
+		for ( ; prop; prop = prop->forw) {
+			cp = prop->name;
+			if (cp[0] == property[0] && strcmp(cp, property) == 0) {
+				break;
+			}
+			last = prop;
+		}
+	}
+	if (prop == (MprVar*) 0) {
+		mprAssert(prop);
+		return MPR_ERR_NOT_FOUND;
+	}
+ 	if (prop->readonly) {
+		mprAssert(! prop->readonly);
+		return MPR_ERR_READ_ONLY;
+	}
+
+	if (obj->trigger) {
+		if ((obj->trigger)(MPR_VAR_DELETE_PROPERTY, obj->properties, prop, 0, 0)
+				== MPR_TRIGGER_ABORT) {
+			return MPR_ERR_ABORTED;
+		}
+	}
+
+	if (last) {
+		last->forw = prop->forw;
+	} else {
+		obj->properties->buckets[bucketIndex] = prop->forw;
+	}
+
+	obj->properties->numItems--;
+	if (! mprVarIsFunction(prop->type)) {
+		obj->properties->numDataItems--;
+	}
+
+	mprDestroyVar(prop);
+
+	return 0;
+}
+
+/******************************************************************************/
+/*
+ *	Find a property in an object and return a pointer to it. If a value arg
+ *	is supplied, then copy the data into the var. 
+ */
+
+MprVar *mprGetProperty(MprVar *obj, const char *property, MprVar *value)
+{
+	MprVar	*prop, triggerValue;
+	int		rc;
+
+	if (obj == 0 || obj->type != MPR_TYPE_OBJECT || property == 0 || 
+			*property == '\0') {
+		if (value) {
+			value->type = MPR_TYPE_UNDEFINED;
+		}
+		return 0;
+	}
+
+	for (prop = getObjChain(obj->properties, property); prop; 
+			prop = prop->forw) {
+		if (prop->name &&
+			prop->name[0] == property[0] && strcmp(prop->name, property) == 0) {
+			break;
+		}
+	}
+	if (prop == 0) {
+		if (value) {
+			value->type = MPR_TYPE_UNDEFINED;
+		}
+		return 0;
+	}
+	if (value) {
+		if (prop->trigger) {
+			triggerValue = *prop;
+			triggerValue.allocatedVar = 0;
+			triggerValue.allocatedData = 0;
+			/*
+			 *	Pass the trigger the current read value and may receive
+			 *	a new value.
+			 */ 
+			rc = (prop->trigger)(MPR_VAR_READ, prop->parentProperties, prop, 
+				&triggerValue, 0);
+			if (rc == MPR_TRIGGER_ABORT) {
+				if (value) {
+					value->type = MPR_TYPE_UNDEFINED;
+				}
+				return 0;
+
+			} else if (rc == MPR_TRIGGER_USE_NEW_VALUE) {
+				copyVarCore(prop, &triggerValue, MPR_SHALLOW_COPY);
+				mprDestroyVar(&triggerValue);
+			}
+		}
+		/*
+		 *	Clone. No copy.
+		 */
+		*value = *prop;
+	}
+	return prop;
+}
+
+/******************************************************************************/
+/*
+ *	Read a properties value. This returns the property's value. It does not
+ *	copy object/string data but returns a pointer directly into the variable.
+ *	The caller does not and should not call mprDestroy on the returned value.
+ *	If value is null, just read the property and run triggers.
+ */
+
+int mprReadProperty(MprVar *prop, MprVar *value)
+{
+	MprVar	triggerValue;
+	int		rc;
+
+	mprAssert(prop);
+
+	if (prop->trigger) {
+		triggerValue = *prop;
+		triggerValue.allocatedVar = 0;
+		triggerValue.allocatedData = 0;
+		rc = (prop->trigger)(MPR_VAR_READ, prop->parentProperties, prop, 
+			&triggerValue, 0);
+
+		if (rc == MPR_TRIGGER_ABORT) {
+			return MPR_ERR_ABORTED;
+
+		} else if (rc == MPR_TRIGGER_USE_NEW_VALUE) {
+			copyVarCore(prop, &triggerValue, MPR_SHALLOW_COPY);
+			mprDestroyVar(&triggerValue);
+			return 0;
+		}
+	}
+	if (value) {
+		*value = *prop;
+
+		/*
+		 *	Just so that if the user calls mprDestroyVar on value, it will do no
+		 *	harm.
+		 */
+		value->allocatedVar = 0;
+		value->allocatedData = 0;
+	}
+	return 0;
+}
+
+/******************************************************************************/
+/*
+ *	Read a properties value. This returns a copy of the property variable. 
+ *	However, if the property is an object or string, it returns a copy of the
+ *	reference to the underlying data. If copyDepth is set to MPR_DEEP_COPY,
+ *	then the underlying objects and strings data will be copied as well. If 
+ *	copyDepth is set to MPR_SHALLOW_COPY, then only strings will be copied. If
+ *	it is set to MPR_NO_COPY, then no data will be copied. In all cases, the 
+ *	user must call mprDestroyVar to free resources. This routine will run any 
+ *	registered triggers which may modify the value the user receives (without 
+ *	updating the properties real value).
+ *
+ *	WARNING: the args are reversed to most other APIs. This conforms to the
+ *	strcpy(dest, src) standard instead.
+ */
+
+int mprCopyProperty(MprVar *dest, MprVar *prop, int copyDepth)
+{
+	MprVar	triggerValue;
+	int		rc;
+
+	mprAssert(prop);
+	mprAssert(dest);
+
+	if (prop->trigger) {
+		triggerValue = *prop;
+		triggerValue.allocatedVar = 0;
+		triggerValue.allocatedData = 0;
+		rc = (prop->trigger)(MPR_VAR_READ, prop->parentProperties, prop, 
+			&triggerValue, copyDepth);
+
+		if (rc == MPR_TRIGGER_ABORT) {
+			return MPR_ERR_ABORTED;
+
+		} else if (rc == MPR_TRIGGER_USE_NEW_VALUE) {
+			copyVarCore(dest, &triggerValue, MPR_SHALLOW_COPY);
+			mprDestroyVar(&triggerValue);
+			return 0;
+		}
+	}
+	mprCopyVar(dest, prop, copyDepth);
+	return 0;
+}
+
+/******************************************************************************/
+/*
+ *	Write a new value into an existing property in an object.
+ */
+
+int mprWriteProperty(MprVar *vp, MprVar *value)
+{
+	MprVar	triggerValue;
+	int		rc;
+
+	mprAssert(vp);
+	mprAssert(value);
+
+	if (vp->readonly) {
+		return MPR_ERR_READ_ONLY;
+	}
+
+	if (vp->trigger) {
+		triggerValue = *value;
+
+		rc = (vp->trigger)(MPR_VAR_WRITE, vp->parentProperties, vp, 
+			&triggerValue, 0);
+
+		if (rc == MPR_TRIGGER_ABORT) {
+			return MPR_ERR_ABORTED;
+
+		} else if (rc == MPR_TRIGGER_USE_NEW_VALUE) {
+			copyVarCore(vp, &triggerValue, MPR_SHALLOW_COPY);
+			mprDestroyVar(&triggerValue);
+			return 0;
+		}
+		/* Fall through */
+	}
+
+	copyVarCore(vp, value, MPR_SHALLOW_COPY);
+	return 0;
+}
+
+/******************************************************************************/
+/*
+ *	Write a new value into an existing property in an object.
+ */
+
+int mprWritePropertyValue(MprVar *vp, MprVar value)
+{
+	mprAssert(vp);
+
+	return mprWriteProperty(vp, &value);
+}
+
+/******************************************************************************/
+/*
+ *	Get the count of properties.
+ */
+
+int mprGetPropertyCount(MprVar *vp, int includeFlags)
+{
+	mprAssert(vp);
+
+	if (vp->type != MPR_TYPE_OBJECT) {
+		return 0;
+	}
+	if (includeFlags == MPR_ENUM_DATA) {
+		return vp->properties->numDataItems;
+	} else {
+		return vp->properties->numItems;
+	}
+}
+
+/******************************************************************************/
+/*
+ *	Get the first property in an object. Used for walking all properties in an
+ *	object.
+ */
+
+MprVar *mprGetFirstProperty(MprVar *obj, int includeFlags)
+{
+	MprVar		*prop;
+	int			i;
+
+	mprAssert(obj);
+	mprAssert(obj->type == MPR_TYPE_OBJECT);
+
+	if (obj->type != MPR_TYPE_OBJECT) {
+		mprAssert(obj->type == MPR_TYPE_OBJECT);
+		return 0;
+	}
+
+	for (i = 0; i < (int) obj->properties->hashSize; i++) {
+		for (prop = obj->properties->buckets[i]; prop; prop = prop->forw) {
+			if (prop) {
+				if (mprVarIsFunction(prop->type)) {
+					if (!(includeFlags & MPR_ENUM_FUNCTIONS)) {
+						continue;
+					}
+				} else {
+					if (!(includeFlags & MPR_ENUM_DATA)) {
+						continue;
+					}
+				}
+				return prop;
+			}
+			break;
+		}
+	}
+	return 0;
+}
+
+/******************************************************************************/
+/*
+ *	Get the next property in sequence.
+ */
+
+MprVar *mprGetNextProperty(MprVar *obj, MprVar *last, int includeFlags)
+{
+	MprProperties	*properties;
+	int				i;
+
+	mprAssert(obj);
+	mprAssert(obj->type == MPR_TYPE_OBJECT);
+
+	if (obj->type != MPR_TYPE_OBJECT) {
+		mprAssert(obj->type == MPR_TYPE_OBJECT);
+		return 0;
+	}
+	properties = obj->properties;
+
+	if (last->forw) {
+		return last->forw;
+	}
+
+	for (i = last->bucketIndex + 1; i < (int) properties->hashSize; i++) {
+		for (last = properties->buckets[i]; last; last = last->forw) {
+			if (mprVarIsFunction(last->type)) {
+				if (!(includeFlags & MPR_ENUM_FUNCTIONS)) {
+					continue;
+				}
+			} else {
+				if (!(includeFlags & MPR_ENUM_DATA)) {
+					continue;
+				}
+			}
+			return last;
+		}
+	}
+	return 0;
+}
+
+/******************************************************************************/
+/************************** Internal Support Routines *************************/
+/******************************************************************************/
+/*
+ *	Create an hash table to hold and index properties. Properties are just 
+ *	variables which may contain primitive data types, functions or other
+ *	objects. The hash table is the essence of an object. HashSize specifies 
+ *	the size of the hash table to use and should be a prime number.
+ */
+
+static MprProperties *createProperties(const char *name, int hashSize)
+{
+	MprProperties	*pp;
+
+	if (hashSize < 7) {
+		hashSize = 7;
+	}
+	if ((pp = (MprProperties*) mprMalloc(sizeof(MprProperties))) == NULL) {
+		mprAssert(0);
+		return 0;
+	}
+	mprAssert(pp);
+	memset(pp, 0, sizeof(MprProperties));
+
+	pp->numItems = 0;
+	pp->numDataItems = 0;
+	pp->hashSize = hashSize;
+	pp->buckets = (MprVar**) mprMalloc(pp->hashSize * sizeof(MprVar*));
+	mprAssert(pp->buckets);
+	memset(pp->buckets, 0, pp->hashSize * sizeof(MprVar*));
+	pp->refCount = 1;
+
+#if VAR_DEBUG
+	if (objectCount == -1) {
+		objectCount = 0;
+		objectList.next = objectList.prev = &objectList;
+	}
+
+	mprStrcpy(pp->name, sizeof(pp->name), name);
+	pp->next = &objectList;
+	pp->prev = objectList.prev;
+	objectList.prev->next = pp;
+	objectList.prev = pp;
+	objectCount++;
+#endif
+	return pp;
+}
+
+/******************************************************************************/
+/*
+ *	Release an object's properties hash table. If this is the last person 
+ *	using it, free it. Return TRUE if the object is released.
+ */
+
+static bool releaseProperties(MprProperties *obj, int force)
+{
+	MprProperties	*pp;
+	MprVar			*prop, *forw;
+	int				i;
+
+	mprAssert(obj);
+	mprAssert(obj->refCount > 0);
+
+#if VAR_DEBUG
+	/*
+	 *	Debug sanity check
+	 */
+	mprAssert(obj->refCount < 20);
+#endif
+
+	if (--obj->refCount > 0 && !force) {
+		return 0;
+	}
+
+#if VAR_DEBUG
+	mprAssert(obj->prev);
+	mprAssert(obj->next);
+	mprAssert(obj->next->prev);
+	mprAssert(obj->prev->next);
+	obj->next->prev = obj->prev;
+	obj->prev->next = obj->next;
+	objectCount--;
+#endif
+
+	for (i = 0; i < (int) obj->hashSize; i++) {
+		for (prop = obj->buckets[i]; prop; prop = forw) {
+			forw = prop->forw;
+			if (prop->type == MPR_TYPE_OBJECT) {
+
+				if (prop->properties == obj) {
+					/* Self reference */
+					continue;
+				}
+				pp = prop->properties;
+				if (pp->visited) {
+					continue;
+				}
+
+				pp->visited = 1;
+				if (! freeVar(prop, pp->deleteProtect ? 0 : force)) {
+					pp->visited = 0;
+				}
+
+			} else {
+				freeVar(prop, force);
+			}
+		}
+	}
+
+	mprFree((void*) obj->buckets);
+	mprFree((void*) obj);
+
+	return 1;
+}
+
+/******************************************************************************/
+/*
+ *	Adjust the reference count
+ */
+
+static int adjustRefCount(MprProperties *pp, int adj)
+{
+	mprAssert(pp);
+
+	/*
+	 *	Debug sanity check
+	 */
+	mprAssert(pp->refCount < 20);
+
+	return pp->refCount += adj;
+}
+
+/******************************************************************************/
+#if VAR_DEBUG
+/*
+ *	Print objects held
+ */
+
+void mprPrintObjects(char *msg)
+{
+	MprProperties	*pp, *np;
+	MprVar			*prop, *forw;
+	char			*buf;
+	int				i;
+
+	mprLog(7, "%s: Object Store. %d objects.\n", msg, objectCount);
+	pp = objectList.next;
+	while (pp != &objectList) {
+		mprLog(7, "%s: 0x%x, refCount %d, properties %d\n", 
+			pp->name, pp, pp->refCount, pp->numItems);
+		for (i = 0; i < (int) pp->hashSize; i++) {
+			for (prop = pp->buckets[i]; prop; prop = forw) {
+				forw = prop->forw;
+				if (prop->properties == pp) {
+					/* Self reference */
+					continue;
+				}
+				mprVarToString(&buf, MPR_MAX_STRING, 0, prop);
+				if (prop->type == MPR_TYPE_OBJECT) {
+					np = objectList.next;
+					while (np != &objectList) {
+						if (prop->properties == np) {
+							break;
+						}
+						np = np->next;
+					}
+					if (prop->properties == np) {
+						mprLog(7, "    %s: OBJECT 0x%x, <%s>\n", 
+							prop->name, prop->properties, prop->fullName);
+					} else {
+						mprLog(7, "    %s: OBJECT NOT FOUND, %s <%s>\n", 
+							prop->name, buf, prop->fullName);
+					}
+				} else {
+					mprLog(7, "    %s: <%s> = %s\n", prop->name, 
+						prop->fullName, buf);
+				}
+				mprFree(buf);
+			}
+		}
+		pp = pp->next;
+	}
+}
+
+/******************************************************************************/
+
+void mprPrintObjRefCount(MprVar *vp)
+{
+	mprLog(7, "OBJECT 0x%x, refCount %d\n", vp->properties,
+		vp->properties->refCount);
+}
+
+#endif
+/******************************************************************************/
+/*
+ *	Get the bucket chain containing a property.
+ */
+
+static MprVar *getObjChain(MprProperties *obj, const char *property)
+{
+	mprAssert(obj);
+
+	return obj->buckets[hash(obj, property)];
+}
+
+/******************************************************************************/
+/*
+ *	Fast hash. The history of this algorithm is part of lost computer science 
+ *	folk lore.
+ */
+
+static int hash(MprProperties *pp, const char *property)
+{
+	uint	sum;
+
+	mprAssert(pp);
+	mprAssert(property);
+
+	sum = 0;
+	while (*property) {
+		sum += (sum * 33) + *property++;
+	}
+
+	return sum % pp->hashSize;
+}
+
+/******************************************************************************/
+/*********************************** Constructors *****************************/
+/******************************************************************************/
+/*
+ *	Initialize an undefined value.
+ */
+
+MprVar mprCreateUndefinedVar()
+{
+	MprVar	v;
+
+	memset(&v, 0x0, sizeof(v));
+	v.type = MPR_TYPE_UNDEFINED;
+	return v;
+}
+
+/******************************************************************************/
+/*
+ *	Initialize an null value.
+ */
+
+MprVar mprCreateNullVar()
+{
+	MprVar	v;
+
+	memset(&v, 0x0, sizeof(v));
+	v.type = MPR_TYPE_NULL;
+	return v;
+}
+
+/******************************************************************************/
+
+MprVar mprCreateBoolVar(bool value)
+{
+	MprVar	v;
+
+	memset(&v, 0x0, sizeof(v));
+	v.type = MPR_TYPE_BOOL;
+	v.boolean = value;
+	return v;
+}
+
+/******************************************************************************/
+/*
+ *	Initialize a C function.
+ */
+
+MprVar mprCreateCFunctionVar(MprCFunction fn, void *thisPtr, int flags)
+{
+	MprVar	v;
+
+	memset(&v, 0x0, sizeof(v));
+	v.type = MPR_TYPE_CFUNCTION;
+	v.cFunction.fn = fn;
+	v.cFunction.thisPtr = thisPtr;
+	v.flags = flags;
+
+	return v;
+}
+
+/******************************************************************************/
+/*
+ *	Initialize a C function.
+ */
+
+MprVar mprCreateStringCFunctionVar(MprStringCFunction fn, void *thisPtr, 
+	int flags)
+{
+	MprVar	v;
+
+	memset(&v, 0x0, sizeof(v));
+	v.type = MPR_TYPE_STRING_CFUNCTION;
+	v.cFunctionWithStrings.fn = fn;
+	v.cFunctionWithStrings.thisPtr = thisPtr;
+	v.flags = flags;
+
+	return v;
+}
+
+/******************************************************************************/
+/*
+ *	Initialize an opaque pointer.
+ */
+
+MprVar mprCreatePtrVar(void *ptr)
+{
+	MprVar	v;
+
+	memset(&v, 0x0, sizeof(v));
+	v.type = MPR_TYPE_PTR;
+	v.ptr = ptr;
+
+	return v;
+}
+
+/******************************************************************************/
+#if BLD_FEATURE_FLOATING_POINT
+/*
+ *	Initialize a floating value.
+ */
+
+MprVar mprCreateFloatVar(double value)
+{
+	MprVar	v;
+
+	memset(&v, 0x0, sizeof(v));
+	v.type = MPR_TYPE_FLOAT;
+	v.floating = value;
+	return v;
+}
+
+#endif
+/******************************************************************************/
+/*
+ *	Initialize an integer value.
+ */
+
+MprVar mprCreateIntegerVar(int value)
+{
+	MprVar	v;
+
+	memset(&v, 0x0, sizeof(v));
+	v.type = MPR_TYPE_INT;
+	v.integer = value;
+	return v;
+}
+
+/******************************************************************************/
+#if BLD_FEATURE_INT64
+/*
+ *	Initialize a 64-bit integer value.
+ */
+
+MprVar mprCreateInteger64Var(int64 value)
+{
+	MprVar	v;
+
+	memset(&v, 0x0, sizeof(v));
+	v.type = MPR_TYPE_INT64;
+	v.integer64 = value;
+	return v;
+}
+
+#endif /* BLD_FEATURE_INT64 */
+/******************************************************************************/
+/*
+ *	Initialize an number variable. Type is defined by configure.
+ */
+
+MprVar mprCreateNumberVar(MprNum value)
+{
+	MprVar	v;
+
+	memset(&v, 0x0, sizeof(v));
+	v.type = BLD_FEATURE_NUM_TYPE_ID;
+#if   BLD_FEATURE_NUM_TYPE_ID == MPR_TYPE_INT64
+	v.integer64 = value;
+#elif BLD_FEATURE_NUM_TYPE_ID == MPR_TYPE_FLOAT
+	v.float = value;
+#else
+	v.integer = value;
+#endif
+	return v;
+}
+
+/******************************************************************************/
+/*
+ *	Initialize a (bare) JavaScript function. args and body can be null.
+ */
+
+MprVar mprCreateFunctionVar(char *args, char *body, int flags)
+{
+	MprVar		v;
+	char		*cp, *arg, *last;
+	int			aid;
+
+	memset(&v, 0x0, sizeof(v));
+	v.type = MPR_TYPE_FUNCTION;
+	v.flags = flags;
+
+	v.function.args = mprCreateArray();
+
+	if (args) {
+		args = mprStrdup(args);
+		arg = mprStrTok(args, ",", &last);
+		while (arg) {
+			while (isspace((int) *arg))
+				arg++;
+			for (cp = &arg[strlen(arg) - 1]; cp > arg; cp--) {
+				if (!isspace((int) *cp)) {
+					break;
+				}
+			}
+			cp[1] = '\0';
+					
+			aid = mprAddToArray(v.function.args, mprStrdup(arg));
+			arg = mprStrTok(0, ",", &last);
+		}
+		mprFree(args);
+	}
+
+	if (body) {
+		v.function.body = mprStrdup(body);
+	}
+	v.allocatedData = 1;
+	return v;
+}
+
+/******************************************************************************/
+/*
+ *	Initialize an object variable. Return type == MPR_TYPE_UNDEFINED if the
+ *	memory allocation for the properties table failed.
+ */
+
+MprVar mprCreateObjVar(const char *name, int hashSize)
+{
+	MprVar	v;
+
+	mprAssert(name && *name);
+
+	memset(&v, 0x0, sizeof(MprVar));
+	v.type = MPR_TYPE_OBJECT;
+	if (hashSize <= 0) {
+		hashSize = MPR_DEFAULT_HASH_SIZE;
+	}
+	v.properties = createProperties(name, hashSize);
+	if (v.properties == 0) {
+		/* Indicate failed memory allocation */
+		v.type = MPR_TYPE_UNDEFINED;
+	}
+	v.allocatedData = 1;
+	v.name = mprStrdup(name);
+	mprLog(7, "mprCreateObjVar %s, 0x%p\n", name, v.properties);
+	return v;
+}
+
+/******************************************************************************/
+/*
+ *	Initialize a string value.
+ */
+
+MprVar mprCreateStringVar(const char *value, bool allocate)
+{
+	MprVar	v;
+
+	memset(&v, 0x0, sizeof(v));
+	v.type = MPR_TYPE_STRING;
+	if (value == 0) {
+		v.string = "";
+	} else if (allocate) {
+		v.string = mprStrdup(value);
+		v.allocatedData = 1;
+	} else {
+		v.string = (char*) value;
+	}
+	return v;
+}
+
+/******************************************************************************/
+/*
+ *	Copy an objects core value (only). This preserves the destination object's 
+ *	name. This implements copy by reference for objects and copy by value for 
+ *	strings and other types. Caller must free dest prior to calling.
+ */
+
+static void copyVarCore(MprVar *dest, MprVar *src, int copyDepth)
+{
+	MprVarTrigger	saveTrigger;
+	MprVar			*srcProp, *destProp, *last;
+	char			**srcArgs;
+	int				i;
+
+	mprAssert(dest);
+	mprAssert(src);
+
+	if (dest == src) {
+		return;
+	}
+
+	/*
+ 	 *	FUTURE: we should allow read-only triggers where the value is never
+	 *	stored in the object. Currently, triggers override the readonly
+	 *	status.
+	 */
+
+	if (dest->type != MPR_TYPE_UNDEFINED && dest->readonly && !dest->trigger) {
+		mprAssert(0);
+		return;
+	}
+
+	if (dest->type != MPR_TYPE_UNDEFINED) {
+		saveTrigger = dest->trigger;
+		freeVarStorage(dest, 0);
+	} else {
+		saveTrigger = 0;
+	}
+
+	switch (src->type) {
+	default:
+	case MPR_TYPE_UNDEFINED:
+	case MPR_TYPE_NULL:
+		break;
+
+	case MPR_TYPE_BOOL:
+		dest->boolean = src->boolean;
+		break;
+
+	case MPR_TYPE_PTR:
+		dest->ptr = src->ptr;
+		break;
+
+	case MPR_TYPE_STRING_CFUNCTION:
+		dest->cFunctionWithStrings = src->cFunctionWithStrings;
+		break;
+
+	case MPR_TYPE_CFUNCTION:
+		dest->cFunction = src->cFunction;
+		break;
+
+#if BLD_FEATURE_FLOATING_POINT
+	case MPR_TYPE_FLOAT:
+		dest->floating = src->floating;
+		break;
+#endif
+
+	case MPR_TYPE_INT:
+		dest->integer = src->integer;
+		break;
+
+#if BLD_FEATURE_INT64
+	case MPR_TYPE_INT64:
+		dest->integer64 = src->integer64;
+		break;
+#endif
+
+	case MPR_TYPE_OBJECT:
+		if (copyDepth == MPR_DEEP_COPY) {
+
+			dest->properties = createProperties(src->name, 
+				src->properties->hashSize);
+			dest->allocatedData = 1;
+
+			for (i = 0; i < (int) src->properties->hashSize; i++) {
+				last = 0;
+				for (srcProp = src->properties->buckets[i]; srcProp; 
+						srcProp = srcProp->forw) {
+					if (srcProp->visited) {
+						continue;
+					}
+					destProp = allocProperty(srcProp->name);
+					if (destProp == 0) {
+						mprAssert(destProp);
+						return;
+					}
+
+					destProp->bucketIndex = i;
+					if (last) {
+						last->forw = destProp;
+					} else {
+						dest->properties->buckets[i] = destProp;
+					}
+					destProp->parentProperties = dest->properties;
+
+					/*
+					 *	Recursively copy the object
+					 */
+					srcProp->visited = 1;
+					copyVarCore(destProp, srcProp, copyDepth);
+					srcProp->visited = 0;
+					last = srcProp;
+				}
+			}
+			dest->properties->numItems = src->properties->numItems;
+			dest->properties->numDataItems = src->properties->numDataItems;
+			dest->allocatedData = 1;
+
+		} else if (copyDepth == MPR_SHALLOW_COPY) {
+			dest->properties = src->properties;
+			adjustVarRefCount(src, 1);
+			dest->allocatedData = 1;
+
+		} else {
+			dest->properties = src->properties;
+			dest->allocatedData = 0;
+		}
+		break;
+
+	case MPR_TYPE_FUNCTION:
+		if (copyDepth != MPR_NO_COPY) {
+			dest->function.args = mprCreateArray();
+			srcArgs = (char**) src->function.args->handles;
+			for (i = 0; i < src->function.args->max; i++) {
+				if (srcArgs[i]) {
+					mprAddToArray(dest->function.args, mprStrdup(srcArgs[i]));
+				}
+			}
+			dest->function.body = mprStrdup(src->function.body);
+			dest->allocatedData = 1;
+		} else {
+			dest->function.args = src->function.args;
+			dest->function.body = src->function.body;
+			dest->allocatedData = 0;
+		}
+		break;
+
+	case MPR_TYPE_STRING:
+		if (src->string && copyDepth != MPR_NO_COPY) {
+			dest->string = mprStrdup(src->string);
+			dest->allocatedData = 1;
+		} else {
+			dest->string = src->string;
+			dest->allocatedData = 0;
+		}
+		break;
+	}
+
+	dest->type = src->type;
+	dest->flags = src->flags;
+	dest->trigger = saveTrigger;
+
+	/*
+	 *	Just for safety
+	 */
+	dest->spare = 0;
+}
+
+/******************************************************************************/
+/*
+ *	Copy an entire object including name.
+ */
+
+void mprCopyVar(MprVar *dest, MprVar *src, int copyDepth)
+{
+	mprAssert(dest);
+	mprAssert(src);
+
+	copyVarCore(dest, src, copyDepth);
+
+	mprFree(dest->name);
+	dest->name = mprStrdup(src->name);
+
+#if VAR_DEBUG
+	if (src->type == MPR_TYPE_OBJECT) {
+
+		mprFree(dest->fullName);
+		dest->fullName = mprStrdup(src->fullName);
+
+		mprLog(7, "mprCopyVar: object \"%s\", FDQ \"%s\" 0x%x, refCount %d\n", 
+			dest->name, dest->fullName, dest->properties, 
+			dest->properties->refCount);
+	}
+#endif
+}
+
+/******************************************************************************/
+/*
+ *	Copy an entire object including name.
+ */
+
+void mprCopyVarValue(MprVar *dest, MprVar src, int copyDepth)
+{
+	mprAssert(dest);
+
+	mprCopyVar(dest, &src, copyDepth); 
+}
+
+/******************************************************************************/
+/*
+ *	Copy an object. This implements copy by reference for objects and copy by
+ *	value for strings and other types. Caller must free dest prior to calling.
+ */
+
+MprVar *mprDupVar(MprVar *src, int copyDepth)
+{
+	MprVar	*dest;
+
+	mprAssert(src);
+
+	dest = (MprVar*) mprMalloc(sizeof(MprVar));
+	memset(dest, 0, sizeof(MprVar));
+
+	mprCopyVar(dest, src, copyDepth);
+	return dest;
+}
+
+/******************************************************************************/
+/*
+ *	Convert a value to a text based representation of its value
+ *	FUTURE -- conver this to use the format string in all cases. Allow
+ *	arbitrary format strings.
+ */
+
+void mprVarToString(char** out, int size, char *fmt, MprVar *obj)
+{
+	char	*src;
+
+	mprAssert(out);
+
+	*out = NULL;
+
+	if (obj->trigger) {
+		mprReadProperty(obj, 0);
+	}
+
+	switch (obj->type) {
+	case MPR_TYPE_UNDEFINED:
+		/*	FUTURE -- spec says convert to "undefined" */
+		*out = mprStrdup("");
+		break;
+
+	case MPR_TYPE_NULL:
+		*out = mprStrdup("null");
+		break;
+
+	case MPR_TYPE_PTR:
+		mprAllocSprintf(out, size, "[Opaque Pointer %p]", obj->ptr);
+		break;
+
+	case MPR_TYPE_BOOL:
+		if (obj->boolean) {
+			*out = mprStrdup("true");
+		} else {
+			*out = mprStrdup("false");
+		}
+		break;
+
+#if BLD_FEATURE_FLOATING_POINT
+	case MPR_TYPE_FLOAT:
+		if (fmt == NULL || *fmt == '\0') {
+			mprAllocSprintf(out, size, "%f", obj->floating);
+		} else {
+			mprAllocSprintf(out, size, fmt, obj->floating);
+		}
+		break;
+#endif
+
+	case MPR_TYPE_INT:
+		if (fmt == NULL || *fmt == '\0') {
+			mprAllocSprintf(out, size, "%d", obj->integer);
+		} else {
+			mprAllocSprintf(out, size, fmt, obj->integer);
+		}
+		break;
+
+#if BLD_FEATURE_INT64
+	case MPR_TYPE_INT64:
+		if (fmt == NULL || *fmt == '\0') {
+#if BLD_GOAHEAD_WEBSERVER
+			mprAllocSprintf(out, size, "%d", (int) obj->integer64);
+#else
+			mprAllocSprintf(out, size, "%Ld", obj->integer64);
+#endif
+		} else {
+			mprAllocSprintf(out, size, fmt, obj->integer64);
+		}
+		break;
+#endif
+
+	case MPR_TYPE_CFUNCTION:
+		mprAllocSprintf(out, size, "[C Function]");
+		break;
+
+	case MPR_TYPE_STRING_CFUNCTION:
+		mprAllocSprintf(out, size, "[C StringFunction]");
+		break;
+
+	case MPR_TYPE_FUNCTION:
+		mprAllocSprintf(out, size, "[JavaScript Function]");
+		break;
+
+	case MPR_TYPE_OBJECT:
+		/*	FUTURE -- really want: [object class: name]  */
+		mprAllocSprintf(out, size, "[object %s]", obj->name);
+		break;
+
+	case MPR_TYPE_STRING:
+		src = obj->string;
+
+		mprAssert(src);
+		if (fmt && *fmt) {
+			mprAllocSprintf(out, size, fmt, src);
+
+		} else if (src == NULL) {
+			*out = mprStrdup("null");
+
+		} else {
+			*out = mprStrdup(src);
+		}
+		break;
+
+	default:
+		mprAssert(0);
+	}
+}
+
+/******************************************************************************/
+/*
+ *	Parse a string based on formatting instructions and intelligently 
+ *	create a variable.
+ */
+
+MprVar mprParseVar(char *buf, MprType preferredType)
+{
+	MprType		type = MPR_TYPE_UNDEFINED;
+	char		*cp;
+
+	mprAssert(buf);
+
+	if (preferredType == MPR_TYPE_UNDEFINED) {
+		if (*buf == '-') {
+			type = MPR_NUM_VAR;
+
+		} else if (!isdigit((int) *buf)) {
+			if (strcmp(buf, "true") == 0 || strcmp(buf, "false") == 0) {
+				type = MPR_TYPE_BOOL;
+			} else {
+				type = MPR_TYPE_STRING;
+			}
+
+		} else if (isdigit((int) *buf)) {
+			type = MPR_NUM_VAR;
+			cp = buf;
+			if (*cp && tolower((unsigned char)cp[1]) == 'x') {
+				cp = &cp[2];
+			}
+			for (cp = buf; *cp; cp++) {
+				if (! isdigit((unsigned char) *cp)) {
+					break;
+				}
+			}
+
+			if (*cp != '\0') {
+#if BLD_FEATURE_FLOATING_POINT
+				if (*cp == '.' || tolower((unsigned char)*cp) == 'e') {
+					type = MPR_TYPE_FLOAT;
+				} else
+#endif
+				{
+					type = MPR_NUM_VAR;
+				}
+			}
+		}
+	} else {
+		type = preferredType;
+	}
+
+	switch (type) {
+	case MPR_TYPE_OBJECT:
+	case MPR_TYPE_UNDEFINED:
+	case MPR_TYPE_NULL:
+	case MPR_TYPE_PTR:
+	default:
+		break;
+
+	case MPR_TYPE_BOOL:
+		return mprCreateBoolVar(buf[0] == 't' ? 1 : 0);
+
+	case MPR_TYPE_INT:
+		return mprCreateIntegerVar(mprParseInteger(buf));
+
+#if BLD_FEATURE_INT64
+	case MPR_TYPE_INT64:
+		return mprCreateInteger64Var(mprParseInteger64(buf));
+#endif
+
+	case MPR_TYPE_STRING:
+		if (strcmp(buf, "null") == 0) {
+			return mprCreateNullVar();
+		} else if (strcmp(buf, "undefined") == 0) {
+			return mprCreateUndefinedVar();
+		} 
+			
+		return mprCreateStringVar(buf, 1);
+
+#if BLD_FEATURE_FLOATING_POINT
+	case MPR_TYPE_FLOAT:
+		return mprCreateFloatVar(atof(buf));
+#endif
+
+	}
+	return mprCreateUndefinedVar();
+}
+
+/******************************************************************************/
+/*
+ *	Convert the variable to a boolean. Only for primitive types.
+ */
+
+bool mprVarToBool(const MprVar *vp)
+{
+	mprAssert(vp);
+
+	switch (vp->type) {
+	case MPR_TYPE_UNDEFINED:
+	case MPR_TYPE_NULL:
+	case MPR_TYPE_STRING_CFUNCTION:
+	case MPR_TYPE_CFUNCTION:
+	case MPR_TYPE_FUNCTION:
+	case MPR_TYPE_OBJECT:
+		return 0;
+
+	case MPR_TYPE_PTR:
+		return (vp->ptr != NULL);
+
+	case MPR_TYPE_BOOL:
+		return vp->boolean;
+
+#if BLD_FEATURE_FLOATING_POINT
+	case MPR_TYPE_FLOAT:
+		return (vp->floating != 0 && !mprIsNan(vp->floating));
+#endif
+
+	case MPR_TYPE_INT:
+		return (vp->integer != 0);
+
+#if BLD_FEATURE_INT64
+	case MPR_TYPE_INT64:
+		return (vp->integer64 != 0);
+#endif
+
+	case MPR_TYPE_STRING:
+		mprAssert(vp->string);
+		return (vp->string[0] != '\0');
+	}
+
+	/* Not reached */
+	return 0;
+}
+
+/******************************************************************************/
+#if BLD_FEATURE_FLOATING_POINT
+/*
+ *	Convert the variable to a floating point number. Only for primitive types.
+ */
+
+double mprVarToFloat(const MprVar *vp)
+{
+	mprAssert(vp);
+
+	switch (vp->type) {
+	case MPR_TYPE_UNDEFINED:
+	case MPR_TYPE_NULL:
+	case MPR_TYPE_STRING_CFUNCTION:
+	case MPR_TYPE_CFUNCTION:
+	case MPR_TYPE_FUNCTION:
+	case MPR_TYPE_OBJECT:
+	case MPR_TYPE_PTR:
+		return 0;
+
+	case MPR_TYPE_BOOL:
+		return (vp->boolean) ? 1.0 : 0.0;
+
+	case MPR_TYPE_FLOAT:
+		return vp->floating;
+
+	case MPR_TYPE_INT:
+		return (double) vp->integer;
+
+#if BLD_FEATURE_INT64
+	case MPR_TYPE_INT64:
+		return (double) vp->integer64;
+#endif
+
+	case MPR_TYPE_STRING:
+		mprAssert(vp->string);
+		return atof(vp->string);
+	}
+
+	/* Not reached */
+	return 0;
+}
+
+#endif
+/******************************************************************************/
+/*
+ *	Convert the variable to a number type. Only works for primitive types.
+ */
+
+MprNum mprVarToNumber(const MprVar *vp)
+{
+#if BLD_FEATURE_NUM_TYPE_ID == MPR_TYPE_INT64
+	return mprVarToInteger64(vp);
+#elif BLD_FEATURE_NUM_TYPE_ID == MPR_TYPE_FLOAT
+	return mprVarToFloat(vp);
+#else 
+	return mprVarToInteger(vp);
+#endif
+}
+
+/******************************************************************************/
+/*
+ *	Convert the variable to a number type. Only works for primitive types.
+ */
+
+MprNum mprParseNumber(char *s)
+{
+#if BLD_FEATURE_NUM_TYPE_ID == MPR_TYPE_INT64
+	return mprParseInteger64(s);
+#elif BLD_FEATURE_NUM_TYPE_ID == MPR_TYPE_FLOAT
+	return mprParseFloat(s);
+#else 
+	return mprParseInteger(s);
+#endif
+}
+
+/******************************************************************************/
+#if BLD_FEATURE_INT64
+/*
+ *	Convert the variable to an Integer64 type. Only works for primitive types.
+ */
+
+int64 mprVarToInteger64(const MprVar *vp)
+{
+	mprAssert(vp);
+
+	switch (vp->type) {
+	case MPR_TYPE_UNDEFINED:
+	case MPR_TYPE_NULL:
+	case MPR_TYPE_STRING_CFUNCTION:
+	case MPR_TYPE_CFUNCTION:
+	case MPR_TYPE_FUNCTION:
+	case MPR_TYPE_OBJECT:
+	case MPR_TYPE_PTR:
+		return 0;
+
+	case MPR_TYPE_BOOL:
+		return (vp->boolean) ? 1 : 0;
+
+#if BLD_FEATURE_FLOATING_POINT
+	case MPR_TYPE_FLOAT:
+		if (mprIsNan(vp->floating)) {
+			return 0;
+		}
+		return (int64) vp->floating;
+#endif
+
+	case MPR_TYPE_INT:
+		return vp->integer;
+
+	case MPR_TYPE_INT64:
+		return vp->integer64;
+
+	case MPR_TYPE_STRING:
+		return mprParseInteger64(vp->string);
+	}
+
+	/* Not reached */
+	return 0;
+}
+
+/******************************************************************************/
+/*
+ *	Convert the string buffer to an Integer64.
+ */
+
+int64 mprParseInteger64(char *str)
+{
+	char	*cp;
+	int64	num64;
+	int		radix, c, negative;
+
+	mprAssert(str);
+
+	cp = str;
+	num64 = 0;
+	negative = 0;
+
+	if (*cp == '-') {
+		cp++;
+		negative = 1;
+	}
+
+	/*
+	 *	Parse a number. Observe hex and octal prefixes (0x, 0)
+	 */
+	if (*cp != '0') {
+		/* 
+		 *	Normal numbers (Radix 10)
+		 */
+		while (isdigit((int) *cp)) {
+			num64 = (*cp - '0') + (num64 * 10);
+			cp++;
+		}
+	} else {
+		cp++;
+		if (tolower((unsigned char)*cp) == 'x') {
+			cp++;
+			radix = 16;
+			while (*cp) {
+				c = tolower((unsigned char)*cp);
+				if (isdigit(c)) {
+					num64 = (c - '0') + (num64 * radix);
+				} else if (c >= 'a' && c <= 'f') {
+					num64 = (c - 'a') + (num64 * radix);
+				} else {
+					break;
+				}
+				cp++;
+			}
+
+		} else{
+			radix = 8;
+			while (*cp) {
+				c = tolower((unsigned char)*cp);
+				if (isdigit(c) && c < '8') {
+					num64 = (c - '0') + (num64 * radix);
+				} else {
+					break;
+				}
+				cp++;
+			}
+		}
+	}
+
+	if (negative) {
+		return 0 - num64;
+	}
+	return num64;
+}
+
+#endif /* BLD_FEATURE_INT64 */
+/******************************************************************************/
+/*
+ *	Convert the variable to an Integer type. Only works for primitive types.
+ */
+
+int mprVarToInteger(const MprVar *vp)
+{
+	mprAssert(vp);
+
+	switch (vp->type) {
+	case MPR_TYPE_UNDEFINED:
+	case MPR_TYPE_NULL:
+	case MPR_TYPE_STRING_CFUNCTION:
+	case MPR_TYPE_CFUNCTION:
+	case MPR_TYPE_FUNCTION:
+	case MPR_TYPE_OBJECT:
+	case MPR_TYPE_PTR:
+		return 0;
+
+	case MPR_TYPE_BOOL:
+		return (vp->boolean) ? 1 : 0;
+
+#if BLD_FEATURE_FLOATING_POINT
+	case MPR_TYPE_FLOAT:
+		if (mprIsNan(vp->floating)) {
+			return 0;
+		}
+		return (int) vp->floating;
+#endif
+
+	case MPR_TYPE_INT:
+		return vp->integer;
+
+#if BLD_FEATURE_INT64
+	case MPR_TYPE_INT64:
+		return (int) vp->integer64;
+#endif
+
+	case MPR_TYPE_STRING:
+		return mprParseInteger(vp->string);
+	}
+
+	/* Not reached */
+	return 0;
+}
+
+/******************************************************************************/
+/*
+ *	Convert the string buffer to an Integer.
+ */
+
+int mprParseInteger(char *str)
+{
+	char	*cp;
+	int		num;
+	int		radix, c, negative;
+
+	mprAssert(str);
+
+	cp = str;
+	num = 0;
+	negative = 0;
+
+	if (*cp == '-') {
+		cp++;
+		negative = 1;
+	}
+
+	/*
+	 *	Parse a number. Observe hex and octal prefixes (0x, 0)
+	 */
+	if (*cp != '0') {
+		/* 
+		 *	Normal numbers (Radix 10)
+		 */
+		while (isdigit((int) *cp)) {
+			num = (*cp - '0') + (num * 10);
+			cp++;
+		}
+	} else {
+		cp++;
+		if (tolower((unsigned char)*cp) == 'x') {
+			cp++;
+			radix = 16;
+			while (*cp) {
+				c = tolower((unsigned char)*cp);
+				if (isdigit(c)) {
+					num = (c - '0') + (num * radix);
+				} else if (c >= 'a' && c <= 'f') {
+					num = (c - 'a') + (num * radix);
+				} else {
+					break;
+				}
+				cp++;
+			}
+
+		} else{
+			radix = 8;
+			while (*cp) {
+				c = tolower((unsigned char)*cp);
+				if (isdigit(c) && c < '8') {
+					num = (c - '0') + (num * radix);
+				} else {
+					break;
+				}
+				cp++;
+			}
+		}
+	}
+
+	if (negative) {
+		return 0 - num;
+	}
+	return num;
+}
+
+/******************************************************************************/
+#if BLD_FEATURE_FLOATING_POINT
+/*
+ *	Convert the string buffer to an Floating.
+ */
+
+double mprParseFloat(char *str)
+{
+	return atof(str);
+}
+
+/******************************************************************************/
+
+bool mprIsNan(double f)
+{
+#if WIN
+	return _isnan(f);
+#elif VXWORKS
+	/* FUTURE */
+	return (0);
+#else
+	return (f == FP_NAN);
+#endif
+}
+/******************************************************************************/
+
+bool mprIsInfinite(double f)
+{
+#if WIN
+	return !_finite(f);
+#elif VXWORKS
+	/* FUTURE */
+	return (0);
+#else
+	return (f == FP_INFINITE);
+#endif
+}
+
+#endif /* BLD_FEATURE_FLOATING_POINT */
+/******************************************************************************/
+
+/*
+ * Local variables:
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ * vim:tw=78
+ * vim600: sw=4 ts=4 fdm=marker
+ * vim<600: sw=4 ts=4
+ */