diff options
Diffstat (limited to '3rdparty/lua-zlib')
-rw-r--r-- | 3rdparty/lua-zlib/.gitattributes | 1 | ||||
-rw-r--r-- | 3rdparty/lua-zlib/CMakeLists.txt | 62 | ||||
-rw-r--r-- | 3rdparty/lua-zlib/Makefile | 62 | ||||
-rw-r--r-- | 3rdparty/lua-zlib/README | 151 | ||||
-rw-r--r-- | 3rdparty/lua-zlib/amnon_david.gz | bin | 0 -> 65 bytes | |||
-rw-r--r-- | 3rdparty/lua-zlib/cmake/Modules/FindLuaJIT.cmake | 63 | ||||
-rw-r--r-- | 3rdparty/lua-zlib/lua_zlib.c | 401 | ||||
-rw-r--r-- | 3rdparty/lua-zlib/rockspec | 35 | ||||
-rw-r--r-- | 3rdparty/lua-zlib/tap.lua | 24 | ||||
-rw-r--r-- | 3rdparty/lua-zlib/test.lua | 198 | ||||
-rw-r--r-- | 3rdparty/lua-zlib/tom_macwright.gz | 4 | ||||
-rw-r--r-- | 3rdparty/lua-zlib/tom_macwright.out | bin | 0 -> 245 bytes | |||
-rw-r--r-- | 3rdparty/lua-zlib/zlib.def | 2 |
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 Binary files differnew file mode 100644 index 00000000000..c56de231d1a --- /dev/null +++ b/3rdparty/lua-zlib/amnon_david.gz 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Ф!ሌvK EF}H
\ No newline at end of file diff --git a/3rdparty/lua-zlib/tom_macwright.out b/3rdparty/lua-zlib/tom_macwright.out Binary files differnew file mode 100644 index 00000000000..ca88bcb6c2d --- /dev/null +++ b/3rdparty/lua-zlib/tom_macwright.out 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 |