pax_global_header00006660000000000000000000000064122461356510014517gustar00rootroot0000000000000052 comment=89dde617715ae07b91cf420d9e95b47662c48c4f lua-zlib-0.2+git+1+9622739/000077500000000000000000000000001224613565100146535ustar00rootroot00000000000000lua-zlib-0.2+git+1+9622739/CMakeLists.txt000066400000000000000000000035271224613565100174220ustar00rootroot00000000000000# 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) version 5.1 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(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(Lua51 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) FIND_PROGRAM(LUA NAMES 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. lua-zlib-0.2+git+1+9622739/Makefile000066400000000000000000000031051224613565100163120ustar00rootroot00000000000000# 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) " @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 $@ lua-zlib-0.2+git+1+9622739/README000066400000000000000000000140331224613565100155340ustar00rootroot00000000000000********************************************************************** * Author : Brian Maher * 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 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)) lua-zlib-0.2+git+1+9622739/amnon_david.gz000066400000000000000000000001011224613565100174640ustar00rootroot00000000000000(ͱIOHWU(,VD=.}>D9Լ7lua-zlib-0.2+git+1+9622739/cmake/000077500000000000000000000000001224613565100157335ustar00rootroot00000000000000lua-zlib-0.2+git+1+9622739/cmake/Modules/000077500000000000000000000000001224613565100173435ustar00rootroot00000000000000lua-zlib-0.2+git+1+9622739/cmake/Modules/FindLuaJIT.cmake000066400000000000000000000034431224613565100222420ustar00rootroot00000000000000# 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) lua-zlib-0.2+git+1+9622739/lua_zlib.c000066400000000000000000000306771224613565100166350ustar00rootroot00000000000000#include #include #include #include #include #include /* * ** 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 #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), 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); /* */ } 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); /* */ } 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((uLong)lua_tonumber(L, lua_upvalueindex(3)), (uLong)lua_tonumber(L, -2), (z_off_t)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((uLong)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; } lua-zlib-0.2+git+1+9622739/tap.lua000066400000000000000000000006221224613565100161420ustar00rootroot00000000000000local os = require("os") module(..., package.seeall) local counter = 1 local failed = false function 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 exit() os.exit(failed and 1 or 0) endlua-zlib-0.2+git+1+9622739/test.lua000066400000000000000000000133721224613565100163430ustar00rootroot00000000000000print "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() lua-zlib-0.2+git+1+9622739/tom_macwright.gz000066400000000000000000000002501224613565100200560ustar00rootroot00000000000000x[ 0E*fIg(NL#m[\scy*=&N:'I1Yi[pzU R?0JzQꁭ%Iw cǩ)˘lbgФ!ሌv򧮮K EF}Hlua-zlib-0.2+git+1+9622739/tom_macwright.out000066400000000000000000000003651224613565100202540ustar00rootroot00000000000000commit 234tree b0d387e58ba8f97e64e43e440d6e226a454cc60c parent 7457837869dbf40e91719b5801301f465867d1c3 author Tom MacWright 1313704231 -0400 committer Tom MacWright 1313704231 -0400 And those ones. lua-zlib-0.2+git+1+9622739/zlib.def000066400000000000000000000000251224613565100162700ustar00rootroot00000000000000EXPORTS luaopen_zlib