author | koda |
Sat, 26 Jun 2010 04:36:28 +0200 | |
changeset 3556 | 4bdc59101ce5 |
parent 3526 | a1d2180fef42 |
child 3690 | c247dee9e1c0 |
permissions | -rw-r--r-- |
3526
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
1 |
unit Adler32; |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
2 |
|
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
3 |
{ZLib - Adler32 checksum function} |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
4 |
|
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
5 |
|
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
6 |
interface |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
7 |
|
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
8 |
(************************************************************************* |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
9 |
|
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
10 |
DESCRIPTION : ZLib - Adler32 checksum function |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
11 |
|
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
12 |
REQUIREMENTS : TP5-7, D1-D7/D9-D10/D12, FPC, VP |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
13 |
|
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
14 |
EXTERNAL DATA : --- |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
15 |
|
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
16 |
MEMORY USAGE : --- |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
17 |
|
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
18 |
DISPLAY MODE : --- |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
19 |
|
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
20 |
REFERENCES : RFC 1950 (http://tools.ietf.org/html/rfc1950) |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
21 |
|
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
22 |
|
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
23 |
Version Date Author Modification |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
24 |
------- -------- ------- ------------------------------------------ |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
25 |
0.10 30.08.03 W.Ehrhardt Initial version based on MD5 layout |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
26 |
2.10 30.08.03 we Common vers., XL versions for Win32 |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
27 |
2.20 27.09.03 we FPC/go32v2 |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
28 |
2.30 05.10.03 we STD.INC, TP5.0 |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
29 |
2.40 10.10.03 we common version, english comments |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
30 |
3.00 01.12.03 we Common version 3.0 |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
31 |
3.01 22.05.05 we Adler32UpdateXL (i,n: integer) |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
32 |
3.02 17.12.05 we Force $I- in Adler32File |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
33 |
3.03 07.08.06 we $ifdef BIT32: (const fname: shortstring...) |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
34 |
3.04 10.02.07 we Adler32File: no eof, XL and filemode via $ifdef |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
35 |
3.05 04.07.07 we BASM16: speed-up factor 15 |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
36 |
3.06 12.11.08 we uses BTypes, Ptr2Inc and/or Str255 |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
37 |
3.07 25.04.09 we updated RFC URL(s) |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
38 |
3.08 19.07.09 we D12 fix: assign with typecast string(fname) |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
39 |
**************************************************************************) |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
40 |
|
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
41 |
(*------------------------------------------------------------------------- |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
42 |
(C) Copyright 2002-2009 Wolfgang Ehrhardt |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
43 |
|
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
44 |
This software is provided 'as-is', without any express or implied warranty. |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
45 |
In no event will the authors be held liable for any damages arising from |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
46 |
the use of this software. |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
47 |
|
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
48 |
Permission is granted to anyone to use this software for any purpose, |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
49 |
including commercial applications, and to alter it and redistribute it |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
50 |
freely, subject to the following restrictions: |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
51 |
|
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
52 |
1. The origin of this software must not be misrepresented; you must not |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
53 |
claim that you wrote the original software. If you use this software in |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
54 |
a product, an acknowledgment in the product documentation would be |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
55 |
appreciated but is not required. |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
56 |
|
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
57 |
2. Altered source versions must be plainly marked as such, and must not be |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
58 |
misrepresented as being the original software. |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
59 |
|
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
60 |
3. This notice may not be removed or altered from any source distribution. |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
61 |
----------------------------------------------------------------------------*) |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
62 |
|
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
63 |
(* |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
64 |
As per the license above, noting that this implementation of adler32 was stripped of everything we didn't need. |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
65 |
That means no btypes, file loading, and the assembly version disabled. |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
66 |
*) |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
67 |
|
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
68 |
procedure Adler32Update(var adler: longint; Msg: pointer; Len: longint); |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
69 |
|
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
70 |
implementation |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
71 |
|
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
72 |
(* |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
73 |
$ifdef BASM16 |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
74 |
|
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
75 |
procedure Adler32Update(var adler: longint; Msg: pointer; Len: longint); |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
76 |
//-update Adler32 with Msg data |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
77 |
const |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
78 |
BASE = 65521; // max. prime < 65536 |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
79 |
NMAX = 5552; // max. n with 255n(n+1)/2 + (n+1)(BASE-1) < 2^32 |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
80 |
type |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
81 |
LH = packed record |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
82 |
L,H: word; |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
83 |
end; |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
84 |
var |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
85 |
s1,s2: longint; |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
86 |
n: integer; |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
87 |
begin |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
88 |
s1 := LH(adler).L; |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
89 |
s2 := LH(adler).H; |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
90 |
while Len > 0 do begin |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
91 |
if Len<NMAX then n := Len else n := NMAX; |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
92 |
//BASM increases speed from about 52 cyc/byte to about 3.7 cyc/byte |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
93 |
asm |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
94 |
mov cx,[n] |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
95 |
db $66; mov ax,word ptr [s1] |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
96 |
db $66; mov di,word ptr [s2] |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
97 |
les si,[msg] |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
98 |
@@1: db $66, $26, $0f, $b6, $1c // movzx ebx,es:[si] |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
99 |
inc si |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
100 |
db $66; add ax,bx // inc(s1, pByte(Msg)^) |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
101 |
db $66; add di,ax // inc(s2, s1 |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
102 |
dec cx |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
103 |
jnz @@1 |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
104 |
db $66; sub cx,cx |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
105 |
mov cx,BASE |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
106 |
db $66; sub dx,dx |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
107 |
db $66; div cx |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
108 |
db $66; mov word ptr [s1],dx // s1 := s1 mod BASE |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
109 |
db $66; sub dx,dx |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
110 |
db $66; mov ax,di |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
111 |
db $66; div cx |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
112 |
db $66; mov word ptr [s2],dx // s2 := s2 mod BASE |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
113 |
mov word ptr [msg],si // save offset for next chunk |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
114 |
end; |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
115 |
dec(len, n); |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
116 |
end; |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
117 |
LH(adler).L := word(s1); |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
118 |
LH(adler).H := word(s2); |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
119 |
end; |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
120 |
*) |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
121 |
|
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
122 |
procedure Adler32Update(var adler: longint; Msg: pointer; Len: longint); |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
123 |
{-update Adler32 with Msg data} |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
124 |
const |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
125 |
BASE = 65521; {max. prime < 65536 } |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
126 |
NMAX = 3854; {max. n with 255n(n+1)/2 + (n+1)(BASE-1) < 2^31} |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
127 |
type |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
128 |
LH = packed record |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
129 |
L,H: word; |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
130 |
end; |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
131 |
var |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
132 |
s1,s2: longint; |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
133 |
i,n: integer; |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
134 |
begin |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
135 |
s1 := LH(adler).L; |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
136 |
s2 := LH(adler).H; |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
137 |
while Len > 0 do begin |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
138 |
if Len<NMAX then n := Len else n := NMAX; |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
139 |
for i:=1 to n do begin |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
140 |
inc(s1, pByte(Msg)^); |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
141 |
inc(Msg); |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
142 |
inc(s2, s1); |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
143 |
end; |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
144 |
s1 := s1 mod BASE; |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
145 |
s2 := s2 mod BASE; |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
146 |
dec(len, n); |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
147 |
end; |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
148 |
LH(adler).L := word(s1); |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
149 |
LH(adler).H := word(s2); |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
150 |
end; |
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
151 |
|
a1d2180fef42
Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents:
diff
changeset
|
152 |
end. |