This is a patch file for "lzma" 4.57. It makes some changes that may be needed to build kernels that support "squashfs plus lzma" filesys- tems. This file is based on a file extracted originally from: ftp://ftp.slax.org/source/slax/sqlzma/sqlzma3.4-457.tar.bz2 The contents are unchanged except for these comments. diff -NPur lzma457.orig/C/Compress/Lzma/kmod/Makefile lzma457/C/Compress/Lzma/kmod/Makefile --- lzma457.orig/C/Compress/Lzma/kmod/Makefile 1969-12-31 18:00:00.000000000 -0600 +++ lzma457/C/Compress/Lzma/kmod/Makefile 2008-10-29 10:18:14.000000000 -0500 @@ -0,0 +1,16 @@ + +# Copyright (C) 2006-2008 Junjiro Okajima +# Copyright (C) 2006-2008 Tomas Matejicek, slax.org +# +# LICENSE follows the described one in lzma.txt. + +# $Id: Makefile,v 1.3 2008-03-12 01:49:39 jro Exp $ + +# # the environment variables are not inherited since 2.6.23 +# ifdef SQLZMA_EXTRA_CFLAGS +# EXTRA_CFLAGS += ${SQLZMA_EXTRA_CFLAGS} +# endif + +obj-m += unlzma.o sqlzma.o +unlzma-y := module.o +sqlzma-y := uncomp.o diff -NPur lzma457.orig/C/Compress/Lzma/kmod/module.c lzma457/C/Compress/Lzma/kmod/module.c --- lzma457.orig/C/Compress/Lzma/kmod/module.c 1969-12-31 18:00:00.000000000 -0600 +++ lzma457/C/Compress/Lzma/kmod/module.c 2008-10-29 10:18:14.000000000 -0500 @@ -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 +#include + +#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."); diff -NPur lzma457.orig/C/Compress/Lzma/kmod.mk lzma457/C/Compress/Lzma/kmod.mk --- lzma457.orig/C/Compress/Lzma/kmod.mk 1969-12-31 18:00:00.000000000 -0600 +++ lzma457/C/Compress/Lzma/kmod.mk 2008-10-29 10:18:14.000000000 -0500 @@ -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: ; diff -NPur lzma457.orig/C/Compress/Lzma/sqlzma.mk lzma457/C/Compress/Lzma/sqlzma.mk --- lzma457.orig/C/Compress/Lzma/sqlzma.mk 1969-12-31 18:00:00.000000000 -0600 +++ lzma457/C/Compress/Lzma/sqlzma.mk 2008-10-29 10:18:14.000000000 -0500 @@ -0,0 +1,47 @@ + +# Copyright (C) 2006-2007 Junjiro Okajima +# Copyright (C) 2006-2007 Tomas Matejicek, slax.org +# +# LICENSE follows the described one in lzma.txt. + +# $Id: sqlzma.mk,v 1.1 2007-11-05 05:43:36 jro Exp $ + +ifndef Sqlzma +$(error Sqlzma is not defined) +endif + +#include makefile.gcc +CFLAGS = -c -O2 -Wall -pedantic -D _LZMA_PROB32 + +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 LzmaDecode.o *~ + +# Local variables: ; +# compile-command: (concat "make Sqlzma=../../../../.. -f " (file-name-nondirectory (buffer-file-name))); +# End: ; diff -NPur lzma457.orig/C/Compress/Lzma/testflags.c lzma457/C/Compress/Lzma/testflags.c --- lzma457.orig/C/Compress/Lzma/testflags.c 1969-12-31 18:00:00.000000000 -0600 +++ lzma457/C/Compress/Lzma/testflags.c 2008-10-29 10:18:14.000000000 -0500 @@ -0,0 +1,5 @@ +#ifdef _LZMA_PROB32 +-D_LZMA_PROB32 +#else +-U_LZMA_PROB32 +#endif diff -NPur lzma457.orig/C/Compress/Lzma/uncomp.c lzma457/C/Compress/Lzma/uncomp.c --- lzma457.orig/C/Compress/Lzma/uncomp.c 1969-12-31 18:00:00.000000000 -0600 +++ lzma457/C/Compress/Lzma/uncomp.c 2008-10-29 10:18:14.000000000 -0500 @@ -0,0 +1,223 @@ +/* + * Copyright (C) 2006-2008 Junjiro Okajima + * Copyright (C) 2006-2008 Tomas Matejicek, slax.org + * + * LICENSE follows the described one in lzma.txt. + */ + +/* $Id: uncomp.c,v 1.7 2008-03-12 16:58:34 jro Exp $ */ + +/* extract some parts from lzma443/C/7zip/Compress/LZMA_C/LzmaTest.c */ + +#ifndef __KERNEL__ +#include +#include +#include +#include +#include +#include +#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 +#include +#include +#include +#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 = (void *)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 (unlikely(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 = 1; + if (un->un_lzma && is_lzma(*src->buf)) { + 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; + } + + by_lzma = 0; + 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 (unlikely(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 "); +MODULE_VERSION("$Id: uncomp.c,v 1.7 2008-03-12 16:58:34 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 diff -NPur lzma457.orig/CPP/7zip/Compress/LZMA_Alone/comp.cc lzma457/CPP/7zip/Compress/LZMA_Alone/comp.cc --- lzma457.orig/CPP/7zip/Compress/LZMA_Alone/comp.cc 1969-12-31 18:00:00.000000000 -0600 +++ lzma457/CPP/7zip/Compress/LZMA_Alone/comp.cc 2008-10-29 10:18:14.000000000 -0500 @@ -0,0 +1,260 @@ +/* + * 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 +#include +#include +#include + +#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 +#include +#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 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 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 encoder = &encoderSpec; + encoder->AddRef(); + CInMemoryStream inStreamSpec(next_in, avail_in); + CMyComPtr inStream = &inStreamSpec; + inStream->AddRef(); + COutMemoryStream outStreamSpec(next_out, avail_out); + CMyComPtr 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::kNumThreads, + 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 = 1; // numThreads + properties[9].vt = VT_UI4; + properties[9].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; +} diff -NPur lzma457.orig/CPP/7zip/Compress/LZMA_Alone/sqlzma.mk lzma457/CPP/7zip/Compress/LZMA_Alone/sqlzma.mk --- lzma457.orig/CPP/7zip/Compress/LZMA_Alone/sqlzma.mk 1969-12-31 18:00:00.000000000 -0600 +++ lzma457/CPP/7zip/Compress/LZMA_Alone/sqlzma.mk 2008-10-29 10:18:32.000000000 -0500 @@ -0,0 +1,57 @@ + +# Copyright (C) 2006-2007 Junjiro Okajima +# Copyright (C) 2006-2007 Tomas Matejicek, slax.org +# +# LICENSE follows the described one in lzma.txt. + +# $Id: sqlzma.mk,v 1.1 2007-11-05 05:43:36 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 StreamUtils_r.o MatchFinder_r.o \ + RangeCoderBit_r.o OutBuffer_r.o 7zCrc_r.o + +%_r.cc: ../LZMA/%.cpp + ln $< $@ +%_r.c: ../../../../C/%.c + ln $< $@ +%_r.c: ../../../../C/Compress/Lz/%.c + ln $< $@ +%_r.cc: ../../Common/%.cpp + ln $< $@ +%_r.cc: ../RangeCoder/%.cpp + ln $< $@ +LZMAEncoder_r.o: CXXFLAGS += -I../LZMA +Alloc_r.o: CFLAGS += -I../../../../C +StreamUtils_r.o: CXXFLAGS += -I../../Common +MatchFinder_r.o: CFLAGS += -I../../../../C/Compress/Lz +RangeCoderBit_r.o: CXXFLAGS += -I../RangeCoder +OutBuffer_r.o: CXXFLAGS += -I../../Common +7zCrc_r.o: CFLAGS += -I../../../../C + +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: ;