[llvm-commits] [parallel] CVS: llvm/runtime/zlib/contrib/delphi/ZLib.pas ZLibConst.pas readme.txt zlibd32.mak

Misha Brukman brukman at cs.uiuc.edu
Mon Mar 1 18:12:32 PST 2004


Changes in directory llvm/runtime/zlib/contrib/delphi:

ZLib.pas added (r1.1.2.1)
ZLibConst.pas added (r1.1.2.1)
readme.txt added (r1.1.2.1)
zlibd32.mak added (r1.1.2.1)

---
Log message:

Merge from trunk

---
Diffs of the changes:  (+737 -0)

Index: llvm/runtime/zlib/contrib/delphi/ZLib.pas
diff -c /dev/null llvm/runtime/zlib/contrib/delphi/ZLib.pas:1.1.2.1
*** /dev/null	Mon Mar  1 17:58:58 2004
--- llvm/runtime/zlib/contrib/delphi/ZLib.pas	Mon Mar  1 17:58:48 2004
***************
*** 0 ****
--- 1,557 ----
+ {*******************************************************}
+ {                                                       }
+ {       Borland Delphi Supplemental Components          }
+ {       ZLIB Data Compression Interface Unit            }
+ {                                                       }
+ {       Copyright (c) 1997,99 Borland Corporation       }
+ {                                                       }
+ {*******************************************************}
+ 
+ { Updated for zlib 1.2.x by Cosmin Truta <cosmint at cs.ubbcluj.ro> }
+ 
+ unit ZLib;
+ 
+ interface
+ 
+ uses SysUtils, Classes;
+ 
+ type
+   TAlloc = function (AppData: Pointer; Items, Size: Integer): Pointer; cdecl;
+   TFree = procedure (AppData, Block: Pointer); cdecl;
+ 
+   // Internal structure.  Ignore.
+   TZStreamRec = packed record
+     next_in: PChar;       // next input byte
+     avail_in: Integer;    // number of bytes available at next_in
+     total_in: Longint;    // total nb of input bytes read so far
+ 
+     next_out: PChar;      // next output byte should be put here
+     avail_out: Integer;   // remaining free space at next_out
+     total_out: Longint;   // total nb of bytes output so far
+ 
+     msg: PChar;           // last error message, NULL if no error
+     internal: Pointer;    // not visible by applications
+ 
+     zalloc: TAlloc;       // used to allocate the internal state
+     zfree: TFree;         // used to free the internal state
+     AppData: Pointer;     // private data object passed to zalloc and zfree
+ 
+     data_type: Integer;   // best guess about the data type: ascii or binary
+     adler: Longint;       // adler32 value of the uncompressed data
+     reserved: Longint;    // reserved for future use
+   end;
+ 
+   // Abstract ancestor class
+   TCustomZlibStream = class(TStream)
+   private
+     FStrm: TStream;
+     FStrmPos: Integer;
+     FOnProgress: TNotifyEvent;
+     FZRec: TZStreamRec;
+     FBuffer: array [Word] of Char;
+   protected
+     procedure Progress(Sender: TObject); dynamic;
+     property OnProgress: TNotifyEvent read FOnProgress write FOnProgress;
+     constructor Create(Strm: TStream);
+   end;
+ 
+ { TCompressionStream compresses data on the fly as data is written to it, and
+   stores the compressed data to another stream.
+ 
+   TCompressionStream is write-only and strictly sequential. Reading from the
+   stream will raise an exception. Using Seek to move the stream pointer
+   will raise an exception.
+ 
+   Output data is cached internally, written to the output stream only when
+   the internal output buffer is full.  All pending output data is flushed
+   when the stream is destroyed.
+ 
+   The Position property returns the number of uncompressed bytes of
+   data that have been written to the stream so far.
+ 
+   CompressionRate returns the on-the-fly percentage by which the original
+   data has been compressed:  (1 - (CompressedBytes / UncompressedBytes)) * 100
+   If raw data size = 100 and compressed data size = 25, the CompressionRate
+   is 75%
+ 
+   The OnProgress event is called each time the output buffer is filled and
+   written to the output stream.  This is useful for updating a progress
+   indicator when you are writing a large chunk of data to the compression
+   stream in a single call.}
+ 
+ 
+   TCompressionLevel = (clNone, clFastest, clDefault, clMax);
+ 
+   TCompressionStream = class(TCustomZlibStream)
+   private
+     function GetCompressionRate: Single;
+   public
+     constructor Create(CompressionLevel: TCompressionLevel; Dest: TStream);
+     destructor Destroy; override;
+     function Read(var Buffer; Count: Longint): Longint; override;
+     function Write(const Buffer; Count: Longint): Longint; override;
+     function Seek(Offset: Longint; Origin: Word): Longint; override;
+     property CompressionRate: Single read GetCompressionRate;
+     property OnProgress;
+   end;
+ 
+ { TDecompressionStream decompresses data on the fly as data is read from it.
+ 
+   Compressed data comes from a separate source stream.  TDecompressionStream
+   is read-only and unidirectional; you can seek forward in the stream, but not
+   backwards.  The special case of setting the stream position to zero is
+   allowed.  Seeking forward decompresses data until the requested position in
+   the uncompressed data has been reached.  Seeking backwards, seeking relative
+   to the end of the stream, requesting the size of the stream, and writing to
+   the stream will raise an exception.
+ 
+   The Position property returns the number of bytes of uncompressed data that
+   have been read from the stream so far.
+ 
+   The OnProgress event is called each time the internal input buffer of
+   compressed data is exhausted and the next block is read from the input stream.
+   This is useful for updating a progress indicator when you are reading a
+   large chunk of data from the decompression stream in a single call.}
+ 
+   TDecompressionStream = class(TCustomZlibStream)
+   public
+     constructor Create(Source: TStream);
+     destructor Destroy; override;
+     function Read(var Buffer; Count: Longint): Longint; override;
+     function Write(const Buffer; Count: Longint): Longint; override;
+     function Seek(Offset: Longint; Origin: Word): Longint; override;
+     property OnProgress;
+   end;
+ 
+ 
+ 
+ { CompressBuf compresses data, buffer to buffer, in one call.
+    In: InBuf = ptr to compressed data
+        InBytes = number of bytes in InBuf
+   Out: OutBuf = ptr to newly allocated buffer containing decompressed data
+        OutBytes = number of bytes in OutBuf   }
+ procedure CompressBuf(const InBuf: Pointer; InBytes: Integer;
+                       out OutBuf: Pointer; out OutBytes: Integer);
+ 
+ 
+ { DecompressBuf decompresses data, buffer to buffer, in one call.
+    In: InBuf = ptr to compressed data
+        InBytes = number of bytes in InBuf
+        OutEstimate = zero, or est. size of the decompressed data
+   Out: OutBuf = ptr to newly allocated buffer containing decompressed data
+        OutBytes = number of bytes in OutBuf   }
+ procedure DecompressBuf(const InBuf: Pointer; InBytes: Integer;
+  OutEstimate: Integer; out OutBuf: Pointer; out OutBytes: Integer);
+ 
+ { DecompressToUserBuf decompresses data, buffer to buffer, in one call.
+    In: InBuf = ptr to compressed data
+        InBytes = number of bytes in InBuf
+   Out: OutBuf = ptr to user-allocated buffer to contain decompressed data
+        BufSize = number of bytes in OutBuf   }
+ procedure DecompressToUserBuf(const InBuf: Pointer; InBytes: Integer;
+   const OutBuf: Pointer; BufSize: Integer);
+ 
+ const
+   zlib_version = '1.2.1';
+ 
+ type
+   EZlibError = class(Exception);
+   ECompressionError = class(EZlibError);
+   EDecompressionError = class(EZlibError);
+ 
+ implementation
+ 
+ uses ZLibConst;
+ 
+ const
+   Z_NO_FLUSH      = 0;
+   Z_PARTIAL_FLUSH = 1;
+   Z_SYNC_FLUSH    = 2;
+   Z_FULL_FLUSH    = 3;
+   Z_FINISH        = 4;
+ 
+   Z_OK            = 0;
+   Z_STREAM_END    = 1;
+   Z_NEED_DICT     = 2;
+   Z_ERRNO         = (-1);
+   Z_STREAM_ERROR  = (-2);
+   Z_DATA_ERROR    = (-3);
+   Z_MEM_ERROR     = (-4);
+   Z_BUF_ERROR     = (-5);
+   Z_VERSION_ERROR = (-6);
+ 
+   Z_NO_COMPRESSION       =   0;
+   Z_BEST_SPEED           =   1;
+   Z_BEST_COMPRESSION     =   9;
+   Z_DEFAULT_COMPRESSION  = (-1);
+ 
+   Z_FILTERED            = 1;
+   Z_HUFFMAN_ONLY        = 2;
+   Z_RLE                 = 3;
+   Z_DEFAULT_STRATEGY    = 0;
+ 
+   Z_BINARY   = 0;
+   Z_ASCII    = 1;
+   Z_UNKNOWN  = 2;
+ 
+   Z_DEFLATED = 8;
+ 
+ 
+ {$L adler32.obj}
+ {$L compress.obj}
+ {$L crc32.obj}
+ {$L deflate.obj}
+ {$L infback.obj}
+ {$L inffast.obj}
+ {$L inflate.obj}
+ {$L inftrees.obj}
+ {$L trees.obj}
+ {$L uncompr.obj}
+ {$L zutil.obj}
+ 
+ procedure adler32; external;
+ procedure compressBound; external;
+ procedure crc32; external;
+ procedure deflateInit2_; external;
+ procedure deflateParams; external;
+ 
+ function _malloc(Size: Integer): Pointer; cdecl;
+ begin
+   Result := AllocMem(Size);
+ end;
+ 
+ procedure _free(Block: Pointer); cdecl;
+ begin
+   FreeMem(Block);
+ end;
+ 
+ procedure _memset(P: Pointer; B: Byte; count: Integer); cdecl;
+ begin
+   FillChar(P^, count, B);
+ end;
+ 
+ procedure _memcpy(dest, source: Pointer; count: Integer); cdecl;
+ begin
+   Move(source^, dest^, count);
+ end;
+ 
+ 
+ 
+ // deflate compresses data
+ function deflateInit_(var strm: TZStreamRec; level: Integer; version: PChar;
+   recsize: Integer): Integer; external;
+ function deflate(var strm: TZStreamRec; flush: Integer): Integer; external;
+ function deflateEnd(var strm: TZStreamRec): Integer; external;
+ 
+ // inflate decompresses data
+ function inflateInit_(var strm: TZStreamRec; version: PChar;
+   recsize: Integer): Integer; external;
+ function inflate(var strm: TZStreamRec; flush: Integer): Integer; external;
+ function inflateEnd(var strm: TZStreamRec): Integer; external;
+ function inflateReset(var strm: TZStreamRec): Integer; external;
+ 
+ 
+ function zlibAllocMem(AppData: Pointer; Items, Size: Integer): Pointer; cdecl;
+ begin
+ //  GetMem(Result, Items*Size);
+   Result := AllocMem(Items * Size);
+ end;
+ 
+ procedure zlibFreeMem(AppData, Block: Pointer); cdecl;
+ begin
+   FreeMem(Block);
+ end;
+ 
+ {function zlibCheck(code: Integer): Integer;
+ begin
+   Result := code;
+   if code < 0 then
+     raise EZlibError.Create('error');    //!!
+ end;}
+ 
+ function CCheck(code: Integer): Integer;
+ begin
+   Result := code;
+   if code < 0 then
+     raise ECompressionError.Create('error'); //!!
+ end;
+ 
+ function DCheck(code: Integer): Integer;
+ begin
+   Result := code;
+   if code < 0 then
+     raise EDecompressionError.Create('error');  //!!
+ end;
+ 
+ procedure CompressBuf(const InBuf: Pointer; InBytes: Integer;
+                       out OutBuf: Pointer; out OutBytes: Integer);
+ var
+   strm: TZStreamRec;
+   P: Pointer;
+ begin
+   FillChar(strm, sizeof(strm), 0);
+   strm.zalloc := zlibAllocMem;
+   strm.zfree := zlibFreeMem;
+   OutBytes := ((InBytes + (InBytes div 10) + 12) + 255) and not 255;
+   GetMem(OutBuf, OutBytes);
+   try
+     strm.next_in := InBuf;
+     strm.avail_in := InBytes;
+     strm.next_out := OutBuf;
+     strm.avail_out := OutBytes;
+     CCheck(deflateInit_(strm, Z_BEST_COMPRESSION, zlib_version, sizeof(strm)));
+     try
+       while CCheck(deflate(strm, Z_FINISH)) <> Z_STREAM_END do
+       begin
+         P := OutBuf;
+         Inc(OutBytes, 256);
+         ReallocMem(OutBuf, OutBytes);
+         strm.next_out := PChar(Integer(OutBuf) + (Integer(strm.next_out) - Integer(P)));
+         strm.avail_out := 256;
+       end;
+     finally
+       CCheck(deflateEnd(strm));
+     end;
+     ReallocMem(OutBuf, strm.total_out);
+     OutBytes := strm.total_out;
+   except
+     FreeMem(OutBuf);
+     raise
+   end;
+ end;
+ 
+ 
+ procedure DecompressBuf(const InBuf: Pointer; InBytes: Integer;
+   OutEstimate: Integer; out OutBuf: Pointer; out OutBytes: Integer);
+ var
+   strm: TZStreamRec;
+   P: Pointer;
+   BufInc: Integer;
+ begin
+   FillChar(strm, sizeof(strm), 0);
+   strm.zalloc := zlibAllocMem;
+   strm.zfree := zlibFreeMem;
+   BufInc := (InBytes + 255) and not 255;
+   if OutEstimate = 0 then
+     OutBytes := BufInc
+   else
+     OutBytes := OutEstimate;
+   GetMem(OutBuf, OutBytes);
+   try
+     strm.next_in := InBuf;
+     strm.avail_in := InBytes;
+     strm.next_out := OutBuf;
+     strm.avail_out := OutBytes;
+     DCheck(inflateInit_(strm, zlib_version, sizeof(strm)));
+     try
+       while DCheck(inflate(strm, Z_FINISH)) <> Z_STREAM_END do
+       begin
+         P := OutBuf;
+         Inc(OutBytes, BufInc);
+         ReallocMem(OutBuf, OutBytes);
+         strm.next_out := PChar(Integer(OutBuf) + (Integer(strm.next_out) - Integer(P)));
+         strm.avail_out := BufInc;
+       end;
+     finally
+       DCheck(inflateEnd(strm));
+     end;
+     ReallocMem(OutBuf, strm.total_out);
+     OutBytes := strm.total_out;
+   except
+     FreeMem(OutBuf);
+     raise
+   end;
+ end;
+ 
+ procedure DecompressToUserBuf(const InBuf: Pointer; InBytes: Integer;
+   const OutBuf: Pointer; BufSize: Integer);
+ var
+   strm: TZStreamRec;
+ begin
+   FillChar(strm, sizeof(strm), 0);
+   strm.zalloc := zlibAllocMem;
+   strm.zfree := zlibFreeMem;
+   strm.next_in := InBuf;
+   strm.avail_in := InBytes;
+   strm.next_out := OutBuf;
+   strm.avail_out := BufSize;
+   DCheck(inflateInit_(strm, zlib_version, sizeof(strm)));
+   try
+     if DCheck(inflate(strm, Z_FINISH)) <> Z_STREAM_END then
+       raise EZlibError.CreateRes(@sTargetBufferTooSmall);
+   finally
+     DCheck(inflateEnd(strm));
+   end;
+ end;
+ 
+ // TCustomZlibStream
+ 
+ constructor TCustomZLibStream.Create(Strm: TStream);
+ begin
+   inherited Create;
+   FStrm := Strm;
+   FStrmPos := Strm.Position;
+   FZRec.zalloc := zlibAllocMem;
+   FZRec.zfree := zlibFreeMem;
+ end;
+ 
+ procedure TCustomZLibStream.Progress(Sender: TObject);
+ begin
+   if Assigned(FOnProgress) then FOnProgress(Sender);
+ end;
+ 
+ 
+ // TCompressionStream
+ 
+ constructor TCompressionStream.Create(CompressionLevel: TCompressionLevel;
+   Dest: TStream);
+ const
+   Levels: array [TCompressionLevel] of ShortInt =
+     (Z_NO_COMPRESSION, Z_BEST_SPEED, Z_DEFAULT_COMPRESSION, Z_BEST_COMPRESSION);
+ begin
+   inherited Create(Dest);
+   FZRec.next_out := FBuffer;
+   FZRec.avail_out := sizeof(FBuffer);
+   CCheck(deflateInit_(FZRec, Levels[CompressionLevel], zlib_version, sizeof(FZRec)));
+ end;
+ 
+ destructor TCompressionStream.Destroy;
+ begin
+   FZRec.next_in := nil;
+   FZRec.avail_in := 0;
+   try
+     if FStrm.Position <> FStrmPos then FStrm.Position := FStrmPos;
+     while (CCheck(deflate(FZRec, Z_FINISH)) <> Z_STREAM_END)
+       and (FZRec.avail_out = 0) do
+     begin
+       FStrm.WriteBuffer(FBuffer, sizeof(FBuffer));
+       FZRec.next_out := FBuffer;
+       FZRec.avail_out := sizeof(FBuffer);
+     end;
+     if FZRec.avail_out < sizeof(FBuffer) then
+       FStrm.WriteBuffer(FBuffer, sizeof(FBuffer) - FZRec.avail_out);
+   finally
+     deflateEnd(FZRec);
+   end;
+   inherited Destroy;
+ end;
+ 
+ function TCompressionStream.Read(var Buffer; Count: Longint): Longint;
+ begin
+   raise ECompressionError.CreateRes(@sInvalidStreamOp);
+ end;
+ 
+ function TCompressionStream.Write(const Buffer; Count: Longint): Longint;
+ begin
+   FZRec.next_in := @Buffer;
+   FZRec.avail_in := Count;
+   if FStrm.Position <> FStrmPos then FStrm.Position := FStrmPos;
+   while (FZRec.avail_in > 0) do
+   begin
+     CCheck(deflate(FZRec, 0));
+     if FZRec.avail_out = 0 then
+     begin
+       FStrm.WriteBuffer(FBuffer, sizeof(FBuffer));
+       FZRec.next_out := FBuffer;
+       FZRec.avail_out := sizeof(FBuffer);
+       FStrmPos := FStrm.Position;
+       Progress(Self);
+     end;
+   end;
+   Result := Count;
+ end;
+ 
+ function TCompressionStream.Seek(Offset: Longint; Origin: Word): Longint;
+ begin
+   if (Offset = 0) and (Origin = soFromCurrent) then
+     Result := FZRec.total_in
+   else
+     raise ECompressionError.CreateRes(@sInvalidStreamOp);
+ end;
+ 
+ function TCompressionStream.GetCompressionRate: Single;
+ begin
+   if FZRec.total_in = 0 then
+     Result := 0
+   else
+     Result := (1.0 - (FZRec.total_out / FZRec.total_in)) * 100.0;
+ end;
+ 
+ 
+ // TDecompressionStream
+ 
+ constructor TDecompressionStream.Create(Source: TStream);
+ begin
+   inherited Create(Source);
+   FZRec.next_in := FBuffer;
+   FZRec.avail_in := 0;
+   DCheck(inflateInit_(FZRec, zlib_version, sizeof(FZRec)));
+ end;
+ 
+ destructor TDecompressionStream.Destroy;
+ begin
+   FStrm.Seek(-FZRec.avail_in, 1);
+   inflateEnd(FZRec);
+   inherited Destroy;
+ end;
+ 
+ function TDecompressionStream.Read(var Buffer; Count: Longint): Longint;
+ begin
+   FZRec.next_out := @Buffer;
+   FZRec.avail_out := Count;
+   if FStrm.Position <> FStrmPos then FStrm.Position := FStrmPos;
+   while (FZRec.avail_out > 0) do
+   begin
+     if FZRec.avail_in = 0 then
+     begin
+       FZRec.avail_in := FStrm.Read(FBuffer, sizeof(FBuffer));
+       if FZRec.avail_in = 0 then
+       begin
+         Result := Count - FZRec.avail_out;
+         Exit;
+       end;
+           FZRec.next_in := FBuffer;
+       FStrmPos := FStrm.Position;
+       Progress(Self);
+     end;
+     CCheck(inflate(FZRec, 0));
+   end;
+   Result := Count;
+ end;
+ 
+ function TDecompressionStream.Write(const Buffer; Count: Longint): Longint;
+ begin
+   raise EDecompressionError.CreateRes(@sInvalidStreamOp);
+ end;
+ 
+ function TDecompressionStream.Seek(Offset: Longint; Origin: Word): Longint;
+ var
+   I: Integer;
+   Buf: array [0..4095] of Char;
+ begin
+   if (Offset = 0) and (Origin = soFromBeginning) then
+   begin
+     DCheck(inflateReset(FZRec));
+     FZRec.next_in := FBuffer;
+     FZRec.avail_in := 0;
+     FStrm.Position := 0;
+     FStrmPos := 0;
+   end
+   else if ( (Offset >= 0) and (Origin = soFromCurrent)) or
+           ( ((Offset - FZRec.total_out) > 0) and (Origin = soFromBeginning)) then
+   begin
+     if Origin = soFromBeginning then Dec(Offset, FZRec.total_out);
+     if Offset > 0 then
+     begin
+       for I := 1 to Offset div sizeof(Buf) do
+         ReadBuffer(Buf, sizeof(Buf));
+       ReadBuffer(Buf, Offset mod sizeof(Buf));
+     end;
+   end
+   else
+     raise EDecompressionError.CreateRes(@sInvalidStreamOp);
+   Result := FZRec.total_out;
+ end;
+ 
+ 
+ end.


Index: llvm/runtime/zlib/contrib/delphi/ZLibConst.pas
diff -c /dev/null llvm/runtime/zlib/contrib/delphi/ZLibConst.pas:1.1.2.1
*** /dev/null	Mon Mar  1 17:58:58 2004
--- llvm/runtime/zlib/contrib/delphi/ZLibConst.pas	Mon Mar  1 17:58:48 2004
***************
*** 0 ****
--- 1,11 ----
+ unit ZLibConst;
+ 
+ interface
+ 
+ resourcestring
+   sTargetBufferTooSmall = 'ZLib error: target buffer may be too small';
+   sInvalidStreamOp = 'Invalid stream operation';
+ 
+ implementation
+ 
+ end.


Index: llvm/runtime/zlib/contrib/delphi/readme.txt
diff -c /dev/null llvm/runtime/zlib/contrib/delphi/readme.txt:1.1.2.1
*** /dev/null	Mon Mar  1 17:58:58 2004
--- llvm/runtime/zlib/contrib/delphi/readme.txt	Mon Mar  1 17:58:48 2004
***************
*** 0 ****
--- 1,76 ----
+ 
+ Overview
+ ========
+ 
+ This directory contains an update to the ZLib interface unit,
+ distributed by Borland as a Delphi supplemental component.
+ 
+ The original ZLib unit is Copyright (c) 1997,99 Borland Corp.,
+ and is based on zlib version 1.0.4.  There are a series of bugs
+ and security problems associated with that old zlib version, and
+ we recommend the users to update their ZLib unit.
+ 
+ 
+ Summary of modifications
+ ========================
+ 
+ - Improved makefile, adapted to zlib version 1.2.1.
+ 
+ - Some field types from TZStreamRec are changed from Integer to
+   Longint, for consistency with the zlib.h header, and for 64-bit
+   readiness.
+ 
+ - The zlib_version constant is updated.
+ 
+ - The new Z_RLE strategy has its corresponding symbolic constant.
+ 
+ - The allocation and deallocation functions and function types
+   (TAlloc, TFree, zlibAllocMem and zlibFreeMem) are now cdecl,
+   and _malloc and _free are added as C RTL stubs.  As a result,
+   the original C sources of zlib can be compiled out of the box,
+   and linked to the ZLib unit.
+ 
+ 
+ Suggestions for improvements
+ ============================
+ 
+ Currently, the ZLib unit provides only a limited wrapper around
+ the zlib library, and much of the original zlib functionality is
+ missing.  Handling compressed file formats like ZIP/GZIP or PNG
+ cannot be implemented without having this functionality.
+ Applications that handle these formats are either using their own,
+ duplicated code, or not using the ZLib unit at all.
+ 
+ Here are a few suggestions:
+ 
+ - Checksum class wrappers around adler32() and crc32(), similar
+   to the Java classes that implement the java.util.zip.Checksum
+   interface.
+ 
+ - The ability to read and write raw deflate streams, without the
+   zlib stream header and trailer.  Raw deflate streams are used
+   in the ZIP file format.
+ 
+ - The ability to read and write gzip streams, used in the GZIP
+   file format, and normally produced by the gzip program.
+ 
+ - The ability to select a different compression strategy, useful
+   to PNG and MNG image compression, and to multimedia compression
+   in general.  Besides the compression level
+ 
+     TCompressionLevel = (clNone, clFastest, clDefault, clMax);
+ 
+   which, in fact, could have used the 'z' prefix and avoided
+   TColor-like symbols
+ 
+     TCompressionLevel = (zcNone, zcFastest, zcDefault, zcMax);
+ 
+   there could be a compression strategy
+ 
+     TCompressionStrategy = (zsDefault, zsFiltered, zsHuffmanOnly, zsRle);
+ 
+ - ZIP and GZIP stream handling via TStreams.
+ 
+ 
+ --
+ Cosmin Truta <cosmint at cs.ubbcluj.ro>


Index: llvm/runtime/zlib/contrib/delphi/zlibd32.mak
diff -c /dev/null llvm/runtime/zlib/contrib/delphi/zlibd32.mak:1.1.2.1
*** /dev/null	Mon Mar  1 17:58:58 2004
--- llvm/runtime/zlib/contrib/delphi/zlibd32.mak	Mon Mar  1 17:58:48 2004
***************
*** 0 ****
--- 1,93 ----
+ # Makefile for zlib
+ # For use with Delphi and C++ Builder under Win32
+ # Updated for zlib 1.2.x by Cosmin Truta
+ 
+ # ------------ Borland C++ ------------
+ 
+ # This project uses the Delphi (fastcall/register) calling convention:
+ LOC = -DZEXPORT=__fastcall -DZEXPORTVA=__cdecl
+ 
+ CC = bcc32
+ LD = bcc32
+ AR = tlib
+ # do not use "-pr" in CFLAGS
+ CFLAGS = -a -d -k- -O2 $(LOC)
+ LDFLAGS =
+ 
+ 
+ # variables
+ ZLIB_LIB = zlib.lib
+ 
+ OBJ1 = adler32.obj compress.obj crc32.obj deflate.obj gzio.obj infback.obj
+ OBJ2 = inffast.obj inflate.obj inftrees.obj trees.obj uncompr.obj zutil.obj
+ OBJP1 = +adler32.obj+compress.obj+crc32.obj+deflate.obj+gzio.obj+infback.obj
+ OBJP2 = +inffast.obj+inflate.obj+inftrees.obj+trees.obj+uncompr.obj+zutil.obj
+ 
+ 
+ # targets
+ all: $(ZLIB_LIB) example.exe minigzip.exe
+ 
+ .c.obj:
+ 	$(CC) -c $(CFLAGS) $*.c
+ 
+ adler32.obj: adler32.c zlib.h zconf.h
+ 
+ compress.obj: compress.c zlib.h zconf.h
+ 
+ crc32.obj: crc32.c zlib.h zconf.h crc32.h
+ 
+ deflate.obj: deflate.c deflate.h zutil.h zlib.h zconf.h
+ 
+ gzio.obj: gzio.c zutil.h zlib.h zconf.h
+ 
+ infback.obj: infback.c zutil.h zlib.h zconf.h inftrees.h inflate.h \
+  inffast.h inffixed.h
+ 
+ inffast.obj: inffast.c zutil.h zlib.h zconf.h inftrees.h inflate.h \
+  inffast.h
+ 
+ inflate.obj: inflate.c zutil.h zlib.h zconf.h inftrees.h inflate.h \
+  inffast.h inffixed.h
+ 
+ inftrees.obj: inftrees.c zutil.h zlib.h zconf.h inftrees.h
+ 
+ trees.obj: trees.c zutil.h zlib.h zconf.h deflate.h trees.h
+ 
+ uncompr.obj: uncompr.c zlib.h zconf.h
+ 
+ zutil.obj: zutil.c zutil.h zlib.h zconf.h
+ 
+ example.obj: example.c zlib.h zconf.h
+ 
+ minigzip.obj: minigzip.c zlib.h zconf.h
+ 
+ 
+ # For the sake of the old Borland make,
+ # the command line is cut to fit in the MS-DOS 128 byte limit:
+ $(ZLIB_LIB): $(OBJ1) $(OBJ2)
+ 	-del $(ZLIB_LIB)
+ 	$(AR) $(ZLIB_LIB) $(OBJP1)
+ 	$(AR) $(ZLIB_LIB) $(OBJP2)
+ 
+ 
+ # testing
+ test: example.exe minigzip.exe
+ 	example
+ 	echo hello world | minigzip | minigzip -d
+ 
+ example.exe: example.obj $(ZLIB_LIB)
+ 	$(LD) $(LDFLAGS) example.obj $(ZLIB_LIB)
+ 
+ minigzip.exe: minigzip.obj $(ZLIB_LIB)
+ 	$(LD) $(LDFLAGS) minigzip.obj $(ZLIB_LIB)
+ 
+ 
+ # cleanup
+ clean:
+ 	-del *.obj
+ 	-del *.exe
+ 	-del *.lib
+ 	-del *.tds
+ 	-del zlib.bak
+ 	-del foo.gz
+ 





More information about the llvm-commits mailing list