9 files changed, 0 insertions, 1056 deletions

diff --git a/depends/lzma/wrapper/common_internal.c b/depends/lzma/wrapper/common_internal.c
deleted file mode 100644
index c9213ef4..00000000
--- a/depends/lzma/wrapper/common_internal.c
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
- * Written in 2009 by Lloyd Hilaiel
- *
- * License
- *
- * All the cruft you find here is public domain.  You don't have to credit
- * anyone to use this code, but my personal request is that you mention
- * Igor Pavlov for his hard, high quality work.
- */
-
-#include "common_internal.h"
-
-static void *elzmaAlloc(void *p, size_t size)
-{
-	struct elzma_alloc_struct *as = (struct elzma_alloc_struct *)p;
-	if (as->clientMallocFunc)
-	{
-		return as->clientMallocFunc(as->clientMallocContext, size);
-	}
-	return malloc(size);
-}
-
-static void elzmaFree(void *p, void *address)
-{
-	struct elzma_alloc_struct *as = (struct elzma_alloc_struct *)p;
-	if (as->clientFreeFunc)
-	{
-		as->clientFreeFunc(as->clientMallocContext, address);
-	}
-	else
-	{
-		free(address);
-	}
-}
-
-void init_alloc_struct(struct elzma_alloc_struct *as, elzma_malloc clientMallocFunc,
-					   void *clientMallocContext, elzma_free clientFreeFunc,
-					   void *clientFreeContext)
-{
-	as->Alloc = elzmaAlloc;
-	as->Free = elzmaFree;
-	as->clientMallocFunc = clientMallocFunc;
-	as->clientMallocContext = clientMallocContext;
-	as->clientFreeFunc = clientFreeFunc;
-	as->clientFreeContext = clientFreeContext;
-}
diff --git a/depends/lzma/wrapper/common_internal.h b/depends/lzma/wrapper/common_internal.h
deleted file mode 100644
index 2c46fadf..00000000
--- a/depends/lzma/wrapper/common_internal.h
+++ /dev/null
@@ -1,60 +0,0 @@
-#ifndef __ELZMA_COMMON_INTERNAL_H__
-#define __ELZMA_COMMON_INTERNAL_H__
-
-#include "common.h"
-
-/** a structure which may be cast and passed into Igor's allocate
- *  routines */
-struct elzma_alloc_struct
-{
-	void *(*Alloc)(void *p, size_t size);
-	void (*Free)(void *p, void *address); /* address can be 0 */
-
-	elzma_malloc clientMallocFunc;
-	void *clientMallocContext;
-
-	elzma_free clientFreeFunc;
-	void *clientFreeContext;
-};
-
-/* initialize an allocation structure, may be called safely multiple
- * times */
-void init_alloc_struct(struct elzma_alloc_struct *allocStruct, elzma_malloc clientMallocFunc,
-					   void *clientMallocContext, elzma_free clientFreeFunc,
-					   void *clientFreeContext);
-
-/** superset representation of a compressed file header */
-struct elzma_file_header
-{
-	unsigned char pb;
-	unsigned char lp;
-	unsigned char lc;
-	unsigned char isStreamed;
-	long long unsigned int uncompressedSize;
-	unsigned int dictSize;
-};
-
-/** superset representation of a compressed file footer */
-struct elzma_file_footer
-{
-	unsigned int crc32;
-	long long unsigned int uncompressedSize;
-};
-
-/** a structure which encapsulates information about the particular
- *  file header and footer in use (lzip vs lzma vs (eventually) xz.
- *  The intention of this structure is to simplify compression and
- *  decompression logic by abstracting the file format details a bit.  */
-struct elzma_format_handler
-{
-	unsigned int header_size;
-	void (*init_header)(struct elzma_file_header *hdr);
-	int (*parse_header)(const unsigned char *hdrBuf, struct elzma_file_header *hdr);
-	int (*serialize_header)(unsigned char *hdrBuf, const struct elzma_file_header *hdr);
-
-	unsigned int footer_size;
-	int (*serialize_footer)(struct elzma_file_footer *ftr, unsigned char *ftrBuf);
-	int (*parse_footer)(const unsigned char *ftrBuf, struct elzma_file_footer *ftr);
-};
-
-#endif
diff --git a/depends/lzma/wrapper/compress.c b/depends/lzma/wrapper/compress.c
deleted file mode 100644
index 38ca0a68..00000000
--- a/depends/lzma/wrapper/compress.c
+++ /dev/null
@@ -1,297 +0,0 @@
-/*
- * Written in 2009 by Lloyd Hilaiel
- *
- * License
- *
- * All the cruft you find here is public domain.  You don't have to credit
- * anyone to use this code, but my personal request is that you mention
- * Igor Pavlov for his hard, high quality work.
- */
-
-#include "compress.h"
-#include "lzma_header.h"
-#include "lzip_header.h"
-#include "common_internal.h"
-
-#include "pavlov/Types.h"
-#include "pavlov/LzmaEnc.h"
-#include "pavlov/7zCrc.h"
-
-#include <string.h>
-
-struct _elzma_compress_handle
-{
-	CLzmaEncProps props;
-	CLzmaEncHandle encHand;
-	unsigned long long uncompressedSize;
-	elzma_file_format format;
-	struct elzma_alloc_struct allocStruct;
-	struct elzma_format_handler formatHandler;
-};
-
-elzma_compress_handle elzma_compress_alloc()
-{
-	elzma_compress_handle hand = malloc(sizeof(struct _elzma_compress_handle));
-	memset((void *)hand, 0, sizeof(struct _elzma_compress_handle));
-
-	/* "reasonable" defaults for props */
-	LzmaEncProps_Init(&(hand->props));
-	hand->props.lc = 3;
-	hand->props.lp = 0;
-	hand->props.pb = 2;
-	hand->props.level = 5;
-	hand->props.algo = 1;
-	hand->props.fb = 32;
-	hand->props.dictSize = 1 << 24;
-	hand->props.btMode = 1;
-	hand->props.numHashBytes = 4;
-	hand->props.mc = 32;
-	hand->props.numThreads = 1;
-	hand->props.writeEndMark = 1;
-
-	init_alloc_struct(&(hand->allocStruct), NULL, NULL, NULL, NULL);
-
-	/* default format is LZMA-Alone */
-	initializeLZMAFormatHandler(&(hand->formatHandler));
-
-	return hand;
-}
-
-void elzma_compress_free(elzma_compress_handle *hand)
-{
-	if (hand && *hand)
-	{
-		if ((*hand)->encHand)
-		{
-			LzmaEnc_Destroy((*hand)->encHand);
-		}
-	}
-	*hand = NULL;
-}
-
-int elzma_compress_config(elzma_compress_handle hand, unsigned char lc, unsigned char lp,
-						  unsigned char pb, unsigned char level, unsigned int dictionarySize,
-						  elzma_file_format format, unsigned long long uncompressedSize)
-{
-	/* XXX: validate arguments are in valid ranges */
-
-	hand->props.lc = lc;
-	hand->props.lp = lp;
-	hand->props.pb = pb;
-	hand->props.level = level;
-	hand->props.dictSize = dictionarySize;
-	hand->uncompressedSize = uncompressedSize;
-	hand->format = format;
-
-	/* default of LZMA-Alone is set at alloc time, and there are only
-	 * two possible formats */
-	if (format == ELZMA_lzip)
-	{
-		initializeLZIPFormatHandler(&(hand->formatHandler));
-	}
-
-	return ELZMA_E_OK;
-}
-
-/* use Igor's stream hooks for compression. */
-struct elzmaInStream
-{
-	SRes (*ReadPtr)(void *p, void *buf, size_t *size);
-	elzma_read_callback inputStream;
-	void *inputContext;
-	unsigned int crc32;
-	unsigned int crc32a;
-	unsigned int crc32b;
-	unsigned int crc32c;
-	int calculateCRC;
-};
-
-static SRes elzmaReadFunc(void *p, void *buf, size_t *size)
-{
-	int rv;
-	struct elzmaInStream *is = (struct elzmaInStream *)p;
-	rv = is->inputStream(is->inputContext, buf, size);
-	if (rv == 0 && *size > 0 && is->calculateCRC)
-	{
-		is->crc32 = CrcUpdate(is->crc32, buf, *size);
-	}
-	return rv;
-}
-
-struct elzmaOutStream
-{
-	size_t (*WritePtr)(void *p, const void *buf, size_t size);
-	elzma_write_callback outputStream;
-	void *outputContext;
-};
-
-static size_t elzmaWriteFunc(void *p, const void *buf, size_t size)
-{
-	struct elzmaOutStream *os = (struct elzmaOutStream *)p;
-	return os->outputStream(os->outputContext, buf, size);
-}
-
-/* use Igor's stream hooks for compression. */
-struct elzmaProgressStruct
-{
-	SRes (*Progress)(void *p, uint64_t inSize, uint64_t outSize);
-	long long unsigned int uncompressedSize;
-	elzma_progress_callback progressCallback;
-	void *progressContext;
-};
-
-#include <stdio.h>
-static SRes elzmaProgress(void *p, uint64_t inSize, uint64_t outSize)
-{
-	struct elzmaProgressStruct *ps = (struct elzmaProgressStruct *)p;
-	if (ps->progressCallback)
-	{
-		ps->progressCallback(ps->progressContext, inSize, ps->uncompressedSize);
-	}
-	return SZ_OK;
-}
-
-void elzma_compress_set_allocation_callbacks(elzma_compress_handle hand,
-											 elzma_malloc mallocFunc, void *mallocFuncContext,
-											 elzma_free freeFunc, void *freeFuncContext)
-{
-	if (hand)
-	{
-		init_alloc_struct(&(hand->allocStruct), mallocFunc, mallocFuncContext, freeFunc,
-						  freeFuncContext);
-	}
-}
-
-int elzma_compress_run(elzma_compress_handle hand, elzma_read_callback inputStream,
-					   void *inputContext, elzma_write_callback outputStream,
-					   void *outputContext, elzma_progress_callback progressCallback,
-					   void *progressContext)
-{
-	struct elzmaInStream inStreamStruct;
-	struct elzmaOutStream outStreamStruct;
-	struct elzmaProgressStruct progressStruct;
-	SRes r;
-
-	CrcGenerateTable();
-
-	if (hand == NULL || inputStream == NULL)
-		return ELZMA_E_BAD_PARAMS;
-
-	/* initialize stream structrures */
-	inStreamStruct.ReadPtr = elzmaReadFunc;
-	inStreamStruct.inputStream = inputStream;
-	inStreamStruct.inputContext = inputContext;
-	inStreamStruct.crc32 = CRC_INIT_VAL;
-	inStreamStruct.calculateCRC = (hand->formatHandler.serialize_footer != NULL);
-
-	outStreamStruct.WritePtr = elzmaWriteFunc;
-	outStreamStruct.outputStream = outputStream;
-	outStreamStruct.outputContext = outputContext;
-
-	progressStruct.Progress = elzmaProgress;
-	progressStruct.uncompressedSize = hand->uncompressedSize;
-	progressStruct.progressCallback = progressCallback;
-	progressStruct.progressContext = progressContext;
-
-	/* create an encoding object */
-	hand->encHand = LzmaEnc_Create();
-
-	if (hand->encHand == NULL)
-	{
-		return ELZMA_E_COMPRESS_ERROR;
-	}
-
-	/* inintialize with compression parameters */
-	if (SZ_OK != LzmaEnc_SetProps(hand->encHand, &(hand->props)))
-	{
-		return ELZMA_E_BAD_PARAMS;
-	}
-
-	/* verify format is sane */
-	if (ELZMA_lzma != hand->format && ELZMA_lzip != hand->format)
-	{
-		return ELZMA_E_UNSUPPORTED_FORMAT;
-	}
-
-	/* now write the compression header header */
-	{
-		unsigned char *hdr =
-			hand->allocStruct.Alloc(&(hand->allocStruct), hand->formatHandler.header_size);
-
-		struct elzma_file_header h;
-		size_t wt;
-
-		hand->formatHandler.init_header(&h);
-		h.pb = (unsigned char)hand->props.pb;
-		h.lp = (unsigned char)hand->props.lp;
-		h.lc = (unsigned char)hand->props.lc;
-		h.dictSize = hand->props.dictSize;
-		h.isStreamed = (unsigned char)(hand->uncompressedSize == 0);
-		h.uncompressedSize = hand->uncompressedSize;
-
-		hand->formatHandler.serialize_header(hdr, &h);
-
-		wt = outputStream(outputContext, (void *)hdr, hand->formatHandler.header_size);
-
-		hand->allocStruct.Free(&(hand->allocStruct), hdr);
-
-		if (wt != hand->formatHandler.header_size)
-		{
-			return ELZMA_E_OUTPUT_ERROR;
-		}
-	}
-
-	/* begin LZMA encoding */
-	/* XXX: expose encoding progress */
-	r = LzmaEnc_Encode(hand->encHand, (ISeqOutStream *)&outStreamStruct,
-					   (ISeqInStream *)&inStreamStruct, (ICompressProgress *)&progressStruct);
-
-	if (r != SZ_OK)
-		return ELZMA_E_COMPRESS_ERROR;
-
-	/* support a footer! (lzip) */
-	if (hand->formatHandler.serialize_footer != NULL && hand->formatHandler.footer_size > 0)
-	{
-		size_t wt;
-		unsigned char *ftrBuf =
-			hand->allocStruct.Alloc(&(hand->allocStruct), hand->formatHandler.footer_size);
-		struct elzma_file_footer ftr;
-		ftr.crc32 = inStreamStruct.crc32 ^ 0xFFFFFFFF;
-		ftr.uncompressedSize = hand->uncompressedSize;
-
-		hand->formatHandler.serialize_footer(&ftr, ftrBuf);
-
-		wt = outputStream(outputContext, (void *)ftrBuf, hand->formatHandler.footer_size);
-
-		hand->allocStruct.Free(&(hand->allocStruct), ftrBuf);
-
-		if (wt != hand->formatHandler.footer_size)
-		{
-			return ELZMA_E_OUTPUT_ERROR;
-		}
-	}
-
-	return ELZMA_E_OK;
-}
-
-unsigned int elzma_get_dict_size(unsigned long long size)
-{
-	int i = 13; /* 16k dict is minimum */
-
-	/* now we'll find the closes power of two with a max at 16< *
-	 * if the size is greater than 8m, we'll divide by two, all of this
-	 * is based on a quick set of emperical tests on hopefully
-	 * representative sample data */
-	if (size > (1 << 23))
-		size >>= 1;
-
-	while (size >> i)
-		i++;
-
-	if (i > 23)
-		return 1 << 23;
-
-	/* now 1 << i is greater than size, let's return either 1<<i or 1<<(i-1),
-	 * whichever is closer to size */
-	return 1 << ((((1 << i) - size) > (size - (1 << (i - 1)))) ? i - 1 : i);
-}
diff --git a/depends/lzma/wrapper/decompress.c b/depends/lzma/wrapper/decompress.c
deleted file mode 100644
index 65ff9119..00000000
--- a/depends/lzma/wrapper/decompress.c
+++ /dev/null
@@ -1,263 +0,0 @@
-/*
- * Written in 2009 by Lloyd Hilaiel
- *
- * License
- *
- * All the cruft you find here is public domain.  You don't have to credit
- * anyone to use this code, but my personal request is that you mention
- * Igor Pavlov for his hard, high quality work.
- */
-
-#include "include/decompress.h"
-#include "pavlov/LzmaDec.h"
-#include "pavlov/7zCrc.h"
-#include "common_internal.h"
-#include "lzma_header.h"
-#include "lzip_header.h"
-
-#include <string.h>
-#include <assert.h>
-
-#define ELZMA_DECOMPRESS_INPUT_BUFSIZE (1024 * 64)
-#define ELZMA_DECOMPRESS_OUTPUT_BUFSIZE (1024 * 256)
-
-/** an opaque handle to an lzma decompressor */
-struct _elzma_decompress_handle
-{
-	char inbuf[ELZMA_DECOMPRESS_INPUT_BUFSIZE];
-	char outbuf[ELZMA_DECOMPRESS_OUTPUT_BUFSIZE];
-	struct elzma_alloc_struct allocStruct;
-};
-
-elzma_decompress_handle elzma_decompress_alloc()
-{
-	elzma_decompress_handle hand = malloc(sizeof(struct _elzma_decompress_handle));
-	memset((void *)hand, 0, sizeof(struct _elzma_decompress_handle));
-	init_alloc_struct(&(hand->allocStruct), NULL, NULL, NULL, NULL);
-	return hand;
-}
-
-void elzma_decompress_set_allocation_callbacks(elzma_decompress_handle hand,
-											   elzma_malloc mallocFunc, void *mallocFuncContext,
-											   elzma_free freeFunc, void *freeFuncContext)
-{
-	if (hand)
-	{
-		init_alloc_struct(&(hand->allocStruct), mallocFunc, mallocFuncContext, freeFunc,
-						  freeFuncContext);
-	}
-}
-
-void elzma_decompress_free(elzma_decompress_handle *hand)
-{
-	if (*hand)
-		free(*hand);
-	*hand = NULL;
-}
-
-int elzma_decompress_run(elzma_decompress_handle hand, elzma_read_callback inputStream,
-						 void *inputContext, elzma_write_callback outputStream,
-						 void *outputContext, elzma_file_format format)
-{
-	unsigned long long int totalRead = 0; /* total amount read from stream */
-	unsigned int crc32 = CRC_INIT_VAL;	/* running crc32 (lzip case) */
-	CLzmaDec dec;
-	unsigned int errorCode = ELZMA_E_OK;
-	struct elzma_format_handler formatHandler;
-	struct elzma_file_header h;
-	struct elzma_file_footer f;
-
-	/* switch between supported formats */
-	if (format == ELZMA_lzma)
-	{
-		initializeLZMAFormatHandler(&formatHandler);
-	}
-	else if (format == ELZMA_lzip)
-	{
-		CrcGenerateTable();
-		initializeLZIPFormatHandler(&formatHandler);
-	}
-	else
-	{
-		return ELZMA_E_BAD_PARAMS;
-	}
-
-	/* initialize footer */
-	f.crc32 = 0;
-	f.uncompressedSize = 0;
-
-	/* initialize decoder memory */
-	memset((void *)&dec, 0, sizeof(dec));
-	LzmaDec_Init(&dec);
-
-	/* decode the header. */
-	{
-		unsigned char *hdr =
-			hand->allocStruct.Alloc(&(hand->allocStruct), formatHandler.header_size);
-
-		size_t sz = formatHandler.header_size;
-
-		formatHandler.init_header(&h);
-
-		if (inputStream(inputContext, hdr, &sz) != 0 || sz != formatHandler.header_size)
-		{
-			hand->allocStruct.Free(&(hand->allocStruct), hdr);
-			return ELZMA_E_INPUT_ERROR;
-		}
-
-		if (0 != formatHandler.parse_header(hdr, &h))
-		{
-			hand->allocStruct.Free(&(hand->allocStruct), hdr);
-			return ELZMA_E_CORRUPT_HEADER;
-		}
-
-		/* the LzmaDec_Allocate call requires 5 bytes which have
-		 * compression properties encoded in them.  In the case of
-		 * lzip, the header format does not already contain what
-		 * LzmaDec_Allocate expects, so we must craft it, silly */
-		{
-			unsigned char propsBuf[13];
-			const unsigned char *propsPtr = hdr;
-
-			if (format == ELZMA_lzip)
-			{
-				struct elzma_format_handler lzmaHand;
-				initializeLZMAFormatHandler(&lzmaHand);
-				lzmaHand.serialize_header(propsBuf, &h);
-				propsPtr = propsBuf;
-			}
-
-			/* now we're ready to allocate the decoder */
-			LzmaDec_Allocate(&dec, propsPtr, 5);
-		}
-
-		hand->allocStruct.Free(&(hand->allocStruct), hdr);
-	}
-
-	/* perform the decoding */
-	for (;;)
-	{
-		size_t dstLen = ELZMA_DECOMPRESS_OUTPUT_BUFSIZE;
-		size_t srcLen = ELZMA_DECOMPRESS_INPUT_BUFSIZE;
-		size_t amt = 0;
-		size_t bufOff = 0;
-		ELzmaStatus stat;
-
-		if (0 != inputStream(inputContext, hand->inbuf, &srcLen))
-		{
-			errorCode = ELZMA_E_INPUT_ERROR;
-			goto decompressEnd;
-		}
-
-		/* handle the case where the input prematurely finishes */
-		if (srcLen == 0)
-		{
-			errorCode = ELZMA_E_INSUFFICIENT_INPUT;
-			goto decompressEnd;
-		}
-
-		amt = srcLen;
-
-		/* handle the case where a single read buffer of compressed bytes
-		 * will translate into multiple buffers of uncompressed bytes,
-		 * with this inner loop */
-		stat = LZMA_STATUS_NOT_SPECIFIED;
-
-		while (bufOff < srcLen)
-		{
-			SRes r = LzmaDec_DecodeToBuf(&dec, (uint8_t *)hand->outbuf, &dstLen,
-										 ((uint8_t *)hand->inbuf + bufOff), &amt,
-										 LZMA_FINISH_ANY, &stat);
-
-			/* XXX deal with result code more granularly*/
-			if (r != SZ_OK)
-			{
-				errorCode = ELZMA_E_DECOMPRESS_ERROR;
-				goto decompressEnd;
-			}
-
-			/* write what we've read */
-			{
-				size_t wt;
-
-				/* if decoding lzip, update our crc32 value */
-				if (format == ELZMA_lzip && dstLen > 0)
-				{
-					crc32 = CrcUpdate(crc32, hand->outbuf, dstLen);
-				}
-				totalRead += dstLen;
-
-				wt = outputStream(outputContext, hand->outbuf, dstLen);
-				if (wt != dstLen)
-				{
-					errorCode = ELZMA_E_OUTPUT_ERROR;
-					goto decompressEnd;
-				}
-			}
-
-			/* do we have more data on the input buffer? */
-			bufOff += amt;
-			assert(bufOff <= srcLen);
-			if (bufOff >= srcLen)
-				break;
-			amt = srcLen - bufOff;
-
-			/* with lzip, we will have the footer left on the buffer! */
-			if (stat == LZMA_STATUS_FINISHED_WITH_MARK)
-			{
-				break;
-			}
-		}
-
-		/* now check status */
-		if (stat == LZMA_STATUS_FINISHED_WITH_MARK)
-		{
-			/* read a footer if one is expected and
-			 * present */
-			if (formatHandler.footer_size > 0 && amt >= formatHandler.footer_size &&
-				formatHandler.parse_footer != NULL)
-			{
-				formatHandler.parse_footer((unsigned char *)hand->inbuf + bufOff, &f);
-			}
-
-			break;
-		}
-		/* for LZMA utils,  we don't always have a finished mark */
-		if (!h.isStreamed && totalRead >= h.uncompressedSize)
-		{
-			break;
-		}
-	}
-
-	/* finish the calculated crc32 */
-	crc32 ^= 0xFFFFFFFF;
-
-	/* if we have a footer, check that the calculated crc32 matches
-	 * the encoded crc32, and that the sizes match */
-	if (formatHandler.footer_size)
-	{
-		if (f.crc32 != crc32)
-		{
-			errorCode = ELZMA_E_CRC32_MISMATCH;
-		}
-		else if (f.uncompressedSize != totalRead)
-		{
-			errorCode = ELZMA_E_SIZE_MISMATCH;
-		}
-	}
-	else if (!h.isStreamed)
-	{
-		/* if the format does not support a footer and has an uncompressed
-		 * size in the header, let's compare that with how much we actually
-		 * read */
-		if (h.uncompressedSize != totalRead)
-		{
-			errorCode = ELZMA_E_SIZE_MISMATCH;
-		}
-	}
-
-decompressEnd:
-	LzmaDec_Free(&dec);
-
-	return errorCode;
-}
diff --git a/depends/lzma/wrapper/lzip_header.c b/depends/lzma/wrapper/lzip_header.c
deleted file mode 100644
index 39872813..00000000
--- a/depends/lzma/wrapper/lzip_header.c
+++ /dev/null
@@ -1,96 +0,0 @@
-#include "lzip_header.h"
-
-#include <string.h>
-
-#define ELZMA_LZIP_HEADER_SIZE 6
-#define ELZMA_LZIP_FOOTER_SIZE 12
-
-static void initLzipHeader(struct elzma_file_header *hdr)
-{
-	memset((void *)hdr, 0, sizeof(struct elzma_file_header));
-}
-
-static int parseLzipHeader(const unsigned char *hdrBuf, struct elzma_file_header *hdr)
-{
-	if (0 != strncmp("LZIP", (char *)hdrBuf, 4))
-		return 1;
-	/* XXX: ignore version for now */
-	hdr->pb = 2;
-	hdr->lp = 0;
-	hdr->lc = 3;
-	/* unknown at this point */
-	hdr->isStreamed = 1;
-	hdr->uncompressedSize = 0;
-	hdr->dictSize = 1 << (hdrBuf[5] & 0x1F);
-	return 0;
-}
-
-static int serializeLzipHeader(unsigned char *hdrBuf, const struct elzma_file_header *hdr)
-{
-	hdrBuf[0] = 'L';
-	hdrBuf[1] = 'Z';
-	hdrBuf[2] = 'I';
-	hdrBuf[3] = 'P';
-	hdrBuf[4] = 0;
-	{
-		int r = 0;
-		while ((hdr->dictSize >> r) != 0)
-			r++;
-		hdrBuf[5] = (unsigned char)(r - 1) & 0x1F;
-	}
-	return 0;
-}
-
-static int serializeLzipFooter(struct elzma_file_footer *ftr, unsigned char *ftrBuf)
-{
-	unsigned int i = 0;
-
-	/* first crc32 */
-	for (i = 0; i < 4; i++)
-	{
-		*(ftrBuf++) = (unsigned char)(ftr->crc32 >> (i * 8));
-	}
-
-	/* next data size */
-	for (i = 0; i < 8; i++)
-	{
-		*(ftrBuf++) = (unsigned char)(ftr->uncompressedSize >> (i * 8));
-	}
-
-	/* write version 0 files, omit member length for now*/
-
-	return 0;
-}
-
-static int parseLzipFooter(const unsigned char *ftrBuf, struct elzma_file_footer *ftr)
-{
-	unsigned int i = 0;
-	ftr->crc32 = 0;
-	ftr->uncompressedSize = 0;
-
-	/* first crc32 */
-	for (i = 0; i < 4; i++)
-	{
-		ftr->crc32 += ((unsigned int)*(ftrBuf++) << (i * 8));
-	}
-
-	/* next data size */
-	for (i = 0; i < 8; i++)
-	{
-		ftr->uncompressedSize += (unsigned long long)*(ftrBuf++) << (i * 8);
-	}
-	/* read version 0 files, omit member length for now*/
-
-	return 0;
-}
-
-void initializeLZIPFormatHandler(struct elzma_format_handler *hand)
-{
-	hand->header_size = ELZMA_LZIP_HEADER_SIZE;
-	hand->init_header = initLzipHeader;
-	hand->parse_header = parseLzipHeader;
-	hand->serialize_header = serializeLzipHeader;
-	hand->footer_size = ELZMA_LZIP_FOOTER_SIZE;
-	hand->serialize_footer = serializeLzipFooter;
-	hand->parse_footer = parseLzipFooter;
-}
diff --git a/depends/lzma/wrapper/lzip_header.h b/depends/lzma/wrapper/lzip_header.h
deleted file mode 100644
index 138afa60..00000000
--- a/depends/lzma/wrapper/lzip_header.h
+++ /dev/null
@@ -1,11 +0,0 @@
-#ifndef __EASYLZMA_LZIP_HEADER__
-#define __EASYLZMA_LZIP_HEADER__
-
-#include "common_internal.h"
-
-/* lzip file format documented here:
- * http://download.savannah.gnu.org/releases-noredirect/lzip/manual/ */
-
-void initializeLZIPFormatHandler(struct elzma_format_handler *hand);
-
-#endif
diff --git a/depends/lzma/wrapper/lzma_header.c b/depends/lzma/wrapper/lzma_header.c
deleted file mode 100644
index ab32549f..00000000
--- a/depends/lzma/wrapper/lzma_header.c
+++ /dev/null
@@ -1,134 +0,0 @@
-/*
- * Written in 2009 by Lloyd Hilaiel
- *
- * License
- *
- * All the cruft you find here is public domain.  You don't have to credit
- * anyone to use this code, but my personal request is that you mention
- * Igor Pavlov for his hard, high quality work.
- */
-
-/* XXX: clean this up, it's mostly lifted from pavel */
-
-#include "lzma_header.h"
-
-#include <string.h>
-#include <assert.h>
-
-#define ELZMA_LZMA_HEADER_SIZE 13
-#define ELZMA_LZMA_PROPSBUF_SIZE 5
-
-/****************
-  Header parsing
- ****************/
-
-#ifndef UINT64_MAX
-#define UINT64_MAX ((unsigned long long)-1)
-#endif
-
-/* Parse the properties byte */
-static char lzmadec_header_properties(unsigned char *pb, unsigned char *lp, unsigned char *lc,
-									  const unsigned char c)
-{
-	/*	 pb, lp and lc are encoded into a single byte.  */
-	if (c > (9 * 5 * 5))
-		return -1;
-	*pb = c / (9 * 5);	   /* 0 <= pb <= 4 */
-	*lp = (c % (9 * 5)) / 9; /* 0 <= lp <= 4 */
-	*lc = c % 9;			 /* 0 <= lc <= 8 */
-
-	assert(*pb < 5 && *lp < 5 && *lc < 9);
-	return 0;
-}
-
-/* Parse the dictionary size (4 bytes, little endian) */
-static char lzmadec_header_dictionary(unsigned int *size, const unsigned char *buffer)
-{
-	unsigned int i;
-	*size = 0;
-	for (i = 0; i < 4; i++)
-		*size += (unsigned int)(*buffer++) << (i * 8);
-	/* The dictionary size is limited to 256 MiB (checked from
-	 * LZMA SDK 4.30) */
-	if (*size > (1 << 28))
-		return -1;
-	return 0;
-}
-
-/* Parse the uncompressed size field (8 bytes, little endian) */
-static void lzmadec_header_uncompressed(unsigned long long *size, unsigned char *is_streamed,
-										const unsigned char *buffer)
-{
-	unsigned int i;
-
-	/* Streamed files have all 64 bits set in the size field.
-	 * We don't know the uncompressed size beforehand. */
-	*is_streamed = 1; /* Assume streamed. */
-	*size = 0;
-	for (i = 0; i < 8; i++)
-	{
-		*size += (unsigned long long)buffer[i] << (i * 8);
-		if (buffer[i] != 255)
-			*is_streamed = 0;
-	}
-	assert((*is_streamed == 1 && *size == UINT64_MAX) ||
-		   (*is_streamed == 0 && *size < UINT64_MAX));
-}
-
-static void initLzmaHeader(struct elzma_file_header *hdr)
-{
-	memset((void *)hdr, 0, sizeof(struct elzma_file_header));
-}
-
-static int parseLzmaHeader(const unsigned char *hdrBuf, struct elzma_file_header *hdr)
-{
-	if (lzmadec_header_properties(&(hdr->pb), &(hdr->lp), &(hdr->lc), *hdrBuf) ||
-		lzmadec_header_dictionary(&(hdr->dictSize), hdrBuf + 1))
-	{
-		return 1;
-	}
-	lzmadec_header_uncompressed(&(hdr->uncompressedSize), &(hdr->isStreamed), hdrBuf + 5);
-
-	return 0;
-}
-
-static int serializeLzmaHeader(unsigned char *hdrBuf, const struct elzma_file_header *hdr)
-{
-	unsigned int i;
-
-	memset((void *)hdrBuf, 0, ELZMA_LZMA_HEADER_SIZE);
-
-	/* encode lc, pb, and lp */
-	*hdrBuf++ = hdr->lc + (hdr->pb * 45) + (hdr->lp * 45 * 9);
-
-	/* encode dictionary size */
-	for (i = 0; i < 4; i++)
-	{
-		*(hdrBuf++) = (unsigned char)(hdr->dictSize >> (i * 8));
-	}
-
-	/* encode uncompressed size */
-	for (i = 0; i < 8; i++)
-	{
-		if (hdr->isStreamed)
-		{
-			*(hdrBuf++) = 0xff;
-		}
-		else
-		{
-			*(hdrBuf++) = (unsigned char)(hdr->uncompressedSize >> (i * 8));
-		}
-	}
-
-	return 0;
-}
-
-void initializeLZMAFormatHandler(struct elzma_format_handler *hand)
-{
-	hand->header_size = ELZMA_LZMA_HEADER_SIZE;
-	hand->init_header = initLzmaHeader;
-	hand->parse_header = parseLzmaHeader;
-	hand->serialize_header = serializeLzmaHeader;
-	hand->footer_size = 0;
-	hand->serialize_footer = NULL;
-}
diff --git a/depends/lzma/wrapper/lzma_header.h b/depends/lzma/wrapper/lzma_header.h
deleted file mode 100644
index 6a5d7a9c..00000000
--- a/depends/lzma/wrapper/lzma_header.h
+++ /dev/null
@@ -1,10 +0,0 @@
-#ifndef __EASYLZMA_LZMA_HEADER__
-#define __EASYLZMA_LZMA_HEADER__
-
-#include "common_internal.h"
-
-/* LZMA-Alone header format gleaned from reading Igor's code */
-
-void initializeLZMAFormatHandler(struct elzma_format_handler *hand);
-
-#endif
diff --git a/depends/lzma/wrapper/simple.c b/depends/lzma/wrapper/simple.c
deleted file mode 100644
index 98d3c285..00000000
--- a/depends/lzma/wrapper/simple.c
+++ /dev/null
@@ -1,139 +0,0 @@
-/*
- * Written in 2009 by Lloyd Hilaiel
- *
- * License
- *
- * All the cruft you find here is public domain.  You don't have to credit
- * anyone to use this code, but my personal request is that you mention
- * Igor Pavlov for his hard, high quality work.
- *
- * simple.c - a wrapper around easylzma to compress/decompress to memory
- */
-
-#include "simple.h"
-
-#include <string.h>
-#include <assert.h>
-
-struct dataStream
-{
-	const unsigned char *inData;
-	size_t inLen;
-
-	unsigned char *outData;
-	size_t outLen;
-};
-
-static int inputCallback(void *ctx, void *buf, size_t *size)
-{
-	size_t rd = 0;
-	struct dataStream *ds = (struct dataStream *)ctx;
-	assert(ds != NULL);
-
-	rd = (ds->inLen < *size) ? ds->inLen : *size;
-
-	if (rd > 0)
-	{
-		memcpy(buf, (void *)ds->inData, rd);
-		ds->inData += rd;
-		ds->inLen -= rd;
-	}
-
-	*size = rd;
-
-	return 0;
-}
-
-static size_t outputCallback(void *ctx, const void *buf, size_t size)
-{
-	struct dataStream *ds = (struct dataStream *)ctx;
-	assert(ds != NULL);
-
-	if (size > 0)
-	{
-		ds->outData = realloc(ds->outData, ds->outLen + size);
-		memcpy((void *)(ds->outData + ds->outLen), buf, size);
-		ds->outLen += size;
-	}
-
-	return size;
-}
-
-int simpleCompress(elzma_file_format format, const unsigned char *inData, size_t inLen,
-				   unsigned char **outData, size_t *outLen)
-{
-	int rc;
-	elzma_compress_handle hand;
-
-	/* allocate compression handle */
-	hand = elzma_compress_alloc();
-	assert(hand != NULL);
-
-	rc = elzma_compress_config(hand, ELZMA_LC_DEFAULT, ELZMA_LP_DEFAULT, ELZMA_PB_DEFAULT, 5,
-							   (1 << 20) /* 1mb */, format, inLen);
-
-	if (rc != ELZMA_E_OK)
-	{
-		elzma_compress_free(&hand);
-		return rc;
-	}
-
-	/* now run the compression */
-	{
-		struct dataStream ds;
-		ds.inData = inData;
-		ds.inLen = inLen;
-		ds.outData = NULL;
-		ds.outLen = 0;
-
-		rc = elzma_compress_run(hand, inputCallback, (void *)&ds, outputCallback, (void *)&ds,
-								NULL, NULL);
-
-		if (rc != ELZMA_E_OK)
-		{
-			if (ds.outData != NULL)
-				free(ds.outData);
-			elzma_compress_free(&hand);
-			return rc;
-		}
-
-		*outData = ds.outData;
-		*outLen = ds.outLen;
-	}
-
-	return rc;
-}
-
-int simpleDecompress(elzma_file_format format, const unsigned char *inData, size_t inLen,
-					 unsigned char **outData, size_t *outLen)
-{
-	int rc;
-	elzma_decompress_handle hand;
-
-	hand = elzma_decompress_alloc();
-
-	/* now run the compression */
-	{
-		struct dataStream ds;
-		ds.inData = inData;
-		ds.inLen = inLen;
-		ds.outData = NULL;
-		ds.outLen = 0;
-
-		rc = elzma_decompress_run(hand, inputCallback, (void *)&ds, outputCallback, (void *)&ds,
-								  format);
-
-		if (rc != ELZMA_E_OK)
-		{
-			if (ds.outData != NULL)
-				free(ds.outData);
-			elzma_decompress_free(&hand);
-			return rc;
-		}
-
-		*outData = ds.outData;
-		*outLen = ds.outLen;
-	}
-
-	return rc;
-}