Edit

kc3-lang/zlib/contrib/pascal/example.pas

Branch :

  • Browse

    Commit

  • Author : Mark Adler
    Date : 2011-09-09 23:22:37
    Hash : 4b5a43a2
    Message : zlib 1.2.0.5

  • contrib/pascal/example.pas
  • (* example.c -- usage example of the zlib compression library
     * Copyright (C) 1995-2003 Jean-loup Gailly.
     * For conditions of distribution and use, see copyright notice in zlib.h
     *
     * Pascal translation
     * Copyright (C) 1998 by Jacques Nomssi Nzali.
     * For conditions of distribution and use, see copyright notice in readme.txt
     *
     * Adaptation to the zlibpas interface
     * Copyright (C) 2003 by Cosmin Truta.
     * For conditions of distribution and use, see copyright notice in readme.txt
     *)
    
    program example;
    
    {$DEFINE TEST_COMPRESS}
    {DO NOT $DEFINE TEST_GZIO}
    {$DEFINE TEST_DEFLATE}
    {$DEFINE TEST_INFLATE}
    {$DEFINE TEST_FLUSH}
    {$DEFINE TEST_SYNC}
    {$DEFINE TEST_DICT}
    
    uses SysUtils, zlibpas;
    
    const TESTFILE = 'foo.gz';
    
    (* "hello world" would be more standard, but the repeated "hello"
     * stresses the compression code better, sorry...
     *)
    const hello: PChar = 'hello, hello!';
    
    const dictionary: PChar = 'hello';
    
    var dictId: LongInt; (* Adler32 value of the dictionary *)
    
    procedure CHECK_ERR(err: Integer; msg: String);
    begin
      if err <> Z_OK then
      begin
        WriteLn(msg, ' error: ', err);
        Halt(1);
      end;
    end;
    
    procedure EXIT_ERR(const msg: String);
    begin
      WriteLn('Error: ', msg);
      Halt(1);
    end;
    
    (* ===========================================================================
     * Test compress and uncompress
     *)
    {$IFDEF TEST_COMPRESS}
    procedure test_compress(compr: Pointer; comprLen: LongInt;
                            uncompr: Pointer; uncomprLen: LongInt);
    var err: Integer;
        len: LongInt;
    begin
      len := StrLen(hello)+1;
    
      err := compress(compr, comprLen, hello, len);
      CHECK_ERR(err, 'compress');
    
      StrCopy(PChar(uncompr), 'garbage');
    
      err := uncompress(uncompr, uncomprLen, compr, comprLen);
      CHECK_ERR(err, 'uncompress');
    
      if StrComp(PChar(uncompr), hello) <> 0 then
        EXIT_ERR('bad uncompress')
      else
        WriteLn('uncompress(): ', PChar(uncompr));
    end;
    {$ENDIF}
    
    (* ===========================================================================
     * Test read/write of .gz files
     *)
    {$IFDEF TEST_GZIO}
    procedure test_gzio(const fname: PChar; (* compressed file name *)
                        uncompr: Pointer;
                        uncomprLen: LongInt);
    var err: Integer;
        len: Integer;
        zfile: gzFile;
        pos: LongInt;
    begin
      len := StrLen(hello)+1;
    
      zfile := gzopen(fname, 'wb');
      if zfile = NIL then
      begin
        WriteLn('gzopen error');
        Halt(1);
      end;
      gzputc(zfile, 'h');
      if gzputs(zfile, 'ello') <> 4 then
      begin
        WriteLn('gzputs err: ', gzerror(zfile, err));
        Halt(1);
      end;
      {$IFDEF GZ_FORMAT_STRING}
      if gzprintf(zfile, ', %s!', 'hello') <> 8 then
      begin
        WriteLn('gzprintf err: ', gzerror(zfile, err));
        Halt(1);
      end;
      {$ELSE}
      if gzputs(zfile, ', hello!') <> 8 then
      begin
        WriteLn('gzputs err: ', gzerror(zfile, err));
        Halt(1);
      end;
      {$ENDIF}
      gzseek(zfile, 1, SEEK_CUR); (* add one zero byte *)
      gzclose(zfile);
    
      zfile := gzopen(fname, 'rb');
      if zfile = NIL then
      begin
        WriteLn('gzopen error');
        Halt(1);
      end;
    
      StrCopy(PChar(uncompr), 'garbage');
    
      if gzread(zfile, uncompr, uncomprLen) <> len then
      begin
        WriteLn('gzread err: ', gzerror(zfile, err));
        Halt(1);
      end;
      if StrComp(PChar(uncompr), hello) <> 0 then
      begin
        WriteLn('bad gzread: ', PChar(uncompr));
        Halt(1);
      end
      else
        WriteLn('gzread(): ', PChar(uncompr));
    
      pos := gzseek(zfile, -8, SEEK_CUR);
      if (pos <> 6) or (gztell(zfile) <> pos) then
      begin
        WriteLn('gzseek error, pos=', pos, ', gztell=', gztell(zfile));
        Halt(1);
      end;
    
      if gzgetc(zfile) <> ' ' then
      begin
        WriteLn('gzgetc error');
        Halt(1);
      end;
    
      if gzungetc(' ', zfile) <> ' ' then
      begin
        WriteLn('gzungetc error');
        Halt(1);
      end;
    
      gzgets(zfile, PChar(uncompr), uncomprLen);
      uncomprLen := StrLen(PChar(uncompr));
      if uncomprLen <> 7 then (* " hello!" *)
      begin
        WriteLn('gzgets err after gzseek: ', gzerror(zfile, err));
        Halt(1);
      end;
      if StrComp(PChar(uncompr), hello + 6) <> 0 then
      begin
        WriteLn('bad gzgets after gzseek');
        Halt(1);
      end
      else
        WriteLn('gzgets() after gzseek: ', PChar(uncompr));
    
      gzclose(zfile);
    end;
    {$ENDIF}
    
    (* ===========================================================================
     * Test deflate with small buffers
     *)
    {$IFDEF TEST_DEFLATE}
    procedure test_deflate(compr: Pointer; comprLen: LongInt);
    var c_stream: z_stream; (* compression stream *)
        err: Integer;
        len: LongInt;
    begin
      len := StrLen(hello)+1;
    
      c_stream.zalloc := NIL;
      c_stream.zfree := NIL;
      c_stream.opaque := NIL;
    
      err := deflateInit(c_stream, Z_DEFAULT_COMPRESSION);
      CHECK_ERR(err, 'deflateInit');
    
      c_stream.next_in := hello;
      c_stream.next_out := compr;
    
      while (c_stream.total_in <> len) and
            (c_stream.total_out < comprLen) do
      begin
        c_stream.avail_out := 1; { force small buffers }
        c_stream.avail_in := 1;
        err := deflate(c_stream, Z_NO_FLUSH);
        CHECK_ERR(err, 'deflate');
      end;
    
      (* Finish the stream, still forcing small buffers: *)
      while TRUE do
      begin
        c_stream.avail_out := 1;
        err := deflate(c_stream, Z_FINISH);
        if err = Z_STREAM_END then
          break;
        CHECK_ERR(err, 'deflate');
      end;
    
      err := deflateEnd(c_stream);
      CHECK_ERR(err, 'deflateEnd');
    end;
    {$ENDIF}
    
    (* ===========================================================================
     * Test inflate with small buffers
     *)
    {$IFDEF TEST_INFLATE}
    procedure test_inflate(compr: Pointer; comprLen : LongInt;
                           uncompr: Pointer; uncomprLen : LongInt);
    var err: Integer;
        d_stream: z_stream; (* decompression stream *)
    begin
      StrCopy(PChar(uncompr), 'garbage');
    
      d_stream.zalloc := NIL;
      d_stream.zfree := NIL;
      d_stream.opaque := NIL;
    
      d_stream.next_in := compr;
      d_stream.avail_in := 0;
      d_stream.next_out := uncompr;
    
      err := inflateInit(d_stream);
      CHECK_ERR(err, 'inflateInit');
    
      while (d_stream.total_out < uncomprLen) and
            (d_stream.total_in < comprLen) do
      begin
        d_stream.avail_out := 1; (* force small buffers *)
        d_stream.avail_in := 1;
        err := inflate(d_stream, Z_NO_FLUSH);
        if err = Z_STREAM_END then
          break;
        CHECK_ERR(err, 'inflate');
      end;
    
      err := inflateEnd(d_stream);
      CHECK_ERR(err, 'inflateEnd');
    
      if StrComp(PChar(uncompr), hello) <> 0 then
        EXIT_ERR('bad inflate')
      else
        WriteLn('inflate(): ', PChar(uncompr));
    end;
    {$ENDIF}
    
    (* ===========================================================================
     * Test deflate with large buffers and dynamic change of compression level
     *)
    {$IFDEF TEST_DEFLATE}
    procedure test_large_deflate(compr: Pointer; comprLen: LongInt;
                                 uncompr: Pointer; uncomprLen: LongInt);
    var c_stream: z_stream; (* compression stream *)
        err: Integer;
    begin
      c_stream.zalloc := NIL;
      c_stream.zfree := NIL;
      c_stream.opaque := NIL;
    
      err := deflateInit(c_stream, Z_BEST_SPEED);
      CHECK_ERR(err, 'deflateInit');
    
      c_stream.next_out := compr;
      c_stream.avail_out := Integer(comprLen);
    
      (* At this point, uncompr is still mostly zeroes, so it should compress
       * very well:
       *)
      c_stream.next_in := uncompr;
      c_stream.avail_in := Integer(uncomprLen);
      err := deflate(c_stream, Z_NO_FLUSH);
      CHECK_ERR(err, 'deflate');
      if c_stream.avail_in <> 0 then
        EXIT_ERR('deflate not greedy');
    
      (* Feed in already compressed data and switch to no compression: *)
      deflateParams(c_stream, Z_NO_COMPRESSION, Z_DEFAULT_STRATEGY);
      c_stream.next_in := compr;
      c_stream.avail_in := Integer(comprLen div 2);
      err := deflate(c_stream, Z_NO_FLUSH);
      CHECK_ERR(err, 'deflate');
    
      (* Switch back to compressing mode: *)
      deflateParams(c_stream, Z_BEST_COMPRESSION, Z_FILTERED);
      c_stream.next_in := uncompr;
      c_stream.avail_in := Integer(uncomprLen);
      err := deflate(c_stream, Z_NO_FLUSH);
      CHECK_ERR(err, 'deflate');
    
      err := deflate(c_stream, Z_FINISH);
      if err <> Z_STREAM_END then
        EXIT_ERR('deflate should report Z_STREAM_END');
    
      err := deflateEnd(c_stream);
      CHECK_ERR(err, 'deflateEnd');
    end;
    {$ENDIF}
    
    (* ===========================================================================
     * Test inflate with large buffers
     *)
    {$IFDEF TEST_INFLATE}
    procedure test_large_inflate(compr: Pointer; comprLen: LongInt;
                                 uncompr: Pointer; uncomprLen: LongInt);
    var err: Integer;
        d_stream: z_stream; (* decompression stream *)
    begin
      StrCopy(PChar(uncompr), 'garbage');
    
      d_stream.zalloc := NIL;
      d_stream.zfree := NIL;
      d_stream.opaque := NIL;
    
      d_stream.next_in := compr;
      d_stream.avail_in := Integer(comprLen);
    
      err := inflateInit(d_stream);
      CHECK_ERR(err, 'inflateInit');
    
      while TRUE do
      begin
        d_stream.next_out := uncompr;            (* discard the output *)
        d_stream.avail_out := Integer(uncomprLen);
        err := inflate(d_stream, Z_NO_FLUSH);
        if err = Z_STREAM_END then
          break;
        CHECK_ERR(err, 'large inflate');
      end;
    
      err := inflateEnd(d_stream);
      CHECK_ERR(err, 'inflateEnd');
    
      if d_stream.total_out <> 2 * uncomprLen + comprLen div 2 then
      begin
        WriteLn('bad large inflate: ', d_stream.total_out);
        Halt(1);
      end
      else
        WriteLn('large_inflate(): OK');
    end;
    {$ENDIF}
    
    (* ===========================================================================
     * Test deflate with full flush
     *)
    {$IFDEF TEST_FLUSH}
    procedure test_flush(compr: Pointer; var comprLen : LongInt);
    var c_stream: z_stream; (* compression stream *)
        err: Integer;
        len: Integer;
    begin
      len := StrLen(hello)+1;
    
      c_stream.zalloc := NIL;
      c_stream.zfree := NIL;
      c_stream.opaque := NIL;
    
      err := deflateInit(c_stream, Z_DEFAULT_COMPRESSION);
      CHECK_ERR(err, 'deflateInit');
    
      c_stream.next_in := hello;
      c_stream.next_out := compr;
      c_stream.avail_in := 3;
      c_stream.avail_out := Integer(comprLen);
      err := deflate(c_stream, Z_FULL_FLUSH);
      CHECK_ERR(err, 'deflate');
    
      Inc(PByteArray(compr)^[3]); (* force an error in first compressed block *)
      c_stream.avail_in := len - 3;
    
      err := deflate(c_stream, Z_FINISH);
      if err <> Z_STREAM_END then
        CHECK_ERR(err, 'deflate');
    
      err := deflateEnd(c_stream);
      CHECK_ERR(err, 'deflateEnd');
    
      comprLen := c_stream.total_out;
    end;
    {$ENDIF}
    
    (* ===========================================================================
     * Test inflateSync()
     *)
    {$IFDEF TEST_SYNC}
    procedure test_sync(compr: Pointer; comprLen: LongInt;
                        uncompr: Pointer; uncomprLen : LongInt);
    var err: Integer;
        d_stream: z_stream; (* decompression stream *)
    begin
      StrCopy(PChar(uncompr), 'garbage');
    
      d_stream.zalloc := NIL;
      d_stream.zfree := NIL;
      d_stream.opaque := NIL;
    
      d_stream.next_in := compr;
      d_stream.avail_in := 2; (* just read the zlib header *)
    
      err := inflateInit(d_stream);
      CHECK_ERR(err, 'inflateInit');
    
      d_stream.next_out := uncompr;
      d_stream.avail_out := Integer(uncomprLen);
    
      inflate(d_stream, Z_NO_FLUSH);
      CHECK_ERR(err, 'inflate');
    
      d_stream.avail_in := Integer(comprLen-2);   (* read all compressed data *)
      err := inflateSync(d_stream);               (* but skip the damaged part *)
      CHECK_ERR(err, 'inflateSync');
    
      err := inflate(d_stream, Z_FINISH);
      if err <> Z_DATA_ERROR then
        EXIT_ERR('inflate should report DATA_ERROR');
        (* Because of incorrect adler32 *)
    
      err := inflateEnd(d_stream);
      CHECK_ERR(err, 'inflateEnd');
    
      WriteLn('after inflateSync(): hel', PChar(uncompr));
    end;
    {$ENDIF}
    
    (* ===========================================================================
     * Test deflate with preset dictionary
     *)
    {$IFDEF TEST_DICT}
    procedure test_dict_deflate(compr: Pointer; comprLen: LongInt);
    var c_stream: z_stream; (* compression stream *)
        err: Integer;
    begin
      c_stream.zalloc := NIL;
      c_stream.zfree := NIL;
      c_stream.opaque := NIL;
    
      err := deflateInit(c_stream, Z_BEST_COMPRESSION);
      CHECK_ERR(err, 'deflateInit');
    
      err := deflateSetDictionary(c_stream, dictionary, StrLen(dictionary));
      CHECK_ERR(err, 'deflateSetDictionary');
    
      dictId := c_stream.adler;
      c_stream.next_out := compr;
      c_stream.avail_out := Integer(comprLen);
    
      c_stream.next_in := hello;
      c_stream.avail_in := StrLen(hello)+1;
    
      err := deflate(c_stream, Z_FINISH);
      if err <> Z_STREAM_END then
        EXIT_ERR('deflate should report Z_STREAM_END');
    
      err := deflateEnd(c_stream);
      CHECK_ERR(err, 'deflateEnd');
    end;
    {$ENDIF}
    
    (* ===========================================================================
     * Test inflate with a preset dictionary
     *)
    {$IFDEF TEST_DICT}
    procedure test_dict_inflate(compr: Pointer; comprLen: LongInt;
                                uncompr: Pointer; uncomprLen: LongInt);
    var err: Integer;
        d_stream: z_stream; (* decompression stream *)
    begin
      StrCopy(PChar(uncompr), 'garbage');
    
      d_stream.zalloc := NIL;
      d_stream.zfree := NIL;
      d_stream.opaque := NIL;
    
      d_stream.next_in := compr;
      d_stream.avail_in := Integer(comprLen);
    
      err := inflateInit(d_stream);
      CHECK_ERR(err, 'inflateInit');
    
      d_stream.next_out := uncompr;
      d_stream.avail_out := Integer(uncomprLen);
    
      while TRUE do
      begin
        err := inflate(d_stream, Z_NO_FLUSH);
        if err = Z_STREAM_END then
          break;
        if err = Z_NEED_DICT then
        begin
          if d_stream.adler <> dictId then
            EXIT_ERR('unexpected dictionary');
          err := inflateSetDictionary(d_stream, dictionary, StrLen(dictionary));
        end;
        CHECK_ERR(err, 'inflate with dict');
      end;
    
      err := inflateEnd(d_stream);
      CHECK_ERR(err, 'inflateEnd');
    
      if StrComp(PChar(uncompr), hello) <> 0 then
        EXIT_ERR('bad inflate with dict')
      else
        WriteLn('inflate with dictionary: ', PChar(uncompr));
    end;
    {$ENDIF}
    
    var compr, uncompr: Pointer;
        comprLen, uncomprLen: LongInt;
    
    begin
      if zlibVersion^ <> ZLIB_VERSION[1] then
        EXIT_ERR('Incompatible zlib version');
    
      WriteLn('zlib version: ', zlibVersion);
      WriteLn('zlib compile flags: ', Format('0x%x', [zlibCompileFlags]));
    
      comprLen := 10000 * SizeOf(Integer); (* don't overflow on MSDOS *)
      uncomprLen := comprLen;
      GetMem(compr, comprLen);
      GetMem(uncompr, uncomprLen);
      if (compr = NIL) or (uncompr = NIL) then
        EXIT_ERR('Out of memory');
      (* compr and uncompr are cleared to avoid reading uninitialized
       * data and to ensure that uncompr compresses well.
       *)
      FillChar(compr^, comprLen, 0);
      FillChar(uncompr^, uncomprLen, 0);
    
      {$IFDEF TEST_COMPRESS}
      WriteLn('** Testing compress');
      test_compress(compr, comprLen, uncompr, uncomprLen);
      {$ENDIF}
    
      {$IFDEF TEST_GZIO}
      WriteLn('** Testing gzio');
      if ParamCount >= 1 then
        test_gzio(ParamStr(1), uncompr, uncomprLen)
      else
        test_gzio(TESTFILE, uncompr, uncomprLen);
      {$ENDIF}
    
      {$IFDEF TEST_DEFLATE}
      WriteLn('** Testing deflate with small buffers');
      test_deflate(compr, comprLen);
      {$ENDIF}
      {$IFDEF TEST_INFLATE}
      WriteLn('** Testing inflate with small buffers');
      test_inflate(compr, comprLen, uncompr, uncomprLen);
      {$ENDIF}
    
      {$IFDEF TEST_DEFLATE}
      WriteLn('** Testing deflate with large buffers');
      test_large_deflate(compr, comprLen, uncompr, uncomprLen);
      {$ENDIF}
      {$IFDEF TEST_INFLATE}
      WriteLn('** Testing inflate with large buffers');
      test_large_inflate(compr, comprLen, uncompr, uncomprLen);
      {$ENDIF}
    
      {$IFDEF TEST_FLUSH}
      WriteLn('** Testing deflate with full flush');
      test_flush(compr, comprLen);
      {$ENDIF}
      {$IFDEF TEST_SYNC}
      WriteLn('** Testing inflateSync');
      test_sync(compr, comprLen, uncompr, uncomprLen);
      {$ENDIF}
      comprLen := uncomprLen;
    
      {$IFDEF TEST_DICT}
      WriteLn('** Testing deflate and inflate with preset dictionary');
      test_dict_deflate(compr, comprLen);
      test_dict_inflate(compr, comprLen, uncompr, uncomprLen);
      {$ENDIF}
    
      FreeMem(compr, comprLen);
      FreeMem(uncompr, uncomprLen);
    end.