Changeset 8198f69 in rtems


Ignore:
Timestamp:
Mar 18, 2011, 10:10:55 AM (9 years ago)
Author:
Ralf Corsepius <ralf.corsepius@…>
Branches:
4.11, master
Children:
a7aa735
Parents:
e7fc2fd
Message:

Import zlib-1.2.3

Location:
cpukit/zlib
Files:
10 added
70 edited

Legend:

Unmodified
Added
Removed
  • cpukit/zlib/ChangeLog

    re7fc2fd r8198f69  
    11
    22                ChangeLog file for zlib
     3
     4Changes in 1.2.3 (18 July 2005)
     5- Apply security vulnerability fixes to contrib/infback9 as well
     6- Clean up some text files (carriage returns, trailing space)
     7- Update testzlib, vstudio, masmx64, and masmx86 in contrib [Vollant]
     8
     9Changes in 1.2.2.4 (11 July 2005)
     10- Add inflatePrime() function for starting inflation at bit boundary
     11- Avoid some Visual C warnings in deflate.c
     12- Avoid more silly Visual C warnings in inflate.c and inftrees.c for 64-bit
     13  compile
     14- Fix some spelling errors in comments [Betts]
     15- Correct inflateInit2() error return documentation in zlib.h
     16- Added zran.c example of compressed data random access to examples
     17  directory, shows use of inflatePrime()
     18- Fix cast for assignments to strm->state in inflate.c and infback.c
     19- Fix zlibCompileFlags() in zutil.c to use 1L for long shifts [Oberhumer]
     20- Move declarations of gf2 functions to right place in crc32.c [Oberhumer]
     21- Add cast in trees.c t avoid a warning [Oberhumer]
     22- Avoid some warnings in fitblk.c, gun.c, gzjoin.c in examples [Oberhumer]
     23- Update make_vms.com [Zinser]
     24- Initialize state->write in inflateReset() since copied in inflate_fast()
     25- Be more strict on incomplete code sets in inflate_table() and increase
     26  ENOUGH and MAXD -- this repairs a possible security vulnerability for
     27  invalid inflate input.  Thanks to Tavis Ormandy and Markus Oberhumer for
     28  discovering the vulnerability and providing test cases.
     29- Add ia64 support to configure for HP-UX [Smith]
     30- Add error return to gzread() for format or i/o error [Levin]
     31- Use malloc.h for OS/2 [Necasek]
     32
     33Changes in 1.2.2.3 (27 May 2005)
     34- Replace 1U constants in inflate.c and inftrees.c for 64-bit compile
     35- Typecast fread() return values in gzio.c [Vollant]
     36- Remove trailing space in minigzip.c outmode (VC++ can't deal with it)
     37- Fix crc check bug in gzread() after gzungetc() [Heiner]
     38- Add the deflateTune() function to adjust internal compression parameters
     39- Add a fast gzip decompressor, gun.c, to examples (use of inflateBack)
     40- Remove an incorrect assertion in examples/zpipe.c
     41- Add C++ wrapper in infback9.h [Donais]
     42- Fix bug in inflateCopy() when decoding fixed codes
     43- Note in zlib.h how much deflateSetDictionary() actually uses
     44- Remove USE_DICT_HEAD in deflate.c (would mess up inflate if used)
     45- Add _WIN32_WCE to define WIN32 in zconf.in.h [Spencer]
     46- Don't include stderr.h or errno.h for _WIN32_WCE in zutil.h [Spencer]
     47- Add gzdirect() function to indicate transparent reads
     48- Update contrib/minizip [Vollant]
     49- Fix compilation of deflate.c when both ASMV and FASTEST [Oberhumer]
     50- Add casts in crc32.c to avoid warnings [Oberhumer]
     51- Add contrib/masmx64 [Vollant]
     52- Update contrib/asm586, asm686, masmx86, testzlib, vstudio [Vollant]
    353
    454Changes in 1.2.2.2 (30 December 2004)
     
    491541- add functions gzprintf, gzputc, gzgetc, gztell, gzeof, gzseek, gzrewind and
    492542  gzsetparams (thanks to Roland Giersig and Kevin Ruland for some of this code)
    493 - Fix a deflate bug occuring only with compression level 0 (thanks to
     543- Fix a deflate bug occurring only with compression level 0 (thanks to
    494544  Andy Buckler for finding this one).
    495545- In minigzip, pass transparently also the first byte for .Z files.
  • cpukit/zlib/Makefile

    re7fc2fd r8198f69  
    11# Makefile for zlib
    2 # Copyright (C) 1995-2003 Jean-loup Gailly.
     2# Copyright (C) 1995-2005 Jean-loup Gailly.
    33# For conditions of distribution and use, see copyright notice in zlib.h
    44
     
    3131LIBS=libz.a
    3232SHAREDLIB=libz.so
    33 SHAREDLIBV=libz.so.1.2.2.2
     33SHAREDLIBV=libz.so.1.2.3
    3434SHAREDLIBM=libz.so.1
    3535
  • cpukit/zlib/Makefile.in

    re7fc2fd r8198f69  
    11# Makefile for zlib
    2 # Copyright (C) 1995-2003 Jean-loup Gailly.
     2# Copyright (C) 1995-2005 Jean-loup Gailly.
    33# For conditions of distribution and use, see copyright notice in zlib.h
    44
     
    3131LIBS=libz.a
    3232SHAREDLIB=libz.so
    33 SHAREDLIBV=libz.so.1.2.2.2
     33SHAREDLIBV=libz.so.1.2.3
    3434SHAREDLIBM=libz.so.1
    3535
  • cpukit/zlib/README

    re7fc2fd r8198f69  
    11ZLIB DATA COMPRESSION LIBRARY
    22
    3 zlib 1.2.2.2 is a general purpose data compression library.  All the code is
     3zlib 1.2.3 is a general purpose data compression library.  All the code is
    44thread safe.  The data format used by the zlib library is described by RFCs
    55(Request for Comments) 1950 to 1952 in the files
     
    3434http://dogma.net/markn/articles/zlibtool/zlibtool.htm
    3535
    36 The changes made in version 1.2.2.2 are documented in the file ChangeLog.
     36The changes made in version 1.2.3 are documented in the file ChangeLog.
    3737
    3838Unsupported third party contributions are provided in directory "contrib".
  • cpukit/zlib/amiga/Makefile.sas

    re7fc2fd r8198f69  
    2424test: all
    2525        example
    26         echo hello world | minigzip | minigzip -d 
     26        echo hello world | minigzip | minigzip -d
    2727
    2828install: z.lib
  • cpukit/zlib/as400/compile.clp

    re7fc2fd r8198f69  
    119119                                 &MODLIB/UNCOMPR     &MODLIB/ZUTIL)      +
    120120                          SRCFILE(&SRCLIB/&CTLFILE) SRCMBR(BNDSRC) +
    121                           TEXT('ZLIB 1.2.2') TGTRLS(V4R4M0)
     121                          TEXT('ZLIB 1.2.3') TGTRLS(V4R4M0)
    122122
    123123             ENDPGM
  • cpukit/zlib/as400/readme.txt

    re7fc2fd r8198f69  
    1         ZLIB version 1.2.2 for AS400 installation instructions
     1        ZLIB version 1.2.3 for AS400 installation instructions
    22
    33I) From an AS400 *SAVF file:
  • cpukit/zlib/as400/zlib.inc

    re7fc2fd r8198f69  
    22      *
    33      *  ILE RPG400 version by Patrick Monnerat, DATASPHERE.
    4       *  Version 1.2.2.2
     4      *  Version 1.2.3
    55      *
    66      *
     
    2121      **************************************************************************
    2222      *
    23      D ZLIB_VERSION    C                   '1.2.2.2'                            Header's version
    24      D ZLIB_VERNUM     C                   X'1222'
     23      *  Versioning information.
     24      *
     25     D ZLIB_VERSION    C                   '1.2.3'
     26     D ZLIB_VERNUM     C                   X'1230'
     27      *
     28      *  Other equates.
    2529      *
    2630     D Z_NO_FLUSH      C                   0
  • cpukit/zlib/configure

    re7fc2fd r8198f69  
    8383         # (alain.bonnefoy@icbt.com)
    8484                 LDSHARED=${LDSHARED-"$cc -shared -Wl,-hlibz.so.1"};;
    85   HP-UX*)        LDSHARED=${LDSHARED-"$cc -shared $SFLAGS"}
     85  HP-UX*)
     86         LDSHARED=${LDSHARED-"$cc -shared $SFLAGS"}
     87         case `(uname -m || echo unknown) 2>/dev/null` in
     88         ia64)
     89                 shared_ext='.so'
     90                 SHAREDLIB='libz.so';;
     91         *)
    8692                 shared_ext='.sl'
    8793                 SHAREDLIB='libz.sl';;
     94         esac;;
    8895  Darwin*)   shared_ext='.dylib'
    8996             SHAREDLIB=libz$shared_ext
     
    101108#            LDSHARED=${LDSHARED-"ld -b +vnocompatwarnings"}
    102109             LDSHARED=${LDSHARED-"ld -b"}
     110         case `(uname -m || echo unknown) 2>/dev/null` in
     111         ia64)
     112             shared_ext='.so'
     113             SHAREDLIB='libz.so';;
     114         *)
    103115             shared_ext='.sl'
    104116             SHAREDLIB='libz.sl';;
     117         esac;;
    105118  IRIX*)     SFLAGS=${CFLAGS-"-ansi -O2 -rpath ."}
    106119             CFLAGS=${CFLAGS-"-ansi -O2"}
  • cpukit/zlib/contrib/README.contrib

    re7fc2fd r8198f69  
    4343        asm code for Pentium Pro/PII, using the MASM syntax
    4444
     45masmx64/    by Gilles Vollant <info@winimage.com>
     46        x86 64-bit (AMD64 and Intel EM64t) code for x64 assembler to
     47        replace longest_match() and inflate_fast()
     48
    4549masmx86/    by Gilles Vollant <info@winimage.com>
    4650        x86 asm code to replace longest_match() and inflate_fast(),
  • cpukit/zlib/contrib/asm586/match.S

    re7fc2fd r8198f69  
    4646 * compile time. Sigh.)
    4747 */
    48 #define dsWSize                 36
    49 #define dsWMask                 44
    50 #define dsWindow                48
    51 #define dsPrev                  56
    52 #define dsMatchLen              88
    53 #define dsPrevMatch             92
    54 #define dsStrStart              100
    55 #define dsMatchStart            104
    56 #define dsLookahead             108
    57 #define dsPrevLen               112
    58 #define dsMaxChainLen           116
    59 #define dsGoodMatch             132
    60 #define dsNiceMatch             136
     48
     49/* All the +zlib1222add offsets are due to the addition of fields
     50 *  in zlib in the deflate_state structure since the asm code was first written
     51 * (if you compile with zlib 1.0.4 or older, use "zlib1222add equ (-4)").
     52 * (if you compile with zlib between 1.0.5 and 1.2.2.1, use "zlib1222add equ 0").
     53 * if you compile with zlib 1.2.2.2 or later , use "zlib1222add equ 8").
     54 */
     55
     56#define zlib1222add             (8)
     57
     58#define dsWSize                 (36+zlib1222add)
     59#define dsWMask                 (44+zlib1222add)
     60#define dsWindow                (48+zlib1222add)
     61#define dsPrev                  (56+zlib1222add)
     62#define dsMatchLen              (88+zlib1222add)
     63#define dsPrevMatch             (92+zlib1222add)
     64#define dsStrStart              (100+zlib1222add)
     65#define dsMatchStart            (104+zlib1222add)
     66#define dsLookahead             (108+zlib1222add)
     67#define dsPrevLen               (112+zlib1222add)
     68#define dsMaxChainLen           (116+zlib1222add)
     69#define dsGoodMatch             (132+zlib1222add)
     70#define dsNiceMatch             (136+zlib1222add)
    6171
    6272
  • cpukit/zlib/contrib/asm686/match.S

    re7fc2fd r8198f69  
    3939#define curmatch                60
    4040
    41 /* Offsets for fields in the deflate_state structure. These numbers
    42  * are calculated from the definition of deflate_state, with the
    43  * assumption that the compiler will dword-align the fields. (Thus,
    44  * changing the definition of deflate_state could easily cause this
    45  * program to crash horribly, without so much as a warning at
    46  * compile time. Sigh.)
     41/* All the +zlib1222add offsets are due to the addition of fields
     42 *  in zlib in the deflate_state structure since the asm code was first written
     43 * (if you compile with zlib 1.0.4 or older, use "zlib1222add equ (-4)").
     44 * (if you compile with zlib between 1.0.5 and 1.2.2.1, use "zlib1222add equ 0").
     45 * if you compile with zlib 1.2.2.2 or later , use "zlib1222add equ 8").
    4746 */
    48 #define dsWSize                 36
    49 #define dsWMask                 44
    50 #define dsWindow                48
    51 #define dsPrev                  56
    52 #define dsMatchLen              88
    53 #define dsPrevMatch             92
    54 #define dsStrStart              100
    55 #define dsMatchStart            104
    56 #define dsLookahead             108
    57 #define dsPrevLen               112
    58 #define dsMaxChainLen           116
    59 #define dsGoodMatch             132
    60 #define dsNiceMatch             136
     47
     48#define zlib1222add             (8)
     49
     50#define dsWSize                 (36+zlib1222add)
     51#define dsWMask                 (44+zlib1222add)
     52#define dsWindow                (48+zlib1222add)
     53#define dsPrev                  (56+zlib1222add)
     54#define dsMatchLen              (88+zlib1222add)
     55#define dsPrevMatch             (92+zlib1222add)
     56#define dsStrStart              (100+zlib1222add)
     57#define dsMatchStart            (104+zlib1222add)
     58#define dsLookahead             (108+zlib1222add)
     59#define dsPrevLen               (112+zlib1222add)
     60#define dsMaxChainLen           (116+zlib1222add)
     61#define dsGoodMatch             (132+zlib1222add)
     62#define dsNiceMatch             (136+zlib1222add)
    6163
    6264
  • cpukit/zlib/contrib/delphi/ZLib.pas

    re7fc2fd r8198f69  
    153153
    154154const
    155   zlib_version = '1.2.2';
     155  zlib_version = '1.2.3';
    156156
    157157type
  • cpukit/zlib/contrib/dotzlib/DotZLib/UnitTests.cs

    re7fc2fd r8198f69  
    157157        {
    158158            Info info = new Info();
    159             Assert.AreEqual("1.2.2", Info.Version);
     159            Assert.AreEqual("1.2.3", Info.Version);
    160160            Assert.AreEqual(32, info.SizeOfUInt);
    161161            Assert.AreEqual(32, info.SizeOfULong);
  • cpukit/zlib/contrib/infback9/infback9.h

    re7fc2fd r8198f69  
    1717 */
    1818
     19#ifdef __cplusplus
     20extern "C" {
     21#endif
     22
    1923ZEXTERN int ZEXPORT inflateBack9 OF((z_stream FAR *strm,
    2024                                    in_func in, void FAR *in_desc,
     
    2832        inflateBack9Init_((strm), (window), \
    2933        ZLIB_VERSION, sizeof(z_stream))
     34
     35#ifdef __cplusplus
     36}
     37#endif
  • cpukit/zlib/contrib/infback9/inftree9.c

    re7fc2fd r8198f69  
    11/* inftree9.c -- generate Huffman trees for efficient decoding
    2  * Copyright (C) 1995-2003 Mark Adler
     2 * Copyright (C) 1995-2005 Mark Adler
    33 * For conditions of distribution and use, see copyright notice in zlib.h
    44 */
     
    1010
    1111const char inflate9_copyright[] =
    12    " inflate9 1.2.2.2 Copyright 1995-2004 Mark Adler ";
     12   " inflate9 1.2.3 Copyright 1995-2005 Mark Adler ";
    1313/*
    1414  If you use the zlib library in a product, an acknowledgment is welcome
     
    6565        128, 128, 128, 128, 128, 128, 128, 128, 129, 129, 129, 129,
    6666        130, 130, 130, 130, 131, 131, 131, 131, 132, 132, 132, 132,
    67         133, 133, 133, 133, 144, 72, 199};
     67        133, 133, 133, 133, 144, 201, 196};
    6868    static const unsigned short dbase[32] = { /* Distance codes 0..31 base */
    6969        1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49,
     
    129129        if (left < 0) return -1;        /* over-subscribed */
    130130    }
    131     if (left > 0 && (type == CODES || (codes - count[0] != 1)))
     131    if (left > 0 && (type == CODES || max != 1))
    132132        return -1;                      /* incomplete set */
    133133
  • cpukit/zlib/contrib/infback9/inftree9.h

    re7fc2fd r8198f69  
    3737
    3838/* Maximum size of dynamic tree.  The maximum found in a long but non-
    39    exhaustive search was 1004 code structures (850 for length/literals
    40    and 154 for distances, the latter actually the result of an
     39   exhaustive search was 1444 code structures (852 for length/literals
     40   and 592 for distances, the latter actually the result of an
    4141   exhaustive search).  The true maximum is not known, but the value
    4242   below is more than safe. */
    43 #define ENOUGH 1440
    44 #define MAXD 154
     43#define ENOUGH 2048
     44#define MAXD 592
    4545
    4646/* Type of code to build for inftable() */
  • cpukit/zlib/contrib/masm686/match.asm

    re7fc2fd r8198f69  
    1313; Written for zlib 1.1.2
    1414; Copyright (C) 1998 Brian Raiter <breadbox@muppetlabs.com>
     15;
     16; Modified by Gilles Vollant (2005) for add gzhead and gzindex
    1517
    1618        .686P
     
    4042ds_pending              dd ?
    4143ds_wrap                 dd ?
     44; gzhead and gzindex are added in zlib 1.2.2.2 (see deflate.h)
     45ds_gzhead               dd ?
     46ds_gzindex              dd ?
    4247ds_data_type            db ?
    4348ds_method               db ?
  • cpukit/zlib/contrib/masmx86/gvmat32.asm

    re7fc2fd r8198f69  
    1 ;
    21; gvmat32.asm -- Asm portion of the optimized longest_match for 32 bits x86
    32; Copyright (C) 1995-1996 Jean-loup Gailly and Gilles Vollant.
    43; File written by Gilles Vollant, by modifiying the longest_match
    54;  from Jean-loup Gailly in deflate.c
    6 ; It need wmask == 0x7fff
    7 ;     (assembly code is faster with a fixed wmask)
    8 ;
    9 ; For Visual C++ 4.2 and ML 6.11c (version in directory \MASM611C of Win95 DDK)
    10 ;   I compile with : "ml /coff /Zi /c gvmat32.asm"
    11 ;
     5;
     6;         http://www.zlib.net
     7;         http://www.winimage.com/zLibDll
     8;         http://www.muppetlabs.com/~breadbox/software/assembly.html
     9;
     10; For Visual C++ 4.x and higher and ML 6.x and higher
     11;   ml.exe is in directory \MASM611C of Win95 DDK
     12;   ml.exe is also distributed in http://www.masm32.com/masmdl.htm
     13;    and in VC++2003 toolkit at http://msdn.microsoft.com/visualc/vctoolkit2003/
     14;
     15; this file contain two implementation of longest_match
     16;
     17;  longest_match_7fff : written 1996 by Gilles Vollant optimized for
     18;            first Pentium. Assume s->w_mask == 0x7fff
     19;  longest_match_686 : written by Brian raiter (1998), optimized for Pentium Pro
     20;
     21;  for using an seembly version of longest_match, you need define ASMV in project
     22;  There is two way in using gvmat32.asm
     23;
     24;  A) Suggested method
     25;    if you want include both longest_match_7fff and longest_match_686
     26;    compile the asm file running
     27;           ml /coff /Zi /Flgvmat32.lst /c gvmat32.asm
     28;    and include gvmat32c.c in your project
     29;    if you have an old cpu (386,486 or first Pentium) and s->w_mask==0x7fff,
     30;        longest_match_7fff will be used
     31;    if you have a more modern CPU (Pentium Pro, II and higher)
     32;        longest_match_686 will be used
     33;    on old cpu with s->w_mask!=0x7fff, longest_match_686 will be used,
     34;        but this is not a sitation you'll find often
     35;
     36;  B) Alternative
     37;    if you are not interresed in old cpu performance and want the smaller
     38;       binaries possible
     39;
     40;    compile the asm file running
     41;           ml /coff /Zi /c /Flgvmat32.lst /DNOOLDPENTIUMCODE gvmat32.asm
     42;    and do not include gvmat32c.c in your project (ou define also
     43;              NOOLDPENTIUMCODE)
     44;
     45; note : as I known, longest_match_686 is very faster than longest_match_7fff
     46;        on pentium Pro/II/III, faster (but less) in P4, but it seem
     47;        longest_match_7fff can be faster (very very litte) on AMD Athlon64/K8
     48;
     49; see below : zlib1222add must be adjuster if you use a zlib version < 1.2.2.2
    1250
    1351;uInt longest_match_7fff(s, cur_match)
     
    1553;    IPos cur_match;                             /* current match */
    1654
    17         NbStack         equ     76
    18         cur_match       equ     dword ptr[esp+NbStack-0]
    19         str_s           equ     dword ptr[esp+NbStack-4]
     55    NbStack         equ     76
     56    cur_match       equ     dword ptr[esp+NbStack-0]
     57    str_s           equ     dword ptr[esp+NbStack-4]
    2058; 5 dword on top (ret,ebp,esi,edi,ebx)
    21         adrret          equ     dword ptr[esp+NbStack-8]
    22         pushebp         equ     dword ptr[esp+NbStack-12]
    23         pushedi         equ     dword ptr[esp+NbStack-16]
    24         pushesi         equ     dword ptr[esp+NbStack-20]
    25         pushebx         equ     dword ptr[esp+NbStack-24]
    26 
    27         chain_length    equ     dword ptr [esp+NbStack-28]
    28         limit           equ     dword ptr [esp+NbStack-32]
    29         best_len        equ     dword ptr [esp+NbStack-36]
    30         window          equ     dword ptr [esp+NbStack-40]
    31         prev            equ     dword ptr [esp+NbStack-44]
    32         scan_start      equ      word ptr [esp+NbStack-48]
    33         wmask           equ     dword ptr [esp+NbStack-52]
    34         match_start_ptr equ     dword ptr [esp+NbStack-56]
    35         nice_match      equ     dword ptr [esp+NbStack-60]
    36         scan            equ     dword ptr [esp+NbStack-64]
    37 
    38         windowlen       equ     dword ptr [esp+NbStack-68]
    39         match_start     equ     dword ptr [esp+NbStack-72]
    40         strend          equ     dword ptr [esp+NbStack-76]
    41         NbStackAdd      equ     (NbStack-24)
     59    adrret          equ     dword ptr[esp+NbStack-8]
     60    pushebp         equ     dword ptr[esp+NbStack-12]
     61    pushedi         equ     dword ptr[esp+NbStack-16]
     62    pushesi         equ     dword ptr[esp+NbStack-20]
     63    pushebx         equ     dword ptr[esp+NbStack-24]
     64
     65    chain_length    equ     dword ptr [esp+NbStack-28]
     66    limit           equ     dword ptr [esp+NbStack-32]
     67    best_len        equ     dword ptr [esp+NbStack-36]
     68    window          equ     dword ptr [esp+NbStack-40]
     69    prev            equ     dword ptr [esp+NbStack-44]
     70    scan_start      equ      word ptr [esp+NbStack-48]
     71    wmask           equ     dword ptr [esp+NbStack-52]
     72    match_start_ptr equ     dword ptr [esp+NbStack-56]
     73    nice_match      equ     dword ptr [esp+NbStack-60]
     74    scan            equ     dword ptr [esp+NbStack-64]
     75
     76    windowlen       equ     dword ptr [esp+NbStack-68]
     77    match_start     equ     dword ptr [esp+NbStack-72]
     78    strend          equ     dword ptr [esp+NbStack-76]
     79    NbStackAdd      equ     (NbStack-24)
    4280
    4381    .386p
     
    4886
    4987
    50 ;  all the +addstr offsets are due to the addition of pending_buf_size in zlib 1.04
    51 ;  and adding gzhead and gzindex in zlib 1.2.2.1
    52 ;  in the deflate_state structure since the asm code was first written
    53 ;  (if you compile with zlib 1.0.4 or older, set addstr to 0).
    54 ;  (if you compiler with zlib between 1.04 and 1.2.1, set addstr to 4)
     88;  all the +zlib1222add offsets are due to the addition of fields
     89;  in zlib in the deflate_state structure since the asm code was first written
     90;  (if you compile with zlib 1.0.4 or older, use "zlib1222add equ (-4)").
     91;  (if you compile with zlib between 1.0.5 and 1.2.2.1, use "zlib1222add equ 0").
     92;  if you compile with zlib 1.2.2.2 or later , use "zlib1222add equ 8").
     93
     94    zlib1222add         equ     8
     95
    5596;  Note : these value are good with a 8 bytes boundary pack structure
    56 
    57     addstr              equ     4+8
    58     dep_chain_length    equ     70h+addstr
    59     dep_window          equ     2ch+addstr
    60     dep_strstart        equ     60h+addstr
    61     dep_prev_length     equ     6ch+addstr
    62     dep_nice_match      equ     84h+addstr
    63     dep_w_size          equ     20h+addstr
    64     dep_prev            equ     34h+addstr
    65     dep_w_mask          equ     28h+addstr
    66     dep_good_match      equ     80h+addstr
    67     dep_match_start     equ     64h+addstr
    68     dep_lookahead       equ     68h+addstr
     97    dep_chain_length    equ     74h+zlib1222add
     98    dep_window          equ     30h+zlib1222add
     99    dep_strstart        equ     64h+zlib1222add
     100    dep_prev_length     equ     70h+zlib1222add
     101    dep_nice_match      equ     88h+zlib1222add
     102    dep_w_size          equ     24h+zlib1222add
     103    dep_prev            equ     38h+zlib1222add
     104    dep_w_mask          equ     2ch+zlib1222add
     105    dep_good_match      equ     84h+zlib1222add
     106    dep_match_start     equ     68h+zlib1222add
     107    dep_lookahead       equ     6ch+zlib1222add
    69108
    70109
     
    72111
    73112IFDEF NOUNDERLINE
    74                         public  longest_match_7fff
    75                         public  longest_match_686
    76 ;                        public  match_init
     113   IFDEF NOOLDPENTIUMCODE
     114            public  longest_match
     115            public  match_init
     116   ELSE           
     117            public  longest_match_7fff
     118            public  cpudetect32
     119            public  longest_match_686
     120   ENDIF
    77121ELSE
    78                         public  _longest_match_7fff
    79                         public  _longest_match_686
    80 ;                        public  _match_init
     122   IFDEF NOOLDPENTIUMCODE
     123            public  _longest_match
     124            public  _match_init
     125   ELSE
     126            public  _longest_match_7fff
     127            public  _cpudetect32
     128            public  _longest_match_686
     129   ENDIF
    81130ENDIF
    82131
     
    87136
    88137
    89 IFDEF NOUNDERLINE
    90 ;match_init      proc near
    91 ;                ret
    92 ;match_init      endp
    93 ELSE
    94 ;_match_init     proc near
    95 ;                ret
    96 ;_match_init     endp
    97 ENDIF
    98 
    99 
     138IFNDEF NOOLDPENTIUMCODE
    100139IFDEF NOUNDERLINE
    101140longest_match_7fff   proc near
     
    104143ENDIF
    105144
    106         mov     edx,[esp+4]
    107 
    108 
    109 
    110         push    ebp
    111         push    edi
    112         push    esi
    113         push    ebx
    114 
    115         sub     esp,NbStackAdd
     145    mov     edx,[esp+4]
     146
     147
     148
     149    push    ebp
     150    push    edi
     151    push    esi
     152    push    ebx
     153
     154    sub     esp,NbStackAdd
    116155
    117156; initialize or check the variables used in match.asm.
    118         mov     ebp,edx
     157    mov     ebp,edx
    119158
    120159; chain_length = s->max_chain_length
    121160; if (prev_length>=good_match) chain_length >>= 2
    122         mov     edx,[ebp+dep_chain_length]
    123         mov     ebx,[ebp+dep_prev_length]
    124         cmp     [ebp+dep_good_match],ebx
    125         ja      noshr
    126         shr     edx,2
     161    mov     edx,[ebp+dep_chain_length]
     162    mov     ebx,[ebp+dep_prev_length]
     163    cmp     [ebp+dep_good_match],ebx
     164    ja      noshr
     165    shr     edx,2
    127166noshr:
    128167; we increment chain_length because in the asm, the --chain_lenght is in the beginning of the loop
    129         inc     edx
    130         mov     edi,[ebp+dep_nice_match]
    131         mov     chain_length,edx
    132         mov     eax,[ebp+dep_lookahead]
    133         cmp     eax,edi
     168    inc     edx
     169    mov     edi,[ebp+dep_nice_match]
     170    mov     chain_length,edx
     171    mov     eax,[ebp+dep_lookahead]
     172    cmp     eax,edi
    134173; if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead;
    135         jae     nolookaheadnicematch
    136         mov     edi,eax
     174    jae     nolookaheadnicematch
     175    mov     edi,eax
    137176nolookaheadnicematch:
    138177; best_len = s->prev_length
    139         mov     best_len,ebx
     178    mov     best_len,ebx
    140179
    141180; window = s->window
    142         mov     esi,[ebp+dep_window]
    143         mov     ecx,[ebp+dep_strstart]
    144         mov     window,esi
    145 
    146         mov     nice_match,edi
     181    mov     esi,[ebp+dep_window]
     182    mov     ecx,[ebp+dep_strstart]
     183    mov     window,esi
     184
     185    mov     nice_match,edi
    147186; scan = window + strstart
    148         add     esi,ecx
    149         mov     scan,esi
     187    add     esi,ecx
     188    mov     scan,esi
    150189; dx = *window
    151         mov     dx,word ptr [esi]
     190    mov     dx,word ptr [esi]
    152191; bx = *(window+best_len-1)
    153         mov     bx,word ptr [esi+ebx-1]
    154         add     esi,MAX_MATCH-1
     192    mov     bx,word ptr [esi+ebx-1]
     193    add     esi,MAX_MATCH-1
    155194; scan_start = *scan
    156         mov     scan_start,dx
     195    mov     scan_start,dx
    157196; strend = scan + MAX_MATCH-1
    158         mov     strend,esi
     197    mov     strend,esi
    159198; bx = scan_end = *(window+best_len-1)
    160199
     
    162201;        s->strstart - (IPos)MAX_DIST(s) : NIL;
    163202
    164         mov     esi,[ebp+dep_w_size]
    165         sub     esi,MIN_LOOKAHEAD
     203    mov     esi,[ebp+dep_w_size]
     204    sub     esi,MIN_LOOKAHEAD
    166205; here esi = MAX_DIST(s)
    167         sub     ecx,esi
    168         ja      nodist
    169         xor     ecx,ecx
     206    sub     ecx,esi
     207    ja      nodist
     208    xor     ecx,ecx
    170209nodist:
    171         mov     limit,ecx
     210    mov     limit,ecx
    172211
    173212; prev = s->prev
    174         mov     edx,[ebp+dep_prev]
    175         mov     prev,edx
    176 
    177 ;
    178         mov     edx,dword ptr [ebp+dep_match_start]
    179         mov     bp,scan_start
    180         mov     eax,cur_match
    181         mov     match_start,edx
    182 
    183         mov     edx,window
    184         mov     edi,edx
    185         add     edi,best_len
    186         mov     esi,prev
    187         dec     edi
     213    mov     edx,[ebp+dep_prev]
     214    mov     prev,edx
     215
     216;
     217    mov     edx,dword ptr [ebp+dep_match_start]
     218    mov     bp,scan_start
     219    mov     eax,cur_match
     220    mov     match_start,edx
     221
     222    mov     edx,window
     223    mov     edi,edx
     224    add     edi,best_len
     225    mov     esi,prev
     226    dec     edi
    188227; windowlen = window + best_len -1
    189         mov     windowlen,edi
    190 
    191         jmp     beginloop2
    192         align   4
     228    mov     windowlen,edi
     229
     230    jmp     beginloop2
     231    align   4
    193232
    194233; here, in the loop
     
    203242;// here; chain_length <=16
    204243normalbeg0add16:
    205         add     chain_length,16
    206         jz      exitloop
     244    add     chain_length,16
     245    jz      exitloop
    207246normalbeg0:
    208         cmp     word ptr[edi+eax],bx
    209         je      normalbeg2noroll
     247    cmp     word ptr[edi+eax],bx
     248    je      normalbeg2noroll
    210249rcontlabnoroll:
    211250; cur_match = prev[cur_match & wmask]
    212         and     eax,7fffh
    213         mov     ax,word ptr[esi+eax*2]
     251    and     eax,7fffh
     252    mov     ax,word ptr[esi+eax*2]
    214253; if cur_match > limit, go to exitloop
    215         cmp     ecx,eax
    216         jnb     exitloop
     254    cmp     ecx,eax
     255    jnb     exitloop
    217256; if --chain_length != 0, go to exitloop
    218         dec     chain_length
    219         jnz     normalbeg0
    220         jmp     exitloop
     257    dec     chain_length
     258    jnz     normalbeg0
     259    jmp     exitloop
    221260
    222261normalbeg2noroll:
    223262; if (scan_start==*(cur_match+window)) goto normalbeg2
    224         cmp     bp,word ptr[edx+eax]
    225         jne     rcontlabnoroll
    226         jmp     normalbeg2
     263    cmp     bp,word ptr[edx+eax]
     264    jne     rcontlabnoroll
     265    jmp     normalbeg2
    227266
    228267contloop3:
    229         mov     edi,windowlen
     268    mov     edi,windowlen
    230269
    231270; cur_match = prev[cur_match & wmask]
    232         and     eax,7fffh
    233         mov     ax,word ptr[esi+eax*2]
     271    and     eax,7fffh
     272    mov     ax,word ptr[esi+eax*2]
    234273; if cur_match > limit, go to exitloop
    235         cmp     ecx,eax
     274    cmp     ecx,eax
    236275jnbexitloopshort1:
    237         jnb     exitloop
     276    jnb     exitloop
    238277; if --chain_length != 0, go to exitloop
    239278
     
    241280; begin the main loop
    242281beginloop2:
    243         sub     chain_length,16+1
     282    sub     chain_length,16+1
    244283; if chain_length <=16, don't use the unrolled loop
    245         jna     normalbeg0add16
     284    jna     normalbeg0add16
    246285
    247286do16:
    248         cmp     word ptr[edi+eax],bx
    249         je      normalbeg2dc0
     287    cmp     word ptr[edi+eax],bx
     288    je      normalbeg2dc0
    250289
    251290maccn   MACRO   lab
    252         and     eax,7fffh
    253         mov     ax,word ptr[esi+eax*2]
    254         cmp     ecx,eax
    255         jnb     exitloop
    256         cmp     word ptr[edi+eax],bx
    257         je      lab
    258         ENDM
     291    and     eax,7fffh
     292    mov     ax,word ptr[esi+eax*2]
     293    cmp     ecx,eax
     294    jnb     exitloop
     295    cmp     word ptr[edi+eax],bx
     296    je      lab
     297    ENDM
    259298
    260299rcontloop0:
    261         maccn   normalbeg2dc1
     300    maccn   normalbeg2dc1
    262301
    263302rcontloop1:
    264         maccn   normalbeg2dc2
     303    maccn   normalbeg2dc2
    265304
    266305rcontloop2:
    267         maccn   normalbeg2dc3
     306    maccn   normalbeg2dc3
    268307
    269308rcontloop3:
    270         maccn   normalbeg2dc4
     309    maccn   normalbeg2dc4
    271310
    272311rcontloop4:
    273         maccn   normalbeg2dc5
     312    maccn   normalbeg2dc5
    274313
    275314rcontloop5:
    276         maccn   normalbeg2dc6
     315    maccn   normalbeg2dc6
    277316
    278317rcontloop6:
    279         maccn   normalbeg2dc7
     318    maccn   normalbeg2dc7
    280319
    281320rcontloop7:
    282         maccn   normalbeg2dc8
     321    maccn   normalbeg2dc8
    283322
    284323rcontloop8:
    285         maccn   normalbeg2dc9
     324    maccn   normalbeg2dc9
    286325
    287326rcontloop9:
    288         maccn   normalbeg2dc10
     327    maccn   normalbeg2dc10
    289328
    290329rcontloop10:
    291         maccn   short normalbeg2dc11
     330    maccn   short normalbeg2dc11
    292331
    293332rcontloop11:
    294         maccn   short normalbeg2dc12
     333    maccn   short normalbeg2dc12
    295334
    296335rcontloop12:
    297         maccn   short normalbeg2dc13
     336    maccn   short normalbeg2dc13
    298337
    299338rcontloop13:
    300         maccn   short normalbeg2dc14
     339    maccn   short normalbeg2dc14
    301340
    302341rcontloop14:
    303         maccn   short normalbeg2dc15
     342    maccn   short normalbeg2dc15
    304343
    305344rcontloop15:
    306         and     eax,7fffh
    307         mov     ax,word ptr[esi+eax*2]
    308         cmp     ecx,eax
    309         jnb     exitloop
    310 
    311         sub     chain_length,16
    312         ja      do16
    313         jmp     normalbeg0add16
     345    and     eax,7fffh
     346    mov     ax,word ptr[esi+eax*2]
     347    cmp     ecx,eax
     348    jnb     exitloop
     349
     350    sub     chain_length,16
     351    ja      do16
     352    jmp     normalbeg0add16
    314353
    315354;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
     
    317356normbeg MACRO   rcontlab,valsub
    318357; if we are here, we know that *(match+best_len-1) == scan_end
    319         cmp     bp,word ptr[edx+eax]
     358    cmp     bp,word ptr[edx+eax]
    320359; if (match != scan_start) goto rcontlab
    321         jne     rcontlab
     360    jne     rcontlab
    322361; calculate the good chain_length, and we'll compare scan and match string
    323         add     chain_length,16-valsub
    324         jmp     iseq
    325         ENDM
     362    add     chain_length,16-valsub
     363    jmp     iseq
     364    ENDM
    326365
    327366
    328367normalbeg2dc11:
    329         normbeg rcontloop11,11
     368    normbeg rcontloop11,11
    330369
    331370normalbeg2dc12:
    332         normbeg short rcontloop12,12
     371    normbeg short rcontloop12,12
    333372
    334373normalbeg2dc13:
    335         normbeg short rcontloop13,13
     374    normbeg short rcontloop13,13
    336375
    337376normalbeg2dc14:
    338         normbeg short rcontloop14,14
     377    normbeg short rcontloop14,14
    339378
    340379normalbeg2dc15:
    341         normbeg short rcontloop15,15
     380    normbeg short rcontloop15,15
    342381
    343382normalbeg2dc10:
    344         normbeg rcontloop10,10
     383    normbeg rcontloop10,10
    345384
    346385normalbeg2dc9:
    347         normbeg rcontloop9,9
     386    normbeg rcontloop9,9
    348387
    349388normalbeg2dc8:
    350         normbeg rcontloop8,8
     389    normbeg rcontloop8,8
    351390
    352391normalbeg2dc7:
    353         normbeg rcontloop7,7
     392    normbeg rcontloop7,7
    354393
    355394normalbeg2dc6:
    356         normbeg rcontloop6,6
     395    normbeg rcontloop6,6
    357396
    358397normalbeg2dc5:
    359         normbeg rcontloop5,5
     398    normbeg rcontloop5,5
    360399
    361400normalbeg2dc4:
    362         normbeg rcontloop4,4
     401    normbeg rcontloop4,4
    363402
    364403normalbeg2dc3:
    365         normbeg rcontloop3,3
     404    normbeg rcontloop3,3
    366405
    367406normalbeg2dc2:
    368         normbeg rcontloop2,2
     407    normbeg rcontloop2,2
    369408
    370409normalbeg2dc1:
    371         normbeg rcontloop1,1
     410    normbeg rcontloop1,1
    372411
    373412normalbeg2dc0:
    374         normbeg rcontloop0,0
     413    normbeg rcontloop0,0
    375414
    376415
     
    378417
    379418normalbeg2:
    380         mov     edi,window
    381 
    382         cmp     bp,word ptr[edi+eax]
    383         jne     contloop3                   ; if *(ushf*)match != scan_start, continue
     419    mov     edi,window
     420
     421    cmp     bp,word ptr[edi+eax]
     422    jne     contloop3                   ; if *(ushf*)match != scan_start, continue
    384423
    385424iseq:
     
    387426; and (match == scan_start)
    388427
    389         mov     edi,edx
    390         mov     esi,scan                    ; esi = scan
    391         add     edi,eax                     ; edi = window + cur_match = match
    392 
    393         mov     edx,[esi+3]                 ; compare manually dword at match+3
    394         xor     edx,[edi+3]                 ; and scan +3
    395 
    396         jz      begincompare                ; if equal, go to long compare
     428    mov     edi,edx
     429    mov     esi,scan                    ; esi = scan
     430    add     edi,eax                     ; edi = window + cur_match = match
     431
     432    mov     edx,[esi+3]                 ; compare manually dword at match+3
     433    xor     edx,[edi+3]                 ; and scan +3
     434
     435    jz      begincompare                ; if equal, go to long compare
    397436
    398437; we will determine the unmatch byte and calculate len (in esi)
    399         or      dl,dl
    400         je      eq1rr
    401         mov     esi,3
    402         jmp     trfinval
     438    or      dl,dl
     439    je      eq1rr
     440    mov     esi,3
     441    jmp     trfinval
    403442eq1rr:
    404         or      dx,dx
    405         je      eq1
    406 
    407         mov     esi,4
    408         jmp     trfinval
     443    or      dx,dx
     444    je      eq1
     445
     446    mov     esi,4
     447    jmp     trfinval
    409448eq1:
    410         and     edx,0ffffffh
    411         jz      eq11
    412         mov     esi,5
    413         jmp     trfinval
     449    and     edx,0ffffffh
     450    jz      eq11
     451    mov     esi,5
     452    jmp     trfinval
    414453eq11:
    415         mov     esi,6
    416         jmp     trfinval
     454    mov     esi,6
     455    jmp     trfinval
    417456
    418457begincompare:
    419         ; here we now scan and match begin same
    420         add     edi,6
    421         add     esi,6
    422         mov     ecx,(MAX_MATCH-(2+4))/4     ; scan for at most MAX_MATCH bytes
    423         repe    cmpsd                       ; loop until mismatch
    424 
    425         je      trfin                       ; go to trfin if not unmatch
     458    ; here we now scan and match begin same
     459    add     edi,6
     460    add     esi,6
     461    mov     ecx,(MAX_MATCH-(2+4))/4     ; scan for at most MAX_MATCH bytes
     462    repe    cmpsd                       ; loop until mismatch
     463
     464    je      trfin                       ; go to trfin if not unmatch
    426465; we determine the unmatch byte
    427         sub     esi,4
    428         mov     edx,[edi-4]
    429         xor     edx,[esi]
    430 
    431         or      dl,dl
    432         jnz     trfin
    433         inc     esi
    434 
    435         or      dx,dx
    436         jnz     trfin
    437         inc     esi
    438 
    439         and     edx,0ffffffh
    440         jnz     trfin
    441         inc     esi
     466    sub     esi,4
     467    mov     edx,[edi-4]
     468    xor     edx,[esi]
     469
     470    or      dl,dl
     471    jnz     trfin
     472    inc     esi
     473
     474    or      dx,dx
     475    jnz     trfin
     476    inc     esi
     477
     478    and     edx,0ffffffh
     479    jnz     trfin
     480    inc     esi
    442481
    443482trfin:
    444         sub     esi,scan          ; esi = len
     483    sub     esi,scan          ; esi = len
    445484trfinval:
    446485; here we have finised compare, and esi contain len of equal string
    447         cmp     esi,best_len        ; if len > best_len, go newbestlen
    448         ja      short newbestlen
     486    cmp     esi,best_len        ; if len > best_len, go newbestlen
     487    ja      short newbestlen
    449488; now we restore edx, ecx and esi, for the big loop
    450         mov     esi,prev
    451         mov     ecx,limit
    452         mov     edx,window
    453         jmp     contloop3
     489    mov     esi,prev
     490    mov     ecx,limit
     491    mov     edx,window
     492    jmp     contloop3
    454493
    455494newbestlen:
    456         mov     best_len,esi        ; len become best_len
    457 
    458         mov     match_start,eax     ; save new position as match_start
    459         cmp     esi,nice_match      ; if best_len >= nice_match, exit
    460         jae     exitloop
    461         mov     ecx,scan
    462         mov     edx,window          ; restore edx=window
    463         add     ecx,esi
    464         add     esi,edx
    465 
    466         dec     esi
    467         mov     windowlen,esi       ; windowlen = window + best_len-1
    468         mov     bx,[ecx-1]          ; bx = *(scan+best_len-1) = scan_end
     495    mov     best_len,esi        ; len become best_len
     496
     497    mov     match_start,eax     ; save new position as match_start
     498    cmp     esi,nice_match      ; if best_len >= nice_match, exit
     499    jae     exitloop
     500    mov     ecx,scan
     501    mov     edx,window          ; restore edx=window
     502    add     ecx,esi
     503    add     esi,edx
     504
     505    dec     esi
     506    mov     windowlen,esi       ; windowlen = window + best_len-1
     507    mov     bx,[ecx-1]          ; bx = *(scan+best_len-1) = scan_end
    469508
    470509; now we restore ecx and esi, for the big loop :
    471         mov     esi,prev
    472         mov     ecx,limit
    473         jmp     contloop3
     510    mov     esi,prev
     511    mov     ecx,limit
     512    jmp     contloop3
    474513
    475514exitloop:
    476515; exit : s->match_start=match_start
    477         mov     ebx,match_start
    478         mov     ebp,str_s
    479         mov     ecx,best_len
    480         mov     dword ptr [ebp+dep_match_start],ebx
    481         mov     eax,dword ptr [ebp+dep_lookahead]
    482         cmp     ecx,eax
    483         ja      minexlo
    484         mov     eax,ecx
     516    mov     ebx,match_start
     517    mov     ebp,str_s
     518    mov     ecx,best_len
     519    mov     dword ptr [ebp+dep_match_start],ebx
     520    mov     eax,dword ptr [ebp+dep_lookahead]
     521    cmp     ecx,eax
     522    ja      minexlo
     523    mov     eax,ecx
    485524minexlo:
    486525; return min(best_len,s->lookahead)
    487526
    488527; restore stack and register ebx,esi,edi,ebp
    489         add     esp,NbStackAdd
    490 
    491         pop     ebx
    492         pop     esi
    493         pop     edi
    494         pop     ebp
    495         ret
     528    add     esp,NbStackAdd
     529
     530    pop     ebx
     531    pop     esi
     532    pop     edi
     533    pop     ebp
     534    ret
    496535InfoAuthor:
    497536; please don't remove this string !
    498537; Your are free use gvmat32 in any fre or commercial apps if you don't remove the string in the binary!
    499         db     0dh,0ah,"GVMat32 optimised assembly code written 1996-98 by Gilles Vollant",0dh,0ah
     538    db     0dh,0ah,"GVMat32 optimised assembly code written 1996-98 by Gilles Vollant",0dh,0ah
    500539
    501540
     
    514553ENDIF
    515554
    516         push    ebx
    517 
    518         pushfd                  ; push original EFLAGS
    519         pop     eax             ; get original EFLAGS
    520         mov     ecx, eax        ; save original EFLAGS
    521         xor     eax, 40000h     ; flip AC bit in EFLAGS
    522         push    eax             ; save new EFLAGS value on stack
    523         popfd                   ; replace current EFLAGS value
    524         pushfd                  ; get new EFLAGS
    525         pop     eax             ; store new EFLAGS in EAX
    526         xor     eax, ecx        ; can’t toggle AC bit, processor=80386
    527         jz      end_cpu_is_386  ; jump if 80386 processor
    528         push    ecx
    529         popfd                   ; restore AC bit in EFLAGS first
    530 
    531         pushfd
    532         pushfd
    533         pop     ecx
    534 
    535         mov     eax, ecx        ; get original EFLAGS
    536         xor     eax, 200000h    ; flip ID bit in EFLAGS
    537         push    eax             ; save new EFLAGS value on stack
    538         popfd                   ; replace current EFLAGS value
    539         pushfd                  ; get new EFLAGS
    540         pop             eax                 ; store new EFLAGS in EAX
    541         popfd                   ; restore original EFLAGS
    542         xor             eax, ecx        ; can’t toggle ID bit,
    543         je              is_old_486              ; processor=old
    544 
    545         mov     eax,1
    546         db      0fh,0a2h        ;CPUID
     555    push    ebx
     556
     557    pushfd                  ; push original EFLAGS
     558    pop     eax             ; get original EFLAGS
     559    mov     ecx, eax        ; save original EFLAGS
     560    xor     eax, 40000h     ; flip AC bit in EFLAGS
     561    push    eax             ; save new EFLAGS value on stack
     562    popfd                   ; replace current EFLAGS value
     563    pushfd                  ; get new EFLAGS
     564    pop     eax             ; store new EFLAGS in EAX
     565    xor     eax, ecx        ; can’t toggle AC bit, processor=80386
     566    jz      end_cpu_is_386  ; jump if 80386 processor
     567    push    ecx
     568    popfd                   ; restore AC bit in EFLAGS first
     569
     570    pushfd
     571    pushfd
     572    pop     ecx
     573
     574    mov     eax, ecx        ; get original EFLAGS
     575    xor     eax, 200000h    ; flip ID bit in EFLAGS
     576    push    eax             ; save new EFLAGS value on stack
     577    popfd                   ; replace current EFLAGS value
     578    pushfd                  ; get new EFLAGS
     579    pop     eax             ; store new EFLAGS in EAX
     580    popfd                   ; restore original EFLAGS
     581    xor     eax, ecx        ; can’t toggle ID bit,
     582    je      is_old_486      ; processor=old
     583
     584    mov     eax,1
     585    db      0fh,0a2h        ;CPUID
    547586
    548587exitcpudetect:
    549         pop     ebx
    550         ret
     588    pop ebx
     589    ret
    551590
    552591end_cpu_is_386:
    553         mov     eax,0300h
    554         jmp     exitcpudetect
     592    mov     eax,0300h
     593    jmp     exitcpudetect
    555594
    556595is_old_486:
    557         mov     eax,0400h
    558         jmp     exitcpudetect
     596    mov     eax,0400h
     597    jmp     exitcpudetect
    559598
    560599IFDEF NOUNDERLINE
     
    563602_cpudetect32    endp
    564603ENDIF
    565 
    566 
    567 
     604ENDIF
    568605
    569606MAX_MATCH       equ     258
     
    575612;;; stack frame offsets
    576613
    577 chainlenwmask   equ  esp + 0    ; high word: current chain len
    578                                         ; low word: s->wmask
    579 window          equ  esp + 4    ; local copy of s->window
    580 windowbestlen   equ  esp + 8    ; s->window + bestlen
    581 scanstart       equ  esp + 16   ; first two bytes of string
    582 scanend         equ  esp + 12   ; last two bytes of string
    583 scanalign       equ  esp + 20   ; dword-misalignment of string
    584 nicematch       equ  esp + 24   ; a good enough match size
    585 bestlen         equ  esp + 28   ; size of best match so far
    586 scan            equ  esp + 32   ; ptr to string wanting match
    587 
    588 LocalVarsSize   equ 36
    589 ;       saved ebx       byte esp + 36
    590 ;       saved edi       byte esp + 40
    591 ;       saved esi       byte esp + 44
    592 ;       saved ebp       byte esp + 48
    593 ;       return address  byte esp + 52
    594 deflatestate    equ  esp + 56   ; the function arguments
    595 curmatch        equ  esp + 60
     614chainlenwmask   equ  esp + 0    ; high word: current chain len
     615                    ; low word: s->wmask
     616window      equ  esp + 4    ; local copy of s->window
     617windowbestlen   equ  esp + 8    ; s->window + bestlen
     618scanstart   equ  esp + 16   ; first two bytes of string
     619scanend     equ  esp + 12   ; last two bytes of string
     620scanalign   equ  esp + 20   ; dword-misalignment of string
     621nicematch   equ  esp + 24   ; a good enough match size
     622bestlen     equ  esp + 28   ; size of best match so far
     623scan        equ  esp + 32   ; ptr to string wanting match
     624
     625LocalVarsSize   equ 36
     626;   saved ebx   byte esp + 36
     627;   saved edi   byte esp + 40
     628;   saved esi   byte esp + 44
     629;   saved ebp   byte esp + 48
     630;   return address  byte esp + 52
     631deflatestate    equ  esp + 56   ; the function arguments
     632curmatch    equ  esp + 60
    596633
    597634;;; Offsets for fields in the deflate_state structure. These numbers
     
    602639;;; compile time. Sigh.)
    603640
    604 dsWSize         equ 36+addstr-4
    605 dsWMask         equ 44+addstr-4
    606 dsWindow        equ 48+addstr-4
    607 dsPrev          equ 56+addstr-4
    608 dsMatchLen      equ 88+addstr-4
    609 dsPrevMatch     equ 92+addstr-4
    610 dsStrStart      equ 100+addstr-4
    611 dsMatchStart    equ 104+addstr-4
    612 dsLookahead     equ 108+addstr-4
    613 dsPrevLen       equ 112+addstr-4
    614 dsMaxChainLen   equ 116+addstr-4
    615 dsGoodMatch     equ 132+addstr-4
    616 dsNiceMatch     equ 136+addstr-4
     641dsWSize     equ 36+zlib1222add
     642dsWMask     equ 44+zlib1222add
     643dsWindow    equ 48+zlib1222add
     644dsPrev      equ 56+zlib1222add
     645dsMatchLen  equ 88+zlib1222add
     646dsPrevMatch equ 92+zlib1222add
     647dsStrStart  equ 100+zlib1222add
     648dsMatchStart    equ 104+zlib1222add
     649dsLookahead equ 108+zlib1222add
     650dsPrevLen   equ 112+zlib1222add
     651dsMaxChainLen   equ 116+zlib1222add
     652dsGoodMatch equ 132+zlib1222add
     653dsNiceMatch equ 136+zlib1222add
    617654
    618655
     
    625662;;; under the terms of the GNU General Public License.
    626663
    627 ;GLOBAL _longest_match, _match_init
    628 
    629 
    630 ;SECTION        .text
     664;GLOBAL _longest_match, _match_init
     665
     666
     667;SECTION    .text
    631668
    632669;;; uInt longest_match(deflate_state *deflatestate, IPos curmatch)
    633670
    634671;_longest_match:
    635 IFDEF NOUNDERLINE
    636 longest_match_686   proc near
     672IFDEF NOOLDPENTIUMCODE
     673    IFDEF NOUNDERLINE
     674    longest_match       proc near
     675    ELSE
     676    _longest_match      proc near
     677    ENDIF
    637678ELSE
    638 _longest_match_686  proc near
     679    IFDEF NOUNDERLINE
     680    longest_match_686   proc near
     681    ELSE
     682    _longest_match_686  proc near
     683    ENDIF
    639684ENDIF
    640 
    641685
    642686;;; Save registers that the compiler may be using, and adjust esp to
    643687;;; make room for our stack frame.
    644688
    645                 push    ebp
    646                 push    edi
    647                 push    esi
    648                 push    ebx
    649                 sub     esp, LocalVarsSize
     689        push    ebp
     690        push    edi
     691        push    esi
     692        push    ebx
     693        sub esp, LocalVarsSize
    650694
    651695;;; Retrieve the function arguments. ecx will hold cur_match
     
    654698;;; entering the main loop.
    655699
    656                 mov     edx, [deflatestate]
    657                 mov     ecx, [curmatch]
     700        mov edx, [deflatestate]
     701        mov ecx, [curmatch]
    658702
    659703;;; uInt wmask = s->w_mask;
     
    663707;;; }
    664708
    665                 mov     eax, [edx + dsPrevLen]
    666                 mov     ebx, [edx + dsGoodMatch]
    667                 cmp     eax, ebx
    668                 mov     eax, [edx + dsWMask]
    669                 mov     ebx, [edx + dsMaxChainLen]
    670                 jl      LastMatchGood
    671                 shr     ebx, 2
     709        mov eax, [edx + dsPrevLen]
     710        mov ebx, [edx + dsGoodMatch]
     711        cmp eax, ebx
     712        mov eax, [edx + dsWMask]
     713        mov ebx, [edx + dsMaxChainLen]
     714        jl  LastMatchGood
     715        shr ebx, 2
    672716LastMatchGood:
    673717
     
    677721;;; value, which it will always accompany.
    678722
    679                 dec     ebx
    680                 shl     ebx, 16
    681                 or      ebx, eax
    682                 mov     [chainlenwmask], ebx
     723        dec ebx
     724        shl ebx, 16
     725        or  ebx, eax
     726        mov [chainlenwmask], ebx
    683727
    684728;;; if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead;
    685729
    686                 mov     eax, [edx + dsNiceMatch]
    687                 mov     ebx, [edx + dsLookahead]
    688                 cmp     ebx, eax
    689                 jl      LookaheadLess
    690                 mov     ebx, eax
    691 LookaheadLess:  mov     [nicematch], ebx
     730        mov eax, [edx + dsNiceMatch]
     731        mov ebx, [edx + dsLookahead]
     732        cmp ebx, eax
     733        jl  LookaheadLess
     734        mov ebx, eax
     735LookaheadLess:  mov [nicematch], ebx
    692736
    693737;;; register Bytef *scan = s->window + s->strstart;
    694738
    695                 mov     esi, [edx + dsWindow]
    696                 mov     [window], esi
    697                 mov     ebp, [edx + dsStrStart]
    698                 lea     edi, [esi + ebp]
    699                 mov     [scan], edi
     739        mov esi, [edx + dsWindow]
     740        mov [window], esi
     741        mov ebp, [edx + dsStrStart]
     742        lea edi, [esi + ebp]
     743        mov [scan], edi
    700744
    701745;;; Determine how many bytes the scan ptr is off from being
    702746;;; dword-aligned.
    703747
    704                 mov     eax, edi
    705                 neg     eax
    706                 and     eax, 3
    707                 mov     [scanalign], eax
     748        mov eax, edi
     749        neg eax
     750        and eax, 3
     751        mov [scanalign], eax
    708752
    709753;;; IPos limit = s->strstart > (IPos)MAX_DIST(s) ?
    710754;;;     s->strstart - (IPos)MAX_DIST(s) : NIL;
    711755
    712                 mov     eax, [edx + dsWSize]
    713                 sub     eax, MIN_LOOKAHEAD
    714                 sub     ebp, eax
    715                 jg      LimitPositive
    716                 xor     ebp, ebp
     756        mov eax, [edx + dsWSize]
     757        sub eax, MIN_LOOKAHEAD
     758        sub ebp, eax
     759        jg  LimitPositive
     760        xor ebp, ebp
    717761LimitPositive:
    718762
    719763;;; int best_len = s->prev_length;
    720764
    721                 mov     eax, [edx + dsPrevLen]
    722                 mov     [bestlen], eax
     765        mov eax, [edx + dsPrevLen]
     766        mov [bestlen], eax
    723767
    724768;;; Store the sum of s->window + best_len in esi locally, and in esi.
    725769
    726                 add     esi, eax
    727                 mov     [windowbestlen], esi
     770        add esi, eax
     771        mov [windowbestlen], esi
    728772
    729773;;; register ush scan_start = *(ushf*)scan;
     
    731775;;; Posf *prev = s->prev;
    732776
    733                 movzx   ebx, word ptr [edi]
    734                 mov     [scanstart], ebx
    735                 movzx   ebx, word ptr [edi + eax - 1]
    736                 mov     [scanend], ebx
    737                 mov     edi, [edx + dsPrev]
     777        movzx   ebx, word ptr [edi]
     778        mov [scanstart], ebx
     779        movzx   ebx, word ptr [edi + eax - 1]
     780        mov [scanend], ebx
     781        mov edi, [edx + dsPrev]
    738782
    739783;;; Jump into the main loop.
    740784
    741                 mov     edx, [chainlenwmask]
    742                 jmp     short LoopEntry
     785        mov edx, [chainlenwmask]
     786        jmp short LoopEntry
    743787
    744788align 4
     
    765809
    766810LookupLoop:
    767                 and     ecx, edx
    768                 movzx   ecx, word ptr [edi + ecx*2]
    769                 cmp     ecx, ebp
    770                 jbe     LeaveNow
    771                 sub     edx, 00010000h
    772                 js      LeaveNow
    773 LoopEntry:      movzx   eax, word ptr [esi + ecx - 1]
    774                 cmp     eax, ebx
    775                 jnz     LookupLoop
    776                 mov     eax, [window]
    777                 movzx   eax, word ptr [eax + ecx]
    778                 cmp     eax, [scanstart]
    779                 jnz     LookupLoop
     811        and ecx, edx
     812        movzx   ecx, word ptr [edi + ecx*2]
     813        cmp ecx, ebp
     814        jbe LeaveNow
     815        sub edx, 00010000h
     816        js  LeaveNow
     817LoopEntry:  movzx   eax, word ptr [esi + ecx - 1]
     818        cmp eax, ebx
     819        jnz LookupLoop
     820        mov eax, [window]
     821        movzx   eax, word ptr [eax + ecx]
     822        cmp eax, [scanstart]
     823        jnz LookupLoop
    780824
    781825;;; Store the current value of chainlen.
    782826
    783                 mov     [chainlenwmask], edx
     827        mov [chainlenwmask], edx
    784828
    785829;;; Point edi to the string under scrutiny, and esi to the string we
     
    788832;;; initialized to -(MAX_MATCH_8 - scanalign).
    789833
    790                 mov     esi, [window]
    791                 mov     edi, [scan]
    792                 add     esi, ecx
    793                 mov     eax, [scanalign]
    794                 mov     edx, 0fffffef8h; -(MAX_MATCH_8)
    795                 lea     edi, [edi + eax + 0108h] ;MAX_MATCH_8]
    796                 lea     esi, [esi + eax + 0108h] ;MAX_MATCH_8]
     834        mov esi, [window]
     835        mov edi, [scan]
     836        add esi, ecx
     837        mov eax, [scanalign]
     838        mov edx, 0fffffef8h; -(MAX_MATCH_8)
     839        lea edi, [edi + eax + 0108h] ;MAX_MATCH_8]
     840        lea esi, [esi + eax + 0108h] ;MAX_MATCH_8]
    797841
    798842;;; Test the strings for equality, 8 bytes at a time. At the end,
     
    811855
    812856LoopCmps:
    813                 mov     eax, [esi + edx]
    814                 xor     eax, [edi + edx]
    815                 jnz     LeaveLoopCmps
    816                 mov     eax, [esi + edx + 4]
    817                 xor     eax, [edi + edx + 4]
    818                 jnz     LeaveLoopCmps4
    819                 add     edx, 8
    820                 jnz     LoopCmps
    821                 jmp     short LenMaximum
    822 LeaveLoopCmps4: add     edx, 4
    823 LeaveLoopCmps:  test    eax, 0000FFFFh
    824                 jnz     LenLower
    825                 add     edx,  2
    826                 shr     eax, 16
    827 LenLower:       sub     al, 1
    828                 adc     edx, 0
     857        mov eax, [esi + edx]
     858        xor eax, [edi + edx]
     859        jnz LeaveLoopCmps
     860        mov eax, [esi + edx + 4]
     861        xor eax, [edi + edx + 4]
     862        jnz LeaveLoopCmps4
     863        add edx, 8
     864        jnz LoopCmps
     865        jmp short LenMaximum
     866LeaveLoopCmps4: add edx, 4
     867LeaveLoopCmps:  test    eax, 0000FFFFh
     868        jnz LenLower
     869        add edx,  2
     870        shr eax, 16
     871LenLower:   sub al, 1
     872        adc edx, 0
    829873
    830874;;; Calculate the length of the match. If it is longer than MAX_MATCH,
    831875;;; then automatically accept it as the best possible match and leave.
    832876
    833                 lea     eax, [edi + edx]
    834                 mov     edi, [scan]
    835                 sub     eax, edi
    836                 cmp     eax, MAX_MATCH
    837                 jge     LenMaximum
     877        lea eax, [edi + edx]
     878        mov edi, [scan]
     879        sub eax, edi
     880        cmp eax, MAX_MATCH
     881        jge LenMaximum
    838882
    839883;;; If the length of the match is not longer than the best match we
    840884;;; have so far, then forget it and return to the lookup loop.
    841885
    842                 mov     edx, [deflatestate]
    843                 mov     ebx, [bestlen]
    844                 cmp     eax, ebx
    845                 jg      LongerMatch
    846                 mov     esi, [windowbestlen]
    847                 mov     edi, [edx + dsPrev]
    848                 mov     ebx, [scanend]
    849                 mov     edx, [chainlenwmask]
    850                 jmp     LookupLoop
     886        mov edx, [deflatestate]
     887        mov ebx, [bestlen]
     888        cmp eax, ebx
     889        jg  LongerMatch
     890        mov esi, [windowbestlen]
     891        mov edi, [edx + dsPrev]
     892        mov ebx, [scanend]
     893        mov edx, [chainlenwmask]
     894        jmp LookupLoop
    851895
    852896;;;         s->match_start = cur_match;
     
    855899;;;         scan_end = *(ushf*)(scan+best_len-1);
    856900
    857 LongerMatch:    mov     ebx, [nicematch]
    858                 mov     [bestlen], eax
    859                 mov     [edx + dsMatchStart], ecx
    860                 cmp     eax, ebx
    861                 jge     LeaveNow
    862                 mov     esi, [window]
    863                 add     esi, eax
    864                 mov     [windowbestlen], esi
    865                 movzx   ebx, word ptr [edi + eax - 1]
    866                 mov     edi, [edx + dsPrev]
    867                 mov     [scanend], ebx
    868                 mov     edx, [chainlenwmask]
    869                 jmp     LookupLoop
     901LongerMatch:    mov ebx, [nicematch]
     902        mov [bestlen], eax
     903        mov [edx + dsMatchStart], ecx
     904        cmp eax, ebx
     905        jge LeaveNow
     906        mov esi, [window]
     907        add esi, eax
     908        mov [windowbestlen], esi
     909        movzx   ebx, word ptr [edi + eax - 1]
     910        mov edi, [edx + dsPrev]
     911        mov [scanend], ebx
     912        mov edx, [chainlenwmask]
     913        jmp LookupLoop
    870914
    871915;;; Accept the current string, with the maximum possible length.
    872916
    873 LenMaximum:     mov     edx, [deflatestate]
    874                 mov     dword ptr [bestlen], MAX_MATCH
    875                 mov     [edx + dsMatchStart], ecx
     917LenMaximum: mov edx, [deflatestate]
     918        mov dword ptr [bestlen], MAX_MATCH
     919        mov [edx + dsMatchStart], ecx
    876920
    877921;;; if ((uInt)best_len <= s->lookahead) return (uInt)best_len;
     
    879923
    880924LeaveNow:
    881                 mov     edx, [deflatestate]
    882                 mov     ebx, [bestlen]
    883                 mov     eax, [edx + dsLookahead]
    884                 cmp     ebx, eax
    885                 jg      LookaheadRet
    886                 mov     eax, ebx
     925        mov edx, [deflatestate]
     926        mov ebx, [bestlen]
     927        mov eax, [edx + dsLookahead]
     928        cmp ebx, eax
     929        jg  LookaheadRet
     930        mov eax, ebx
    887931LookaheadRet:
    888932
    889933;;; Restore the stack and return from whence we came.
    890934
    891                 add     esp, LocalVarsSize
    892                 pop     ebx
    893                 pop     esi
    894                 pop     edi
    895                 pop     ebp
    896 
    897                 ret
     935        add esp, LocalVarsSize
     936        pop ebx
     937        pop esi
     938        pop edi
     939        pop ebp
     940
     941        ret
    898942; please don't remove this string !
    899943; Your can freely use gvmat32 in any free or commercial app if you don't remove the string in the binary!
    900         db     0dh,0ah,"asm686 with masm, optimised assembly code from Brian Raiter, written 1998",0dh,0ah
    901 
    902 IFDEF NOUNDERLINE
    903 longest_match_686   endp
     944    db     0dh,0ah,"asm686 with masm, optimised assembly code from Brian Raiter, written 1998",0dh,0ah
     945
     946
     947IFDEF NOOLDPENTIUMCODE
     948    IFDEF NOUNDERLINE
     949    longest_match       endp
     950    ELSE
     951    _longest_match      endp
     952    ENDIF
     953
     954    IFDEF NOUNDERLINE
     955    match_init      proc near
     956                    ret
     957    match_init      endp
     958    ELSE
     959    _match_init     proc near
     960                    ret
     961    _match_init     endp
     962    ENDIF   
    904963ELSE
    905 _longest_match_686  endp
     964    IFDEF NOUNDERLINE
     965    longest_match_686   endp
     966    ELSE
     967    _longest_match_686  endp
     968    ENDIF
    906969ENDIF
    907970
  • cpukit/zlib/contrib/masmx86/gvmat32c.c

    re7fc2fd r8198f69  
    77 *     (assembly code is faster with a fixed wmask)
    88 *
     9 * Read comment at beginning of gvmat32.asm for more information
    910 */
    1011
     12#if defined(ASMV) && (!defined(NOOLDPENTIUMCODE))
    1113#include "deflate.h"
    12 
    13 #ifdef ASMV
    14 #define NIL 0
    15 
    16 #define UNALIGNED_OK
    17 
    1814
    1915/* if your C compiler don't add underline before function name,
     
    2521#endif
    2622
    27 
    28 
    29 void match_init()
    30 {
    31 }
    3223
    3324unsigned long cpudetect32();
     
    4637    IPos cur_match);                             /* current match */
    4738
     39
     40static uInt iIsPPro=2;
     41
     42void match_init ()
     43{
     44    iIsPPro = (((cpudetect32()/0x100)&0xf)>=6) ? 1 : 0;
     45}
     46
    4847uInt longest_match(
    4948    deflate_state *s,
    5049    IPos cur_match)                             /* current match */
    5150{
    52     static uInt iIsPPro=2;
    53 
    54     if ((s->w_mask == 0x7fff) && (iIsPPro==0))
    55         return longest_match_7fff(s,cur_match);
    56 
    57     if (iIsPPro==1)
     51    if (iIsPPro!=0)
    5852        return longest_match_686(s,cur_match);
    5953
    60     if (iIsPPro==2)
    61         iIsPPro = (((cpudetect32()/0x100)&0xf)>=6) ? 1 : 0;
     54    if (s->w_mask != 0x7fff)
     55        return longest_match_686(s,cur_match);
    6256
    63     return longest_match_c(s,cur_match);
     57    /* now ((s->w_mask == 0x7fff) && (iIsPPro==0)) */
     58        return longest_match_7fff(s,cur_match);
    6459}
    6560
    6661
    67 
    68 uInt longest_match_c(s, cur_match)
    69     deflate_state *s;
    70     IPos cur_match;                             /* current match */
    71 {
    72     unsigned chain_length = s->max_chain_length;/* max hash chain length */
    73     register Bytef *scan = s->window + s->strstart; /* current string */
    74     register Bytef *match;                       /* matched string */
    75     register int len;                           /* length of current match */
    76     int best_len = s->prev_length;              /* best match length so far */
    77     int nice_match = s->nice_match;             /* stop if match long enough */
    78     IPos limit = s->strstart > (IPos)MAX_DIST(s) ?
    79         s->strstart - (IPos)MAX_DIST(s) : NIL;
    80     /* Stop when cur_match becomes <= limit. To simplify the code,
    81      * we prevent matches with the string of window index 0.
    82      */
    83     Posf *prev = s->prev;
    84     uInt wmask = s->w_mask;
    85 
    86 #ifdef UNALIGNED_OK
    87     /* Compare two bytes at a time. Note: this is not always beneficial.
    88      * Try with and without -DUNALIGNED_OK to check.
    89      */
    90     register Bytef *strend = s->window + s->strstart + MAX_MATCH - 1;
    91     register ush scan_start = *(ushf*)scan;
    92     register ush scan_end   = *(ushf*)(scan+best_len-1);
    93 #else
    94     register Bytef *strend = s->window + s->strstart + MAX_MATCH;
    95     register Byte scan_end1  = scan[best_len-1];
    96     register Byte scan_end   = scan[best_len];
    97 #endif
    98 
    99     /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16.
    100      * It is easy to get rid of this optimization if necessary.
    101      */
    102     Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever");
    103 
    104     /* Do not waste too much time if we already have a good match: */
    105     if (s->prev_length >= s->good_match) {
    106         chain_length >>= 2;
    107     }
    108     /* Do not look for matches beyond the end of the input. This is necessary
    109      * to make deflate deterministic.
    110      */
    111     if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead;
    112 
    113     Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead");
    114 
    115     do {
    116         Assert(cur_match < s->strstart, "no future");
    117         match = s->window + cur_match;
    118 
    119         /* Skip to next match if the match length cannot increase
    120          * or if the match length is less than 2:
    121          */
    122 #if (defined(UNALIGNED_OK) && MAX_MATCH == 258)
    123         /* This code assumes sizeof(unsigned short) == 2. Do not use
    124          * UNALIGNED_OK if your compiler uses a different size.
    125          */
    126         if (*(ushf*)(match+best_len-1) != scan_end ||
    127             *(ushf*)match != scan_start) continue;
    128 
    129         /* It is not necessary to compare scan[2] and match[2] since they are
    130          * always equal when the other bytes match, given that the hash keys
    131          * are equal and that HASH_BITS >= 8. Compare 2 bytes at a time at
    132          * strstart+3, +5, ... up to strstart+257. We check for insufficient
    133          * lookahead only every 4th comparison; the 128th check will be made
    134          * at strstart+257. If MAX_MATCH-2 is not a multiple of 8, it is
    135          * necessary to put more guard bytes at the end of the window, or
    136          * to check more often for insufficient lookahead.
    137          */
    138         Assert(scan[2] == match[2], "scan[2]?");
    139         scan++, match++;
    140         do {
    141         } while (*(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
    142                  *(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
    143                  *(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
    144                  *(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
    145                  scan < strend);
    146         /* The funny "do {}" generates better code on most compilers */
    147 
    148         /* Here, scan <= window+strstart+257 */
    149         Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan");
    150         if (*scan == *match) scan++;
    151 
    152         len = (MAX_MATCH - 1) - (int)(strend-scan);
    153         scan = strend - (MAX_MATCH-1);
    154 
    155 #else /* UNALIGNED_OK */
    156 
    157         if (match[best_len]   != scan_end  ||
    158             match[best_len-1] != scan_end1 ||
    159             *match            != *scan     ||
    160             *++match          != scan[1])      continue;
    161 
    162         /* The check at best_len-1 can be removed because it will be made
    163          * again later. (This heuristic is not always a win.)
    164          * It is not necessary to compare scan[2] and match[2] since they
    165          * are always equal when the other bytes match, given that
    166          * the hash keys are equal and that HASH_BITS >= 8.
    167          */
    168         scan += 2, match++;
    169         Assert(*scan == *match, "match[2]?");
    170 
    171         /* We check for insufficient lookahead only every 8th comparison;
    172          * the 256th check will be made at strstart+258.
    173          */
    174         do {
    175         } while (*++scan == *++match && *++scan == *++match &&
    176                  *++scan == *++match && *++scan == *++match &&
    177                  *++scan == *++match && *++scan == *++match &&
    178                  *++scan == *++match && *++scan == *++match &&
    179                  scan < strend);
    180 
    181         Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan");
    182 
    183         len = MAX_MATCH - (int)(strend - scan);
    184         scan = strend - MAX_MATCH;
    185 
    186 #endif /* UNALIGNED_OK */
    187 
    188         if (len > best_len) {
    189             s->match_start = cur_match;
    190             best_len = len;
    191             if (len >= nice_match) break;
    192 #ifdef UNALIGNED_OK
    193             scan_end = *(ushf*)(scan+best_len-1);
    194 #else
    195             scan_end1  = scan[best_len-1];
    196             scan_end   = scan[best_len];
    197 #endif
    198         }
    199     } while ((cur_match = prev[cur_match & wmask]) > limit
    200              && --chain_length != 0);
    201 
    202     if ((uInt)best_len <= s->lookahead) return (uInt)best_len;
    203     return s->lookahead;
    204 }
    205 
    206 #endif /* ASMV */
     62#endif /* defined(ASMV) && (!defined(NOOLDPENTIUMCODE)) */
  • cpukit/zlib/contrib/masmx86/inffas32.asm

    re7fc2fd r8198f69  
     1;/* inffas32.asm is a hand tuned assembler version of inffast.c -- fast decoding
     2; *
     3; * inffas32.asm is derivated from inffas86.c, with translation of assembly code
     4; *
     5; * Copyright (C) 1995-2003 Mark Adler
     6; * For conditions of distribution and use, see copyright notice in zlib.h
     7; *
     8; * Copyright (C) 2003 Chris Anderson <christop@charm.net>
     9; * Please use the copyright conditions above.
     10; *
     11; * Mar-13-2003 -- Most of this is derived from inffast.S which is derived from
     12; * the gcc -S output of zlib-1.2.0/inffast.c.  Zlib-1.2.0 is in beta release at
     13; * the moment.  I have successfully compiled and tested this code with gcc2.96,
     14; * gcc3.2, icc5.0, msvc6.0.  It is very close to the speed of inffast.S
     15; * compiled with gcc -DNO_MMX, but inffast.S is still faster on the P3 with MMX
     16; * enabled.  I will attempt to merge the MMX code into this version.  Newer
     17; * versions of this and inffast.S can be found at
     18; * http://www.eetbeetee.com/zlib/ and http://www.charm.net/~christop/zlib/
     19; *
     20; * 2005 : modification by Gilles Vollant
     21; */
     22; For Visual C++ 4.x and higher and ML 6.x and higher
     23;   ml.exe is in directory \MASM611C of Win95 DDK
     24;   ml.exe is also distributed in http://www.masm32.com/masmdl.htm
     25;    and in VC++2003 toolkit at http://msdn.microsoft.com/visualc/vctoolkit2003/
     26;
     27;
     28;   compile with command line option
     29;   ml  /coff /Zi /c /Flinffas32.lst inffas32.asm
     30
     31;   if you define NO_GZIP (see inflate.h), compile with
     32;   ml  /coff /Zi /c /Flinffas32.lst /DNO_GUNZIP inffas32.asm
     33
     34
     35; zlib122sup is 0 fort zlib 1.2.2.1 and lower
     36; zlib122sup is 8 fort zlib 1.2.2.2 and more (with addition of dmax and head
     37;        in inflate_state in inflate.h)
     38zlib1222sup      equ    8
     39
     40
     41IFDEF GUNZIP
     42  INFLATE_MODE_TYPE    equ 11
     43  INFLATE_MODE_BAD     equ 26
     44ELSE
     45  IFNDEF NO_GUNZIP
     46    INFLATE_MODE_TYPE    equ 11
     47    INFLATE_MODE_BAD     equ 26
     48  ELSE
     49    INFLATE_MODE_TYPE    equ 3
     50    INFLATE_MODE_BAD     equ 17
     51  ENDIF
     52ENDIF
     53
     54
    155; 75 "inffast.S"
    256;FILE "inffast.S"
     
    85139
    86140
    87 ; head was added in zlib 1.2.2.1, so we add addstr
    88 ; set addstr to 0 with zlib 1.2.1 of below
    89 addstr           equ    4
    90 
    91141mode_state       equ    0       ;/* state->mode */
    92 wsize_state      equ    32+addstr       ;/* state->wsize */
    93 write_state      equ    (36+4+addstr)   ;/* state->write */
    94 window_state     equ    (40+4+addstr)   ;/* state->window */
    95 hold_state       equ    (44+4+addstr)   ;/* state->hold */
    96 bits_state       equ    (48+4+addstr)   ;/* state->bits */
    97 lencode_state    equ    (64+4+addstr)   ;/* state->lencode */
    98 distcode_state   equ    (68+4+addstr)   ;/* state->distcode */
    99 lenbits_state    equ    (72+4+addstr)   ;/* state->lenbits */
    100 distbits_state   equ    (76+4+addstr)   ;/* state->distbits */
     142wsize_state      equ    (32+zlib1222sup)        ;/* state->wsize */
     143write_state      equ    (36+4+zlib1222sup)      ;/* state->write */
     144window_state     equ    (40+4+zlib1222sup)      ;/* state->window */
     145hold_state       equ    (44+4+zlib1222sup)      ;/* state->hold */
     146bits_state       equ    (48+4+zlib1222sup)      ;/* state->bits */
     147lencode_state    equ    (64+4+zlib1222sup)      ;/* state->lencode */
     148distcode_state   equ    (68+4+zlib1222sup)      ;/* state->distcode */
     149lenbits_state    equ    (72+4+zlib1222sup)      ;/* state->lenbits */
     150distbits_state   equ    (76+4+zlib1222sup)      ;/* state->distbits */
    101151
    102152
     
    872922
    873923        mov  ecx, invalid_distance_code_msg
    874         mov  edx,26
     924        mov  edx,INFLATE_MODE_BAD
    875925        jmp  L_update_stream_state
    876926
     
    885935
    886936        mov  ecx,0
    887         mov  edx,11
     937        mov  edx,INFLATE_MODE_TYPE
    888938        jmp  L_update_stream_state
    889939
     
    895945
    896946        mov  ecx, invalid_literal_length_code_msg
    897         mov  edx,26
     947        mov  edx,INFLATE_MODE_BAD
    898948        jmp  L_update_stream_state
    899949
     
    904954        mov  esi, [esp+44]
    905955        mov  ecx, invalid_distance_too_far_msg
    906         mov  edx,26
     956        mov  edx,INFLATE_MODE_BAD
    907957        jmp  L_update_stream_state
    908958
     
    10301080        ret
    10311081
    1032 
    1033 
    1034 
    10351082_TEXT   ends
    10361083end
  • cpukit/zlib/contrib/minizip/ChangeLogUnzip

    re7fc2fd r8198f69  
     1Change in 1.01e (12 feb 05)
     2- Fix in zipOpen2 for globalcomment (Rolf Kalbermatter)
     3- Fix possible memory leak in unzip.c (Zoran Stevanovic)
     4
    15Change in 1.01b (20 may 04)
    26- Integrate patch from Debian package (submited by Mark Brown)
  • cpukit/zlib/contrib/minizip/crypt.h

    re7fc2fd r8198f69  
    22
    33
    4    Version 1.01, May 8th, 2004
     4   Version 1.01e, February 12th, 2005
    55
    6    Copyright (C) 1998-2004 Gilles Vollant
     6   Copyright (C) 1998-2005 Gilles Vollant
    77
    88   This code is a modified version of crypting code in Infozip distribution
  • cpukit/zlib/contrib/minizip/ioapi.c

    re7fc2fd r8198f69  
    22   files using zlib + zip or unzip API
    33
    4    Version 1.01, May 8th, 2004
     4   Version 1.01e, February 12th, 2005
    55
    6    Copyright (C) 1998-2004 Gilles Vollant
     6   Copyright (C) 1998-2005 Gilles Vollant
    77*/
    88
  • cpukit/zlib/contrib/minizip/ioapi.h

    re7fc2fd r8198f69  
    22   files using zlib + zip or unzip API
    33
    4    Version 1.01, May 8th, 2004
     4   Version 1.01e, February 12th, 2005
    55
    6    Copyright (C) 1998-2004 Gilles Vollant
     6   Copyright (C) 1998-2005 Gilles Vollant
    77*/
    88
  • cpukit/zlib/contrib/minizip/iowin32.c

    re7fc2fd r8198f69  
    33   This IO API version uses the Win32 API (for Microsoft Windows)
    44
    5    Version 1.01, May 8th, 2004
    6 
    7    Copyright (C) 1998-2004 Gilles Vollant
     5   Version 1.01e, February 12th, 2005
     6
     7   Copyright (C) 1998-2005 Gilles Vollant
    88*/
    99
  • cpukit/zlib/contrib/minizip/iowin32.h

    re7fc2fd r8198f69  
    33   This IO API version uses the Win32 API (for Microsoft Windows)
    44
    5    Version 1.01, May 8th, 2004
     5   Version 1.01e, February 12th, 2005
    66
    7    Copyright (C) 1998-2004 Gilles Vollant
     7   Copyright (C) 1998-2005 Gilles Vollant
    88*/
    99
  • cpukit/zlib/contrib/minizip/miniunz.c

    re7fc2fd r8198f69  
    11/*
    22   miniunz.c
    3    Version 1.01b, May 30th, 2004
    4 
    5    Copyright (C) 1998-2004 Gilles Vollant
     3   Version 1.01e, February 12th, 2005
     4
     5   Copyright (C) 1998-2005 Gilles Vollant
    66*/
    77
     
    318318                    printf("The file %s exists. Overwrite ? [y]es, [n]o, [A]ll: ",write_filename);
    319319                    ret = scanf("%1s",answer);
    320                     if (ret != 1)
     320                    if (ret != 1) 
    321321                    {
    322322                       exit(EXIT_FAILURE);
     
    568568    else if (opt_do_extract==1)
    569569    {
    570         if (opt_extractdir && chdir(dirname))
     570        if (opt_extractdir && chdir(dirname)) 
    571571        {
    572572          printf("Error changing into %s, aborting\n", dirname);
  • cpukit/zlib/contrib/minizip/minizip.c

    re7fc2fd r8198f69  
    11/*
    22   minizip.c
    3    Version 1.01b, May 30th, 2004
    4 
    5    Copyright (C) 1998-2004 Gilles Vollant
     3   Version 1.01e, February 12th, 2005
     4
     5   Copyright (C) 1998-2005 Gilles Vollant
    66*/
    77
  • cpukit/zlib/contrib/minizip/mztools.c

    re7fc2fd r8198f69  
    6363        unsigned int extsize = READ_16(header + 28); /* extra field length */
    6464        filename[0] = extra[0] = '\0';
    65 
     65       
    6666        /* Header */
    6767        if (fwrite(header, 1, 30, fpOut) == 30) {
     
    7171          break;
    7272        }
    73 
     73       
    7474        /* Filename */
    7575        if (fnsize > 0) {
     
    104104          }
    105105        }
    106 
     106       
    107107        /* Data */
    108108        {
     
    134134          }
    135135        }
    136 
     136       
    137137        /* Central directory entry */
    138138        {
     
    160160          if (fwrite(header, 1, 46, fpOutCD) == 46) {
    161161            offsetCD += 46;
    162 
     162           
    163163            /* Filename */
    164164            if (fnsize > 0) {
     
    173173              break;
    174174            }
    175 
     175           
    176176            /* Extra field */
    177177            if (extsize > 0) {
     
    183183              }
    184184            }
    185 
     185           
    186186            /* Comment field */
    187187            if (comsize > 0) {
     
    193193              }
    194194            }
    195 
    196 
     195           
     196           
    197197          } else {
    198198            err = Z_ERRNO;
     
    226226      WRITE_32(header + 16, offset);      /* offset to CD */
    227227      WRITE_16(header + 20, comsize);     /* comment */
    228 
     228     
    229229      /* Header */
    230230      if (fwrite(header, 1, 22, fpOutCD) == 22) {
    231 
     231       
    232232        /* Comment field */
    233233        if (comsize > 0) {
     
    236236          }
    237237        }
    238 
     238       
    239239      } else {
    240240        err = Z_ERRNO;
     
    249249        int nRead;
    250250        char buffer[8192];
    251         while ( (nRead = fread(buffer, 1, sizeof(buffer), fpOutCD)) > 0) {
     251        while ( (nRead = (int)fread(buffer, 1, sizeof(buffer), fpOutCD)) > 0) {
    252252          if ((int)fwrite(buffer, 1, nRead, fpOut) != nRead) {
    253253            err = Z_ERRNO;
     
    258258      }
    259259    }
    260 
     260   
    261261    /* Close */
    262262    fclose(fpZip);
    263263    fclose(fpOut);
    264 
     264   
    265265    /* Wipe temporary file */
    266266    (void)remove(fileOutTmp);
    267 
     267   
    268268    /* Number of recovered entries */
    269269    if (err == Z_OK) {
  • cpukit/zlib/contrib/minizip/mztools.h

    re7fc2fd r8198f69  
    1818#include "unzip.h"
    1919
    20 /* Repair a ZIP file (missing central directory)
     20/* Repair a ZIP file (missing central directory) 
    2121   file: file to recover
    2222   fileOut: output file after recovery
    2323   fileOutTmp: temporary file name used for recovery
    2424*/
    25 extern int ZEXPORT unzRepair(const char* file,
    26                              const char* fileOut,
    27                              const char* fileOutTmp,
     25extern int ZEXPORT unzRepair(const char* file, 
     26                             const char* fileOut, 
     27                             const char* fileOutTmp, 
    2828                             uLong* nRecovered,
    2929                             uLong* bytesRecovered);
  • cpukit/zlib/contrib/minizip/unzip.c

    re7fc2fd r8198f69  
    11/* unzip.c -- IO for uncompress .zip files using zlib
    2    Version 1.01d, September 22th, 2004
    3 
    4    Copyright (C) 1998-2004 Gilles Vollant
     2   Version 1.01e, February 12th, 2005
     3
     4   Copyright (C) 1998-2005 Gilles Vollant
    55
    66   Read unzip.h for more info
     
    11381138        pfile_in_zip_read_info->stream_initialised=1;
    11391139      else
     1140      {
     1141        TRYFREE(pfile_in_zip_read_info);
    11401142        return err;
     1143      }
    11411144        /* windowBits is passed < 0 to tell that there is no zlib header.
    11421145         * Note that in this case inflate *requires* an extra "dummy" byte
  • cpukit/zlib/contrib/minizip/unzip.h

    re7fc2fd r8198f69  
    11/* unzip.h -- IO for uncompress .zip files using zlib
    2    Version 1.01, May 8th, 2004
    3 
    4    Copyright (C) 1998-2004 Gilles Vollant
     2   Version 1.01e, February 12th, 2005
     3
     4   Copyright (C) 1998-2005 Gilles Vollant
    55
    66   This unzip package allow extract file from .ZIP file, compatible with PKZip 2.04g
    77     WinZip, InfoZip tools and compatible.
    8    Encryption and multi volume ZipFile (span) are not supported.
     8
     9   Multi volume ZipFile (span) are not supported.
     10   Encryption compatible with pkzip 2.04g only supported
    911   Old compressions used by old PKZip 1.x are not supported
    1012
  • cpukit/zlib/contrib/minizip/zip.c

    re7fc2fd r8198f69  
    11/* zip.c -- IO on .zip files using zlib
    2    Version 1.01, May 8th, 2004
    3 
    4    Copyright (C) 1998-2004 Gilles Vollant
     2   Version 1.01e, February 12th, 2005
     3
     4   27 Dec 2004 Rolf Kalbermatter
     5   Modification to zipOpen2 to support globalComment retrieval.
     6
     7   Copyright (C) 1998-2005 Gilles Vollant
    58
    69   Read zip.h for more info
     
    144147    uLong add_position_when_writting_offset;
    145148    uLong number_entry;
     149#ifndef NO_ADDFILEINEXISTINGZIP
     150    char *globalcomment;
     151#endif
    146152} zip_internal;
    147153
     
    533539    /* now we add file in a zipfile */
    534540#    ifndef NO_ADDFILEINEXISTINGZIP
     541    ziinit.globalcomment = NULL;
    535542    if (append == APPEND_STATUS_ADDINZIP)
    536543    {
     
    593600            err=ZIP_ERRNO;
    594601
    595         /* zipfile comment length */
     602        /* zipfile global comment length */
    596603        if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&size_comment)!=ZIP_OK)
    597604            err=ZIP_ERRNO;
     
    607614        }
    608615
     616        if (size_comment>0)
     617        {
     618            ziinit.globalcomment = ALLOC(size_comment+1);
     619            if (ziinit.globalcomment)
     620            {
     621               size_comment = ZREAD(ziinit.z_filefunc, ziinit.filestream,ziinit.globalcomment,size_comment);
     622               ziinit.globalcomment[size_comment]=0;
     623            }
     624        }
     625
    609626        byte_before_the_zipfile = central_pos -
    610627                                (offset_central_dir+size_central_dir);
    611         ziinit.add_position_when_writting_offset = byte_before_the_zipfile ;
     628        ziinit.add_position_when_writting_offset = byte_before_the_zipfile;
    612629
    613630        {
     
    642659            err=ZIP_ERRNO;
    643660    }
     661
     662    if (globalcomment)
     663    {
     664      *globalcomment = ziinit.globalcomment;
     665    }
    644666#    endif /* !NO_ADDFILEINEXISTINGZIP*/
    645667
    646668    if (err != ZIP_OK)
    647669    {
     670#    ifndef NO_ADDFILEINEXISTINGZIP
     671        TRYFREE(ziinit.globalcomment);
     672#    endif /* !NO_ADDFILEINEXISTINGZIP*/
    648673        TRYFREE(zi);
    649674        return NULL;
     
    11131138    int err = 0;
    11141139    uLong size_centraldir = 0;
    1115     uLong centraldir_pos_inzip ;
     1140    uLong centraldir_pos_inzip;
    11161141    uInt size_global_comment;
    11171142    if (file == NULL)
     
    11241149    }
    11251150
     1151#ifndef NO_ADDFILEINEXISTINGZIP
     1152    if (global_comment==NULL)
     1153        global_comment = zi->globalcomment;
     1154#endif
    11261155    if (global_comment==NULL)
    11271156        size_global_comment = 0;
    11281157    else
    11291158        size_global_comment = (uInt)strlen(global_comment);
    1130 
    11311159
    11321160    centraldir_pos_inzip = ZTELL(zi->z_filefunc,zi->filestream);
     
    11831211            err = ZIP_ERRNO;
    11841212
     1213#ifndef NO_ADDFILEINEXISTINGZIP
     1214    TRYFREE(zi->globalcomment);
     1215#endif
    11851216    TRYFREE(zi);
    11861217
  • cpukit/zlib/contrib/minizip/zip.h

    re7fc2fd r8198f69  
    11/* zip.h -- IO for compress .zip files using zlib
    2    Version 1.01, May 8th, 2004
    3 
    4    Copyright (C) 1998-2004 Gilles Vollant
     2   Version 1.01e, February 12th, 2005
     3
     4   Copyright (C) 1998-2005 Gilles Vollant
    55
    66   This unzip package allow creates .ZIP file, compatible with PKZip 2.04g
    77     WinZip, InfoZip tools and compatible.
    8    Encryption and multi volume ZipFile (span) are not supported.
     8   Multi volume ZipFile (span) are not supported.
     9   Encryption compatible with pkzip 2.04g only supported
    910   Old compressions used by old PKZip 1.x are not supported
    1011
  • cpukit/zlib/contrib/pascal/zlibpas.pas

    re7fc2fd r8198f69  
    1111
    1212const
    13   ZLIB_VERSION = '1.2.2';
     13  ZLIB_VERSION = '1.2.3';
    1414
    1515type
  • cpukit/zlib/contrib/testzlib/testzlib.c

    re7fc2fd r8198f69  
    1 
    21#include <stdio.h>
    32#include <stdlib.h>
    43#include <windows.h>
     4
    55#include "zlib.h"
     6
     7
     8void MyDoMinus64(LARGE_INTEGER *R,LARGE_INTEGER A,LARGE_INTEGER B)
     9{
     10    R->HighPart = A.HighPart - B.HighPart;
     11    if (A.LowPart >= B.LowPart)
     12        R->LowPart = A.LowPart - B.LowPart;
     13    else
     14    {
     15        R->LowPart = A.LowPart - B.LowPart;
     16        R->HighPart --;
     17    }
     18}
     19
     20#ifdef _M_X64
     21// see http://msdn2.microsoft.com/library/twchhe95(en-us,vs.80).aspx for __rdtsc
     22unsigned __int64 __rdtsc(void);
     23void BeginCountRdtsc(LARGE_INTEGER * pbeginTime64)
     24{
     25 //   printf("rdtsc = %I64x\n",__rdtsc());
     26   pbeginTime64->QuadPart=__rdtsc();
     27}
     28
     29LARGE_INTEGER GetResRdtsc(LARGE_INTEGER beginTime64,BOOL fComputeTimeQueryPerf)
     30{
     31    LARGE_INTEGER LIres;
     32    unsigned _int64 res=__rdtsc()-((unsigned _int64)(beginTime64.QuadPart));
     33    LIres.QuadPart=res;
     34   // printf("rdtsc = %I64x\n",__rdtsc());
     35    return LIres;
     36}
     37#else
     38#ifdef _M_IX86
     39void myGetRDTSC32(LARGE_INTEGER * pbeginTime64)
     40{
     41    DWORD dwEdx,dwEax;
     42    _asm
     43    {
     44        rdtsc
     45        mov dwEax,eax
     46        mov dwEdx,edx
     47    }
     48    pbeginTime64->LowPart=dwEax;
     49    pbeginTime64->HighPart=dwEdx;
     50}
     51
     52void BeginCountRdtsc(LARGE_INTEGER * pbeginTime64)
     53{
     54    myGetRDTSC32(pbeginTime64);
     55}
     56
     57LARGE_INTEGER GetResRdtsc(LARGE_INTEGER beginTime64,BOOL fComputeTimeQueryPerf)
     58{
     59    LARGE_INTEGER LIres,endTime64;
     60    myGetRDTSC32(&endTime64);
     61
     62    LIres.LowPart=LIres.HighPart=0;
     63    MyDoMinus64(&LIres,endTime64,beginTime64);
     64    return LIres;
     65}
     66#else
     67void myGetRDTSC32(LARGE_INTEGER * pbeginTime64)
     68{
     69}
     70
     71void BeginCountRdtsc(LARGE_INTEGER * pbeginTime64)
     72{
     73}
     74
     75LARGE_INTEGER GetResRdtsc(LARGE_INTEGER beginTime64,BOOL fComputeTimeQueryPerf)
     76{
     77    LARGE_INTEGER lr;
     78    lr.QuadPart=0;
     79    return lr;
     80}
     81#endif
     82#endif
     83
     84void BeginCountPerfCounter(LARGE_INTEGER * pbeginTime64,BOOL fComputeTimeQueryPerf)
     85{
     86    if ((!fComputeTimeQueryPerf) || (!QueryPerformanceCounter(pbeginTime64)))
     87    {
     88        pbeginTime64->LowPart = GetTickCount();
     89        pbeginTime64->HighPart = 0;
     90    }
     91}
     92
     93DWORD GetMsecSincePerfCounter(LARGE_INTEGER beginTime64,BOOL fComputeTimeQueryPerf)
     94{
     95    LARGE_INTEGER endTime64,ticksPerSecond,ticks;
     96    DWORDLONG ticksShifted,tickSecShifted;
     97    DWORD dwLog=16+0;
     98    DWORD dwRet;
     99    if ((!fComputeTimeQueryPerf) || (!QueryPerformanceCounter(&endTime64)))
     100        dwRet = (GetTickCount() - beginTime64.LowPart)*1;
     101    else
     102    {
     103        MyDoMinus64(&ticks,endTime64,beginTime64);
     104        QueryPerformanceFrequency(&ticksPerSecond);
     105
     106   
     107        {
     108            ticksShifted = Int64ShrlMod32(*(DWORDLONG*)&ticks,dwLog);
     109            tickSecShifted = Int64ShrlMod32(*(DWORDLONG*)&ticksPerSecond,dwLog);
     110       
     111        }
     112
     113        dwRet = (DWORD)((((DWORD)ticksShifted)*1000)/(DWORD)(tickSecShifted));
     114        dwRet *=1;
     115    }
     116    return dwRet;
     117}
    6118
    7119int ReadFileMemory(const char* filename,long* plFileSize,void** pFilePtr)
     
    44156    unsigned char* UncprPtr;
    45157    long lSizeCpr,lSizeUncpr;
    46     DWORD dwGetTick;
     158    DWORD dwGetTick,dwMsecQP;
     159    LARGE_INTEGER li_qp,li_rdtsc,dwResRdtsc;
    47160
    48161    if (argc<=1)
     
    72185
    73186    CprPtr=(unsigned char*)malloc(lBufferSizeCpr + BlockSizeCompress);
    74     UncprPtr=(unsigned char*)malloc(lBufferSizeUncpr + BlockSizeUncompress);
    75 
     187
     188    BeginCountPerfCounter(&li_qp,TRUE);
    76189    dwGetTick=GetTickCount();
     190    BeginCountRdtsc(&li_rdtsc);
    77191    {
    78192        z_stream zcpr;
     
    102216        deflateEnd(&zcpr);
    103217        dwGetTick=GetTickCount()-dwGetTick;
     218        dwMsecQP=GetMsecSincePerfCounter(li_qp,TRUE);
     219        dwResRdtsc=GetResRdtsc(li_rdtsc,TRUE);
    104220        printf("total compress size = %u, in %u step\n",lSizeCpr,step);
    105         printf("time = %u msec = %f sec\n\n",dwGetTick,dwGetTick/(double)1000.);
    106     }
    107 
     221        printf("time = %u msec = %f sec\n",dwGetTick,dwGetTick/(double)1000.);
     222        printf("defcpr time QP = %u msec = %f sec\n",dwMsecQP,dwMsecQP/(double)1000.);
     223        printf("defcpr result rdtsc = %I64x\n\n",dwResRdtsc.QuadPart);
     224    }
     225
     226    CprPtr=(unsigned char*)realloc(CprPtr,lSizeCpr);
     227    UncprPtr=(unsigned char*)malloc(lBufferSizeUncpr + BlockSizeUncompress);
     228
     229    BeginCountPerfCounter(&li_qp,TRUE);
    108230    dwGetTick=GetTickCount();
     231    BeginCountRdtsc(&li_rdtsc);
    109232    {
    110233        z_stream zcpr;
     
    134257        inflateEnd(&zcpr);
    135258        dwGetTick=GetTickCount()-dwGetTick;
     259        dwMsecQP=GetMsecSincePerfCounter(li_qp,TRUE);
     260        dwResRdtsc=GetResRdtsc(li_rdtsc,TRUE);
    136261        printf("total uncompress size = %u, in %u step\n",lSizeUncpr,step);
    137         printf("time = %u msec = %f sec\n\n",dwGetTick,dwGetTick/(double)1000.);
     262        printf("time = %u msec = %f sec\n",dwGetTick,dwGetTick/(double)1000.);
     263        printf("uncpr  time QP = %u msec = %f sec\n",dwMsecQP,dwMsecQP/(double)1000.);
     264        printf("uncpr  result rdtsc = %I64x\n\n",dwResRdtsc.QuadPart);
    138265    }
    139266
     
    146273
    147274    return 0;
    148 
    149 }
     275}
  • cpukit/zlib/contrib/vstudio/readme.txt

    re7fc2fd r8198f69  
    1 Building instructions for the DLL versions of Zlib 1.2.x
    2 =======================================================
     1Building instructions for the DLL versions of Zlib 1.2.3
     2========================================================
    33
    44This directory contains projects that build zlib and minizip using
    5 Microsoft Visual C++ 7.0/7.1.
     5Microsoft Visual C++ 7.0/7.1, and Visual C++ .
    66
    77You don't need to build these projects yourself. You can download the
     
    1212
    1313
    14 Build instructions
    15 ------------------
    16 - Unzip zlib*.zip and copy the files from contrib\vstudio\vc7,
    17   from contrib\vstudio\masmx86 and from contrib\minizip into the same
    18   directory.
     14Build instructions for Visual Studio 7.x (32 bits)
     15--------------------------------------------------
     16- Uncompress current zlib, including all contrib/* files
    1917- Download the crtdll library from
    2018    http://www.winimage.com/zLibDll/crtdll.zip
    21   Unzip crtdll.zip to extract crtdll.lib.
    22 - If you are using x86, use the Release target.
    23 - Open zlibvc.sln with Microsoft Visual C++ 7.0 or 7.1
     19  Unzip crtdll.zip to extract crtdll.lib on contrib\vstudio\vc7.
     20- Open contrib\vstudio\vc7\zlibvc.sln with Microsoft Visual C++ 7.x
    2421  (Visual Studio .Net 2002 or 2003).
     22
     23Build instructions for Visual Studio 2005 (32 bits or 64 bits)
     24--------------------------------------------------------------
     25- Uncompress current zlib, including all contrib/* files
     26- For 32 bits only: download the crtdll library from
     27    http://www.winimage.com/zLibDll/crtdll.zip
     28  Unzip crtdll.zip to extract crtdll.lib on contrib\vstudio\vc8.
     29- Open contrib\vstudio\vc8\zlibvc.sln with Microsoft Visual C++ 8.0
     30
     31Build instructions for Visual Studio 2005 64 bits, PSDK compiler
     32----------------------------------------------------------------
     33at the time of writing this text file, Visual Studio 2005 (and
     34  Microsoft Visual C++ 8.0) is on the beta 2 stage.
     35Using you can get the free 64 bits compiler from Platform SDK,
     36  which is NOT a beta, and compile using the Visual studio 2005 IDE
     37see http://www.winimage.com/misc/sdk64onvs2005/ for instruction
     38
     39- Uncompress current zlib, including all contrib/* files
     40- start Visual Studio 2005 from a platform SDK command prompt, using
     41  the /useenv switch
     42- Open contrib\vstudio\vc8\zlibvc.sln with Microsoft Visual C++ 8.0
    2543
    2644
  • cpukit/zlib/contrib/vstudio/vc7/miniunz.vcproj

    re7fc2fd r8198f69  
    2020                                Name="VCCLCompilerTool"
    2121                                Optimization="0"
     22                                AdditionalIncludeDirectories="..\..\..;..\..\minizip"
    2223                                PreprocessorDefinitions="WIN32;ZLIB_WINAPI;_DEBUG;_CONSOLE"
    2324                                MinimalRebuild="TRUE"
     
    6465                                InlineFunctionExpansion="1"
    6566                                OmitFramePointers="TRUE"
     67                                AdditionalIncludeDirectories="..\..\..;..\..\minizip"
    6668                                PreprocessorDefinitions="WIN32;ZLIB_WINAPI;NDEBUG;_CONSOLE"
    6769                                StringPooling="TRUE"
     
    105107                        Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm">
    106108                        <File
    107                                 RelativePath="miniunz.c">
     109                                RelativePath="..\..\minizip\miniunz.c">
    108110                        </File>
    109111                </Filter>
     
    117119                </Filter>
    118120                <File
    119                         RelativePath="zlibwapi.lib">
     121                        RelativePath="ReleaseDll\zlibwapi.lib">
    120122                </File>
    121123        </Files>
  • cpukit/zlib/contrib/vstudio/vc7/minizip.vcproj

    re7fc2fd r8198f69  
    2020                                Name="VCCLCompilerTool"
    2121                                Optimization="0"
     22                                AdditionalIncludeDirectories="..\..\..;..\..\minizip"
    2223                                PreprocessorDefinitions="WIN32;ZLIB_WINAPI;_DEBUG;_CONSOLE"
    2324                                MinimalRebuild="TRUE"
     
    6465                                InlineFunctionExpansion="1"
    6566                                OmitFramePointers="TRUE"
     67                                AdditionalIncludeDirectories="..\..\..;..\..\minizip"
    6668                                PreprocessorDefinitions="WIN32;ZLIB_WINAPI;NDEBUG;_CONSOLE"
    6769                                StringPooling="TRUE"
     
    105107                        Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm">
    106108                        <File
    107                                 RelativePath="minizip.c">
     109                                RelativePath="..\..\minizip\minizip.c">
    108110                        </File>
    109111                </Filter>
     
    117119                </Filter>
    118120                <File
    119                         RelativePath="zlibwapi.lib">
     121                        RelativePath="ReleaseDll\zlibwapi.lib">
    120122                </File>
    121123        </Files>
  • cpukit/zlib/contrib/vstudio/vc7/zlib.rc

    re7fc2fd r8198f69  
    33#define IDR_VERSION1  1
    44IDR_VERSION1    VERSIONINFO     MOVEABLE IMPURE LOADONCALL DISCARDABLE
    5   FILEVERSION    1,2,2,2
    6   PRODUCTVERSION 1,2,2,2
     5  FILEVERSION    1,2,3,0
     6  PRODUCTVERSION 1,2,3,0
    77  FILEFLAGSMASK VS_FFI_FILEFLAGSMASK
    88  FILEFLAGS     0
     
    1818    BEGIN
    1919      VALUE "FileDescription", "zlib data compression library\0"
    20       VALUE "FileVersion",      "1.2.2.2\0"
     20      VALUE "FileVersion",      "1.2.3.0\0"
    2121      VALUE "InternalName",     "zlib\0"
    2222      VALUE "OriginalFilename", "zlib.dll\0"
  • cpukit/zlib/contrib/vstudio/vc7/zlibstat.vcproj

    re7fc2fd r8198f69  
    2121                                Name="VCCLCompilerTool"
    2222                                Optimization="0"
     23                                AdditionalIncludeDirectories="..\..\..;..\..\masmx86"
    2324                                PreprocessorDefinitions="WIN32;ZLIB_WINAPI"
    2425                                ExceptionHandling="FALSE"
     
    6263                                Name="VCCLCompilerTool"
    6364                                InlineFunctionExpansion="1"
     65                                AdditionalIncludeDirectories="..\..\..;..\..\masmx86"
    6466                                PreprocessorDefinitions="WIN32;ZLIB_WINAPI"
    6567                                StringPooling="TRUE"
     
    103105                                Name="VCCLCompilerTool"
    104106                                InlineFunctionExpansion="1"
     107                                AdditionalIncludeDirectories="..\..\..;..\..\masmx86"
    105108                                PreprocessorDefinitions="WIN32;ZLIB_WINAPI;ASMV;ASMINF"
    106109                                StringPooling="TRUE"
     
    118121                        <Tool
    119122                                Name="VCLibrarianTool"
    120                                 AdditionalOptions="gvmat32.obj inffas32.obj /NODEFAULTLIB "
     123                                AdditionalOptions="..\..\masmx86\gvmat32.obj ..\..\masmx86\inffas32.obj /NODEFAULTLIB "
    121124                                OutputFile=".\zlibstat\zlibstat.lib"
    122125                                SuppressStartupBanner="TRUE"/>
     
    145148                                Name="VCCLCompilerTool"
    146149                                InlineFunctionExpansion="1"
     150                                AdditionalIncludeDirectories="..\..\..;..\..\masmx86"
    147151                                PreprocessorDefinitions="WIN32;ZLIB_WINAPI"
    148152                                StringPooling="TRUE"
     
    183187                        Filter="">
    184188                        <File
    185                                 RelativePath=".\adler32.c">
    186                         </File>
    187                         <File
    188                                 RelativePath=".\compress.c">
    189                         </File>
    190                         <File
    191                                 RelativePath=".\crc32.c">
    192                         </File>
    193                         <File
    194                                 RelativePath=".\deflate.c">
    195                         </File>
    196                         <File
    197                                 RelativePath=".\gvmat32c.c">
    198                         </File>
    199                         <File
    200                                 RelativePath=".\gzio.c">
    201                         </File>
    202                         <File
    203                                 RelativePath=".\infback.c">
    204                         </File>
    205                         <File
    206                                 RelativePath=".\inffast.c">
    207                         </File>
    208                         <File
    209                                 RelativePath=".\inflate.c">
    210                         </File>
    211                         <File
    212                                 RelativePath=".\inftrees.c">
    213                         </File>
    214                         <File
    215                                 RelativePath=".\ioapi.c">
    216                         </File>
    217                         <File
    218                                 RelativePath=".\trees.c">
    219                         </File>
    220                         <File
    221                                 RelativePath=".\uncompr.c">
    222                         </File>
    223                         <File
    224                                 RelativePath=".\unzip.c">
    225                         </File>
    226                         <File
    227                                 RelativePath=".\zip.c">
     189                                RelativePath="..\..\..\adler32.c">
     190                        </File>
     191                        <File
     192                                RelativePath="..\..\..\compress.c">
     193                        </File>
     194                        <File
     195                                RelativePath="..\..\..\crc32.c">
     196                        </File>
     197                        <File
     198                                RelativePath="..\..\..\deflate.c">
     199                        </File>
     200                        <File
     201                                RelativePath="..\..\masmx86\gvmat32c.c">
     202                        </File>
     203                        <File
     204                                RelativePath="..\..\..\gzio.c">
     205                        </File>
     206                        <File
     207                                RelativePath="..\..\..\infback.c">
     208                        </File>
     209                        <File
     210                                RelativePath="..\..\..\inffast.c">
     211                        </File>
     212                        <File
     213                                RelativePath="..\..\..\inflate.c">
     214                        </File>
     215                        <File
     216                                RelativePath="..\..\..\inftrees.c">
     217                        </File>
     218                        <File
     219                                RelativePath="..\..\minizip\ioapi.c">
     220                        </File>
     221                        <File
     222                                RelativePath="..\..\..\trees.c">
     223                        </File>
     224                        <File
     225                                RelativePath="..\..\..\uncompr.c">
     226                        </File>
     227                        <File
     228                                RelativePath="..\..\minizip\unzip.c">
     229                        </File>
     230                        <File
     231                                RelativePath="..\..\minizip\zip.c">
    228232                        </File>
    229233                        <File
     
    234238                        </File>
    235239                        <File
    236                                 RelativePath=".\zutil.c">
     240                                RelativePath="..\..\..\zutil.c">
    237241                        </File>
    238242                </Filter>
  • cpukit/zlib/contrib/vstudio/vc7/zlibvc.def

    re7fc2fd r8198f69  
    11
    2 VERSION         1.21
     2VERSION         1.23
    33
    44HEAPSIZE        1048576,8192
  • cpukit/zlib/contrib/vstudio/vc7/zlibvc.sln

    re7fc2fd r8198f69  
    77EndProject
    88Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "miniunz", "miniunz.vcproj", "{C52F9E7B-498A-42BE-8DB4-85A15694382A}"
     9EndProject
     10Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "testZlibDll", "testzlib.vcproj", "{AA6666AA-E09F-4135-9C0C-4FE50C3C654C}"
    911EndProject
    1012Global
     
    5961                {C52F9E7B-498A-42BE-8DB4-85A15694382A}.ReleaseWithoutCrtdll.ActiveCfg = Release|Win32
    6062                {C52F9E7B-498A-42BE-8DB4-85A15694382A}.ReleaseWithoutCrtdll.Build.0 = Release|Win32
     63                {AA6666AA-E09F-4135-9C0C-4FE50C3C654C}.Debug.ActiveCfg = Debug|Win32
     64                {AA6666AA-E09F-4135-9C0C-4FE50C3C654C}.Debug.Build.0 = Debug|Win32
     65                {AA6666AA-E09F-4135-9C0C-4FE50C3C654C}.Release.ActiveCfg = Release|Win32
     66                {AA6666AA-E09F-4135-9C0C-4FE50C3C654C}.Release.Build.0 = Release|Win32
     67                {AA6666AA-E09F-4135-9C0C-4FE50C3C654C}.ReleaseAxp.ActiveCfg = Release|Win32
     68                {AA6666AA-E09F-4135-9C0C-4FE50C3C654C}.ReleaseAxp.Build.0 = Release|Win32
     69                {AA6666AA-E09F-4135-9C0C-4FE50C3C654C}.ReleaseWithoutAsm.ActiveCfg = Release|Win32
     70                {AA6666AA-E09F-4135-9C0C-4FE50C3C654C}.ReleaseWithoutAsm.Build.0 = Release|Win32
     71                {AA6666AA-E09F-4135-9C0C-4FE50C3C654C}.ReleaseWithoutCrtdll.ActiveCfg = Release|Win32
     72                {AA6666AA-E09F-4135-9C0C-4FE50C3C654C}.ReleaseWithoutCrtdll.Build.0 = Release|Win32
    6173        EndGlobalSection
    6274        GlobalSection(ExtensibilityGlobals) = postSolution
  • cpukit/zlib/contrib/vstudio/vc7/zlibvc.vcproj

    re7fc2fd r8198f69  
    2121                                Name="VCCLCompilerTool"
    2222                                Optimization="0"
     23                                AdditionalIncludeDirectories="..\..\..;..\..\masmx86"
    2324                                PreprocessorDefinitions="WIN32,ZLIB_WINAPI,ASMV,ASMINF"
    2425                                ExceptionHandling="FALSE"
     
    3637                                Name="VCLinkerTool"
    3738                                AdditionalOptions="/MACHINE:I386"
    38                                 AdditionalDependencies="gvmat32.obj inffas32.obj"
     39                                AdditionalDependencies="..\..\masmx86\gvmat32.obj ..\..\masmx86\inffas32.obj"
    3940                                OutputFile=".\DebugDll\zlibwapi.dll"
    4041                                LinkIncremental="2"
     
    7374                        ConfigurationType="2"
    7475                        UseOfMFC="0"
    75                         ATLMinimizesCRunTimeLibraryUsage="FALSE">
     76                        ATLMinimizesCRunTimeLibraryUsage="FALSE"
     77                        WholeProgramOptimization="TRUE">
    7678                        <Tool
    7779                                Name="VCCLCompilerTool"
    7880                                InlineFunctionExpansion="1"
     81                                AdditionalIncludeDirectories="..\..\..;..\..\masmx86"
    7982                                PreprocessorDefinitions="WIN32,ZLIB_WINAPI"
    8083                                StringPooling="TRUE"
     
    135138                        ConfigurationType="2"
    136139                        UseOfMFC="0"
    137                         ATLMinimizesCRunTimeLibraryUsage="FALSE">
     140                        ATLMinimizesCRunTimeLibraryUsage="FALSE"
     141                        WholeProgramOptimization="TRUE">
    138142                        <Tool
    139143                                Name="VCCLCompilerTool"
    140144                                InlineFunctionExpansion="1"
     145                                AdditionalIncludeDirectories="..\..\..;..\..\masmx86"
    141146                                PreprocessorDefinitions="WIN32,ZLIB_WINAPI,ASMV,ASMINF"
    142147                                StringPooling="TRUE"
     
    157162                                Name="VCLinkerTool"
    158163                                AdditionalOptions="/MACHINE:I386"
    159                                 AdditionalDependencies="gvmat32.obj inffas32.obj "
     164                                AdditionalDependencies="..\..\masmx86\gvmat32.obj ..\..\masmx86\inffas32.obj "
    160165                                OutputFile=".\zlibDllWithoutCrtDll\zlibwapi.dll"
    161166                                LinkIncremental="1"
     
    197202                        ConfigurationType="2"
    198203                        UseOfMFC="0"
    199                         ATLMinimizesCRunTimeLibraryUsage="FALSE">
     204                        ATLMinimizesCRunTimeLibraryUsage="FALSE"
     205                        WholeProgramOptimization="TRUE">
    200206                        <Tool
    201207                                Name="VCCLCompilerTool"
    202208                                InlineFunctionExpansion="1"
     209                                AdditionalIncludeDirectories="..\..\..;..\..\masmx86"
    203210                                PreprocessorDefinitions="WIN32,ZLIB_WINAPI"
    204211                                StringPooling="TRUE"
     
    257264                        ConfigurationType="2"
    258265                        UseOfMFC="0"
    259                         ATLMinimizesCRunTimeLibraryUsage="FALSE">
     266                        ATLMinimizesCRunTimeLibraryUsage="FALSE"
     267                        WholeProgramOptimization="TRUE">
    260268                        <Tool
    261269                                Name="VCCLCompilerTool"
    262270                                InlineFunctionExpansion="1"
     271                                AdditionalIncludeDirectories="..\..\..;..\..\masmx86"
    263272                                PreprocessorDefinitions="WIN32,ZLIB_WINAPI,ASMV,ASMINF"
    264273                                StringPooling="TRUE"
     
    279288                                Name="VCLinkerTool"
    280289                                AdditionalOptions="/MACHINE:I386"
    281                                 AdditionalDependencies="gvmat32.obj inffas32.obj crtdll.lib"
     290                                AdditionalDependencies="..\..\masmx86\gvmat32.obj ..\..\masmx86\inffas32.obj crtdll.lib"
    282291                                OutputFile=".\ReleaseDll\zlibwapi.dll"
    283292                                LinkIncremental="1"
     
    319328                        Filter="cpp;c;cxx;rc;def;r;odl;hpj;bat;for;f90">
    320329                        <File
    321                                 RelativePath=".\adler32.c">
    322                         </File>
    323                         <File
    324                                 RelativePath=".\compress.c">
    325                         </File>
    326                         <File
    327                                 RelativePath=".\crc32.c">
    328                         </File>
    329                         <File
    330                                 RelativePath=".\deflate.c">
    331                         </File>
    332                         <File
    333                                 RelativePath=".\gvmat32c.c">
     330                                RelativePath="..\..\..\adler32.c">
     331                        </File>
     332                        <File
     333                                RelativePath="..\..\..\compress.c">
     334                        </File>
     335                        <File
     336                                RelativePath="..\..\..\crc32.c">
     337                        </File>
     338                        <File
     339                                RelativePath="..\..\..\deflate.c">
     340                        </File>
     341                        <File
     342                                RelativePath="..\..\masmx86\gvmat32c.c">
    334343                                <FileConfiguration
    335344                                        Name="ReleaseWithoutAsm|Win32"
     
    340349                        </File>
    341350                        <File
    342                                 RelativePath=".\gzio.c">
    343                         </File>
    344                         <File
    345                                 RelativePath=".\infback.c">
    346                         </File>
    347                         <File
    348                                 RelativePath=".\inffast.c">
    349                         </File>
    350                         <File
    351                                 RelativePath=".\inflate.c">
    352                         </File>
    353                         <File
    354                                 RelativePath=".\inftrees.c">
    355                         </File>
    356                         <File
    357                                 RelativePath=".\ioapi.c">
    358                         </File>
    359                         <File
    360                                 RelativePath=".\iowin32.c">
    361                         </File>
    362                         <File
    363                                 RelativePath=".\trees.c">
    364                         </File>
    365                         <File
    366                                 RelativePath=".\uncompr.c">
    367                         </File>
    368                         <File
    369                                 RelativePath=".\unzip.c">
     351                                RelativePath="..\..\..\gzio.c">
     352                        </File>
     353                        <File
     354                                RelativePath="..\..\..\infback.c">
     355                        </File>
     356                        <File
     357                                RelativePath="..\..\..\inffast.c">
     358                        </File>
     359                        <File
     360                                RelativePath="..\..\..\inflate.c">
     361                        </File>
     362                        <File
     363                                RelativePath="..\..\..\inftrees.c">
     364                        </File>
     365                        <File
     366                                RelativePath="..\..\minizip\ioapi.c">
     367                        </File>
     368                        <File
     369                                RelativePath="..\..\minizip\iowin32.c">
     370                        </File>
     371                        <File
     372                                RelativePath="..\..\..\trees.c">
     373                        </File>
     374                        <File
     375                                RelativePath="..\..\..\uncompr.c">
     376                        </File>
     377                        <File
     378                                RelativePath="..\..\minizip\unzip.c">
    370379                                <FileConfiguration
    371380                                        Name="Release|Win32">
     
    377386                        </File>
    378387                        <File
    379                                 RelativePath=".\zip.c">
     388                                RelativePath="..\..\minizip\zip.c">
    380389                                <FileConfiguration
    381390                                        Name="Release|Win32">
     
    393402                        </File>
    394403                        <File
    395                                 RelativePath=".\zutil.c">
     404                                RelativePath="..\..\..\zutil.c">
    396405                        </File>
    397406                </Filter>
     
    400409                        Filter="h;hpp;hxx;hm;inl;fi;fd">
    401410                        <File
    402                                 RelativePath=".\deflate.h">
    403                         </File>
    404                         <File
    405                                 RelativePath=".\infblock.h">
    406                         </File>
    407                         <File
    408                                 RelativePath=".\infcodes.h">
    409                         </File>
    410                         <File
    411                                 RelativePath=".\inffast.h">
    412                         </File>
    413                         <File
    414                                 RelativePath=".\inftrees.h">
    415                         </File>
    416                         <File
    417                                 RelativePath=".\infutil.h">
    418                         </File>
    419                         <File
    420                                 RelativePath=".\zconf.h">
    421                         </File>
    422                         <File
    423                                 RelativePath=".\zlib.h">
    424                         </File>
    425                         <File
    426                                 RelativePath=".\zutil.h">
     411                                RelativePath="..\..\..\deflate.h">
     412                        </File>
     413                        <File
     414                                RelativePath="..\..\..\infblock.h">
     415                        </File>
     416                        <File
     417                                RelativePath="..\..\..\infcodes.h">
     418                        </File>
     419                        <File
     420                                RelativePath="..\..\..\inffast.h">
     421                        </File>
     422                        <File
     423                                RelativePath="..\..\..\inftrees.h">
     424                        </File>
     425                        <File
     426                                RelativePath="..\..\..\infutil.h">
     427                        </File>
     428                        <File
     429                                RelativePath="..\..\..\zconf.h">
     430                        </File>
     431                        <File
     432                                RelativePath="..\..\..\zlib.h">
     433                        </File>
     434                        <File
     435                                RelativePath="..\..\..\zutil.h">
    427436                        </File>
    428437                </Filter>
  • cpukit/zlib/crc32.c

    re7fc2fd r8198f69  
    11/* crc32.c -- compute the CRC-32 of a data stream
    2  * Copyright (C) 1995-2004 Mark Adler
     2 * Copyright (C) 1995-2005 Mark Adler
    33 * For conditions of distribution and use, see copyright notice in zlib.h
    44 *
     
    6565#endif /* BYFOUR */
    6666
     67/* Local functions for crc concatenation */
     68local unsigned long gf2_matrix_times OF((unsigned long *mat,
     69                                         unsigned long vec));
     70local void gf2_matrix_square OF((unsigned long *square, unsigned long *mat));
     71
    6772#ifdef DYNAMIC_CRC_TABLE
    6873
     
    7378   local void write_table OF((FILE *, const unsigned long FAR *));
    7479#endif /* MAKECRCH */
    75 local unsigned long gf2_matrix_times OF((unsigned long *mat,
    76                                          unsigned long vec));
    77 local void gf2_matrix_square OF((unsigned long *square, unsigned long *mat));
    78 
    7980/*
    8081  Generate tables for a byte-wise 32-bit CRC calculation on the polynomial:
     
    274275    }
    275276
    276     buf4 = (const u4 FAR *)buf;
     277    buf4 = (const u4 FAR *)(const void FAR *)buf;
    277278    while (len >= 32) {
    278279        DOLIT32;
     
    314315    }
    315316
    316     buf4 = (const u4 FAR *)buf;
     317    buf4 = (const u4 FAR *)(const void FAR *)buf;
    317318    buf4--;
    318319    while (len >= 32) {
  • cpukit/zlib/deflate.c

    re7fc2fd r8198f69  
    11/* deflate.c -- compress data using the deflation algorithm
    2  * Copyright (C) 1995-2004 Jean-loup Gailly.
     2 * Copyright (C) 1995-2005 Jean-loup Gailly.
    33 * For conditions of distribution and use, see copyright notice in zlib.h
    44 */
     
    5353
    5454const char deflate_copyright[] =
    55    " deflate 1.2.2.2 Copyright 1995-2004 Jean-loup Gailly ";
     55   " deflate 1.2.3 Copyright 1995-2005 Jean-loup Gailly ";
    5656/*
    5757  If you use the zlib library in a product, an acknowledgment is welcome
     
    335335    if (length > MAX_DIST(s)) {
    336336        length = MAX_DIST(s);
    337 #ifndef USE_DICT_HEAD
    338337        dictionary += dictLength - length; /* use the tail of the dictionary */
    339 #endif
    340338    }
    341339    zmemcpy(s->window, dictionary, length);
     
    451449    s->strategy = strategy;
    452450    return err;
     451}
     452
     453/* ========================================================================= */
     454int ZEXPORT deflateTune(strm, good_length, max_lazy, nice_length, max_chain)
     455    z_streamp strm;
     456    int good_length;
     457    int max_lazy;
     458    int nice_length;
     459    int max_chain;
     460{
     461    deflate_state *s;
     462
     463    if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
     464    s = strm->state;
     465    s->good_match = good_length;
     466    s->max_lazy_match = max_lazy;
     467    s->nice_match = nice_length;
     468    s->max_chain_length = max_chain;
     469    return Z_OK;
    453470}
    454471
     
    584601                            (s->gzhead->comment == Z_NULL ? 0 : 16)
    585602                        );
    586                 put_byte(s, s->gzhead->time & 0xff);
    587                 put_byte(s, (s->gzhead->time >> 8) & 0xff);
    588                 put_byte(s, (s->gzhead->time >> 16) & 0xff);
    589                 put_byte(s, (s->gzhead->time >> 24) & 0xff);
     603                put_byte(s, (Byte)(s->gzhead->time & 0xff));
     604                put_byte(s, (Byte)((s->gzhead->time >> 8) & 0xff));
     605                put_byte(s, (Byte)((s->gzhead->time >> 16) & 0xff));
     606                put_byte(s, (Byte)((s->gzhead->time >> 24) & 0xff));
    590607                put_byte(s, s->level == 9 ? 2 :
    591608                            (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ?
     
    635652    if (s->status == EXTRA_STATE) {
    636653        if (s->gzhead->extra != NULL) {
    637             int beg = s->pending;   /* start of bytes to update crc */
     654            uInt beg = s->pending;  /* start of bytes to update crc */
    638655
    639656            while (s->gzindex < (s->gzhead->extra_len & 0xffff)) {
     
    663680    if (s->status == NAME_STATE) {
    664681        if (s->gzhead->name != NULL) {
    665             int beg = s->pending;   /* start of bytes to update crc */
     682            uInt beg = s->pending;  /* start of bytes to update crc */
    666683            int val;
    667684
     
    694711    if (s->status == COMMENT_STATE) {
    695712        if (s->gzhead->comment != NULL) {
    696             int beg = s->pending;   /* start of bytes to update crc */
     713            uInt beg = s->pending;  /* start of bytes to update crc */
    697714            int val;
    698715
     
    726743                flush_pending(strm);
    727744            if (s->pending + 2 <= s->pending_buf_size) {
    728                 put_byte(s, strm->adler & 0xff);
    729                 put_byte(s, (strm->adler >> 8) & 0xff);
     745                put_byte(s, (Byte)(strm->adler & 0xff));
     746                put_byte(s, (Byte)((strm->adler >> 8) & 0xff));
    730747                strm->adler = crc32(0L, Z_NULL, 0);
    731748                s->status = BUSY_STATE;
     
    9871004    s->match_available = 0;
    9881005    s->ins_h = 0;
     1006#ifndef FASTEST
    9891007#ifdef ASMV
    9901008    match_init(); /* initialize the asm code */
     1009#endif
    9911010#endif
    9921011}
     
    12851304               zlib, so we don't care about this pathological case.)
    12861305             */
     1306            /* %%% avoid this when Z_RLE */
    12871307            n = s->hash_size;
    12881308            p = &s->head[n];
     
    16541674}
    16551675#endif /* FASTEST */
     1676
     1677#if 0
     1678/* ===========================================================================
     1679 * For Z_RLE, simply look for runs of bytes, generate matches only of distance
     1680 * one.  Do not maintain a hash table.  (It will be regenerated if this run of
     1681 * deflate switches away from Z_RLE.)
     1682 */
     1683local block_state deflate_rle(s, flush)
     1684    deflate_state *s;
     1685    int flush;
     1686{
     1687    int bflush;         /* set if current block must be flushed */
     1688    uInt run;           /* length of run */
     1689    uInt max;           /* maximum length of run */
     1690    uInt prev;          /* byte at distance one to match */
     1691    Bytef *scan;        /* scan for end of run */
     1692
     1693    for (;;) {
     1694        /* Make sure that we always have enough lookahead, except
     1695         * at the end of the input file. We need MAX_MATCH bytes
     1696         * for the longest encodable run.
     1697         */
     1698        if (s->lookahead < MAX_MATCH) {
     1699            fill_window(s);
     1700            if (s->lookahead < MAX_MATCH && flush == Z_NO_FLUSH) {
     1701                return need_more;
     1702            }
     1703            if (s->lookahead == 0) break; /* flush the current block */
     1704        }
     1705
     1706        /* See how many times the previous byte repeats */
     1707        run = 0;
     1708        if (s->strstart > 0) {      /* if there is a previous byte, that is */
     1709            max = s->lookahead < MAX_MATCH ? s->lookahead : MAX_MATCH;
     1710            scan = s->window + s->strstart - 1;
     1711            prev = *scan++;
     1712            do {
     1713                if (*scan++ != prev)
     1714                    break;
     1715            } while (++run < max);
     1716        }
     1717
     1718        /* Emit match if have run of MIN_MATCH or longer, else emit literal */
     1719        if (run >= MIN_MATCH) {
     1720            check_match(s, s->strstart, s->strstart - 1, run);
     1721            _tr_tally_dist(s, 1, run - MIN_MATCH, bflush);
     1722            s->lookahead -= run;
     1723            s->strstart += run;
     1724        } else {
     1725            /* No match, output a literal byte */
     1726            Tracevv((stderr,"%c", s->window[s->strstart]));
     1727            _tr_tally_lit (s, s->window[s->strstart], bflush);
     1728            s->lookahead--;
     1729            s->strstart++;
     1730        }
     1731        if (bflush) FLUSH_BLOCK(s, 0);
     1732    }
     1733    FLUSH_BLOCK(s, flush == Z_FINISH);
     1734    return flush == Z_FINISH ? finish_done : block_done;
     1735}
     1736#endif
  • cpukit/zlib/deflate.h

    re7fc2fd r8198f69  
    9898    ulg   pending_buf_size; /* size of pending_buf */
    9999    Bytef *pending_out;  /* next pending byte to output to the stream */
    100     int   pending;       /* nb of bytes in the pending buffer */
     100    uInt   pending;      /* nb of bytes in the pending buffer */
    101101    int   wrap;          /* bit 0 true for zlib, bit 1 true for gzip */
    102102    gz_headerp  gzhead;  /* gzip header information to write */
    103     int   gzindex;       /* where in extra, name, or comment */
     103    uInt   gzindex;      /* where in extra, name, or comment */
    104104    Byte  method;        /* STORED (for zip only) or DEFLATED */
    105105    int   last_flush;    /* value of flush param for previous deflate call */
  • cpukit/zlib/examples/README.examples

    re7fc2fd r8198f69  
    44    compress just enough input to nearly fill a requested output size
    55    - zlib isn't designed to do this, but fitblk does it anyway
     6
     7gun.c
     8    uncompress a gzip file
     9    - illustrates the use of inflateBack() for high speed file-to-file
     10      decompression using call-back functions
     11    - is approximately twice as fast as gzip -d
     12    - also provides Unix uncompress functionality, again twice as fast
    613
    714gzappend.c
     
    2835    reads and writes zlib streams from stdin to stdout
    2936    - illustrates the proper use of deflate() and inflate()
     37    - deeply commented in zlib_how.html (see above)
     38
     39zran.c
     40    index a zlib or gzip stream and randomly access it
     41    - illustrates the use of Z_BLOCK, inflatePrime(), and
     42      inflateSetDictionary() to provide random access
  • cpukit/zlib/examples/fitblk.c

    re7fc2fd r8198f69  
    7474{
    7575    int ret, flush;
    76     char raw[RAWLEN];
     76    unsigned char raw[RAWLEN];
    7777
    7878    flush = Z_NO_FLUSH;
     
    9797{
    9898    int ret, flush;
    99     char raw[RAWLEN];
     99    unsigned char raw[RAWLEN];
    100100
    101101    flush = Z_NO_FLUSH;
     
    130130    unsigned size;          /* requested fixed output block size */
    131131    unsigned have;          /* bytes written by deflate() call */
    132     char *blk;              /* intermediate and final stream */
    133     char *tmp;              /* close to desired size stream */
     132    unsigned char *blk;     /* intermediate and final stream */
     133    unsigned char *tmp;     /* close to desired size stream */
    134134    z_stream def, inf;      /* zlib deflate and inflate states */
    135135
     
    164164        /* write block to stdout */
    165165        have = size + EXCESS - def.avail_out;
    166         ret = fwrite(blk, 1, have, stdout);
    167         if (ret != have || ferror(stdout))
     166        if (fwrite(blk, 1, have, stdout) != have || ferror(stdout))
    168167            quit("error writing output");
    169168
     
    218217    /* done -- write block to stdout */
    219218    have = size - def.avail_out;
    220     ret = fwrite(blk, 1, have, stdout);
    221     if (ret != have || ferror(stdout))
     219    if (fwrite(blk, 1, have, stdout) != have || ferror(stdout))
    222220        quit("error writing output");
    223221
  • cpukit/zlib/examples/gzjoin.c

    re7fc2fd r8198f69  
    2727 *
    2828 * 1.0  11 Dec 2004     - First version
     29 * 1.1  12 Jun 2005     - Changed ssize_t to long for portability
    2930 */
    3031
     
    119120local int bload(bin *in)
    120121{
    121     ssize_t len;
     122    long len;
    122123
    123124    if (in == NULL)
     
    127128    in->next = in->buf;
    128129    do {
    129         len = read(in->fd, in->buf + in->left, CHUNK - in->left);
     130        len = (long)read(in->fd, in->buf + in->left, CHUNK - in->left);
    130131        if (len < 0)
    131132            return -1;
  • cpukit/zlib/examples/zlib_how.html

    re7fc2fd r8198f69  
    421421</b></pre>
    422422The inner <tt>do</tt>-loop ends when <tt>inflate()</tt> has no more output as indicated
    423 by not filling the output buffer, just as for <tt>deflate()</tt>.
     423by not filling the output buffer, just as for <tt>deflate()</tt>.  In this case, we cannot
     424assert that <tt>strm.avail_in</tt> will be zero, since the deflate stream may end before the file
     425does.
    424426<pre><b>
    425427        } while (strm.avail_out == 0);
    426         assert(strm.avail_in == 0);     /* all input will be used */
    427428</b></pre><!-- -->
    428429The outer <tt>do</tt>-loop ends when <tt>inflate()</tt> reports that it has reached the
  • cpukit/zlib/examples/zpipe.c

    re7fc2fd r8198f69  
    88                     Use switch statement for inflate() return values
    99   1.2   9 Nov 2004  Add assertions to document zlib guarantees
     10   1.3   6 Apr 2005  Remove incorrect assertion in inf()
    1011 */
    1112
     
    128129            }
    129130        } while (strm.avail_out == 0);
    130         assert(strm.avail_in == 0);     /* all input will be used */
    131131
    132132        /* done when inflate() says it's done */
  • cpukit/zlib/gzio.c

    re7fc2fd r8198f69  
    11/* gzio.c -- IO on .gz files
    2  * Copyright (C) 1995-2004 Jean-loup Gailly.
     2 * Copyright (C) 1995-2005 Jean-loup Gailly.
    33 * For conditions of distribution and use, see copyright notice in zlib.h
    44 *
     
    265265    if (s->stream.avail_in == 0) {
    266266        errno = 0;
    267         s->stream.avail_in = fread(s->inbuf, 1, Z_BUFSIZE, s->file);
     267        s->stream.avail_in = (uInt)fread(s->inbuf, 1, Z_BUFSIZE, s->file);
    268268        if (s->stream.avail_in == 0) {
    269269            s->z_eof = 1;
     
    301301        if (len) s->inbuf[0] = s->stream.next_in[0];
    302302        errno = 0;
    303         len = fread(s->inbuf + len, 1, Z_BUFSIZE >> len, s->file);
     303        len = (uInt)fread(s->inbuf + len, 1, Z_BUFSIZE >> len, s->file);
    304304        if (len == 0 && ferror(s->file)) s->z_err = Z_ERRNO;
    305305        s->stream.avail_in += len;
     
    416416        s->back = EOF;
    417417        s->out++;
     418        start++;
    418419        if (s->last) {
    419420            s->z_err = Z_STREAM_END;
     
    437438            }
    438439            if (s->stream.avail_out > 0) {
    439                 s->stream.avail_out -= fread(next_out, 1, s->stream.avail_out,
    440                                             s->file);
     440                s->stream.avail_out -=
     441                    (uInt)fread(next_out, 1, s->stream.avail_out, s->file);
    441442            }
    442443            len -= s->stream.avail_out;
     
    449450
    450451            errno = 0;
    451             s->stream.avail_in = fread(s->inbuf, 1, Z_BUFSIZE, s->file);
     452            s->stream.avail_in = (uInt)fread(s->inbuf, 1, Z_BUFSIZE, s->file);
    452453            if (s->stream.avail_in == 0) {
    453454                s->z_eof = 1;
    454455                if (ferror(s->file)) {
    455456                    s->z_err = Z_ERRNO;
    456                     break;
    457                 }
    458                 if (feof(s->file)) {        /* avoid error for empty file */
    459                     s->z_err = Z_STREAM_END;
    460457                    break;
    461458                }
     
    493490    s->crc = crc32(s->crc, start, (uInt)(s->stream.next_out - start));
    494491
     492    if (len == s->stream.avail_out &&
     493        (s->z_err == Z_DATA_ERROR || s->z_err == Z_ERRNO))
     494        return -1;
    495495    return (int)(len - s->stream.avail_out);
    496496}
     
    904904
    905905/* ===========================================================================
     906     Returns 1 if reading and doing so transparently, otherwise zero.
     907*/
     908int ZEXPORT gzdirect (file)
     909    gzFile file;
     910{
     911    gz_stream *s = (gz_stream*)file;
     912
     913    if (s == NULL || s->mode != 'r') return 0;
     914    return s->transparent;
     915}
     916
     917/* ===========================================================================
    906918   Outputs a long in LSB order to the given file
    907919*/
     
    967979
    968980/* ===========================================================================
    969      Returns the error message for the last error which occured on the
     981     Returns the error message for the last error which occurred on the
    970982   given compressed file. errnum is set to zlib error number. If an
    971    error occured in the file system and not in the compression library,
     983   error occurred in the file system and not in the compression library,
    972984   errnum is set to Z_ERRNO and the application may consult errno
    973985   to get the exact error code.
  • cpukit/zlib/infback.c

    re7fc2fd r8198f69  
    11/* infback.c -- inflate using a call-back interface
    2  * Copyright (C) 1995-2004 Mark Adler
     2 * Copyright (C) 1995-2005 Mark Adler
    33 * For conditions of distribution and use, see copyright notice in zlib.h
    44 */
     
    5151    if (state == Z_NULL) return Z_MEM_ERROR;
    5252    Tracev((stderr, "inflate: allocated\n"));
    53     strm->state = (voidpf)state;
     53    strm->state = (struct internal_state FAR *)state;
    5454    state->dmax = 32768U;
    5555    state->wbits = windowBits;
  • cpukit/zlib/inflate.c

    re7fc2fd r8198f69  
    11/* inflate.c -- zlib decompression
    2  * Copyright (C) 1995-2004 Mark Adler
     2 * Copyright (C) 1995-2005 Mark Adler
    33 * For conditions of distribution and use, see copyright notice in zlib.h
    44 */
     
    118118    state->wsize = 0;
    119119    state->whave = 0;
     120    state->write = 0;
    120121    state->hold = 0;
    121122    state->bits = 0;
    122123    state->lencode = state->distcode = state->next = state->codes;
    123124    Tracev((stderr, "inflate: reset\n"));
     125    return Z_OK;
     126}
     127
     128int ZEXPORT inflatePrime(strm, bits, value)
     129z_streamp strm;
     130int bits;
     131int value;
     132{
     133    struct inflate_state FAR *state;
     134
     135    if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
     136    state = (struct inflate_state FAR *)strm->state;
     137    if (bits > 16 || state->bits + bits > 32) return Z_STREAM_ERROR;
     138    value &= (1L << bits) - 1;
     139    state->hold += value << state->bits;
     140    state->bits += bits;
    124141    return Z_OK;
    125142}
     
    147164    if (state == Z_NULL) return Z_MEM_ERROR;
    148165    Tracev((stderr, "inflate: allocated\n"));
    149     strm->state = (voidpf)state;
     166    strm->state = (struct internal_state FAR *)state;
    150167    if (windowBits < 0) {
    151168        state->wrap = 0;
     
    13111328    struct inflate_state FAR *copy;
    13121329    unsigned char FAR *window;
     1330    unsigned wsize;
    13131331
    13141332    /* check input */
     
    13351353    zmemcpy(dest, source, sizeof(z_stream));
    13361354    zmemcpy(copy, state, sizeof(struct inflate_state));
    1337     copy->lencode = copy->codes + (state->lencode - state->codes);
    1338     copy->distcode = copy->codes + (state->distcode - state->codes);
     1355    if (state->lencode >= state->codes &&
     1356        state->lencode <= state->codes + ENOUGH - 1) {
     1357        copy->lencode = copy->codes + (state->lencode - state->codes);
     1358        copy->distcode = copy->codes + (state->distcode - state->codes);
     1359    }
    13391360    copy->next = copy->codes + (state->next - state->codes);
    1340     if (window != Z_NULL)
    1341         zmemcpy(window, state->window, 1U << state->wbits);
     1361    if (window != Z_NULL) {
     1362        wsize = 1U << state->wbits;
     1363        zmemcpy(window, state->window, wsize);
     1364    }
    13421365    copy->window = window;
    1343     dest->state = (voidpf)copy;
     1366    dest->state = (struct internal_state FAR *)copy;
    13441367    return Z_OK;
    13451368}
  • cpukit/zlib/inftrees.c

    re7fc2fd r8198f69  
    11/* inftrees.c -- generate Huffman trees for efficient decoding
    2  * Copyright (C) 1995-2004 Mark Adler
     2 * Copyright (C) 1995-2005 Mark Adler
    33 * For conditions of distribution and use, see copyright notice in zlib.h
    44 */
     
    1010
    1111const char inflate_copyright[] =
    12    " inflate 1.2.2.2 Copyright 1995-2004 Mark Adler ";
     12   " inflate 1.2.3 Copyright 1995-2005 Mark Adler ";
    1313/*
    1414  If you use the zlib library in a product, an acknowledgment is welcome
     
    6363    static const unsigned short lext[31] = { /* Length codes 257..285 extra */
    6464        16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18,
    65         19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 72, 199};
     65        19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 201, 196};
    6666    static const unsigned short dbase[32] = { /* Distance codes 0..29 base */
    6767        1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
     
    135135        if (left < 0) return -1;        /* over-subscribed */
    136136    }
    137     if (left > 0 && (type == CODES || (codes - count[0] != 1)))
     137    if (left > 0 && (type == CODES || max != 1))
    138138        return -1;                      /* incomplete set */
    139139
     
    233233        incr = 1U << (len - drop);
    234234        fill = 1U << curr;
     235        min = fill;                 /* save offset to next table */
    235236        do {
    236237            fill -= incr;
     
    263264
    264265            /* increment past last table */
    265             next += 1U << curr;
     266            next += min;            /* here min is 1 << curr */
    266267
    267268            /* determine length of next table */
  • cpukit/zlib/inftrees.h

    re7fc2fd r8198f69  
    11/* inftrees.h -- header to use inftrees.c
    2  * Copyright (C) 1995-2003 Mark Adler
     2 * Copyright (C) 1995-2005 Mark Adler
    33 * For conditions of distribution and use, see copyright notice in zlib.h
    44 */
     
    3737
    3838/* Maximum size of dynamic tree.  The maximum found in a long but non-
    39    exhaustive search was 1004 code structures (850 for length/literals
    40    and 154 for distances, the latter actually the result of an
     39   exhaustive search was 1444 code structures (852 for length/literals
     40   and 592 for distances, the latter actually the result of an
    4141   exhaustive search).  The true maximum is not known, but the value
    4242   below is more than safe. */
    43 #define ENOUGH 1440
    44 #define MAXD 154
     43#define ENOUGH 2048
     44#define MAXD 592
    4545
    4646/* Type of code to build for inftable() */
  • cpukit/zlib/make_vms.com

    re7fc2fd r8198f69  
    1 $! make libz under VMS
    2 $! written by Martin P.J. Zinser <m.zinser@gsi.de>
     1$! make libz under VMS written by
     2$! Martin P.J. Zinser
     3$! <zinser@zinser.no-ip.info or zinser@sysdev.deutsche-boerse.com>
     4$!
     5$ on error then goto err_exit
     6$!
     7$!
     8$! Just some general constants...
     9$!
     10$ true  = 1
     11$ false = 0
     12$ tmpnam = "temp_" + f$getjpi("","pid")
     13$ SAY = "WRITE SYS$OUTPUT"
     14$!
     15$! Setup variables holding "config" information
     16$!
     17$ Make     = ""
     18$ name     = "Zlib"
     19$ version  = "?.?.?"
     20$ v_string = "ZLIB_VERSION"
     21$ v_file   = "zlib.h"
     22$ ccopt    = ""
     23$ lopts    = ""
     24$ linkonly = false
     25$ optfile  = name + ".opt"
     26$ its_decc = false
     27$ its_vaxc = false
     28$ its_gnuc = false
     29$ axp      = f$getsyi("HW_MODEL").ge.1024
     30$ s_case   = false
     31$! Check for MMK/MMS
     32$!
     33$ If F$Search ("Sys$System:MMS.EXE") .nes. "" Then Make = "MMS"
     34$ If F$Type (MMK) .eqs. "STRING" Then Make = "MMK"
     35$!
     36$!
     37$ gosub find_version
     38$!
     39$ gosub check_opts
    340$!
    441$! Look for the compiler used
    542$!
    6 $ ccopt = ""
    7 $ if f$getsyi("HW_MODEL").ge.1024
    8 $ then
    9 $  ccopt = "/prefix=all"+ccopt
    10 $  comp  = "__decc__=1"
    11 $  if f$trnlnm("SYS").eqs."" then define sys sys$library:
    12 $ else
    13 $  if f$search("SYS$SYSTEM:DECC$COMPILER.EXE").eqs.""
    14 $   then
    15 $    comp  = "__vaxc__=1"
     43$ gosub check_compiler
     44$ if its_decc
     45$ then
     46$   ccopt = "/prefix=all" + ccopt
     47$   if f$trnlnm("SYS") .eqs. ""
     48$   then
     49$     if axp
     50$     then
     51$       define sys sys$library:
     52$     else
     53$       ccopt = "/decc" + ccopt
     54$       define sys decc$library_include:
     55$     endif
     56$   endif
     57$ endif
     58$ if its_vaxc .or. its_gnuc
     59$ then
    1660$    if f$trnlnm("SYS").eqs."" then define sys sys$library:
    17 $   else
    18 $    if f$trnlnm("SYS").eqs."" then define sys decc$library_include:
    19 $    ccopt = "/decc/prefix=all"+ccopt
    20 $    comp  = "__decc__=1"
    21 $  endif
    2261$ endif
    2362$!
     
    2564$!
    2665$ write sys$output "Compiling Zlib sources ..."
    27 $ if f$search("SYS$SYSTEM:MMS.EXE").eqs.""
     66$ if make.eqs.""
    2867$  then
    2968$   dele example.obj;*,minigzip.obj;*
     
    3372                compress.c zlib.h zconf.h
    3473$   CALL MAKE crc32.OBJ "CC ''CCOPT' crc32" -
    35                 crc32.c crc32.h zlib.h zconf.h zutil.h
     74                crc32.c zlib.h zconf.h
    3675$   CALL MAKE deflate.OBJ "CC ''CCOPT' deflate" -
    3776                deflate.c deflate.h zutil.h zlib.h zconf.h
    38 $   CALL MAKE gzio.OBJ "CC ''CCOPT' gzio /define=""NO_vsnprintf""" -
     77$   CALL MAKE gzio.OBJ "CC ''CCOPT' gzio" -
    3978                gzio.c zutil.h zlib.h zconf.h
    4079$   CALL MAKE infback.OBJ "CC ''CCOPT' infback" -
    41                 infback.c zutil.h zlib.h zconf.h -
    42                 "inftrees.h inflate.h inffast.h inffixed.h"
     80                infback.c zutil.h inftrees.h inflate.h inffast.h inffixed.h
    4381$   CALL MAKE inffast.OBJ "CC ''CCOPT' inffast" -
    44                 inffast.c zutil.h zlib.h zconf.h -
    45                 "inftrees.h inflate.h inffast.h"
     82                inffast.c zutil.h zlib.h zconf.h inffast.h
    4683$   CALL MAKE inflate.OBJ "CC ''CCOPT' inflate" -
    47                 inflate.c zutil.h zlib.h zconf.h -
    48                 "inftrees.h inflate.h inffast.h inffixed.h"
     84                inflate.c zutil.h zlib.h zconf.h infblock.h
    4985$   CALL MAKE inftrees.OBJ "CC ''CCOPT' inftrees" -
    5086                inftrees.c zutil.h zlib.h zconf.h inftrees.h
    5187$   CALL MAKE trees.OBJ "CC ''CCOPT' trees" -
    52                 trees.c trees.h deflate.h zutil.h zlib.h zconf.h
     88                trees.c deflate.h zutil.h zlib.h zconf.h
    5389$   CALL MAKE uncompr.OBJ "CC ''CCOPT' uncompr" -
    5490                uncompr.c zlib.h zconf.h
     
    6197                example.c zlib.h zconf.h
    6298$   call make example.exe "LINK example,libz.olb/lib" example.obj libz.olb
    63 $   write sys$output "Building minigzip..."
    64 $   CALL MAKE minigzip.OBJ "CC ''CCOPT' minigzip" -
     99$   if f$search("x11vms:xvmsutils.olb") .nes. ""
     100$   then
     101$     write sys$output "Building minigzip..."
     102$     CALL MAKE minigzip.OBJ "CC ''CCOPT' minigzip" -
    65103                minigzip.c zlib.h zconf.h
    66 $   call make minigzip.exe -
    67                 "LINK minigzip,libz.olb/lib" -
     104$     call make minigzip.exe -
     105                "LINK minigzip,libz.olb/lib,x11vms:xvmsutils.olb/lib" -
    68106                minigzip.obj libz.olb
     107$   endif
    69108$  else
    70 $   mms/macro=('comp')
     109$   gosub crea_mms
     110$   SAY "Make ''name' ''version' with ''Make' "
     111$   'make'
    71112$  endif
     113$!
     114$! Alpha gets a shareable image
     115$!
     116$ If axp
     117$ Then
     118$   gosub crea_olist
     119$   write sys$output "Creating libzshr.exe"
     120$   call anal_obj_axp modules.opt _link.opt
     121$   if s_case
     122$   then
     123$      open/append optf modules.opt
     124$      write optf "case_sensitive=YES"
     125$      close optf
     126$   endif
     127$   LINK_'lopts'/SHARE=libzshr.exe modules.opt/opt,_link.opt/opt
     128$ endif
    72129$ write sys$output "Zlib build completed"
    73130$ exit
     131$CC_ERR:
     132$ write sys$output "C compiler required to build ''name'"
     133$ goto err_exit
     134$ERR_EXIT:
     135$ set message/facil/ident/sever/text
     136$ write sys$output "Exiting..."
     137$ exit 2
    74138$!
    75139$!
     
    113177$ If V Then Set Verify
    114178$ENDSUBROUTINE
     179$!------------------------------------------------------------------------------
     180$!
     181$! Check command line options and set symbols accordingly
     182$!
     183$ CHECK_OPTS:
     184$ i = 1
     185$ OPT_LOOP:
     186$ if i .lt. 9
     187$ then
     188$   cparm = f$edit(p'i',"upcase")
     189$   if cparm .eqs. "DEBUG"
     190$   then
     191$     ccopt = ccopt + "/noopt/deb"
     192$     lopts = lopts + "/deb"
     193$   endif
     194$   if f$locate("CCOPT=",cparm) .lt. f$length(cparm)
     195$   then
     196$     start = f$locate("=",cparm) + 1
     197$     len   = f$length(cparm) - start
     198$     ccopt = ccopt + f$extract(start,len,cparm)
     199$     if f$locate("AS_IS",f$edit(ccopt,"UPCASE")) .lt. f$length(ccopt) -
     200         then s_case = true
     201$   endif
     202$   if cparm .eqs. "LINK" then linkonly = true
     203$   if f$locate("LOPTS=",cparm) .lt. f$length(cparm)
     204$   then
     205$     start = f$locate("=",cparm) + 1
     206$     len   = f$length(cparm) - start
     207$     lopts = lopts + f$extract(start,len,cparm)
     208$   endif
     209$   if f$locate("CC=",cparm) .lt. f$length(cparm)
     210$   then
     211$     start  = f$locate("=",cparm) + 1
     212$     len    = f$length(cparm) - start
     213$     cc_com = f$extract(start,len,cparm)
     214      if (cc_com .nes. "DECC") .and. -
     215         (cc_com .nes. "VAXC") .and. -
     216         (cc_com .nes. "GNUC")
     217$     then
     218$       write sys$output "Unsupported compiler choice ''cc_com' ignored"
     219$       write sys$output "Use DECC, VAXC, or GNUC instead"
     220$     else
     221$       if cc_com .eqs. "DECC" then its_decc = true
     222$       if cc_com .eqs. "VAXC" then its_vaxc = true
     223$       if cc_com .eqs. "GNUC" then its_gnuc = true
     224$     endif
     225$   endif
     226$   if f$locate("MAKE=",cparm) .lt. f$length(cparm)
     227$   then
     228$     start  = f$locate("=",cparm) + 1
     229$     len    = f$length(cparm) - start
     230$     mmks = f$extract(start,len,cparm)
     231$     if (mmks .eqs. "MMK") .or. (mmks .eqs. "MMS")
     232$     then
     233$       make = mmks
     234$     else
     235$       write sys$output "Unsupported make choice ''mmks' ignored"
     236$       write sys$output "Use MMK or MMS instead"
     237$     endif
     238$   endif
     239$   i = i + 1
     240$   goto opt_loop
     241$ endif
     242$ return
     243$!------------------------------------------------------------------------------
     244$!
     245$! Look for the compiler used
     246$!
     247$CHECK_COMPILER:
     248$ if (.not. (its_decc .or. its_vaxc .or. its_gnuc))
     249$ then
     250$   its_decc = (f$search("SYS$SYSTEM:DECC$COMPILER.EXE") .nes. "")
     251$   its_vaxc = .not. its_decc .and. (F$Search("SYS$System:VAXC.Exe") .nes. "")
     252$   its_gnuc = .not. (its_decc .or. its_vaxc) .and. (f$trnlnm("gnu_cc") .nes. "")
     253$ endif
     254$!
     255$! Exit if no compiler available
     256$!
     257$ if (.not. (its_decc .or. its_vaxc .or. its_gnuc))
     258$ then goto CC_ERR
     259$ else
     260$   if its_decc then write sys$output "CC compiler check ... Compaq C"
     261$   if its_vaxc then write sys$output "CC compiler check ... VAX C"
     262$   if its_gnuc then write sys$output "CC compiler check ... GNU C"
     263$ endif
     264$ return
     265$!------------------------------------------------------------------------------
     266$!
     267$! If MMS/MMK are available dump out the descrip.mms if required
     268$!
     269$CREA_MMS:
     270$ write sys$output "Creating descrip.mms..."
     271$ create descrip.mms
     272$ open/append out descrip.mms
     273$ copy sys$input: out
     274$ deck
     275# descrip.mms: MMS description file for building zlib on VMS
     276# written by Martin P.J. Zinser
     277# <zinser@zinser.no-ip.info or zinser@sysdev.deutsche-boerse.com>
     278
     279OBJS = adler32.obj, compress.obj, crc32.obj, gzio.obj, uncompr.obj, infback.obj\
     280       deflate.obj, trees.obj, zutil.obj, inflate.obj, \
     281       inftrees.obj, inffast.obj
     282
     283$ eod
     284$ write out "CFLAGS=", ccopt
     285$ write out "LOPTS=", lopts
     286$ copy sys$input: out
     287$ deck
     288
     289all : example.exe minigzip.exe libz.olb
     290        @ write sys$output " Example applications available"
     291
     292libz.olb : libz.olb($(OBJS))
     293        @ write sys$output " libz available"
     294
     295example.exe : example.obj libz.olb
     296              link $(LOPTS) example,libz.olb/lib
     297
     298minigzip.exe : minigzip.obj libz.olb
     299              link $(LOPTS) minigzip,libz.olb/lib,x11vms:xvmsutils.olb/lib
     300
     301clean :
     302        delete *.obj;*,libz.olb;*,*.opt;*,*.exe;*
     303
     304
     305# Other dependencies.
     306adler32.obj  : adler32.c zutil.h zlib.h zconf.h
     307compress.obj : compress.c zlib.h zconf.h
     308crc32.obj    : crc32.c zutil.h zlib.h zconf.h
     309deflate.obj  : deflate.c deflate.h zutil.h zlib.h zconf.h
     310example.obj  : example.c zlib.h zconf.h
     311gzio.obj     : gzio.c zutil.h zlib.h zconf.h
     312inffast.obj  : inffast.c zutil.h zlib.h zconf.h inftrees.h inffast.h
     313inflate.obj  : inflate.c zutil.h zlib.h zconf.h
     314inftrees.obj : inftrees.c zutil.h zlib.h zconf.h inftrees.h
     315minigzip.obj : minigzip.c zlib.h zconf.h
     316trees.obj    : trees.c deflate.h zutil.h zlib.h zconf.h
     317uncompr.obj  : uncompr.c zlib.h zconf.h
     318zutil.obj    : zutil.c zutil.h zlib.h zconf.h
     319infback.obj  : infback.c zutil.h inftrees.h inflate.h inffast.h inffixed.h
     320$ eod
     321$ close out
     322$ return
     323$!------------------------------------------------------------------------------
     324$!
     325$! Read list of core library sources from makefile.in and create options
     326$! needed to build shareable image
     327$!
     328$CREA_OLIST:
     329$ open/read min makefile.in
     330$ open/write mod modules.opt
     331$ src_check = "OBJS ="
     332$MRLOOP:
     333$ read/end=mrdone min rec
     334$ if (f$extract(0,6,rec) .nes. src_check) then goto mrloop
     335$ rec = rec - src_check
     336$ gosub extra_filnam
     337$ if (f$element(1,"\",rec) .eqs. "\") then goto mrdone
     338$MRSLOOP:
     339$ read/end=mrdone min rec
     340$ gosub extra_filnam
     341$ if (f$element(1,"\",rec) .nes. "\") then goto mrsloop
     342$MRDONE:
     343$ close min
     344$ close mod
     345$ return
     346$!------------------------------------------------------------------------------
     347$!
     348$! Take record extracted in crea_olist and split it into single filenames
     349$!
     350$EXTRA_FILNAM:
     351$ myrec = f$edit(rec - "\", "trim,compress")
     352$ i = 0
     353$FELOOP:
     354$ srcfil = f$element(i," ", myrec)
     355$ if (srcfil .nes. " ")
     356$ then
     357$   write mod f$parse(srcfil,,,"NAME"), ".obj"
     358$   i = i + 1
     359$   goto feloop
     360$ endif
     361$ return
     362$!------------------------------------------------------------------------------
     363$!
     364$! Find current Zlib version number
     365$!
     366$FIND_VERSION:
     367$ open/read h_in 'v_file'
     368$hloop:
     369$ read/end=hdone h_in rec
     370$ rec = f$edit(rec,"TRIM")
     371$ if (f$extract(0,1,rec) .nes. "#") then goto hloop
     372$ rec = f$edit(rec - "#", "TRIM")
     373$ if f$element(0," ",rec) .nes. "define" then goto hloop
     374$ if f$element(1," ",rec) .eqs. v_string
     375$ then
     376$   version = 'f$element(2," ",rec)'
     377$   goto hdone
     378$ endif
     379$ goto hloop
     380$hdone:
     381$ close h_in
     382$ return
     383$!------------------------------------------------------------------------------
     384$!
     385$! Analyze Object files for OpenVMS AXP to extract Procedure and Data
     386$! information to build a symbol vector for a shareable image
     387$! All the "brains" of this logic was suggested by Hartmut Becker
     388$! (Hartmut.Becker@compaq.com). All the bugs were introduced by me
     389$! (zinser@decus.de), so if you do have problem reports please do not
     390$! bother Hartmut/HP, but get in touch with me
     391$!
     392$ ANAL_OBJ_AXP: Subroutine
     393$ V = 'F$Verify(0)
     394$ SAY := "WRITE_ SYS$OUTPUT"
     395$
     396$ IF F$SEARCH("''P1'") .EQS. ""
     397$ THEN
     398$    SAY "ANAL_OBJ_AXP-E-NOSUCHFILE:  Error, inputfile ''p1' not available"
     399$    goto exit_aa
     400$ ENDIF
     401$ IF "''P2'" .EQS. ""
     402$ THEN
     403$    SAY "ANAL_OBJ_AXP:  Error, no output file provided"
     404$    goto exit_aa
     405$ ENDIF
     406$
     407$ open/read in 'p1
     408$ create a.tmp
     409$ open/append atmp a.tmp
     410$ loop:
     411$ read/end=end_loop in line
     412$ f= f$search(line)
     413$ if f .eqs. ""
     414$ then
     415$       write sys$output "ANAL_OBJ_AXP-w-nosuchfile, ''line'"
     416$       goto loop
     417$ endif
     418$ define/user sys$output nl:
     419$ define/user sys$error nl:
     420$ anal/obj/gsd 'f /out=x.tmp
     421$ open/read xtmp x.tmp
     422$ XLOOP:
     423$ read/end=end_xloop xtmp xline
     424$ xline = f$edit(xline,"compress")
     425$ write atmp xline
     426$ goto xloop
     427$ END_XLOOP:
     428$ close xtmp
     429$ goto loop
     430$ end_loop:
     431$ close in
     432$ close atmp
     433$ if f$search("a.tmp") .eqs. "" -
     434        then $ exit
     435$ ! all global definitions
     436$ search a.tmp "symbol:","EGSY$V_DEF 1","EGSY$V_NORM 1"/out=b.tmp
     437$ ! all procedures
     438$ search b.tmp "EGSY$V_NORM 1"/wind=(0,1) /out=c.tmp
     439$ search c.tmp "symbol:"/out=d.tmp
     440$ define/user sys$output nl:
     441$ edito/edt/command=sys$input d.tmp
     442sub/symbol: "/symbol_vector=(/whole
     443sub/"/=PROCEDURE)/whole
     444exit
     445$ ! all data
     446$ search b.tmp "EGSY$V_DEF 1"/wind=(0,1) /out=e.tmp
     447$ search e.tmp "symbol:"/out=f.tmp
     448$ define/user sys$output nl:
     449$ edito/edt/command=sys$input f.tmp
     450sub/symbol: "/symbol_vector=(/whole
     451sub/"/=DATA)/whole
     452exit
     453$ sort/nodupl d.tmp,f.tmp 'p2'
     454$ delete a.tmp;*,b.tmp;*,c.tmp;*,d.tmp;*,e.tmp;*,f.tmp;*
     455$ if f$search("x.tmp") .nes. "" -
     456        then $ delete x.tmp;*
     457$!
     458$ EXIT_AA:
     459$ if V then set verify
     460$ endsubroutine
     461$!------------------------------------------------------------------------------
  • cpukit/zlib/minigzip.c

    re7fc2fd r8198f69  
    11/* minigzip.c -- simulate gzip using the zlib compression library
    2  * Copyright (C) 1995-2004 Jean-loup Gailly.
     2 * Copyright (C) 1995-2005 Jean-loup Gailly.
    33 * For conditions of distribution and use, see copyright notice in zlib.h
    44 */
     
    296296      argc--, argv++;
    297297    }
     298    if (outmode[3] == ' ')
     299        outmode[3] = 0;
    298300    if (argc == 0) {
    299301        SET_BINARY_MODE(stdin);
  • cpukit/zlib/old/Makefile.riscos

    re7fc2fd r8198f69  
    44
    55# Toolflags:
    6 CCflags = -c -depend !Depend -IC: -g -throwback  -DRISCOS  -fah 
     6CCflags = -c -depend !Depend -IC: -g -throwback  -DRISCOS  -fah
    77C++flags = -c -depend !Depend -IC: -throwback
    8 Linkflags = -aif -c++ -o $@ 
     8Linkflags = -aif -c++ -o $@
    99ObjAsmflags = -throwback -NoCache -depend !Depend
    10 CMHGflags = 
    11 LibFileflags = -c -l -o $@ 
     10CMHGflags =
     11LibFileflags = -c -l -o $@
    1212Squeezeflags = -o $@
    1313
     
    1818@.lib:   @.o.adler32 @.o.compress @.o.crc32 @.o.deflate @.o.gzio \
    1919        @.o.infblock @.o.infcodes @.o.inffast @.o.inflate @.o.inftrees @.o.infutil @.o.trees \
    20         @.o.uncompr @.o.zutil 
     20        @.o.uncompr @.o.zutil
    2121        LibFile $(LibFileflags) @.o.adler32 @.o.compress @.o.crc32 @.o.deflate \
    2222        @.o.gzio @.o.infblock @.o.infcodes @.o.inffast @.o.inflate @.o.inftrees @.o.infutil \
    23         @.o.trees @.o.uncompr @.o.zutil 
     23        @.o.trees @.o.uncompr @.o.zutil
    2424test:   @.minigzip @.example @.lib
    2525        @copy @.lib @.libc  A~C~DF~L~N~P~Q~RS~TV
     
    4242        @echo that will have given lots of hello!'s.
    4343
    44 @.minigzip:   @.o.minigzip @.lib C:o.Stubs 
    45         Link $(Linkflags) @.o.minigzip @.lib C:o.Stubs 
    46 @.example:   @.o.example @.lib C:o.Stubs 
     44@.minigzip:   @.o.minigzip @.lib C:o.Stubs
     45        Link $(Linkflags) @.o.minigzip @.lib C:o.Stubs
     46@.example:   @.o.example @.lib C:o.Stubs
    4747        Link $(Linkflags) @.o.example @.lib C:o.Stubs
    4848
  • cpukit/zlib/qnx/package.qpg

    re7fc2fd r8198f69  
    2626         <QPG:Add file="../zconf.h" install="/opt/include/" user="root:sys" permission="644"/>
    2727         <QPG:Add file="../zlib.h" install="/opt/include/" user="root:sys" permission="644"/>
    28          <QPG:Add file="../libz.so.1.2.2.2" install="/opt/lib/" user="root:bin" permission="644"/>
    29          <QPG:Add file="libz.so" install="/opt/lib/" component="dev" filetype="symlink" linkto="libz.so.1.2.2.2"/>
    30          <QPG:Add file="libz.so.1" install="/opt/lib/" filetype="symlink" linkto="libz.so.1.2.2.2"/>
    31          <QPG:Add file="../libz.so.1.2.2.2" install="/opt/lib/" component="slib"/>
     28         <QPG:Add file="../libz.so.1.2.3" install="/opt/lib/" user="root:bin" permission="644"/>
     29         <QPG:Add file="libz.so" install="/opt/lib/" component="dev" filetype="symlink" linkto="libz.so.1.2.3"/>
     30         <QPG:Add file="libz.so.1" install="/opt/lib/" filetype="symlink" linkto="libz.so.1.2.3"/>
     31         <QPG:Add file="../libz.so.1.2.3" install="/opt/lib/" component="slib"/>
    3232      </QPG:Files>
    3333
     
    6464
    6565            <QPM:ReleaseDescription>
    66                <QPM:ReleaseVersion>1.2.2.2</QPM:ReleaseVersion>
     66               <QPM:ReleaseVersion>1.2.3</QPM:ReleaseVersion>
    6767               <QPM:ReleaseUrgency>Medium</QPM:ReleaseUrgency>
    6868               <QPM:ReleaseStability>Stable</QPM:ReleaseStability>
     
    106106            </QPM:ProductInstallationProcedure>
    107107         </QPM:PackageManifest>
    108          
     108
    109109         <QPM:Launch>
    110110         </QPM:Launch>
     
    120120            </QPM:ProductInstallationProcedure>
    121121         </QPM:PackageManifest>
    122          
     122
    123123         <QPM:Launch>
    124124         </QPM:Launch>
     
    134134            </QPM:ProductInstallationProcedure>
    135135         </QPM:PackageManifest>
    136          
     136
    137137         <QPM:Launch>
    138138         </QPM:Launch>
  • cpukit/zlib/trees.c

    re7fc2fd r8198f69  
    11/* trees.c -- output deflated data using Huffman coding
    2  * Copyright (C) 1995-2004 Jean-loup Gailly
     2 * Copyright (C) 1995-2005 Jean-loup Gailly
    33 * For conditions of distribution and use, see copyright notice in zlib.h
    44 */
     
    556556            m = s->heap[--h];
    557557            if (m > max_code) continue;
    558             if (tree[m].Len != (unsigned) bits) {
     558            if ((unsigned) tree[m].Len != (unsigned) bits) {
    559559                Trace((stderr,"code %d bits %d->%d\n", m, tree[m].Len, bits));
    560560                s->opt_len += ((long)bits - (long)tree[m].Len)
  • cpukit/zlib/win32/zlib1.rc

    re7fc2fd r8198f69  
    66VS_VERSION_INFO         VERSIONINFO     MOVEABLE IMPURE LOADONCALL DISCARDABLE
    77#endif
    8   FILEVERSION           1,2,2,2
    9   PRODUCTVERSION        1,2,2,2
     8  FILEVERSION           1,2,2,0
     9  PRODUCTVERSION        1,2,2,0
    1010  FILEFLAGSMASK         VS_FFI_FILEFLAGSMASK
    1111#ifdef _DEBUG
     
    2424    BEGIN
    2525      VALUE "FileDescription",  "zlib data compression library\0"
    26       VALUE "FileVersion",      "1.2.2.2\0"
     26      VALUE "FileVersion",      "1.2.3\0"
    2727      VALUE "InternalName",     "zlib1.dll\0"
    2828      VALUE "LegalCopyright",   "(C) 1995-2004 Jean-loup Gailly & Mark Adler\0"
    2929      VALUE "OriginalFilename", "zlib1.dll\0"
    3030      VALUE "ProductName",      "zlib\0"
    31       VALUE "ProductVersion",   "1.2.2.2\0"
     31      VALUE "ProductVersion",   "1.2.3\0"
    3232      VALUE "Comments","DLL support by Alessandro Iacopetti & Gilles Vollant\0"
    3333    END
  • cpukit/zlib/zconf.h

    re7fc2fd r8198f69  
    11/* zconf.h -- configuration of the zlib compression library
    2  * Copyright (C) 1995-2004 Jean-loup Gailly.
     2 * Copyright (C) 1995-2005 Jean-loup Gailly.
    33 * For conditions of distribution and use, see copyright notice in zlib.h
    44 */
     
    6969#  define WINDOWS
    7070#endif
    71 #if (defined(_WIN32) || defined(__WIN32__)) && !defined(WIN32)
    72 #  define WIN32
     71#if defined(_WIN32) || defined(_WIN32_WCE) || defined(__WIN32__)
     72#  ifndef WIN32
     73#    define WIN32
     74#  endif
    7375#endif
    7476#if (defined(MSDOS) || defined(OS2) || defined(WINDOWS)) && !defined(WIN32)
  • cpukit/zlib/zconf.in.h

    re7fc2fd r8198f69  
    11/* zconf.h -- configuration of the zlib compression library
    2  * Copyright (C) 1995-2004 Jean-loup Gailly.
     2 * Copyright (C) 1995-2005 Jean-loup Gailly.
    33 * For conditions of distribution and use, see copyright notice in zlib.h
    44 */
     
    6969#  define WINDOWS
    7070#endif
    71 #if (defined(_WIN32) || defined(__WIN32__)) && !defined(WIN32)
    72 #  define WIN32
     71#if defined(_WIN32) || defined(_WIN32_WCE) || defined(__WIN32__)
     72#  ifndef WIN32
     73#    define WIN32
     74#  endif
    7375#endif
    7476#if (defined(MSDOS) || defined(OS2) || defined(WINDOWS)) && !defined(WIN32)
  • cpukit/zlib/zlib.3

    re7fc2fd r8198f69  
    1 .TH ZLIB 3 "30 December 2004"
     1.TH ZLIB 3 "18 July 2005"
    22.SH NAME
    33zlib \- compression/decompression library
     
    134134or (for the Windows DLL version) to Gilles Vollant (info@winimage.com).
    135135.SH AUTHORS
    136 Version 1.2.2.2
    137 Copyright (C) 1995-2004 Jean-loup Gailly (jloup@gzip.org)
     136Version 1.2.3
     137Copyright (C) 1995-2005 Jean-loup Gailly (jloup@gzip.org)
    138138and Mark Adler (madler@alumni.caltech.edu).
    139139.LP
  • cpukit/zlib/zlib.h

    re7fc2fd r8198f69  
    11/* zlib.h -- interface of the 'zlib' general purpose compression library
    2   version 1.2.2.2, December 30th, 2004
    3 
    4   Copyright (C) 1995-2004 Jean-loup Gailly and Mark Adler
     2  version 1.2.3, July 18th, 2005
     3
     4  Copyright (C) 1995-2005 Jean-loup Gailly and Mark Adler
    55
    66  This software is provided 'as-is', without any express or implied
     
    3838#endif
    3939
    40 #define ZLIB_VERSION "1.2.2.2"
    41 #define ZLIB_VERNUM 0x1222
     40#define ZLIB_VERSION "1.2.3"
     41#define ZLIB_VERNUM 0x1230
    4242
    4343/*
     
    557557   discarded, for example if the dictionary is larger than the window size in
    558558   deflate or deflate2. Thus the strings most likely to be useful should be
    559    put at the end of the dictionary, not at the front.
     559   put at the end of the dictionary, not at the front. In addition, the
     560   current implementation of deflate will use at most the window size minus
     561   262 bytes of the provided dictionary.
    560562
    561563     Upon return of this function, strm->adler is set to the adler32 value
     
    622624   if strm->avail_out was zero.
    623625*/
     626
     627ZEXTERN int ZEXPORT deflateTune OF((z_streamp strm,
     628                                    int good_length,
     629                                    int max_lazy,
     630                                    int nice_length,
     631                                    int max_chain));
     632/*
     633     Fine tune deflate's internal compression parameters.  This should only be
     634   used by someone who understands the algorithm used by zlib's deflate for
     635   searching for the best matching string, and even then only by the most
     636   fanatic optimizer trying to squeeze out the last compressed bit for their
     637   specific input data.  Read the deflate.c source code for the meaning of the
     638   max_lazy, good_length, nice_length, and max_chain parameters.
     639
     640     deflateTune() can be called after deflateInit() or deflateInit2(), and
     641   returns Z_OK on success, or Z_STREAM_ERROR for an invalid deflate stream.
     642 */
    624643
    625644ZEXTERN uLong ZEXPORT deflateBound OF((z_streamp strm,
     
    704723   32 to windowBits to enable zlib and gzip decoding with automatic header
    705724   detection, or add 16 to decode only the gzip format (the zlib format will
    706    return a Z_DATA_ERROR.  If a gzip stream is being decoded, strm->adler is
     725   return a Z_DATA_ERROR).  If a gzip stream is being decoded, strm->adler is
    707726   a crc32 instead of an adler32.
    708727
    709728     inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
    710    memory, Z_STREAM_ERROR if a parameter is invalid (such as a negative
    711    memLevel). msg is set to null if there is no error message.  inflateInit2
    712    does not perform any decompression apart from reading the zlib header if
    713    present: this will be done by inflate(). (So next_in and avail_in may be
    714    modified, but next_out and avail_out are unchanged.)
     729   memory, Z_STREAM_ERROR if a parameter is invalid (such as a null strm). msg
     730   is set to null if there is no error message.  inflateInit2 does not perform
     731   any decompression apart from reading the zlib header if present: this will
     732   be done by inflate(). (So next_in and avail_in may be modified, but next_out
     733   and avail_out are unchanged.)
    715734*/
    716735
     
    776795      inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
    777796   stream state was inconsistent (such as zalloc or state being NULL).
     797*/
     798
     799ZEXTERN int ZEXPORT inflatePrime OF((z_streamp strm,
     800                                     int bits,
     801                                     int value));
     802/*
     803     This function inserts bits in the inflate input stream.  The intent is
     804  that this function is used to start inflating at a bit position in the
     805  middle of a byte.  The provided bits will be used before any bytes are used
     806  from next_in.  This function should only be used with raw inflate, and
     807  should be used before the first inflate() call after inflateInit2() or
     808  inflateReset().  bits must be less than or equal to 16, and that many of the
     809  least significant bits of value will be inserted in the input.
     810
     811      inflatePrime returns Z_OK if success, or Z_STREAM_ERROR if the source
     812   stream state was inconsistent.
    778813*/
    779814
     
    11841219     Returns 1 when EOF has previously been detected reading the given
    11851220   input stream, otherwise zero.
     1221*/
     1222
     1223ZEXTERN int ZEXPORT gzdirect OF((gzFile file));
     1224/*
     1225     Returns 1 if file is being read directly without decompression, otherwise
     1226   zero.
    11861227*/
    11871228
  • cpukit/zlib/zutil.c

    re7fc2fd r8198f69  
    11/* zutil.c -- target dependent utility functions for the compression library
    2  * Copyright (C) 1995-2004 Jean-loup Gailly.
     2 * Copyright (C) 1995-2005 Jean-loup Gailly.
    33 * For conditions of distribution and use, see copyright notice in zlib.h
    44 */
     
    7575#endif
    7676#ifdef NO_GZCOMPRESS
    77     flags += 1 << 16;
     77    flags += 1L << 16;
    7878#endif
    7979#ifdef NO_GZIP
    80     flags += 1 << 17;
     80    flags += 1L << 17;
    8181#endif
    8282#ifdef PKZIP_BUG_WORKAROUND
    83     flags += 1 << 20;
     83    flags += 1L << 20;
    8484#endif
    8585#ifdef FASTEST
    86     flags += 1 << 21;
     86    flags += 1L << 21;
    8787#endif
    8888#ifdef STDC
    8989#  ifdef NO_vsnprintf
    90         flags += 1 << 25;
     90        flags += 1L << 25;
    9191#    ifdef HAS_vsprintf_void
    92         flags += 1 << 26;
     92        flags += 1L << 26;
    9393#    endif
    9494#  else
    9595#    ifdef HAS_vsnprintf_void
    96         flags += 1 << 26;
     96        flags += 1L << 26;
    9797#    endif
    9898#  endif
    9999#else
    100         flags += 1 << 24;
     100        flags += 1L << 24;
    101101#  ifdef NO_snprintf
    102         flags += 1 << 25;
     102        flags += 1L << 25;
    103103#    ifdef HAS_sprintf_void
    104         flags += 1 << 26;
     104        flags += 1L << 26;
    105105#    endif
    106106#  else
    107107#    ifdef HAS_snprintf_void
    108         flags += 1 << 26;
     108        flags += 1L << 26;
    109109#    endif
    110110#  endif
  • cpukit/zlib/zutil.h

    re7fc2fd r8198f69  
    11/* zutil.h -- internal interface and configuration of the compression library
    2  * Copyright (C) 1995-2004 Jean-loup Gailly.
     2 * Copyright (C) 1995-2005 Jean-loup Gailly.
    33 * For conditions of distribution and use, see copyright notice in zlib.h
    44 */
     
    1818
    1919#ifdef STDC
    20 #  include <stddef.h>
     20#  ifndef _WIN32_WCE
     21#    include <stddef.h>
     22#  endif
    2123#  include <string.h>
    2224#  include <stdlib.h>
     
    3335    extern int errno;
    3436#else
    35 #   include <errno.h>
     37#  ifndef _WIN32_WCE
     38#    include <errno.h>
     39#  endif
    3640#endif
    3741
     
    114118#ifdef OS2
    115119#  define OS_CODE  0x06
     120#  ifdef M_I86
     121     #include <malloc.h>
     122#  endif
    116123#endif
    117124
Note: See TracChangeset for help on using the changeset viewer.