29 Jun
2014
29 Jun
'14
7:29 p.m.
Idwer Vollering (vidwer(a)gmail.com) just uploaded a new patch set to gerrit, which you can
find at http://review.coreboot.org/3918
-gerrit
commit 59c528fd3e524dceaf6e226c7dfb806ae5b0b057
Author: Idwer Vollering <vidwer(a)gmail.com>
Date: Mon Jun 30 03:57:34 2014 +0200
[1/4] HP DL120G5: import lzf code
Change-Id: Ia1d8abdd181ace44c5b94c7bba2f284701c7c2eb
Signed-off-by: Idwer Vollering <vidwer(a)gmail.com>
Signed-off-by: Ruud Schramp <schramp(a)holmes.nl>
---
SerialICE/lzf/README | 4 +
SerialICE/lzf/liblzf-3.6/Changes | 136 ++++++++
SerialICE/lzf/liblzf-3.6/LICENSE | 27 ++
SerialICE/lzf/liblzf-3.6/Makefile | 71 ++++
SerialICE/lzf/liblzf-3.6/Makefile.in | 66 ++++
SerialICE/lzf/liblzf-3.6/README | 29 ++
SerialICE/lzf/liblzf-3.6/config.h | 17 +
SerialICE/lzf/liblzf-3.6/crc32.h | 65 ++++
SerialICE/lzf/liblzf-3.6/cs/CLZF.cs | 344 ++++++++++++++++++++
SerialICE/lzf/liblzf-3.6/cs/README | 7 +
SerialICE/lzf/liblzf-3.6/lzf.c | 537 +++++++++++++++++++++++++++++++
SerialICE/lzf/liblzf-3.6/lzf.h | 100 ++++++
SerialICE/lzf/liblzf-3.6/lzfP.h | 185 +++++++++++
SerialICE/lzf/liblzf-3.6/lzf_c.c | 291 +++++++++++++++++
SerialICE/lzf/liblzf-3.6/lzf_d.c | 185 +++++++++++
SerialICE/lzf/liblzf-3.6/romdecompress.c | 245 ++++++++++++++
16 files changed, 2309 insertions(+)
diff --git a/SerialICE/lzf/README b/SerialICE/lzf/README
new file mode 100644
index 0000000..a2f87ba
--- /dev/null
+++ b/SerialICE/lzf/README
@@ -0,0 +1,4 @@
+This application is using
+liblzf-3.6.tar.gz
+
+The decompression application was hand-edited into the makefile
diff --git a/SerialICE/lzf/liblzf-3.6/Changes b/SerialICE/lzf/liblzf-3.6/Changes
new file mode 100644
index 0000000..93bd4cb
--- /dev/null
+++ b/SerialICE/lzf/liblzf-3.6/Changes
@@ -0,0 +1,136 @@
+3.6 Mon Feb 7 17:37:31 CET 2011
+ - fixed hash calculation in C♯ version (Tiago Freitas Leal).
+ - unroll copy for small sizes, use memcpy for larger sizes,
+ greatly speeding up decompression in most cases.
+ - finally disable rep movsb - it's a big loss on modern intel cpus,
+ and only a small win on amd cpus.
+ - improve C++ compatibility of the code.
+ - slightly improve compressor speed.
+ - halved memory requirements for compressor on 64 bit architectures,
+ which can improve the speed quite a bit on older cpus.
+
+3.5 Fri May 1 02:28:42 CEST 2009
+ - lzf_compress did sometimes write one octet past the given output
+ buffer (analyzed and nice testcase by Salvatore Sanfilippo).
+
+3.4 Tue Sep 2 06:45:00 CEST 2008
+ - the fix from 3.3 introduced a compression bug, which is fixed in
+ this release (which explains the mysterious prerelease...). Thanks
+ once more to Clément Calmels.
+
+3.3 Mon Aug 25 03:17:42 CEST 2008
+ - lzf_compress could access memory after the given input buffer
+ when outputting back references. reported with nice testcase
+ by Clément Calmels.
+
+3.2 Fri May 9 18:52:23 CEST 2008
+ - include a workaround for failing POSIX and real-world compliance
+ on 64 bit windows (microsoft claims to support POSIX, but is far
+ from it). (bug found and analysed nicely by John Lilley).
+
+3.1 Fri Nov 30 11:33:04 CET 2007
+ - IMPORTANT BUGFIX: a too long final literal run would corrupt data
+ in the encoder (this was introduced in 3.0 only, earlier versions
+ are safe).
+
+3.0 Tue Nov 13 22:13:09 CET 2007
+ - switched to 2-clause bsd with "GPL v2 or any later version" option.
+ - speed up compression by ~10-15% in common cases
+ by some manual unrolling.
+ - import some compiler tricks from JSON::XS, for further speed-ups.
+ - tune hash functions depending on ULTRA_FAST or VERY_FAST settings.
+ - for typical binary data (e.g. /bin/bash, memory dumps,
+ canterbury corpus etc.), speed is now comparable to fastlz, but
+ with better compression ratio. with ULTRA_FAST, it's typically
+ 3-15% faster than fastlz while still maintaining a similar ratio.
+ (amd64 and core 2 duo, ymmv). thanks a lot for the competition :)
+ - undo inline assembly in compressor, it is no longer helpful.
+ - no changes to the decompressor.
+ - use a HLOG of 16 by default now (formerly 15).
+
+2.1 Fri Nov 2 13:34:42 CET 2007
+ - switched to a 2-clause bsd license with GPL exception.
+ - get rid of memcpy.
+ - tentatively use rep movsb on x86 and x86_64 (gcc only) for a
+ moderate speed improvement.
+ - applied patch by Kein-Hong Man to maske lzf.c compile under
+ the crippled mingw32 environment.
+
+2.0 Fri Feb 16 23:11:18 CET 2007
+ - replaced lzf demo by industrial-strength lzf utility with behaviour
+ similar other compression utilities. Thanks for Stefan Traby for
+ rewriting it!
+ - fix state arg prototype.
+
+1.7 Wed Sep 27 17:29:15 CEST 2006
+ - remove bogus "unlzf" patch.
+ note to self: never accept well-meant patches.
+ - make lzf more robust in presence of padding bytes or sudden eof.
+
+1.6 Fri Jul 7 17:31:26 CEST 2006
+ - the lzf example utility will now uncompress if invoked
+ as "unlzf" (patch by Scott Feeney).
+ - add CHECK_INPUT option that adds more checks for input
+ data validity.
+ - help applications that do not pass in the correct length
+ (such as php) by returning either EINVAL or E2BIG.
+ - default HLOG size is now 15 (cpu caches have increased).
+ - documentation fixes.
+
+1.51 Thu Apr 14 22:15:46 CEST 2005
+ - incorporated C♯ implementation of both the en- and decoder,
+ written by "Oren J. Maurice".
+ You can find it in the cs/ subdirectory.
+ - make FRST, NEXT IDX overridable if lzf_c.c is directly included
+ in the code.
+
+1.5 Tue Mar 8 20:23:23 CET 2005
+ - incorporated improvements by Adam D. Moss,
+ which includes a new VERY_FAST mode which is
+ a bit slower than ULTRA_FAST but much better,
+ and enabled it as default.
+
+1.401 Thu Mar 3 18:00:52 CET 2005
+ - use cstring in c++, not string.h.
+ - change of contact address.
+
+1.4 Wed Dec 15 08:08:49 CET 2004
+ - very very slight tuning of the hashing function.
+
+1.3 Thu Mar 25 15:41:17 CET 2004
+ - changed license of lzf core code to explicitly allow
+ relicensing under the GPLv2.
+ - added VPATH support as suggested by Björn Eriksson.
+
+1.2 Mon Dec 29 13:47:28 CET 2003
+ - avoid spurious memory accesses after the to-be-compressed
+ memory region. originally reported by Michal Zalewski.
+ - flip LZF_STACK_ARG meaning (to be correct).
+
+1.1 Tue Dec 23 05:48:32 CET 2003
+ - removed #warn directive, it's not worth the hassle.
+ - add LZF_STACK_ARG and AVOID_ERRNO configurations
+ for embedded systems.
+ - make it compile cleanly as c++.
+ - some small documentation and code fixes.
+
+1.0 Sun Nov 17 12:37:37 CET 2002
+ - slightly better compression ratio, almost unmeasurably
+ slower.
+ - some documentation fixes.
+
+0.4 Thu Jun 13 14:11:10 CEST 2002
+ - typoe fix.
+ - lzf demo program now properly decompresses small files.
+ - fix another 64 bit issue, found by Laurent Deniel.
+
+0.3 Tue Jan 16 13:21:14 CET 2001
+ - fix silly beginners 32/64 bit mistake.
+
+0.2 Thu Jan 4 05:56:42 CET 2001
+ - now totally independent of autoconfig, for
+ easy inclusion into other programs.
+ - much better fine-tuning, faster and better than 0.1.
+
+0.1 2000
+ - initial release.
diff --git a/SerialICE/lzf/liblzf-3.6/LICENSE b/SerialICE/lzf/liblzf-3.6/LICENSE
new file mode 100644
index 0000000..ee54ff7
--- /dev/null
+++ b/SerialICE/lzf/liblzf-3.6/LICENSE
@@ -0,0 +1,27 @@
+Copyright (c) 2000-2009 Marc Alexander Lehmann <schmorp(a)schmorp.de>
+
+Redistribution and use in source and binary forms, with or without modifica-
+tion, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MER-
+CHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPE-
+CIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTH-
+ERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+OF THE POSSIBILITY OF SUCH DAMAGE.
+
+Alternatively, the following files carry an additional notice that
+explicitly allows relicensing under the GPLv2: lzf.c lzf.h lzfP.h lzf_c.c
+lzf_d.c
+
diff --git a/SerialICE/lzf/liblzf-3.6/Makefile b/SerialICE/lzf/liblzf-3.6/Makefile
new file mode 100644
index 0000000..af55575
--- /dev/null
+++ b/SerialICE/lzf/liblzf-3.6/Makefile
@@ -0,0 +1,71 @@
+VERSION = 3.6
+
+prefix = /usr/local
+exec_prefix = ${prefix}
+libdir = ${exec_prefix}/lib
+bindir = ${exec_prefix}/bin
+includedir = ${prefix}/include
+
+
+
+CC = gcc
+CPPFLAGS = -I.
+CFLAGS = -g
+#CFLAGS = -g -O2 -O3 -funroll-all-loops
+LDFLAGS =
+RANLIB = ranlib
+INSTALL = /usr/bin/install -c
+INSTALL_DATA = ${INSTALL} -m 644
+
+all: Makefile lzf romdecompress
+
+clean:
+ -rm -f *.o *.a lzf bench romdecompress
+
+lzf_c.o: lzf_c.c lzfP.h
+
+lzf_d.o: lzf_d.c lzfP.h
+
+romdecompress.o: romdecompress.c
+
+romdecompress: romdecompress.o liblzf.a
+
+lzf.o: lzf.c
+
+lzf: lzf.o liblzf.a
+
+lzfP.h: lzf.h config.h
+
+liblzf.a: lzf_c.o lzf_d.o
+ rm -f $@
+ $(AR) rc $@ $^
+ $(RANLIB) $@
+
+install: all
+ $(INSTALL) -d $(bindir)
+ $(INSTALL) -m 755 lzf $(bindir)
+ $(INSTALL) -d $(includedir)
+ $(INSTALL_DATA) lzf.h $(includedir)
+ $(INSTALL) -d $(libdir)
+ $(INSTALL_DATA) liblzf.a $(libdir)
+
+dist:
+ mkdir liblzf-$(VERSION)
+ tar c LICENSE README Makefile.in config.h.in \
+ configure configure.ac install-sh \
+ cs/README cs/CLZF.cs \
+ lzf.h lzfP.h lzf_c.c lzf_d.c \
+ crc32.h lzf.c Changes \
+ | tar xpC liblzf-$(VERSION)
+ -chown -R root.root liblzf-$(VERSION)
+ chmod -R u=rwX,go=rX liblzf-$(VERSION)
+ tar cvf - liblzf-$(VERSION) | gzip -9 >liblzf-$(VERSION).tar.gz
+ rm -rf liblzf-$(VERSION)
+ ls -l liblzf-$(VERSION).tar.gz
+
+Makefile: Makefile.in
+ ./config.status
+
+bench: Makefile liblzf.a bench.c
+ $(CC) $(CPPFLAGS) $(CFLAGS) -g -o bench bench.c -L. -llzf
+
diff --git a/SerialICE/lzf/liblzf-3.6/Makefile.in b/SerialICE/lzf/liblzf-3.6/Makefile.in
new file mode 100644
index 0000000..3c87d62
--- /dev/null
+++ b/SerialICE/lzf/liblzf-3.6/Makefile.in
@@ -0,0 +1,66 @@
+VERSION = 3.6
+
+prefix = @prefix@
+exec_prefix = @exec_prefix@
+libdir = @libdir@
+bindir = @bindir@
+includedir = @includedir@
+
+VPATH = @srcdir@
+
+CC = @CC@
+CPPFLAGS = -I. @CPPFLAGS@
+CFLAGS = @CFLAGS@
+LDFLAGS = @LDFLAGS@
+RANLIB = @RANLIB@
+INSTALL = @INSTALL@
+INSTALL_DATA = @INSTALL_DATA@
+
+all: Makefile lzf
+
+clean:
+ -rm -f *.o *.a lzf bench
+
+lzf_c.o: lzf_c.c lzfP.h
+
+lzf_d.o: lzf_d.c lzfP.h
+
+lzf.o: lzf.c
+
+lzf: lzf.o liblzf.a
+
+lzfP.h: lzf.h config.h
+
+liblzf.a: lzf_c.o lzf_d.o
+ rm -f $@
+ $(AR) rc $@ $^
+ $(RANLIB) $@
+
+install: all
+ $(INSTALL) -d $(bindir)
+ $(INSTALL) -m 755 lzf $(bindir)
+ $(INSTALL) -d $(includedir)
+ $(INSTALL_DATA) lzf.h $(includedir)
+ $(INSTALL) -d $(libdir)
+ $(INSTALL_DATA) liblzf.a $(libdir)
+
+dist:
+ mkdir liblzf-$(VERSION)
+ tar c LICENSE README Makefile.in config.h.in \
+ configure configure.ac install-sh \
+ cs/README cs/CLZF.cs \
+ lzf.h lzfP.h lzf_c.c lzf_d.c \
+ crc32.h lzf.c Changes \
+ | tar xpC liblzf-$(VERSION)
+ -chown -R root.root liblzf-$(VERSION)
+ chmod -R u=rwX,go=rX liblzf-$(VERSION)
+ tar cvf - liblzf-$(VERSION) | gzip -9 >liblzf-$(VERSION).tar.gz
+ rm -rf liblzf-$(VERSION)
+ ls -l liblzf-$(VERSION).tar.gz
+
+Makefile: Makefile.in
+ ./config.status
+
+bench: Makefile liblzf.a bench.c
+ $(CC) $(CPPFLAGS) $(CFLAGS) -g -o bench bench.c -L. -llzf
+
diff --git a/SerialICE/lzf/liblzf-3.6/README b/SerialICE/lzf/liblzf-3.6/README
new file mode 100644
index 0000000..0734ebe
--- /dev/null
+++ b/SerialICE/lzf/liblzf-3.6/README
@@ -0,0 +1,29 @@
+DESCRIPTION
+ LZF is an extremely fast (not that much slower than a pure memcpy)
+ compression algorithm. It is ideal for applications where you want to
+ save *some* space but not at the cost of speed. It is ideal for
+ repetitive data as well. The module is self-contained and very small.
+
+ It's written in ISO-C with no external dependencies other than what
+ C provides and can easily be #include'd into your code, no makefile
+ changes or library builds requires.
+
+ A C♯ implementation without external dependencies is available, too.
+
+ I do not know for certain whether any patents in any countries apply
+ to this algorithm, but at the moment it is believed that it is free
+ from any patents. More importantly, it is also free to use in every
+ software package (see LICENSE).
+
+ See the lzf.h file for details on how the functions in this
+ mini-library are to be used.
+
+ NOTE: This package contains a very bare-bones command-line utility
+ which is neither optimized for speed nor for compression. This library
+ is really intended to be used inside larger programs.
+
+AUTHOR
+ This library was written by Marc Lehmann <schmorp(a)schmorp.de> (See also
+ http://software.schmorp.de/pkg/liblzf).
+
+
diff --git a/SerialICE/lzf/liblzf-3.6/config.h b/SerialICE/lzf/liblzf-3.6/config.h
new file mode 100644
index 0000000..b5df3b1
--- /dev/null
+++ b/SerialICE/lzf/liblzf-3.6/config.h
@@ -0,0 +1,17 @@
+/* config.h. Generated from config.h.in by configure. */
+/* config.h.in. Generated automatically from configure.in by autoheader 2.13. */
+
+/* Define to empty if the keyword does not work. */
+/* #undef const */
+
+/* Define if you have the ANSI C header files. */
+#define STDC_HEADERS 1
+
+/* The number of bytes in a int. */
+#define SIZEOF_INT 4
+
+/* The number of bytes in a long. */
+#define SIZEOF_LONG 4
+
+/* The number of bytes in a short. */
+#define SIZEOF_SHORT 2
diff --git a/SerialICE/lzf/liblzf-3.6/crc32.h b/SerialICE/lzf/liblzf-3.6/crc32.h
new file mode 100644
index 0000000..cf8f6d4
--- /dev/null
+++ b/SerialICE/lzf/liblzf-3.6/crc32.h
@@ -0,0 +1,65 @@
+#ifndef CRC32_H
+#define CRC32_H
+
+/* crc32 0xdebb20e3 table and supplementary functions. */
+
+static const u32 crc_32_tab[] =
+{
+ 0x00000000UL, 0x77073096UL, 0xee0e612cUL, 0x990951baUL, 0x076dc419UL,
+ 0x706af48fUL, 0xe963a535UL, 0x9e6495a3UL, 0x0edb8832UL, 0x79dcb8a4UL,
+ 0xe0d5e91eUL, 0x97d2d988UL, 0x09b64c2bUL, 0x7eb17cbdUL, 0xe7b82d07UL,
+ 0x90bf1d91UL, 0x1db71064UL, 0x6ab020f2UL, 0xf3b97148UL, 0x84be41deUL,
+ 0x1adad47dUL, 0x6ddde4ebUL, 0xf4d4b551UL, 0x83d385c7UL, 0x136c9856UL,
+ 0x646ba8c0UL, 0xfd62f97aUL, 0x8a65c9ecUL, 0x14015c4fUL, 0x63066cd9UL,
+ 0xfa0f3d63UL, 0x8d080df5UL, 0x3b6e20c8UL, 0x4c69105eUL, 0xd56041e4UL,
+ 0xa2677172UL, 0x3c03e4d1UL, 0x4b04d447UL, 0xd20d85fdUL, 0xa50ab56bUL,
+ 0x35b5a8faUL, 0x42b2986cUL, 0xdbbbc9d6UL, 0xacbcf940UL, 0x32d86ce3UL,
+ 0x45df5c75UL, 0xdcd60dcfUL, 0xabd13d59UL, 0x26d930acUL, 0x51de003aUL,
+ 0xc8d75180UL, 0xbfd06116UL, 0x21b4f4b5UL, 0x56b3c423UL, 0xcfba9599UL,
+ 0xb8bda50fUL, 0x2802b89eUL, 0x5f058808UL, 0xc60cd9b2UL, 0xb10be924UL,
+ 0x2f6f7c87UL, 0x58684c11UL, 0xc1611dabUL, 0xb6662d3dUL, 0x76dc4190UL,
+ 0x01db7106UL, 0x98d220bcUL, 0xefd5102aUL, 0x71b18589UL, 0x06b6b51fUL,
+ 0x9fbfe4a5UL, 0xe8b8d433UL, 0x7807c9a2UL, 0x0f00f934UL, 0x9609a88eUL,
+ 0xe10e9818UL, 0x7f6a0dbbUL, 0x086d3d2dUL, 0x91646c97UL, 0xe6635c01UL,
+ 0x6b6b51f4UL, 0x1c6c6162UL, 0x856530d8UL, 0xf262004eUL, 0x6c0695edUL,
+ 0x1b01a57bUL, 0x8208f4c1UL, 0xf50fc457UL, 0x65b0d9c6UL, 0x12b7e950UL,
+ 0x8bbeb8eaUL, 0xfcb9887cUL, 0x62dd1ddfUL, 0x15da2d49UL, 0x8cd37cf3UL,
+ 0xfbd44c65UL, 0x4db26158UL, 0x3ab551ceUL, 0xa3bc0074UL, 0xd4bb30e2UL,
+ 0x4adfa541UL, 0x3dd895d7UL, 0xa4d1c46dUL, 0xd3d6f4fbUL, 0x4369e96aUL,
+ 0x346ed9fcUL, 0xad678846UL, 0xda60b8d0UL, 0x44042d73UL, 0x33031de5UL,
+ 0xaa0a4c5fUL, 0xdd0d7cc9UL, 0x5005713cUL, 0x270241aaUL, 0xbe0b1010UL,
+ 0xc90c2086UL, 0x5768b525UL, 0x206f85b3UL, 0xb966d409UL, 0xce61e49fUL,
+ 0x5edef90eUL, 0x29d9c998UL, 0xb0d09822UL, 0xc7d7a8b4UL, 0x59b33d17UL,
+ 0x2eb40d81UL, 0xb7bd5c3bUL, 0xc0ba6cadUL, 0xedb88320UL, 0x9abfb3b6UL,
+ 0x03b6e20cUL, 0x74b1d29aUL, 0xead54739UL, 0x9dd277afUL, 0x04db2615UL,
+ 0x73dc1683UL, 0xe3630b12UL, 0x94643b84UL, 0x0d6d6a3eUL, 0x7a6a5aa8UL,
+ 0xe40ecf0bUL, 0x9309ff9dUL, 0x0a00ae27UL, 0x7d079eb1UL, 0xf00f9344UL,
+ 0x8708a3d2UL, 0x1e01f268UL, 0x6906c2feUL, 0xf762575dUL, 0x806567cbUL,
+ 0x196c3671UL, 0x6e6b06e7UL, 0xfed41b76UL, 0x89d32be0UL, 0x10da7a5aUL,
+ 0x67dd4accUL, 0xf9b9df6fUL, 0x8ebeeff9UL, 0x17b7be43UL, 0x60b08ed5UL,
+ 0xd6d6a3e8UL, 0xa1d1937eUL, 0x38d8c2c4UL, 0x4fdff252UL, 0xd1bb67f1UL,
+ 0xa6bc5767UL, 0x3fb506ddUL, 0x48b2364bUL, 0xd80d2bdaUL, 0xaf0a1b4cUL,
+ 0x36034af6UL, 0x41047a60UL, 0xdf60efc3UL, 0xa867df55UL, 0x316e8eefUL,
+ 0x4669be79UL, 0xcb61b38cUL, 0xbc66831aUL, 0x256fd2a0UL, 0x5268e236UL,
+ 0xcc0c7795UL, 0xbb0b4703UL, 0x220216b9UL, 0x5505262fUL, 0xc5ba3bbeUL,
+ 0xb2bd0b28UL, 0x2bb45a92UL, 0x5cb36a04UL, 0xc2d7ffa7UL, 0xb5d0cf31UL,
+ 0x2cd99e8bUL, 0x5bdeae1dUL, 0x9b64c2b0UL, 0xec63f226UL, 0x756aa39cUL,
+ 0x026d930aUL, 0x9c0906a9UL, 0xeb0e363fUL, 0x72076785UL, 0x05005713UL,
+ 0x95bf4a82UL, 0xe2b87a14UL, 0x7bb12baeUL, 0x0cb61b38UL, 0x92d28e9bUL,
+ 0xe5d5be0dUL, 0x7cdcefb7UL, 0x0bdbdf21UL, 0x86d3d2d4UL, 0xf1d4e242UL,
+ 0x68ddb3f8UL, 0x1fda836eUL, 0x81be16cdUL, 0xf6b9265bUL, 0x6fb077e1UL,
+ 0x18b74777UL, 0x88085ae6UL, 0xff0f6a70UL, 0x66063bcaUL, 0x11010b5cUL,
+ 0x8f659effUL, 0xf862ae69UL, 0x616bffd3UL, 0x166ccf45UL, 0xa00ae278UL,
+ 0xd70dd2eeUL, 0x4e048354UL, 0x3903b3c2UL, 0xa7672661UL, 0xd06016f7UL,
+ 0x4969474dUL, 0x3e6e77dbUL, 0xaed16a4aUL, 0xd9d65adcUL, 0x40df0b66UL,
+ 0x37d83bf0UL, 0xa9bcae53UL, 0xdebb9ec5UL, 0x47b2cf7fUL, 0x30b5ffe9UL,
+ 0xbdbdf21cUL, 0xcabac28aUL, 0x53b39330UL, 0x24b4a3a6UL, 0xbad03605UL,
+ 0xcdd70693UL, 0x54de5729UL, 0x23d967bfUL, 0xb3667a2eUL, 0xc4614ab8UL,
+ 0x5d681b02UL, 0x2a6f2b94UL, 0xb40bbe37UL, 0xc30c8ea1UL, 0x5a05df1bUL,
+ 0x2d02ef8dL
+};
+
+#define crc32(crc,byte) (crc_32_tab[(u8)(crc) ^ (u8)(byte)] ^ ((crc) >> 8))
+
+#endif
+
diff --git a/SerialICE/lzf/liblzf-3.6/cs/CLZF.cs b/SerialICE/lzf/liblzf-3.6/cs/CLZF.cs
new file mode 100644
index 0000000..710419a
--- /dev/null
+++ b/SerialICE/lzf/liblzf-3.6/cs/CLZF.cs
@@ -0,0 +1,344 @@
+/*
+ * Copyright (c) 2005 Oren J. Maurice <oymaurice(a)hazorea.org.il>
+ *
+ * Redistribution and use in source and binary forms, with or without modifica-
+ * tion, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * 3. The name of the author may not be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MER-
+ * CHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPE-
+ * CIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTH-
+ * ERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * the GNU General Public License version 2 (the "GPL"), in which case the
+ * provisions of the GPL are applicable instead of the above. If you wish to
+ * allow the use of your version of this file only under the terms of the
+ * GPL and not to allow others to use your version of this file under the
+ * BSD license, indicate your decision by deleting the provisions above and
+ * replace them with the notice and other provisions required by the GPL. If
+ * you do not delete the provisions above, a recipient may use your version
+ * of this file under either the BSD or the GPL.
+ */
+
+using System;
+
+namespace LZF.NET
+{
+
+ /// <summary>
+ /// Summary description for CLZF.
+ /// </summary>
+ public class CLZF
+ {
+ // CRC32 data & function
+ UInt32 []crc_32_tab = new UInt32[256]
+ {
+ 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
+ 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
+ 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
+ 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
+ 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
+ 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
+ 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
+ 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
+ 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
+ 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
+ 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
+ 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
+ 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
+ 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
+ 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
+ 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
+ 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
+ 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
+ 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
+ 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
+ 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
+ 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
+ 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
+ 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
+ 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
+ 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
+ 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
+ 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
+ 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
+ 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
+ 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
+ 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
+ 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
+ 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
+ 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
+ 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
+ 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
+ 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
+ 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
+ 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
+ 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
+ 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
+ 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
+ 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
+ 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
+ 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
+ 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
+ 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
+ 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
+ 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
+ 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
+ 0x2d02ef8d
+ };
+
+ public UInt32 crc32(UInt32 OldCRC,byte NewData)
+ {
+ return crc_32_tab[(OldCRC & 0xff) ^ NewData] ^ (OldCRC >> 8);
+ }
+
+
+ /// <summary>
+ /// LZF Compressor
+ /// </summary>
+
+ UInt32 HLOG=14;
+ UInt32 HSIZE=(1<<14);
+
+ /*
+ * don't play with this unless you benchmark!
+ * decompression is not dependent on the hash function
+ * the hashing function might seem strange, just believe me
+ * it works ;)
+ */
+ UInt32 MAX_LIT=(1 << 5);
+ UInt32 MAX_OFF=(1 << 13);
+ UInt32 MAX_REF=((1 << 8) + (1 << 3));
+
+ UInt32 FRST(byte[] Array,UInt32 ptr)
+ {
+ return (UInt32)(((Array[ptr]) << 8) | Array[ptr+1]);
+ }
+
+ UInt32 NEXT(UInt32 v,byte[] Array,UInt32 ptr)
+ {
+ return ((v) << 8) | Array[ptr+2];
+ }
+
+ UInt32 IDX(UInt32 h)
+ {
+ return ((((h ^ (h << 5)) >> (int) (3*8 - HLOG)) - h*5) &
(HSIZE - 1));
+ }
+
+ /*
+ * compressed format
+ *
+ * 000LLLLL <L+1> ; literal
+ * LLLOOOOO oooooooo ; backref L
+ * 111OOOOO LLLLLLLL oooooooo ; backref L+7
+ *
+ */
+
+ public int lzf_compress (byte[] in_data, int in_len,byte[] out_data, int out_len)
+ {
+ int c;
+ long []htab=new long[1<<14];
+ for (c=0;c<1<<14;c++)
+ {
+ htab[c]=0;
+ }
+
+ long hslot;
+ UInt32 iidx = 0;
+ UInt32 oidx = 0;
+ //byte *in_end = ip + in_len;
+ //byte *out_end = op + out_len;
+ long reference;
+
+ UInt32 hval = FRST (in_data,iidx);
+ long off;
+ int lit = 0;
+
+ for (;;)
+ {
+ if (iidx < in_len - 2)
+ {
+ hval = NEXT (hval, in_data,iidx);
+ hslot = IDX (hval);
+ reference = htab[hslot];
+ htab[hslot] = (long)iidx;
+
+ if ((off = iidx - reference - 1) < MAX_OFF
+ && iidx + 4 < in_len
+ && reference > 0
+ && in_data[reference+0] == in_data[iidx+0]
+ && in_data[reference+1] == in_data[iidx+1]
+ && in_data[reference+2] == in_data[iidx+2]
+ )
+ {
+ /* match found at *reference++ */
+ UInt32 len = 2;
+ UInt32 maxlen = (UInt32)in_len - iidx - len;
+ maxlen = maxlen > MAX_REF ? MAX_REF : maxlen;
+
+ if (oidx + lit + 1 + 3 >= out_len)
+ return 0;
+
+ do
+ len++;
+ while (len < maxlen && in_data[reference+len] == in_data[iidx+len]);
+
+ if (lit!=0)
+ {
+ out_data[oidx++] = (byte)(lit - 1);
+ lit = -lit;
+ do
+ out_data[oidx++] = in_data[iidx+lit];
+ while ((++lit)!=0);
+ }
+
+ len -= 2;
+ iidx++;
+
+ if (len < 7)
+ {
+ out_data[oidx++] = (byte)((off >> 8) + (len << 5));
+ }
+ else
+ {
+ out_data[oidx++] = (byte)((off >> 8) + ( 7 << 5));
+ out_data[oidx++] = (byte)(len - 7);
+ }
+
+ out_data[oidx++] = (byte)off;
+
+ iidx += len-1;
+ hval = FRST (in_data,iidx);
+
+ hval = NEXT (hval,in_data, iidx);
+ htab[IDX (hval)] = iidx;
+ iidx++;
+
+ hval = NEXT (hval, in_data,iidx);
+ htab[IDX (hval)] = iidx;
+ iidx++;
+ continue;
+ }
+ }
+ else if (iidx == in_len)
+ break;
+
+ /* one more literal byte we must copy */
+ lit++;
+ iidx++;
+
+ if (lit == MAX_LIT)
+ {
+ if (oidx + 1 + MAX_LIT >= out_len)
+ return 0;
+
+ out_data[oidx++] = (byte)(MAX_LIT - 1);
+ lit = -lit;
+ do
+ out_data[oidx++] = in_data[iidx+lit];
+ while ((++lit)!=0);
+ }
+ }
+
+ if (lit!=0)
+ {
+ if (oidx + lit + 1 >= out_len)
+ return 0;
+
+ out_data[oidx++] = (byte)(lit - 1);
+ lit = -lit;
+ do
+ out_data[oidx++] = in_data[iidx+lit];
+ while ((++lit)!=0);
+ }
+
+ return (int)oidx;
+ }
+
+ /// <summary>
+ /// LZF Decompressor
+ /// </summary>
+ public int lzf_decompress ( byte[] in_data, int in_len, byte[] out_data, int out_len)
+ {
+ UInt32 iidx=0;
+ UInt32 oidx=0;
+
+ do
+ {
+ UInt32 ctrl = in_data[iidx++];
+
+ if (ctrl < (1 << 5)) /* literal run */
+ {
+ ctrl++;
+
+ if (oidx + ctrl > out_len)
+ {
+ //SET_ERRNO (E2BIG);
+ return 0;
+ }
+
+ do
+ out_data[oidx++] = in_data[iidx++];
+ while ((--ctrl)!=0);
+ }
+ else /* back reference */
+ {
+ UInt32 len = ctrl >> 5;
+
+ int reference = (int)(oidx - ((ctrl & 0x1f) << 8) - 1);
+
+ if (len == 7)
+ len += in_data[iidx++];
+
+ reference -= in_data[iidx++];
+
+ if (oidx + len + 2 > out_len)
+ {
+ //SET_ERRNO (E2BIG);
+ return 0;
+ }
+
+ if (reference < 0)
+ {
+ //SET_ERRNO (EINVAL);
+ return 0;
+ }
+
+ out_data[oidx++]=out_data[reference++];
+ out_data[oidx++]=out_data[reference++];
+
+ do
+ out_data[oidx++]=out_data[reference++];
+ while ((--len)!=0);
+ }
+ }
+ while (iidx < in_len);
+
+ return (int)oidx;
+ }
+
+ public CLZF()
+ {
+ //
+ // TODO: Add ructor logic here
+ //
+ }
+ }
+}
+
diff --git a/SerialICE/lzf/liblzf-3.6/cs/README b/SerialICE/lzf/liblzf-3.6/cs/README
new file mode 100644
index 0000000..9964aff
--- /dev/null
+++ b/SerialICE/lzf/liblzf-3.6/cs/README
@@ -0,0 +1,7 @@
+The C♯ implementation of the LZF en-/decoder functions in this
+directory was written (and is maintained) by
+
+ Oren J. Maurice <oymaurice(a)hazorea.org.il>il>.
+
+If you have any questions or improvements, you should contact the
+original author (and maybe CC me, Marc Lehmann <liblzf(a)schmorp.de>)e>).
diff --git a/SerialICE/lzf/liblzf-3.6/lzf.c b/SerialICE/lzf/liblzf-3.6/lzf.c
new file mode 100644
index 0000000..bedfdb6
--- /dev/null
+++ b/SerialICE/lzf/liblzf-3.6/lzf.c
@@ -0,0 +1,537 @@
+/*
+ * Copyright (c) 2006 Stefan Traby <stefan(a)hello-penguin.com>
+ *
+ * Redistribution and use in source and binary forms, with or without modifica-
+ * tion, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MER-
+ * CHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPE-
+ * CIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTH-
+ * ERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * the GNU General Public License ("GPL") version 2 or any later version,
+ * in which case the provisions of the GPL are applicable instead of
+ * the above. If you wish to allow the use of your version of this file
+ * only under the terms of the GPL and not to allow others to use your
+ * version of this file under the BSD license, indicate your decision
+ * by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL. If you do not delete the
+ * provisions above, a recipient may use your version of this file under
+ * either the BSD or the GPL.
+ */
+
+#include "config.h"
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <limits.h>
+#include "lzf.h"
+
+#ifdef HAVE_GETOPT_H
+# include <getopt.h>
+#endif
+
+#define BLOCKSIZE (1024 * 64 - 1)
+#define MAX_BLOCKSIZE BLOCKSIZE
+
+typedef unsigned char u8;
+
+static off_t nr_read, nr_written;
+
+static const char *imagename;
+static enum { compress, uncompress, lzcat } mode = compress;
+static int verbose = 0;
+static int force = 0;
+static long blocksize = BLOCKSIZE;
+
+#ifdef HAVE_GETOPT_LONG
+
+ struct option longopts[] = {
+ {"compress", 0, 0, 'c'},
+ {"decompress", 0, 0, 'd'},
+ {"uncompress", 0, 0, 'd'},
+ {"force", 0, 0, 'f'},
+ {"help", 0, 0, 'h'},
+ {"verbose", 0, 0, 'v'},
+ {"blocksize", 1, 0, 'b'},
+ {0, 0, 0, 0}
+ };
+
+ static const char *opt =
+ "-c --compress compress\n"
+ "-d --decompress decompress\n"
+ "-f --force force overwrite of output file\n"
+ "-h --help give this help\n" "-v --verbose verbose
mode\n" "-b # --blocksize # set blocksize\n" "\n";
+
+#else
+
+ static const char *opt =
+ "-c compress\n"
+ "-d decompress\n"
+ "-f force overwrite of output file\n"
+ "-h give this help\n"
+ "-v verbose mode\n"
+ "-b # set blocksize\n"
+ "\n";
+
+#endif
+
+static void
+usage (int rc)
+{
+ fprintf (stderr, "\n"
+ "lzf, a very lightweight compression/decompression utility written by
Stefan Traby.\n"
+ "uses liblzf written by Marc Lehmann <schmorp(a)schmorp.de> You can
find more info at\n"
+ "http://liblzf.plan9.de/\n"
+ "\n"
+ "usage: lzf [-dufhvb] [file ...]\n"
+ " unlzf [file ...]\n"
+ " lzcat [file ...]\n"
+ "\n%s",
+ opt);
+
+ exit (rc);
+}
+
+static inline ssize_t
+rread (int fd, void *buf, size_t len)
+{
+ ssize_t rc = 0, offset = 0;
+ char *p = buf;
+
+ while (len && (rc = read (fd, &p[offset], len)) > 0)
+ {
+ offset += rc;
+ len -= rc;
+ }
+
+ nr_read += offset;
+
+ if (rc < 0)
+ return rc;
+
+ return offset;
+}
+
+/* returns 0 if all written else -1 */
+static inline ssize_t
+wwrite (int fd, void *buf, size_t len)
+{
+ ssize_t rc;
+ char *b = buf;
+ size_t l = len;
+
+ while (l)
+ {
+ rc = write (fd, b, l);
+ if (rc < 0)
+ {
+ fprintf (stderr, "%s: write error: ", imagename);
+ perror ("");
+ return -1;
+ }
+
+ l -= rc;
+ b += rc;
+ }
+
+ nr_written += len;
+ return 0;
+}
+
+/*
+ * Anatomy: an lzf file consists of any number of blocks in the following format:
+ *
+ * \x00 EOF (optional)
+ * "ZV\0" 2-byte-usize <uncompressed data>
+ * "ZV\1" 2-byte-csize 2-byte-usize <compressed data>
+ * "ZV\2" 4-byte-crc32-0xdebb20e3 (NYI)
+ */
+
+
+#define TYPE0_HDR_SIZE 5
+#define TYPE1_HDR_SIZE 7
+#define MAX_HDR_SIZE 7
+#define MIN_HDR_SIZE 5
+
+static int
+compress_fd (int from, int to)
+{
+ ssize_t us, cs, len;
+ u8 buf1[MAX_BLOCKSIZE + MAX_HDR_SIZE + 16];
+ u8 buf2[MAX_BLOCKSIZE + MAX_HDR_SIZE + 16];
+ u8 *header;
+
+ nr_read = nr_written = 0;
+ while ((us = rread (from, &buf1[MAX_HDR_SIZE], blocksize)) > 0)
+ {
+ cs = lzf_compress (&buf1[MAX_HDR_SIZE], us, &buf2[MAX_HDR_SIZE], us > 4
? us - 4 : us);
+ if (cs)
+ {
+ header = &buf2[MAX_HDR_SIZE - TYPE1_HDR_SIZE];
+ header[0] = 'Z';
+ header[1] = 'V';
+ header[2] = 1;
+ header[3] = cs >> 8;
+ header[4] = cs & 0xff;
+ header[5] = us >> 8;
+ header[6] = us & 0xff;
+ len = cs + TYPE1_HDR_SIZE;
+ }
+ else
+ { // write uncompressed
+ header = &buf1[MAX_HDR_SIZE - TYPE0_HDR_SIZE];
+ header[0] = 'Z';
+ header[1] = 'V';
+ header[2] = 0;
+ header[3] = us >> 8;
+ header[4] = us & 0xff;
+ len = us + TYPE0_HDR_SIZE;
+ }
+
+ if (wwrite (to, header, len) == -1)
+ return -1;
+ }
+
+ return 0;
+}
+
+static int
+uncompress_fd (int from, int to)
+{
+ u8 header[MAX_HDR_SIZE];
+ u8 buf1[MAX_BLOCKSIZE + MAX_HDR_SIZE + 16];
+ u8 buf2[MAX_BLOCKSIZE + MAX_HDR_SIZE + 16];
+ u8 *p;
+ int l, rd;
+ ssize_t rc, cs, us, bytes, over = 0;
+
+ nr_read = nr_written = 0;
+ while (1)
+ {
+ rc = rread (from, header + over, MAX_HDR_SIZE - over);
+ if (rc < 0)
+ {
+ fprintf (stderr, "%s: read error: ", imagename);
+ perror ("");
+ return -1;
+ }
+
+ rc += over;
+ over = 0;
+ if (!rc || header[0] == 0)
+ return 0;
+
+ if (rc < MIN_HDR_SIZE || header[0] != 'Z' || header[1] != 'V')
+ {
+ fprintf (stderr, "%s: invalid data stream - magic not found or short
header\n", imagename);
+ return -1;
+ }
+
+ switch (header[2])
+ {
+ case 0:
+ cs = -1;
+ us = (header[3] << 8) | header[4];
+ p = &header[TYPE0_HDR_SIZE];
+ break;
+ case 1:
+ if (rc < TYPE1_HDR_SIZE)
+ {
+ goto short_read;
+ }
+ cs = (header[3] << 8) | header[4];
+ us = (header[5] << 8) | header[6];
+ p = &header[TYPE1_HDR_SIZE];
+ break;
+ default:
+ fprintf (stderr, "%s: unknown blocktype\n", imagename);
+ return -1;
+ }
+
+ bytes = cs == -1 ? us : cs;
+ l = &header[rc] - p;
+
+ if (l > 0)
+ memcpy (buf1, p, l);
+
+ if (l > bytes)
+ {
+ over = l - bytes;
+ memmove (header, &p[bytes], over);
+ }
+
+ p = &buf1[l];
+ rd = bytes - l;
+ if (rd > 0)
+ if ((rc = rread (from, p, rd)) != rd)
+ goto short_read;
+
+ if (cs == -1)
+ {
+ if (wwrite (to, buf1, us))
+ return -1;
+ }
+ else
+ {
+ if (lzf_decompress (buf1, cs, buf2, us) != us)
+ {
+ fprintf (stderr, "%s: decompress: invalid stream - data
corrupted\n", imagename);
+ return -1;
+ }
+
+ if (wwrite (to, buf2, us))
+ return -1;
+ }
+ }
+
+ return 0;
+
+short_read:
+ fprintf (stderr, "%s: short data\n", imagename);
+ return -1;
+}
+
+static int
+open_out (const char *name)
+{
+ int fd;
+ int m = O_EXCL;
+
+ if (force)
+ m = 0;
+
+ fd = open (name, O_CREAT | O_WRONLY | O_TRUNC | m, 600);
+#if defined(__MINGW32__)
+ _setmode(fd, _O_BINARY);
+#endif
+ return fd;
+}
+
+static int
+compose_name (const char *fname, char *oname)
+{
+ char *p;
+
+ if (mode == compress)
+ {
+ if (strlen (fname) > PATH_MAX - 4)
+ {
+ fprintf (stderr, "%s: %s.lzf: name too long", imagename, fname);
+ return -1;
+ }
+
+ strcpy (oname, fname);
+ strcat (oname, ".lzf");
+ }
+ else
+ {
+ if (strlen (fname) > PATH_MAX)
+ {
+ fprintf (stderr, "%s: %s: name too long\n", imagename, fname);
+ return -1;
+ }
+
+ strcpy (oname, fname);
+ p = &oname[strlen (oname)] - 4;
+ if (p < oname || strcmp (p, ".lzf"))
+ {
+ fprintf (stderr, "%s: %s: unknown suffix\n", imagename, fname);
+ return -1;
+ }
+
+ *p = 0;
+ }
+
+ return 0;
+}
+
+static int
+run_file (const char *fname)
+{
+ int fd, fd2;
+ int rc;
+ struct stat mystat;
+ char oname[PATH_MAX + 1];
+
+ if (mode != lzcat)
+ if (compose_name (fname, oname))
+ return -1;
+
+#if !defined(__MINGW32__)
+ rc = lstat (fname, &mystat);
+#else
+ rc = stat (fname, &mystat);
+#endif
+ fd = open (fname, O_RDONLY);
+#if defined(__MINGW32__)
+ _setmode(fd, _O_BINARY);
+#endif
+ if (rc || fd == -1)
+ {
+ fprintf (stderr, "%s: %s: ", imagename, fname);
+ perror ("");
+ return -1;
+ }
+
+ if (!S_ISREG (mystat.st_mode))
+ {
+ fprintf (stderr, "%s: %s: not a regular file.\n", imagename, fname);
+ close (fd);
+ return -1;
+ }
+
+ if (mode == lzcat)
+ {
+ rc = uncompress_fd (fd, 1);
+ close (fd);
+ return rc;
+ }
+
+ fd2 = open_out (oname);
+ if (fd2 == -1)
+ {
+ fprintf (stderr, "%s: %s: ", imagename, oname);
+ perror ("");
+ close (fd);
+ return -1;
+ }
+
+ if (mode == compress)
+ {
+ rc = compress_fd (fd, fd2);
+ if (!rc && verbose)
+ fprintf (stderr, "%s: %5.1f%% -- replaced with %s\n",
+ fname, nr_read == 0 ? 0 : 100.0 - nr_written / ((double) nr_read /
100.0), oname);
+ }
+ else
+ {
+ rc = uncompress_fd (fd, fd2);
+ if (!rc && verbose)
+ fprintf (stderr, "%s: %5.1f%% -- replaced with %s\n",
+ fname, nr_written == 0 ? 0 : 100.0 - nr_read / ((double) nr_written /
100.0), oname);
+ }
+
+#if !defined(__MINGW32__)
+ fchmod (fd2, mystat.st_mode);
+#else
+ chmod (oname, mystat.st_mode);
+#endif
+ close (fd);
+ close (fd2);
+
+ if (!rc)
+ unlink (fname);
+
+ return rc;
+}
+
+int
+main (int argc, char *argv[])
+{
+ char *p = argv[0];
+ int optc;
+ int rc = 0;
+
+ errno = 0;
+ p = getenv ("LZF_BLOCKSIZE");
+ if (p)
+ {
+ blocksize = strtoul (p, 0, 0);
+ if (errno || !blocksize || blocksize > MAX_BLOCKSIZE)
+ blocksize = BLOCKSIZE;
+ }
+
+ p = strrchr (argv[0], '/');
+ imagename = p ? ++p : argv[0];
+
+ if (!strncmp (imagename, "un", 2) || !strncmp (imagename, "de",
2))
+ mode = uncompress;
+
+ if (strstr (imagename, "cat"))
+ mode = lzcat;
+
+#ifdef HAVE_GETOPT_LONG
+ while ((optc = getopt_long (argc, argv, "cdfhvb:", longopts, 0)) != -1)
+#else
+ while ((optc = getopt (argc, argv, "cdfhvb:")) != -1)
+#endif
+ {
+ switch (optc)
+ {
+ case 'c':
+ mode = compress;
+ break;
+ case 'd':
+ mode = uncompress;
+ break;
+ case 'f':
+ force = 1;
+ break;
+ case 'h':
+ usage (0);
+ break;
+ case 'v':
+ verbose = 1;
+ break;
+ case 'b':
+ errno = 0;
+ blocksize = strtoul (optarg, 0, 0);
+ if (errno || !blocksize || blocksize > MAX_BLOCKSIZE)
+ blocksize = BLOCKSIZE;
+ break;
+ default:
+ usage (1);
+ break;
+ }
+ }
+
+ if (optind == argc)
+ { // stdin stdout
+ if (!force)
+ {
+ if ((mode == uncompress || mode == lzcat) && isatty (0))
+ {
+ fprintf (stderr, "%s: compressed data not read from a terminal. Use -f
to force decompression.\n", imagename);
+ exit (1);
+ }
+ if (mode == compress && isatty (1))
+ {
+ fprintf (stderr, "%s: compressed data not written to a terminal. Use
-f to force compression.\n", imagename);
+ exit (1);
+ }
+ }
+
+ if (mode == compress)
+ rc = compress_fd (0, 1);
+ else
+ rc = uncompress_fd (0, 1);
+
+ exit (rc ? 1 : 0);
+ }
+
+ while (optind < argc)
+ rc |= run_file (argv[optind++]);
+
+ exit (rc ? 1 : 0);
+}
+
diff --git a/SerialICE/lzf/liblzf-3.6/lzf.h b/SerialICE/lzf/liblzf-3.6/lzf.h
new file mode 100644
index 0000000..919b6e6
--- /dev/null
+++ b/SerialICE/lzf/liblzf-3.6/lzf.h
@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) 2000-2008 Marc Alexander Lehmann <schmorp(a)schmorp.de>
+ *
+ * Redistribution and use in source and binary forms, with or without modifica-
+ * tion, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MER-
+ * CHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPE-
+ * CIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTH-
+ * ERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * the GNU General Public License ("GPL") version 2 or any later version,
+ * in which case the provisions of the GPL are applicable instead of
+ * the above. If you wish to allow the use of your version of this file
+ * only under the terms of the GPL and not to allow others to use your
+ * version of this file under the BSD license, indicate your decision
+ * by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL. If you do not delete the
+ * provisions above, a recipient may use your version of this file under
+ * either the BSD or the GPL.
+ */
+
+#ifndef LZF_H
+#define LZF_H
+
+/***********************************************************************
+**
+** lzf -- an extremely fast/free compression/decompression-method
+** http://liblzf.plan9.de/
+**
+** This algorithm is believed to be patent-free.
+**
+***********************************************************************/
+
+#define LZF_VERSION 0x0105 /* 1.5, API version */
+
+/*
+ * Compress in_len bytes stored at the memory block starting at
+ * in_data and write the result to out_data, up to a maximum length
+ * of out_len bytes.
+ *
+ * If the output buffer is not large enough or any error occurs return 0,
+ * otherwise return the number of bytes used, which might be considerably
+ * more than in_len (but less than 104% of the original size), so it
+ * makes sense to always use out_len == in_len - 1), to ensure _some_
+ * compression, and store the data uncompressed otherwise (with a flag, of
+ * course.
+ *
+ * lzf_compress might use different algorithms on different systems and
+ * even different runs, thus might result in different compressed strings
+ * depending on the phase of the moon or similar factors. However, all
+ * these strings are architecture-independent and will result in the
+ * original data when decompressed using lzf_decompress.
+ *
+ * The buffers must not be overlapping.
+ *
+ * If the option LZF_STATE_ARG is enabled, an extra argument must be
+ * supplied which is not reflected in this header file. Refer to lzfP.h
+ * and lzf_c.c.
+ *
+ */
+unsigned int
+lzf_compress (const void *const in_data, unsigned int in_len,
+ void *out_data, unsigned int out_len);
+
+/*
+ * Decompress data compressed with some version of the lzf_compress
+ * function and stored at location in_data and length in_len. The result
+ * will be stored at out_data up to a maximum of out_len characters.
+ *
+ * If the output buffer is not large enough to hold the decompressed
+ * data, a 0 is returned and errno is set to E2BIG. Otherwise the number
+ * of decompressed bytes (i.e. the original length of the data) is
+ * returned.
+ *
+ * If an error in the compressed data is detected, a zero is returned and
+ * errno is set to EINVAL.
+ *
+ * This function is very fast, about as fast as a copying loop.
+ */
+unsigned int
+lzf_decompress (const void *const in_data, unsigned int in_len,
+ void *out_data, unsigned int out_len);
+
+#endif
+
diff --git a/SerialICE/lzf/liblzf-3.6/lzfP.h b/SerialICE/lzf/liblzf-3.6/lzfP.h
new file mode 100644
index 0000000..7b7feda
--- /dev/null
+++ b/SerialICE/lzf/liblzf-3.6/lzfP.h
@@ -0,0 +1,185 @@
+/*
+ * Copyright (c) 2000-2007 Marc Alexander Lehmann <schmorp(a)schmorp.de>
+ *
+ * Redistribution and use in source and binary forms, with or without modifica-
+ * tion, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MER-
+ * CHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPE-
+ * CIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTH-
+ * ERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * the GNU General Public License ("GPL") version 2 or any later version,
+ * in which case the provisions of the GPL are applicable instead of
+ * the above. If you wish to allow the use of your version of this file
+ * only under the terms of the GPL and not to allow others to use your
+ * version of this file under the BSD license, indicate your decision
+ * by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL. If you do not delete the
+ * provisions above, a recipient may use your version of this file under
+ * either the BSD or the GPL.
+ */
+
+#ifndef LZFP_h
+#define LZFP_h
+
+#define STANDALONE 1 /* at the moment, this is ok. */
+
+#ifndef STANDALONE
+# include "lzf.h"
+#endif
+
+/*
+ * Size of hashtable is (1 << HLOG) * sizeof (char *)
+ * decompression is independent of the hash table size
+ * the difference between 15 and 14 is very small
+ * for small blocks (and 14 is usually a bit faster).
+ * For a low-memory/faster configuration, use HLOG == 13;
+ * For best compression, use 15 or 16 (or more, up to 22).
+ */
+#ifndef HLOG
+# define HLOG 16
+#endif
+
+/*
+ * Sacrifice very little compression quality in favour of compression speed.
+ * This gives almost the same compression as the default code, and is
+ * (very roughly) 15% faster. This is the preferred mode of operation.
+ */
+#ifndef VERY_FAST
+# define VERY_FAST 1
+#endif
+
+/*
+ * Sacrifice some more compression quality in favour of compression speed.
+ * (roughly 1-2% worse compression for large blocks and
+ * 9-10% for small, redundant, blocks and >>20% better speed in both cases)
+ * In short: when in need for speed, enable this for binary data,
+ * possibly disable this for text data.
+ */
+#ifndef ULTRA_FAST
+# define ULTRA_FAST 0
+#endif
+
+/*
+ * Unconditionally aligning does not cost very much, so do it if unsure
+ */
+#ifndef STRICT_ALIGN
+# define STRICT_ALIGN !(defined(__i386) || defined (__amd64))
+#endif
+
+/*
+ * You may choose to pre-set the hash table (might be faster on some
+ * modern cpus and large (>>64k) blocks, and also makes compression
+ * deterministic/repeatable when the configuration otherwise is the same).
+ */
+#ifndef INIT_HTAB
+# define INIT_HTAB 0
+#endif
+
+/*
+ * Avoid assigning values to errno variable? for some embedding purposes
+ * (linux kernel for example), this is necessary. NOTE: this breaks
+ * the documentation in lzf.h. Avoiding errno has no speed impact.
+ */
+#ifndef AVOID_ERRNO
+# define AVOID_ERRNO 0
+#endif
+
+/*
+ * Whether to pass the LZF_STATE variable as argument, or allocate it
+ * on the stack. For small-stack environments, define this to 1.
+ * NOTE: this breaks the prototype in lzf.h.
+ */
+#ifndef LZF_STATE_ARG
+# define LZF_STATE_ARG 0
+#endif
+
+/*
+ * Whether to add extra checks for input validity in lzf_decompress
+ * and return EINVAL if the input stream has been corrupted. This
+ * only shields against overflowing the input buffer and will not
+ * detect most corrupted streams.
+ * This check is not normally noticeable on modern hardware
+ * (<1% slowdown), but might slow down older cpus considerably.
+ */
+#ifndef CHECK_INPUT
+# define CHECK_INPUT 1
+#endif
+
+/*
+ * Whether to store pointers or offsets inside the hash table. On
+ * 64 bit architetcures, pointers take up twice as much space,
+ * and might also be slower. Default is to autodetect.
+ */
+/*#define LZF_USER_OFFSETS autodetect */
+
+/*****************************************************************************/
+/* nothing should be changed below */
+
+#ifdef __cplusplus
+# include <cstring>
+# include <climits>
+using namespace std;
+#else
+# include <string.h>
+# include <limits.h>
+#endif
+
+#ifndef LZF_USE_OFFSETS
+# if defined (WIN32)
+# define LZF_USE_OFFSETS defined(_M_X64)
+# else
+# if __cplusplus > 199711L
+# include <cstdint>
+# else
+# include <stdint.h>
+# endif
+# define LZF_USE_OFFSETS (UINTPTR_MAX > 0xffffffffU)
+# endif
+#endif
+
+typedef unsigned char u8;
+
+#if LZF_USE_OFFSETS
+# define LZF_HSLOT_BIAS ((const u8 *)in_data)
+ typedef unsigned int LZF_HSLOT;
+#else
+# define LZF_HSLOT_BIAS 0
+ typedef const u8 *LZF_HSLOT;
+#endif
+
+typedef LZF_HSLOT LZF_STATE[1 << (HLOG)];
+
+#if !STRICT_ALIGN
+/* for unaligned accesses we need a 16 bit datatype. */
+# if USHRT_MAX == 65535
+ typedef unsigned short u16;
+# elif UINT_MAX == 65535
+ typedef unsigned int u16;
+# else
+# undef STRICT_ALIGN
+# define STRICT_ALIGN 1
+# endif
+#endif
+
+#if ULTRA_FAST
+# undef VERY_FAST
+#endif
+
+#endif
+
diff --git a/SerialICE/lzf/liblzf-3.6/lzf_c.c b/SerialICE/lzf/liblzf-3.6/lzf_c.c
new file mode 100644
index 0000000..bc07084
--- /dev/null
+++ b/SerialICE/lzf/liblzf-3.6/lzf_c.c
@@ -0,0 +1,291 @@
+/*
+ * Copyright (c) 2000-2010 Marc Alexander Lehmann <schmorp(a)schmorp.de>
+ *
+ * Redistribution and use in source and binary forms, with or without modifica-
+ * tion, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MER-
+ * CHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPE-
+ * CIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTH-
+ * ERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * the GNU General Public License ("GPL") version 2 or any later version,
+ * in which case the provisions of the GPL are applicable instead of
+ * the above. If you wish to allow the use of your version of this file
+ * only under the terms of the GPL and not to allow others to use your
+ * version of this file under the BSD license, indicate your decision
+ * by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL. If you do not delete the
+ * provisions above, a recipient may use your version of this file under
+ * either the BSD or the GPL.
+ */
+
+#include "lzfP.h"
+
+#define HSIZE (1 << (HLOG))
+
+/*
+ * don't play with this unless you benchmark!
+ * the data format is not dependent on the hash function.
+ * the hash function might seem strange, just believe me,
+ * it works ;)
+ */
+#ifndef FRST
+# define FRST(p) (((p[0]) << 8) | p[1])
+# define NEXT(v,p) (((v) << 8) | p[2])
+# if ULTRA_FAST
+# define IDX(h) ((( h >> (3*8 - HLOG)) - h ) & (HSIZE - 1))
+# elif VERY_FAST
+# define IDX(h) ((( h >> (3*8 - HLOG)) - h*5) & (HSIZE - 1))
+# else
+# define IDX(h) ((((h ^ (h << 5)) >> (3*8 - HLOG)) - h*5) & (HSIZE -
1))
+# endif
+#endif
+/*
+ * IDX works because it is very similar to a multiplicative hash, e.g.
+ * ((h * 57321 >> (3*8 - HLOG)) & (HSIZE - 1))
+ * the latter is also quite fast on newer CPUs, and compresses similarly.
+ *
+ * the next one is also quite good, albeit slow ;)
+ * (int)(cos(h & 0xffffff) * 1e6)
+ */
+
+#if 0
+/* original lzv-like hash function, much worse and thus slower */
+# define FRST(p) (p[0] << 5) ^ p[1]
+# define NEXT(v,p) ((v) << 5) ^ p[2]
+# define IDX(h) ((h) & (HSIZE - 1))
+#endif
+
+#define MAX_LIT (1 << 5)
+#define MAX_OFF (1 << 13)
+#define MAX_REF ((1 << 8) + (1 << 3))
+
+#if __GNUC__ >= 3
+# define expect(expr,value) __builtin_expect ((expr),(value))
+# define inline inline
+#else
+# define expect(expr,value) (expr)
+# define inline static
+#endif
+
+#define expect_false(expr) expect ((expr) != 0, 0)
+#define expect_true(expr) expect ((expr) != 0, 1)
+
+/*
+ * compressed format
+ *
+ * 000LLLLL <L+1> ; literal, L+1=1..33 octets
+ * LLLooooo oooooooo ; backref L+1=1..7 octets, o+1=1..4096 offset
+ * 111ooooo LLLLLLLL oooooooo ; backref L+8 octets, o+1=1..4096 offset
+ *
+ */
+
+unsigned int
+lzf_compress (const void *const in_data, unsigned int in_len,
+ void *out_data, unsigned int out_len
+#if LZF_STATE_ARG
+ , LZF_STATE htab
+#endif
+ )
+{
+#if !LZF_STATE_ARG
+ LZF_STATE htab;
+#endif
+ const u8 *ip = (const u8 *)in_data;
+ u8 *op = (u8 *)out_data;
+ const u8 *in_end = ip + in_len;
+ u8 *out_end = op + out_len;
+ const u8 *ref;
+
+ /* off requires a type wide enough to hold a general pointer difference.
+ * ISO C doesn't have that (size_t might not be enough and ptrdiff_t only
+ * works for differences within a single object). We also assume that no
+ * no bit pattern traps. Since the only platform that is both non-POSIX
+ * and fails to support both assumptions is windows 64 bit, we make a
+ * special workaround for it.
+ */
+#if defined (WIN32) && defined (_M_X64)
+ unsigned _int64 off; /* workaround for missing POSIX compliance */
+#else
+ unsigned long off;
+#endif
+ unsigned int hval;
+ int lit;
+
+ if (!in_len || !out_len)
+ return 0;
+
+#if INIT_HTAB
+ memset (htab, 0, sizeof (htab));
+#endif
+
+ lit = 0; op++; /* start run */
+
+ hval = FRST (ip);
+ while (ip < in_end - 2)
+ {
+ LZF_HSLOT *hslot;
+
+ hval = NEXT (hval, ip);
+ hslot = htab + IDX (hval);
+ ref = *hslot + LZF_HSLOT_BIAS; *hslot = ip - LZF_HSLOT_BIAS;
+
+ if (1
+#if INIT_HTAB
+ && ref < ip /* the next test will actually take care of this, but
this is faster */
+#endif
+ && (off = ip - ref - 1) < MAX_OFF
+ && ref > (u8 *)in_data
+ && ref[2] == ip[2]
+#if STRICT_ALIGN
+ && ((ref[1] << 8) | ref[0]) == ((ip[1] << 8) | ip[0])
+#else
+ && *(u16 *)ref == *(u16 *)ip
+#endif
+ )
+ {
+ /* match found at *ref++ */
+ unsigned int len = 2;
+ unsigned int maxlen = in_end - ip - len;
+ maxlen = maxlen > MAX_REF ? MAX_REF : maxlen;
+
+ if (expect_false (op + 3 + 1 >= out_end)) /* first a faster conservative
test */
+ if (op - !lit + 3 + 1 >= out_end) /* second the exact but rare test */
+ return 0;
+
+ op [- lit - 1] = lit - 1; /* stop run */
+ op -= !lit; /* undo run if length is zero */
+
+ for (;;)
+ {
+ if (expect_true (maxlen > 16))
+ {
+ len++; if (ref [len] != ip [len]) break;
+ len++; if (ref [len] != ip [len]) break;
+ len++; if (ref [len] != ip [len]) break;
+ len++; if (ref [len] != ip [len]) break;
+
+ len++; if (ref [len] != ip [len]) break;
+ len++; if (ref [len] != ip [len]) break;
+ len++; if (ref [len] != ip [len]) break;
+ len++; if (ref [len] != ip [len]) break;
+
+ len++; if (ref [len] != ip [len]) break;
+ len++; if (ref [len] != ip [len]) break;
+ len++; if (ref [len] != ip [len]) break;
+ len++; if (ref [len] != ip [len]) break;
+
+ len++; if (ref [len] != ip [len]) break;
+ len++; if (ref [len] != ip [len]) break;
+ len++; if (ref [len] != ip [len]) break;
+ len++; if (ref [len] != ip [len]) break;
+ }
+
+ do
+ len++;
+ while (len < maxlen && ref[len] == ip[len]);
+
+ break;
+ }
+
+ len -= 2; /* len is now #octets - 1 */
+ ip++;
+
+ if (len < 7)
+ {
+ *op++ = (off >> 8) + (len << 5);
+ }
+ else
+ {
+ *op++ = (off >> 8) + ( 7 << 5);
+ *op++ = len - 7;
+ }
+
+ *op++ = off;
+
+ lit = 0; op++; /* start run */
+
+ ip += len + 1;
+
+ if (expect_false (ip >= in_end - 2))
+ break;
+
+#if ULTRA_FAST || VERY_FAST
+ --ip;
+# if VERY_FAST && !ULTRA_FAST
+ --ip;
+# endif
+ hval = FRST (ip);
+
+ hval = NEXT (hval, ip);
+ htab[IDX (hval)] = ip - LZF_HSLOT_BIAS;
+ ip++;
+
+# if VERY_FAST && !ULTRA_FAST
+ hval = NEXT (hval, ip);
+ htab[IDX (hval)] = ip - LZF_HSLOT_BIAS;
+ ip++;
+# endif
+#else
+ ip -= len + 1;
+
+ do
+ {
+ hval = NEXT (hval, ip);
+ htab[IDX (hval)] = ip - LZF_HSLOT_BIAS;
+ ip++;
+ }
+ while (len--);
+#endif
+ }
+ else
+ {
+ /* one more literal byte we must copy */
+ if (expect_false (op >= out_end))
+ return 0;
+
+ lit++; *op++ = *ip++;
+
+ if (expect_false (lit == MAX_LIT))
+ {
+ op [- lit - 1] = lit - 1; /* stop run */
+ lit = 0; op++; /* start run */
+ }
+ }
+ }
+
+ if (op + 3 > out_end) /* at most 3 bytes can be missing here */
+ return 0;
+
+ while (ip < in_end)
+ {
+ lit++; *op++ = *ip++;
+
+ if (expect_false (lit == MAX_LIT))
+ {
+ op [- lit - 1] = lit - 1; /* stop run */
+ lit = 0; op++; /* start run */
+ }
+ }
+
+ op [- lit - 1] = lit - 1; /* end run */
+ op -= !lit; /* undo run if length is zero */
+
+ return op - (u8 *)out_data;
+}
+
diff --git a/SerialICE/lzf/liblzf-3.6/lzf_d.c b/SerialICE/lzf/liblzf-3.6/lzf_d.c
new file mode 100644
index 0000000..8433b8f
--- /dev/null
+++ b/SerialICE/lzf/liblzf-3.6/lzf_d.c
@@ -0,0 +1,185 @@
+/*
+ * Copyright (c) 2000-2010 Marc Alexander Lehmann <schmorp(a)schmorp.de>
+ *
+ * Redistribution and use in source and binary forms, with or without modifica-
+ * tion, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MER-
+ * CHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPE-
+ * CIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTH-
+ * ERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * the GNU General Public License ("GPL") version 2 or any later version,
+ * in which case the provisions of the GPL are applicable instead of
+ * the above. If you wish to allow the use of your version of this file
+ * only under the terms of the GPL and not to allow others to use your
+ * version of this file under the BSD license, indicate your decision
+ * by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL. If you do not delete the
+ * provisions above, a recipient may use your version of this file under
+ * either the BSD or the GPL.
+ */
+
+#include "lzfP.h"
+
+#if AVOID_ERRNO
+# define SET_ERRNO(n)
+#else
+# include <errno.h>
+# define SET_ERRNO(n) errno = (n)
+#endif
+
+#if USE_REP_MOVSB /* small win on amd, big loss on intel */
+#if (__i386 || __amd64) && __GNUC__ >= 3
+# define lzf_movsb(dst, src, len) \
+ asm ("rep movsb" \
+ : "=D" (dst), "=S" (src), "=c" (len) \
+ : "0" (dst), "1" (src), "2" (len));
+#endif
+#endif
+
+unsigned int
+lzf_decompress (const void *const in_data, unsigned int in_len,
+ void *out_data, unsigned int out_len)
+{
+ u8 const *ip = (const u8 *)in_data;
+ u8 *op = (u8 *)out_data;
+ u8 const *const in_end = ip + in_len;
+ u8 *const out_end = op + out_len;
+
+ do
+ {
+ unsigned int ctrl = *ip++;
+
+ if (ctrl < (1 << 5)) /* literal run */
+ {
+ ctrl++;
+
+ if (op + ctrl > out_end)
+ {
+ SET_ERRNO (E2BIG);
+ return 0;
+ }
+
+#if CHECK_INPUT
+ if (ip + ctrl > in_end)
+ {
+ SET_ERRNO (EINVAL);
+ return 0;
+ }
+#endif
+
+#ifdef lzf_movsb
+ lzf_movsb (op, ip, ctrl);
+#else
+ switch (ctrl)
+ {
+ case 32: *op++ = *ip++; case 31: *op++ = *ip++; case 30: *op++ = *ip++;
case 29: *op++ = *ip++;
+ case 28: *op++ = *ip++; case 27: *op++ = *ip++; case 26: *op++ = *ip++;
case 25: *op++ = *ip++;
+ case 24: *op++ = *ip++; case 23: *op++ = *ip++; case 22: *op++ = *ip++;
case 21: *op++ = *ip++;
+ case 20: *op++ = *ip++; case 19: *op++ = *ip++; case 18: *op++ = *ip++;
case 17: *op++ = *ip++;
+ case 16: *op++ = *ip++; case 15: *op++ = *ip++; case 14: *op++ = *ip++;
case 13: *op++ = *ip++;
+ case 12: *op++ = *ip++; case 11: *op++ = *ip++; case 10: *op++ = *ip++;
case 9: *op++ = *ip++;
+ case 8: *op++ = *ip++; case 7: *op++ = *ip++; case 6: *op++ = *ip++;
case 5: *op++ = *ip++;
+ case 4: *op++ = *ip++; case 3: *op++ = *ip++; case 2: *op++ = *ip++;
case 1: *op++ = *ip++;
+ }
+#endif
+ }
+ else /* back reference */
+ {
+ unsigned int len = ctrl >> 5;
+
+ u8 *ref = op - ((ctrl & 0x1f) << 8) - 1;
+
+#if CHECK_INPUT
+ if (ip >= in_end)
+ {
+ SET_ERRNO (EINVAL);
+ return 0;
+ }
+#endif
+ if (len == 7)
+ {
+ len += *ip++;
+#if CHECK_INPUT
+ if (ip >= in_end)
+ {
+ SET_ERRNO (EINVAL);
+ return 0;
+ }
+#endif
+ }
+
+ ref -= *ip++;
+
+ if (op + len + 2 > out_end)
+ {
+ SET_ERRNO (E2BIG);
+ return 0;
+ }
+
+ if (ref < (u8 *)out_data)
+ {
+ SET_ERRNO (EINVAL);
+ return 0;
+ }
+
+#ifdef lzf_movsb
+ len += 2;
+ lzf_movsb (op, ref, len);
+#else
+ switch (len)
+ {
+ default:
+ len += 2;
+
+ if (op >= ref + len)
+ {
+ /* disjunct areas */
+ memcpy (op, ref, len);
+ op += len;
+ }
+ else
+ {
+ /* overlapping, use octte by octte copying */
+ do
+ *op++ = *ref++;
+ while (--len);
+ }
+
+ break;
+
+ case 9: *op++ = *ref++;
+ case 8: *op++ = *ref++;
+ case 7: *op++ = *ref++;
+ case 6: *op++ = *ref++;
+ case 5: *op++ = *ref++;
+ case 4: *op++ = *ref++;
+ case 3: *op++ = *ref++;
+ case 2: *op++ = *ref++;
+ case 1: *op++ = *ref++;
+ case 0: *op++ = *ref++; /* two octets more */
+ *op++ = *ref++;
+ }
+#endif
+ }
+ }
+ while (ip < in_end);
+
+ return op - (u8 *)out_data;
+}
+
diff --git a/SerialICE/lzf/liblzf-3.6/romdecompress.c
b/SerialICE/lzf/liblzf-3.6/romdecompress.c
new file mode 100644
index 0000000..1f76cf2
--- /dev/null
+++ b/SerialICE/lzf/liblzf-3.6/romdecompress.c
@@ -0,0 +1,245 @@
+/*
+ * Copyright (c) 2006 Stefan Traby <stefan(a)hello-penguin.com>
+ *
+ * Redistribution and use in source and binary forms, with or without modifica-
+ * tion, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MER-
+ * CHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPE-
+ * CIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTH-
+ * ERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * the GNU General Public License ("GPL") version 2 or any later version,
+ * in which case the provisions of the GPL are applicable instead of
+ * the above. If you wish to allow the use of your version of this file
+ * only under the terms of the GPL and not to allow others to use your
+ * version of this file under the BSD license, indicate your decision
+ * by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL. If you do not delete the
+ * provisions above, a recipient may use your version of this file under
+ * either the BSD or the GPL.
+ */
+
+#define _LARGEFILE64_SOURCE
+#include "config.h"
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <limits.h>
+#include "lzf.h"
+
+#ifdef HAVE_GETOPT_H
+# include <getopt.h>
+#endif
+
+#define OVERLAP 64
+#define MAXBLOCK (512*1024)
+
+char buffer[MAXBLOCK];
+
+
+int findsyncCOMP(char *buffer, int size)
+{
+ char *ptr=buffer;
+ char *end=buffer+size-4;
+ while (ptr<end)
+ {
+ if (memcmp(ptr,"COMP",4)==0)
+ {
+ fprintf(stderr,"COMP FOUND\n");
+ return ptr-buffer;
+ }
+ ptr++;
+ };
+ return -1;
+};
+
+int findsyncSTRT(char *buffer, int size)
+{
+ char *ptr=buffer;
+ char *end=buffer+size-4;
+ while (ptr<end)
+ {
+ if (memcmp(ptr,"STRT",4)==0)
+ {
+ fprintf(stderr,"STRT FOUND\n");
+ return ptr-buffer;
+ }
+ ptr++;
+ };
+ return -1;
+};
+
+#define ONEGIG (1024LL*1024LL*1024LL)
+
+
+int decodeblockCOMP(char *buffer,int bufsize)
+{
+ int paged_gigabyte;
+ unsigned int intaddr;
+ off64_t addr;
+ int size;
+ int csize;
+ int csum;
+ if (memcmp(buffer,"COMP",4)!=0)
+ {
+ fprintf(stderr,"Decoding error EXPECTED COMP\n");
+ return -1;
+ };
+
+ int cnt =
sscanf(buffer+4,"%02x%08x%08x%08x%08x",&paged_gigabyte,&intaddr,&size,&csize,&csum);
+ if (cnt != 5)
+ {
+ fprintf(stderr,"Decoding error expected addresses\n");
+ return 4;
+ };
+
+ addr=intaddr;
+ if (addr>=ONEGIG && addr<(2*ONEGIG))
+ {
+ addr-=ONEGIG;
+ addr+=(ONEGIG*paged_gigabyte);
+ };
+
+ fprintf(stderr,"%08llx %08x %08x %08x\n",addr,size,csize,csum);
+ {
+ unsigned char outbuffer[size+10];
+ int outsize = lzf_decompress (buffer+(4+2+4*8),csize,outbuffer,size);
+ if (outsize!=size)
+ {
+ fprintf(stderr,"Decompression length error %08x!=%08x\n",size,outsize);
+ return 4;
+ };
+ int off;
+ int check=0;
+ for(off=0;off<size;off++)
+ {
+ check+=outbuffer[off];
+ };
+ if (check!=csum)
+ {
+ fprintf(stderr,"Decompression checksum error %08x!=%08x\n",csum,check);
+ };
+ lseek64(1,addr,SEEK_SET);
+ write(1,outbuffer,size);
+ };
+
+ return (4+2+4*8)+csize;
+};
+
+int decodeblockSTRT(char *buffer,int bufsize)
+{
+ int addr; //Terminating zero
+ int size; //Terminating zero
+ int csum; //Terminating zero
+ if (memcmp(buffer,"STRT",4)!=0)
+ {
+ fprintf(stderr,"Decoding error EXPECTED STRT\n");
+ return -1;
+ };
+
+ int cnt = sscanf(buffer+4,"%08x",&addr);
+ if (cnt != 1)
+ {
+ fprintf(stderr,"Decoding error expected address\n");
+ return 4;
+ };
+
+ size=65536;
+ csum=*(int *) (buffer+8+4+size);
+
+ fprintf(stderr,"%08x %08x %08x\n",addr,size,csum);
+ {
+ int off;
+ int check=0;
+ for(off=0;off<size;off++)
+ {
+ check+=(unsigned char ) buffer[4+8+off];
+ };
+ if (check!=csum)
+ {
+ fprintf(stderr,"transport checksum error %08x!=%08x\n",csum,check);
+ return 4;
+ };
+ lseek(1,addr,SEEK_SET);
+ write(1,buffer+4,size);
+ };
+
+ return (4+8+4+2+size);
+};
+
+
+int
+main (int argc, char *argv[])
+{
+ enum { sync , nosync } state = nosync;
+ int offset=0;
+ int size=0;
+ int sizeread=0;
+
+ while ((sizeread=read(0,buffer+size,MAXBLOCK-size)) || (size>OVERLAP))
+ {
+ size+=sizeread;
+ if (state==nosync) {
+ if ((offset=findsyncCOMP(buffer,size))>=0)
+ state=sync;
+ else
+ offset=(size-OVERLAP) >=0 ? (size-OVERLAP) : 0;
+ size-=offset;
+ if (offset!=0)
+ memmove(buffer,buffer+offset,size);
+ } else {
+ if ((offset=decodeblockCOMP(buffer,size))<8)
+ {
+ state=nosync;
+ };
+ size-=offset;
+ memmove(buffer,buffer+offset,size);
+ };
+
+ };
+
+ lseek(0,0,SEEK_SET);
+ while ((sizeread=read(0,buffer+size,MAXBLOCK-size)) || (size>OVERLAP))
+ {
+ size+=sizeread;
+ if (state==nosync) {
+ if ((offset=findsyncSTRT(buffer,size))>=0)
+ state=sync;
+ else
+ offset=(size-OVERLAP) >=0 ? (size-OVERLAP) : 0;
+ size-=offset;
+ if (offset!=0)
+ memmove(buffer,buffer+offset,size);
+ } else {
+ if ((offset=decodeblockSTRT(buffer,size))<8)
+ {
+ state=nosync;
+ };
+ size-=offset;
+ memmove(buffer,buffer+offset,size);
+ };
+ sizeread=0;
+
+ };
+}
+
2636
days inactive
2636
days old
0 comments
1 participants
participants (1)
-
Idwer Vollering