10 files changed, 1125 insertions, 0 deletions
diff --git a/intern/memutil/MEM_NonCopyable.h b/intern/memutil/MEM_NonCopyable.h
new file mode 100644
index 00000000000..88284d53803
--- /dev/null
+++ b/intern/memutil/MEM_NonCopyable.h
@@ -0,0 +1,59 @@
+/**
+ * $Id$
+ * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
+ *
+ * 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. The Blender
+ * Foundation also sells licenses for use in proprietary software under
+ * the Blender License.  See http://www.blender.org/BL/ for information
+ * about this.
+ *
+ * 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): none yet.
+ *
+ * ***** END GPL/BL DUAL LICENSE BLOCK *****
+ */
+
+#ifndef NAN_INCLUDED_NonCopyable_h
+
+#define NAN_INCLUDED_NonCopyable_h
+
+/**
+ * Simple class that makes sure sub classes cannot
+ * generate standard copy constructors.
+ * If you want to make sure that your class does
+ * not have any of these cheesy hidden constructors
+ * inherit from this class.
+ */
+
+class MEM_NonCopyable {
+protected :
+
+	MEM_NonCopyable(
+	) {
+	};
+
+private :
+
+	MEM_NonCopyable (const MEM_NonCopyable *);
+	MEM_NonCopyable (const MEM_NonCopyable &);
+};
+
+#endif
+
+
diff --git a/intern/memutil/MEM_RefCountPtr.h b/intern/memutil/MEM_RefCountPtr.h
new file mode 100644
index 00000000000..fb563109087
--- /dev/null
+++ b/intern/memutil/MEM_RefCountPtr.h
@@ -0,0 +1,294 @@
+/**
+ * $Id$
+ * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
+ *
+ * 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. The Blender
+ * Foundation also sells licenses for use in proprietary software under
+ * the Blender License.  See http://www.blender.org/BL/ for information
+ * about this.
+ *
+ * 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): none yet.
+ *
+ * ***** END GPL/BL DUAL LICENSE BLOCK *****
+ */
+
+#ifndef NAN_INCLUDED_MEM_RefCountPtr_h
+
+#define NAN_INCLUDED_MEM_RefCountPtr_h
+
+/**
+ * $Id$
+ * Copyright (C) 2001 NaN Technologies B.V.
+ *
+ * @author Laurence
+ */
+
+#include <stdlib.h> // for NULL !
+
+/**
+ * @section MEM_RefCountable
+ * This is a base class for reference countable objects.
+ * If you want an object to be shared using a reference 
+ * counted system derrivce from this class. All subclasses
+ * should insist that they are created on the heap, this
+ * can be done by makeing all constructors private and 
+ * defining a static New() method that returns a ref counted
+ * ptr to a new()ly allocated instance. 
+ *
+ * @section Example subclass
+ *
+ *
+ * class MySharedObject : public MEM_RefCountable {
+ *
+ * private :
+ *	MySharedObject() : MEM_RefCountable() { //class specific initialization};
+ *  MySharedObject(const MySharedObject &other) // not implemented
+ * public :
+ *		static	
+ *			MEM_RefCountPtr<MySharedObject> 
+ *		New(
+ *		) {
+ *			return MEM_RefCountPtr<MySharedObject>( new MySharedObject());
+ *		}
+ *		
+ *		// other member functions
+ * };
+ *
+ * Alternitively you may first wish to define a fully functional
+ * class and then define a reference counting wrapper for this class.
+ * This is useful when the base type can be used without reference
+ * counting.
+ *
+ * E.g.
+ * class UsefullClass {
+ * private :
+ *  ...
+ * public :
+ *
+ *      UsefullClass()
+ *      UsefullMethod(...)
+ *      AnotherUsefullMethod(...)
+ * };
+ *
+ * class RcUsefullClass : public UsefullClass, public MEM_RefCountable
+ * {
+ * private :
+ *      // Override base class public constructor --- forces
+ *      // use of New(...)
+ *      RcUsefullClass(...)
+ * public :
+ *
+ *  // Override each public constructor of UsefullClass with
+ *  // an equivalent static New method returning a MEM_RefCountPtr
+ *
+ *  static
+ *      MEM_RefCountPtr<RcUsefullClass>
+ *  New(...){
+ *       return MEM_RefCountPtr<RcUsefullClass> output(
+ *           new UsefullClass(...)
+ *       );
+ *   }
+ *
+ *  // warning never call destructor directly allow ref counting
+ *  // mechanism to handle object lifetime.
+ *  ~RcUsefullClass();
+ * };
+ *
+ *
+ */
+
+class MEM_RefCountable {
+private :
+
+	/**
+	 * The reference count!
+	 * We use mutable here because we would like to
+	 * share references of const objects!
+	 * Maybe should think about having decRef()
+	 * another value because we should not be deleting
+	 * non-const objects
+	 */
+
+	mutable int m_count;
+
+protected :
+
+	/**
+	 * Protected constructors
+	 * This class is not for direct instanciation. Sub classes
+	 * should only be allocated on the heap.
+	 */
+
+	MEM_RefCountable (
+	) :
+		m_count (0)
+	{
+	};
+
+	MEM_RefCountable (
+		const MEM_RefCountable & other
+	) :
+		m_count (0)
+	{
+	}
+
+public :
+
+		void
+	IncRef(
+	) const {
+		m_count++;
+	}
+
+		int
+	DecRef(
+	) {
+		return (--m_count);
+	}
+
+	~MEM_RefCountable(
+	) {
+		//nothing to do
+	}
+};
+
+/**
+ * @section MEM_RefCountPtr
+ */
+
+template
+	< class T >
+class MEM_RefCountPtr {
+
+public :
+
+	/**
+	 * Construction from reference - share ownership with
+	 * the right hand side.
+	 */
+
+	MEM_RefCountPtr(
+		const MEM_RefCountPtr &rhs
+	) : m_val (NULL) {
+		ShareOwnership(rhs.m_val);
+	}
+
+	/**
+	 * Construction from ptr - this class shares
+	 * ownership of object val.
+	 */
+
+	MEM_RefCountPtr(
+		const T* val
+	) :
+		m_val (NULL)
+	{
+		ShareOwnership(val);
+	}
+
+	/**
+	 * Defalut constructor
+	 */
+
+	MEM_RefCountPtr(
+	) :
+		m_val (NULL)
+	{
+	}
+
+	/**
+	 * Type conversion from this class to the type
+	 * of a pointer to the template parameter.
+	 * This means you can pass an instance of this class
+	 * to a function expecting a ptr of type T.
+	 */
+
+	operator T * () const {
+		return m_val;
+	}
+
+
+	MEM_RefCountPtr & operator=(
+		const MEM_RefCountPtr &rhs
+	) {
+		if (this->m_val != rhs.m_val) {
+			ReleaseOwnership();
+			ShareOwnership(rhs.m_val);
+		}
+		return *this;
+	}
+
+	/**
+	 * Overload the operator -> so that it's possible to access
+	 * all the normal methods of the internal ptr.
+	 */
+
+	T * operator->() const {
+		return m_val;
+	}
+
+	/**
+	 * Returrn a reference to the shared object.
+	 */
+
+		T&
+	Ref(
+	) {
+		return *m_val;
+	}
+
+	/**
+	 * Destructor - deletes object if it's ref count is zero.
+	 */
+
+	~MEM_RefCountPtr(
+	) {
+		ReleaseOwnership();
+	}
+
+private :
+	
+	/// The ptr owned by this class.
+	T * m_val;
+
+		void
+	ShareOwnership(
+		const T * val
+	) {
+		if (val != NULL) {
+			val->IncRef();
+		}
+		m_val = const_cast<T *>(val);
+	}
+		
+		void
+	ReleaseOwnership(
+	) {
+		if (m_val) {
+			if (m_val->DecRef() == 0) {
+				delete(m_val);
+				m_val = NULL;
+			}
+		}
+	}
+
+};
+
+#endif
diff --git a/intern/memutil/MEM_RefCounted.h b/intern/memutil/MEM_RefCounted.h
new file mode 100644
index 00000000000..3531f700ee3
--- /dev/null
+++ b/intern/memutil/MEM_RefCounted.h
@@ -0,0 +1,120 @@
+/**
+ * $Id$
+ * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
+ *
+ * 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. The Blender
+ * Foundation also sells licenses for use in proprietary software under
+ * the Blender License.  See http://www.blender.org/BL/ for information
+ * about this.
+ *
+ * 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): none yet.
+ *
+ * ***** END GPL/BL DUAL LICENSE BLOCK *****
+ */
+
+/**
+
+ * $Id$
+ * Copyright (C) 2001 NaN Technologies B.V.
+ * @author	Maarten Gribnau
+ * @date	March 31, 2001
+ */
+
+#ifndef _H_MEM_REF_COUNTED
+#define _H_MEM_REF_COUNTED
+
+
+/**
+ * An object with reference counting.
+ * Base class for objects with reference counting.
+ * When a shared object is ceated, it has reference count == 1.
+ * If the the reference count of a shared object reaches zero, the object self-destructs.
+ * The default destructor of this object has been made protected on purpose.
+ * This disables the creation of shared objects on the stack.
+ *
+ * @author	Maarten Gribnau
+ * @date	March 31, 2001
+ */
+
+class MEM_RefCounted {
+public:
+	/**
+	 * Constructs a a shared object.
+	 */
+	MEM_RefCounted() : m_refCount(1)
+	{
+	}
+
+	/** 
+	 * Returns the reference count of this object.
+	 * @return the reference count.
+	 */
+	inline virtual int getRef() const;
+
+	/** 
+	 * Increases the reference count of this object.
+	 * @return the new reference count.
+	 */
+	inline virtual int incRef();
+
+	/** 
+	 * Decreases the reference count of this object.
+	 * If the the reference count reaches zero, the object self-destructs.
+	 * @return the new reference count.
+	 */
+	inline virtual int decRef();
+
+protected:
+	/**
+	 * Destructs a shared object.
+	 * The destructor is protected to force the use of incRef and decRef.
+	 */
+	virtual ~MEM_RefCounted()
+	{
+	}
+
+protected:
+	/// The reference count.
+	int m_refCount;
+};
+
+
+inline int MEM_RefCounted::getRef() const
+{
+	return m_refCount;
+}
+
+inline int MEM_RefCounted::incRef()
+{
+	return ++m_refCount;
+}
+
+inline int MEM_RefCounted::decRef()
+{
+	m_refCount--;
+	if (m_refCount == 0) {
+		delete this;
+		return 0;
+	}
+	return m_refCount;
+}
+
+
+#endif // _H_MEM_REF_COUNTED
+\ No newline at end of file
diff --git a/intern/memutil/MEM_RefCountedC-Api.h b/intern/memutil/MEM_RefCountedC-Api.h
new file mode 100644
index 00000000000..abaef47604c
--- /dev/null
+++ b/intern/memutil/MEM_RefCountedC-Api.h
@@ -0,0 +1,90 @@
+/**
+ * $Id$
+ * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
+ *
+ * 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. The Blender
+ * Foundation also sells licenses for use in proprietary software under
+ * the Blender License.  See http://www.blender.org/BL/ for information
+ * about this.
+ *
+ * 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): none yet.
+ *
+ * ***** END GPL/BL DUAL LICENSE BLOCK *****
+ */
+
+/**
+
+ * $Id$
+ * Copyright (C) 2001 NaN Technologies B.V.
+ * Interface for C access to functionality relating to shared objects in the foundation library.
+ * @author	Maarten Gribnau
+ * @date	June 17, 2001
+ */
+
+#ifndef _H_MEM_REF_COUNTED_C_API
+#define _H_MEM_REF_COUNTED_C_API
+
+/** A pointer to a private object. */
+typedef struct MEM_TOpaqueObject* MEM_TObjectPtr;
+/** A pointer to a shared object. */
+typedef MEM_TObjectPtr MEM_TRefCountedObjectPtr;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/**
+ * A shared object in an object with reference counting.
+ * When a shared object is ceated, it has reference count == 1.
+ * If the the reference count of a shared object reaches zero, the object self-destructs.
+ * The default constrcutor and destructor of this object have been made protected on purpose.
+ * This disables the creation and disposal of shared objects on the stack.
+ */
+
+/** 
+ * Returns the reference count of this object.
+ * @param shared The object to query.
+ * @return The current reference count.
+ */
+extern int	MEM_RefCountedGetRef(MEM_TRefCountedObjectPtr shared);
+
+/** 
+ * Increases the reference count of this object.
+ * @param shared The object to query.
+ * @return The new reference count.
+ */
+extern int	MEM_RefCountedIncRef(MEM_TRefCountedObjectPtr shared);
+
+/** 
+ * Decreases the reference count of this object.
+ * If the the reference count reaches zero, the object self-destructs.
+ * @param shared The object to query.
+ * @return The new reference count.
+ */
+extern int	MEM_RefCountedDecRef(MEM_TRefCountedObjectPtr shared);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _H_MEM_REF_COUNTED_C_API
+\ No newline at end of file
diff --git a/intern/memutil/MEM_SmartPtr.h b/intern/memutil/MEM_SmartPtr.h
new file mode 100644
index 00000000000..b47b2bdc1a4
--- /dev/null
+++ b/intern/memutil/MEM_SmartPtr.h
@@ -0,0 +1,240 @@
+/**
+ * $Id$
+ * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
+ *
+ * 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. The Blender
+ * Foundation also sells licenses for use in proprietary software under
+ * the Blender License.  See http://www.blender.org/BL/ for information
+ * about this.
+ *
+ * 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): none yet.
+ *
+ * ***** END GPL/BL DUAL LICENSE BLOCK *****
+ */
+
+#ifndef NAN_INCLUDED_MEM_SmartPtr_h
+
+#define NAN_INCLUDED_MEM_SmartPtr_h
+
+/**
+ * $Id$
+ * Copyright (C) 2001 NaN Technologies B.V.
+ *
+ * @author Laurence
+ */
+
+#include <stdlib.h> // for NULL !
+
+/**
+ * @section MEM_SmartPtr 
+ * This class defines a smart pointer similar to that defined in 
+ * the Standard Template Library but without the painful get()
+ * semantics to access the internal c style pointer.
+ *
+ * It is often useful to explicitely decalre ownership of memory
+ * allocated on the heap within class or function scope. This
+ * class helps you to encapsulate this ownership within a value
+ * type. When an instance of this class goes out of scope it
+ * makes sure that any memory associated with it's internal pointer
+ * is deleted. It can help to inform users of an aggregate class
+ * that it owns instances of it's members and these instances 
+ * should not be shared. This is not reliably enforcable in C++
+ * but this class attempts to make the 1-1 relationship clear.
+ * 
+ * @section Example usage
+ *
+ * class foo {
+ *		...constructors accessors etc.
+ *		int x[1000];
+ * }
+ * 
+ * class bar {
+ *  public :
+ *		static
+ *			bar *
+ *		New(
+ *		) {
+ *			MEM_SmartPtr<foo> afoo = new foo();
+ *			MEM_SmartPtr<bar> that = new bar();
+ *
+ *			if (foo == NULL || that == NULL) return NULL;
+ *
+ *			that->m_foo = afoo.Release();
+ *			return that.Release();
+ *		}
+ *
+ *		~bar() {
+ *			// smart ptr takes care of deletion
+ *		}
+ *	private :
+ *		MEM_SmartPtr<foo> m_foo;
+ *	}
+ *			
+ * You my also safely construct vectors of MEM_SmartPtrs and 
+ * have the vector own stuff you put into it. 
+ *
+ * e.g.
+ * { 
+ * std::vector<MEM_SmartPtr<foo> > foo_vector;
+ * foo_vector.push_back( new foo());
+ * foo_vector.push_back( new foo());
+ *
+ * foo_vector[0]->bla();
+ * } // foo_vector out of scope => heap memory freed for both foos
+ *
+ * @warning this class should only be used for objects created
+ * on the heap via the new function. It will not behave correctly
+ * if you pass ptrs to objects created with new[] nor with 
+ * objects declared on the stack. Doing this is likely to crash
+ * the program or lead to memory leaks.
+ */
+
+template 
+	< class T >
+class MEM_SmartPtr {
+
+public :
+
+	/**
+	 * Construction from reference - this class
+	 * always assumes ownership from the rhs.
+	 */
+
+	MEM_SmartPtr(
+		const MEM_SmartPtr &rhs
+	){
+		m_val = rhs.Release();
+	}
+
+	/**
+	 * Construction from ptr - this class always
+	 * assumes that it now owns the memory associated with the
+	 * ptr.
+	 */
+
+	MEM_SmartPtr(
+		T* val
+	) :
+		m_val (val)
+	{
+	}
+	
+	/**
+	 * Defalut constructor
+	 */
+
+	MEM_SmartPtr(
+	) :
+		m_val (NULL)
+	{
+	}
+
+	/**
+	 * Type conversion from this class to the type
+	 * of a pointer to the template parameter. 
+	 * This means you can pass an instance of this class
+	 * to a function expecting a ptr of type T.
+	 */
+
+	operator T * () const {
+		return m_val;
+	}
+
+	/**
+	 * Return a reference to the internal ptr class.
+	 * Use with care when you now that the internal ptr
+	 * is not NULL!
+	 */
+
+		T &
+	Ref(
+	) const {
+		return *m_val;
+	}	
+
+	/** 
+	 * Assignment operator - ownership is transfered from rhs to lhs. 
+	 * There is an intenional side-effect of function of transferring
+	 * ownership from the const parameter rhs. This is to insure 
+	 * the 1-1 relationship.
+	 * The object associated with this instance is deleted if it 
+	 * is not the same as that contained in the rhs.
+	 */
+
+	MEM_SmartPtr & operator=(
+		const MEM_SmartPtr &rhs
+	) {
+		if (this->m_val != rhs.m_val) {
+			delete this->m_val;
+		}
+
+		this->m_val = rhs.Release();
+		return *this;
+	}
+	
+	/** 
+	 * Overload the operator -> so that it's possible to access
+	 * all the normal methods of the internal ptr. 
+	 */
+	
+	T * operator->() const {
+		return m_val;
+	}
+
+	/**
+	 * Caller takes ownership of the object - the object will not 
+	 * be deleted when the ptr goes out of scope.
+	 */
+
+		T *
+	Release(
+	) const {
+		T* temp = m_val;
+		(const_cast<MEM_SmartPtr *>(this))->m_val = NULL;	
+		return temp;
+	}
+
+	/**
+	 * Force destruction of the internal object.
+	 */
+	
+		void
+	Delete(
+	) {
+		delete (m_val);
+		m_val = NULL;
+	}
+
+	/** 
+	 * Destructor - deletes object if it exists
+	 */
+
+	~MEM_SmartPtr(
+	) {
+		delete (m_val);
+	}
+
+private :
+	
+	/// The ptr owned by this class.
+	T * m_val;
+};
+
+#endif
diff --git a/intern/memutil/Makefile b/intern/memutil/Makefile
new file mode 100644
index 00000000000..e163fa63eff
--- /dev/null
+++ b/intern/memutil/Makefile
@@ -0,0 +1,52 @@
+#
+# $Id$
+#
+# ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
+#
+# 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. The Blender
+# Foundation also sells licenses for use in proprietary software under
+# the Blender License.  See http://www.blender.org/BL/ for information
+# about this.
+#
+# 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+# The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
+# All rights reserved.
+#
+# The Original Code is: all of this file.
+#
+# Contributor(s): none yet.
+#
+# ***** END GPL/BL DUAL LICENSE BLOCK *****
+# memutil main makefile.
+#
+
+include nan_definitions.mk
+
+LIBNAME = memutil
+SOURCEDIR = intern/$(LIBNAME)
+DIR = $(OCGDIR)/$(SOURCEDIR)
+DIRS = intern
+#not yet TESTDIRS = test
+ 
+include nan_subdirs.mk
+
+install: all debug
+	@[ -d $(NAN_MEMUTIL) ] || mkdir $(NAN_MEMUTIL)
+	@[ -d $(NAN_MEMUTIL)/include ] || mkdir $(NAN_MEMUTIL)/include
+	@[ -d $(NAN_MEMUTIL)/lib ] || mkdir $(NAN_MEMUTIL)/lib
+	@[ -d $(NAN_MEMUTIL)/lib/debug ] || mkdir $(NAN_MEMUTIL)/lib/debug
+	cp -f $(DIR)/libmemutil.a $(NAN_MEMUTIL)/lib/
+	cp -f $(DIR)/debug/libmemutil.a $(NAN_MEMUTIL)/lib/debug
+	cp -f *.h $(NAN_MEMUTIL)/include/
+
diff --git a/intern/memutil/intern/MEM_RefCountedC-Api.cpp b/intern/memutil/intern/MEM_RefCountedC-Api.cpp
new file mode 100644
index 00000000000..92f02ac78fa
--- /dev/null
+++ b/intern/memutil/intern/MEM_RefCountedC-Api.cpp
@@ -0,0 +1,64 @@
+/**
+ * $Id$
+ * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
+ *
+ * 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. The Blender
+ * Foundation also sells licenses for use in proprietary software under
+ * the Blender License.  See http://www.blender.org/BL/ for information
+ * about this.
+ *
+ * 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): none yet.
+ *
+ * ***** END GPL/BL DUAL LICENSE BLOCK *****
+ */
+
+/**
+
+ * $Id$
+ * Copyright (C) 2001 NaN Technologies B.V.
+ * @author	Maarten Gribnau
+ * @date	Jun 17, 2001
+ */
+
+#include "MEM_RefCountedC-Api.h"
+
+#include "MEM_RefCounted.h"
+
+
+
+int MEM_RefCountedGetRef(MEM_TRefCountedObjectPtr shared)
+{
+	return shared ? ((MEM_RefCounted*)shared)->getRef() : 0;
+}
+
+
+int MEM_RefCountedIncRef(MEM_TRefCountedObjectPtr shared)
+{
+	return shared ? ((MEM_RefCounted*)shared)->incRef() : 0;
+}
+
+
+int MEM_RefCountedDecRef(MEM_TRefCountedObjectPtr shared)
+{
+	return shared ? ((MEM_RefCounted*)shared)->decRef() : 0;
+}
+
+
+
diff --git a/intern/memutil/intern/Makefile b/intern/memutil/intern/Makefile
new file mode 100644
index 00000000000..0d0d3af6327
--- /dev/null
+++ b/intern/memutil/intern/Makefile
@@ -0,0 +1,42 @@
+#
+# $Id$
+#
+# ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
+#
+# 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. The Blender
+# Foundation also sells licenses for use in proprietary software under
+# the Blender License.  See http://www.blender.org/BL/ for information
+# about this.
+#
+# 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+# The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
+# All rights reserved.
+#
+# The Original Code is: all of this file.
+#
+# Contributor(s): none yet.
+#
+# ***** END GPL/BL DUAL LICENSE BLOCK *****
+# memutil intern Makefile
+#
+
+LIBNAME = memutil
+DIR = $(OCGDIR)/intern/$(LIBNAME)
+
+include nan_compile.mk
+
+CCFLAGS += $(LEVEL_2_CPP_WARNINGS)
+
+CPPFLAGS += -I..
+
diff --git a/intern/memutil/make/msvc_60/memutil.dsp b/intern/memutil/make/msvc_60/memutil.dsp
new file mode 100644
index 00000000000..85e903f8764
--- /dev/null
+++ b/intern/memutil/make/msvc_60/memutil.dsp
@@ -0,0 +1,134 @@
+# Microsoft Developer Studio Project File - Name="memutil" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Static Library" 0x0104
+
+CFG=memutil - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "memutil.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "memutil.mak" CFG="memutil - Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "memutil - Win32 Release" (based on "Win32 (x86) Static Library")
+!MESSAGE "memutil - Win32 Debug" (based on "Win32 (x86) Static Library")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "memutil - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "../../../../../obj/windows/intern/memutil"
+# PROP Intermediate_Dir "../../../../../obj/windows/intern/memutil"
+# PROP Target_Dir ""
+LINK32=link.exe -lib
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /YX /FD /c
+# ADD CPP /nologo /MT /W3 /GX /O2 /Ob2 /I "../.." /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /YX /FD /c
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo /out:"Release\memutil.lib"
+# Begin Special Build Tool
+SOURCE="$(InputPath)"
+PostBuild_Cmds=ECHO Copying header files	COPY "..\..\*.h" "..\..\..\..\lib\windows\memutil\include"	ECHO Copying lib	COPY "Release\memutil.lib" "..\..\..\..\lib\windows\memutil\lib\memutil.a"	ECHO Done
+# End Special Build Tool
+
+!ELSEIF  "$(CFG)" == "memutil - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "../../../../../obj/windows/intern/memutil/debug"
+# PROP Intermediate_Dir "../../../../../obj/windows/intern/memutil/debug"
+# PROP Target_Dir ""
+LINK32=link.exe -lib
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c
+# ADD CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /I "../.." /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo /out:"Debug\memutil.lib"
+# Begin Special Build Tool
+SOURCE="$(InputPath)"
+PostBuild_Cmds=ECHO Copying header files	COPY "..\..\*.h" "..\..\..\..\lib\windows\memutil\include"	ECHO Copying lib	COPY "Debug\memutil.lib" "..\..\..\..\lib\windows\memutil\lib\debug\memutil.a"	ECHO Copying Debug info.	COPY "Debug\vc60.*" "..\..\..\..\lib\windows\memutil\lib\debug\"	ECHO Done
+# End Special Build Tool
+
+!ENDIF 
+
+# Begin Target
+
+# Name "memutil - Win32 Release"
+# Name "memutil - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
+# Begin Source File
+
+SOURCE="..\..\intern\MEM_RefCountedC-Api.cpp"
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl"
+# Begin Group "intern"
+
+# PROP Default_Filter ""
+# End Group
+# Begin Group "extern"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\MEM_NonCopyable.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\MEM_RefCounted.h
+# End Source File
+# Begin Source File
+
+SOURCE="..\..\MEM_RefCountedC-Api.h"
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\MEM_RefCountPtr.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\MEM_SmartPtr.h
+# End Source File
+# End Group
+# End Group
+# End Target
+# End Project
diff --git a/intern/memutil/make/msvc_60/memutil.dsw b/intern/memutil/make/msvc_60/memutil.dsw
new file mode 100644
index 00000000000..2ac4d9e7a48
--- /dev/null
+++ b/intern/memutil/make/msvc_60/memutil.dsw
@@ -0,0 +1,30 @@
+Microsoft Developer Studio Workspace File, Format Version 6.00
+# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
+
+
+###############################################################################
+
+Project: "memutil"=".\memutil.dsp" - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Global:
+
+Package=<5>
+{{{
+}}}
+
+Package=<3>
+{{{
+}}}
+
+###############################################################################
+