zlib 1.2.3.4v1.2.3.4

11 files changed, 683 insertions, 70 deletions

diff --git a/contrib/README.contrib b/contrib/README.contrib
index 20afc62..f9c1665 100644
--- a/contrib/README.contrib
+++ b/contrib/README.contrib
@@ -8,6 +8,10 @@ ada/        by Dmitriy Anisimkov <anisimkov@yahoo.com>
         Support for Ada
         See http://zlib-ada.sourceforge.net/
 
+amd64/      by Mikhail Teterin <mi@ALDAN.algebra.com>
+        asm code for AMD64
+        See patch at http://www.freebsd.org/cgi/query-pr.cgi?pr=bin/96393
+
 asm586/
 asm686/     by Brian Raiter <breadbox@muppetlabs.com>
         asm code for Pentium and PPro/PII, using the AT&T (GNU as) syntax
diff --git a/contrib/amd64/amd64-match.S b/contrib/amd64/amd64-match.S
new file mode 100644
index 0000000..b3bf1ac
--- /dev/null
+++ b/contrib/amd64/amd64-match.S
@@ -0,0 +1,357 @@
+/*
+ * match.S -- optimized version of longest_match()
+ * based on the similar work by Gilles Vollant, and Brian Raiter, written 1998
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the BSD License. Use by owners of Che Guevarra
+ * parafernalia is prohibited, where possible, and highly discouraged
+ * elsewhere.
+ */
+
+#ifndef NO_UNDERLINE
+#       define  match_init      _match_init
+#       define  longest_match   _longest_match
+#endif
+
+#define scanend         ebx
+#define scanendw        bx
+#define chainlenwmask   edx /* high word: current chain len low word: s->wmask */
+#define curmatch        rsi
+#define curmatchd       esi
+#define windowbestlen   r8
+#define scanalign       r9
+#define scanalignd      r9d
+#define window          r10
+#define bestlen         r11
+#define bestlend        r11d
+#define scanstart       r12d
+#define scanstartw      r12w
+#define scan            r13
+#define nicematch       r14d
+#define limit           r15
+#define limitd          r15d
+#define prev            rcx
+
+/*
+ * The 258 is a "magic number, not a parameter -- changing it
+ * breaks the hell loose
+ */
+#define MAX_MATCH       (258)
+#define MIN_MATCH       (3)
+#define MIN_LOOKAHEAD   (MAX_MATCH + MIN_MATCH + 1)
+#define MAX_MATCH_8     ((MAX_MATCH + 7) & ~7)
+
+/* stack frame offsets */
+#define LocalVarsSize   (112)
+#define _chainlenwmask  ( 8-LocalVarsSize)(%rsp)
+#define _windowbestlen  (16-LocalVarsSize)(%rsp)
+#define save_r14        (24-LocalVarsSize)(%rsp)
+#define save_rsi        (32-LocalVarsSize)(%rsp)
+#define save_rbx        (40-LocalVarsSize)(%rsp)
+#define save_r12        (56-LocalVarsSize)(%rsp)
+#define save_r13        (64-LocalVarsSize)(%rsp)
+#define save_r15        (80-LocalVarsSize)(%rsp)
+
+/*
+ * On AMD64 the first argument of a function (in our case -- the pointer to
+ * deflate_state structure) is passed in %rdi, hence our offsets below are
+ * all off of that.
+ */
+#ifndef STRUCT_OFFSET
+#       define STRUCT_OFFSET    (0)
+#endif
+#define dsWSize         ( 56 + STRUCT_OFFSET)(%rdi)
+#define dsWMask         ( 64 + STRUCT_OFFSET)(%rdi)
+#define dsWindow        ( 72 + STRUCT_OFFSET)(%rdi)
+#define dsPrev          ( 88 + STRUCT_OFFSET)(%rdi)
+#define dsMatchLen      (136 + STRUCT_OFFSET)(%rdi)
+#define dsPrevMatch     (140 + STRUCT_OFFSET)(%rdi)
+#define dsStrStart      (148 + STRUCT_OFFSET)(%rdi)
+#define dsMatchStart    (152 + STRUCT_OFFSET)(%rdi)
+#define dsLookahead     (156 + STRUCT_OFFSET)(%rdi)
+#define dsPrevLen       (160 + STRUCT_OFFSET)(%rdi)
+#define dsMaxChainLen   (164 + STRUCT_OFFSET)(%rdi)
+#define dsGoodMatch     (180 + STRUCT_OFFSET)(%rdi)
+#define dsNiceMatch     (184 + STRUCT_OFFSET)(%rdi)
+
+.globl  match_init, longest_match
+
+.text
+
+/* uInt longest_match(deflate_state *deflatestate, IPos curmatch) */
+
+longest_match:
+/*
+ * Retrieve the function arguments. %curmatch will hold cur_match
+ * throughout the entire function (passed via rsi on amd64).
+ * rdi will hold the pointer to the deflate_state (first arg on amd64)
+ */
+                mov     %rsi, save_rsi
+                mov     %rbx, save_rbx
+                mov     %r12, save_r12
+                mov     %r13, save_r13
+                mov     %r14, save_r14
+                mov     %r15, save_r15
+
+/* uInt wmask = s->w_mask;                                              */
+/* unsigned chain_length = s->max_chain_length;                         */
+/* if (s->prev_length >= s->good_match) {                               */
+/*     chain_length >>= 2;                                              */
+/* }                                                                    */
+
+                movl    dsPrevLen, %eax
+                movl    dsGoodMatch, %ebx
+                cmpl    %ebx, %eax
+                movl    dsWMask, %eax
+                movl    dsMaxChainLen, %chainlenwmask
+                jl      LastMatchGood
+                shrl    $2, %chainlenwmask
+LastMatchGood:
+
+/* chainlen is decremented once beforehand so that the function can     */
+/* use the sign flag instead of the zero flag for the exit test.        */
+/* It is then shifted into the high word, to make room for the wmask    */
+/* value, which it will always accompany.                               */
+
+                decl    %chainlenwmask
+                shll    $16, %chainlenwmask
+                orl     %eax, %chainlenwmask
+
+/* if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead;      */
+
+                movl    dsNiceMatch, %eax
+                movl    dsLookahead, %ebx
+                cmpl    %eax, %ebx
+                jl      LookaheadLess
+                movl    %eax, %ebx
+LookaheadLess:  movl    %ebx, %nicematch
+
+/* register Bytef *scan = s->window + s->strstart;                      */
+
+                mov     dsWindow, %window
+                movl    dsStrStart, %limitd
+                lea     (%limit, %window), %scan
+
+/* Determine how many bytes the scan ptr is off from being              */
+/* dword-aligned.                                                       */
+
+                mov     %scan, %scanalign
+                negl    %scanalignd
+                andl    $3, %scanalignd
+
+/* IPos limit = s->strstart > (IPos)MAX_DIST(s) ?                       */
+/*     s->strstart - (IPos)MAX_DIST(s) : NIL;                           */
+
+                movl    dsWSize, %eax
+                subl    $MIN_LOOKAHEAD, %eax
+                xorl    %ecx, %ecx
+                subl    %eax, %limitd
+                cmovng  %ecx, %limitd
+
+/* int best_len = s->prev_length;                                       */
+
+                movl    dsPrevLen, %bestlend
+
+/* Store the sum of s->window + best_len in %windowbestlen locally, and in memory.      */
+
+                lea     (%window, %bestlen), %windowbestlen
+                mov     %windowbestlen, _windowbestlen
+
+/* register ush scan_start = *(ushf*)scan;                              */
+/* register ush scan_end   = *(ushf*)(scan+best_len-1);                 */
+/* Posf *prev = s->prev;                                                */
+
+                movzwl  (%scan), %scanstart
+                movzwl  -1(%scan, %bestlen), %scanend
+                mov     dsPrev, %prev
+
+/* Jump into the main loop.                                             */
+
+                movl    %chainlenwmask, _chainlenwmask
+                jmp     LoopEntry
+
+.balign 16
+
+/* do {
+ *     match = s->window + cur_match;
+ *     if (*(ushf*)(match+best_len-1) != scan_end ||
+ *         *(ushf*)match != scan_start) continue;
+ *     [...]
+ * } while ((cur_match = prev[cur_match & wmask]) > limit
+ *          && --chain_length != 0);
+ *
+ * Here is the inner loop of the function. The function will spend the
+ * majority of its time in this loop, and majority of that time will
+ * be spent in the first ten instructions.
+ */
+LookupLoop:
+                andl    %chainlenwmask, %curmatchd
+                movzwl  (%prev, %curmatch, 2), %curmatchd
+                cmpl    %limitd, %curmatchd
+                jbe     LeaveNow
+                subl    $0x00010000, %chainlenwmask
+                js      LeaveNow
+LoopEntry:      cmpw    -1(%windowbestlen, %curmatch), %scanendw
+                jne     LookupLoop
+                cmpw    %scanstartw, (%window, %curmatch)
+                jne     LookupLoop
+
+/* Store the current value of chainlen.                                 */
+                movl    %chainlenwmask, _chainlenwmask
+
+/* %scan is the string under scrutiny, and %prev to the string we       */
+/* are hoping to match it up with. In actuality, %esi and %edi are      */
+/* both pointed (MAX_MATCH_8 - scanalign) bytes ahead, and %edx is      */
+/* initialized to -(MAX_MATCH_8 - scanalign).                           */
+
+                mov     $(-MAX_MATCH_8), %rdx
+                lea     (%curmatch, %window), %windowbestlen
+                lea     MAX_MATCH_8(%windowbestlen, %scanalign), %windowbestlen
+                lea     MAX_MATCH_8(%scan, %scanalign), %prev
+
+/* the prefetching below makes very little difference... */
+                prefetcht1      (%windowbestlen, %rdx)
+                prefetcht1      (%prev, %rdx)
+
+/*
+ * Test the strings for equality, 8 bytes at a time. At the end,
+ * adjust %rdx so that it is offset to the exact byte that mismatched.
+ *
+ * It should be confessed that this loop usually does not represent
+ * much of the total running time. Replacing it with a more
+ * straightforward "rep cmpsb" would not drastically degrade
+ * performance -- unrolling it, for example, makes no difference.
+ */
+#undef USE_SSE  /* works, but is 6-7% slower, than non-SSE... */
+LoopCmps:
+#ifdef USE_SSE
+                /* Preload the SSE registers */
+                movdqu    (%windowbestlen, %rdx), %xmm1
+                movdqu    (%prev, %rdx), %xmm2
+                pcmpeqb %xmm2, %xmm1
+                movdqu  16(%windowbestlen, %rdx), %xmm3
+                movdqu  16(%prev, %rdx), %xmm4
+                pcmpeqb %xmm4, %xmm3
+                movdqu  32(%windowbestlen, %rdx), %xmm5
+                movdqu  32(%prev, %rdx), %xmm6
+                pcmpeqb %xmm6, %xmm5
+                movdqu  48(%windowbestlen, %rdx), %xmm7
+                movdqu  48(%prev, %rdx), %xmm8
+                pcmpeqb %xmm8, %xmm7
+
+                /* Check the comparisions' results */
+                pmovmskb %xmm1, %rax
+                notw    %ax
+                bsfw    %ax, %ax
+                jnz     LeaveLoopCmps
+                add     $16, %rdx
+                pmovmskb %xmm3, %rax
+                notw    %ax
+                bsfw    %ax, %ax
+                jnz     LeaveLoopCmps
+                add     $16, %rdx
+                pmovmskb %xmm5, %rax
+                notw    %ax
+                bsfw    %ax, %ax
+                jnz     LeaveLoopCmps
+                add     $16, %rdx
+                pmovmskb %xmm7, %rax
+                notw    %ax
+                bsfw    %ax, %ax
+                jnz     LeaveLoopCmps
+                add     $16, %rdx
+                jmp     LoopCmps
+LeaveLoopCmps:  add     %rax, %rdx
+#else
+                mov     (%windowbestlen, %rdx), %rax
+                xor     (%prev, %rdx), %rax
+                jnz     LeaveLoopCmps
+                add     $8, %rdx
+                jnz     LoopCmps
+                jmp     LenMaximum
+#       if 0
+/*
+ * This three-liner is tantalizingly simple, but bsf is a slow instruction,
+ * and the complicated alternative down below is quite a bit faster. Sad...
+ */
+LeaveLoopCmps:  bsf     %rax, %rax /* find the first non-zero bit */
+                shrl    $3, %eax /* divide by 8 to get the byte */
+                add     %rax, %rdx
+#       else
+LeaveLoopCmps:  testl   $0xFFFFFFFF, %eax /* Check the first 4 bytes */
+                jnz     Check16
+                add     $4, %rdx
+                shr     $32, %rax
+Check16:        testw   $0xFFFF, %ax
+                jnz     LenLower
+                add     $2, %rdx
+                shrl    $16, %eax
+LenLower:       subb    $1, %al
+                adc     $0, %rdx
+#       endif
+#endif
+
+/* Calculate the length of the match. If it is longer than MAX_MATCH,   */
+/* then automatically accept it as the best possible match and leave.   */
+
+                lea     (%prev, %rdx), %rax
+                sub     %scan, %rax
+                cmpl    $MAX_MATCH, %eax
+                jge     LenMaximum
+
+/* If the length of the match is not longer than the best match we      */
+/* have so far, then forget it and return to the lookup loop.           */
+
+                cmpl    %bestlend, %eax
+                jg      LongerMatch
+                mov     _windowbestlen, %windowbestlen
+                mov     dsPrev, %prev
+                movl    _chainlenwmask, %edx
+                jmp     LookupLoop
+
+/*         s->match_start = cur_match;                                  */
+/*         best_len = len;                                              */
+/*         if (len >= nice_match) break;                                */
+/*         scan_end = *(ushf*)(scan+best_len-1);                        */
+
+LongerMatch:
+                movl    %eax, %bestlend
+                movl    %curmatchd, dsMatchStart
+                cmpl    %nicematch, %eax
+                jge     LeaveNow
+
+                lea     (%window, %bestlen), %windowbestlen
+                mov     %windowbestlen, _windowbestlen
+
+                movzwl  -1(%scan, %rax), %scanend
+                mov     dsPrev, %prev
+                movl    _chainlenwmask, %chainlenwmask
+                jmp     LookupLoop
+
+/* Accept the current string, with the maximum possible length.         */
+
+LenMaximum:
+                movl    $MAX_MATCH, %bestlend
+                movl    %curmatchd, dsMatchStart
+
+/* if ((uInt)best_len <= s->lookahead) return (uInt)best_len;           */
+/* return s->lookahead;                                                 */
+
+LeaveNow:
+                movl    dsLookahead, %eax
+                cmpl    %eax, %bestlend
+                cmovngl %bestlend, %eax
+LookaheadRet:
+
+/* Restore the registers and return from whence we came.                        */
+
+        mov     save_rsi, %rsi
+        mov     save_rbx, %rbx
+        mov     save_r12, %r12
+        mov     save_r13, %r13
+        mov     save_r14, %r14
+        mov     save_r15, %r15
+
+        ret
+
+match_init:     ret
diff --git a/contrib/infback9/infback9.c b/contrib/infback9/infback9.c
index c5547ae..7bbe90c 100644
--- a/contrib/infback9/infback9.c
+++ b/contrib/infback9/infback9.c
@@ -1,5 +1,5 @@
 /* infback9.c -- inflate deflate64 data using a call-back interface
- * Copyright (C) 1995-2006 Mark Adler
+ * Copyright (C) 1995-2008 Mark Adler
  * For conditions of distribution and use, see copyright notice in zlib.h
  */
 
@@ -433,7 +433,16 @@ void FAR *out_desc;
             /* handle error breaks in while */
             if (mode == BAD) break;
 
-            /* build code tables */
+            /* check for end-of-block code (better have one) */
+            if (state->lens[256] == 0) {
+                strm->msg = (char *)"invalid code -- missing end-of-block";
+                mode = BAD;
+                break;
+            }
+
+            /* build code tables -- note: do not change the lenbits or distbits
+               values here (9 and 6) without reading the comments in inftree9.h
+               concerning the ENOUGH constants, which depend on those values */
             state->next = state->codes;
             lencode = (code const FAR *)(state->next);
             lenbits = 9;
diff --git a/contrib/infback9/inftree9.c b/contrib/infback9/inftree9.c
index c24302b..18353cb 100644
--- a/contrib/infback9/inftree9.c
+++ b/contrib/infback9/inftree9.c
@@ -1,5 +1,5 @@
 /* inftree9.c -- generate Huffman trees for efficient decoding
- * Copyright (C) 1995-2006 Mark Adler
+ * Copyright (C) 1995-2008 Mark Adler
  * For conditions of distribution and use, see copyright notice in zlib.h
  */
 
@@ -9,7 +9,7 @@
 #define MAXBITS 15
 
 const char inflate9_copyright[] =
-   " inflate9 1.2.3.3 Copyright 1995-2006 Mark Adler ";
+   " inflate9 1.2.3.4 Copyright 1995-2008 Mark Adler ";
 /*
   If you use the zlib library in a product, an acknowledgment is welcome
   in the documentation of your product. If for some reason you cannot
@@ -64,7 +64,7 @@ unsigned short FAR *work;
     static const unsigned short lext[31] = { /* Length codes 257..285 extra */
         128, 128, 128, 128, 128, 128, 128, 128, 129, 129, 129, 129,
         130, 130, 130, 130, 131, 131, 131, 131, 132, 132, 132, 132,
-        133, 133, 133, 133, 144, 201, 203};
+        133, 133, 133, 133, 144, 72, 200};
     static const unsigned short dbase[32] = { /* Distance codes 0..31 base */
         1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49,
         65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 2049, 3073,
@@ -160,11 +160,10 @@ unsigned short FAR *work;
        entered in the tables.
 
        used keeps track of how many table entries have been allocated from the
-       provided *table space.  It is checked when a LENS table is being made
-       against the space in *table, ENOUGH, minus the maximum space needed by
-       the worst case distance code, MAXD.  This should never happen, but the
-       sufficiency of ENOUGH has not been proven exhaustively, hence the check.
-       This assumes that when type == LENS, bits == 9.
+       provided *table space.  It is checked for LENS and DIST tables against
+       the constants ENOUGH_LENS and ENOUGH_DISTS to guard against changes in
+       the initial root table size constants.  See the comments in inftree9.h
+       for more information.
 
        sym increments through all symbols, and the loop terminates when
        all codes of length max, i.e. all codes, have been processed.  This
@@ -203,7 +202,8 @@ unsigned short FAR *work;
     mask = used - 1;            /* mask for comparing low */
 
     /* check available table space */
-    if (type == LENS && used >= ENOUGH - MAXD)
+    if ((type == LENS && used >= ENOUGH_LENS) ||
+        (type == DISTS && used >= ENOUGH_DISTS))
         return 1;
 
     /* process all codes and make table entries */
@@ -270,7 +270,8 @@ unsigned short FAR *work;
 
             /* check for enough space */
             used += 1U << curr;
-            if (type == LENS && used >= ENOUGH - MAXD)
+            if ((type == LENS && used >= ENOUGH_LENS) ||
+                (type == DISTS && used >= ENOUGH_DISTS))
                 return 1;
 
             /* point entry in root table to sub-table */
diff --git a/contrib/infback9/inftree9.h b/contrib/infback9/inftree9.h
index a268084..5ab21f0 100644
--- a/contrib/infback9/inftree9.h
+++ b/contrib/infback9/inftree9.h
@@ -1,5 +1,5 @@
 /* inftree9.h -- header to use inftree9.c
- * Copyright (C) 1995-2003 Mark Adler
+ * Copyright (C) 1995-2008 Mark Adler
  * For conditions of distribution and use, see copyright notice in zlib.h
  */
 
@@ -35,15 +35,21 @@ typedef struct {
     01000000 - invalid code
  */
 
-/* Maximum size of dynamic tree.  The maximum found in a long but non-
-   exhaustive search was 1444 code structures (852 for length/literals
-   and 592 for distances, the latter actually the result of an
-   exhaustive search).  The true maximum is not known, but the value
-   below is more than safe. */
-#define ENOUGH 2048
-#define MAXD 592
+/* Maximum size of the dynamic table.  The maximum number of code structures is
+   1446, which is the sum of 852 for literal/length codes and 594 for distance
+   codes.  These values were found by exhaustive searches using the program
+   examples/enough.c found in the zlib distribtution.  The arguments to that
+   program are the number of symbols, the initial root table size, and the
+   maximum bit length of a code.  "enough 286 9 15" for literal/length codes
+   returns returns 852, and "enough 32 6 15" for distance codes returns 594.
+   The initial root table size (9 or 6) is found in the fifth argument of the
+   inflate_table() calls in infback9.c.  If the root table size is changed,
+   then these maximum sizes would be need to be recalculated and updated. */
+#define ENOUGH_LENS 852
+#define ENOUGH_DISTS 594
+#define ENOUGH (ENOUGH_LENS+ENOUGH_DISTS)
 
-/* Type of code to build for inftable() */
+/* Type of code to build for inflate_table9() */
 typedef enum {
     CODES,
     LENS,
diff --git a/contrib/nintendods/Makefile b/contrib/nintendods/Makefile
new file mode 100644
index 0000000..21337d0
--- /dev/null
+++ b/contrib/nintendods/Makefile
@@ -0,0 +1,126 @@
+#---------------------------------------------------------------------------------
+.SUFFIXES:
+#---------------------------------------------------------------------------------
+
+ifeq ($(strip $(DEVKITARM)),)
+$(error "Please set DEVKITARM in your environment. export DEVKITARM=<path to>devkitARM")
+endif
+
+include $(DEVKITARM)/ds_rules
+
+#---------------------------------------------------------------------------------
+# TARGET is the name of the output
+# BUILD is the directory where object files & intermediate files will be placed
+# SOURCES is a list of directories containing source code
+# DATA is a list of directories containing data files
+# INCLUDES is a list of directories containing header files
+#---------------------------------------------------------------------------------
+TARGET          :=      $(shell basename $(CURDIR))
+BUILD           :=      build
+SOURCES         :=      ../../
+DATA            :=      data
+INCLUDES        :=      include
+
+#---------------------------------------------------------------------------------
+# options for code generation
+#---------------------------------------------------------------------------------
+ARCH    :=      -mthumb -mthumb-interwork
+
+CFLAGS  :=      -Wall -O2\
+                -march=armv5te -mtune=arm946e-s \
+                -fomit-frame-pointer -ffast-math \
+                $(ARCH)
+
+CFLAGS  +=      $(INCLUDE) -DARM9
+CXXFLAGS        := $(CFLAGS) -fno-rtti -fno-exceptions
+
+ASFLAGS :=      $(ARCH) -march=armv5te -mtune=arm946e-s
+LDFLAGS =       -specs=ds_arm9.specs -g $(ARCH) -Wl,-Map,$(notdir $*.map)
+
+#---------------------------------------------------------------------------------
+# list of directories containing libraries, this must be the top level containing
+# include and lib
+#---------------------------------------------------------------------------------
+LIBDIRS :=      $(LIBNDS)
+
+#---------------------------------------------------------------------------------
+# no real need to edit anything past this point unless you need to add additional
+# rules for different file extensions
+#---------------------------------------------------------------------------------
+ifneq ($(BUILD),$(notdir $(CURDIR)))
+#---------------------------------------------------------------------------------
+
+export OUTPUT   :=      $(CURDIR)/lib/libz.a
+
+export VPATH    :=      $(foreach dir,$(SOURCES),$(CURDIR)/$(dir)) \
+                        $(foreach dir,$(DATA),$(CURDIR)/$(dir))
+
+export DEPSDIR  :=      $(CURDIR)/$(BUILD)
+
+CFILES          :=      $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.c)))
+CPPFILES        :=      $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.cpp)))
+SFILES          :=      $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.s)))
+BINFILES        :=      $(foreach dir,$(DATA),$(notdir $(wildcard $(dir)/*.*)))
+
+#---------------------------------------------------------------------------------
+# use CXX for linking C++ projects, CC for standard C
+#---------------------------------------------------------------------------------
+ifeq ($(strip $(CPPFILES)),)
+#---------------------------------------------------------------------------------
+        export LD       :=      $(CC)
+#---------------------------------------------------------------------------------
+else
+#---------------------------------------------------------------------------------
+        export LD       :=      $(CXX)
+#---------------------------------------------------------------------------------
+endif
+#---------------------------------------------------------------------------------
+
+export OFILES   :=      $(addsuffix .o,$(BINFILES)) \
+                        $(CPPFILES:.cpp=.o) $(CFILES:.c=.o) $(SFILES:.s=.o)
+
+export INCLUDE  :=      $(foreach dir,$(INCLUDES),-I$(CURDIR)/$(dir)) \
+                        $(foreach dir,$(LIBDIRS),-I$(dir)/include) \
+                        -I$(CURDIR)/$(BUILD)
+
+.PHONY: $(BUILD) clean all
+
+#---------------------------------------------------------------------------------
+all: $(BUILD)
+        @[ -d $@ ] || mkdir -p include
+        @cp ../../*.h include
+
+lib:
+        @[ -d $@ ] || mkdir -p $@
+        
+$(BUILD): lib
+        @[ -d $@ ] || mkdir -p $@
+        @$(MAKE) --no-print-directory -C $(BUILD) -f $(CURDIR)/Makefile
+
+#---------------------------------------------------------------------------------
+clean:
+        @echo clean ...
+        @rm -fr $(BUILD) lib
+
+#---------------------------------------------------------------------------------
+else
+
+DEPENDS :=      $(OFILES:.o=.d)
+
+#---------------------------------------------------------------------------------
+# main targets
+#---------------------------------------------------------------------------------
+$(OUTPUT)       :       $(OFILES)
+
+#---------------------------------------------------------------------------------
+%.bin.o :       %.bin
+#---------------------------------------------------------------------------------
+        @echo $(notdir $<)
+        @$(bin2o)
+
+
+-include $(DEPENDS)
+
+#---------------------------------------------------------------------------------------
+endif
+#---------------------------------------------------------------------------------------
diff --git a/contrib/nintendods/README b/contrib/nintendods/README
new file mode 100644
index 0000000..ba7a37d
--- /dev/null
+++ b/contrib/nintendods/README
@@ -0,0 +1,5 @@
+This Makefile requires devkitARM (http://www.devkitpro.org/category/devkitarm/) and works inside "contrib/nds". It is based on a devkitARM template.
+
+Eduardo Costa <eduardo.m.costa@gmail.com>
+January 3, 2009
+
diff --git a/contrib/puff/puff b/contrib/puff/puff
new file mode 100755
index 0000000..bedac26
--- /dev/null
+++ b/contrib/puff/puff
diff --git a/contrib/puff/puff.c b/contrib/puff/puff.c
index ce0cc40..df5b79f 100644
--- a/contrib/puff/puff.c
+++ b/contrib/puff/puff.c
@@ -1,8 +1,8 @@
 /*
  * puff.c
- * Copyright (C) 2002-2004 Mark Adler
+ * Copyright (C) 2002-2008 Mark Adler
  * For conditions of distribution and use, see copyright notice in puff.h
- * version 1.8, 9 Jan 2004
+ * version 2.0, 25 Jul 2008
  *
  * puff.c is a simple inflate written to be an unambiguous way to specify the
  * deflate format.  It is not written for speed but rather simplicity.  As a
@@ -61,6 +61,12 @@
  * 1.7   3 Mar 2003     - Added test code for distribution
  *                      - Added zlib-like license
  * 1.8   9 Jan 2004     - Added some comments on no distance codes case
+ * 1.9  21 Feb 2008     - Fix bug on 16-bit integer architectures [Pohland]
+ *                      - Catch missing end-of-block symbol error
+ * 2.0  25 Jul 2008     - Add #define to permit distance too far back
+ *                      - Add option in TEST code for puff to write the data
+ *                      - Add option in TEST code to skip input bytes
+ *                      - Allow TEST code to read from piped stdin
  */
 
 #include <setjmp.h>             /* for setjmp(), longjmp(), and jmp_buf */
@@ -194,7 +200,7 @@ struct huffman {
  * Decode a code from the stream s using huffman table h.  Return the symbol or
  * a negative value if there is an error.  If all of the lengths are zero, i.e.
  * an empty code, or if the code is incomplete and an invalid code is received,
- * then -9 is returned after reading MAXBITS bits.
+ * then -10 is returned after reading MAXBITS bits.
  *
  * Format notes:
  *
@@ -226,14 +232,14 @@ local int decode(struct state *s, struct huffman *h)
     for (len = 1; len <= MAXBITS; len++) {
         code |= bits(s, 1);             /* get next bit */
         count = h->count[len];
-        if (code < first + count)       /* if length len, return symbol */
+        if (code - count < first)       /* if length len, return symbol */
             return h->symbol[index + (code - first)];
         index += count;                 /* else update for next length */
         first += count;
         first <<= 1;
         code <<= 1;
     }
-    return -9;                          /* ran out of codes */
+    return -10;                         /* ran out of codes */
 }
 
 /*
@@ -263,7 +269,7 @@ local int decode(struct state *s, struct huffman *h)
             code |= bitbuf & 1;
             bitbuf >>= 1;
             count = *next++;
-            if (code < first + count) { /* if length len, return symbol */
+            if (code - count < first) { /* if length len, return symbol */
                 s->bitbuf = bitbuf;
                 s->bitcnt = (s->bitcnt - len) & 7;
                 return h->symbol[index + (code - first)];
@@ -280,7 +286,7 @@ local int decode(struct state *s, struct huffman *h)
         bitbuf = s->in[s->incnt++];
         if (left > 8) left = 8;
     }
-    return -9;                          /* ran out of codes */
+    return -10;                         /* ran out of codes */
 }
 #endif /* SLOW */
 
@@ -448,21 +454,27 @@ local int codes(struct state *s,
         else if (symbol > 256) {        /* length */
             /* get and compute length */
             symbol -= 257;
-            if (symbol >= 29) return -9;        /* invalid fixed code */
+            if (symbol >= 29) return -10;       /* invalid fixed code */
             len = lens[symbol] + bits(s, lext[symbol]);
 
             /* get and check distance */
             symbol = decode(s, distcode);
             if (symbol < 0) return symbol;      /* invalid symbol */
             dist = dists[symbol] + bits(s, dext[symbol]);
+#ifndef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
             if (dist > s->outcnt)
-                return -10;     /* distance too far back */
+                return -11;     /* distance too far back */
+#endif
 
             /* copy length bytes from distance bytes back */
             if (s->out != NIL) {
                 if (s->outcnt + len > s->outlen) return 1;
                 while (len--) {
-                    s->out[s->outcnt] = s->out[s->outcnt - dist];
+                    s->out[s->outcnt] =
+#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
+                        dist > s->outcnt ? 0 :
+#endif
+                        s->out[s->outcnt - dist];
                     s->outcnt++;
                 }
             }
@@ -680,6 +692,10 @@ local int dynamic(struct state *s)
         }
     }
 
+    /* check for end-of-block code -- there better be one! */
+    if (lengths[256] == 0)
+        return -9;
+
     /* build huffman table for literal/length codes */
     err = construct(&lencode, lengths, nlen);
     if (err < 0 || (err > 0 && nlen - lencode.count[0] != 1))
@@ -724,8 +740,9 @@ local int dynamic(struct state *s)
  *  -6:  dynamic block code description: repeat more than specified lengths
  *  -7:  dynamic block code description: invalid literal/length code lengths
  *  -8:  dynamic block code description: invalid distance code lengths
- *  -9:  invalid literal/length or distance code in fixed or dynamic block
- * -10:  distance is too far back in fixed or dynamic block
+ *  -9:  dynamic block code description: missing end-of-block code
+ * -10:  invalid literal/length or distance code in fixed or dynamic block
+ * -11:  distance is too far back in fixed or dynamic block
  *
  * Format notes:
  *
@@ -783,54 +800,142 @@ int puff(unsigned char *dest,           /* pointer to destination pointer */
 }
 
 #ifdef TEST
-/* Example of how to use puff() */
+/* Examples of how to use puff().
+
+   Usage: puff [-w] [-nnn] file
+          ... | puff [-w] [-nnn]
+
+   where file is the input file with deflate data, nnn is the number of bytes
+   of input to skip before inflating (e.g. to skip a zlib or gzip header), and
+   -w is used to write the decompressed data to stdout */
+
 #include <stdio.h>
 #include <stdlib.h>
-#include <sys/types.h>
-#include <sys/stat.h>
 
-local unsigned char *yank(char *name, unsigned long *len)
+/* Return size times approximately the cube root of 2, keeping the result as 1,
+   3, or 5 times a power of 2 -- the result is always > size, until the result
+   is the maximum value of an unsigned long, where it remains.  This is useful
+   to keep reallocations less than ~33% over the actual data. */
+local size_t bythirds(size_t size)
 {
-    unsigned long size;
-    unsigned char *buf;
+    int n;
+    size_t m;
+
+    m = size;
+    for (n = 0; m; n++)
+        m >>= 1;
+    if (n < 3)
+        return size + 1;
+    n -= 3;
+    m = size >> n;
+    m += m == 6 ? 2 : 1;
+    m <<= n;
+    return m > size ? m : (size_t)(-1);
+}
+
+/* Read the input file *name, or stdin if name is NULL, into allocated memory.
+   Reallocate to larger buffers until the entire file is read in.  Return a
+   pointer to the allocated data, or NULL if there was a memory allocation
+   failure.  *len is the number of bytes of data read from the input file (even
+   if load() returns NULL).  If the input file was empty or could not be opened
+   or read, *len is zero. */
+local void *load(char *name, size_t *len)
+{
+    size_t size;
+    void *buf, *swap;
     FILE *in;
-    struct stat s;
 
     *len = 0;
-    if (stat(name, &s)) return NULL;
-    if ((s.st_mode & S_IFMT) != S_IFREG) return NULL;
-    size = (unsigned long)(s.st_size);
-    if (size == 0 || (off_t)size != s.st_size) return NULL;
-    in = fopen(name, "r");
-    if (in == NULL) return NULL;
-    buf = malloc(size);
-    if (buf != NULL && fread(buf, 1, size, in) != size) {
-        free(buf);
-        buf = NULL;
+    buf = malloc(size = 4096);
+    if (buf == NULL)
+        return NULL;
+    in = name == NULL ? stdin : fopen(name, "rb");
+    if (in != NULL) {
+        for (;;) {
+            *len += fread((char *)buf + *len, 1, size - *len, in);
+            if (*len < size) break;
+            size = bythirds(size);
+            if (size == *len || (swap = realloc(buf, size)) == NULL) {
+                free(buf);
+                buf = NULL;
+                break;
+            }
+            buf = swap;
+        }
+        fclose(in);
     }
-    fclose(in);
-    *len = size;
     return buf;
 }
 
 int main(int argc, char **argv)
 {
-    int ret;
-    unsigned char *source;
-    unsigned long len, sourcelen, destlen;
-
-    if (argc < 2) return 2;
-    source = yank(argv[1], &len);
-    if (source == NULL) return 2;
-    sourcelen = len;
-    ret = puff(NIL, &destlen, source, &sourcelen);
+    int ret, skip = 0, put = 0;
+    char *arg, *name = NULL;
+    unsigned char *source = NULL, *dest;
+    size_t len = 0;
+    unsigned long sourcelen, destlen;
+
+    /* process arguments */
+    while (arg = *++argv, --argc)
+        if (arg[0] == '-') {
+            if (arg[1] == 'w' && arg[2] == 0)
+                put = 1;
+            else if (arg[1] >= '0' && arg[1] <= '9')
+                skip = atoi(arg + 1);
+            else {
+                fprintf(stderr, "invalid option %s\n", arg);
+                return 3;
+            }
+        }
+        else if (name != NULL) {
+            fprintf(stderr, "only one file name allowed\n");
+            return 3;
+        }
+        else
+            name = arg;
+    source = load(name, &len);
+    if (source == NULL) {
+        fprintf(stderr, "memory allocation failure\n");
+        return 4;
+    }
+    if (len == 0) {
+        fprintf(stderr, "could not read %s, or it was empty\n",
+                name == NULL ? "<stdin>" : name);
+        free(source);
+        return 3;
+    }
+    if (skip >= len) {
+        fprintf(stderr, "skip request of %d leaves no input\n", skip);
+        free(source);
+        return 3;
+    }
+
+    /* test inflate data with offset skip */
+    len -= skip;
+    sourcelen = (unsigned long)len;
+    ret = puff(NIL, &destlen, source + skip, &sourcelen);
     if (ret)
-        printf("puff() failed with return code %d\n", ret);
+        fprintf(stderr, "puff() failed with return code %d\n", ret);
     else {
-        printf("puff() succeeded uncompressing %lu bytes\n", destlen);
-        if (sourcelen < len) printf("%lu compressed bytes unused\n",
-                                    len - sourcelen);
+        fprintf(stderr, "puff() succeeded uncompressing %lu bytes\n", destlen);
+        if (sourcelen < len) fprintf(stderr, "%lu compressed bytes unused\n",
+                                     len - sourcelen);
     }
+
+    /* if requested, inflate again and write decompressd data to stdout */
+    if (put) {
+        dest = malloc(destlen);
+        if (dest == NULL) {
+            fprintf(stderr, "memory allocation failure\n");
+            free(source);
+            return 4;
+        }
+        puff(dest, &destlen, source + skip, &sourcelen);
+        fwrite(dest, 1, destlen, stdout);
+        free(dest);
+    }
+
+    /* clean up */
     free(source);
     return ret;
 }
diff --git a/contrib/puff/puff.h b/contrib/puff/puff.h
index ef61252..8d7f5f8 100644
--- a/contrib/puff/puff.h
+++ b/contrib/puff/puff.h
@@ -1,6 +1,6 @@
 /* puff.h
-  Copyright (C) 2002, 2003 Mark Adler, all rights reserved
-  version 1.7, 3 Mar 2002
+  Copyright (C) 2002-2008 Mark Adler, all rights reserved
+  version 1.9, 10 Jan 2008
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the author be held liable for any damages
diff --git a/contrib/vstudio/vc7/zlib.rc b/contrib/vstudio/vc7/zlib.rc
index 39eca7e..98ca20b 100644
--- a/contrib/vstudio/vc7/zlib.rc
+++ b/contrib/vstudio/vc7/zlib.rc
@@ -2,8 +2,8 @@
 

 #define IDR_VERSION1  1

 IDR_VERSION1    VERSIONINFO     MOVEABLE IMPURE LOADONCALL DISCARDABLE

-  FILEVERSION    1,2,3,3

-  PRODUCTVERSION 1,2,3,3

+  FILEVERSION    1,2,3,4

+  PRODUCTVERSION 1,2,3,4

   FILEFLAGSMASK VS_FFI_FILEFLAGSMASK

   FILEFLAGS     0

   FILEOS        VOS_DOS_WINDOWS32

@@ -17,7 +17,7 @@ BEGIN
 

     BEGIN

       VALUE "FileDescription", "zlib data compression library\0"

-      VALUE "FileVersion",      "1.2.3.3\0"

+      VALUE "FileVersion",      "1.2.3.4\0"

       VALUE "InternalName",     "zlib\0"

       VALUE "OriginalFilename", "zlib.dll\0"

       VALUE "ProductName",      "ZLib.DLL\0"