summaryrefslogtreecommitdiffstatshomepage
path: root/3rdparty/lua-zlib
diff options
context:
space:
mode:
author ImJezze <jezze@gmx.net>2016-02-21 11:48:45 +0100
committer ImJezze <jezze@gmx.net>2016-02-21 11:48:45 +0100
commitcc24a339d8c0517259084b5c178d784626ba965c (patch)
tree9868e9687b5802ae0a3733712a3bbeb3bc75c953 /3rdparty/lua-zlib
parentb5daabda5495dea5c50e17961ecfed2ea8619d76 (diff)
Merge remote-tracking branch 'refs/remotes/mamedev/master'
Second attempt
Diffstat (limited to '3rdparty/lua-zlib')
-rw-r--r--3rdparty/lua-zlib/.gitattributes1
-rw-r--r--3rdparty/lua-zlib/CMakeLists.txt62
-rw-r--r--3rdparty/lua-zlib/Makefile62
-rw-r--r--3rdparty/lua-zlib/README151
-rw-r--r--3rdparty/lua-zlib/amnon_david.gzbin0 -> 65 bytes
-rw-r--r--3rdparty/lua-zlib/cmake/Modules/FindLuaJIT.cmake63
-rw-r--r--3rdparty/lua-zlib/lua_zlib.c401
-rw-r--r--3rdparty/lua-zlib/rockspec35
-rw-r--r--3rdparty/lua-zlib/tap.lua24
-rw-r--r--3rdparty/lua-zlib/test.lua198
-rw-r--r--3rdparty/lua-zlib/tom_macwright.gz4
-rw-r--r--3rdparty/lua-zlib/tom_macwright.outbin0 -> 245 bytes
-rw-r--r--3rdparty/lua-zlib/zlib.def2
13 files changed, 1003 insertions, 0 deletions
diff --git a/3rdparty/lua-zlib/.gitattributes b/3rdparty/lua-zlib/.gitattributes
new file mode 100644
index 00000000000..54be6288857
--- /dev/null
+++ b/3rdparty/lua-zlib/.gitattributes
@@ -0,0 +1 @@
+lua_zlib.c export-subst ident
diff --git a/3rdparty/lua-zlib/CMakeLists.txt b/3rdparty/lua-zlib/CMakeLists.txt
new file mode 100644
index 00000000000..1cda6b7532b
--- /dev/null
+++ b/3rdparty/lua-zlib/CMakeLists.txt
@@ -0,0 +1,62 @@
+# Copyright (C) 2007-2009 LuaDist.
+# Submitted by David Manura
+# Redistribution and use of this file is allowed according to the
+# terms of the MIT license.
+# For details see the COPYRIGHT file distributed with LuaDist.
+# Please note that the package source code is licensed under its own
+# license.
+
+PROJECT(lua-zlib C)
+CMAKE_MINIMUM_REQUIRED (VERSION 2.6)
+
+option(USE_LUA "Use Lua (also called 'C' Lua) includes (default)" ON)
+option(USE_LUAJIT "Use LuaJIT includes instead of 'C' Lua ones (recommended, if you're using LuaJIT, but disabled by default)")
+set(USE_LUA_VERSION 5.1 CACHE STRING "Set the Lua version to use (default: 5.1)")
+
+set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake/Modules/")
+
+if(USE_LUAJIT)
+# Find luajit
+ find_package(LuaJIT REQUIRED)
+ set(USE_LUA OFF)
+# / Find lua
+endif()
+
+if(USE_LUA)
+# Find lua
+ find_package(Lua ${USE_LUA_VERSION} EXACT REQUIRED)
+# / Find lua
+endif()
+
+
+# Basic configurations
+ SET(INSTALL_CMOD share/lua/cmod CACHE PATH "Directory to install Lua binary modules (configure lua via LUA_CPATH)")
+# / configs
+
+# Find zlib
+ FIND_PACKAGE(ZLIB REQUIRED)
+# / Find zlib
+
+# Define how to build zlib.so:
+ INCLUDE_DIRECTORIES(${ZLIB_INCLUDE_DIRS} ${LUA_INCLUDE_DIR})
+ ADD_LIBRARY(cmod_zlib MODULE
+ lua_zlib.c zlib.def)
+ SET_TARGET_PROPERTIES(cmod_zlib PROPERTIES PREFIX "")
+ SET_TARGET_PROPERTIES(cmod_zlib PROPERTIES OUTPUT_NAME zlib)
+ TARGET_LINK_LIBRARIES(cmod_zlib ${ZLIB_LIBRARIES})
+# / build zlib.so
+
+# Define how to test zlib.so:
+ INCLUDE(CTest)
+ SET(LUA_BIN "lua${LUA_VERSION_MAJOR}.${LUA_VERSION_MINOR}")
+ FIND_PROGRAM(LUA NAMES ${LUA_BIN} lua luajit lua.bat)
+ ADD_TEST(basic ${LUA} ${CMAKE_CURRENT_SOURCE_DIR}/test.lua ${CMAKE_CURRENT_SOURCE_DIR}/ ${CMAKE_CURRENT_BINARY_DIR}/)
+ SET_TESTS_PROPERTIES(basic
+ PROPERTIES
+ FAIL_REGULAR_EXPRESSION
+ "not ok")
+# / test zlib.so
+
+# Where to install stuff
+ INSTALL (TARGETS cmod_zlib DESTINATION ${INSTALL_CMOD})
+# / Where to install.
diff --git a/3rdparty/lua-zlib/Makefile b/3rdparty/lua-zlib/Makefile
new file mode 100644
index 00000000000..801ea0436f2
--- /dev/null
+++ b/3rdparty/lua-zlib/Makefile
@@ -0,0 +1,62 @@
+# This Makefile is based on LuaSec's Makefile. Thanks to the LuaSec developers.
+# Inform the location to intall the modules
+LUAPATH ?= /usr/share/lua/5.1
+LUACPATH ?= /usr/lib/lua/5.1
+INCDIR ?= -I/usr/include/lua5.1
+LIBDIR ?= -L/usr/lib
+
+# For Mac OS X: set the system version
+MACOSX_VERSION = 10.4
+
+CMOD = zlib.so
+OBJS = lua_zlib.o
+
+LIBS = -lz -llua -lm
+WARN = -Wall -pedantic
+
+BSD_CFLAGS = -O2 -fPIC $(WARN) $(INCDIR) $(DEFS)
+BSD_LDFLAGS = -O -shared -fPIC $(LIBDIR)
+
+LNX_CFLAGS = -O2 -fPIC $(WARN) $(INCDIR) $(DEFS)
+LNX_LDFLAGS = -O -shared -fPIC $(LIBDIR)
+
+MAC_ENV = env MACOSX_DEPLOYMENT_TARGET='$(MACVER)'
+MAC_CFLAGS = -O2 -fPIC -fno-common $(WARN) $(INCDIR) $(DEFS)
+MAC_LDFLAGS = -bundle -undefined dynamic_lookup -fPIC $(LIBDIR)
+
+CC = gcc
+LD = $(MYENV) gcc
+CFLAGS = $(MYCFLAGS)
+LDFLAGS = $(MYLDFLAGS)
+
+.PHONY: all clean install none linux bsd macosx
+
+all:
+ @echo "Usage: $(MAKE) <platform>"
+ @echo " * linux"
+ @echo " * bsd"
+ @echo " * macosx"
+
+install: $(CMOD)
+ cp $(CMOD) $(LUACPATH)
+
+uninstall:
+ rm $(LUACPATH)/zlib.so
+
+linux:
+ @$(MAKE) $(CMOD) MYCFLAGS="$(LNX_CFLAGS)" MYLDFLAGS="$(LNX_LDFLAGS)" INCDIR="$(INCDIR)" LIBDIR="$(LIBDIR)" DEFS="$(DEFS)"
+
+bsd:
+ @$(MAKE) $(CMOD) MYCFLAGS="$(BSD_CFLAGS)" MYLDFLAGS="$(BSD_LDFLAGS)" INCDIR="$(INCDIR)" LIBDIR="$(LIBDIR)" DEFS="$(DEFS)"
+
+macosx:
+ @$(MAKE) $(CMOD) MYCFLAGS="$(MAC_CFLAGS)" MYLDFLAGS="$(MAC_LDFLAGS)" MYENV="$(MAC_ENV)" INCDIR="$(INCDIR)" LIBDIR="$(LIBDIR)" DEFS="$(DEFS)"
+
+clean:
+ rm -f $(OBJS) $(CMOD)
+
+.c.o:
+ $(CC) -c $(CFLAGS) $(DEFS) $(INCDIR) -o $@ $<
+
+$(CMOD): $(OBJS)
+ $(LD) $(LDFLAGS) $(LIBDIR) $(OBJS) $(LIBS) -o $@
diff --git a/3rdparty/lua-zlib/README b/3rdparty/lua-zlib/README
new file mode 100644
index 00000000000..8c1ef8d5f8d
--- /dev/null
+++ b/3rdparty/lua-zlib/README
@@ -0,0 +1,151 @@
+**********************************************************************
+* Author : Brian Maher <maherb at brimworks dot com>
+* Library : lua_zlib - Lua 5.1 interface to zlib
+*
+* The MIT License
+*
+* Copyright (c) 2009 Brian Maher
+*
+* Permission is hereby granted, free of charge, to any person obtaining a copy
+* of this software and associated documentation files (the "Software"), to deal
+* in the Software without restriction, including without limitation the rights
+* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+* copies of the Software, and to permit persons to whom the Software is
+* furnished to do so, subject to the following conditions:
+*
+* The above copyright notice and this permission notice shall be included in
+* all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+* THE SOFTWARE.
+**********************************************************************
+
+To use this library, you need zlib, get it here:
+ http://www.gzip.org/zlib/
+
+To build this library, you can use CMake and get it here:
+ http://www.cmake.org/cmake/resources/software.html
+
+...or you can use GNU Make.
+ make <platform>
+
+Loading the library:
+
+ If you built the library as a loadable package
+ [local] zlib = require 'zlib'
+
+ If you compiled the package statically into your application, call
+ the function "luaopen_zlib(L)". It will create a table with the zlib
+ functions and leave it on the stack.
+
+-- zlib functions --
+
+int major, int minor, int patch = zlib.version()
+
+ returns numeric zlib version for the major, minor, and patch
+ levels of the version dynamically linked in.
+
+function stream = zlib.deflate([ int compression_level ], [ int window_size ])
+
+ If no compression_level is provided uses Z_DEFAULT_COMPRESSION (6),
+ compression level is a number from 1-9 where zlib.BEST_SPEED is 1
+ and zlib.BEST_COMPRESSION is 9.
+
+ Returns a "stream" function that compresses (or deflates) all
+ strings passed in. Specifically, use it as such:
+
+ string deflated, bool eof, int bytes_in, int bytes_out =
+ stream(string input [, 'sync' | 'full' | 'finish'])
+
+ Takes input and deflates and returns a portion of it,
+ optionally forcing a flush.
+
+ A 'sync' flush will force all pending output to be flushed to
+ the return value and the output is aligned on a byte boundary,
+ so that the decompressor can get all input data available so
+ far. Flushing may degrade compression for some compression
+ algorithms and so it should be used only when necessary.
+
+ A 'full' flush will flush all output as with 'sync', and the
+ compression state is reset so that decompression can restart
+ from this point if previous compressed data has been damaged
+ or if random access is desired. Using Z_FULL_FLUSH too often
+ can seriously degrade the compression.
+
+ A 'finish' flush will force all pending output to be processed
+ and results in the stream become unusable. Any future
+ attempts to print anything other than the empty string will
+ result in an error that begins with IllegalState.
+
+ The eof result is true if 'finish' was specified, otherwise
+ it is false.
+
+ The bytes_in is how many bytes of input have been passed to
+ stream, and bytes_out is the number of bytes returned in
+ deflated string chunks.
+
+function stream = zlib.inflate([int windowBits])
+
+ Returns a "stream" function that decompresses (or inflates) all
+ strings passed in. Optionally specify a windowBits argument
+ that is passed to inflateInit2(), see zlib.h for details about
+ this argument. By default, gzip header detection is done, and
+ the max window size is used.
+
+ The "stream" function should be used as such:
+
+ string inflated, bool eof, int bytes_in, int bytes_out =
+ stream(string input)
+
+ Takes input and inflates and returns a portion of it. If it
+ detects the end of a deflation stream, then total will be the
+ total number of bytes read from input and all future calls to
+ stream() with a non empty string will result in an error that
+ begins with IllegalState.
+
+ No flush options are provided since the maximal amount of
+ input is always processed.
+
+ eof will be true when the input string is determined to be at
+ the "end of the file".
+
+ The bytes_in is how many bytes of input have been passed to
+ stream, and bytes_out is the number of bytes returned in
+ inflated string chunks.
+
+
+function compute_checksum = zlib.adler32()
+function compute_checksum = zlib.crc32()
+
+ Create a new checksum computation function using either the
+ adler32 or crc32 algorithms. This resulting function should be
+ used as such:
+
+ int checksum = compute_checksum(string input |
+ function compute_checksum)
+
+ The compute_checksum function takes as input either a string
+ that is logically getting appended to or another
+ compute_checksum function that is logically getting appended.
+ The result is the updated checksum.
+
+ For example, these uses will all result in the same checksum:
+
+ -- All in one call:
+ local csum = zlib.crc32()("one two")
+
+ -- Multiple calls:
+ local compute = zlib.crc32()
+ compute("one")
+ assert(csum == compute(" two"))
+
+ -- Multiple compute_checksums joined:
+ local compute1, compute2 = zlib.crc32(), zlib.crc32()
+ compute1("one")
+ compute2(" two")
+ assert(csum == compute1(compute2))
diff --git a/3rdparty/lua-zlib/amnon_david.gz b/3rdparty/lua-zlib/amnon_david.gz
new file mode 100644
index 00000000000..c56de231d1a
--- /dev/null
+++ b/3rdparty/lua-zlib/amnon_david.gz
Binary files differ
diff --git a/3rdparty/lua-zlib/cmake/Modules/FindLuaJIT.cmake b/3rdparty/lua-zlib/cmake/Modules/FindLuaJIT.cmake
new file mode 100644
index 00000000000..e626a5a1d94
--- /dev/null
+++ b/3rdparty/lua-zlib/cmake/Modules/FindLuaJIT.cmake
@@ -0,0 +1,63 @@
+# Locate LuaJIT library
+# This module defines
+# LUAJIT_FOUND, if false, do not try to link to Lua
+# LUA_LIBRARIES
+# LUA_INCLUDE_DIR, where to find lua.h
+# LUAJIT_VERSION_STRING, the version of Lua found (since CMake 2.8.8)
+
+## Copied from default CMake FindLua51.cmake
+
+find_path(LUA_INCLUDE_DIR luajit.h
+ HINTS
+ ENV LUA_DIR
+ PATH_SUFFIXES include/luajit-2.0 include
+ PATHS
+ ~/Library/Frameworks
+ /Library/Frameworks
+ /sw # Fink
+ /opt/local # DarwinPorts
+ /opt/csw # Blastwave
+ /opt
+)
+
+find_library(LUA_LIBRARY
+ NAMES luajit-5.1
+ HINTS
+ ENV LUA_DIR
+ PATH_SUFFIXES lib
+ PATHS
+ ~/Library/Frameworks
+ /Library/Frameworks
+ /sw
+ /opt/local
+ /opt/csw
+ /opt
+)
+
+if(LUA_LIBRARY)
+ # include the math library for Unix
+ if(UNIX AND NOT APPLE)
+ find_library(LUA_MATH_LIBRARY m)
+ set( LUA_LIBRARIES "${LUA_LIBRARY};${LUA_MATH_LIBRARY}" CACHE STRING "Lua Libraries")
+ # For Windows and Mac, don't need to explicitly include the math library
+ else()
+ set( LUA_LIBRARIES "${LUA_LIBRARY}" CACHE STRING "Lua Libraries")
+ endif()
+endif()
+
+if(LUA_INCLUDE_DIR AND EXISTS "${LUA_INCLUDE_DIR}/luajit.h")
+ file(STRINGS "${LUA_INCLUDE_DIR}/luajit.h" luajit_version_str REGEX "^#define[ \t]+LUAJIT_VERSION[ \t]+\"LuaJIT .+\"")
+
+ string(REGEX REPLACE "^#define[ \t]+LUAJIT_VERSION[ \t]+\"LuaJIT ([^\"]+)\".*" "\\1" LUAJIT_VERSION_STRING "${luajit_version_str}")
+ unset(luajit_version_str)
+endif()
+
+include(FindPackageHandleStandardArgs)
+# handle the QUIETLY and REQUIRED arguments and set LUA_FOUND to TRUE if
+# all listed variables are TRUE
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(LuaJIT
+ REQUIRED_VARS LUA_LIBRARIES LUA_INCLUDE_DIR
+ VERSION_VAR LUAJIT_VERSION_STRING)
+
+mark_as_advanced(LUA_INCLUDE_DIR LUA_LIBRARIES LUA_LIBRARY LUA_MATH_LIBRARY)
+
diff --git a/3rdparty/lua-zlib/lua_zlib.c b/3rdparty/lua-zlib/lua_zlib.c
new file mode 100644
index 00000000000..b619258c75f
--- /dev/null
+++ b/3rdparty/lua-zlib/lua_zlib.c
@@ -0,0 +1,401 @@
+#include <ctype.h>
+#include <lauxlib.h>
+#include <lua.h>
+#include <stdlib.h>
+#include <string.h>
+#include <zlib.h>
+
+/*
+ * ** compatibility with Lua 5.2
+ * */
+#if (LUA_VERSION_NUM >= 502)
+#undef luaL_register
+#define luaL_register(L,n,f) \
+ { if ((n) == NULL) luaL_setfuncs(L,f,0); else luaL_newlib(L,f); }
+
+#endif
+
+#if (LUA_VERSION_NUM >= 503)
+#undef luaL_optint
+#define luaL_optint(L,n,d) ((int)luaL_optinteger(L,(n),(d)))
+#endif
+
+#define DEF_MEM_LEVEL 8
+
+typedef uLong (*checksum_t) (uLong crc, const Bytef *buf, uInt len);
+typedef uLong (*checksum_combine_t)(uLong crc1, uLong crc2, z_off_t len2);
+
+
+static int lz_deflate(lua_State *L);
+static int lz_deflate_delete(lua_State *L);
+static int lz_inflate_delete(lua_State *L);
+static int lz_inflate(lua_State *L);
+static int lz_checksum(lua_State *L);
+static int lz_checksum_new(lua_State *L, checksum_t checksum, checksum_combine_t combine);
+static int lz_adler32(lua_State *L);
+static int lz_crc32(lua_State *L);
+
+static int lz_version(lua_State *L) {
+ const char* version = zlibVersion();
+ int count = strlen(version) + 1;
+ char* cur = (char*)memcpy(lua_newuserdata(L, count),
+ version, count);
+
+ count = 0;
+ while ( *cur ) {
+ char* begin = cur;
+ /* Find all digits: */
+ while ( isdigit(*cur) ) cur++;
+ if ( begin != cur ) {
+ int is_end = *cur == '\0';
+ *cur = '\0';
+ lua_pushnumber(L, atoi(begin));
+ count++;
+ if ( is_end ) break;
+ cur++;
+ }
+ while ( *cur && ! isdigit(*cur) ) cur++;
+ }
+
+ return count;
+}
+
+static int lz_assert(lua_State *L, int result, const z_stream* stream, const char* file, int line) {
+ /* Both of these are "normal" return codes: */
+ if ( result == Z_OK || result == Z_STREAM_END ) return result;
+ switch ( result ) {
+ case Z_NEED_DICT:
+ lua_pushfstring(L, "RequiresDictionary: input stream requires a dictionary to be deflated (%s) at %s line %d",
+ stream->msg, file, line);
+ break;
+ case Z_STREAM_ERROR:
+ lua_pushfstring(L, "InternalError: inconsistent internal zlib stream (%s) at %s line %d",
+ stream->msg, file, line);
+ break;
+ case Z_DATA_ERROR:
+ lua_pushfstring(L, "InvalidInput: input string does not conform to zlib format or checksum failed at %s line %d",
+ file, line);
+ break;
+ case Z_MEM_ERROR:
+ lua_pushfstring(L, "OutOfMemory: not enough memory (%s) at %s line %d",
+ stream->msg, file, line);
+ break;
+ case Z_BUF_ERROR:
+ lua_pushfstring(L, "InternalError: no progress possible (%s) at %s line %d",
+ stream->msg, file, line);
+ break;
+ case Z_VERSION_ERROR:
+ lua_pushfstring(L, "IncompatibleLibrary: built with version %s, but dynamically linked with version %s (%s) at %s line %d",
+ ZLIB_VERSION, zlibVersion(), stream->msg, file, line);
+ break;
+ default:
+ lua_pushfstring(L, "ZLibError: unknown code %d (%s) at %s line %d",
+ result, stream->msg, file, line);
+ }
+ lua_error(L);
+ return result;
+}
+
+/**
+ * @upvalue z_stream - Memory for the z_stream.
+ * @upvalue remainder - Any remainder from the last deflate call.
+ *
+ * @param string - "print" to deflate stream.
+ * @param int - flush output buffer? Z_SYNC_FLUSH, Z_FULL_FLUSH, or Z_FINISH.
+ *
+ * if no params, terminates the stream (as if we got empty string and Z_FINISH).
+ */
+static int lz_filter_impl(lua_State *L, int (*filter)(z_streamp, int), int (*end)(z_streamp), const char* name) {
+ int flush = Z_NO_FLUSH, result;
+ z_stream* stream;
+ luaL_Buffer buff;
+ size_t avail_in;
+
+ if ( filter == deflate ) {
+ const char *const opts[] = { "none", "sync", "full", "finish", NULL };
+ flush = luaL_checkoption(L, 2, opts[0], opts);
+ if ( flush ) flush++;
+ /* Z_NO_FLUSH(0) Z_SYNC_FLUSH(2), Z_FULL_FLUSH(3), Z_FINISH (4) */
+
+ /* No arguments or nil, we are terminating the stream: */
+ if ( lua_gettop(L) == 0 || lua_isnil(L, 1) ) {
+ flush = Z_FINISH;
+ }
+ }
+
+ stream = (z_stream*)lua_touserdata(L, lua_upvalueindex(1));
+ if ( stream == NULL ) {
+ if ( lua_gettop(L) >= 1 && lua_isstring(L, 1) ) {
+ lua_pushfstring(L, "IllegalState: calling %s function when stream was previously closed", name);
+ lua_error(L);
+ }
+ lua_pushstring(L, "");
+ lua_pushboolean(L, 1);
+ return 2; /* Ignore duplicate calls to "close". */
+ }
+
+ luaL_buffinit(L, &buff);
+
+ if ( lua_gettop(L) > 1 ) lua_pushvalue(L, 1);
+
+ if ( lua_isstring(L, lua_upvalueindex(2)) ) {
+ lua_pushvalue(L, lua_upvalueindex(2));
+ if ( lua_gettop(L) > 1 && lua_isstring(L, -2) ) {
+ lua_concat(L, 2);
+ }
+ }
+
+ /* Do the actual deflate'ing: */
+ if (lua_gettop(L) > 0) {
+ stream->next_in = (unsigned char*)lua_tolstring(L, -1, &avail_in);
+ } else {
+ stream->next_in = NULL;
+ avail_in = 0;
+ }
+ stream->avail_in = avail_in;
+
+ if ( ! stream->avail_in && ! flush ) {
+ /* Passed empty string, make it a noop instead of erroring out. */
+ lua_pushstring(L, "");
+ lua_pushboolean(L, 0);
+ lua_pushinteger(L, stream->total_in);
+ lua_pushinteger(L, stream->total_out);
+ return 4;
+ }
+
+ do {
+ stream->next_out = (unsigned char*)luaL_prepbuffer(&buff);
+ stream->avail_out = LUAL_BUFFERSIZE;
+ result = filter(stream, flush);
+ if ( Z_BUF_ERROR != result ) {
+ /* Ignore Z_BUF_ERROR since that just indicates that we
+ * need a larger buffer in order to proceed. Thanks to
+ * Tobias Markmann for finding this bug!
+ */
+ lz_assert(L, result, stream, __FILE__, __LINE__);
+ }
+ luaL_addsize(&buff, LUAL_BUFFERSIZE - stream->avail_out);
+ } while ( stream->avail_out == 0 );
+
+ /* Need to do this before we alter the stack: */
+ luaL_pushresult(&buff);
+
+ /* Save remainder in lua_upvalueindex(2): */
+ if ( NULL != stream->next_in ) {
+ lua_pushlstring(L, (char*)stream->next_in, stream->avail_in);
+ lua_replace(L, lua_upvalueindex(2));
+ }
+
+ /* "close" the stream/remove finalizer: */
+ if ( result == Z_STREAM_END ) {
+ /* Clear-out the metatable so end is not called twice: */
+ lua_pushnil(L);
+ lua_setmetatable(L, lua_upvalueindex(1));
+
+ /* nil the upvalue: */
+ lua_pushnil(L);
+ lua_replace(L, lua_upvalueindex(1));
+
+ /* Close the stream: */
+ lz_assert(L, end(stream), stream, __FILE__, __LINE__);
+
+ lua_pushboolean(L, 1);
+ } else {
+ lua_pushboolean(L, 0);
+ }
+ lua_pushinteger(L, stream->total_in);
+ lua_pushinteger(L, stream->total_out);
+ return 4;
+}
+
+static void lz_create_deflate_mt(lua_State *L) {
+ luaL_newmetatable(L, "lz.deflate.meta"); /* {} */
+
+ lua_pushcfunction(L, lz_deflate_delete);
+ lua_setfield(L, -2, "__gc");
+
+ lua_pop(L, 1); /* <empty> */
+}
+
+static int lz_deflate_new(lua_State *L) {
+ int level = luaL_optint(L, 1, Z_DEFAULT_COMPRESSION);
+ int window_size = luaL_optint(L, 2, MAX_WBITS);
+
+ /* Allocate the stream: */
+ z_stream* stream = (z_stream*)lua_newuserdata(L, sizeof(z_stream));
+
+ stream->zalloc = Z_NULL;
+ stream->zfree = Z_NULL;
+
+ int result = deflateInit2(stream, level, Z_DEFLATED, window_size,
+ DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY);
+
+ lz_assert(L, result, stream, __FILE__, __LINE__);
+
+ /* Don't allow destructor to execute unless deflateInit2 was successful: */
+ luaL_getmetatable(L, "lz.deflate.meta");
+ lua_setmetatable(L, -2);
+
+ lua_pushnil(L);
+ lua_pushcclosure(L, lz_deflate, 2);
+ return 1;
+}
+
+static int lz_deflate(lua_State *L) {
+ return lz_filter_impl(L, deflate, deflateEnd, "deflate");
+}
+
+static int lz_deflate_delete(lua_State *L) {
+ z_stream* stream = (z_stream*)lua_touserdata(L, 1);
+
+ /* Ignore errors. */
+ deflateEnd(stream);
+
+ return 0;
+}
+
+
+static void lz_create_inflate_mt(lua_State *L) {
+ luaL_newmetatable(L, "lz.inflate.meta"); /* {} */
+
+ lua_pushcfunction(L, lz_inflate_delete);
+ lua_setfield(L, -2, "__gc");
+
+ lua_pop(L, 1); /* <empty> */
+}
+
+static int lz_inflate_new(lua_State *L) {
+ /* Allocate the stream */
+ z_stream* stream = (z_stream*)lua_newuserdata(L, sizeof(z_stream));
+
+ /* By default, we will do gzip header detection w/ max window size */
+ int window_size = lua_isnumber(L, 1) ? lua_tointeger(L, 1) : MAX_WBITS + 32;
+
+ stream->zalloc = Z_NULL;
+ stream->zfree = Z_NULL;
+ stream->next_in = Z_NULL;
+ stream->avail_in = 0;
+
+ lz_assert(L, inflateInit2(stream, window_size), stream, __FILE__, __LINE__);
+
+ /* Don't allow destructor to execute unless deflateInit was successful: */
+ luaL_getmetatable(L, "lz.inflate.meta");
+ lua_setmetatable(L, -2);
+
+ lua_pushnil(L);
+ lua_pushcclosure(L, lz_inflate, 2);
+ return 1;
+}
+
+static int lz_inflate(lua_State *L) {
+ return lz_filter_impl(L, inflate, inflateEnd, "inflate");
+}
+
+static int lz_inflate_delete(lua_State *L) {
+ z_stream* stream = (z_stream*)lua_touserdata(L, 1);
+
+ /* Ignore errors: */
+ inflateEnd(stream);
+
+ return 0;
+}
+
+static int lz_checksum(lua_State *L) {
+ if ( lua_gettop(L) <= 0 ) {
+ lua_pushvalue(L, lua_upvalueindex(3));
+ lua_pushvalue(L, lua_upvalueindex(4));
+ } else if ( lua_isfunction(L, 1) ) {
+ checksum_combine_t combine = (checksum_combine_t)
+ lua_touserdata(L, lua_upvalueindex(2));
+
+ lua_pushvalue(L, 1);
+ lua_call(L, 0, 2);
+ if ( ! lua_isnumber(L, -2) || ! lua_isnumber(L, -1) ) {
+ luaL_argerror(L, 1, "expected function to return two numbers");
+ }
+
+ /* Calculate and replace the checksum */
+ lua_pushnumber(L,
+ combine(lua_tonumber(L, lua_upvalueindex(3)),
+ lua_tonumber(L, -2),
+ lua_tonumber(L, -1)));
+ lua_pushvalue(L, -1);
+ lua_replace(L, lua_upvalueindex(3));
+
+ /* Calculate and replace the length */
+ lua_pushnumber(L,
+ lua_tonumber(L, lua_upvalueindex(4)) + lua_tonumber(L, -2));
+ lua_pushvalue(L, -1);
+ lua_replace(L, lua_upvalueindex(4));
+ } else {
+ const Bytef* str;
+ size_t len;
+
+ checksum_t checksum = (checksum_t)
+ lua_touserdata(L, lua_upvalueindex(1));
+ str = (const Bytef*)luaL_checklstring(L, 1, &len);
+
+ /* Calculate and replace the checksum */
+ lua_pushnumber(L,
+ checksum(lua_tonumber(L, lua_upvalueindex(3)),
+ str,
+ len));
+ lua_pushvalue(L, -1);
+ lua_replace(L, lua_upvalueindex(3));
+
+ /* Calculate and replace the length */
+ lua_pushnumber(L,
+ lua_tonumber(L, lua_upvalueindex(4)) + len);
+ lua_pushvalue(L, -1);
+ lua_replace(L, lua_upvalueindex(4));
+ }
+ return 2;
+}
+
+static int lz_checksum_new(lua_State *L, checksum_t checksum, checksum_combine_t combine) {
+ lua_pushlightuserdata(L, checksum);
+ lua_pushlightuserdata(L, combine);
+ lua_pushnumber(L, checksum(0L, Z_NULL, 0));
+ lua_pushnumber(L, 0);
+ lua_pushcclosure(L, lz_checksum, 4);
+ return 1;
+}
+
+static int lz_adler32(lua_State *L) {
+ return lz_checksum_new(L, adler32, adler32_combine);
+}
+
+static int lz_crc32(lua_State *L) {
+ return lz_checksum_new(L, crc32, crc32_combine);
+}
+
+static const luaL_Reg zlib_functions[] = {
+ { "deflate", lz_deflate_new },
+ { "inflate", lz_inflate_new },
+ { "adler32", lz_adler32 },
+ { "crc32", lz_crc32 },
+ { "version", lz_version },
+ { NULL, NULL }
+};
+
+#define SETLITERAL(n,v) (lua_pushliteral(L, n), lua_pushliteral(L, v), lua_settable(L, -3))
+#define SETINT(n,v) (lua_pushliteral(L, n), lua_pushinteger(L, v), lua_settable(L, -3))
+
+LUALIB_API int luaopen_zlib(lua_State * const L) {
+ lz_create_deflate_mt(L);
+ lz_create_inflate_mt(L);
+
+ luaL_register(L, "zlib", zlib_functions);
+
+ SETINT("BEST_SPEED", Z_BEST_SPEED);
+ SETINT("BEST_COMPRESSION", Z_BEST_COMPRESSION);
+
+ SETLITERAL("_COPYRIGHT", "Copyright (c) 2009-2010 Brian Maher");
+ SETLITERAL("_DESCRIPTION", "Yet another binding to the zlib library");
+ SETLITERAL("_VERSION", "lua-zlib $Id$ $Format:%d$");
+
+ /* Expose this to lua so we can do a test: */
+ SETINT("_TEST_BUFSIZ", LUAL_BUFFERSIZE);
+
+ return 1;
+}
diff --git a/3rdparty/lua-zlib/rockspec b/3rdparty/lua-zlib/rockspec
new file mode 100644
index 00000000000..d248bc099ed
--- /dev/null
+++ b/3rdparty/lua-zlib/rockspec
@@ -0,0 +1,35 @@
+package = "lua-zlib"
+version = "0.3-1"
+source = {
+ url = "git://github.com/brimworks/lua-zlib.git",
+ tag = "v0.4",
+}
+description = {
+ summary = "Simple streaming interface to zlib for Lua.",
+ detailed = [[
+ Simple streaming interface to zlib for Lua.
+ Consists of two functions: inflate and deflate.
+ Both functions return "stream functions" (takes a buffer of input and returns a buffer of output).
+ This project is hosted on github.
+ ]],
+ homepage = "https://github.com/brimworks/lua-zlib",
+ license = "MIT"
+}
+dependencies = {
+ "lua >= 5.1, < 5.3"
+}
+external_dependencies = {
+ ZLIB = {
+ header = "zlib.h"
+ }
+}
+
+build = {
+ type = "builtin",
+ modules = {
+ zlib = {
+ sources = { "lua_zlib.c" };
+ libraries = { "z" },
+ };
+ }
+}
diff --git a/3rdparty/lua-zlib/tap.lua b/3rdparty/lua-zlib/tap.lua
new file mode 100644
index 00000000000..05266a9c997
--- /dev/null
+++ b/3rdparty/lua-zlib/tap.lua
@@ -0,0 +1,24 @@
+local tap_module = {}
+
+local os = require("os")
+
+local counter = 1
+local failed = false
+
+function tap_module.ok(assert_true, desc)
+ local msg = ( assert_true and "ok " or "not ok " ) .. counter
+ if ( not assert_true ) then
+ failed = true
+ end
+ if ( desc ) then
+ msg = msg .. " - " .. desc
+ end
+ print(msg)
+ counter = counter + 1
+end
+
+function tap_module.exit()
+ os.exit(failed and 1 or 0)
+end
+
+return tap_module
diff --git a/3rdparty/lua-zlib/test.lua b/3rdparty/lua-zlib/test.lua
new file mode 100644
index 00000000000..d64e1835506
--- /dev/null
+++ b/3rdparty/lua-zlib/test.lua
@@ -0,0 +1,198 @@
+print "1..9"
+
+local src_dir, build_dir = ...
+package.path = (src_dir or "./") .. "?.lua;" .. package.path
+package.cpath = (build_dir or "./") .. "?.so;" .. package.cpath
+
+local tap = require("tap")
+local lz = require("zlib")
+local ok = tap.ok
+local table = require("table")
+local io = require("io")
+
+function main()
+ test_stats()
+ test_buff_err()
+ test_small_inputs()
+ test_basic()
+ test_large()
+ test_no_input()
+ test_invalid_input()
+ test_streaming()
+ test_illegal_state()
+ test_checksum()
+ test_version()
+ test_tom_macwright()
+ test_amnon_david()
+end
+
+function test_tom_macwright()
+ local deflated =
+ assert(io.open(src_dir.. "/tom_macwright.gz")):read("*a")
+
+ local inflated = lz.inflate()(deflated)
+
+ local expected_inflated =
+ assert(io.open(src_dir.. "/tom_macwright.out")):read("*a")
+
+ ok(expected_inflated == inflated, "Tom MacWright Test")
+end
+
+function test_amnon_david()
+ local body = assert(io.open(src_dir.."/amnon_david.gz")):read("*a")
+
+ local inflate = lz.inflate()
+ local inflated, eof, bytes_in, bytes_out = inflate(body)
+
+ local deflate = lz.deflate()
+ local deflated, eof, bytes_in, bytes_out = deflate(inflated, "full")
+end
+
+function test_stats()
+ local string = ("one"):rep(20)
+ local deflated, eof, bin, bout = lz.deflate()(string, 'finish')
+ ok(eof == true, "eof is true (" .. tostring(eof) .. ")");
+ ok(bin > bout, "bytes in is greater than bytes out?")
+ ok(#deflated == bout, "bytes out is the same size as deflated string length")
+ ok(#string == bin, "bytes in is the same size as the input string length")
+end
+
+-- Thanks to Tobias Markmann for the bug report! We are trying to
+-- force inflate() to return a Z_BUF_ERROR (which should be recovered
+-- from). For some reason this only happens when the input is exactly
+-- LUAL_BUFFERSIZE (at least on my machine).
+function test_buff_err()
+ local text = ("X"):rep(lz._TEST_BUFSIZ);
+
+ local deflated = lz.deflate()(text, 'finish')
+
+ for i=1,#deflated do
+ lz.inflate()(deflated:sub(1,i))
+ end
+end
+
+function test_small_inputs()
+ local text = ("X"):rep(lz._TEST_BUFSIZ);
+
+ local deflated = lz.deflate()(text, 'finish')
+
+ local inflated = {}
+ local inflator = lz.inflate()
+ for i=1,#deflated do
+ local part = inflator(deflated:sub(i,i))
+ table.insert(inflated, part)
+ end
+ inflated = table.concat(inflated)
+ ok(inflated == text, "Expected " .. #text .. " Xs got " .. #inflated)
+end
+
+function test_basic()
+ local test_string = "abcdefghijklmnopqrstuv"
+
+ ok(lz.inflate()(lz.deflate()(), "finish") == "")
+
+ -- Input to deflate is same as output to inflate:
+ local deflated = lz.deflate()(test_string, "finish")
+ local inflated = lz.inflate()(deflated, "finish")
+
+ ok(test_string == inflated, "'" .. tostring(test_string) .. "' == '" .. tostring(inflated) .. "'")
+end
+
+function test_large()
+ -- Try a larger string:
+ local numbers = ""
+ for i=1, 100 do numbers = numbers .. string.format("%3d", i) end
+ local numbers_table = {}
+ for i=1, 10000 do numbers_table[i] = numbers end
+ local test_string = table.concat(numbers_table, "\n")
+
+ local deflated = lz.deflate()(test_string, "finish")
+ local inflated = lz.inflate()(deflated, "finish")
+ ok(test_string == inflated, "large string")
+end
+
+function test_no_input()
+ local stream = lz.deflate()
+ local deflated = stream("")
+ deflated = deflated .. stream("")
+ deflated = deflated .. stream(nil, "finish")
+ ok("" == lz.inflate()(deflated, "finish"), "empty string")
+end
+
+function test_invalid_input()
+ local stream = lz.inflate()
+ local isok, err = pcall(
+ function()
+ stream("bad input")
+ end)
+ ok(not isok)
+ ok(string.find(err, "^InvalidInput"),
+ string.format("InvalidInput error (%s)", err))
+end
+
+function test_streaming()
+ local shrink = lz.deflate(lz.BEST_COMPRESSION)
+ local enlarge = lz.inflate()
+ local expected = {}
+ local got = {}
+ local chant = "Isn't He great, isn't He wonderful?\n"
+ for i=1,100 do
+ if ( i == 100 ) then
+ chant = nil
+ print "EOF round"
+ end
+ local shrink_part, shrink_eof = shrink(chant)
+ local enlarge_part, enlarge_eof = enlarge(shrink_part)
+ if ( i == 100 ) then
+ if not shrink_eof then error("expected eof after shrinking flush") end
+ if not enlarge_eof then error("expected eof after enlarging") end
+ else
+ if shrink_eof then error("unexpected eof after shrinking") end
+ if enlarge_eof then error("unexpected eof after enlarging") end
+ end
+ if enlarge_part then table.insert(got, enlarge_part) end
+ if chant then table.insert(expected, chant) end
+ end
+ ok(table.concat(got) == table.concat(expected), "streaming works")
+end
+
+function test_illegal_state()
+ local stream = lz.deflate()
+ stream("abc")
+ stream() -- eof/close
+
+ local _, emsg = pcall(
+ function()
+ stream("printing on 'closed' handle")
+ end)
+ ok(string.find(emsg, "^IllegalState"),
+ string.format("IllegalState error (%s)", emsg))
+
+ local enlarge = lz.inflate()
+end
+
+function test_checksum()
+ for _, factory in pairs{lz.crc32, lz.adler32} do
+ local csum = factory()("one two")
+
+ -- Multiple calls:
+ local compute = factory()
+ compute("one")
+ assert(csum == compute(" two"))
+
+ -- Multiple compute_checksums joined:
+ local compute1, compute2 = factory(), factory()
+ compute1("one")
+ compute2(" two")
+ assert(csum == compute1(compute2))
+ end
+end
+
+function test_version()
+ local major, minor, patch = lz.version()
+ ok(1 == major, "major version 1 == " .. major);
+ ok(type(minor) == "number", "minor version is number (" .. minor .. ")")
+ ok(type(patch) == "number", "patch version is number (" .. patch .. ")")
+end
+
+main()
diff --git a/3rdparty/lua-zlib/tom_macwright.gz b/3rdparty/lua-zlib/tom_macwright.gz
new file mode 100644
index 00000000000..bb9060b2535
--- /dev/null
+++ b/3rdparty/lua-zlib/tom_macwright.gz
@@ -0,0 +1,4 @@
+x[
+0E*fIg(NL#m[\scy*=&N:'I1Yi[pzU
+R?0JzQꁭ%Iw
+cǩ)˘lbgФ!ሌv򧮮K EF}H \ No newline at end of file
diff --git a/3rdparty/lua-zlib/tom_macwright.out b/3rdparty/lua-zlib/tom_macwright.out
new file mode 100644
index 00000000000..ca88bcb6c2d
--- /dev/null
+++ b/3rdparty/lua-zlib/tom_macwright.out
Binary files differ
diff --git a/3rdparty/lua-zlib/zlib.def b/3rdparty/lua-zlib/zlib.def
new file mode 100644
index 00000000000..d6c5a916b64
--- /dev/null
+++ b/3rdparty/lua-zlib/zlib.def
@@ -0,0 +1,2 @@
+EXPORTS
+luaopen_zlib