← Back to branch summary

~ubuntu-branches/debian/lenny/fpc/lenny

« back to all changes in this revision

Viewing changes to packages/base/paszlib/gzcrc.pas

  • Committer: Bazaar Package Importer
  • Author(s): Mazen Neifer, Torsten Werner, Mazen Neifer
  • Date: 2008-05-17 17:12:11 UTC
  • mfrom: (3.1.9 intrepid)
  • Revision ID: james.westby@ubuntu.com-20080517171211-9qi33xhd9evfa0kg
Tags: 2.2.0-dfsg1-9
http://bugs.debian.org/477743
[ Torsten Werner ]
* Add Mazen Neifer to Uploaders field.

[ Mazen Neifer ]
* Moved FPC sources into a version dependent directory from /usr/share/fpcsrc
  to /usr/share/fpcsrc/${FPCVERSION}. This allow installing more than on FPC
  release.
* Fixed far call issue in compiler preventing building huge binearies.
  (closes: #477743)
* Updated building dependencies, recomennded and suggested packages.
* Moved fppkg to fp-utils as it is just a helper tool and is not required by
  compiler.

Show diffs side-by-side

added added

removed removed

Lines of Context:
packages/base/paszlib/gzcrc.pas
1
 
Unit gzCrc;
2
 
 
3
 
{
4
 
  crc32.c -- compute the CRC-32 of a data stream
5
 
  Copyright (C) 1995-1998 Mark Adler
6
 
 
7
 
  Pascal tranlastion
8
 
  Copyright (C) 1998 by Jacques Nomssi Nzali
9
 
  For conditions of distribution and use, see copyright notice in readme.txt
10
 
}
11
 
 
12
 
interface
13
 
 
14
 
{$I zconf.inc}
15
 
 
16
 
uses
17
 
  zutil, zbase;
18
 
 
19
 
 
20
 
function crc32(crc : uLong; buf : pBytef; len : uInt) : uLong;
21
 
 
22
 
{  Update a running crc with the bytes buf[0..len-1] and return the updated
23
 
   crc. If buf is NULL, this function returns the required initial value
24
 
   for the crc. Pre- and post-conditioning (one's complement) is performed
25
 
   within this function so it shouldn't be done by the application.
26
 
   Usage example:
27
 
 
28
 
    var
29
 
      crc : uLong;
30
 
    begin
31
 
      crc := crc32(0, Z_NULL, 0);
32
 
 
33
 
      while (read_buffer(buffer, length) <> EOF) do
34
 
        crc := crc32(crc, buffer, length);
35
 
 
36
 
      if (crc <> original_crc) then error();
37
 
    end;
38
 
 
39
 
}
40
 
 
41
 
function get_crc_table : pointer;  { can be used by asm versions of crc32() }
42
 
 
43
 
 
44
 
implementation
45
 
 
46
 
{$IFDEF DYNAMIC_CRC_TABLE}
47
 
 
48
 
{local}
49
 
const
50
 
  crc_table_empty : boolean = TRUE;
51
 
{local}
52
 
var
53
 
  crc_table : array[0..256-1] of uLongf;
54
 
 
55
 
 
56
 
{
57
 
  Generate a table for a byte-wise 32-bit CRC calculation on the polynomial:
58
 
  x^32+x^26+x^23+x^22+x^16+x^12+x^11+x^10+x^8+x^7+x^5+x^4+x^2+x+1.
59
 
 
60
 
  Polynomials over GF(2) are represented in binary, one bit per coefficient,
61
 
  with the lowest powers in the most significant bit.  Then adding polynomials
62
 
  is just exclusive-or, and multiplying a polynomial by x is a right shift by
63
 
  one.  If we call the above polynomial p, and represent a byte as the
64
 
  polynomial q, also with the lowest power in the most significant bit (so the
65
 
  byte 0xb1 is the polynomial x^7+x^3+x+1), then the CRC is (q*x^32) mod p,
66
 
  where a mod b means the remainder after dividing a by b.
67
 
 
68
 
  This calculation is done using the shift-register method of multiplying and
69
 
  taking the remainder.  The register is initialized to zero, and for each
70
 
  incoming bit, x^32 is added mod p to the register if the bit is a one (where
71
 
  x^32 mod p is p+x^32 = x^26+...+1), and the register is multiplied mod p by
72
 
  x (which is shifting right by one and adding x^32 mod p if the bit shifted
73
 
  out is a one).  We start with the highest power (least significant bit) of
74
 
  q and repeat for all eight bits of q.
75
 
 
76
 
  The table is simply the CRC of all possible eight bit values.  This is all
77
 
  the information needed to generate CRC's on data a byte at a time for all
78
 
  combinations of CRC register values and incoming bytes.
79
 
}
80
 
{local}
81
 
procedure make_crc_table;
82
 
var
83
 
 c    : uLong;
84
 
 n,k  : int;
85
 
 poly : uLong; { polynomial exclusive-or pattern }
86
 
 
87
 
const
88
 
 { terms of polynomial defining this crc (except x^32): }
89
 
 p: array [0..13] of Byte = (0,1,2,4,5,7,8,10,11,12,16,22,23,26);
90
 
 
91
 
begin
92
 
  { make exclusive-or pattern from polynomial ($EDB88320) }
93
 
  poly := Long(0);
94
 
  for n := 0 to (sizeof(p) div sizeof(Byte))-1 do
95
 
    poly := poly or (Long(1) shl (31 - p[n]));
96
 
 
97
 
  for n := 0 to 255 do
98
 
  begin
99
 
    c := uLong(n);
100
 
    for k := 0 to 7 do
101
 
    begin
102
 
      if (c and 1) <> 0 then
103
 
        c := poly xor (c shr 1)
104
 
      else
105
 
        c := (c shr 1);
106
 
    end;
107
 
    crc_table[n] := c;
108
 
  end;
109
 
  crc_table_empty := FALSE;
110
 
end;
111
 
 
112
 
{$ELSE}
113
 
 
114
 
{ ========================================================================
115
 
  Table of CRC-32's of all single-byte values (made by make_crc_table) }
116
 
 
117
 
{local}
118
 
const
119
 
  crc_table : array[0..256-1] of uLongf = (
120
 
  $00000000, $77073096, $ee0e612c, $990951ba, $076dc419,
121
 
  $706af48f, $e963a535, $9e6495a3, $0edb8832, $79dcb8a4,
122
 
  $e0d5e91e, $97d2d988, $09b64c2b, $7eb17cbd, $e7b82d07,
123
 
  $90bf1d91, $1db71064, $6ab020f2, $f3b97148, $84be41de,
124
 
  $1adad47d, $6ddde4eb, $f4d4b551, $83d385c7, $136c9856,
125
 
  $646ba8c0, $fd62f97a, $8a65c9ec, $14015c4f, $63066cd9,
126
 
  $fa0f3d63, $8d080df5, $3b6e20c8, $4c69105e, $d56041e4,
127
 
  $a2677172, $3c03e4d1, $4b04d447, $d20d85fd, $a50ab56b,
128
 
  $35b5a8fa, $42b2986c, $dbbbc9d6, $acbcf940, $32d86ce3,
129
 
  $45df5c75, $dcd60dcf, $abd13d59, $26d930ac, $51de003a,
130
 
  $c8d75180, $bfd06116, $21b4f4b5, $56b3c423, $cfba9599,
131
 
  $b8bda50f, $2802b89e, $5f058808, $c60cd9b2, $b10be924,
132
 
  $2f6f7c87, $58684c11, $c1611dab, $b6662d3d, $76dc4190,
133
 
  $01db7106, $98d220bc, $efd5102a, $71b18589, $06b6b51f,
134
 
  $9fbfe4a5, $e8b8d433, $7807c9a2, $0f00f934, $9609a88e,
135
 
  $e10e9818, $7f6a0dbb, $086d3d2d, $91646c97, $e6635c01,
136
 
  $6b6b51f4, $1c6c6162, $856530d8, $f262004e, $6c0695ed,
137
 
  $1b01a57b, $8208f4c1, $f50fc457, $65b0d9c6, $12b7e950,
138
 
  $8bbeb8ea, $fcb9887c, $62dd1ddf, $15da2d49, $8cd37cf3,
139
 
  $fbd44c65, $4db26158, $3ab551ce, $a3bc0074, $d4bb30e2,
140
 
  $4adfa541, $3dd895d7, $a4d1c46d, $d3d6f4fb, $4369e96a,
141
 
  $346ed9fc, $ad678846, $da60b8d0, $44042d73, $33031de5,
142
 
  $aa0a4c5f, $dd0d7cc9, $5005713c, $270241aa, $be0b1010,
143
 
  $c90c2086, $5768b525, $206f85b3, $b966d409, $ce61e49f,
144
 
  $5edef90e, $29d9c998, $b0d09822, $c7d7a8b4, $59b33d17,
145
 
  $2eb40d81, $b7bd5c3b, $c0ba6cad, $edb88320, $9abfb3b6,
146
 
  $03b6e20c, $74b1d29a, $ead54739, $9dd277af, $04db2615,
147
 
  $73dc1683, $e3630b12, $94643b84, $0d6d6a3e, $7a6a5aa8,
148
 
  $e40ecf0b, $9309ff9d, $0a00ae27, $7d079eb1, $f00f9344,
149
 
  $8708a3d2, $1e01f268, $6906c2fe, $f762575d, $806567cb,
150
 
  $196c3671, $6e6b06e7, $fed41b76, $89d32be0, $10da7a5a,
151
 
  $67dd4acc, $f9b9df6f, $8ebeeff9, $17b7be43, $60b08ed5,
152
 
  $d6d6a3e8, $a1d1937e, $38d8c2c4, $4fdff252, $d1bb67f1,
153
 
  $a6bc5767, $3fb506dd, $48b2364b, $d80d2bda, $af0a1b4c,
154
 
  $36034af6, $41047a60, $df60efc3, $a867df55, $316e8eef,
155
 
  $4669be79, $cb61b38c, $bc66831a, $256fd2a0, $5268e236,
156
 
  $cc0c7795, $bb0b4703, $220216b9, $5505262f, $c5ba3bbe,
157
 
  $b2bd0b28, $2bb45a92, $5cb36a04, $c2d7ffa7, $b5d0cf31,
158
 
  $2cd99e8b, $5bdeae1d, $9b64c2b0, $ec63f226, $756aa39c,
159
 
  $026d930a, $9c0906a9, $eb0e363f, $72076785, $05005713,
160
 
  $95bf4a82, $e2b87a14, $7bb12bae, $0cb61b38, $92d28e9b,
161
 
  $e5d5be0d, $7cdcefb7, $0bdbdf21, $86d3d2d4, $f1d4e242,
162
 
  $68ddb3f8, $1fda836e, $81be16cd, $f6b9265b, $6fb077e1,
163
 
  $18b74777, $88085ae6, $ff0f6a70, $66063bca, $11010b5c,
164
 
  $8f659eff, $f862ae69, $616bffd3, $166ccf45, $a00ae278,
165
 
  $d70dd2ee, $4e048354, $3903b3c2, $a7672661, $d06016f7,
166
 
  $4969474d, $3e6e77db, $aed16a4a, $d9d65adc, $40df0b66,
167
 
  $37d83bf0, $a9bcae53, $debb9ec5, $47b2cf7f, $30b5ffe9,
168
 
  $bdbdf21c, $cabac28a, $53b39330, $24b4a3a6, $bad03605,
169
 
  $cdd70693, $54de5729, $23d967bf, $b3667a2e, $c4614ab8,
170
 
  $5d681b02, $2a6f2b94, $b40bbe37, $c30c8ea1, $5a05df1b,
171
 
  $2d02ef8d);
172
 
 
173
 
{$ENDIF}
174
 
 
175
 
{ =========================================================================
176
 
  This function can be used by asm versions of crc32() }
177
 
 
178
 
function get_crc_table : {const} pointer;
179
 
begin
180
 
{$ifdef DYNAMIC_CRC_TABLE}
181
 
  if (crc_table_empty) then
182
 
    make_crc_table;
183
 
{$endif}
184
 
  get_crc_table :=  {const} pointer(@crc_table);
185
 
end;
186
 
 
187
 
{ ========================================================================= }
188
 
 
189
 
function crc32 (crc : uLong; buf : pBytef; len : uInt): uLong;
190
 
begin
191
 
  if (buf = Z_NULL) then
192
 
    crc32 := Long(0)
193
 
  else
194
 
  begin
195
 
 
196
 
{$IFDEF DYNAMIC_CRC_TABLE}
197
 
    if crc_table_empty then
198
 
      make_crc_table;
199
 
{$ENDIF}
200
 
 
201
 
    crc := crc xor ULong($ffffffff);
202
 
    while (len >= 8) do
203
 
    begin
204
 
      {DO8(buf)}
205
 
      crc := crc_table[(int(crc) xor buf^) and $ff] xor (crc shr 8);
206
 
      inc(buf);
207
 
      crc := crc_table[(int(crc) xor buf^) and $ff] xor (crc shr 8);
208
 
      inc(buf);
209
 
      crc := crc_table[(int(crc) xor buf^) and $ff] xor (crc shr 8);
210
 
      inc(buf);
211
 
      crc := crc_table[(int(crc) xor buf^) and $ff] xor (crc shr 8);
212
 
      inc(buf);
213
 
      crc := crc_table[(int(crc) xor buf^) and $ff] xor (crc shr 8);
214
 
      inc(buf);
215
 
      crc := crc_table[(int(crc) xor buf^) and $ff] xor (crc shr 8);
216
 
      inc(buf);
217
 
      crc := crc_table[(int(crc) xor buf^) and $ff] xor (crc shr 8);
218
 
      inc(buf);
219
 
      crc := crc_table[(int(crc) xor buf^) and $ff] xor (crc shr 8);
220
 
      inc(buf);
221
 
 
222
 
      Dec(len, 8);
223
 
    end;
224
 
    if (len <> 0) then
225
 
    repeat
226
 
      {DO1(buf)}
227
 
      crc := crc_table[(int(crc) xor buf^) and $ff] xor (crc shr 8);
228
 
      inc(buf);
229
 
 
230
 
      Dec(len);
231
 
    until (len = 0);
232
 
    crc32 := crc xor ULong($ffffffff);
233
 
  end;
234
 
end;
235
 
 
236
 
 
237
 
end.