--- lzma-4.32.4/C/7zip/Compress/LZMA_Alone/comp.cc.sqlzma 2007-12-12 20:23:31.000000000 +0100
+++ lzma-4.32.4/C/7zip/Compress/LZMA_Alone/comp.cc 2007-12-12 20:27:12.000000000 +0100
@@ -0,0 +1,257 @@
+/*
+ * Copyright (C) 2006-2007 Junjiro Okajima
+ * Copyright (C) 2006-2007 Tomas Matejicek, slax.org
+ *
+ * LICENSE follows the described one in lzma.txt.
+ */
+
+/* $Id: comp.cc,v 1.3 2007/11/13 13:27:23 jro Exp $ */
+
+// extract some parts from lzma443/C/7zip/Compress/LZMA_Alone/LzmaAlone.cpp
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <errno.h>
+
+#include "StdAfx.h"
+#include "../../../Common/MyInitGuid.h"
+//#include "../../../Common/MyWindows.h"
+#include "../../../Common/StringConvert.h"
+//#include "../../../Common/StringToInt.h"
+//#include "../../Common/StreamUtils.h"
+#include "../LZMA/LZMAEncoder.h"
+
+#include <pthread.h>
+#include <zlib.h>
+#include "sqlzma.h"
+
+//////////////////////////////////////////////////////////////////////
+
+class CMemoryStream {
+protected:
+ Bytef *m_data;
+ UInt64 m_limit;
+ UInt64 m_pos;
+
+public:
+ CMemoryStream(Bytef *data, UInt64 size)
+ : m_data(data), m_limit(size), m_pos(0) {}
+
+ virtual ~CMemoryStream() {}
+};
+
+class CInMemoryStream : public CMemoryStream, public IInStream,
+ public CMyUnknownImp {
+//protected:
+ CMyComPtr<ISequentialInStream> m_stream;
+
+public:
+ MY_UNKNOWN_IMP1(IInStream);
+
+ CInMemoryStream(Bytef *data, UInt64 size)
+ : CMemoryStream(data, size), m_stream(this) {}
+
+ virtual ~CInMemoryStream() {}
+
+ STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize)
+ {
+ UInt64 room = m_limit - m_pos;
+ if (size > room)
+ size = room;
+ if (size) {
+ memcpy(data, m_data + m_pos, size);
+ m_pos += size;
+ }
+ if (processedSize)
+ *processedSize = size;
+ return S_OK;
+ }
+
+ // disabled all
+ STDMETHOD(Seek)(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition) {
+ assert(0);
+ return E_NOTIMPL;
+ }
+};
+
+class COutMemoryStream : public CMemoryStream, public IOutStream,
+ public CMyUnknownImp {
+//protected:
+ CMyComPtr<ISequentialOutStream> m_stream;
+
+public:
+ MY_UNKNOWN_IMP1(IOutStream);
+
+ COutMemoryStream(Bytef *data, UInt64 size)
+ : CMemoryStream(data, size), m_stream(this) {}
+
+ virtual ~COutMemoryStream() {}
+
+ UInt32 GetSize() {return m_pos;}
+
+ STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize) {
+ if (m_pos + size > m_limit)
+ return -ENOSPC;
+ memcpy(m_data + m_pos, data, size);
+ m_pos += size;
+ if (processedSize)
+ *processedSize = size;
+ return S_OK;
+ }
+
+ // disabled all
+ STDMETHOD(Seek)(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition) {
+ assert(0);
+ return E_NOTIMPL;
+ }
+ STDMETHOD(SetSize)(Int64 newSize) {
+ assert(0);
+ return E_NOTIMPL;
+ }
+};
+
+//////////////////////////////////////////////////////////////////////
+
+static int
+LzmaCompress(Bytef *next_in, uInt avail_in, Bytef *next_out, uInt avail_out,
+ struct sqlzma_opts *opts, uLong *total_out)
+{
+ int err;
+ HRESULT res;
+ const Byte a[] = {
+ avail_in, avail_in >> 8, avail_in >> 16, avail_in >> 24,
+ 0, 0, 0, 0
+ };
+
+ NCompress::NLZMA::CEncoder encoderSpec;
+ CMyComPtr<ICompressCoder> encoder = &encoderSpec;
+ encoder->AddRef();
+ CInMemoryStream inStreamSpec(next_in, avail_in);
+ CMyComPtr<ISequentialInStream> inStream = &inStreamSpec;
+ inStream->AddRef();
+ COutMemoryStream outStreamSpec(next_out, avail_out);
+ CMyComPtr<ISequentialOutStream> outStream = &outStreamSpec;
+ outStream->AddRef();
+
+ // these values are dpending upon is_lzma() macro in sqlzma.h
+ const UInt32 dictionary = opts->dicsize;
+ //fprintf(stderr, "dic %u\n", dictionary);
+ const UString mf = L"BT4";
+ const UInt32 posStateBits = 2;
+ const UInt32 litContextBits = 3; // for normal files
+ // UInt32 litContextBits = 0; // for 32-bit data
+ const UInt32 litPosBits = 0;
+ // UInt32 litPosBits = 2; // for 32-bit data
+ //const UInt32 algorithm = 2;
+ const UInt32 algorithm = 1;
+ const UInt32 numFastBytes = 128;
+ const UInt32 matchFinderCycles = 16 + numFastBytes / 2;
+ //const bool matchFinderCyclesDefined = false;
+ const PROPID propIDs[] = {
+ NCoderPropID::kDictionarySize,
+ NCoderPropID::kPosStateBits,
+ NCoderPropID::kLitContextBits,
+ NCoderPropID::kLitPosBits,
+ NCoderPropID::kAlgorithm,
+ NCoderPropID::kNumFastBytes,
+ NCoderPropID::kMatchFinder,
+ NCoderPropID::kEndMarker,
+ NCoderPropID::kMatchFinderCycles
+ };
+ const int kNumPropsMax = sizeof(propIDs) / sizeof(propIDs[0]);
+ PROPVARIANT properties[kNumPropsMax];
+ for (int p = 0; p < 6; p++)
+ properties[p].vt = VT_UI4;
+ properties[0].ulVal = UInt32(dictionary);
+ properties[1].ulVal = UInt32(posStateBits);
+ properties[2].ulVal = UInt32(litContextBits);
+ properties[3].ulVal = UInt32(litPosBits);
+ properties[4].ulVal = UInt32(algorithm);
+ properties[5].ulVal = UInt32(numFastBytes);
+
+ properties[6].vt = VT_BSTR;
+ properties[6].bstrVal = (BSTR)(const wchar_t *)mf;
+ properties[7].vt = VT_BOOL;
+ properties[7].boolVal = VARIANT_FALSE; // EOS
+ properties[8].vt = VT_UI4;
+ properties[8].ulVal = UInt32(matchFinderCycles);
+
+ err = -EINVAL;
+ res = encoderSpec.SetCoderProperties(propIDs, properties,
+ kNumPropsMax - 1);
+ if (res)
+ goto out;
+ res = encoderSpec.WriteCoderProperties(outStream);
+ if (res)
+ goto out;
+
+ UInt32 r;
+ res = outStream->Write(a, sizeof(a), &r);
+ if (res || r != sizeof(a))
+ goto out;
+
+ err = encoder->Code(inStream, outStream, 0, /*broken*/0, 0);
+ if (err)
+ goto out;
+ *total_out = outStreamSpec.GetSize();
+
+ out:
+ return err;
+}
+
+//////////////////////////////////////////////////////////////////////
+
+#define Failure(p) do { \
+ fprintf(stderr, "%s:%d: please report to jro " \
+ "{%02x, %02x, %02x, %02x, %02x, %02x, %02x, %02x}\n", \
+ __func__, __LINE__, \
+ p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]); \
+ abort(); \
+} while(0)
+
+extern "C" int
+sqlzma_cm(struct sqlzma_opts *opts, z_stream *stream, Bytef *next_in, uInt
+ avail_in, Bytef *next_out, uInt avail_out)
+{
+ int err;
+ Bytef *p = next_out;
+ uInt l = avail_out;
+
+ stream->next_in = next_in;
+ stream->avail_in = avail_in;
+ stream->next_out = p;
+ stream->avail_out = l;
+ err = deflate(stream, Z_FINISH);
+ if (err != Z_STREAM_END && err != Z_OK)
+ goto out_err;
+ if (avail_in < stream->total_out)
+ return err;
+ if (is_lzma(*p))
+ Failure(p);
+
+ if (opts->try_lzma) {
+ unsigned char a[stream->total_out];
+ uLong processed;
+
+ memcpy(a, p, stream->total_out);
+
+ // malloc family in glibc and stdc++ seems to be thread-safe
+ err = LzmaCompress(next_in, avail_in, p, l, opts, &processed);
+ if (!err && processed <= stream->total_out) {
+ if (!is_lzma(*next_out))
+ Failure(next_out);
+ stream->total_out = processed;
+ err = Z_STREAM_END;
+ } else {
+ //puts("by zlib");
+ memcpy(p, a, stream->total_out);
+ err = Z_STREAM_END;
+ }
+ }
+ return err;
+
+ out_err:
+ fprintf(stderr, "%s: ZLIB err %s\n", __func__, zError(err));
+ return err;
+}
--- lzma-4.32.4/C/7zip/Compress/LZMA_Alone/sqlzma.mk.sqlzma 2007-12-12 20:23:31.000000000 +0100
+++ lzma-4.32.4/C/7zip/Compress/LZMA_Alone/sqlzma.mk 2007-12-12 20:23:31.000000000 +0100
@@ -0,0 +1,54 @@
+
+# Copyright (C) 2006 Junjiro Okajima
+# Copyright (C) 2006 Tomas Matejicek, slax.org
+#
+# LICENSE follows the described one in lzma.txt.
+
+# $Id: sqlzma.mk,v 1.23 2006/11/27 03:54:58 jro Exp $
+
+ifndef Sqlzma
+$(error Sqlzma is not defined)
+endif
+
+include makefile.gcc
+
+ifdef UseDebugFlags
+DebugFlags = -Wall -O0 -g -UNDEBUG
+endif
+# -pthread
+CXXFLAGS = ${CFLAGS} -D_REENTRANT -include pthread.h -DNDEBUG ${DebugFlags}
+Tgt = liblzma_r.a
+
+all: ${Tgt}
+
+RObjs = LZMAEncoder_r.o Alloc_r.o LZInWindow_r.o CRC_r.o StreamUtils_r.o \
+ OutBuffer_r.o RangeCoderBit_r.o
+%_r.cc: ../LZMA/%.cpp
+ ln $< $@
+%_r.cc: ../LZ/%.cpp
+ ln $< $@
+%_r.cc: ../RangeCoder/%.cpp
+ ln $< $@
+%_r.cc: ../../Common/%.cpp
+ ln $< $@
+%_r.cc: ../../../Common/%.cpp
+ ln $< $@
+LZMAEncoder_r.o: CXXFLAGS += -I../LZMA
+LZInWindow_r.o: CXXFLAGS += -I../LZ
+RangeCoderBit_r.o: CXXFLAGS += -I../RangeCoder
+OutBuffer_r.o StreamUtils_r.o: CXXFLAGS += -I../../Common
+Alloc_r.o CRC_r.o: CXXFLAGS += -I../../../Common
+
+comp.o: CXXFLAGS += -I${Sqlzma}
+comp.o: comp.cc ${Sqlzma}/sqlzma.h
+
+liblzma_r.a: ${RObjs} comp.o
+ ${AR} cr $@ $^
+
+clean: clean_sqlzma
+clean_sqlzma:
+ $(RM) comp.o *_r.o ${Tgt} *~
+
+# Local variables: ;
+# compile-command: (concat "make Sqlzma=../../../../.. -f " (file-name-nondirectory (buffer-file-name)));
+# End: ;
--- lzma-4.32.4/C/7zip/Compress/LZMA_C/kmod.mk.sqlzma 2007-12-12 20:23:31.000000000 +0100
+++ lzma-4.32.4/C/7zip/Compress/LZMA_C/kmod.mk 2007-12-12 20:23:31.000000000 +0100
@@ -0,0 +1,40 @@
+
+# Copyright (C) 2006-2007 Junjiro Okajima
+# Copyright (C) 2006-2007 Tomas Matejicek, slax.org
+#
+# LICENSE follows the described one in lzma.txt.
+
+# $Id: kmod.mk,v 1.1 2007/11/05 05:43:35 jro Exp $
+
+ifndef Sqlzma
+$(error Sqlzma is not defined)
+endif
+ifndef KDir
+$(error KDir is not defined)
+endif
+
+#include makefile.gcc
+
+Kmod = kmod
+EXTRA_CFLAGS += -Wall -Werror -I${CURDIR} -I${Sqlzma}
+# -D_LZMA_PROB32
+EXTRA_CFLAGS += $(shell ${CPP} ${CFLAGS} -P testflags.c)
+
+all: ${Kmod}/uncomp.c
+ ${MAKE} EXTRA_CFLAGS="${EXTRA_CFLAGS}" M=${CURDIR}/${Kmod} \
+ -C ${KDir} C=0 V=0 modules
+
+${Kmod}/uncomp.c: uncomp.c
+ ln $< $@
+
+clean: clean_kmod
+clean_kmod:
+ ${MAKE} -C ${KDir} M=${CURDIR}/${Kmod} V=0 clean
+ ${RM} ${Kmod}/*~
+ -@test -e ${Kmod}/uncomp.c && \
+ diff -q ${Kmod}/uncomp.c uncomp.c > /dev/null && \
+ find ${Kmod}/uncomp.c -links +1 | xargs -r ${RM}
+
+# Local variables: ;
+# compile-command: (concat "make Sqlzma=../../../../.. KDir=/lib/modules/`uname -r`/build -f " (file-name-nondirectory (buffer-file-name)));
+# End: ;
--- lzma-4.32.4/C/7zip/Compress/LZMA_C/sqlzma.mk.sqlzma 2007-12-12 20:23:31.000000000 +0100
+++ lzma-4.32.4/C/7zip/Compress/LZMA_C/sqlzma.mk 2007-12-12 20:23:31.000000000 +0100
@@ -0,0 +1,45 @@
+
+# Copyright (C) 2006 Junjiro Okajima
+# Copyright (C) 2006 Tomas Matejicek, slax.org
+#
+# LICENSE follows the described one in lzma.txt.
+
+# $Id: sqlzma.mk,v 1.20 2007/01/07 15:12:48 jro Exp $
+
+ifndef Sqlzma
+$(error Sqlzma is not defined)
+endif
+
+include makefile.gcc
+ifdef KDir
+include kmod.mk
+endif
+
+ifdef UseDebugFlags
+DebugFlags = -O0 -g -UNDEBUG
+endif
+CFLAGS += -DNDEBUG ${DebugFlags}
+Tgt = libunlzma.a libunlzma_r.a
+
+all: ${Tgt}
+
+%_r.c: %.c
+ ln $< $@
+# -pthread
+%_r.o: CFLAGS += -D_REENTRANT -include pthread.h
+
+uncomp.o uncomp_r.o: CFLAGS += -I${Sqlzma}
+uncomp.o: uncomp.c ${Sqlzma}/sqlzma.h
+
+libunlzma.a: uncomp.o LzmaDecode.o
+ ${AR} cr $@ $^
+libunlzma_r.a: uncomp_r.o LzmaDecode_r.o
+ ${AR} cr $@ $^
+
+clean: clean_sqlzma
+clean_sqlzma:
+ $(RM) ${Tgt} uncomp.o uncomp_r.o LzmaDecode_r.o *~
+
+# Local variables: ;
+# compile-command: (concat "make Sqlzma=../../../../.. -f " (file-name-nondirectory (buffer-file-name)));
+# End: ;
--- lzma-4.32.4/C/7zip/Compress/LZMA_C/testflags.c.sqlzma 2007-12-12 20:23:31.000000000 +0100
+++ lzma-4.32.4/C/7zip/Compress/LZMA_C/testflags.c 2007-12-12 20:23:31.000000000 +0100
@@ -0,0 +1,5 @@
+#ifdef _LZMA_PROB32
+-D_LZMA_PROB32
+#else
+-U_LZMA_PROB32
+#endif
--- lzma-4.32.4/C/7zip/Compress/LZMA_C/uncomp.c.sqlzma 2007-12-12 20:23:31.000000000 +0100
+++ lzma-4.32.4/C/7zip/Compress/LZMA_C/uncomp.c 2007-12-12 20:23:31.000000000 +0100
@@ -0,0 +1,221 @@
+/*
+ * Copyright (C) 2006, 2007 Junjiro Okajima
+ * Copyright (C) 2006, 2007 Tomas Matejicek, slax.org
+ *
+ * LICENSE follows the described one in lzma.txt.
+ */
+
+/* $Id: uncomp.c,v 1.1 2007/11/05 05:43:36 jro Exp $ */
+
+/* extract some parts from lzma443/C/7zip/Compress/LZMA_C/LzmaTest.c */
+
+#ifndef __KERNEL__
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <assert.h>
+#include <pthread.h>
+#define unlikely(x) __builtin_expect(!!(x), 0)
+#define BUG_ON(x) assert(!(x))
+/* sqlzma buffers are always larger than a page. true? */
+#define kmalloc(sz,gfp) malloc(sz)
+#define kfree(p) free(p)
+#define zlib_inflate(s, f) inflate(s, f)
+#define zlib_inflateInit(s) inflateInit(s)
+#define zlib_inflateReset(s) inflateReset(s)
+#define zlib_inflateEnd(s) inflateEnd(s)
+#else
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/vmalloc.h>
+#ifndef WARN_ON_ONCE
+#define WARN_ON_ONCE(b) WARN_ON(b)
+#endif
+#endif /* __KERNEL__ */
+
+#include "sqlzma.h"
+#include "LzmaDecode.h"
+
+static int LzmaUncompress(struct sqlzma_un *un)
+{
+ int err, i, ret;
+ SizeT outSize, inProcessed, outProcessed, srclen;
+ /* it's about 24-80 bytes structure, if int is 32-bit */
+ CLzmaDecoderState state;
+ unsigned char *dst, *src, a[8];
+ struct sized_buf *sbuf;
+
+ /* Decode LZMA properties and allocate memory */
+ err = -EINVAL;
+ src = un->un_cmbuf;
+ ret = LzmaDecodeProperties(&state.Properties, src, LZMA_PROPERTIES_SIZE);
+ src += LZMA_PROPERTIES_SIZE;
+ if (unlikely(ret != LZMA_RESULT_OK))
+ goto out;
+ i = LzmaGetNumProbs(&state.Properties);
+ if (unlikely(i <= 0))
+ i = 1;
+ i *= sizeof(CProb);
+ sbuf = un->un_a + SQUN_PROB;
+ if (unlikely(sbuf->sz < i)) {
+ if (sbuf->buf && sbuf->buf != un->un_prob)
+ kfree(sbuf->buf);
+#ifdef __KERNEL__
+ printk("%s:%d: %d --> %d\n", __func__, __LINE__, sbuf->sz, i);
+#else
+ printf("%d --> %d\n", sbuf->sz, i);
+#endif
+ err = -ENOMEM;
+ sbuf->sz = 0;
+ sbuf->buf = kmalloc(i, GFP_ATOMIC);
+ if (unlikely(!sbuf->buf))
+ goto out;
+ sbuf->sz = i;
+ }
+ state.Probs = (void*)sbuf->buf;
+
+ /* Read uncompressed size */
+ memcpy(a, src, sizeof(a));
+ src += sizeof(a);
+ outSize = a[0] | (a[1] << 8) | (a[2] << 16) | (a[3] << 24);
+
+ err = -EINVAL;
+ dst = un->un_resbuf;
+ if (unlikely(!dst || outSize > un->un_reslen))
+ goto out;
+ un->un_reslen = outSize;
+ srclen = un->un_cmlen - (src - un->un_cmbuf);
+
+ /* Decompress */
+ err = LzmaDecode(&state, src, srclen, &inProcessed, dst, outSize,
+ &outProcessed);
+ if (err)
+ err = -EINVAL;
+
+ out:
+#ifndef __KERNEL__
+ if (err)
+ fprintf(stderr, "err %d\n", err);
+#endif
+ return err;
+}
+
+int sqlzma_un(struct sqlzma_un *un, struct sized_buf *src,
+ struct sized_buf *dst)
+{
+ int err, by_lzma = 0;
+ if (un->un_lzma && is_lzma(*src->buf)) {
+ by_lzma = 1;
+ un->un_cmbuf = src->buf;
+ un->un_cmlen = src->sz;
+ un->un_resbuf = dst->buf;
+ un->un_reslen = dst->sz;
+
+ /* this library is thread-safe */
+ err = LzmaUncompress(un);
+ goto out;
+ }
+
+ err = zlib_inflateReset(&un->un_stream);
+ if (unlikely(err != Z_OK))
+ goto out;
+ un->un_stream.next_in = src->buf;
+ un->un_stream.avail_in = src->sz;
+ un->un_stream.next_out = dst->buf;
+ un->un_stream.avail_out = dst->sz;
+ err = zlib_inflate(&un->un_stream, Z_FINISH);
+ if (err == Z_STREAM_END)
+ err = 0;
+
+ out:
+ if (err) {
+#ifdef __KERNEL__
+ WARN_ON_ONCE(1);
+#else
+ char a[64] = "ZLIB ";
+ if (by_lzma) {
+ strcpy(a, "LZMA ");
+#ifdef _REENTRANT
+ strerror_r(err, a + 5, sizeof(a) - 5);
+#else
+ strncat(a, strerror(err), sizeof(a) - 5);
+#endif
+ } else
+ strncat(a, zError(err), sizeof(a) - 5);
+ fprintf(stderr, "%s: %.*s\n", __func__, sizeof(a), a);
+#endif
+ }
+ return err;
+}
+
+int sqlzma_init(struct sqlzma_un *un, int do_lzma, unsigned int res_sz)
+{
+ int err;
+
+ err = -ENOMEM;
+ un->un_lzma = do_lzma;
+ memset(un->un_a, 0, sizeof(un->un_a));
+ un->un_a[SQUN_PROB].buf = un->un_prob;
+ un->un_a[SQUN_PROB].sz = sizeof(un->un_prob);
+ if (res_sz) {
+ un->un_a[SQUN_RESULT].buf = kmalloc(res_sz, GFP_KERNEL);
+ if (unlikely(!un->un_a[SQUN_RESULT].buf))
+ return err;
+ un->un_a[SQUN_RESULT].sz = res_sz;
+ }
+
+ un->un_stream.next_in = NULL;
+ un->un_stream.avail_in = 0;
+#ifdef __KERNEL__
+ un->un_stream.workspace = kmalloc(zlib_inflate_workspacesize(), GFP_KERNEL);
+ if (unlikely(!un->un_stream.workspace))
+ return err;
+#else
+ un->un_stream.opaque = NULL;
+ un->un_stream.zalloc = Z_NULL;
+ un->un_stream.zfree = Z_NULL;
+#endif
+ err = zlib_inflateInit(&un->un_stream);
+ if (unlikely(err == Z_MEM_ERROR))
+ return -ENOMEM;
+ BUG_ON(err);
+ return err;
+}
+
+void sqlzma_fin(struct sqlzma_un *un)
+{
+ int i;
+ for (i = 0; i < SQUN_LAST; i++)
+ if (un->un_a[i].buf && un->un_a[i].buf != un->un_prob)
+ kfree(un->un_a[i].buf);
+ BUG_ON(zlib_inflateEnd(&un->un_stream) != Z_OK);
+}
+
+#ifdef __KERNEL__
+EXPORT_SYMBOL(sqlzma_un);
+EXPORT_SYMBOL(sqlzma_init);
+EXPORT_SYMBOL(sqlzma_fin);
+
+#if 0
+static int __init sqlzma_init(void)
+{
+ return 0;
+}
+
+static void __exit sqlzma_exit(void)
+{
+}
+
+module_init(sqlzma_init);
+module_exit(sqlzma_exit);
+#endif
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Junjiro Okajima <sfjro at users dot sf dot net>");
+MODULE_VERSION("$Id: uncomp.c,v 1.1 2007/11/05 05:43:36 jro Exp $");
+MODULE_DESCRIPTION("LZMA uncompress for squashfs. "
+ "Some functions for squashfs to support LZMA and "
+ "a tiny wrapper for LzmaDecode.c in LZMA SDK from www.7-zip.org.");
+#endif
--- lzma-4.32.4/C/7zip/Compress/LZMA_C/kmod/Makefile.sqlzma 2007-12-12 20:23:31.000000000 +0100
+++ lzma-4.32.4/C/7zip/Compress/LZMA_C/kmod/Makefile 2007-12-12 20:23:31.000000000 +0100
@@ -0,0 +1,11 @@
+
+# Copyright (C) 2006-2007 Junjiro Okajima
+# Copyright (C) 2006-2007 Tomas Matejicek, slax.org
+#
+# LICENSE follows the described one in lzma.txt.
+
+# $Id: Makefile,v 1.1 2007/11/05 05:43:36 jro Exp $
+
+obj-m += unlzma.o sqlzma.o
+unlzma-y := module.o
+sqlzma-y := uncomp.o
--- lzma-4.32.4/C/7zip/Compress/LZMA_C/kmod/module.c.sqlzma 2007-12-12 20:23:31.000000000 +0100
+++ lzma-4.32.4/C/7zip/Compress/LZMA_C/kmod/module.c 2007-12-12 20:23:31.000000000 +0100
@@ -0,0 +1,36 @@
+
+/*
+ * Copyright (C) 2006-2007 Junjiro Okajima
+ * Copyright (C) 2006-2007 Tomas Matejicek, slax.org
+ *
+ * LICENSE follows the described one in lzma.txt.
+ */
+
+/* $Id: module.c,v 1.1 2007/11/05 05:43:36 jro Exp $ */
+
+#include <linux/init.h>
+#include <linux/module.h>
+
+#include "../LzmaDecode.c"
+
+EXPORT_SYMBOL(LzmaDecodeProperties);
+EXPORT_SYMBOL(LzmaDecode);
+
+#if 0
+static int __init unlzma_init(void)
+{
+ return 0;
+}
+
+static void __exit unlzma_exit(void)
+{
+}
+
+module_init(unlzma_init);
+module_exit(unlzma_exit);
+#endif
+
+MODULE_LICENSE("GPL");
+MODULE_VERSION("$Id: module.c,v 1.1 2007/11/05 05:43:36 jro Exp $");
+MODULE_DESCRIPTION("LZMA uncompress. "
+ "A tiny wrapper for LzmaDecode.c in LZMA SDK from www.7-zip.org.");
