- added more utilities from GZDoom - TArray/TMap and FileReader.

source/CMakeLists.txt

@@ -963,6 +963,9 @@ set (PCH_SOURCES
 	blood/src/weapon.cpp
 
 	common/utility/m_argv.cpp
+	common/utility/files.cpp
+	common/utility/files_decompress.cpp
+	#common/utility/configfile.cpp
 )
 
 if( MSVC )

source/common/utility/files.cpp

@@ -0,0 +1,494 @@
+/*
+** files.cpp
+** Implements classes for reading from files or memory blocks
+**
+**---------------------------------------------------------------------------
+** Copyright 1998-2008 Randy Heit
+** Copyright 2005-2008 Christoph Oelckers
+** 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 "files.h"
+#include "templates.h"	// just for 'clamp'
+
+
+FILE *myfopen(const char *filename, const char *flags)
+{
+	// fix this later
+#if 1//ndef _WIN32
+	return fopen(filename, flags);
+#else
+	auto widename = WideString(filename);
+	auto wideflags = WideString(flags);
+	return _wfopen(widename.c_str(), wideflags.c_str());
+#endif
+}
+
+
+//==========================================================================
+//
+// StdFileReader
+//
+// reads data from an stdio FILE* or part of it.
+//
+//==========================================================================
+
+class StdFileReader : public FileReaderInterface
+{
+	FILE *File = nullptr;
+	long StartPos = 0;
+	long FilePos = 0;
+
+public:
+	StdFileReader()
+	{}
+
+	~StdFileReader()
+	{
+		if (File != nullptr)
+		{
+			fclose(File);
+		}
+		File = nullptr;
+	}
+
+	bool Open(const char *filename, long startpos = 0, long len = -1)
+	{
+		File = myfopen(filename, "rb");
+		if (File == nullptr) return false;
+		FilePos = startpos;
+		StartPos = startpos;
+		Length = CalcFileLen();
+		if (len >= 0 && len < Length) Length = len;
+		if (startpos > 0) Seek(0, SEEK_SET);
+		return true;
+	}
+
+	long Tell() const override
+	{
+		return FilePos - StartPos;
+	}
+
+	long Seek(long offset, int origin) override
+	{
+		if (origin == SEEK_SET)
+		{
+			offset += StartPos;
+		}
+		else if (origin == SEEK_CUR)
+		{
+			offset += FilePos;
+		}
+		else if (origin == SEEK_END)
+		{
+			offset += StartPos + Length;
+		}
+		if (offset < StartPos || offset > StartPos + Length) return -1;	// out of scope
+
+		if (0 == fseek(File, offset, SEEK_SET))
+		{
+			FilePos = offset;
+			return 0;
+		}
+		return -1;
+	}
+
+	long Read(void *buffer, long len) override
+	{
+		assert(len >= 0);
+		if (len <= 0) return 0;
+		if (FilePos + len > StartPos + Length)
+		{
+			len = Length - FilePos + StartPos;
+		}
+		len = (long)fread(buffer, 1, len, File);
+		FilePos += len;
+		return len;
+	}
+
+	char *Gets(char *strbuf, int len) override
+	{
+		if (len <= 0 || FilePos >= StartPos + Length) return NULL;
+		char *p = fgets(strbuf, len, File);
+		if (p != NULL)
+		{
+			int old = FilePos;
+			FilePos = ftell(File);
+			if (FilePos - StartPos > Length)
+			{
+				strbuf[Length - old + StartPos] = 0;
+			}
+		}
+		return p;
+	}
+
+private:
+	long CalcFileLen() const
+	{
+		long endpos;
+
+		fseek(File, 0, SEEK_END);
+		endpos = ftell(File);
+		fseek(File, 0, SEEK_SET);
+		return endpos;
+	}
+};
+
+//==========================================================================
+//
+// FileReaderRedirect
+//
+// like the above, but uses another File reader as its backing data
+//
+//==========================================================================
+
+class FileReaderRedirect : public FileReaderInterface
+{
+	FileReader *mReader = nullptr;
+	long StartPos = 0;
+	long FilePos = 0;
+
+public:
+	FileReaderRedirect(FileReader &parent, long start, long length)
+	{
+		mReader = &parent;
+		FilePos = start;
+		StartPos = start;
+		Length = length;
+		Seek(0, SEEK_SET);
+	}
+
+	virtual long Tell() const override
+	{
+		return FilePos - StartPos;
+	}
+
+	virtual long Seek(long offset, int origin)
+	{
+		switch (origin)
+		{
+		case SEEK_SET:
+			offset += StartPos;
+			break;
+
+		case SEEK_END:
+			offset += StartPos + Length;
+			break;
+
+		case SEEK_CUR:
+			offset += (long)mReader->Tell();
+			break;
+		}
+		if (offset < StartPos || offset > StartPos + Length) return -1;	// out of scope
+		if (mReader->Seek(offset, FileReader::SeekSet) == 0)
+		{
+			FilePos = offset;
+			return 0;
+		}
+		return -1;
+	}
+
+	virtual long Read(void *buffer, long len)
+	{
+		assert(len >= 0);
+		if (len <= 0) return 0;
+		if (FilePos + len > StartPos + Length)
+		{
+			len = Length - FilePos + StartPos;
+		}
+		len = (long)mReader->Read(buffer, len);
+		FilePos += len;
+		return len;
+	}
+
+	virtual char *Gets(char *strbuf, int len)
+	{
+		if (len <= 0 || FilePos >= StartPos + Length) return NULL;
+		char *p = mReader->Gets(strbuf, len);
+		if (p != NULL)
+		{
+			int old = FilePos;
+			FilePos = (long)mReader->Tell();
+			if (FilePos - StartPos > Length)
+			{
+				strbuf[Length - old + StartPos] = 0;
+			}
+		}
+		return p;
+	}
+
+};
+
+//==========================================================================
+//
+// MemoryReader
+//
+// reads data from a block of memory
+//
+//==========================================================================
+
+long MemoryReader::Tell() const
+{
+	return FilePos;
+}
+
+long MemoryReader::Seek(long offset, int origin)
+{
+	switch (origin)
+	{
+	case SEEK_CUR:
+		offset += FilePos;
+		break;
+
+	case SEEK_END:
+		offset += Length;
+		break;
+
+	}
+	if (offset < 0 || offset > Length) return -1;
+	FilePos = clamp<long>(offset, 0, Length);
+	return 0;
+}
+
+long MemoryReader::Read(void *buffer, long len)
+{
+	if (len>Length - FilePos) len = Length - FilePos;
+	if (len<0) len = 0;
+	memcpy(buffer, bufptr + FilePos, len);
+	FilePos += len;
+	return len;
+}
+
+char *MemoryReader::Gets(char *strbuf, int len)
+{
+	if (len>Length - FilePos) len = Length - FilePos;
+	if (len <= 0) return NULL;
+
+	char *p = strbuf;
+	while (len > 1)
+	{
+		if (bufptr[FilePos] == 0)
+		{
+			FilePos++;
+			break;
+		}
+		if (bufptr[FilePos] != '\r')
+		{
+			*p++ = bufptr[FilePos];
+			len--;
+			if (bufptr[FilePos] == '\n')
+			{
+				FilePos++;
+				break;
+			}
+		}
+		FilePos++;
+	}
+	if (p == strbuf) return NULL;
+	*p++ = 0;
+	return strbuf;
+}
+
+//==========================================================================
+//
+// MemoryArrayReader
+//
+// reads data from an array of memory
+//
+//==========================================================================
+
+class MemoryArrayReader : public MemoryReader
+{
+	TArray<uint8_t> buf;
+
+public:
+	MemoryArrayReader(const char *buffer, long length)
+	{
+		if (length > 0)
+		{
+			buf.Resize(length);
+			memcpy(&buf[0], buffer, length);
+		}
+		UpdateBuffer();
+	}
+
+	TArray<uint8_t> &GetArray() { return buf; }
+
+	void UpdateBuffer() 
+	{ 
+		bufptr = (const char*)&buf[0];
+		FilePos = 0;
+		Length = buf.Size();
+	}
+};
+
+
+
+//==========================================================================
+//
+// FileReader
+//
+// this wraps the different reader types in an object with value semantics.
+//
+//==========================================================================
+
+bool FileReader::OpenFile(const char *filename, FileReader::Size start, FileReader::Size length)
+{
+	auto reader = new StdFileReader;
+	if (!reader->Open(filename, (long)start, (long)length))
+	{
+		delete reader;
+		return false;
+	}
+	Close();
+	mReader = reader;
+	return true;
+}
+
+bool FileReader::OpenFilePart(FileReader &parent, FileReader::Size start, FileReader::Size length)
+{
+	auto reader = new FileReaderRedirect(parent, (long)start, (long)length);
+	Close();
+	mReader = reader;
+	return true;
+}
+
+bool FileReader::OpenMemory(const void *mem, FileReader::Size length)
+{
+	Close();
+	mReader = new MemoryReader((const char *)mem, (long)length);
+	return true;
+}
+
+bool FileReader::OpenMemoryArray(const void *mem, FileReader::Size length)
+{
+	Close();
+	mReader = new MemoryArrayReader((const char *)mem, (long)length);
+	return true;
+}
+
+bool FileReader::OpenMemoryArray(std::function<bool(TArray<uint8_t>&)> getter)
+{
+	auto reader = new MemoryArrayReader(nullptr, 0);
+	if (getter(reader->GetArray()))
+	{
+		Close();
+		reader->UpdateBuffer();
+		mReader = reader;
+		return true;
+	}
+	else
+	{
+		// This will keep the old buffer, if one existed
+		delete reader;
+		return false;
+	}
+}
+
+
+//==========================================================================
+//
+// FileWriter (the motivation here is to have a buffer writing subclass)
+//
+//==========================================================================
+
+bool FileWriter::OpenDirect(const char *filename)
+{
+	File = myfopen(filename, "wb");
+	return (File != NULL);
+}
+
+FileWriter *FileWriter::Open(const char *filename)
+{
+	FileWriter *fwrit = new FileWriter();
+	if (fwrit->OpenDirect(filename))
+	{
+		return fwrit;
+	}
+	delete fwrit;
+	return NULL;
+}
+
+size_t FileWriter::Write(const void *buffer, size_t len)
+{
+	if (File != NULL)
+	{
+		return fwrite(buffer, 1, len, File);
+	}
+	else
+	{
+		return 0;
+	}
+}
+
+long FileWriter::Tell()
+{
+	if (File != NULL)
+	{
+		return ftell(File);
+	}
+	else
+	{
+		return 0;
+	}
+}
+
+long FileWriter::Seek(long offset, int mode)
+{
+	if (File != NULL)
+	{
+		return fseek(File, offset, mode);
+	}
+	else
+	{
+		return 0;
+	}
+}
+
+size_t FileWriter::Printf(const char *fmt, ...)
+{
+	// fix me later
+#if 0
+	va_list ap;
+	FString out;
+
+	va_start(ap, fmt);
+	out.VFormat(fmt, ap);
+	va_end(ap);
+	return Write(out.GetChars(), out.Len());
+#else
+	return 0;
+#endif
+}
+
+size_t BufferWriter::Write(const void *buffer, size_t len)
+{
+	unsigned int ofs = mBuffer.Reserve((unsigned)len);
+	memcpy(&mBuffer[ofs], buffer, len);
+	return len;
+}

source/common/utility/files.h

@@ -0,0 +1,331 @@
+/*
+** files.h
+** Implements classes for reading from files or memory blocks
+**
+**---------------------------------------------------------------------------
+** Copyright 1998-2008 Randy Heit
+** Copyright 2005-2008 Christoph Oelckers
+** 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 FILES_H
+#define FILES_H
+
+#include <stddef.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <functional>
+#include "basics.h"
+#include "m_swap.h"
+#include "tarray.h"
+
+// Zip compression methods, extended by some internal types to be passed to OpenDecompressor
+enum
+{
+	METHOD_STORED = 0,
+	METHOD_SHRINK = 1,
+	METHOD_IMPLODE = 6,
+	METHOD_DEFLATE = 8,
+	METHOD_BZIP2 = 12,
+	METHOD_LZMA = 14,
+	METHOD_PPMD = 98,
+	METHOD_LZSS = 1337,	// not used in Zips - this is for Console Doom compression
+	METHOD_ZLIB = 1338,	// Zlib stream with header, used by compressed nodes.
+};
+
+class FileReaderInterface
+{
+public:
+	long Length = -1;
+	virtual ~FileReaderInterface() {}
+	virtual long Tell () const = 0;
+	virtual long Seek (long offset, int origin) = 0;
+	virtual long Read (void *buffer, long len) = 0;
+	virtual char *Gets(char *strbuf, int len) = 0;
+	virtual const char *GetBuffer() const { return nullptr; }
+	long GetLength () const { return Length; }
+};
+
+class DecompressorBase : public FileReaderInterface
+{
+	std::function<void(const char*)> ErrorCallback = nullptr;
+public:
+	// These do not work but need to be defined to satisfy the FileReaderInterface.
+	// They will just error out when called.
+	long Tell() const override;
+	long Seek(long offset, int origin) override;
+	char *Gets(char *strbuf, int len) override;
+	void DecompressionError(const char* error, ...) const;
+	void SetErrorCallback(const std::function<void(const char*)>& cb)
+	{
+		ErrorCallback = cb;
+	}
+};
+
+class MemoryReader : public FileReaderInterface
+{
+protected:
+	const char * bufptr = nullptr;
+	long FilePos = 0;
+
+	MemoryReader()
+	{}
+
+public:
+	MemoryReader(const char *buffer, long length)
+	{
+		bufptr = buffer;
+		Length = length;
+		FilePos = 0;
+	}
+
+	long Tell() const override;
+	long Seek(long offset, int origin) override;
+	long Read(void *buffer, long len) override;
+	char *Gets(char *strbuf, int len) override;
+	virtual const char *GetBuffer() const override { return bufptr; }
+};
+
+
+struct FResourceLump;
+
+class FileReader
+{
+	friend struct FResourceLump;	// needs access to the private constructor.
+
+	FileReaderInterface *mReader = nullptr;
+
+	FileReader(const FileReader &r) = delete;
+	FileReader &operator=(const FileReader &r) = delete;
+
+	explicit FileReader(FileReaderInterface *r)
+	{
+		mReader = r;
+	}
+
+public:
+	enum ESeek
+	{
+		SeekSet = SEEK_SET,
+		SeekCur = SEEK_CUR,
+		SeekEnd = SEEK_END
+	};
+
+	typedef ptrdiff_t Size;	// let's not use 'long' here.
+
+	FileReader() {}
+
+	FileReader(FileReader &&r)
+	{
+		mReader = r.mReader;
+		r.mReader = nullptr;
+	}
+
+	FileReader& operator =(FileReader &&r)
+	{
+		Close();
+		mReader = r.mReader;
+		r.mReader = nullptr;
+		return *this;
+	}
+
+
+	~FileReader()
+	{
+		Close();
+	}
+
+	bool isOpen() const
+	{
+		return mReader != nullptr;
+	}
+
+	void Close()
+	{
+		if (mReader != nullptr) delete mReader;
+		mReader = nullptr;
+	}
+
+	bool OpenFile(const char *filename, Size start = 0, Size length = -1);
+	bool OpenFilePart(FileReader &parent, Size start, Size length);
+	bool OpenMemory(const void *mem, Size length);	// read directly from the buffer
+	bool OpenMemoryArray(const void *mem, Size length);	// read from a copy of the buffer.
+	bool OpenMemoryArray(std::function<bool(TArray<uint8_t>&)> getter);	// read contents to a buffer and return a reader to it
+	bool OpenDecompressor(FileReader &parent, Size length, int method, bool seekable, const std::function<void(const char*)>& cb);	// creates a decompressor stream. 'seekable' uses a buffered version so that the Seek and Tell methods can be used.
+
+	Size Tell() const
+	{
+		return mReader->Tell();
+	}
+
+	Size Seek(Size offset, ESeek origin)
+	{
+		return mReader->Seek((long)offset, origin);
+	}
+
+	Size Read(void *buffer, Size len)
+	{
+		return mReader->Read(buffer, (long)len);
+	}
+
+	TArray<uint8_t> Read(size_t len)
+	{
+		TArray<uint8_t> buffer((int)len, true);
+		Size length = mReader->Read(&buffer[0], (long)len);
+		buffer.Clamp((int)length);
+		return buffer;
+	}
+
+	TArray<uint8_t> Read()
+	{
+		TArray<uint8_t> buffer(mReader->Length, true);
+		Size length = mReader->Read(&buffer[0], mReader->Length);
+		if (length < mReader->Length) buffer.Clear();
+		return buffer;
+	}
+
+	char *Gets(char *strbuf, Size len)
+	{
+		return mReader->Gets(strbuf, (int)len);
+	}
+
+	const char *GetBuffer()
+	{
+		return mReader->GetBuffer();
+	}
+
+	Size GetLength() const
+	{
+		return mReader->GetLength();
+	}
+
+	uint8_t ReadUInt8()
+	{
+		uint8_t v = 0;
+		Read(&v, 1);
+		return v;
+	}
+
+	int8_t ReadInt8()
+	{
+		int8_t v = 0;
+		Read(&v, 1);
+		return v;
+	}
+
+	uint16_t ReadUInt16()
+	{
+		uint16_t v = 0;
+		Read(&v, 2);
+		return LittleShort(v);
+	}
+
+	int16_t ReadInt16()
+	{
+		uint16_t v = 0;
+		Read(&v, 2);
+		return LittleShort(v);
+	}
+
+	uint32_t ReadUInt32()
+	{
+		uint32_t v = 0;
+		Read(&v, 4);
+		return LittleLong(v);
+	}
+
+	int32_t ReadInt32()
+	{
+		uint32_t v = 0;
+		Read(&v, 4);
+		return LittleLong(v);
+	}
+
+	uint32_t ReadUInt32BE()
+	{
+		uint32_t v = 0;
+		Read(&v, 4);
+		return BigLong(v);
+	}
+
+	int32_t ReadInt32BE()
+	{
+		uint32_t v = 0;
+		Read(&v, 4);
+		return BigLong(v);
+	}
+
+
+	friend class FWadCollection;
+};
+
+
+
+
+class FileWriter
+{
+protected:
+	bool OpenDirect(const char *filename);
+
+	FileWriter()
+	{
+		File = NULL;
+	}
+public:
+	virtual ~FileWriter()
+	{
+		if (File != NULL) fclose(File);
+	}
+
+	static FileWriter *Open(const char *filename);
+
+	virtual size_t Write(const void *buffer, size_t len);
+	virtual long Tell();
+	virtual long Seek(long offset, int mode);
+	size_t Printf(const char *fmt, ...) GCCPRINTF(2,3);
+
+protected:
+
+	FILE *File;
+
+protected:
+	bool CloseOnDestruct;
+};
+
+class BufferWriter : public FileWriter
+{
+protected:
+	TArray<unsigned char> mBuffer;
+public:
+
+	BufferWriter() {}
+	virtual size_t Write(const void *buffer, size_t len) override;
+	TArray<unsigned char> *GetBuffer() { return &mBuffer; }
+};
+
+#endif

source/common/utility/files_decompress.cpp

@@ -0,0 +1,672 @@
+/*
+** files.cpp
+** Implements classes for reading from files or memory blocks
+**
+**---------------------------------------------------------------------------
+** Copyright 1998-2008 Randy Heit
+** Copyright 2005-2008 Christoph Oelckers
+** 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.
+**---------------------------------------------------------------------------
+**
+*/
+
+// Caution: LzmaDec also pulls in windows.h!
+#include "LzmaDec.h"
+#include <zlib.h>
+#include <bzlib.h>
+#include <algorithm>
+
+#include "files.h"
+#include "templates.h"
+
+//==========================================================================
+//
+// I_Error
+//
+// Throw an error that will send us to the console if we are far enough
+// along in the startup process.
+//
+//==========================================================================
+
+void DecompressorBase::DecompressionError(const char *error, ...) const 
+{
+	const int MAX_ERRORTEXT = 300;
+	va_list argptr;
+	char errortext[MAX_ERRORTEXT];
+
+	va_start(argptr, error);
+	vsnprintf(errortext, MAX_ERRORTEXT, error, argptr);
+	va_end(argptr);
+
+	if (ErrorCallback != nullptr) ErrorCallback(errortext);
+	else std::terminate();
+}
+
+long DecompressorBase::Tell () const
+{
+	DecompressionError("Cannot get position of decompressor stream");
+	return 0;
+}
+long DecompressorBase::Seek (long offset, int origin)
+{
+	DecompressionError("Cannot seek in decompressor stream");
+	return 0;
+}
+char *DecompressorBase::Gets(char *strbuf, int len)
+{
+	DecompressionError("Cannot use Gets on decompressor stream");
+	return nullptr;
+}
+
+//
+// M_ZlibError
+//
+#if 0
+FString M_ZLibError(int zerr)
+{
+	if (zerr >= 0)
+	{
+		return "OK";
+	}
+	else if (zerr < -6)
+	{
+		FString out;
+		out.Format("%d", zerr);
+		return out;
+	}
+	else
+	{
+		static const char* errs[6] =
+		{
+			"Errno",
+			"Stream Error",
+			"Data Error",
+			"Memory Error",
+			"Buffer Error",
+			"Version Error"
+		};
+		return errs[-zerr - 1];
+	}
+}
+#endif
+
+//==========================================================================
+//
+// DecompressorZ
+//
+// The zlib wrapper
+// reads data from a ZLib compressed stream
+//
+//==========================================================================
+
+class DecompressorZ : public DecompressorBase
+{
+	enum { BUFF_SIZE = 4096 };
+
+	FileReader &File;
+	bool SawEOF;
+	z_stream Stream;
+	uint8_t InBuff[BUFF_SIZE];
+	
+public:
+	DecompressorZ (FileReader &file, bool zip, const std::function<void(const char*)>& cb)
+	: File(file), SawEOF(false)
+	{
+		int err;
+
+		SetErrorCallback(cb);
+		FillBuffer ();
+
+		Stream.zalloc = Z_NULL;
+		Stream.zfree = Z_NULL;
+
+		if (!zip) err = inflateInit (&Stream);
+		else err = inflateInit2 (&Stream, -MAX_WBITS);
+
+		if (err != Z_OK)
+		{
+			// Later, when FString is available.
+#if 0
+			DecompressionError ("DecompressorZ: inflateInit failed: %s\n", M_ZLibError(err).GetChars());
+#endif
+		}
+	}
+
+	~DecompressorZ ()
+	{
+		inflateEnd (&Stream);
+	}
+
+	long Read (void *buffer, long len) override
+	{
+		int err;
+
+		Stream.next_out = (Bytef *)buffer;
+		Stream.avail_out = len;
+
+		do
+		{
+			err = inflate (&Stream, Z_SYNC_FLUSH);
+			if (Stream.avail_in == 0 && !SawEOF)
+			{
+				FillBuffer ();
+			}
+		} while (err == Z_OK && Stream.avail_out != 0);
+
+		if (err != Z_OK && err != Z_STREAM_END)
+		{
+			DecompressionError ("Corrupt zlib stream");
+		}
+
+		if (Stream.avail_out != 0)
+		{
+			DecompressionError ("Ran out of data in zlib stream");
+		}
+
+		return len - Stream.avail_out;
+	}
+
+	void FillBuffer ()
+	{
+		auto numread = File.Read (InBuff, BUFF_SIZE);
+
+		if (numread < BUFF_SIZE)
+		{
+			SawEOF = true;
+		}
+		Stream.next_in = InBuff;
+		Stream.avail_in = (uInt)numread;
+	}
+};
+
+
+//==========================================================================
+//
+// DecompressorZ
+//
+// The bzip2 wrapper
+// reads data from a libbzip2 compressed stream
+//
+//==========================================================================
+
+class DecompressorBZ2;
+static DecompressorBZ2 * stupidGlobal;	// Why does that dumb global error callback not pass the decompressor state?
+										// Thanks to that brain-dead interface we have to use a global variable to get the error to the proper handler.
+
+class DecompressorBZ2 : public DecompressorBase
+{
+	enum { BUFF_SIZE = 4096 };
+
+	FileReader &File;
+	bool SawEOF;
+	bz_stream Stream;
+	uint8_t InBuff[BUFF_SIZE];
+	
+public:
+	DecompressorBZ2 (FileReader &file, const std::function<void(const char*)>& cb)
+	: File(file), SawEOF(false)
+	{
+		int err;
+
+		SetErrorCallback(cb);
+		stupidGlobal = this;
+		FillBuffer ();
+
+		Stream.bzalloc = NULL;
+		Stream.bzfree = NULL;
+		Stream.opaque = NULL;
+
+		err = BZ2_bzDecompressInit(&Stream, 0, 0);
+
+		if (err != BZ_OK)
+		{
+			DecompressionError ("DecompressorBZ2: bzDecompressInit failed: %d\n", err);
+		}
+	}
+
+	~DecompressorBZ2 ()
+	{
+		stupidGlobal = this;
+		BZ2_bzDecompressEnd (&Stream);
+	}
+
+	long Read (void *buffer, long len) override
+	{
+		int err;
+
+		stupidGlobal = this;
+		Stream.next_out = (char *)buffer;
+		Stream.avail_out = len;
+
+		do
+		{
+			err = BZ2_bzDecompress(&Stream);
+			if (Stream.avail_in == 0 && !SawEOF)
+			{
+				FillBuffer ();
+			}
+		} while (err == BZ_OK && Stream.avail_out != 0);
+
+		if (err != BZ_OK && err != BZ_STREAM_END)
+		{
+			DecompressionError ("Corrupt bzip2 stream");
+		}
+
+		if (Stream.avail_out != 0)
+		{
+			DecompressionError ("Ran out of data in bzip2 stream");
+		}
+
+		return len - Stream.avail_out;
+	}
+
+	void FillBuffer ()
+	{
+		auto numread = File.Read(InBuff, BUFF_SIZE);
+
+		if (numread < BUFF_SIZE)
+		{
+			SawEOF = true;
+		}
+		Stream.next_in = (char *)InBuff;
+		Stream.avail_in = (unsigned)numread;
+	}
+
+};
+
+//==========================================================================
+//
+// bz_internal_error
+//
+// libbzip2 wants this, since we build it with BZ_NO_STDIO set.
+//
+//==========================================================================
+
+extern "C" void bz_internal_error (int errcode)
+{
+	if (stupidGlobal) stupidGlobal->DecompressionError("libbzip2: internal error number %d\n", errcode);
+	else std::terminate();
+}
+
+//==========================================================================
+//
+// DecompressorLZMA
+//
+// The lzma wrapper
+// reads data from a LZMA compressed stream
+//
+//==========================================================================
+
+static void *SzAlloc(ISzAllocPtr, size_t size) { return malloc(size); }
+static void SzFree(ISzAllocPtr, void *address) { free(address); }
+ISzAlloc g_Alloc = { SzAlloc, SzFree };
+
+// Wraps around a Decompressor to decompress a lzma stream
+class DecompressorLZMA : public DecompressorBase
+{
+	enum { BUFF_SIZE = 4096 };
+
+	FileReader &File;
+	bool SawEOF;
+	CLzmaDec Stream;
+	size_t Size;
+	size_t InPos, InSize;
+	size_t OutProcessed;
+	uint8_t InBuff[BUFF_SIZE];
+
+public:
+
+	DecompressorLZMA (FileReader &file, size_t uncompressed_size, const std::function<void(const char*)>& cb)
+	: File(file), SawEOF(false)
+	{
+		uint8_t header[4 + LZMA_PROPS_SIZE];
+		int err;
+		SetErrorCallback(cb);
+
+		Size = uncompressed_size;
+		OutProcessed = 0;
+
+		// Read zip LZMA properties header
+		if (File.Read(header, sizeof(header)) < (long)sizeof(header))
+		{
+			DecompressionError("DecompressorLZMA: File too short\n");
+		}
+		if (header[2] + header[3] * 256 != LZMA_PROPS_SIZE)
+		{
+			DecompressionError("DecompressorLZMA: LZMA props size is %d (expected %d)\n",
+				header[2] + header[3] * 256, LZMA_PROPS_SIZE);
+		}
+
+		FillBuffer();
+
+		LzmaDec_Construct(&Stream);
+		err = LzmaDec_Allocate(&Stream, header + 4, LZMA_PROPS_SIZE, &g_Alloc);
+
+		if (err != SZ_OK)
+		{
+			DecompressionError("DecompressorLZMA: LzmaDec_Allocate failed: %d\n", err);
+		}
+
+		LzmaDec_Init(&Stream);
+	}
+
+	~DecompressorLZMA ()
+	{
+		LzmaDec_Free(&Stream, &g_Alloc);
+	}
+
+	long Read (void *buffer, long len) override
+	{
+		int err;
+		Byte *next_out = (Byte *)buffer;
+
+		do
+		{
+			ELzmaFinishMode finish_mode = LZMA_FINISH_ANY;
+			ELzmaStatus status;
+			size_t out_processed = len;
+			size_t in_processed = InSize;
+
+			err = LzmaDec_DecodeToBuf(&Stream, next_out, &out_processed, InBuff + InPos, &in_processed, finish_mode, &status);
+			InPos += in_processed;
+			InSize -= in_processed;
+			next_out += out_processed;
+			len = (long)(len - out_processed);
+			if (err != SZ_OK)
+			{
+				DecompressionError ("Corrupt LZMA stream");
+			}
+			if (in_processed == 0 && out_processed == 0)
+			{
+				if (status != LZMA_STATUS_FINISHED_WITH_MARK)
+				{
+					DecompressionError ("Corrupt LZMA stream");
+				}
+			}
+			if (InSize == 0 && !SawEOF)
+			{
+				FillBuffer ();
+			}
+		} while (err == SZ_OK && len != 0);
+
+		if (err != Z_OK && err != Z_STREAM_END)
+		{
+			DecompressionError ("Corrupt LZMA stream");
+		}
+
+		if (len != 0)
+		{
+			DecompressionError ("Ran out of data in LZMA stream");
+		}
+
+		return (long)(next_out - (Byte *)buffer);
+	}
+
+	void FillBuffer ()
+	{
+		auto numread = File.Read(InBuff, BUFF_SIZE);
+
+		if (numread < BUFF_SIZE)
+		{
+			SawEOF = true;
+		}
+		InPos = 0;
+		InSize = numread;
+	}
+
+};
+
+//==========================================================================
+//
+// Console Doom LZSS wrapper.
+//
+//==========================================================================
+
+class DecompressorLZSS : public DecompressorBase
+{
+	enum { BUFF_SIZE = 4096, WINDOW_SIZE = 4096, INTERNAL_BUFFER_SIZE = 128 };
+
+	FileReader &File;
+	bool SawEOF;
+	uint8_t InBuff[BUFF_SIZE];
+
+	enum StreamState
+	{
+		STREAM_EMPTY,
+		STREAM_BITS,
+		STREAM_FLUSH,
+		STREAM_FINAL
+	};
+	struct
+	{
+		StreamState State;
+
+		uint8_t *In;
+		unsigned int AvailIn;
+		unsigned int InternalOut;
+
+		uint8_t CFlags, Bits;
+
+		uint8_t Window[WINDOW_SIZE+INTERNAL_BUFFER_SIZE];
+		const uint8_t *WindowData;
+		uint8_t *InternalBuffer;
+	} Stream;
+
+	void FillBuffer()
+	{
+		if(Stream.AvailIn)
+			memmove(InBuff, Stream.In, Stream.AvailIn);
+
+		auto numread = File.Read(InBuff+Stream.AvailIn, BUFF_SIZE-Stream.AvailIn);
+
+		if (numread < BUFF_SIZE)
+		{
+			SawEOF = true;
+		}
+		Stream.In = InBuff;
+		Stream.AvailIn = (unsigned)numread+Stream.AvailIn;
+	}
+
+	// Reads a flag byte.
+	void PrepareBlocks()
+	{
+		assert(Stream.InternalBuffer == Stream.WindowData);
+		Stream.CFlags = *Stream.In++;
+		--Stream.AvailIn;
+		Stream.Bits = 0xFF;
+		Stream.State = STREAM_BITS;
+	}
+
+	// Reads the next chunk in the block. Returns true if successful and
+	// returns false if it ran out of input data.
+	bool UncompressBlock()
+	{
+		if(Stream.CFlags & 1)
+		{
+			// Check to see if we have enough input
+			if(Stream.AvailIn < 2)
+				return false;
+			Stream.AvailIn -= 2;
+
+			uint16_t pos = BigShort(*(uint16_t*)Stream.In);
+			uint8_t len = (pos & 0xF)+1;
+			pos >>= 4;
+			Stream.In += 2;
+			if(len == 1)
+			{
+				// We've reached the end of the stream.
+				Stream.State = STREAM_FINAL;
+				return true;
+			}
+
+			const uint8_t* copyStart = Stream.InternalBuffer-pos-1;
+
+			// Complete overlap: Single byte repeated
+			if(pos == 0)
+				memset(Stream.InternalBuffer, *copyStart, len);
+			// No overlap: One copy
+			else if(pos >= len)
+				memcpy(Stream.InternalBuffer, copyStart, len);
+			else
+			{
+				// Partial overlap: Copy in 2 or 3 chunks.
+				do
+				{
+					unsigned int copy = std::min<unsigned int>(len, pos+1);
+					memcpy(Stream.InternalBuffer, copyStart, copy);
+					Stream.InternalBuffer += copy;
+					Stream.InternalOut += copy;
+					len -= copy;
+					pos += copy; // Increase our position since we can copy twice as much the next round.
+				}
+				while(len);
+			}
+
+			Stream.InternalOut += len;
+			Stream.InternalBuffer += len;
+		}
+		else
+		{
+			// Uncompressed byte.
+			*Stream.InternalBuffer++ = *Stream.In++;
+			--Stream.AvailIn;
+			++Stream.InternalOut;
+		}
+
+		Stream.CFlags >>= 1;
+		Stream.Bits >>= 1;
+
+		// If we're done with this block, flush the output
+		if(Stream.Bits == 0)
+			Stream.State = STREAM_FLUSH;
+
+		return true;
+	}
+
+public:
+	DecompressorLZSS(FileReader &file, const std::function<void(const char*)>& cb) : File(file), SawEOF(false)
+	{
+		SetErrorCallback(cb);
+		Stream.State = STREAM_EMPTY;
+		Stream.WindowData = Stream.InternalBuffer = Stream.Window+WINDOW_SIZE;
+		Stream.InternalOut = 0;
+		Stream.AvailIn = 0;
+
+		FillBuffer();
+	}
+
+	~DecompressorLZSS()
+	{
+	}
+
+	long Read(void *buffer, long len) override
+	{
+
+		uint8_t *Out = (uint8_t*)buffer;
+		long AvailOut = len;
+
+		do
+		{
+			while(Stream.AvailIn)
+			{
+				if(Stream.State == STREAM_EMPTY)
+					PrepareBlocks();
+				else if(Stream.State == STREAM_BITS && !UncompressBlock())
+					break;
+				else
+					break;
+			}
+
+			unsigned int copy = std::min<unsigned int>(Stream.InternalOut, AvailOut);
+			if(copy > 0)
+			{
+				memcpy(Out, Stream.WindowData, copy);
+				Out += copy;
+				AvailOut -= copy;
+
+				// Slide our window
+				memmove(Stream.Window, Stream.Window+copy, WINDOW_SIZE+INTERNAL_BUFFER_SIZE-copy);
+				Stream.InternalBuffer -= copy;
+				Stream.InternalOut -= copy;
+			}
+
+			if(Stream.State == STREAM_FINAL)
+				break;
+
+			if(Stream.InternalOut == 0 && Stream.State == STREAM_FLUSH)
+				Stream.State = STREAM_EMPTY;
+
+			if(Stream.AvailIn < 2)
+				FillBuffer();
+		}
+		while(AvailOut && Stream.State != STREAM_FINAL);
+
+		assert(AvailOut == 0);
+		return (long)(Out - (uint8_t*)buffer);
+	}
+};
+
+
+bool FileReader::OpenDecompressor(FileReader &parent, Size length, int method, bool seekable, const std::function<void(const char*)>& cb)
+{
+	DecompressorBase *dec = nullptr;
+	switch (method)
+	{
+		case METHOD_DEFLATE:
+		case METHOD_ZLIB:
+			dec = new DecompressorZ(parent, method == METHOD_DEFLATE, cb);
+			break;
+
+		case METHOD_BZIP2:
+			dec = new DecompressorBZ2(parent, cb);
+			break;
+
+		case METHOD_LZMA:
+			dec = new DecompressorLZMA(parent, length, cb);
+			break;
+
+		case METHOD_LZSS:
+			dec = new DecompressorLZSS(parent, cb);
+			break;
+			
+		// todo: METHOD_IMPLODE, METHOD_SHRINK
+		default:
+			return false;
+	}
+	dec->Length = (long)length;
+	if (!seekable)
+	{
+		Close();
+		mReader = dec;
+		return true;
+	}
+	else
+	{
+		// todo: create a wrapper. for now this fails
+		delete dec;
+		return false;
+	}
+}

source/common/utility/m_argv.cpp

@@ -67,6 +67,17 @@ FArgs::FArgs(int argc, char **argv)
 	SetArgs(argc, argv);
 }
 
+//===========================================================================
+//
+// FArgs Argv Constructor
+//
+//===========================================================================
+
+FArgs::FArgs(int argc, const char** argv)
+{
+	SetArgs(argc, const_cast<char **>(argv));	// Thanks, C++, for the inflexible const casting rules...
+}
+
 //===========================================================================
 //
 // FArgs String Argv Constructor

source/common/utility/m_argv.h

@@ -46,6 +46,7 @@ public:
 	FArgs();
 	FArgs(const FArgs &args);
 	FArgs(int argc, char **argv);
+	FArgs(int argc, const char** argv);
 	FArgs(int argc, const std::string *argv);
 
 	FArgs &operator=(const FArgs &other);

source/common/utility/m_swap.h

@@ -0,0 +1,255 @@
+//
+// DESCRIPTION:
+//		Endianess handling, swapping 16bit and 32bit.
+//
+//-----------------------------------------------------------------------------
+
+
+#ifndef __M_SWAP_H__
+#define __M_SWAP_H__
+
+#include <stdlib.h>
+
+// Endianess handling.
+// WAD files are stored little endian.
+
+#ifdef __APPLE__
+#include <libkern/OSByteOrder.h>
+
+inline short LittleShort(short x)
+{
+	return (short)OSSwapLittleToHostInt16((uint16_t)x);
+}
+
+inline unsigned short LittleShort(unsigned short x)
+{
+	return OSSwapLittleToHostInt16(x);
+}
+
+inline short LittleShort(int x)
+{
+	return OSSwapLittleToHostInt16((uint16_t)x);
+}
+
+inline unsigned short LittleShort(unsigned int x)
+{
+	return OSSwapLittleToHostInt16((uint16_t)x);
+}
+
+inline int LittleLong(int x)
+{
+	return OSSwapLittleToHostInt32((uint32_t)x);
+}
+
+inline unsigned int LittleLong(unsigned int x)
+{
+	return OSSwapLittleToHostInt32(x);
+}
+
+inline short BigShort(short x)
+{
+	return (short)OSSwapBigToHostInt16((uint16_t)x);
+}
+
+inline unsigned short BigShort(unsigned short x)
+{
+	return OSSwapBigToHostInt16(x);
+}
+
+inline int BigLong(int x)
+{
+	return OSSwapBigToHostInt32((uint32_t)x);
+}
+
+inline unsigned int BigLong(unsigned int x)
+{
+	return OSSwapBigToHostInt32(x);
+}
+
+#elif defined __BIG_ENDIAN__
+
+// Swap 16bit, that is, MSB and LSB byte.
+// No masking with 0xFF should be necessary. 
+inline short LittleShort (short x)
+{
+	return (short)((((unsigned short)x)>>8) | (((unsigned short)x)<<8));
+}
+
+inline unsigned short LittleShort (unsigned short x)
+{
+	return (unsigned short)((x>>8) | (x<<8));
+}
+
+inline short LittleShort (int x)
+{
+	return LittleShort((short)x);
+}
+
+inline unsigned short LittleShort (unsigned int x)
+{
+	return LittleShort((unsigned short)x);
+}
+
+// Swapping 32bit.
+inline unsigned int LittleLong (unsigned int x)
+{
+	return (unsigned int)(
+		(x>>24)
+		| ((x>>8) & 0xff00)
+		| ((x<<8) & 0xff0000)
+		| (x<<24));
+}
+
+inline int LittleLong (int x)
+{
+	return (int)(
+		(((unsigned int)x)>>24)
+		| ((((unsigned int)x)>>8) & 0xff00)
+		| ((((unsigned int)x)<<8) & 0xff0000)
+		| (((unsigned int)x)<<24));
+}
+
+inline short BigShort(short x)
+{
+	return x;
+}
+
+inline unsigned short BigShort(unsigned short x)
+{
+	return x;
+}
+
+inline unsigned int BigLong(unsigned int x)
+{
+	return x;
+}
+
+inline int BigLong(int x)
+{
+	return x;
+}
+
+#else
+
+inline short LittleShort(short x)
+{
+	return x;
+}
+
+inline unsigned short LittleShort(unsigned short x)
+{
+	return x;
+}
+
+inline unsigned int LittleLong(unsigned int x)
+{
+	return x;
+}
+
+inline int LittleLong(int x)
+{
+	return x;
+}
+
+#ifdef _MSC_VER
+
+inline short BigShort(short x)
+{
+	return (short)_byteswap_ushort((unsigned short)x);
+}
+
+inline unsigned short BigShort(unsigned short x)
+{
+	return _byteswap_ushort(x);
+}
+
+inline int BigLong(int x)
+{
+	return (int)_byteswap_ulong((unsigned long)x);
+}
+
+inline unsigned int BigLong(unsigned int x)
+{
+	return (unsigned int)_byteswap_ulong((unsigned long)x);
+}
+#pragma warning (default: 4035)
+
+#else
+
+inline short BigShort (short x)
+{
+	return (short)((((unsigned short)x)>>8) | (((unsigned short)x)<<8));
+}
+
+inline unsigned short BigShort (unsigned short x)
+{
+	return (unsigned short)((x>>8) | (x<<8));
+}
+
+inline unsigned int BigLong (unsigned int x)
+{
+	return (unsigned int)(
+		(x>>24)
+		| ((x>>8) & 0xff00)
+		| ((x<<8) & 0xff0000)
+		| (x<<24));
+}
+
+inline int BigLong (int x)
+{
+	return (int)(
+		(((unsigned int)x)>>24)
+		| ((((unsigned int)x)>>8) & 0xff00)
+		| ((((unsigned int)x)<<8) & 0xff0000)
+		| (((unsigned int)x)<<24));
+}
+
+#endif
+
+#endif // __BIG_ENDIAN__
+
+// These may be destructive so they should create errors
+unsigned long BigLong(unsigned long) = delete;
+long BigLong(long) = delete;
+unsigned long LittleLong(unsigned long) = delete;
+long LittleLong(long) = delete;
+
+
+// Data accessors, since some data is highly likely to be unaligned.
+#if defined(_M_IX86) || defined(_M_X64) || defined(__i386__) || defined(__x86_64__)
+inline int GetShort(const unsigned char *foo)
+{
+	return *(const short *)foo;
+}
+inline int GetInt(const unsigned char *foo)
+{
+	return *(const int *)foo;
+}
+#else
+inline int GetShort(const unsigned char *foo)
+{
+	return short(foo[0] | (foo[1] << 8));
+}
+inline int GetInt(const unsigned char *foo)
+{
+	return int(foo[0] | (foo[1] << 8) | (foo[2] << 16) | (foo[3] << 24));
+}
+#endif
+inline int GetBigInt(const unsigned char *foo)
+{
+	return int((foo[0] << 24) | (foo[1] << 16) | (foo[2] << 8) | foo[3]);
+}
+
+#ifdef __BIG_ENDIAN__
+inline int GetNativeInt(const unsigned char *foo)
+{
+	return GetBigInt(foo);
+}
+#else
+inline int GetNativeInt(const unsigned char *foo)
+{
+	return GetInt(foo);
+}
+#endif
+
+#endif // __M_SWAP_H__

source/common/utility/templates.h

@@ -0,0 +1,18 @@
+
+#pragma once
+
+// we do not want C++17 just for this one function...
+
+//==========================================================================
+//
+// clamp
+//
+// Clamps in to the range [min,max].
+//==========================================================================
+
+template<class T>
+inline
+T clamp (const T in, const T min, const T max)
+{
+	return in <= min ? min : in >= max ? max : in;
+}