archive/blender-archive
Archived
1
1
Fork 0
Code Pull Requests Packages Activity

Initial revision

Browse Source
This commit is contained in:
Hans Lambermont
2002-10-12 11:37:38 +00:00
commit 12315f4d0e
1699 changed files with 444708 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

59
intern/memutil/MEM_NonCopyable.h Normal file
View File

@@ -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

294
intern/memutil/MEM_RefCountPtr.h Normal file
View File

@@ -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

120
intern/memutil/MEM_RefCounted.h Normal file
View File

@@ -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

90
intern/memutil/MEM_RefCountedC-Api.h Normal file
View File

@@ -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

240
intern/memutil/MEM_SmartPtr.h Normal file
View File

@@ -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

52
intern/memutil/Makefile Normal file
View File

@@ -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/

64
intern/memutil/intern/MEM_RefCountedC-Api.cpp Normal file
View File

@@ -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;
}

42
intern/memutil/intern/Makefile Normal file
View File

@@ -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..

134
intern/memutil/make/msvc_60/memutil.dsp Normal file
View File

@@ -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

30
intern/memutil/make/msvc_60/memutil.dsw Normal file
View File

@@ -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>
{{{
}}}
###############################################################################