- added a stripped down version of ZDoom's DObject.

This only retains the objecct factory feature, but removes the garbage collector which I have no use for.

# Conflicts:
#	source/CMakeLists.txt

source/CMakeLists.txt

@@ -623,6 +623,7 @@ file( GLOB HEADER_FILES
 	common/console/*.h
 	common/filesystem/*.h
 	common/music/*.h
+	common/dobject/*.h
 
 	build/src/*.h
 	thirdparty/include/*.h
@@ -664,6 +665,8 @@ set( FASTMATH_SOURCES
 
 
 set (PCH_SOURCES
+	common/dobject/__autostart.cpp # must be first
+	
 	audiolib/src/drivers.cpp
 	audiolib/src/driver_adlib.cpp
 	audiolib/src/driver_nosound.cpp
@@ -825,6 +828,10 @@ set (PCH_SOURCES
 	common/music/backend/i_sound.cpp
 
 
+	common/dobject/dobject.cpp
+	common/dobject/dobjtype.cpp
+	
+	common/dobject/zzautozend.cpp #must be last
 )
 
 if( MSVC )
@@ -887,6 +894,7 @@ include_directories(
 	common/textures
 	common/filesystem
 	common/music
+	common/dobject
 	platform
 
 	${CMAKE_BINARY_DIR}/libraries/gdtoa
@@ -995,6 +1003,7 @@ source_group("Code\\Console" REGULAR_EXPRESSION "^${CMAKE_CURRENT_SOURCE_DIR}/co
 source_group("Code\\Fonts" REGULAR_EXPRESSION "^${CMAKE_CURRENT_SOURCE_DIR}/common/fonts/.+")
 source_group("Code\\File System" REGULAR_EXPRESSION "^${CMAKE_CURRENT_SOURCE_DIR}/common/filesystem/.+")
 source_group("Code\\Music" REGULAR_EXPRESSION "^${CMAKE_CURRENT_SOURCE_DIR}/common/music/.+")
+source_group("Code\\DObject" REGULAR_EXPRESSION "^${CMAKE_CURRENT_SOURCE_DIR}/common/dobject/.+")
 source_group("Utility\\Audiolib" REGULAR_EXPRESSION "^${CMAKE_CURRENT_SOURCE_DIR}/audiolib/.+")
 source_group("Utility\\Audiolib Headers" REGULAR_EXPRESSION "^${CMAKE_CURRENT_SOURCE_DIR}/audiolib/include/.+")
 source_group("Utility\\Audiolib Sources" REGULAR_EXPRESSION "^${CMAKE_CURRENT_SOURCE_DIR}/audiolib/src/.+")

source/common/dobject/__autostart.cpp

@@ -0,0 +1,75 @@
+/*
+** autostart.cpp
+** This file contains the heads of lists stored in special data segments
+**
+**---------------------------------------------------------------------------
+** Copyright 1998-2006 Randy Heit
+** All rights reserved.
+**
+** Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions
+** are met:
+**
+** 1. Redistributions of source code must retain the above copyright
+**    notice, this list of conditions and the following disclaimer.
+** 2. Redistributions in binary form must reproduce the above copyright
+**    notice, this list of conditions and the following disclaimer in the
+**    documentation and/or other materials provided with the distribution.
+** 3. The name of the author may not be used to endorse or promote products
+**    derived from this software without specific prior written permission.
+**
+** THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+** IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+** OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+** IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+** INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+** NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+** THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+**---------------------------------------------------------------------------
+**
+** The particular scheme used here was chosen because it's small.
+**
+** An alternative that will work with any C++ compiler is to use static
+** classes to build these lists at run time. Under Visual C++, doing things
+** that way can require a lot of extra space, which is why I'm doing things
+** this way.
+**
+** In the case of PClass lists (section creg), I orginally used the
+** constructor to do just that, and the code for that still exists if you
+** compile with something other than Visual C++ or GCC.
+*/
+
+#include "autosegs.h"
+
+#if defined(_MSC_VER)
+
+// The various reg sections are used to group pointers spread across multiple
+// source files into cohesive arrays in the final executable. We don't
+// actually care about these sections themselves and merge them all into
+// a single section during the final link. (.rdata is the standard section
+// for initialized read-only data.)
+
+#pragma comment(linker, "/merge:.creg=.rdata")
+
+#pragma section(".creg$a",read)
+__declspec(allocate(".creg$a")) void *const CRegHead = 0;
+
+#elif defined(__GNUC__)
+
+#include "doomtype.h"
+
+// I don't know of an easy way to merge sections together with the GNU linker,
+// so GCC users will see all of these sections appear in the final executable.
+// (There are linker scripts, but that apparently involves extracting the
+// default script from ld and then modifying it.)
+
+void *const CRegHead __attribute__((section(SECTION_CREG))) = 0;
+
+#else
+
+#error Please fix autostart.cpp for your compiler
+
+#endif

source/common/dobject/autosegs.h

@@ -0,0 +1,102 @@
+/*
+** autosegs.h
+** Arrays built at link-time
+**
+**---------------------------------------------------------------------------
+** Copyright 1998-2006 Randy Heit
+** All rights reserved.
+**
+** Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions
+** are met:
+**
+** 1. Redistributions of source code must retain the above copyright
+**    notice, this list of conditions and the following disclaimer.
+** 2. Redistributions in binary form must reproduce the above copyright
+**    notice, this list of conditions and the following disclaimer in the
+**    documentation and/or other materials provided with the distribution.
+** 3. The name of the author may not be used to endorse or promote products
+**    derived from this software without specific prior written permission.
+**
+** THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+** IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+** OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+** IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+** INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+** NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+** THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+**---------------------------------------------------------------------------
+**
+*/
+
+#ifndef AUTOSEGS_H
+#define AUTOSEGS_H
+
+#define REGMARKER(x) (x)
+typedef void * const REGINFO;
+
+// List of Action functons
+extern REGINFO ARegHead;
+extern REGINFO ARegTail;
+
+// List of TypeInfos
+extern REGINFO CRegHead;
+extern REGINFO CRegTail;
+
+// List of properties
+extern REGINFO GRegHead;
+extern REGINFO GRegTail;
+
+// List of variables
+extern REGINFO MRegHead;
+extern REGINFO MRegTail;
+
+// List of MAPINFO map options
+extern REGINFO YRegHead;
+extern REGINFO YRegTail;
+
+class FAutoSegIterator
+{
+	public:
+		FAutoSegIterator(REGINFO &head, REGINFO &tail)
+		{
+			// Weirdness. Mingw's linker puts these together backwards.
+			if (&head <= &tail)
+			{
+				Head = &head;
+				Tail = &tail;
+			}
+			else
+			{
+				Head = &tail;
+				Tail = &head;
+			}
+			Probe = Head;
+		}
+		REGINFO operator*() const
+		{
+			return *Probe;
+		}
+		FAutoSegIterator &operator++()
+		{
+			do
+			{
+				++Probe;
+			} while (*Probe == 0 && Probe < Tail);
+			return *this;
+		}
+		void Reset()
+		{
+			Probe = Head;
+		}
+
+	protected:
+		REGINFO *Probe;
+		REGINFO *Head;
+		REGINFO *Tail;
+};
+
+#endif

source/common/dobject/dobject.cpp

@@ -0,0 +1,73 @@
+/*
+** dobject.cpp
+** Implements the base class DObject, which most other classes derive from
+**
+**---------------------------------------------------------------------------
+** Copyright 1998-2006 Randy Heit
+** All rights reserved.
+**
+** Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions
+** are met:
+**
+** 1. Redistributions of source code must retain the above copyright
+**    notice, this list of conditions and the following disclaimer.
+** 2. Redistributions in binary form must reproduce the above copyright
+**    notice, this list of conditions and the following disclaimer in the
+**    documentation and/or other materials provided with the distribution.
+** 3. The name of the author may not be used to endorse or promote products
+**    derived from this software without specific prior written permission.
+**
+** THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+** IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+** OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+** IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+** INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+** NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+** THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+**---------------------------------------------------------------------------
+**
+*/
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "dobject.h"
+
+PClass DObject::_StaticType;
+ClassReg DObject::RegistrationInfo =
+{
+	&DObject::_StaticType,			// MyClass
+	"DObject",						// Name
+	NULL,							// ParentType
+	sizeof(DObject),				// SizeOf
+	NULL,							// Pointers
+	&DObject::InPlaceConstructor	// ConstructNative
+};
+_DECLARE_TI(DObject)
+
+void DObject::InPlaceConstructor (void *mem)
+{
+	new ((EInPlace *)mem) DObject;
+}
+
+DObject::DObject ()
+: Class(0)
+{
+}
+
+DObject::DObject (PClass *inClass)
+: Class(inClass)
+{
+}
+
+DObject::~DObject ()
+{
+}
+
+void DObject::Destroy ()
+{
+}

source/common/dobject/dobject.h

@@ -0,0 +1,169 @@
+/*
+** dobject.h
+**
+**---------------------------------------------------------------------------
+** Copyright 1998-2008 Randy Heit
+** All rights reserved.
+**
+** Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions
+** are met:
+**
+** 1. Redistributions of source code must retain the above copyright
+**    notice, this list of conditions and the following disclaimer.
+** 2. Redistributions in binary form must reproduce the above copyright
+**    notice, this list of conditions and the following disclaimer in the
+**    documentation and/or other materials provided with the distribution.
+** 3. The name of the author may not be used to endorse or promote products
+**    derived from this software without specific prior written permission.
+**
+** THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+** IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+** OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+** IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+** INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+** NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+** THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+**---------------------------------------------------------------------------
+**
+*/
+
+#ifndef __DOBJECT_H__
+#define __DOBJECT_H__
+
+#include <stdlib.h>
+
+struct PClass;
+
+#define RUNTIME_TYPE(object)	(object->GetClass())	// Passed an object, returns the type of that object
+#define RUNTIME_CLASS(cls)		(&cls::_StaticType)		// Passed a class name, returns a PClass representing that class
+#define NATIVE_TYPE(object)		(object->StaticType())	// Passed an object, returns the type of the C++ class representing the object
+
+struct ClassReg
+{
+	PClass *MyClass;
+	const char *Name;
+	PClass *ParentType;
+	unsigned int SizeOf;
+	const size_t *Pointers;
+	void (*ConstructNative)(void *);
+
+	void RegisterClass() const;
+};
+
+enum EInPlace { EC_InPlace };
+
+#define DECLARE_ABSTRACT_CLASS(cls,parent) \
+public: \
+	static PClass _StaticType; \
+	virtual PClass *StaticType() const { return &_StaticType; } \
+	static ClassReg RegistrationInfo, *RegistrationInfoPtr; \
+private: \
+	typedef parent Super; \
+	typedef cls ThisClass;
+
+#define DECLARE_CLASS(cls,parent) \
+	DECLARE_ABSTRACT_CLASS(cls,parent) \
+		private: static void InPlaceConstructor (void *mem);
+
+#if defined(_MSC_VER)
+#	pragma data_seg(".creg$u")
+#	pragma data_seg()
+#	define _DECLARE_TI(cls) __declspec(allocate(".creg$u")) ClassReg *cls::RegistrationInfoPtr = &cls::RegistrationInfo;
+#else
+#	define _DECLARE_TI(cls) ClassReg *cls::RegistrationInfoPtr __attribute__((section(SECTION_CREG))) = &cls::RegistrationInfo;
+#endif
+
+#define _IMP_PCLASS(cls,ptrs,create) \
+	PClass cls::_StaticType; \
+	ClassReg cls::RegistrationInfo = {\
+		RUNTIME_CLASS(cls), \
+		#cls, \
+		RUNTIME_CLASS(cls::Super), \
+		sizeof(cls), \
+		ptrs, \
+		create }; \
+	_DECLARE_TI(cls)
+
+#define _IMP_CREATE_OBJ(cls) \
+	void cls::InPlaceConstructor(void *mem) { new((EInPlace *)mem) cls; }
+
+#define IMPLEMENT_CLASS(cls) \
+	_IMP_CREATE_OBJ(cls) \
+	_IMP_PCLASS(cls,NULL,cls::InPlaceConstructor) 
+
+#define IMPLEMENT_ABSTRACT_CLASS(cls) \
+	_IMP_PCLASS(cls,NULL,NULL)
+
+
+class DObject
+{
+public:
+	static PClass _StaticType;
+	virtual PClass *StaticType() const { return &_StaticType; }
+	static ClassReg RegistrationInfo, *RegistrationInfoPtr;
+	static void InPlaceConstructor (void *mem);
+private:
+	typedef DObject ThisClass;
+
+	// Per-instance variables. There are four.
+private:
+	PClass *Class;				// This object's type
+public:
+
+public:
+	DObject ();
+	DObject (PClass *inClass);
+	virtual ~DObject();
+
+	inline bool IsKindOf (const PClass *base);
+	inline bool IsA (const PClass *type);
+
+	virtual void Destroy ();
+
+	PClass *GetClass() const
+	{
+		if (Class == NULL)
+		{
+			// Save a little time the next time somebody wants this object's type
+			// by recording it now.
+			const_cast<DObject *>(this)->Class = StaticType();
+		}
+		return Class;
+	}
+
+	void SetClass (PClass *inClass)
+	{
+		Class = inClass;
+	}
+
+protected:
+	// This form of placement new and delete is for use *only* by PClass's
+	// CreateNew() method. Do not use them for some other purpose.
+	void *operator new(size_t, EInPlace *mem)
+	{
+		return (void *)mem;
+	}
+
+	void operator delete (void *mem, EInPlace *)
+	{
+		free (mem);
+	}
+};
+
+#include "dobjtype.h"
+
+inline bool DObject::IsKindOf (const PClass *base)
+{
+	return base->IsAncestorOf (GetClass ());
+}
+
+inline bool DObject::IsA (const PClass *type)
+{
+	return (type == GetClass());
+}
+
+#endif //__DOBJECT_H__

source/common/dobject/dobjtype.cpp

@@ -0,0 +1,104 @@
+/*
+** dobjtype.cpp
+** Implements the type information class
+**
+**---------------------------------------------------------------------------
+** Copyright 1998-2008 Randy Heit
+** All rights reserved.
+**
+** Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions
+** are met:
+**
+** 1. Redistributions of source code must retain the above copyright
+**    notice, this list of conditions and the following disclaimer.
+** 2. Redistributions in binary form must reproduce the above copyright
+**    notice, this list of conditions and the following disclaimer in the
+**    documentation and/or other materials provided with the distribution.
+** 3. The name of the author may not be used to endorse or promote products
+**    derived from this software without specific prior written permission.
+**
+** THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+** IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+** OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+** IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+** INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+** NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+** THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+**---------------------------------------------------------------------------
+**
+*/
+
+#include <stdlib.h>
+#include <stdint.h>
+#include "dobject.h"
+#include "templates.h"
+#include "autosegs.h"
+#include "tarray.h"
+
+static TArray<PClass *> Types;
+static TMap<FName, PClass *> Map;
+
+static int cregcmp (const void *a, const void *b)
+{
+	// VC++ introduces NULLs in the sequence. GCC seems to work as expected and not do it.
+	const ClassReg *class1 = *(const ClassReg **)a;
+	const ClassReg *class2 = *(const ClassReg **)b;
+	if (class1 == NULL) return 1;
+	if (class2 == NULL) return -1;
+	return strcmp (class1->Name, class2->Name);
+}
+
+void PClass::StaticInit ()
+{
+	// Sort classes by name to remove dependance on how the compiler ordered them.
+	REGINFO *head = &CRegHead;
+	REGINFO *tail = &CRegTail;
+
+	// MinGW's linker is linking the object files backwards for me now...
+	if (head > tail)
+	{
+		std::swap (head, tail);
+	}
+	qsort ((void*)(head + 1), tail - head - 1, sizeof(REGINFO), cregcmp);
+
+	FAutoSegIterator probe(CRegHead, CRegTail);
+
+	while (*++probe != NULL)
+	{
+		((ClassReg *)*probe)->RegisterClass ();
+	}
+}
+
+void ClassReg::RegisterClass () const
+{
+	assert (MyClass != NULL);
+
+	// Add type to list
+	MyClass->TypeName = FName(Name+1);
+	MyClass->ParentClass = ParentType;
+	MyClass->Size = SizeOf;
+	MyClass->ConstructNative = ConstructNative;
+	Map.Insert(MyClass->TypeName, MyClass);
+}
+
+// Find a type, passed the name as a name
+const PClass *PClass::FindClass (FName zaname)
+{
+	auto pcls = Map.CheckKey(zaname);
+	return pcls? *pcls : nullptr;
+}
+
+// Create a new object that this class represents
+DObject *PClass::CreateNew () const
+{
+	uint8_t *mem = (uint8_t *)calloc (Size, 1);
+	assert (mem != NULL);
+
+	ConstructNative (mem);
+	((DObject *)mem)->SetClass (const_cast<PClass *>(this));
+	return (DObject *)mem;
+}

source/common/dobject/dobjtype.h

@@ -0,0 +1,51 @@
+#ifndef DOBJTYPE_H
+#define DOBJTYPE_H
+
+#ifndef __DOBJECT_H__
+#error You must #include "dobject.h" to get dobjtype.h
+#endif
+
+#include "name.h"
+
+
+// Meta-info for every class derived from DObject ---------------------------
+
+struct PClass
+{
+	static void StaticInit ();
+
+	// Per-class information -------------------------------------
+	FName				 TypeName;		// this class's name
+	unsigned int		 Size;			// this class's size
+	PClass				*ParentClass;	// the class this class derives from
+	PClass				*HashNext;
+
+	void (*ConstructNative)(void *);
+
+	// The rest are all functions and static data ----------------
+	DObject *CreateNew () const;
+
+	// Returns true if this type is an ancestor of (or same as) the passed type.
+	bool IsAncestorOf (const PClass *ti) const
+	{
+		while (ti)
+		{
+			if (this == ti)
+				return true;
+			ti = ti->ParentClass;
+		}
+		return false;
+	}
+	inline bool IsDescendantOf (const PClass *ti) const
+	{
+		return ti->IsAncestorOf (this);
+	}
+
+	// Find a type, given its name.
+	static const PClass *FindClass (const char *name) { return FindClass (FName (name, true)); }
+	static const PClass *FindClass (const FString &name) { return FindClass (FName (name, true)); }
+	static const PClass *FindClass (ENamedName name) { return FindClass (FName (name)); }
+	static const PClass *FindClass (FName name);
+};
+
+#endif

source/common/dobject/zzautozend.cpp

@@ -0,0 +1,54 @@
+/*
+** autozend.cpp
+** This file contains the tails of lists stored in special data segments
+**
+**---------------------------------------------------------------------------
+** Copyright 1998-2006 Randy Heit
+** All rights reserved.
+**
+** Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions
+** are met:
+**
+** 1. Redistributions of source code must retain the above copyright
+**    notice, this list of conditions and the following disclaimer.
+** 2. Redistributions in binary form must reproduce the above copyright
+**    notice, this list of conditions and the following disclaimer in the
+**    documentation and/or other materials provided with the distribution.
+** 3. The name of the author may not be used to endorse or promote products
+**    derived from this software without specific prior written permission.
+**
+** THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+** IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+** OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+** IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+** INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+** NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+** THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+**---------------------------------------------------------------------------
+**
+** See autostart.cpp for an explanation of why I do things like this.
+*/
+
+#include "autosegs.h"
+
+#if defined(_MSC_VER)
+
+#pragma section(".creg$z",read)
+__declspec(allocate(".creg$z")) void *const CRegTail = 0;
+
+
+#elif defined(__GNUC__)
+
+#include "doomtype.h"
+
+void *const CRegTail __attribute__((section(SECTION_CREG))) = 0;
+
+#else
+
+#error Please fix autozend.cpp for your compiler
+
+#endif