[llvm-commits] CVS: llvm/runtime/zlib/contrib/delphi/ZLib.pas ZLibConst.pas readme.txt zlibd32.mak
John Criswell
criswell at cs.uiuc.edu
Fri Feb 6 10:42:25 PST 2004
Changes in directory llvm/runtime/zlib/contrib/delphi:
ZLib.pas added (r1.1)
ZLibConst.pas added (r1.1)
readme.txt added (r1.1)
zlibd32.mak added (r1.1)
---
Log message:
Initial checking of the zlib library.
---
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
*** /dev/null Fri Feb 6 10:36:49 2004
--- llvm/runtime/zlib/contrib/delphi/ZLib.pas Fri Feb 6 10:36:39 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
*** /dev/null Fri Feb 6 10:36:49 2004
--- llvm/runtime/zlib/contrib/delphi/ZLibConst.pas Fri Feb 6 10:36:39 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
*** /dev/null Fri Feb 6 10:36:49 2004
--- llvm/runtime/zlib/contrib/delphi/readme.txt Fri Feb 6 10:36:39 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
*** /dev/null Fri Feb 6 10:36:50 2004
--- llvm/runtime/zlib/contrib/delphi/zlibd32.mak Fri Feb 6 10:36:39 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