CRC-32: Difference between revisions

From Rosetta Code
Content added Content deleted
(→‎{{header|Wren}}: Fixed a potential bug.)
m (→‎{{header|11l}}: `(-)` -> `~`)
 
(39 intermediate revisions by 24 users not shown)
Line 21: Line 21:
=={{header|11l}}==
=={{header|11l}}==
{{trans|C}}
{{trans|C}}
<lang 11l>V crc_table = [0] * 256
<syntaxhighlight lang=11l>V crc_table = [0] * 256
L(i) 256
L(i) 256
UInt32 rem = i
UInt32 rem = i
L 8
L 8
I rem [&] 1
I rem [&] 1 != 0
rem >>= 1
rem >>= 1
rem (+)= EDB8'8320
rem (+)= EDB8'8320
Line 33: Line 33:


F crc32(buf, =crc = UInt32(0))
F crc32(buf, =crc = UInt32(0))
crc = (-)crc
crc = ~crc
L(k) buf
L(k) buf
crc = (crc >> 8) (+) :crc_table[(crc [&] 00'FF) (+) k.code]
crc = (crc >> 8) (+) :crc_table[(crc [&] F'F) (+) k.code]
R (-)crc
R ~crc


print(hex(crc32(‘The quick brown fox jumps over the lazy dog’)))</lang>
print(hex(crc32(‘The quick brown fox jumps over the lazy dog’)))</syntaxhighlight>


{{out}}
{{out}}
Line 45: Line 45:
</pre>
</pre>


=={{header|6502 Assembly}}==
<syntaxhighlight lang=6502 Assembly>PRHEX EQU $FDDA ; <= REPLACE THIS WITH THE PRHEX ROUTINE FOR YOUR MACHINE

string EQU $EC
length EQU $EE
crc0 EQU $FA
crc1 EQU $FB
crc2 EQU $FC
crc3 EQU $FD
table0 EQU $9200
table1 EQU $9300
table2 EQU $9400
table3 EQU $9500
ORG $9114
LDA #<text
STA string
LDA #>text
STA string+1
LDA #$2b ; length of text
STA length
LDA #$00
STA length+1
STA crc0
STA crc1
STA crc2
STA crc3
JSR crc32
LDA crc3
JSR PRHEX
LDA crc2
JSR PRHEX
LDA crc1
JSR PRHEX
LDA crc0
JMP PRHEX
text
ASC 'The quick brown fox jumps over the lazy dog'
; ORG $916E
crc32
JSR start
LDY string
STX string
loop
LDA length
BNE no_borrow
LDA length+1
BEQ ones_complement
DEC length+1
no_borrow
DEC length
LDA (string),Y
EOR crc0
TAX
LDA table0,X
EOR crc1
STA crc0
LDA table1,X
EOR crc2
STA crc1
LDA table2,X
EOR crc3
STA crc2
LDA table3,X
STA crc3
INY
BNE loop
INC string+1
BNE loop
start
have_table
LDX #$00
BNE loop4 ; LDX #$04 BNE ones_complement
loop256
LDA #$00
STA table3,X
STA table2,X
STA table1,X
TXA
STA table0,X
LDY #$08
loop8
LSR table3,X
ROR table2,X
ROR table1,X
ROR table0,X
BCC no_xor
LDA table3,X
EOR #$ED
STA table3,X
LDA table2,X
EOR #$B8
STA table2,X
LDA table1,X
EOR #$83
STA table1,X
LDA table0,X
EOR #$20
STA table0,X
no_xor
DEY
BNE loop8
INX
BNE loop256
ones_complement
LDX #$04
STX have_table+1 ; self-modify
loop4
DEX
LDA crc0,X
EOR #$FF
STA crc0,X
TXA
BNE loop4
RTS</syntaxhighlight>
=={{header|Ada}}==
=={{header|Ada}}==
{{works with|GNAT}}
{{works with|GNAT}}
<lang Ada>with Ada.Text_IO; use Ada.Text_IO;
<syntaxhighlight lang=Ada>with Ada.Text_IO; use Ada.Text_IO;
with GNAT.CRC32; use GNAT.CRC32;
with GNAT.CRC32; use GNAT.CRC32;
with Interfaces; use Interfaces;
with Interfaces; use Interfaces;
Line 60: Line 174:
num := Get_Value (crc);
num := Get_Value (crc);
IIO.Put (num, Base => 16); New_Line;
IIO.Put (num, Base => 16); New_Line;
end TestCRC;</lang>
end TestCRC;</syntaxhighlight>
{{out}}
{{out}}
<pre>16#414FA339#</pre>
<pre>16#414FA339#</pre>

=={{header|Arturo}}==

<syntaxhighlight lang=rebol>print crc "The quick brown fox jumps over the lazy dog"</syntaxhighlight>

{{out}}

<pre>414FA339</pre>


=={{header|ALGOL 68}}==
=={{header|ALGOL 68}}==
<lang algol68>
<syntaxhighlight lang=algol68>
[0:255]BITS crc_table;
[0:255]BITS crc_table;
BOOL crc_table_computed := FALSE;
BOOL crc_table_computed := FALSE;
Line 120: Line 242:
STRING s = "The quick brown fox jumps over the lazy dog";
STRING s = "The quick brown fox jumps over the lazy dog";
print(("CRC32 OF ", s, " is: ", hex (crc (s)), newline))
print(("CRC32 OF ", s, " is: ", hex (crc (s)), newline))
</syntaxhighlight>
</lang>


{{out}}
{{out}}
<pre>CRC32 OF The quick brown fox jumps over the lazy dog is: 0414fa339</pre>
<pre>CRC32 OF The quick brown fox jumps over the lazy dog is: 0414fa339</pre>

=={{header|Applesoft BASIC}}==
===Implementation using Binary ASCII===
<syntaxhighlight lang=Applesoft BASIC> 0 DIM D$(1111):D$(0)="0":D$(1)="1":D$(10)="2":D$(11)="3":D$(100)="4":D$(101)="5":D$(110)="6":D$(111)="7":D$(1000)="8":D$(1001)="9":D$(1010)="A":D$(1011)="B":D$(1100)="C":D$(1101)="D":D$(1110)="E":D$(1111)="F"
1 Z$ = CHR$ (8) + CHR$ (8) + CHR$ (8) + CHR$ (8) + CHR$ (8) + CHR$ (8) + CHR$ (8) + CHR$ (8) + CHR$ (8) + CHR$ (8)
100 C$ = "00000000000000000000000000000000"
110 S$ = "The quick brown fox jumps over the lazy dog"
120 GOSUB 200"CRC32
130 PRINT D$( VAL ( MID$ (C$,1,4)))D$( VAL ( MID$ (C$,5,4)))D$( VAL ( MID$ (C$,9,4)))D$( VAL ( MID$ (C$,13,4)))D$( VAL ( MID$ (C$,17,4)))D$( VAL ( MID$ (C$,21,4)))D$( VAL ( MID$ (C$,25,4)))D$( VAL ( MID$ (C$,29,4)))" ";
140 END
200 IF LEN (S$) = 0 THEN RETURN
210 GOSUB 280"XOR #$FFFFFFFF
220 FOR I = 1 TO LEN (S$)
230 R$ = "00000000" + MID$ (C$,1,24)
235 PRINT D$( VAL ( MID$ (C$,1,4)))D$( VAL ( MID$ (C$,5,4)))D$( VAL ( MID$ (C$,9,4)))D$( VAL ( MID$ (C$,13,4)));
236 PRINT D$( VAL ( MID$ (C$,17,4)))D$( VAL ( MID$ (C$,21,4)))D$( VAL ( MID$ (C$,25,4)))D$( VAL ( MID$ (C$,29,4)))" " MID$ (S$,I,1)Z$;
240 C = ASC ( MID$ (S$,I,1)):O$ = "": FOR B = 1 TO 8:K = INT (C / 2):O$ = STR$ (C - K * 2) + O$:C = K: NEXT B
250 A = ( MID$ (C$,25,1) < > MID$ (O$,1,1)) * 128 + ( MID$ (C$,26,1) < > MID$ (O$,2,1)) * 64 + ( MID$ (C$,27,1) < > MID$ (O$,3,1)) * 32 + ( MID$ (C$,28,1) < > MID$ (O$,4,1)) * 16
251 A = ( MID$ (C$,29,1) < > MID$ (O$,5,1)) * 8 + ( MID$ (C$,30,1) < > MID$ (O$,6,1)) * 4 + ( MID$ (C$,31,1) < > MID$ (O$,7,1)) * 2 + ( MID$ (C$,32,1) < > MID$ (O$,8,1)) + A: GOSUB 300
260 C$ = STR$ (( MID$ (R$,1,1) < > MID$ (T$,1,1))) + STR$ (( MID$ (R$,2,1) < > MID$ (T$,2,1))) + STR$ (( MID$ (R$,3,1) < > MID$ (T$,3,1))) + STR$ (( MID$ (R$,4,1) < > MID$ (T$,4,1)))
261 C$ = C$ + STR$ (( MID$ (R$,5,1) < > MID$ (T$,5,1))) + STR$ (( MID$ (R$,6,1) < > MID$ (T$,6,1))) + STR$ (( MID$ (R$,7,1) < > MID$ (T$,7,1))) + STR$ (( MID$ (R$,8,1) < > MID$ (T$,8,1)))
262 C$ = C$ + STR$ (( MID$ (R$,9,1) < > MID$ (T$,9,1))) + STR$ (( MID$ (R$,10,1) < > MID$ (T$,10,1))) + STR$ (( MID$ (R$,11,1) < > MID$ (T$,11,1))) + STR$ (( MID$ (R$,12,1) < > MID$ (T$,12,1)))
263 C$ = C$ + STR$ (( MID$ (R$,13,1) < > MID$ (T$,13,1))) + STR$ (( MID$ (R$,14,1) < > MID$ (T$,14,1))) + STR$ (( MID$ (R$,15,1) < > MID$ (T$,15,1))) + STR$ (( MID$ (R$,16,1) < > MID$ (T$,16,1)))
264 C$ = C$ + STR$ (( MID$ (R$,17,1) < > MID$ (T$,17,1))) + STR$ (( MID$ (R$,18,1) < > MID$ (T$,18,1))) + STR$ (( MID$ (R$,19,1) < > MID$ (T$,19,1))) + STR$ (( MID$ (R$,20,1) < > MID$ (T$,20,1)))
265 C$ = C$ + STR$ (( MID$ (R$,21,1) < > MID$ (T$,21,1))) + STR$ (( MID$ (R$,22,1) < > MID$ (T$,22,1))) + STR$ (( MID$ (R$,23,1) < > MID$ (T$,23,1))) + STR$ (( MID$ (R$,24,1) < > MID$ (T$,24,1)))
266 C$ = C$ + STR$ (( MID$ (R$,25,1) < > MID$ (T$,25,1))) + STR$ (( MID$ (R$,26,1) < > MID$ (T$,26,1))) + STR$ (( MID$ (R$,27,1) < > MID$ (T$,27,1))) + STR$ (( MID$ (R$,28,1) < > MID$ (T$,28,1)))
267 C$ = C$ + STR$ (( MID$ (R$,29,1) < > MID$ (T$,29,1))) + STR$ (( MID$ (R$,30,1) < > MID$ (T$,30,1))) + STR$ (( MID$ (R$,31,1) < > MID$ (T$,31,1))) + STR$ (( MID$ (R$,32,1) < > MID$ (T$,32,1)))
270 NEXT I
280 B$ = "": FOR B = 1 TO 32:B$ = B$ + STR$ (( MID$ (C$,B,1) < > "1")): NEXT B:C$ = B$
290 RETURN
300 IF NOT T THEN DIM T$(255): FOR T = 0 TO 38: READ J: READ T$(J): NEXT T
310 IF LEN (T$(A)) THEN T$ = T$(A): RETURN
320 R = A:T$ = "": FOR B = 1 TO 8:N = INT (R / 2):T$ = MID$ ("01",R - N * 2 + 1,1) + T$:R = N: NEXT B:T$ = "000000000000000000000000" + T$
330 FOR J = 0 TO 7
340 X = VAL ( MID$ (T$,32,1))
350 T$ = "0" + MID$ (T$,1,31)
360 IF X THEN B$ = "": FOR B = 1 TO 32:B$ = B$ + MID$ ("01",( MID$ (T$,B,1) < > MID$ ("11101101101110001000001100100000",B,1)) + 1,1): NEXT B:T$ = B$
370 NEXT J
380 T$(A) = T$:T = T + 1
390 RETURN
600 DATA171,01000001000001000111101001100000
610 DATA247,00100011110110010110011110111111
620 DATA95,11111011110101000100110001100101
630 DATA217,11111111000011110110101001110000
640 DATA213,11110110101110010010011001011011
650 DATA179,01010010011010001110001000110110
660 DATA141,10010011000010011111111110011101
670 DATA90,10001011101111101011100011101010
680 DATA224,10100000000010101110001001111000
690 DATA187,01011100101100110110101000000100
700 DATA169,10101111000010100001101101001100
710 DATA60,00101111011011110111110010000111
720 DATA128,11101101101110001000001100100000
730 DATA36,00111100000000111110010011010001
740 DATA235,00110111110110000011101111110000
750 DATA229,11010000011000000001011011110111
760 DATA77,00001000011011010011110100101101
770 DATA167,01001000101100100011011001001011
780 DATA1,01110111000001110011000010010110
790 DATA119,11001110011000011110010010011111
800 DATA96,01001101101100100110000101011000
810 DATA158,00010111101101111011111001000011
820 DATA68,01110001101100011000010110001001
830 DATA56,00101000000000101011100010011110
840 DATA193,11101100011000111111001000100110
850 DATA87,11110101000011111100010001010111
860 DATA160,11010110110101101010001111101000
870 DATA2,11101110000011100110000100101100
880 DATA30,11111010000011110011110101100011
890 DATA7,10011110011001001001010110100011
900 DATA26,11111101011000101111100101111010
910 DATA85,00011011000000011010010101111011
920 DATA15,10010000101111110001110110010001
930 DATA201,11100010101110000111101000010100
940 DATA188,11000010110101111111111110100111
950 DATA0,00000000000000000000000000000000
960 DATA238,01000111101100101100111101111111
970 DATA181,10111011000010110100011100000011
980 DATA114,10111110000010110001000000010000</syntaxhighlight>

===Using 6502 Assembly===
<syntaxhighlight lang=Applesoft BASIC> 0 HIMEM: 37230
8A=37229:P$=" 'Q$L.L%BP#%GKSFGFB1LEZ*=!4E[-Z=!6EW-[=!TEX-W=!U-XHPR?MPN<!PJ)!7!U7!T7!607!49&^!U+!T+!6+!43 =!UIM7!U=!TI87!T=!6IC7!6=!4I 7!4/POAP;<D2(Q>5ZIYUZ0PV@"
9FORI=1TOLEN(P$):B$=MID$("D2A0--A6Q4Q5A8Q7Q8Q9R0M6--N3N4N6N8R7O2O4O6S1O7P7S4Q0--S7Q2S9U2X0J6X2X8N1A4G9T8X9U0H3H4Y0X6X7U6U7U8O5V0L5O8O9Y6Z2Z3Z5Z0Z1----J4",(ASC(MID$(P$,I))-32)*2+1,2):POKEA+I,(ASC(MID$(B$,1))-65)*10+ASC(MID$(B$,2))-48:NEXT
100 S$ = "THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG"
110 FOR I = 2 TO LEN (S$)
120 C = ASC ( MID$ (S$,I,1))
130 C$ = CHR$ (C + 32 * (C > = ASC ("A") AND C < = ASC ("Z")))
140 S$ = LEFT$ (S$,I - 1) + C$ + MID$ (S$,I + 1, LEN (S$) - I)
150 NEXT
155 PRINT MID$ (S$,1,0 * FRE (0));
160 POKE 236, PEEK (131)
170 POKE 237, PEEK (132)
180 A = PEEK (236) + PEEK (237) * 256
190 POKE 236, PEEK (A + 1)
200 POKE 237, PEEK (A + 2)
210 POKE 238, PEEK (A)
220 POKE 239,0
230 FOR I = 250 TO 253
240 POKE I,0
250 NEXT
260 CALL 37230
270 FOR I = 253 TO 250 STEP - 1
280 B = PEEK (I)
290 FOR J = 0 TO 1
300 PRINT MID$ ("0123456789ABCDEF",B / 16 + 1,1);
310 B = (B - INT (B / 16) * 16) * 16
320 NEXT J,I</syntaxhighlight>


=={{header|AutoHotkey}}==
=={{header|AutoHotkey}}==
===DllCall / WinAPI===
===DllCall / WinAPI===
<lang AutoHotkey>CRC32(str, enc = "UTF-8")
<syntaxhighlight lang=AutoHotkey>CRC32(str, enc = "UTF-8")
{
{
l := (enc = "CP1200" || enc = "UTF-16") ? 2 : 1, s := (StrPut(str, enc) - 1) * l
l := (enc = "CP1200" || enc = "UTF-16") ? 2 : 1, s := (StrPut(str, enc) - 1) * l
Line 135: Line 365:
}
}


MsgBox % CRC32("The quick brown fox jumps over the lazy dog")</lang>
MsgBox % CRC32("The quick brown fox jumps over the lazy dog")</syntaxhighlight>
{{out}}
{{out}}
<pre>0x414fa339</pre>
<pre>0x414fa339</pre>


===Implementation===
===Implementation===
<lang AutoHotkey>CRC32(str)
<syntaxhighlight lang=AutoHotkey>CRC32(str)
{
{
static table := []
static table := []
Line 155: Line 385:
}
}


MsgBox % CRC32("The quick brown fox jumps over the lazy dog")</lang>
MsgBox % CRC32("The quick brown fox jumps over the lazy dog")</syntaxhighlight>
{{out}}
{{out}}
<pre>0x414fa339</pre>
<pre>0x414fa339</pre>

=={{header|Bait}}==
<syntaxhighlight lang="bait">
import hash.crc32

fun main() {
text := 'The quick brown fox jumps over the lazy dog'
sum := crc32.checksum(text.bytes())
println(sum.hex())
}
</syntaxhighlight>

{{out}}
<pre>
414fa339
</pre>


=={{header|C}}==
=={{header|C}}==
===Library===
===Library===
Using [http://www.stillhq.com/gpg/source-modified-1.0.3/zlib/crc32.html zlib's crc32]:
Using [http://www.stillhq.com/gpg/source-modified-1.0.3/zlib/crc32.html zlib's crc32]:
<lang c>#include <stdio.h>
<syntaxhighlight lang=c>#include <stdio.h>
#include <string.h>
#include <string.h>
#include <zlib.h>
#include <zlib.h>
Line 172: Line 418:


return 0;
return 0;
}</lang>
}</syntaxhighlight>


===Implementation===
===Implementation===
This code is a translation from [[{{FULLPAGENAME}}#Ruby|Ruby]], with an adjustment to use 32-bit integers. This code happens to resemble the examples from [http://tools.ietf.org/html/rfc1952#section-8 RFC 1952 section 8] and from [http://www.w3.org/TR/2003/REC-PNG-20031110/#D-CRCAppendix PNG annex D], because those examples use an identical table.
This code is a translation from [[{{FULLPAGENAME}}#Ruby|Ruby]], with an adjustment to use 32-bit integers. This code happens to resemble the examples from [http://tools.ietf.org/html/rfc1952#section-8 RFC 1952 section 8] and from [http://www.w3.org/TR/2003/REC-PNG-20031110/#D-CRCAppendix PNG annex D], because those examples use an identical table.


<lang c>#include <inttypes.h>
<syntaxhighlight lang=c>#include <inttypes.h>
#include <stdio.h>
#include <stdio.h>
#include <string.h>
#include <string.h>
Line 224: Line 470:
return 0;
return 0;
}</lang>
}</syntaxhighlight>


=={{header|C sharp|C#}}==
=={{header|C sharp|C#}}==
<lang Csharp>
<syntaxhighlight lang=Csharp>
/// <summary>
/// <summary>
/// Performs 32-bit reversed cyclic redundancy checks.
/// Performs 32-bit reversed cyclic redundancy checks.
Line 298: Line 544:
#endregion
#endregion
}
}
</syntaxhighlight>
</lang>


Test:
Test:
<lang Csharp>
<syntaxhighlight lang=Csharp>
var arrayOfBytes = Encoding.ASCII.GetBytes("The quick brown fox jumps over the lazy dog");
var arrayOfBytes = Encoding.ASCII.GetBytes("The quick brown fox jumps over the lazy dog");


var crc32 = new Crc32();
var crc32 = new Crc32();
Console.WriteLine(crc32.Get(arrayOfBytes).ToString("X"));
Console.WriteLine(crc32.Get(arrayOfBytes).ToString("X"));
</syntaxhighlight>
</lang>


{{out}}
{{out}}
Line 313: Line 559:
=={{header|C++}}==
=={{header|C++}}==


<lang cpp>#include <algorithm>
<syntaxhighlight lang=cpp>#include <array>
#include <array>
#include <ranges>
#include <cstdint>
#include <cstdint>
#include <numeric>
#include <numeric>
#include <concepts>
#include <algorithm>


// These headers are only needed for main(), to demonstrate.
// These headers are only needed for main(), to demonstrate.
#include <iomanip>
#include <iomanip>
#include <iostream>
#include <iostream>
#include <string>
#include <string_view>


inline constexpr auto crc_table = []() {
// Generates a lookup table for the checksums of all 8-bit values.
std::array<std::uint_fast32_t, 256> generate_crc_lookup_table() noexcept
std::array<std::uint32_t, 256> retval{};
std::generate(retval.begin(), retval.end(),
{
[n = std::uint32_t{ 0 }]() mutable {
auto const reversed_polynomial = std::uint_fast32_t{0xEDB88320uL};
auto c = n++;
for (std::uint8_t k = 0; k < 8; ++k) {
// This is a function object that calculates the checksum for a value,
if (c & 1) c = std::uint32_t{ 0xedb88320 } ^ (c >> 1);
// then increments the value, starting from zero.
else c >>= 1;
struct byte_checksum
}
{
return c;
std::uint_fast32_t operator()() noexcept
{
});
return retval;
auto checksum = static_cast<std::uint_fast32_t>(n++);
}();
for (auto i = 0; i < 8; ++i)
checksum = (checksum >> 1) ^ ((checksum & 0x1u) ? reversed_polynomial : 0);
return checksum;
}
unsigned n = 0;
};
auto table = std::array<std::uint_fast32_t, 256>{};
std::generate(table.begin(), table.end(), byte_checksum{});
return table;
}



// Calculates the CRC for any sequence of values. (You could use type traits and a
[[nodiscard]] constexpr std::uint32_t crc(const std::ranges::input_range auto& rng)
// static assert to ensure the values can be converted to 8 bits.)
noexcept requires std::convertible_to<std::ranges::range_value_t<decltype(rng)>, std::uint8_t> {
template <typename InputIterator>
return ~std::accumulate(std::ranges::begin(rng), std::ranges::end(rng),
std::uint_fast32_t crc(InputIterator first, InputIterator last)
~std::uint32_t{ 0 } & std::uint32_t{ 0xff'ff'ff'ffu },
{
[](std::uint32_t checksum, std::uint8_t value)
// Generate lookup table only on first use then cache it - this is thread-safe.
{ return crc_table[(checksum ^ value) & 0xff] ^ (checksum >> 8); });
static auto const table = generate_crc_lookup_table();
// Calculate the checksum - make sure to clip to 32 bits, for systems that don't
// have a true (fast) 32-bit type.
return std::uint_fast32_t{0xFFFFFFFFuL} &
~std::accumulate(first, last,
~std::uint_fast32_t{0} & std::uint_fast32_t{0xFFFFFFFFuL},
[](std::uint_fast32_t checksum, std::uint_fast8_t value)
{ return table[(checksum ^ value) & 0xFFu] ^ (checksum >> 8); });
}
}


int main()
int main() {
constexpr std::string_view str = "The quick brown fox jumps over the lazy dog";
{
auto const s = std::string{"The quick brown fox jumps over the lazy dog"};
std::cout << std::hex << std::setw(8) << std::setfill('0') << crc(s.begin(), s.end()) << '\n';
std::cout << std::hex << std::setw(8) << std::setfill('0') << crc(str) << '\n';
}</syntaxhighlight>
}
</lang>
{{out}}
{{out}}
<pre>
<pre>
Line 390: Line 614:
</pre>
</pre>
{{libheader|boost}}
{{libheader|boost}}
<lang cpp>#include <boost\crc.hpp>
<syntaxhighlight lang=cpp>#include <boost\crc.hpp>
#include <string>
#include <string>
#include <iostream>
#include <iostream>
Line 402: Line 626:
std::cout << "Checksum: " << std::hex << crc.checksum() << std::endl;
std::cout << "Checksum: " << std::hex << crc.checksum() << std::endl;
return 0;
return 0;
}</lang>
}</syntaxhighlight>
{{out}}
{{out}}
<pre>
<pre>
Line 410: Line 634:
=={{header|Clojure}}==
=={{header|Clojure}}==
{{trans|Java}}
{{trans|Java}}
<lang clojure>(let [crc (new java.util.zip.CRC32)
<syntaxhighlight lang=clojure>(let [crc (new java.util.zip.CRC32)
str "The quick brown fox jumps over the lazy dog"]
str "The quick brown fox jumps over the lazy dog"]
(. crc update (. str getBytes))
(. crc update (. str getBytes))
(printf "CRC-32('%s') = %s\n" str (Long/toHexString (. crc getValue))))</lang>
(printf "CRC-32('%s') = %s\n" str (Long/toHexString (. crc getValue))))</syntaxhighlight>


{{out}}
{{out}}
Line 421: Line 645:
=={{header|COBOL}}==
=={{header|COBOL}}==
{{works with|GnuCOBOL}} {{libheader|zlib}}
{{works with|GnuCOBOL}} {{libheader|zlib}}
<lang COBOL> *> tectonics: cobc -xj crc32-zlib.cob -lz
<syntaxhighlight lang=COBOL> *> tectonics: cobc -xj crc32-zlib.cob -lz
identification division.
identification division.
program-id. rosetta-crc32.
program-id. rosetta-crc32.
Line 457: Line 681:


goback.
goback.
end program rosetta-crc32.</lang>
end program rosetta-crc32.</syntaxhighlight>
{{out}}
{{out}}
<pre>prompt$ cobc -xj crc32-zlib.cob -lz
<pre>prompt$ cobc -xj crc32-zlib.cob -lz
Line 466: Line 690:
=={{header|CoffeeScript}}==
=={{header|CoffeeScript}}==
Allows the specification of the initial CRC value, which defaults to 0xFFFFFFFF. Optimized for speed and terseness (then readability/indentation).
Allows the specification of the initial CRC value, which defaults to 0xFFFFFFFF. Optimized for speed and terseness (then readability/indentation).
<lang coffeescript>
<syntaxhighlight lang=coffeescript>
crc32 = do ->
crc32 = do ->
table =
table =
Line 480: Line 704:
crc = crc >>> 8 ^ table[(crc ^ c.charCodeAt 0) & 255]
crc = crc >>> 8 ^ table[(crc ^ c.charCodeAt 0) & 255]
(crc ^ -1) >>> 0
(crc ^ -1) >>> 0
</syntaxhighlight>
</lang>
Test:
Test:
<lang coffeescript>console.log (crc32 'The quick brown fox jumps over the lazy dog').toString 16</lang>
<syntaxhighlight lang=coffeescript>console.log (crc32 'The quick brown fox jumps over the lazy dog').toString 16</syntaxhighlight>
Output:
Output:
<lang>414fa339</lang>
<syntaxhighlight lang=text>414fa339</syntaxhighlight>


=={{header|Common Lisp}}==
=={{header|Common Lisp}}==
{{libheader|Ironclad}}
{{libheader|Ironclad}}
<lang lisp>(ql:quickload :ironclad)
<syntaxhighlight lang=lisp>(ql:quickload :ironclad)
(defun string-to-digest (str digest)
(defun string-to-digest (str digest)
"Return the specified digest for the ASCII string as a hex string."
"Return the specified digest for the ASCII string as a hex string."
Line 496: Line 720:


(string-to-digest "The quick brown fox jumps over the lazy dog" :crc32)
(string-to-digest "The quick brown fox jumps over the lazy dog" :crc32)
</syntaxhighlight>
</lang>
{{out}}
{{out}}
<pre>"414fa339"</pre>
<pre>"414fa339"</pre>
Line 503: Line 727:
BlackBox Component Builder<br/>
BlackBox Component Builder<br/>
Require ZLib Subsystem
Require ZLib Subsystem
<lang oberon2>
<syntaxhighlight lang=oberon2>
MODULE BbtComputeCRC32;
MODULE BbtComputeCRC32;
IMPORT ZlibCrc32,StdLog;
IMPORT ZlibCrc32,StdLog;
Line 516: Line 740:
END Do;
END Do;
END BbtComputeCRC32.
END BbtComputeCRC32.
</syntaxhighlight>
</lang>
Execute: ^Q BbtComputeCRC32.Do<br/>
Execute: ^Q BbtComputeCRC32.Do<br/>
{{out}}
{{out}}
<pre>
<pre>
0414FA339%16
0414FA339%16
</pre>

=={{header|Crystal}}==
<syntaxhighlight lang=crystal>
require "digest/crc32";

p Digest::CRC32.checksum("The quick brown fox jumps over the lazy dog").to_s(16)
</syntaxhighlight>
{{out}}
<pre>
"414fa339"
</pre>
</pre>


=={{header|D}}==
=={{header|D}}==
<lang d>void main() {
<syntaxhighlight lang=d>void main() {
import std.stdio, std.digest.crc;
import std.stdio, std.digest.crc;


"The quick brown fox jumps over the lazy dog"
"The quick brown fox jumps over the lazy dog"
.crc32Of.crcHexString.writeln;
.crc32Of.crcHexString.writeln;
}</lang>
}</syntaxhighlight>
{{out}}
{{out}}
<pre>414FA339</pre>
<pre>414FA339</pre>


=={{header|Delphi}}==
=={{header|Delphi}}==
<lang delphi>program CalcCRC32;
<syntaxhighlight lang=delphi>program CalcCRC32;


{$APPTYPE CONSOLE}
{$APPTYPE CONSOLE}
Line 548: Line 783:
CRC := crc32(0, @Data[1], Length(Data));
CRC := crc32(0, @Data[1], Length(Data));
WriteLn(Format('CRC32 = %8.8X', [CRC]));
WriteLn(Format('CRC32 = %8.8X', [CRC]));
end.</lang>
end.</syntaxhighlight>
{{out}}
{{out}}
<pre>CRC32 = 414FA339</pre>
<pre>CRC32 = 414FA339</pre>


=={{header|Elixir}}==
=={{header|Elixir}}==
<lang elixir>defmodule Test do
<syntaxhighlight lang=elixir>defmodule Test do
def crc32(str) do
def crc32(str) do
IO.puts :erlang.crc32(str) |> Integer.to_string(16)
IO.puts :erlang.crc32(str) |> Integer.to_string(16)
Line 559: Line 794:
end
end


Test.crc32("The quick brown fox jumps over the lazy dog")</lang>
Test.crc32("The quick brown fox jumps over the lazy dog")</syntaxhighlight>


{{out}}
{{out}}
Line 569: Line 804:
Using the built-in crc32 implementation.
Using the built-in crc32 implementation.


<lang erlang>
<syntaxhighlight lang=erlang>
-module(crc32).
-module(crc32).
-export([test/0]).
-export([test/0]).
test() ->
test() ->
io:fwrite("~.16#~n",[erlang:crc32(<<"The quick brown fox jumps over the lazy dog">>)]).
io:fwrite("~.16#~n",[erlang:crc32(<<"The quick brown fox jumps over the lazy dog">>)]).
</syntaxhighlight>
</lang>


{{out}}
{{out}}
<lang erlang>
<syntaxhighlight lang=erlang>
16#414FA339
16#414FA339
</syntaxhighlight>
</lang>


=={{header|F Sharp}}==
=={{header|F Sharp|F#}}==
<lang fsharp>
<syntaxhighlight lang=fsharp>
module Crc32 =
module Crc32 =
Line 622: Line 857:
let result = crc32OfAscii testString
let result = crc32OfAscii testString
printfn "CRC32: 0x%x" result
printfn "CRC32: 0x%x" result
</syntaxhighlight>
</lang>


{{out}}
{{out}}
<lang fsharp>
<syntaxhighlight lang=fsharp>
ASCII Input: The quick brown fox jumps over the lazy dog
ASCII Input: The quick brown fox jumps over the lazy dog
CRC32: 0x414fa339
CRC32: 0x414fa339
</syntaxhighlight>
</lang>


=={{header|Factor}}==
=={{header|Factor}}==
Line 641: Line 876:


=={{header|FBSL}}==
=={{header|FBSL}}==
<lang qbasic>#APPTYPE CONSOLE
<syntaxhighlight lang=qbasic>#APPTYPE CONSOLE


PRINT HEX(CHECKSUM("The quick brown fox jumps over the lazy dog"))
PRINT HEX(CHECKSUM("The quick brown fox jumps over the lazy dog"))


PAUSE</lang>
PAUSE</syntaxhighlight>
{{out}}
{{out}}
<pre>414FA339
<pre>414FA339
Line 654: Line 889:
This code can implement other types of CRC by using other polynomial constants: use $8408 for CCITT CRC-16, or $a001 for IBM CRC-16.
This code can implement other types of CRC by using other polynomial constants: use $8408 for CCITT CRC-16, or $a001 for IBM CRC-16.


<lang forth>
<syntaxhighlight lang=forth>
: crc/ ( n -- n ) 8 0 do dup 1 rshift swap 1 and if $edb88320 xor then loop ;
: crc/ ( n -- n ) 8 0 do dup 1 rshift swap 1 and if $edb88320 xor then loop ;


Line 666: Line 901:


$ffffffff s" The quick brown fox jumps over the lazy dog" crcbuf $ffffffff xor hex. bye \ $414FA339
$ffffffff s" The quick brown fox jumps over the lazy dog" crcbuf $ffffffff xor hex. bye \ $414FA339
</syntaxhighlight>
</lang>


=={{header|Fortran}}==
=={{header|Fortran}}==
<lang fortran>module crc32_m
<syntaxhighlight lang=fortran>module crc32_m
use iso_fortran_env
use iso_fortran_env
implicit none
implicit none
Line 713: Line 948:
call update_crc(s, crc)
call update_crc(s, crc)
print "(Z8)", crc
print "(Z8)", crc
end program</lang>
end program</syntaxhighlight>


=={{header|FreeBASIC}}==
=={{header|FreeBASIC}}==
{{trans|C}}
{{trans|C}}
<lang freebasic>' version 18-03-2017
<syntaxhighlight lang=freebasic>' version 18-03-2017
' compile with: fbc -s console
' compile with: fbc -s console


Line 766: Line 1,001:
Print : Print "hit any key to end program"
Print : Print "hit any key to end program"
Sleep
Sleep
End</lang>
End</syntaxhighlight>
{{out}}
{{out}}
<pre>input = The quick brown fox jumps over the lazy dog
<pre>input = The quick brown fox jumps over the lazy dog
Line 774: Line 1,009:
=={{header|Go}}==
=={{header|Go}}==
===Library===
===Library===
<lang go>package main
<syntaxhighlight lang=go>package main


import (
import (
Line 785: Line 1,020:
result := crc32.ChecksumIEEE(s)
result := crc32.ChecksumIEEE(s)
fmt.Printf("%X\n", result)
fmt.Printf("%X\n", result)
}</lang>
}</syntaxhighlight>
{{out}}
{{out}}
<pre>414FA339</pre>
<pre>414FA339</pre>


===Implementation===
===Implementation===
<lang go>package main
<syntaxhighlight lang=go>package main


import "fmt"
import "fmt"
Line 820: Line 1,055:
func main() {
func main() {
fmt.Printf("%0x\n", crc32("The quick brown fox jumps over the lazy dog"))
fmt.Printf("%0x\n", crc32("The quick brown fox jumps over the lazy dog"))
}</lang>
}</syntaxhighlight>
{{out}}
{{out}}
<pre>
<pre>
Line 827: Line 1,062:


=={{header|Groovy}}==
=={{header|Groovy}}==
<lang Groovy>def crc32(byte[] bytes) {
<syntaxhighlight lang=Groovy>def crc32(byte[] bytes) {
new java.util.zip.CRC32().with { update bytes; value }
new java.util.zip.CRC32().with { update bytes; value }
}</lang>
}</syntaxhighlight>
Testing:
Testing:
<lang Groovy>assert '414FA339' == sprintf('%04X', crc32('The quick brown fox jumps over the lazy dog'.bytes))</lang>
<syntaxhighlight lang=Groovy>assert '414FA339' == sprintf('%04X', crc32('The quick brown fox jumps over the lazy dog'.bytes))</syntaxhighlight>


=={{header|Haskell}}==
=={{header|Haskell}}==
Line 837: Line 1,072:
Pure Haskell:
Pure Haskell:


<lang haskell>import Data.Bits ((.&.), complement, shiftR, xor)
<syntaxhighlight lang=haskell>import Data.Bits ((.&.), complement, shiftR, xor)
import Data.Word (Word32)
import Data.Word (Word32)
import Numeric (showHex)
import Numeric (showHex)
Line 862: Line 1,097:


main :: IO ()
main :: IO ()
main = putStrLn $ crc32 "The quick brown fox jumps over the lazy dog"</lang>
main = putStrLn $ crc32 "The quick brown fox jumps over the lazy dog"</syntaxhighlight>
{{Out}}
{{Out}}
<pre>414fa339</pre>
<pre>414fa339</pre>
Line 869: Line 1,104:
Using the zlib C library ( compile with "ghc -lz file.hs"):
Using the zlib C library ( compile with "ghc -lz file.hs"):


<lang haskell>import Data.List (genericLength)
<syntaxhighlight lang=haskell>import Data.List (genericLength)
import Numeric (showHex)
import Numeric (showHex)
import Foreign.C
import Foreign.C
Line 881: Line 1,116:
ptr <- newCString s
ptr <- newCString s
let r = zlib_crc32 0 ptr (genericLength s)
let r = zlib_crc32 0 ptr (genericLength s)
putStrLn $ showHex r ""</lang>
putStrLn $ showHex r ""</syntaxhighlight>
{{Out}}
{{Out}}
<pre>414fa339</pre>
<pre>414fa339</pre>


=={{header|Haxe}}==
=={{header|Haxe}}==
<lang haxe>using StringTools;
<syntaxhighlight lang=haxe>using StringTools;


class Main {
class Main {
Line 894: Line 1,129:
Sys.println(crc.hex());
Sys.println(crc.hex());
}
}
}</lang>
}</syntaxhighlight>


{{out}}
{{out}}
Line 902: Line 1,137:
=={{header|Icon}} and {{header|Unicon}}==
=={{header|Icon}} and {{header|Unicon}}==
There is no library function for this so we implement one. Icon/Unicon binary operations apply to large integers so we need to mask to the desired unsigned word size. This also only applies to full bytes.
There is no library function for this so we implement one. Icon/Unicon binary operations apply to large integers so we need to mask to the desired unsigned word size. This also only applies to full bytes.
<lang Icon>link hexcvt,printf
<syntaxhighlight lang=Icon>link hexcvt,printf


procedure main()
procedure main()
Line 934: Line 1,169:
ixor(crcL[iand(255,ixor(crc,ord(!s)))+1],ishift(crc,-8)))
ixor(crcL[iand(255,ixor(crc,ord(!s)))+1],ishift(crc,-8)))
return hexstring(ixor(crc,mask)) # return hexstring
return hexstring(ixor(crc,mask)) # return hexstring
end</lang>
end</syntaxhighlight>


{{libheader|Icon Programming Library}}
{{libheader|Icon Programming Library}}
Line 944: Line 1,179:


=={{header|J}}==
=={{header|J}}==
<lang j> ((i.32) e. 32 26 23 22 16 12 11 10 8 7 5 4 2 1 0) 128!:3 'The quick brown fox jumps over the lazy dog'
<syntaxhighlight lang=j> ((i.32) e. 32 26 23 22 16 12 11 10 8 7 5 4 2 1 0) 128!:3 'The quick brown fox jumps over the lazy dog'
_3199229127</lang>
_3199229127</syntaxhighlight>


Other possible representations of this result:
Other possible representations of this result:


<lang j> (2^32x)|((i.32) e. 32 26 23 22 16 12 11 10 8 7 5 4 2 1 0) 128!:3 'The quick brown fox jumps over the lazy dog'
<syntaxhighlight lang=j> (2^32x)|((i.32) e. 32 26 23 22 16 12 11 10 8 7 5 4 2 1 0) 128!:3 'The quick brown fox jumps over the lazy dog'
1095738169
1095738169
require'convert'
require'convert'
hfd (2^32x)|((i.32) e. 32 26 23 22 16 12 11 10 8 7 5 4 2 1 0) 128!:3 'The quick brown fox jumps over the lazy dog'
hfd (2^32x)|((i.32) e. 32 26 23 22 16 12 11 10 8 7 5 4 2 1 0) 128!:3 'The quick brown fox jumps over the lazy dog'
414FA339</lang>
414FA339</syntaxhighlight>


=={{header|Java}}==
=={{header|Java}}==
<syntaxhighlight lang=Java>
<lang Java>import java.util.zip.* ;
import java.util.zip.CRC32;

</syntaxhighlight>
public class CRCMaker {
<syntaxhighlight lang=Java>
public static void main( String[ ] args ) {
public static void main(String[] args) throws IOException {
String toBeEncoded = new String( "The quick brown fox jumps over the lazy dog" ) ;
String string = "The quick brown fox jumps over the lazy dog";
CRC32 myCRC = new CRC32( ) ;
CRC32 crc = new CRC32();
myCRC.update( toBeEncoded.getBytes( ) ) ;
crc.update(string.getBytes());
System.out.println( "The CRC-32 value is : " + Long.toHexString( myCRC.getValue( ) ) + " !" ) ;
System.out.printf("%x", crc.getValue());
}
}
}</lang>
</syntaxhighlight>
{{out}}
{{out}}
<pre>
<pre>The CRC-32 value is : 414fa339 !</pre>
414fa339
</pre>


=={{header|JavaScript}}==
=={{header|JavaScript}}==
<lang JavaScript>(() => {
<syntaxhighlight lang=JavaScript>(() => {
'use strict';
'use strict';


// --------------------- CRC-32 ----------------------
const main = () =>
showHex(
crc32('The quick brown fox jumps over the lazy dog')
);


// crc32 :: String -> Int
// crc32 :: String -> Int
const crc32 = str => {
const crc32 = str => {

// table :: [Int]
// table :: [Int]
const table = map(
const table = enumFromTo(0)(255).map(
n => take(9,
n => take(9)(
iterate(
iterate(
x => (
x => (
x & 1 ? z => 0xEDB88320 ^ z : id
x & 1 ? (
)(x >>> 1),
z => 0xEDB88320 ^ z
n
) : identity
)
)(x >>> 1)
)[8],
)(n)
enumFromTo(0, 255)
)[8]
);
return (
foldl(
(a, c) => (a >>> 8) ^ table[
(a ^ c.charCodeAt(0)) & 255
],
-1,
chars(str)
) ^ -1
);
);
return chars(str).reduce(
(a, c) => (a >>> 8) ^ table[
(a ^ c.charCodeAt(0)) & 255
],
-1
) ^ -1;
};
};


// GENERIC ABSTRACTIONS -------------------------------
// ---------------------- TEST -----------------------
// main :: IO ()
const main = () =>
showHex(
crc32('The quick brown fox jumps over the lazy dog')
);

// --------------------- GENERIC ---------------------


// chars :: String -> [Char]
// chars :: String -> [Char]
const chars = s => s.split('');
const chars = s =>
s.split('');



// enumFromTo :: Int -> Int -> [Int]
// enumFromTo :: Int -> Int -> [Int]
const enumFromTo = (m, n) =>
const enumFromTo = m =>
Array.from({
n => !isNaN(m) ? (
length: 1 + n - m
Array.from({
}, (_, i) => m + i);
length: 1 + n - m
}, (_, i) => m + i)
) : enumFromTo_(m)(n);


// foldl :: (a -> b -> a) -> a -> [b] -> a
const foldl = (f, a, xs) => xs.reduce(f, a);


// id :: a -> a
// identity :: a -> a
const id = x => x;
const identity = x =>
// The identity function.
x;



// iterate :: (a -> a) -> a -> Gen [a]
// iterate :: (a -> a) -> a -> Gen [a]
function* iterate(f, x) {
const iterate = f =>
let v = x;
// An infinite list of repeated
while (true) {
// applications of f to x.
yield(v);
function* (x) {
v = f(v);
let v = x;
}
while (true) {
yield(v);
}
v = f(v);
}
};


// map :: (a -> b) -> [a] -> [b]
const map = (f, xs) => xs.map(f);


// showHex :: Int -> String
// showHex :: Int -> String
const showHex = n =>
const showHex = n =>
// Hexadecimal string for a given integer.
n.toString(16);
'0x' + n.toString(16);



// take :: Int -> [a] -> [a]
// take :: Int -> [a] -> [a]
// take :: Int -> String -> String
// take :: Int -> String -> String
const take = (n, xs) =>
const take = n =>
// The first n elements of a list,
xs.constructor.constructor.name !== 'GeneratorFunction' ? (
// string of characters, or stream.
xs => 'GeneratorFunction' !== xs
.constructor.constructor.name ? (
xs.slice(0, n)
xs.slice(0, n)
) : [].concat.apply([], Array.from({
) : [].concat.apply([], Array.from({
Line 1,056: Line 1,305:
result
result
);
);
})();</lang>
})();</syntaxhighlight>
{{Out}}
{{Out}}
<pre>414fa339</pre>
<pre>0x414fa339</pre>


=={{header|Jsish}}==
=={{header|Jsish}}==
From the shell
From the shell
<lang javascript># Util.crc32('The quick brown fox jumps over the lazy dog').toString(16);</lang>
<syntaxhighlight lang=javascript># Util.crc32('The quick brown fox jumps over the lazy dog').toString(16);</syntaxhighlight>
{{out}}
{{out}}
<pre>"414fa339"</pre>
<pre>"414fa339"</pre>
Line 1,068: Line 1,317:
=={{header|Julia}}==
=={{header|Julia}}==
===Using the zlib Library===
===Using the zlib Library===
<lang julia>using Libz
<syntaxhighlight lang=julia>using Libz
println(string(Libz.crc32(UInt8.(b"The quick brown fox jumps over the lazy dog")), base=16))
println(string(Libz.crc32(UInt8.(b"The quick brown fox jumps over the lazy dog")), base=16))
</lang>{{out}}
</syntaxhighlight>{{out}}
<pre>
<pre>
414fa339
414fa339
Line 1,077: Line 1,326:
===Source Implementation===
===Source Implementation===
{{works with|Julia|0.6}}
{{works with|Julia|0.6}}
<lang Julia>function crc32(crc::Int, str::String)
<syntaxhighlight lang=Julia>function crc32(crc::Int, str::String)
table = zeros(UInt32, 256)
table = zeros(UInt32, 256)


Line 1,107: Line 1,356:
assert(crc == 0x414fa339)
assert(crc == 0x414fa339)
println("Message: ", str)
println("Message: ", str)
println("Checksum: ", hex(crc))</lang>
println("Checksum: ", hex(crc))</syntaxhighlight>


{{out}}
{{out}}
Line 1,114: Line 1,363:


=={{header|Kotlin}}==
=={{header|Kotlin}}==
<lang scala>// version 1.0.6
<syntaxhighlight lang=scala>// version 1.0.6


import java.util.zip.CRC32
import java.util.zip.CRC32
Line 1,125: Line 1,374:
println("The CRC-32 checksum of '$text' = ${"%x".format(value)}")
println("The CRC-32 checksum of '$text' = ${"%x".format(value)}")
}
}
}</lang>
}</syntaxhighlight>


{{out}}
{{out}}
Line 1,136: Line 1,385:
===Pure Lingo===
===Pure Lingo===


<lang lingo>crcObj = script("CRC").new()
<syntaxhighlight lang=lingo>crcObj = script("CRC").new()


crc32 = crcObj.crc32("The quick brown fox jumps over the lazy dog")
crc32 = crcObj.crc32("The quick brown fox jumps over the lazy dog")
Line 1,144: Line 1,393:


put crc32.toHexString(1, crc32.length)
put crc32.toHexString(1, crc32.length)
-- "41 4f a3 39"</lang>
-- "41 4f a3 39"</syntaxhighlight>


Implementation:
Implementation:


<lang lingo>--****************************************************************************
<syntaxhighlight lang=lingo>--****************************************************************************
-- @desc CRC-32 Class
-- @desc CRC-32 Class
-- @file parent script "CRC"
-- @file parent script "CRC"
Line 1,214: Line 1,463:
ba.position = 1
ba.position = 1
return ba
return ba
end</lang>
end</syntaxhighlight>


===Using an "Xtra" (=binary plugin)===
===Using an "Xtra" (=binary plugin)===


<lang lingo>cx = Xtra("Crypto").new()
<syntaxhighlight lang=lingo>cx = Xtra("Crypto").new()
put cx.cx_crc32_string("The quick brown fox jumps over the lazy dog")
put cx.cx_crc32_string("The quick brown fox jumps over the lazy dog")
-- "414fa339"</lang>
-- "414fa339"</syntaxhighlight>


=={{header|Lua}}==
=={{header|Lua}}==
Line 1,226: Line 1,475:
[https://github.com/brimworks/lua-zlib <code>zlib.crc32</code>]
[https://github.com/brimworks/lua-zlib <code>zlib.crc32</code>]


<lang lua>local compute=require"zlib".crc32()
<syntaxhighlight lang=lua>local compute=require"zlib".crc32()
local sum=compute("The quick brown fox jumps over the lazy dog")
local sum=compute("The quick brown fox jumps over the lazy dog")
print(string.format("0x%x", sum))
print(string.format("0x%x", sum))
</syntaxhighlight>
</lang>


{{out}}
{{out}}
0x414fa339
0x414fa339
===Implementation===
<syntaxhighlight lang=lua>
function crc32(buf, size)
local crc = 0xFFFFFFFF
local table = {}
local rem, c

-- calculate CRC-table
for i = 0, 0xFF do
rem = i
for j = 1, 8 do
if (rem & 1 == 1) then
rem = rem >> 1
rem = rem ~ 0xEDB88320
else
rem = rem >> 1
end
end
table[i] = rem
end

for x = 1, size do
c = buf[x]
crc = (crc >> 8) ~ table[(crc & 0xFF) ~ c]
end
return crc ~ 0xFFFFFFFF
end


local str = "The quick brown fox jumps over the lazy dog"
local t = {}
for i = 1, #str do
t[i] = str:byte(i)
end

print(string.format("CRC32: %x", crc32(t,#str)))
</syntaxhighlight>
{{out}}
CRC32: 414fa339


=={{header|M2000 Interpreter}}==
=={{header|M2000 Interpreter}}==
===Using Code===
===Using Code===
<lang M2000 Interpreter>
<syntaxhighlight lang=M2000 Interpreter>
Module CheckIt {
Module CheckIt {
Function PrepareTable {
Function PrepareTable {
Line 1,262: Line 1,550:
}
}
CheckIt
CheckIt
</syntaxhighlight>
</lang>


===Using Api===
===Using Api===
<lang M2000 Interpreter>
<syntaxhighlight lang=M2000 Interpreter>
Module CheckApi {
Module CheckApi {
Declare CRC32 LIB "ntdll.RtlComputeCrc32" {Long Zero, a$, long s}
Declare CRC32 LIB "ntdll.RtlComputeCrc32" {Long Zero, a$, long s}
Line 1,273: Line 1,561:
}
}
CheckApi
CheckApi
</syntaxhighlight>
</lang>


=={{header|Mathematica}} / {{header|Wolfram Language}}==
=={{header|Mathematica}} / {{header|Wolfram Language}}==
<lang Mathematica>type="CRC32"; (*pick one out of 13 predefined hash types*)
<syntaxhighlight lang=Mathematica>type="CRC32"; (*pick one out of 13 predefined hash types*)
StringForm[
StringForm[
"The "<>type<>" hash code of \"``\" is ``.",
"The "<>type<>" hash code of \"``\" is ``.",
Line 1,282: Line 1,570:
Hash[s,type,"HexString"]
Hash[s,type,"HexString"]
]
]
</syntaxhighlight>
</lang>
{{out}}
{{out}}
<pre>
<pre>
Line 1,291: Line 1,579:
The NekoVM is a 31 bit machine; 30 signed. Loadable primitives handle 32bit integers. The zlib library API exposes a CRC-32 function, that expects and returns Int32.
The NekoVM is a 31 bit machine; 30 signed. Loadable primitives handle 32bit integers. The zlib library API exposes a CRC-32 function, that expects and returns Int32.


<lang ActionScript>/**
<syntaxhighlight lang=ActionScript>/**
<doc>CRC32 in Neko</doc>
<doc>CRC32 in Neko</doc>
**/
**/
Line 1,302: Line 1,590:


crc = update_crc32(crc, txt, 0, $ssize(txt))
crc = update_crc32(crc, txt, 0, $ssize(txt))
$print(crc, "\n")</lang>
$print(crc, "\n")</syntaxhighlight>


{{out}}
{{out}}
Line 1,313: Line 1,601:
=={{header|NetRexx}}==
=={{header|NetRexx}}==
{{trans|Java}}
{{trans|Java}}
<lang NetRexx>/* NetRexx */
<syntaxhighlight lang=NetRexx>/* NetRexx */
options replace format comments java crossref symbols binary
options replace format comments java crossref symbols binary


Line 1,324: Line 1,612:


return
return
</syntaxhighlight>
</lang>


{{out}}
{{out}}
Line 1,332: Line 1,620:


=={{header|Nim}}==
=={{header|Nim}}==
<lang nim>import unsigned, strutils
<syntaxhighlight lang=nim>import strutils


type TCrc32* = uint32
type TCrc32* = uint32
const InitCrc32* = TCrc32(-1)
const InitCrc32* = TCrc32(0xffffffff)


proc createCrcTable(): array[0..255, TCrc32] =
proc createCrcTable(): array[0..255, TCrc32] =
Line 1,351: Line 1,639:
result = InitCrc32
result = InitCrc32
for c in s:
for c in s:
result = (result shr 8) xor crc32table[(result and 0xff) xor ord(c)]
result = (result shr 8) xor crc32table[(result and 0xff) xor byte(c)]
result = not result
result = not result


echo crc32("The quick brown fox jumps over the lazy dog").int64.toHex(8)</lang>
echo crc32("The quick brown fox jumps over the lazy dog").int64.toHex(8)</syntaxhighlight>
{{out}}
{{out}}
<pre>414FA339</pre>
<pre>414FA339</pre>

=={{header|NOWUT}}==
adapted from FreeBASIC
<syntaxhighlight lang=NOWUT>; link with PIOxxx.OBJ

sectionbss

crctable.d: resd 256

sectiondata

havetable.b: db 0
string: db "The quick brown fox jumps over the lazy dog"
stringend:
db 13,10,0 ; carriage return and null terminator
sectioncode

start!
gosub initplatform

beginfunc
localvar crc.d

callex ,printnt,"input = ".a
callex ,printnt,string

callex ,printnt,"The CRC-32 checksum = ".a
callex crc,crc32,string,stringend
callex ,printhexr,crc

endfunc
end

crc32:
beginfunc bufend.d,buf.d
localvar i.d,j.d,k.d,k2.d,crc.d

ifunequal havetable,0,tabledone
i=0
whileless i,256

k=i > j=8
countdown j
k2=k > k=_ shr 1
ifequal k2 and 1,0,noxor > k=_ xor $EDB88320
noxor:
nextcount

crctable(i shl 2)=k
i=_+1
wend

havetable=1
tabledone:

crc=-1

whileless buf,bufend
crc=_ shr 8 xor crctable(crc and $FF xor [buf].b shl 2)
buf=_+1
wend

crc=_ xor -1
endfunc crc
returnex 8 ; clean off 2 parameters from the stack
</syntaxhighlight>
{{out}}
<pre>input = The quick brown fox jumps over the lazy dog
The CRC-32 checksum = 414FA339</pre>


=={{header|Oberon-2}}==
=={{header|Oberon-2}}==
{{Works with|oo2c Version 2}}
{{Works with|oo2c Version 2}}
<lang oberon2>
<syntaxhighlight lang=oberon2>
MODULE CRC32;
MODULE CRC32;
IMPORT
IMPORT
Line 1,372: Line 1,730:
Out.Hex(Zlib.CRC32(0,s,0,Strings.Length(s)),0);Out.Ln
Out.Hex(Zlib.CRC32(0,s,0,Strings.Length(s)),0);Out.Ln
END CRC32.
END CRC32.
</syntaxhighlight>
</lang>
{{out}}
{{out}}
<pre>
<pre>
Line 1,379: Line 1,737:


=={{header|Objeck}}==
=={{header|Objeck}}==
<lang objeck>class CRC32 {
<syntaxhighlight lang=objeck>class CRC32 {
function : Main(args : String[]) ~ Nil {
function : Main(args : String[]) ~ Nil {
"The quick brown fox jumps over the lazy dog"->ToByteArray()->CRC32()->PrintLine();
"The quick brown fox jumps over the lazy dog"->ToByteArray()->CRC32()->PrintLine();
}
}
}
}
</syntaxhighlight>
</lang>


{{out}}
{{out}}
Line 1,395: Line 1,753:
{{libheader|camlzip}}
{{libheader|camlzip}}


<lang ocaml>let () =
<syntaxhighlight lang=ocaml>let () =
let s = "The quick brown fox jumps over the lazy dog" in
let s = "The quick brown fox jumps over the lazy dog" in
let crc = Zlib.update_crc 0l s 0 (String.length s) in
let crc = Zlib.update_crc 0l s 0 (String.length s) in
Printf.printf "crc: %lX\n" crc</lang>
Printf.printf "crc: %lX\n" crc</syntaxhighlight>


Running this code in interpreted mode:<nowiki>[[Media:Insert non-formatted text here]][[File:[Example.jpg][http://www.example.com link title]]]</nowiki>
Running this code in interpreted mode:<nowiki>[[Media:Insert non-formatted text here]][[File:[Example.jpg][http://www.example.com link title]]]</nowiki>
Line 1,405: Line 1,763:
$ ocaml unix.cma -I +zip zip.cma crc.ml
$ ocaml unix.cma -I +zip zip.cma crc.ml
crc: 414FA339
crc: 414FA339
</pre>

=={{header|Ol}}==
<syntaxhighlight lang=scheme>
(define (crc32 str)
(bxor #xFFFFFFFF
(fold (lambda (crc char)
(let loop ((n 8) (crc crc) (bits char))
(if (eq? n 0)
crc
(let*((flag (band (bxor bits crc) 1))
(crc (>> crc 1))
(crc (if (eq? flag 0) crc (bxor crc #xEDB88320)))
(bits (>> bits 1)))
(loop (- n 1) crc bits)))))
#xFFFFFFFF
(string->list str))))

(print (number->string (crc32 "The quick brown fox jumps over the lazy dog") 16))
(print (number->string (crc32 (list->string (repeat #x00 32))) 16))
(print (number->string (crc32 (list->string (repeat #xFF 32))) 16))
(print (number->string (crc32 (list->string (iota 32))) 16))
</syntaxhighlight>
{{Out}}
<pre>
414fa339
190a55ad
ff6cab0b
91267e8a
</pre>
</pre>


Line 1,410: Line 1,797:
This Program shows how easy it is to use JAVA functionality from ooRexx.
This Program shows how easy it is to use JAVA functionality from ooRexx.
bsf4oorexx from Sourceforge https://sourceforge.net/projects/bsf4oorexx/ makes that possible.
bsf4oorexx from Sourceforge https://sourceforge.net/projects/bsf4oorexx/ makes that possible.
<lang oorexx>/* ooRexx */
<syntaxhighlight lang=oorexx>/* ooRexx */
clzCRC32=bsf.importClass("java.util.zip.CRC32")
clzCRC32=bsf.importClass("java.util.zip.CRC32")
myCRC32 =clzCRC32~new
myCRC32 =clzCRC32~new
Line 1,418: Line 1,805:
say 'The CRC-32 value of "'toBeEncoded'" is:' myCRC32~getValue~d2x
say 'The CRC-32 value of "'toBeEncoded'" is:' myCRC32~getValue~d2x


::requires "BSF.CLS" -- get Java bridge </lang>
::requires "BSF.CLS" -- get Java bridge </syntaxhighlight>
{{out}}
{{out}}
<pre>The CRC-32 value of "The quick brown fox jumps over the lazy dog" is: 414FA339</pre>
<pre>The CRC-32 value of "The quick brown fox jumps over the lazy dog" is: 414FA339</pre>
Line 1,427: Line 1,814:
{{libheader|libz.so}}
{{libheader|libz.so}}


<lang parigp>
<syntaxhighlight lang=parigp>
install("crc32", "lLsL", "crc32", "libz.so");
install("crc32", "lLsL", "crc32", "libz.so");
s = "The quick brown fox jumps over the lazy dog";
s = "The quick brown fox jumps over the lazy dog";
printf("%0x\n", crc32(0, s, #s))
printf("%0x\n", crc32(0, s, #s))
</syntaxhighlight>
</lang>

Output:
Output:
<pre>414fa339</pre>
<pre>414fa339</pre>
=={{header|Pascal}}==
==={{header|Free Pascal}}===
<syntaxhighlight lang=pascal>
Program CheckCRC;
{$IFDEF fpc}{$mode Delphi}{$ENDIF}
{$IFDEF WINDOWS}{$APPTYPE CONSOLE}{$ENDIF}
uses
sysutils,crc;
function CrcString(const mystring: string) : longword;
var
crcvalue: longword;
begin
crcvalue := crc32(0,nil,0);
result := crc32(crcvalue, @mystring[1], length(mystring));
end;

var
mytext: string;
begin
myText := 'The quick brown fox jumps over the lazy dog';
writeln('crc32 = ', IntToHex(CrcString(mytext), 8));
end.</syntaxhighlight>
Output:
<pre>crc32 = 414FA339</pre>


=={{header|Perl}}==
=={{header|Perl}}==
<lang Perl>#!/usr/bin/perl
<syntaxhighlight lang=Perl>#!/usr/bin/perl
use 5.010 ;
use 5.010 ;
use strict ;
use strict ;
Line 1,446: Line 1,857:
$crc->add ( "The quick brown fox jumps over the lazy dog" ) ;
$crc->add ( "The quick brown fox jumps over the lazy dog" ) ;
say "The checksum is " . $crc->hexdigest( ) ;
say "The checksum is " . $crc->hexdigest( ) ;
</syntaxhighlight>
</lang>
{{out}}
{{out}}
<pre>The checksum is 414fa339</pre>
<pre>The checksum is 414fa339</pre>
Line 1,452: Line 1,863:
=={{header|Phix}}==
=={{header|Phix}}==
Included as demo\rosetta\crc32.exw, which also includes a thread-safe version
Included as demo\rosetta\crc32.exw, which also includes a thread-safe version
<!--<syntaxhighlight lang="phix">(phixonline)-->
<lang Phix>sequence table
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
integer have_table = 0
<span style="color: #004080;">sequence</span> <span style="color: #000000;">table</span>

<span style="color: #004080;">bool</span> <span style="color: #000000;">have_table</span> <span style="color: #0000FF;">=</span> <span style="color: #004600;">false</span>
procedure make_crc()
atom rem
<span style="color: #008080;">function</span> <span style="color: #000000;">crc32</span><span style="color: #0000FF;">(</span><span style="color: #004080;">string</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">)</span>
if have_table=0 then
<span style="color: #008080;">if</span> <span style="color: #008080;">not</span> <span style="color: #000000;">have_table</span> <span style="color: #008080;">then</span>
have_table = 1
<span style="color: #000000;">have_table</span> <span style="color: #0000FF;">=</span> <span style="color: #004600;">true</span>
table = repeat(0,256)
<span style="color: #000000;">table</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span><span style="color: #000000;">256</span><span style="color: #0000FF;">)</span>
for i=0 to 255 do
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">0</span> <span style="color: #008080;">to</span> <span style="color: #000000;">255</span> <span style="color: #008080;">do</span>
rem = i
<span style="color: #004080;">atom</span> <span style="color: #000000;">rem</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">i</span>
for j=1 to 8 do
<span style="color: #008080;">for</span> <span style="color: #000000;">j</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">8</span> <span style="color: #008080;">do</span>
if and_bits(rem,1) then
<span style="color: #008080;">if</span> <span style="color: #7060A8;">and_bits</span><span style="color: #0000FF;">(</span><span style="color: #000000;">rem</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">then</span>
rem = xor_bits(floor(rem/2),#EDB88320)
<span style="color: #000000;">rem</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">xor_bits</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">floor</span><span style="color: #0000FF;">(</span><span style="color: #000000;">rem</span><span style="color: #0000FF;">/</span><span style="color: #000000;">2</span><span style="color: #0000FF;">),</span><span style="color: #000000;">#EDB88320</span><span style="color: #0000FF;">)</span>
else
rem = floor(rem/2)
<span style="color: #008080;">else</span>
<span style="color: #000000;">rem</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">floor</span><span style="color: #0000FF;">(</span><span style="color: #000000;">rem</span><span style="color: #0000FF;">/</span><span style="color: #000000;">2</span><span style="color: #0000FF;">)</span>
end if
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
if rem<0 then
<span style="color: #008080;">if</span> <span style="color: #000000;">rem</span><span style="color: #0000FF;"><</span><span style="color: #000000;">0</span> <span style="color: #008080;">then</span>
rem += #100000000
<span style="color: #000000;">rem</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">#100000000</span>
end if
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
end for
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
table[i+1] = rem
<span style="color: #000000;">table</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">+</span><span style="color: #000000;">1</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">rem</span>
end for
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
end if
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
end procedure
<span style="color: #004080;">atom</span> <span style="color: #000000;">crc</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">#FFFFFFFF</span>

<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
function crc32(string s)
<span style="color: #000000;">crc</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">xor_bits</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">floor</span><span style="color: #0000FF;">(</span><span style="color: #000000;">crc</span><span style="color: #0000FF;">/</span><span style="color: #000000;">#100</span><span style="color: #0000FF;">),</span><span style="color: #000000;">table</span><span style="color: #0000FF;">[</span><span style="color: #7060A8;">xor_bits</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">and_bits</span><span style="color: #0000FF;">(</span><span style="color: #000000;">crc</span><span style="color: #0000FF;">,</span><span style="color: #000000;">0xff</span><span style="color: #0000FF;">),</span><span style="color: #000000;">s</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">])+</span><span style="color: #000000;">1</span><span style="color: #0000FF;">])</span>
atom crc = #FFFFFFFF
<span style="color: #008080;">if</span> <span style="color: #000000;">crc</span><span style="color: #0000FF;"><</span><span style="color: #000000;">0</span> <span style="color: #008080;">then</span>
if have_table=0 then make_crc() end if
<span style="color: #000000;">crc</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">#100000000</span>
for i=1 to length(s) do
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
crc = xor_bits(floor(crc/#100),table[xor_bits(and_bits(crc,0xff),s[i])+1])
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
if crc<0 then
<span style="color: #008080;">return</span> <span style="color: #7060A8;">and_bits</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">not_bits</span><span style="color: #0000FF;">(</span><span style="color: #000000;">crc</span><span style="color: #0000FF;">),</span><span style="color: #000000;">#FFFFFFFF</span><span style="color: #0000FF;">)</span>
crc += #100000000
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
end if
end for
<span style="color: #004080;">string</span> <span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"The quick brown fox jumps over the lazy dog"</span>
-- return not_bits(crc)
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"The CRC of %s is %08x\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">s</span><span style="color: #0000FF;">,</span><span style="color: #000000;">crc32</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">)})</span>
return and_bits(not_bits(crc),#FFFFFFFF)
<!--</syntaxhighlight>-->
end function</lang>
Test code:
<lang Phix>string s = "The quick brown fox jumps over the lazy dog"
printf(1,"The CRC of %s is %08x\n",{s,crc32(s)})</lang>
{{out}}
{{out}}
<pre>
<pre>
Line 1,500: Line 1,908:
PHP has a built-in function [http://us2.php.net/manual/en/function.crc32.php crc32].
PHP has a built-in function [http://us2.php.net/manual/en/function.crc32.php crc32].


<lang php>printf("%x\n", crc32("The quick brown fox jumps over the lazy dog"));</lang>
<syntaxhighlight lang=php>printf("%x\n", crc32("The quick brown fox jumps over the lazy dog"));</syntaxhighlight>


<pre>414fa339</pre>
<pre>414fa339</pre>
Line 1,507: Line 1,915:
Library and implementation.
Library and implementation.


<lang PicoLisp>(setq *Table
<syntaxhighlight lang=PicoLisp>(setq *Table
(mapcar
(mapcar
'((N)
'((N)
Line 1,533: Line 1,941:
(hex (native "libz.so" "crc32" 'N 0 Str (length Str))) ) )
(hex (native "libz.so" "crc32" 'N 0 Str (length Str))) ) )
(bye)</lang>
(bye)</syntaxhighlight>


=={{header|Pike}}==
=={{header|Pike}}==
<lang Pike>string foo = "The quick brown fox jumps over the lazy dog";
<syntaxhighlight lang=Pike>string foo = "The quick brown fox jumps over the lazy dog";
write("0x%x\n", Gz.crc32(foo));</lang>
write("0x%x\n", Gz.crc32(foo));</syntaxhighlight>
{{Out}}
{{Out}}
<pre>
<pre>
Line 1,544: Line 1,952:


=={{header|PL/I}}==
=={{header|PL/I}}==
<lang pli>*process source attributes xref or(!) nest;
<syntaxhighlight lang=pli>*process source attributes xref or(!) nest;
crct: Proc Options(main);
crct: Proc Options(main);
/*********************************************************************
/*********************************************************************
Line 1,641: Line 2,049:
End;
End;
End;
End;
End;</lang>
End;</syntaxhighlight>
{{out}}
{{out}}
<pre>
<pre>
Line 1,651: Line 2,059:


=={{header|PowerBASIC}}==
=={{header|PowerBASIC}}==
<lang powerbasic>#COMPILE EXE
<syntaxhighlight lang=powerbasic>#COMPILE EXE
#DIM ALL
#DIM ALL
#COMPILER PBCC 6
#COMPILER PBCC 6
Line 1,698: Line 2,106:
crc = CRC32(STRPTR(s), LEN(s))
crc = CRC32(STRPTR(s), LEN(s))
CON.PRINT "CRC32: " & HEX$(crc)
CON.PRINT "CRC32: " & HEX$(crc)
END FUNCTION</lang>
END FUNCTION</syntaxhighlight>
{{out}}
{{out}}
<pre>Text: The quick brown fox jumps over the lazy dog
<pre>Text: The quick brown fox jumps over the lazy dog
Line 1,705: Line 2,113:
=={{header|PureBasic}}==
=={{header|PureBasic}}==
{{works with|PB Version 5.40}}
{{works with|PB Version 5.40}}
<lang PureBasic>
<syntaxhighlight lang=PureBasic>
a$="The quick brown fox jumps over the lazy dog"
a$="The quick brown fox jumps over the lazy dog"


Line 1,715: Line 2,123:
Input()
Input()


End</lang>
End</syntaxhighlight>
{{out}}<pre>CRC32 Cecksum [hex] = 414FA339
{{out}}<pre>CRC32 Cecksum [hex] = 414FA339
CRC32 Cecksum [dec] = 1095738169</pre>
CRC32 Cecksum [dec] = 1095738169</pre>
Line 1,723: Line 2,131:
[http://docs.python.org/library/zlib.html#zlib.crc32 <code>zlib.crc32</code>] and [http://docs.python.org/library/binascii.html#binascii.crc32 <code>binascii.crc32</code>] give identical results.
[http://docs.python.org/library/zlib.html#zlib.crc32 <code>zlib.crc32</code>] and [http://docs.python.org/library/binascii.html#binascii.crc32 <code>binascii.crc32</code>] give identical results.


<lang python>>>> s = 'The quick brown fox jumps over the lazy dog'
<syntaxhighlight lang=python>>>> s = 'The quick brown fox jumps over the lazy dog'
>>> import zlib
>>> import zlib
>>> hex(zlib.crc32(s))
>>> hex(zlib.crc32(s))
Line 1,730: Line 2,138:
>>> import binascii
>>> import binascii
>>> hex(binascii.crc32(s))
>>> hex(binascii.crc32(s))
'0x414fa339'</lang>
'0x414fa339'</syntaxhighlight>


If you have Python 2.x, these functions might return a negative integer; you would need to use <code>& 0xffffffff</code> to get the same answer as Python 3.x. With Python 3.x, convert first the string to bytes, for instance with <code>s.encode('UTF-8')</code>, as these functions do not accept strings.
If you have Python 2.x, these functions might return a negative integer; you would need to use <code>& 0xffffffff</code> to get the same answer as Python 3.x. With Python 3.x, convert first the string to bytes, for instance with <code>s.encode('UTF-8')</code>, as these functions do not accept strings.
===Implementation===
===Implementation===
====Procedural====
====Procedural====
<lang python>def create_table():
<syntaxhighlight lang=python>def create_table():
a = []
a = []
for i in range(256):
for i in range(256):
Line 1,753: Line 2,161:
crc_table = create_table()
crc_table = create_table()
print(hex(crc_update(b"The quick brown fox jumps over the lazy dog", 0)))</lang>
print(hex(crc_update(b"The quick brown fox jumps over the lazy dog", 0)))</syntaxhighlight>


====Composition of pure functions====
====Composition of pure functions====
<lang Python>'''CRC-32 checksums for ascii strings'''
<syntaxhighlight lang=Python>'''CRC-32 checksums for ascii strings'''


from functools import (reduce)
from functools import (reduce)
Line 1,776: Line 2,184:
(a ^ ord(c)) & 0xff
(a ^ ord(c)) & 0xff
],
],
list(s),
s,
(0xffffffff)
(0xffffffff)
) ^ 0xffffffff
) ^ 0xffffffff




# TEST ----------------------------------------------------
# ------------------------- TEST -------------------------
# main :: IO ()
# main :: IO ()
def main():
def main():
Line 1,793: Line 2,201:




# GENERIC ABSTRACTION -------------------------------------
# ----------------------- GENERIC ------------------------


# index (!!) :: [a] -> Int -> a
# index (!!) :: [a] -> Int -> a
Line 1,807: Line 2,215:
# iterate :: (a -> a) -> a -> Gen [a]
# iterate :: (a -> a) -> a -> Gen [a]
def iterate(f):
def iterate(f):
'''An infinite list of repeated applications of f to x.'''
'''An infinite list of repeated
applications of f to x.
'''
def go(x):
def go(x):
v = x
v = x
Line 1,813: Line 2,223:
yield v
yield v
v = f(v)
v = f(v)
return lambda x: go(x)
return go




if __name__ == '__main__':
if __name__ == '__main__':
main()</lang>
main()</syntaxhighlight>
{{Out}}
{{Out}}
<pre>414fa339</pre>
<pre>414fa339</pre>

=={{header|QB64}}==
{{trans|C}}
<syntaxhighlight lang=QB64>
PRINT HEX$(crc32("The quick brown fox jumps over the lazy dog"))

FUNCTION crc32~& (buf AS STRING)
STATIC table(255) AS _UNSIGNED LONG
STATIC have_table AS _BYTE
DIM crc AS _UNSIGNED LONG, k AS _UNSIGNED LONG
DIM i AS LONG, j AS LONG

IF have_table = 0 THEN
FOR i = 0 TO 255
k = i
FOR j = 0 TO 7
IF (k AND 1) THEN
k = _SHR(k, 1)
k = k XOR &HEDB88320
ELSE
k = _SHR(k, 1)
END IF
table(i) = k
NEXT
NEXT
have_table = -1
END IF

crc = NOT crc ' crc = &Hffffffff

FOR i = 1 TO LEN(buf)
crc = (_SHR(crc, 8)) XOR table((crc AND &HFF) XOR ASC(buf, i))
NEXT

crc32~& = NOT crc
END FUNCTION
</syntaxhighlight>
{{Out}}
<pre>414FA339</pre>

=={{header|Quackery}}==

{{trans|Forth}}

<syntaxhighlight lang=Quackery> [ table ] is crctable ( n --> n )

256 times
[ i^ 8 times
[ dup 1 >>
swap 1 & if
[ hex EDB88320 ^ ] ]
' crctable put ]

[ hex FFFFFFFF swap
witheach
[ over ^ hex FF &
crctable
swap 8 >> ^ ]
hex FFFFFFFF ^ ] is crc-32 ( [ --> n )

$ "The quick brown fox jumps over the lazy dog" crc-32
16 base put
echo
base release</syntaxhighlight>

{{out}}

<pre>414FA339</pre>


=={{header|R}}==
=={{header|R}}==
<syntaxhighlight lang=R>
<lang R>
digest("The quick brown fox jumps over the lazy dog","crc32", serialize=F)
digest("The quick brown fox jumps over the lazy dog","crc32", serialize=F)
</syntaxhighlight>
</lang>
{{out}}
{{out}}
<pre>[1] "414fa339"</pre>
<pre>[1] "414fa339"</pre>


=={{header|Racket}}==
=={{header|Racket}}==
<lang scheme>#lang racket
<syntaxhighlight lang=scheme>#lang racket
(define (bytes-crc32 data)
(define (bytes-crc32 data)
(bitwise-xor
(bitwise-xor
Line 1,843: Line 2,321:
(bytes-crc32 (string->bytes/utf-8 s)))
(bytes-crc32 (string->bytes/utf-8 s)))


(format "~x" (crc32 "The quick brown fox jumps over the lazy dog"))</lang>
(format "~x" (crc32 "The quick brown fox jumps over the lazy dog"))</syntaxhighlight>
{{out}}
{{out}}
<pre>"414fa339"</pre>
<pre>"414fa339"</pre>
Line 1,852: Line 2,330:
=== Call to native function crc32 in zlib ===
=== Call to native function crc32 in zlib ===


<lang perl6>use NativeCall;
<syntaxhighlight lang=raku line>use NativeCall;
sub crc32(int32 $crc, Buf $buf, int32 $len --> int32) is native('z') { * }
sub crc32(int32 $crc, Buf $buf, int32 $len --> int32) is native('z') { * }
my $buf = 'The quick brown fox jumps over the lazy dog'.encode;
my $buf = 'The quick brown fox jumps over the lazy dog'.encode;
say crc32(0, $buf, $buf.bytes).fmt('%08x');</lang>
say crc32(0, $buf, $buf.bytes).fmt('%08x');</syntaxhighlight>


The libary name "z" resolves to <tt>/usr/lib/libz.so</tt> on a typical Linux system and <tt>/usr/lib/libz.dylib</tt> on Mac OS X, but may need to be changed for other platforms. Types may be platform-dependent as well. As written, the solution has been tested on Mac OS X 10.5.8 and Arch Linux 2016.08.01 x86_64.
The libary name "z" resolves to <tt>/usr/lib/libz.so</tt> on a typical Linux system and <tt>/usr/lib/libz.dylib</tt> on Mac OS X, but may need to be changed for other platforms. Types may be platform-dependent as well. As written, the solution has been tested on Mac OS X 10.5.8 and Arch Linux 2016.08.01 x86_64.
Line 1,868: Line 2,346:
A fairly generic implementation with no regard to execution speed:
A fairly generic implementation with no regard to execution speed:


<lang perl6>sub crc(
<syntaxhighlight lang=raku line>sub crc(
Blob $buf,
Blob $buf,
# polynomial including leading term, default: ISO 3309/PNG/gzip
# polynomial including leading term, default: ISO 3309/PNG/gzip
Line 1,887: Line 2,365:
}
}


say crc('The quick brown fox jumps over the lazy dog'.encode('ascii')).base(16);</lang>
say crc('The quick brown fox jumps over the lazy dog'.encode('ascii')).base(16);</syntaxhighlight>


{{out}}
{{out}}
Line 1,893: Line 2,371:


=={{header|REXX}}==
=={{header|REXX}}==
<lang rexx>/*REXX program computes the CRC─32 (32 bit Cyclic Redundancy Check) checksum for a */
<syntaxhighlight lang=rexx>/*REXX program computes the CRC─32 (32 bit Cyclic Redundancy Check) checksum for a */
/*─────────────────────────────────given string [as described in ISO 3309, ITU─T V.42].*/
/*─────────────────────────────────given string [as described in ISO 3309, ITU─T V.42].*/
call show 'The quick brown fox jumps over the lazy dog' /*the 1st string.*/
call show 'The quick brown fox jumps over the lazy dog' /*the 1st string.*/
Line 1,923: Line 2,401:
say "hex CRC─32 checksum =" c2x(checksum) left('', 15),
say "hex CRC─32 checksum =" c2x(checksum) left('', 15),
"dec CRC─32 checksum =" c2d(checksum) /*show the CRC─32 in hex and dec.*/
"dec CRC─32 checksum =" c2d(checksum) /*show the CRC─32 in hex and dec.*/
return</lang>
return</syntaxhighlight>
{{out|output|text=&nbsp; when using the internal default input:}}
{{out|output|text=&nbsp; when using the internal default input:}}
<pre>
<pre>
Line 1,936: Line 2,414:


hex CRC-32 checksum = D1370232 dec CRC-32 checksum = 3510043186
hex CRC-32 checksum = D1370232 dec CRC-32 checksum = 3510043186
</pre>

=={{header|RPL}}==
{{trans|FreeBASIC}}
≪ → string
≪ <span style="color:red">32</span> STWS <span style="color:grey">@ set binary word size to 32</span>
'''IFERR''' ‘<span style="color:green">CRCtable</span>’ RCL '''THEN'''
{ }
<span style="color:red">0 255</span> '''FOR''' j
j R→B
<span style="color:red">0 7</span> '''START'''
SR '''IF''' LAST <span style="color:red">#1</span> AND B→R '''THEN''' <span style="color:red">#EDB88320h</span> XOR '''END'''
'''NEXT''' + '''NEXT'''
‘<span style="color:green">CRCtable</span>’ STO
'''END'''
DROP <span style="color:red">#0</span> NOT
<span style="color:red">1</span> string SIZE '''FOR''' j
SRB SWAP
<span style="color:red">#FFh</span> AND string j DUP SUB NUM R→B XOR
B→R <span style="color:red">1</span> + ‘<span style="color:green">CRCtable</span>’ SWAP GET XOR
'''NEXT'''
NOT
≫ ≫ ‘<span style="color:blue">CRC32</span>’ STO

<span style="color:red">"The quick brown fox jumps over the lazy dog"</span> <span style="color:blue">CRC32</span>
{{out}}
<pre>
1: # 414FA339h
</pre>
</pre>


Line 1,941: Line 2,447:
Use 'zlib' from standard library.
Use 'zlib' from standard library.


<lang ruby>require 'zlib'
<syntaxhighlight lang=ruby>require 'zlib'
printf "0x%08x\n", Zlib.crc32('The quick brown fox jumps over the lazy dog')
printf "0x%08x\n", Zlib.crc32('The quick brown fox jumps over the lazy dog')
# => 0x414fa339</lang>
# => 0x414fa339</syntaxhighlight>


Reimplement CRC-32 in Ruby, with comments to show the polynomials.
Reimplement CRC-32 in Ruby, with comments to show the polynomials.


<lang ruby>module CRC
<syntaxhighlight lang=ruby>module CRC
# Divisor is a polynomial of degree 32 with coefficients modulo 2.
# Divisor is a polynomial of degree 32 with coefficients modulo 2.
# We store Divisor in a 33-bit Integer; the polynomial is
# We store Divisor in a 33-bit Integer; the polynomial is
Line 2,021: Line 2,527:


printf "0x%08x\n", CRC.crc32("The quick brown fox jumps over the lazy dog")
printf "0x%08x\n", CRC.crc32("The quick brown fox jumps over the lazy dog")
# => 0x414fa339</lang>
# => 0x414fa339</syntaxhighlight>


=={{header|Rust}}==
=={{header|Rust}}==
This does not perform any caching of the lookup table for simplicity.
This does not perform any caching of the lookup table for simplicity.
<lang rust>
<syntaxhighlight lang=rust>
fn crc32_compute_table() -> [u32; 256] {
fn crc32_compute_table() -> [u32; 256] {
let mut crc32_table = [0; 256];
let mut crc32_table = [0; 256];
Line 2,052: Line 2,558:
println!("{:x}", crc32("The quick brown fox jumps over the lazy dog"));
println!("{:x}", crc32("The quick brown fox jumps over the lazy dog"));
}
}
</syntaxhighlight>
</lang>
{{Output}}
{{Output}}
<pre>
<pre>
Line 2,060: Line 2,566:
=={{header|Scala}}==
=={{header|Scala}}==
{{trans|Java}}
{{trans|Java}}
<lang scala>import java.util.zip.CRC32
<syntaxhighlight lang=scala>import java.util.zip.CRC32
val crc=new CRC32
val crc=new CRC32
crc.update("The quick brown fox jumps over the lazy dog".getBytes)
crc.update("The quick brown fox jumps over the lazy dog".getBytes)
println(crc.getValue.toHexString) //> 414fa339</lang>
println(crc.getValue.toHexString) //> 414fa339</syntaxhighlight>


=={{header|Seed7}}==
=={{header|Seed7}}==
<lang seed7>$ include "seed7_05.s7i";
<syntaxhighlight lang=seed7>$ include "seed7_05.s7i";
include "crc32.s7i";
include "crc32.s7i";


Line 2,072: Line 2,578:
begin
begin
writeln(ord(crc32("The quick brown fox jumps over the lazy dog")) radix 16 lpad0 8);
writeln(ord(crc32("The quick brown fox jumps over the lazy dog")) radix 16 lpad0 8);
end func;</lang>
end func;</syntaxhighlight>


{{out}}
{{out}}
Line 2,081: Line 2,587:
=={{header|Shell}}==
=={{header|Shell}}==
===Bash===
===Bash===
<lang Bash>#!/usr/bin/env bash
<syntaxhighlight lang=Bash>#!/usr/bin/env bash
declare -i -a CRC32_LOOKUP_TABLE
declare -i -a CRC32_LOOKUP_TABLE


Line 2,112: Line 2,618:
# crc32_string "The quick brown fox jumps over the lazy dog"
# crc32_string "The quick brown fox jumps over the lazy dog"
# yields 414fa339
# yields 414fa339
</syntaxhighlight>
</lang>
===POSIX===
===POSIX===
The POSIX Shell has no array type and no string indexation.
The POSIX Shell has no array type and no string indexation.
It costs less to recompute polynomal shift for each character than indexing
It costs less to recompute polynomal shift for each character than indexing
with external tools like <code>awk</code> or <code>tr</code>.
with external tools like <code>awk</code> or <code>tr</code>.
<lang bash>#!/usr/bin/env sh
<syntaxhighlight lang=bash>#!/usr/bin/env sh
# POSIX Shell CRC32 of string
# POSIX Shell CRC32 of string
# @Name: crc32.sh
# @Name: crc32.sh
Line 2,168: Line 2,674:


# crc32_string "The quick brown fox jumps over the lazy dog"
# crc32_string "The quick brown fox jumps over the lazy dog"
# yields 414fa339</lang>
# yields 414fa339</syntaxhighlight>
{{out}}
{{out}}
<pre>bash ./crc32.sh "The quick brown fox jumps over the lazy dog"
<pre>bash ./crc32.sh "The quick brown fox jumps over the lazy dog"
Line 2,177: Line 2,683:
{{works with|Smalltalk/X}}
{{works with|Smalltalk/X}}
the CRC32Stream utility class can do it for me:
the CRC32Stream utility class can do it for me:
<lang smalltalk>CRC32Stream hashValueOf:'The quick brown fox jumps over the lazy dog'</lang>
<syntaxhighlight lang=smalltalk>CRC32Stream hashValueOf:'The quick brown fox jumps over the lazy dog'</syntaxhighlight>
{{out}}
{{out}}
1095738169 "which is 16r414FA339"
1095738169 "which is 16r414FA339"
Line 2,183: Line 2,689:
=={{header|Swift}}==
=={{header|Swift}}==
Using the zlib crc32 function available to Swift from libz.dylib.
Using the zlib crc32 function available to Swift from libz.dylib.
<lang Swift>import Foundation
<syntaxhighlight lang=Swift>import Foundation


let strData = "The quick brown fox jumps over the lazy dog".dataUsingEncoding(NSUTF8StringEncoding,
let strData = "The quick brown fox jumps over the lazy dog".dataUsingEncoding(NSUTF8StringEncoding,
Line 2,189: Line 2,695:
let crc = crc32(uLong(0), UnsafePointer<Bytef>(strData!.bytes), uInt(strData!.length))
let crc = crc32(uLong(0), UnsafePointer<Bytef>(strData!.bytes), uInt(strData!.length))


println(NSString(format:"%2X", crc))</lang>
println(NSString(format:"%2X", crc))</syntaxhighlight>
{{out}}
{{out}}
<pre>414FA339
<pre>414FA339
Line 2,195: Line 2,701:


=={{header|Tcl}}==
=={{header|Tcl}}==
<lang tcl>package require Tcl 8.6
<syntaxhighlight lang=tcl>package require Tcl 8.6


set data "The quick brown fox jumps over the lazy dog"
set data "The quick brown fox jumps over the lazy dog"
puts [format "%x" [zlib crc32 $data]]</lang>
puts [format "%x" [zlib crc32 $data]]</syntaxhighlight>
{{out}}
{{out}}
<pre>414fa339</pre>
<pre>414fa339</pre>
Line 2,204: Line 2,710:
Alternatively, with older versions of Tcl:
Alternatively, with older versions of Tcl:
{{tcllib|crc32}}
{{tcllib|crc32}}
<lang tcl>package require crc32
<syntaxhighlight lang=tcl>package require crc32
puts [format "%x" [crc::crc32 $data]]</lang>
puts [format "%x" [crc::crc32 $data]]</syntaxhighlight>
With the same input data, it produces identical output.
With the same input data, it produces identical output.

=={{header|TXR}}==
===Standard Library===
<syntaxhighlight lang=txrlisp>(crc32 "The quick brown fox jumps over the lazy dog")</syntaxhighlight>
{{out}}
<pre>1095738169</pre>
===FFI access to Zlib===
<syntaxhighlight lang=txrlisp>(with-dyn-lib "libz.so.1"
(deffi zlib-crc32 "crc32" ulong (ulong str uint)))</syntaxhighlight>
{{out}}
<pre>$ txr -i crc32-zlib.tl
1> (let ((s "The quick brown fox jumps over the lazy dog"))
(zlib-crc32 0 s (coded-length s)))
1095738169</pre>
Note: <code>coded-length</code> gives UTF-8 length; <code>len</code> yields a code point count. Since this is an ASCII string, the two agree.
===Lisp Code===
<syntaxhighlight lang=txrlisp>(defvarl crc-tab
#(#x00000000 #x77073096 #xee0e612c #x990951ba #x076dc419 #x706af48f
#xe963a535 #x9e6495a3 #x0edb8832 #x79dcb8a4 #xe0d5e91e #x97d2d988
#x09b64c2b #x7eb17cbd #xe7b82d07 #x90bf1d91 #x1db71064 #x6ab020f2
#xf3b97148 #x84be41de #x1adad47d #x6ddde4eb #xf4d4b551 #x83d385c7
#x136c9856 #x646ba8c0 #xfd62f97a #x8a65c9ec #x14015c4f #x63066cd9
#xfa0f3d63 #x8d080df5 #x3b6e20c8 #x4c69105e #xd56041e4 #xa2677172
#x3c03e4d1 #x4b04d447 #xd20d85fd #xa50ab56b #x35b5a8fa #x42b2986c
#xdbbbc9d6 #xacbcf940 #x32d86ce3 #x45df5c75 #xdcd60dcf #xabd13d59
#x26d930ac #x51de003a #xc8d75180 #xbfd06116 #x21b4f4b5 #x56b3c423
#xcfba9599 #xb8bda50f #x2802b89e #x5f058808 #xc60cd9b2 #xb10be924
#x2f6f7c87 #x58684c11 #xc1611dab #xb6662d3d #x76dc4190 #x01db7106
#x98d220bc #xefd5102a #x71b18589 #x06b6b51f #x9fbfe4a5 #xe8b8d433
#x7807c9a2 #x0f00f934 #x9609a88e #xe10e9818 #x7f6a0dbb #x086d3d2d
#x91646c97 #xe6635c01 #x6b6b51f4 #x1c6c6162 #x856530d8 #xf262004e
#x6c0695ed #x1b01a57b #x8208f4c1 #xf50fc457 #x65b0d9c6 #x12b7e950
#x8bbeb8ea #xfcb9887c #x62dd1ddf #x15da2d49 #x8cd37cf3 #xfbd44c65
#x4db26158 #x3ab551ce #xa3bc0074 #xd4bb30e2 #x4adfa541 #x3dd895d7
#xa4d1c46d #xd3d6f4fb #x4369e96a #x346ed9fc #xad678846 #xda60b8d0
#x44042d73 #x33031de5 #xaa0a4c5f #xdd0d7cc9 #x5005713c #x270241aa
#xbe0b1010 #xc90c2086 #x5768b525 #x206f85b3 #xb966d409 #xce61e49f
#x5edef90e #x29d9c998 #xb0d09822 #xc7d7a8b4 #x59b33d17 #x2eb40d81
#xb7bd5c3b #xc0ba6cad #xedb88320 #x9abfb3b6 #x03b6e20c #x74b1d29a
#xead54739 #x9dd277af #x04db2615 #x73dc1683 #xe3630b12 #x94643b84
#x0d6d6a3e #x7a6a5aa8 #xe40ecf0b #x9309ff9d #x0a00ae27 #x7d079eb1
#xf00f9344 #x8708a3d2 #x1e01f268 #x6906c2fe #xf762575d #x806567cb
#x196c3671 #x6e6b06e7 #xfed41b76 #x89d32be0 #x10da7a5a #x67dd4acc
#xf9b9df6f #x8ebeeff9 #x17b7be43 #x60b08ed5 #xd6d6a3e8 #xa1d1937e
#x38d8c2c4 #x4fdff252 #xd1bb67f1 #xa6bc5767 #x3fb506dd #x48b2364b
#xd80d2bda #xaf0a1b4c #x36034af6 #x41047a60 #xdf60efc3 #xa867df55
#x316e8eef #x4669be79 #xcb61b38c #xbc66831a #x256fd2a0 #x5268e236
#xcc0c7795 #xbb0b4703 #x220216b9 #x5505262f #xc5ba3bbe #xb2bd0b28
#x2bb45a92 #x5cb36a04 #xc2d7ffa7 #xb5d0cf31 #x2cd99e8b #x5bdeae1d
#x9b64c2b0 #xec63f226 #x756aa39c #x026d930a #x9c0906a9 #xeb0e363f
#x72076785 #x05005713 #x95bf4a82 #xe2b87a14 #x7bb12bae #x0cb61b38
#x92d28e9b #xe5d5be0d #x7cdcefb7 #x0bdbdf21 #x86d3d2d4 #xf1d4e242
#x68ddb3f8 #x1fda836e #x81be16cd #xf6b9265b #x6fb077e1 #x18b74777
#x88085ae6 #xff0f6a70 #x66063bca #x11010b5c #x8f659eff #xf862ae69
#x616bffd3 #x166ccf45 #xa00ae278 #xd70dd2ee #x4e048354 #x3903b3c2
#xa7672661 #xd06016f7 #x4969474d #x3e6e77db #xaed16a4a #xd9d65adc
#x40df0b66 #x37d83bf0 #xa9bcae53 #xdebb9ec5 #x47b2cf7f #x30b5ffe9
#xbdbdf21c #xcabac28a #x53b39330 #x24b4a3a6 #xbad03605 #xcdd70693
#x54de5729 #x23d967bf #xb3667a2e #xc4614ab8 #x5d681b02 #x2a6f2b94
#xb40bbe37 #xc30c8ea1 #x5a05df1b #x2d02ef8d))

(defun crc32 (buf)
(let ((crc #xffffffff)
(l (len buf)))
(each ((i 0..l))
(set crc (logxor [crc-tab (logand (logxor crc [buf i]) #xff)]
(ash crc -8))))
(logxor crc #xffffffff)))</syntaxhighlight>

{{out}}
<pre>$ ./txr -i crc.tl
warning: (crc.tl:46) defun: redefining crc32, which is a built-in defun
1> (crc32 (buf-str "The quick brown fox jumps over the lazy dog"))
1095738169</pre>


=={{header|Vala}}==
=={{header|Vala}}==
===Library===
===Library===
<lang vala>using ZLib.Utility;
<syntaxhighlight lang=vala>using ZLib.Utility;


void main() {
void main() {
var str = (uint8[])"The quick brown fox jumps over the lazy dog".to_utf8();
var str = (uint8[])"The quick brown fox jumps over the lazy dog".to_utf8();
stdout.printf("%lx\n", crc32(0, str));
stdout.printf("%lx\n", crc32(0, str));
}</lang>
}</syntaxhighlight>
{{out}}
{{out}}
<pre>
<pre>
Line 2,221: Line 2,801:
</pre>
</pre>
===Implementation===
===Implementation===
<lang vala>public class Crc32
<syntaxhighlight lang=vala>public class Crc32
{
{
private const uint32 s_generator = 0xedb88320u;
private const uint32 s_generator = 0xedb88320u;
Line 2,257: Line 2,837:
var crc32 = new Crc32();
var crc32 = new Crc32();
stdout.printf("%x\n", crc32.get("The quick brown fox jumps over the lazy dog"));
stdout.printf("%x\n", crc32.get("The quick brown fox jumps over the lazy dog"));
}</lang>
}</syntaxhighlight>


{{out}}
{{out}}
Line 2,265: Line 2,845:


=={{header|VAX Assembly}}==
=={{header|VAX Assembly}}==
<lang VAX Assembly> EDB88320 0000 1 poly: .long ^xedb88320 ;crc32
<syntaxhighlight lang=VAX Assembly> EDB88320 0000 1 poly: .long ^xedb88320 ;crc32
00000044 0004 2 table: .blkl 16
00000044 0004 2 table: .blkl 16
0044 3
0044 3
Line 2,288: Line 2,868:
67 6F 64 20 79 7A 61 00BC
67 6F 64 20 79 7A 61 00BC
0000002B 00C3 18 len = .-msg
0000002B 00C3 18 len = .-msg
00C3 19 .end crc</lang>
00C3 19 .end crc</syntaxhighlight>

=={{header|VBScript}}==
VBScript does'nt have bit rotation instructions and then bit to bit logic converts the default Double values to SIGNED 32 bit integers and back. A table driven implementation is required to speed things up. The code generates the table on the fly.
<syntaxhighlight lang=vb>
dim crctbl(255)
const crcc =&hEDB88320

sub gencrctable
for i= 0 to 255
k=i
for j=1 to 8
if k and 1 then
k=(k and &h7fffffff)\2 or (&h40000000 and ((k and &h80000000)<>0))
k=k xor crcc
else
k=(k and &h7fffffff)\2 or (&h40000000 and ((k and &h80000000)<>0))
end if
next ' j
crctbl(i)=k
next
end sub
function crc32 (buf)
dim r,r1,i
r=&hffffffff
for i=1 to len(buf)
r1=(r and &h7fffffff)\&h100 or (&h800000 and (r and &h80000000)<>0)
r=r1 xor crctbl((asc(mid(buf,i,1))xor r) and 255)
next
crc32=r xor &hffffffff
end function

'414FA339
gencrctable
wscript.stdout.writeline hex(crc32("The quick brown fox jumps over the lazy dog"))
</syntaxhighlight>
Output
<pre>
414FA339
</pre>


=={{header|Visual Basic}}==
=={{header|Visual Basic}}==
Line 2,298: Line 2,919:
{{libheader|Win32}}
{{libheader|Win32}}
Not an ideal task for Visual Basic because the language lacks bit shifting operators (which can of course be emulated, but that's slow). Then again, since the only platform supported by VB is Microsoft Windows (32 Bit Subsystem), we can let the Windows API do the work for us. RtlComputeCrc32() was available since Windows XP and is still present in Windows 10.
Not an ideal task for Visual Basic because the language lacks bit shifting operators (which can of course be emulated, but that's slow). Then again, since the only platform supported by VB is Microsoft Windows (32 Bit Subsystem), we can let the Windows API do the work for us. RtlComputeCrc32() was available since Windows XP and is still present in Windows 10.
<lang vb>Option Explicit
<syntaxhighlight lang=vb>Option Explicit
Declare Function RtlComputeCrc32 Lib "ntdll.dll" _
Declare Function RtlComputeCrc32 Lib "ntdll.dll" _
(ByVal dwInitial As Long, pData As Any, ByVal iLen As Long) As Long
(ByVal dwInitial As Long, pData As Any, ByVal iLen As Long) As Long
Line 2,312: Line 2,933:
Debug.Assert l = &H414FA339
Debug.Assert l = &H414FA339


End Sub</lang>
End Sub</syntaxhighlight>


=={{header|Visual Basic .NET}}==
=={{header|Visual Basic .NET}}==
Allows the resumption of calculations, useful for processing a large file with a series of buffer reads.
Allows the resumption of calculations, useful for processing a large file with a series of buffer reads.
<lang vbnet>Public Class Crc32
<syntaxhighlight lang=vbnet>Public Class Crc32


' Table for pre-calculated values.
' Table for pre-calculated values.
Line 2,344: Line 2,965:
End Function
End Function


End Class</lang>
End Class</syntaxhighlight>
Test:
Test:
<lang vbnet> ' Returns a Byte Array from a string of ASCII characters.
<syntaxhighlight lang=vbnet> ' Returns a Byte Array from a string of ASCII characters.
Function Str2BA(Str As String) As Byte()
Function Str2BA(Str As String) As Byte()
Return System.Text.Encoding.ASCII.GetBytes(Str)
Return System.Text.Encoding.ASCII.GetBytes(Str)
Line 2,368: Line 2,989:
Crc32.cs(Str2BA(Mid(Str, 1, 20)))
Crc32.cs(Str2BA(Mid(Str, 1, 20)))
Debug.Print("Crc32 = " & HexF(Crc32.cs(Str2BA(Mid(Str, 21)), False), 8))
Debug.Print("Crc32 = " & HexF(Crc32.cs(Str2BA(Mid(Str, 21)), False), 8))
End Sub</lang>
End Sub</syntaxhighlight>
Output:
Output:
<lang>Input = "The quick brown fox jumps over the lazy dog"
<syntaxhighlight lang=text>Input = "The quick brown fox jumps over the lazy dog"
Crc32 = 414FA339
Crc32 = 414FA339
Crc32 = 414FA339</lang>
Crc32 = 414FA339</syntaxhighlight>

=={{header|V (Vlang)}}==
<syntaxhighlight lang="v (vlang)">import hash.crc32

fn main() {
text := "The quick brown fox jumps over the lazy dog"
result := crc32.sum(text.bytes())
println(result.hex())
}
</syntaxhighlight>

{{out}}
<pre>
414fa339
</pre>


=={{header|Wren}}==
=={{header|Wren}}==
{{trans|Go}}
{{trans|Go}}
{{libheader|Wren-fmt}}
<lang ecmascript>var toHex = Fn.new { |n|
<syntaxhighlight lang="wren">import "./fmt" for Conv
var digits = "0123456789abcdef"
if (n == 0) return "0"
var neg = false
if (n < 0) neg = true
var hex = ""
while (n > 0) {
hex = hex + "%(digits[n%16])"
n = (n/16).floor
}
return (neg) ? "-" : "" + hex[-1 .. 0]
}


class CRC32 {
class CRC32 {
Line 2,418: Line 3,044:
CRC32.init()
CRC32.init()
var crc = CRC32.compute("The quick brown fox jumps over the lazy dog")
var crc = CRC32.compute("The quick brown fox jumps over the lazy dog")
System.print(toHex.call(crc))</lang>
System.print(Conv.hex(crc))</syntaxhighlight>


{{out}}
{{out}}
Line 2,426: Line 3,052:


=={{header|XPL0}}==
=={{header|XPL0}}==
<lang XPL0>code HexOut=27; \intrinsic routine
<syntaxhighlight lang=XPL0>code HexOut=27; \intrinsic routine
string 0; \use zero-terminated strings
string 0; \use zero-terminated strings


Line 2,444: Line 3,070:
];
];


HexOut(0, CRC32("The quick brown fox jumps over the lazy dog", 43))</lang>
HexOut(0, CRC32("The quick brown fox jumps over the lazy dog", 43))</syntaxhighlight>


{{out}}
{{out}}
Line 2,453: Line 3,079:
=={{header|zkl}}==
=={{header|zkl}}==
Using zlib:
Using zlib:
<lang zkl>var [const] ZLib=Import("zeelib");
<syntaxhighlight lang=zkl>var [const] ZLib=Import("zeelib");
ZLib.calcCRC32(Data(Void,"The quick brown fox jumps over the lazy dog"));
ZLib.calcCRC32(Data(Void,"The quick brown fox jumps over the lazy dog"));
//-->0x414fa339</lang>
//-->0x414fa339</syntaxhighlight>

=={{header|Zig}}==
<syntaxhighlight lang="zig">const std = @import("std");
const Crc32Ieee = std.hash.Crc32;

pub fn main() !void {
var res: u32 = Crc32Ieee.hash("The quick brown fox jumps over the lazy dog");
std.debug.print("{x}\n", .{res});
}
</syntaxhighlight>

{{out}}
<pre>
414fa339
</pre>

Latest revision as of 10:00, 17 March 2024

Task
CRC-32
You are encouraged to solve this task according to the task description, using any language you may know.


Task

Demonstrate a method of deriving the Cyclic Redundancy Check from within the language.


The result should be in accordance with ISO 3309, ITU-T V.42, Gzip and PNG.

Algorithms are described on Computation of CRC in Wikipedia. This variant of CRC-32 uses LSB-first order, sets the initial CRC to FFFFFFFF16, and complements the final CRC.

For the purpose of this task, generate a CRC-32 checksum for the ASCII encoded string:

The quick brown fox jumps over the lazy dog



11l

Translation of: C
V crc_table = [0] * 256
L(i) 256
   UInt32 rem = i
   L 8
      I rem [&] 1 != 0
         rem >>= 1
         rem (+)= EDB8'8320
      E
         rem >>= 1
   crc_table[i] = rem

F crc32(buf, =crc = UInt32(0))
   crc = ~crc
   L(k) buf
      crc = (crc >> 8) (+) :crc_table[(crc [&] F'F) (+) k.code]
   R ~crc

print(hex(crc32(‘The quick brown fox jumps over the lazy dog’)))
Output:
414FA339

6502 Assembly

PRHEX	EQU  $FDDA ; <= REPLACE THIS WITH THE PRHEX ROUTINE FOR YOUR MACHINE

string	EQU  $EC
length	EQU  $EE
crc0	EQU  $FA
crc1	EQU  $FB
crc2	EQU  $FC
crc3	EQU  $FD
table0	EQU  $9200
table1	EQU  $9300
table2	EQU  $9400
table3	EQU  $9500
	ORG  $9114
	LDA #<text
	STA  string
	LDA #>text
	STA  string+1
	LDA #$2b ; length of text
	STA  length
	LDA #$00
	STA  length+1
	STA  crc0
	STA  crc1
	STA  crc2
	STA  crc3
	JSR  crc32
	LDA  crc3
	JSR  PRHEX
	LDA  crc2
	JSR  PRHEX
	LDA  crc1
	JSR  PRHEX
	LDA  crc0
	JMP  PRHEX
text
	ASC 'The quick brown fox jumps over the lazy dog'
	; ORG  $916E
crc32
	JSR  start
	LDY  string
	STX  string
loop
	LDA length
	BNE no_borrow
	LDA length+1
	BEQ ones_complement
	DEC length+1
no_borrow
	DEC length
	LDA (string),Y
	EOR  crc0
	TAX
	LDA  table0,X
	EOR  crc1
	STA  crc0
	LDA  table1,X
	EOR  crc2
	STA  crc1
	LDA  table2,X
	EOR  crc3
	STA  crc2
	LDA  table3,X
	STA  crc3
	INY
	BNE  loop
	INC  string+1
	BNE  loop
start
have_table
	LDX #$00
	BNE  loop4 ; LDX #$04 BNE ones_complement
loop256
	LDA #$00
	STA  table3,X
	STA  table2,X
	STA  table1,X
	TXA
	STA  table0,X
	LDY #$08
loop8
	LSR  table3,X
	ROR  table2,X
	ROR  table1,X
	ROR  table0,X
	BCC  no_xor
	LDA  table3,X
	EOR #$ED
	STA  table3,X
	LDA  table2,X
	EOR #$B8
	STA  table2,X
	LDA  table1,X
	EOR #$83
	STA  table1,X
	LDA  table0,X
	EOR #$20
	STA  table0,X
no_xor
	DEY
	BNE  loop8
	INX
	BNE  loop256
ones_complement
	LDX #$04
	STX  have_table+1 ; self-modify
loop4
	DEX
	LDA  crc0,X
	EOR #$FF
	STA  crc0,X
	TXA
	BNE loop4
	RTS

Ada

Works with: GNAT
with Ada.Text_IO; use Ada.Text_IO;
with GNAT.CRC32; use GNAT.CRC32;
with Interfaces; use Interfaces;
procedure TestCRC is
   package IIO is new Ada.Text_IO.Modular_IO (Unsigned_32);
   crc : CRC32;
   num : Unsigned_32;
   str : String := "The quick brown fox jumps over the lazy dog";
begin
   Initialize (crc);
   Update (crc, str);
   num := Get_Value (crc);
   IIO.Put (num, Base => 16); New_Line;
end TestCRC;
Output:
16#414FA339#

Arturo

print crc "The quick brown fox jumps over the lazy dog"
Output:
414FA339

ALGOL 68

[0:255]BITS crc_table;
BOOL crc_table_computed := FALSE;

PROC make_crc_table = VOID:
   BEGIN 
      INT n, k;
      FOR n FROM 0 TO 255 DO 
         BITS c := BIN n;
         FOR k TO 8 DO 
            c := IF 32 ELEM c THEN 
                    16redb88320 XOR (c SHR 1)
                 ELSE
                    c SHR 1
		 FI
	 OD;
	 crc_table[n] := c
      OD;
      crc_table_computed := TRUE
   END;

PROC update_crc = (BITS crc, STRING buf) BITS:
   BEGIN 
      BITS c := crc XOR 16rffffffff;
      INT n;

      IF NOT crc_table_computed THEN make_crc_table FI;
      FOR n TO UPB buf DO 
         c := crc_table[ABS ((c XOR BIN ABS buf[n]) AND 16rff)] XOR (c SHR 8)
      OD ;
      c XOR 16rffffffff
   END;

 PROC hex = (BITS x) STRING :
   BEGIN
      PROC hexdig = (BITS x) CHAR: REPR (IF ABS x ≤ 9 THEN ABS x + ABS "0"
                                         ELSE ABS x - 10 + ABS "a"
					 FI);
      STRING h := "";
      IF x = 16r0 THEN
	 h := "0"
      ELSE
	 BITS n := x;
	 WHILE h := hexdig (n AND 16rf) + h; n ≠ 16r0 DO
	    n := n SHR 4
	 OD
      FI;
      h
   END;

PROC crc = (STRING buf) BITS:
   update_crc(16r0, buf);

STRING s = "The quick brown fox jumps over the lazy dog";
print(("CRC32 OF ", s, " is: ", hex (crc (s)), newline))
Output:
CRC32 OF The quick brown fox jumps over the lazy dog is: 0414fa339

Applesoft BASIC

Implementation using Binary ASCII

 0 DIM D$(1111):D$(0)="0":D$(1)="1":D$(10)="2":D$(11)="3":D$(100)="4":D$(101)="5":D$(110)="6":D$(111)="7":D$(1000)="8":D$(1001)="9":D$(1010)="A":D$(1011)="B":D$(1100)="C":D$(1101)="D":D$(1110)="E":D$(1111)="F"
 1 Z$ =  CHR$ (8) +  CHR$ (8) +  CHR$ (8) +  CHR$ (8) +  CHR$ (8) +  CHR$ (8) +  CHR$ (8) +  CHR$ (8) +  CHR$ (8) +  CHR$ (8)
 100 C$ = "00000000000000000000000000000000"
 110 S$ = "The quick brown fox jumps over the lazy dog"
 120  GOSUB 200"CRC32
 130  PRINT D$( VAL ( MID$ (C$,1,4)))D$( VAL ( MID$ (C$,5,4)))D$( VAL ( MID$ (C$,9,4)))D$( VAL ( MID$ (C$,13,4)))D$( VAL ( MID$ (C$,17,4)))D$( VAL ( MID$ (C$,21,4)))D$( VAL ( MID$ (C$,25,4)))D$( VAL ( MID$ (C$,29,4)))"  ";
 140  END 
 200  IF  LEN (S$) = 0 THEN  RETURN 
 210  GOSUB 280"XOR #$FFFFFFFF
 220  FOR I = 1 TO  LEN (S$)
 230 R$ = "00000000" +  MID$ (C$,1,24)
 235  PRINT D$( VAL ( MID$ (C$,1,4)))D$( VAL ( MID$ (C$,5,4)))D$( VAL ( MID$ (C$,9,4)))D$( VAL ( MID$ (C$,13,4)));
 236  PRINT D$( VAL ( MID$ (C$,17,4)))D$( VAL ( MID$ (C$,21,4)))D$( VAL ( MID$ (C$,25,4)))D$( VAL ( MID$ (C$,29,4)))" " MID$ (S$,I,1)Z$;
 240 C =  ASC ( MID$ (S$,I,1)):O$ = "": FOR B = 1 TO 8:K =  INT (C / 2):O$ =  STR$ (C - K * 2) + O$:C = K: NEXT B
 250 A = ( MID$ (C$,25,1) <  >  MID$ (O$,1,1)) * 128 + ( MID$ (C$,26,1) <  >  MID$ (O$,2,1)) * 64 + ( MID$ (C$,27,1) <  >  MID$ (O$,3,1)) * 32 + ( MID$ (C$,28,1) <  >  MID$ (O$,4,1)) * 16
 251 A = ( MID$ (C$,29,1) <  >  MID$ (O$,5,1)) * 8 + ( MID$ (C$,30,1) <  >  MID$ (O$,6,1)) * 4 + ( MID$ (C$,31,1) <  >  MID$ (O$,7,1)) * 2 + ( MID$ (C$,32,1) <  >  MID$ (O$,8,1)) + A: GOSUB 300
 260 C$ =  STR$ (( MID$ (R$,1,1) <  >  MID$ (T$,1,1))) +  STR$ (( MID$ (R$,2,1) <  >  MID$ (T$,2,1))) +  STR$ (( MID$ (R$,3,1) <  >  MID$ (T$,3,1))) +  STR$ (( MID$ (R$,4,1) <  >  MID$ (T$,4,1)))
 261 C$ = C$ +  STR$ (( MID$ (R$,5,1) <  >  MID$ (T$,5,1))) +  STR$ (( MID$ (R$,6,1) <  >  MID$ (T$,6,1))) +  STR$ (( MID$ (R$,7,1) <  >  MID$ (T$,7,1))) +  STR$ (( MID$ (R$,8,1) <  >  MID$ (T$,8,1)))
 262 C$ = C$ +  STR$ (( MID$ (R$,9,1) <  >  MID$ (T$,9,1))) +  STR$ (( MID$ (R$,10,1) <  >  MID$ (T$,10,1))) +  STR$ (( MID$ (R$,11,1) <  >  MID$ (T$,11,1))) +  STR$ (( MID$ (R$,12,1) <  >  MID$ (T$,12,1)))
 263 C$ = C$ +  STR$ (( MID$ (R$,13,1) <  >  MID$ (T$,13,1))) +  STR$ (( MID$ (R$,14,1) <  >  MID$ (T$,14,1))) +  STR$ (( MID$ (R$,15,1) <  >  MID$ (T$,15,1))) +  STR$ (( MID$ (R$,16,1) <  >  MID$ (T$,16,1)))
 264 C$ = C$ +  STR$ (( MID$ (R$,17,1) <  >  MID$ (T$,17,1))) +  STR$ (( MID$ (R$,18,1) <  >  MID$ (T$,18,1))) +  STR$ (( MID$ (R$,19,1) <  >  MID$ (T$,19,1))) +  STR$ (( MID$ (R$,20,1) <  >  MID$ (T$,20,1)))
 265 C$ = C$ +  STR$ (( MID$ (R$,21,1) <  >  MID$ (T$,21,1))) +  STR$ (( MID$ (R$,22,1) <  >  MID$ (T$,22,1))) +  STR$ (( MID$ (R$,23,1) <  >  MID$ (T$,23,1))) +  STR$ (( MID$ (R$,24,1) <  >  MID$ (T$,24,1)))
 266 C$ = C$ +  STR$ (( MID$ (R$,25,1) <  >  MID$ (T$,25,1))) +  STR$ (( MID$ (R$,26,1) <  >  MID$ (T$,26,1))) +  STR$ (( MID$ (R$,27,1) <  >  MID$ (T$,27,1))) +  STR$ (( MID$ (R$,28,1) <  >  MID$ (T$,28,1)))
 267 C$ = C$ +  STR$ (( MID$ (R$,29,1) <  >  MID$ (T$,29,1))) +  STR$ (( MID$ (R$,30,1) <  >  MID$ (T$,30,1))) +  STR$ (( MID$ (R$,31,1) <  >  MID$ (T$,31,1))) +  STR$ (( MID$ (R$,32,1) <  >  MID$ (T$,32,1)))
 270  NEXT I
 280 B$ = "": FOR B = 1 TO 32:B$ = B$ +  STR$ (( MID$ (C$,B,1) <  > "1")): NEXT B:C$ = B$
 290  RETURN 
 300  IF  NOT T THEN  DIM T$(255): FOR T = 0 TO 38: READ J: READ T$(J): NEXT T
 310  IF  LEN (T$(A)) THEN T$ = T$(A): RETURN 
 320 R = A:T$ = "": FOR B = 1 TO 8:N =  INT (R / 2):T$ =  MID$ ("01",R - N * 2 + 1,1) + T$:R = N: NEXT B:T$ = "000000000000000000000000" + T$
 330  FOR J = 0 TO 7
 340 X =  VAL ( MID$ (T$,32,1))
 350 T$ = "0" +  MID$ (T$,1,31)
 360  IF X THEN B$ = "": FOR B = 1 TO 32:B$ = B$ +  MID$ ("01",( MID$ (T$,B,1) <  >  MID$ ("11101101101110001000001100100000",B,1)) + 1,1): NEXT B:T$ = B$
 370  NEXT J
 380 T$(A) = T$:T = T + 1
 390  RETURN 
 600  DATA171,01000001000001000111101001100000
 610  DATA247,00100011110110010110011110111111
 620  DATA95,11111011110101000100110001100101
 630  DATA217,11111111000011110110101001110000
 640  DATA213,11110110101110010010011001011011
 650  DATA179,01010010011010001110001000110110
 660  DATA141,10010011000010011111111110011101
 670  DATA90,10001011101111101011100011101010
 680  DATA224,10100000000010101110001001111000
 690  DATA187,01011100101100110110101000000100
 700  DATA169,10101111000010100001101101001100
 710  DATA60,00101111011011110111110010000111
 720  DATA128,11101101101110001000001100100000
 730  DATA36,00111100000000111110010011010001
 740  DATA235,00110111110110000011101111110000
 750  DATA229,11010000011000000001011011110111
 760  DATA77,00001000011011010011110100101101
 770  DATA167,01001000101100100011011001001011
 780  DATA1,01110111000001110011000010010110
 790  DATA119,11001110011000011110010010011111
 800  DATA96,01001101101100100110000101011000
 810  DATA158,00010111101101111011111001000011
 820  DATA68,01110001101100011000010110001001
 830  DATA56,00101000000000101011100010011110
 840  DATA193,11101100011000111111001000100110
 850  DATA87,11110101000011111100010001010111
 860  DATA160,11010110110101101010001111101000
 870  DATA2,11101110000011100110000100101100
 880  DATA30,11111010000011110011110101100011
 890  DATA7,10011110011001001001010110100011
 900  DATA26,11111101011000101111100101111010
 910  DATA85,00011011000000011010010101111011
 920  DATA15,10010000101111110001110110010001
 930  DATA201,11100010101110000111101000010100
 940  DATA188,11000010110101111111111110100111
 950  DATA0,00000000000000000000000000000000
 960  DATA238,01000111101100101100111101111111
 970  DATA181,10111011000010110100011100000011
 980  DATA114,10111110000010110001000000010000

Using 6502 Assembly

 0  HIMEM: 37230
8A=37229:P$=" 'Q$L.L%BP#%GKSFGFB1LEZ*=!4E[-Z=!6EW-[=!TEX-W=!U-XHPR?MPN<!PJ)!7!U7!T7!607!49&^!U+!T+!6+!43 =!UIM7!U=!TI87!T=!6IC7!6=!4I 7!4/POAP;<D2(Q>5ZIYUZ0PV@"
9FORI=1TOLEN(P$):B$=MID$("D2A0--A6Q4Q5A8Q7Q8Q9R0M6--N3N4N6N8R7O2O4O6S1O7P7S4Q0--S7Q2S9U2X0J6X2X8N1A4G9T8X9U0H3H4Y0X6X7U6U7U8O5V0L5O8O9Y6Z2Z3Z5Z0Z1----J4",(ASC(MID$(P$,I))-32)*2+1,2):POKEA+I,(ASC(MID$(B$,1))-65)*10+ASC(MID$(B$,2))-48:NEXT
 100 S$ = "THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG"
 110  FOR I = 2 TO  LEN (S$)
 120 C =  ASC ( MID$ (S$,I,1))
 130 C$ =  CHR$ (C + 32 * (C >  =  ASC ("A") AND C <  =  ASC ("Z")))
 140 S$ =  LEFT$ (S$,I - 1) + C$ +  MID$ (S$,I + 1, LEN (S$) - I)
 150  NEXT 
 155  PRINT  MID$ (S$,1,0 *  FRE (0));
 160  POKE 236, PEEK (131)
 170  POKE 237, PEEK (132)
 180 A =  PEEK (236) +  PEEK (237) * 256
 190  POKE 236, PEEK (A + 1)
 200  POKE 237, PEEK (A + 2)
 210  POKE 238, PEEK (A)
 220  POKE 239,0
 230  FOR I = 250 TO 253
 240  POKE I,0
 250  NEXT
 260  CALL 37230
 270  FOR I = 253 TO 250 STEP  - 1
 280 B =  PEEK (I)
 290  FOR J = 0 TO 1
 300  PRINT  MID$ ("0123456789ABCDEF",B / 16 + 1,1);
 310 B = (B -  INT (B / 16) * 16) * 16
 320  NEXT J,I

AutoHotkey

DllCall / WinAPI

CRC32(str, enc = "UTF-8")
{
    l := (enc = "CP1200" || enc = "UTF-16") ? 2 : 1, s := (StrPut(str, enc) - 1) * l
    VarSetCapacity(b, s, 0) && StrPut(str, &b, floor(s / l), enc)
    CRC32 := DllCall("ntdll.dll\RtlComputeCrc32", "UInt", 0, "Ptr", &b, "UInt", s)
    return Format("{:#x}", CRC32)
}

MsgBox % CRC32("The quick brown fox jumps over the lazy dog")
Output:
0x414fa339

Implementation

CRC32(str)
{
    static table := []
    loop 256 {
        crc := A_Index - 1
        loop 8
            crc := (crc & 1) ? (crc >> 1) ^ 0xEDB88320 : (crc >> 1)
        table[A_Index - 1] := crc
    }
    crc := ~0
    loop, parse, str
        crc := table[(crc & 0xFF) ^ Asc(A_LoopField)] ^ (crc >> 8)
    return Format("{:#x}", ~crc)
}

MsgBox % CRC32("The quick brown fox jumps over the lazy dog")
Output:
0x414fa339

Bait

import hash.crc32

fun main() {
	text := 'The quick brown fox jumps over the lazy dog'
	sum := crc32.checksum(text.bytes())
	println(sum.hex())
}
Output:
414fa339

C

Library

Using zlib's crc32:

#include <stdio.h>
#include <string.h>
#include <zlib.h>
 
int main()
{
	const char *s = "The quick brown fox jumps over the lazy dog";
	printf("%lX\n", crc32(0, (const void*)s, strlen(s)));

	return 0;
}

Implementation

This code is a translation from Ruby, with an adjustment to use 32-bit integers. This code happens to resemble the examples from RFC 1952 section 8 and from PNG annex D, because those examples use an identical table.

#include <inttypes.h>
#include <stdio.h>
#include <string.h>

uint32_t
rc_crc32(uint32_t crc, const char *buf, size_t len)
{
	static uint32_t table[256];
	static int have_table = 0;
	uint32_t rem;
	uint8_t octet;
	int i, j;
	const char *p, *q;

	/* This check is not thread safe; there is no mutex. */
	if (have_table == 0) {
		/* Calculate CRC table. */
		for (i = 0; i < 256; i++) {
			rem = i;  /* remainder from polynomial division */
			for (j = 0; j < 8; j++) {
				if (rem & 1) {
					rem >>= 1;
					rem ^= 0xedb88320;
				} else
					rem >>= 1;
			}
			table[i] = rem;
		}
		have_table = 1;
	}

	crc = ~crc;
	q = buf + len;
	for (p = buf; p < q; p++) {
		octet = *p;  /* Cast to unsigned octet. */
		crc = (crc >> 8) ^ table[(crc & 0xff) ^ octet];
	}
	return ~crc;
}

int
main()
{
	const char *s = "The quick brown fox jumps over the lazy dog";
	printf("%" PRIX32 "\n", rc_crc32(0, s, strlen(s)));
 
	return 0;
}

C#

    /// <summary>
    /// Performs 32-bit reversed cyclic redundancy checks.
    /// </summary>
    public class Crc32
    {
        #region Constants
        /// <summary>
        /// Generator polynomial (modulo 2) for the reversed CRC32 algorithm. 
        /// </summary>
        private const UInt32 s_generator = 0xEDB88320;
        #endregion

        #region Constructors
        /// <summary>
        /// Creates a new instance of the Crc32 class.
        /// </summary>
        public Crc32()
        {
            // Constructs the checksum lookup table. Used to optimize the checksum.
            m_checksumTable = Enumerable.Range(0, 256).Select(i =>
            {
                var tableEntry = (uint)i;
                for (var j = 0; j < 8; ++j)
                {
                    tableEntry = ((tableEntry & 1) != 0)
                        ? (s_generator ^ (tableEntry >> 1)) 
                        : (tableEntry >> 1);
                }
                return tableEntry;
            }).ToArray();
        }
        #endregion

        #region Methods
        /// <summary>
        /// Calculates the checksum of the byte stream.
        /// </summary>
        /// <param name="byteStream">The byte stream to calculate the checksum for.</param>
        /// <returns>A 32-bit reversed checksum.</returns>
        public UInt32 Get<T>(IEnumerable<T> byteStream)
        {
            try
            {
                // Initialize checksumRegister to 0xFFFFFFFF and calculate the checksum.
                return ~byteStream.Aggregate(0xFFFFFFFF, (checksumRegister, currentByte) => 
                          (m_checksumTable[(checksumRegister & 0xFF) ^ Convert.ToByte(currentByte)] ^ (checksumRegister >> 8)));
            }
            catch (FormatException e)
            {
                throw new CrcException("Could not read the stream out as bytes.", e);
            }
            catch (InvalidCastException e)
            {
                throw new CrcException("Could not read the stream out as bytes.", e);
            }
            catch (OverflowException e)
            {
                throw new CrcException("Could not read the stream out as bytes.", e);
            }
        }
        #endregion

        #region Fields
        /// <summary>
        /// Contains a cache of calculated checksum chunks.
        /// </summary>
        private readonly UInt32[] m_checksumTable;

        #endregion
    }

Test:

	var arrayOfBytes = Encoding.ASCII.GetBytes("The quick brown fox jumps over the lazy dog");

	var crc32 = new Crc32();
	Console.WriteLine(crc32.Get(arrayOfBytes).ToString("X"));
Output:

414fa339

C++

#include <array>
#include <ranges>
#include <cstdint>
#include <numeric>
#include <concepts>
#include <algorithm>

// These headers are only needed for main(), to demonstrate.
#include <iomanip>
#include <iostream>
#include <string_view>

inline constexpr auto crc_table = []() {
    std::array<std::uint32_t, 256> retval{};
    std::generate(retval.begin(), retval.end(), 
        [n = std::uint32_t{ 0 }]() mutable {
            auto c = n++;
            for (std::uint8_t k = 0; k < 8; ++k) {
                if (c & 1) c = std::uint32_t{ 0xedb88320 } ^ (c >> 1);
                else c >>= 1;
            }
            return c;
        });
    return retval;
}();


[[nodiscard]] constexpr std::uint32_t crc(const std::ranges::input_range auto& rng)
noexcept requires std::convertible_to<std::ranges::range_value_t<decltype(rng)>, std::uint8_t> {
  return ~std::accumulate(std::ranges::begin(rng), std::ranges::end(rng),
      ~std::uint32_t{ 0 } & std::uint32_t{ 0xff'ff'ff'ffu },
        [](std::uint32_t checksum, std::uint8_t value) 
          { return crc_table[(checksum ^ value) & 0xff] ^ (checksum >> 8); });
}

int main() {
  constexpr std::string_view str = "The quick brown fox jumps over the lazy dog";
  
  std::cout << std::hex << std::setw(8) << std::setfill('0') << crc(str) << '\n';
}
Output:
414fa339
"The quick brown fox jumps over the lazy dog"
(to hex ...)
54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F67 414FA339
[other useful test vectors]
0000000000000000000000000000000000000000000000000000000000000000 190A55AD
FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF FF6CAB0B
000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F 91267E8A
Library: boost
#include <boost\crc.hpp>
#include <string>
#include <iostream>

int main()
{
    std::string str( "The quick brown fox jumps over the lazy dog" );
    boost::crc_32_type  crc;
    crc.process_bytes( str.data(), str.size() );

    std::cout << "Checksum: " << std::hex << crc.checksum() << std::endl;
    return 0;
}
Output:
Checksum: 414fa339

Clojure

Translation of: Java
(let [crc (new java.util.zip.CRC32)
      str "The quick brown fox jumps over the lazy dog"]
  (. crc update (. str getBytes))
  (printf "CRC-32('%s') = %s\n" str (Long/toHexString (. crc getValue))))
Output:
CRC-32('The quick brown fox jumps over the lazy dog') = 414fa339

COBOL

Works with: GnuCOBOL
Library: zlib
      *> tectonics: cobc -xj crc32-zlib.cob -lz
       identification division.
       program-id. rosetta-crc32.

       environment division.
       configuration section.
       repository.
           function all intrinsic.

       data division.
       working-storage section.
       01 crc32-initial        usage binary-c-long.
       01 crc32-result         usage binary-c-long unsigned.
       01 crc32-input.
          05 value "The quick brown fox jumps over the lazy dog".
       01 crc32-hex            usage pointer.

       procedure division.
       crc32-main.

      *> libz crc32
       call "crc32" using
           by value crc32-initial
           by reference crc32-input
           by value length(crc32-input)
           returning crc32-result
           on exception
               display "error: no crc32 zlib linkage" upon syserr
       end-call
       call "printf" using "checksum: %lx" & x"0a" by value crc32-result

      *> GnuCOBOL pointers are displayed in hex by default
       set crc32-hex up by crc32-result
       display 'crc32 of "' crc32-input '" is ' crc32-hex

       goback.
       end program rosetta-crc32.
Output:
prompt$ cobc -xj crc32-zlib.cob -lz
checksum: 414fa339
crc32 of "The quick brown fox jumps over the lazy dog" is 0x00000000414fa339

CoffeeScript

Allows the specification of the initial CRC value, which defaults to 0xFFFFFFFF. Optimized for speed and terseness (then readability/indentation).

crc32 = do ->
  table =
    for n in [0..255]
      for [0..7]
        if n & 1
          n = 0xEDB88320 ^ n >>> 1
        else
          n >>>= 1
      n
  (str, crc = -1) ->
    for c in str
      crc = crc >>> 8 ^ table[(crc ^ c.charCodeAt 0) & 255]
    (crc ^ -1) >>> 0

Test:

console.log (crc32 'The quick brown fox jumps over the lazy dog').toString 16

Output:

414fa339

Common Lisp

Library: Ironclad
(ql:quickload :ironclad)
(defun string-to-digest (str digest)
  "Return the specified digest for the ASCII string as a hex string."
  (ironclad:byte-array-to-hex-string 
    (ironclad:digest-sequence digest 
                              (ironclad:ascii-string-to-byte-array str))))

(string-to-digest "The quick brown fox jumps over the lazy dog" :crc32)
Output:
"414fa339"

Component Pascal

BlackBox Component Builder
Require ZLib Subsystem

MODULE BbtComputeCRC32;
IMPORT ZlibCrc32,StdLog;

PROCEDURE Do*;
VAR
	s: ARRAY 128 OF SHORTCHAR;
BEGIN	
	s := "The quick brown fox jumps over the lazy dog";
	StdLog.IntForm(ZlibCrc32.CRC32(0,s,0,LEN(s$)),16,12,'0',TRUE);
	StdLog.Ln;
END Do;
END BbtComputeCRC32.

Execute: ^Q BbtComputeCRC32.Do

Output:
0414FA339%16

Crystal

require "digest/crc32";

p Digest::CRC32.checksum("The quick brown fox jumps over the lazy dog").to_s(16)
Output:
"414fa339"

D

void main() {
    import std.stdio, std.digest.crc;

    "The quick brown fox jumps over the lazy dog"
    .crc32Of.crcHexString.writeln;
}
Output:
414FA339

Delphi

program CalcCRC32;

{$APPTYPE CONSOLE}

uses
  System.SysUtils, System.ZLib;

var
  Data: AnsiString = 'The quick brown fox jumps over the lazy dog';
  CRC: UInt32;

begin
  CRC := crc32(0, @Data[1], Length(Data));
  WriteLn(Format('CRC32 = %8.8X', [CRC]));
end.
Output:
CRC32 = 414FA339

Elixir

defmodule Test do
  def crc32(str) do
    IO.puts :erlang.crc32(str) |> Integer.to_string(16)
  end
end

Test.crc32("The quick brown fox jumps over the lazy dog")
Output:
414FA339

Erlang

Using the built-in crc32 implementation.

-module(crc32).
-export([test/0]).
test() ->
  io:fwrite("~.16#~n",[erlang:crc32(<<"The quick brown fox jumps over the lazy dog">>)]).
Output:
16#414FA339

F#

module Crc32 =
    
    open System
    
    // Generator polynomial (modulo 2) for the reversed CRC32 algorithm.
    let private s_generator = uint32 0xEDB88320
    
    // Generate lookup table 
    let private lutIntermediate input =
        if (input &&& uint32 1) <> uint32 0
        then s_generator ^^^ (input >>> 1)
        else input >>> 1
        
    let private lutEntry input =
        {0..7}
        |> Seq.fold (fun acc x -> lutIntermediate acc) input
        
    let private crc32lut =
        [uint32 0 .. uint32 0xFF]
        |> List.map lutEntry
        
    let crc32byte (register : uint32) (byte : byte) =
        crc32lut.[Convert.ToInt32((register &&& uint32 0xFF) ^^^ Convert.ToUInt32(byte))] ^^^ (register >>> 8)
        
    // CRC32 of a byte array
    let crc32 (input : byte[]) =
        let result = Array.fold crc32byte (uint32 0xFFFFFFFF) input
        ~~~result
        
    // CRC32 from ASCII string
    let crc32OfAscii (inputAscii : string) =
        let bytes = System.Text.Encoding.ASCII.GetBytes(inputAscii)
        crc32 bytes
    
    // Test
    let testString = "The quick brown fox jumps over the lazy dog"
    printfn "ASCII Input: %s" testString
    let result = crc32OfAscii testString
    printfn "CRC32: 0x%x" result
Output:
ASCII Input: The quick brown fox jumps over the lazy dog
CRC32: 0x414fa339

Factor

Like SHA-1#Factor, but with crc32.

IN: scratchpad USING: checksums checksums.crc32 ;
IN: scratchpad "The quick brown fox jumps over the lazy dog" crc32
               checksum-bytes hex-string .
"414fa339"

The implementation is at core/checksums/crc32/crc32.factor.

FBSL

#APPTYPE CONSOLE

PRINT HEX(CHECKSUM("The quick brown fox jumps over the lazy dog"))

PAUSE
Output:
414FA339

Press any key to continue...

Forth

This code can implement other types of CRC by using other polynomial constants: use $8408 for CCITT CRC-16, or $a001 for IBM CRC-16.

: crc/ ( n -- n ) 8 0 do dup 1 rshift swap 1 and if $edb88320 xor then loop ;

: crcfill   256 0 do i crc/ , loop ;

create crctbl crcfill

: crc+ ( crc n -- crc' ) over xor $ff and  cells crctbl + @  swap 8 rshift xor ;

: crcbuf ( crc str len -- crc ) bounds ?do i c@ crc+ loop ;

$ffffffff s" The quick brown fox jumps over the lazy dog" crcbuf $ffffffff xor hex.  bye   \ $414FA339

Fortran

module crc32_m
    use iso_fortran_env
    implicit none
    integer(int32) :: crc_table(0:255)
contains
    subroutine update_crc(a, crc)
        integer :: n, i
        character(*) :: a
        integer(int32) :: crc
        
        crc = not(crc)
        n = len(a)
        do i = 1, n
            crc = ieor(shiftr(crc, 8), crc_table(iand(ieor(crc, iachar(a(i:i))), 255)))
        end do
        crc = not(crc)
    end subroutine
    
    subroutine init_table
        integer :: i, j
        integer(int32) :: k
        
        do i = 0, 255
            k = i
            do j = 1, 8
                if (btest(k, 0)) then
                    k = ieor(shiftr(k, 1), -306674912)
                else
                    k = shiftr(k, 1)
                end if
            end do
            crc_table(i) = k
        end do
    end subroutine
end module

program crc32
    use crc32_m
    implicit none
    integer(int32) :: crc = 0
    character(*), parameter :: s = "The quick brown fox jumps over the lazy dog"
    call init_table
    call update_crc(s, crc)
    print "(Z8)", crc
end program

FreeBASIC

Translation of: C
' version 18-03-2017
' compile with: fbc -s console

Function crc32(buf As String) As UInteger<32>

    Static As UInteger<32> table(256)
    Static As UInteger<32> have_table
    Dim As UInteger<32> crc, k
    Dim As ULong i, j

    If have_table = 0 Then
        For i = 0 To 255
            k = i
            For j = 0 To 7
                If (k And 1) Then
                    k Shr= 1
                    k Xor= &Hedb88320
                Else
                    k Shr= 1
                End If
                table(i) = k
            Next
        Next
        have_table = 1
    End If

    crc = Not crc ' crc = &Hffffffff
    
    For i = 0 To Len(buf) -1
        crc = (crc Shr 8) Xor table((crc And &hff) Xor buf[i])
    Next

    Return Not crc

End Function

' ------=< MAIN >=------

Dim As String l = "The quick brown fox jumps over the lazy dog"
Dim As UInteger<32> crc

Print "input = "; l
print
Print "The CRC-32 checksum = "; Hex(crc32(l), 8)

' empty keyboard buffer
While Inkey <> "" : Wend
Print : Print "hit any key to end program"
Sleep
End
Output:
input = The quick brown fox jumps over the lazy dog

The CRC-32 checksum = 414FA339

Go

Library

package main

import (
    "fmt"
    "hash/crc32"
)

func main() {
    s := []byte("The quick brown fox jumps over the lazy dog")
    result := crc32.ChecksumIEEE(s)
    fmt.Printf("%X\n", result)
}
Output:
414FA339

Implementation

package main

import "fmt"

var table [256]uint32

func init() {
    for i := range table {
        word := uint32(i)
        for j := 0; j < 8; j++ {
            if word&1 == 1 {
                word = (word >> 1) ^ 0xedb88320
            } else {
                word >>= 1
            }
        }
        table[i] = word
    }
}

func crc32(s string) uint32 {
    crc := ^uint32(0)
    for i := 0; i < len(s); i++ {
        crc = table[byte(crc)^s[i]] ^ (crc >> 8)
    }
    return ^crc
}

func main() {
    fmt.Printf("%0x\n", crc32("The quick brown fox jumps over the lazy dog"))
}
Output:
414fa339

Groovy

def crc32(byte[] bytes) {
    new java.util.zip.CRC32().with { update bytes; value }
}

Testing:

assert '414FA339' == sprintf('%04X', crc32('The quick brown fox jumps over the lazy dog'.bytes))

Haskell

Pure Haskell:

import Data.Bits ((.&.), complement, shiftR, xor)
import Data.Word (Word32)
import Numeric (showHex)

crcTable :: Word32 -> Word32
crcTable = (table !!) . fromIntegral
  where
    table = ((!! 8) . iterate xf) <$> [0 .. 255]
    shifted x = shiftR x 1
    xf r
      | r .&. 1 == 1 = xor (shifted r) 0xedb88320
      | otherwise = shifted r

charToWord :: Char -> Word32
charToWord = fromIntegral . fromEnum

calcCrc :: String -> Word32
calcCrc = complement . foldl cf (complement 0)
  where
    cf crc x = xor (shiftR crc 8) (crcTable $ xor (crc .&. 0xff) (charToWord x))

crc32 :: String -> String
crc32 = flip showHex [] . calcCrc

main :: IO ()
main = putStrLn $ crc32 "The quick brown fox jumps over the lazy dog"
Output:
414fa339


Using the zlib C library ( compile with "ghc -lz file.hs"):

import Data.List (genericLength)
import Numeric (showHex)
import Foreign.C

foreign import ccall "zlib.h crc32" zlib_crc32 ::
               CULong -> CString -> CUInt -> CULong

main :: IO ()
main = do
  let s = "The quick brown fox jumps over the lazy dog"
  ptr <- newCString s
  let r = zlib_crc32 0 ptr (genericLength s)
  putStrLn $ showHex r ""
Output:
414fa339

Haxe

using StringTools;

class Main {
  static function main() {
    var data = haxe.io.Bytes.ofString("The quick brown fox jumps over the lazy dog");
    var crc = haxe.crypto.Crc32.make(data);
    Sys.println(crc.hex());
  }
}
Output:
414FA339

Icon and Unicon

There is no library function for this so we implement one. Icon/Unicon binary operations apply to large integers so we need to mask to the desired unsigned word size. This also only applies to full bytes.

link hexcvt,printf

procedure main()
   s := "The quick brown fox jumps over the lazy dog"
   a := "414FA339"
   printf("crc(%i)=%s - implementation is %s\n",
          s,r := crc32(s),if r == a then "correct" else "in error")
end

procedure crc32(s)      #: return crc-32 (ISO 3309, ITU-T V.42, Gzip, PNG) of s
static crcL,mask
initial {
   crcL := list(256)                            # crc table
   p := [0,1,2,4,5,7,8,10,11,12,16,22,23,26]    # polynomial terms 
   mask := 2^32-1                               # word size mask   
   every (poly := 0) := ior(poly,ishift(1,31-p[1 to *p]))
   every c := n := 0 to *crcL-1 do {            # table 
      every 1 to 8 do 
         c := iand(mask, 
                   if iand(c,1) = 1 then
                      ixor(poly,ishift(c,-1)) 
                   else 
                      ishift(c,-1)
                  )
      crcL[n+1] := c
      }
   }
   
   crc := ixor(0,mask)                          # invert bits
   every crc := iand(mask,
                     ixor(crcL[iand(255,ixor(crc,ord(!s)))+1],ishift(crc,-8)))               
   return hexstring(ixor(crc,mask))             # return hexstring
end

hexcvt.icn (provides hex and hexstring) printf.icn (provides formatting)

Output:
crc("The quick brown fox jumps over the lazy dog")=414FA339 - implementation is correct

J

   ((i.32) e. 32 26 23 22 16 12 11 10 8 7 5 4 2 1 0) 128!:3 'The quick brown fox jumps over the lazy dog'
_3199229127

Other possible representations of this result:

   (2^32x)|((i.32) e. 32 26 23 22 16 12 11 10 8 7 5 4 2 1 0) 128!:3 'The quick brown fox jumps over the lazy dog'
1095738169
   require'convert'
   hfd (2^32x)|((i.32) e. 32 26 23 22 16 12 11 10 8 7 5 4 2 1 0) 128!:3 'The quick brown fox jumps over the lazy dog'
414FA339

Java

import java.util.zip.CRC32;
public static void main(String[] args) throws IOException {
    String string = "The quick brown fox jumps over the lazy dog";
    CRC32 crc = new CRC32();
    crc.update(string.getBytes());
    System.out.printf("%x", crc.getValue());
}
Output:
414fa339

JavaScript

(() => {
    'use strict';

    // --------------------- CRC-32 ----------------------

    // crc32 :: String -> Int
    const crc32 = str => {
        // table :: [Int]
        const table = enumFromTo(0)(255).map(
            n => take(9)(
                iterate(
                    x => (
                        x & 1 ? (
                            z => 0xEDB88320 ^ z
                        ) : identity
                    )(x >>> 1)
                )(n)
            )[8]
        );
        return chars(str).reduce(
            (a, c) => (a >>> 8) ^ table[
                (a ^ c.charCodeAt(0)) & 255
            ],
            -1
        ) ^ -1;
    };

    // ---------------------- TEST -----------------------
    // main :: IO ()
    const main = () =>
        showHex(
            crc32('The quick brown fox jumps over the lazy dog')
        );

    // --------------------- GENERIC ---------------------

    // chars :: String -> [Char]
    const chars = s =>
        s.split('');


    // enumFromTo :: Int -> Int -> [Int]
    const enumFromTo = m =>
        n => !isNaN(m) ? (
            Array.from({
                length: 1 + n - m
            }, (_, i) => m + i)
        ) : enumFromTo_(m)(n);


    // identity :: a -> a
    const identity = x =>
        // The identity function.
        x;


    // iterate :: (a -> a) -> a -> Gen [a]
    const iterate = f =>
        // An infinite list of repeated 
        // applications of f to x.
        function* (x) {
            let v = x;
            while (true) {
                yield(v);
                v = f(v);
            }
        };


    // showHex :: Int -> String
    const showHex = n =>
        // Hexadecimal string for a given integer.
        '0x' + n.toString(16);


    // take :: Int -> [a] -> [a]
    // take :: Int -> String -> String
    const take = n =>
        // The first n elements of a list,
        // string of characters, or stream.
        xs => 'GeneratorFunction' !== xs
        .constructor.constructor.name ? (
            xs.slice(0, n)
        ) : [].concat.apply([], Array.from({
            length: n
        }, () => {
            const x = xs.next();
            return x.done ? [] : [x.value];
        }));


    // MAIN -------------
    const result = main();
    return (
        console.log(result),
        result
    );
})();
Output:
0x414fa339

Jsish

From the shell

# Util.crc32('The quick brown fox jumps over the lazy dog').toString(16);
Output:
"414fa339"

Julia

Using the zlib Library

using Libz
println(string(Libz.crc32(UInt8.(b"The quick brown fox jumps over the lazy dog")), base=16))
Output:
414fa339

Source Implementation

Works with: Julia version 0.6
function crc32(crc::Int, str::String)
    table = zeros(UInt32, 256)

    for i in 0:255
        tmp = i
        for j in 0:7
            if tmp & 1 == 1
                tmp >>= 1
                tmp ⊻= 0xedb88320
            else
                tmp >>= 1
            end
        end

        table[i + 1] = tmp
    end

    crc ⊻= 0xffffffff

    for i in UInt32.(collect(str))
        crc = (crc >> 8)  table[(crc & 0xff)  i + 1]
    end

    crc  0xffffffff
end

str = "The quick brown fox jumps over the lazy dog"
crc = crc32(0, str)
assert(crc == 0x414fa339)
println("Message: ", str)
println("Checksum: ", hex(crc))
Output:
Message: The quick brown fox jumps over the lazy dog
Checksum: 414fa339

Kotlin

// version 1.0.6

import java.util.zip.CRC32

fun main(args: Array<String>) {
    val text = "The quick brown fox jumps over the lazy dog"
    val crc = CRC32()
    with (crc) {
        update(text.toByteArray())
        println("The CRC-32 checksum of '$text' = ${"%x".format(value)}")
    }
}
Output:
The CRC-32 checksum of 'The quick brown fox jumps over the lazy dog' = 414fa339

Lingo

Pure Lingo

crcObj = script("CRC").new()

crc32 = crcObj.crc32("The quick brown fox jumps over the lazy dog")

put crc32
-- <ByteArrayObject length = 4 ByteArray = 0x41, 0x4f, 0xa3, 0x39 >

put crc32.toHexString(1, crc32.length)
-- "41 4f a3 39"

Implementation:

--****************************************************************************
-- @desc      CRC-32 Class
-- @file      parent script "CRC"
-- @version   0.1
--****************************************************************************

property _CRC32Table

----------------------------------------
-- @constructor
----------------------------------------
on new me

  -- used for fast CRC32 calculation
  me._CRC32Table = [\
  0, 1996959894, -301047508, -1727442502, 124634137, 1886057615, -379345611, -1637575261, 249268274, 2044508324,\
  -522852066, -1747789432, 162941995, 2125561021, -407360249, -1866523247, 498536548, 1789927666, -205950648,\
  -2067906082, 450548861, 1843258603, -187386543, -2083289657, 325883990, 1684777152, -43845254, -1973040660,\
  335633487, 1661365465, -99664541, -1928851979, 997073096, 1281953886, -715111964, -1570279054, 1006888145,\
  1258607687, -770865667, -1526024853, 901097722, 1119000684, -608450090, -1396901568, 853044451, 1172266101,\
  -589951537, -1412350631, 651767980, 1373503546, -925412992, -1076862698, 565507253, 1454621731, -809855591,\
  -1195530993, 671266974, 1594198024, -972236366, -1324619484, 795835527, 1483230225, -1050600021, -1234817731,\
  1994146192, 31158534, -1731059524, -271249366, 1907459465, 112637215, -1614814043, -390540237, 2013776290,\
  251722036, -1777751922, -519137256, 2137656763, 141376813, -1855689577, -429695999, 1802195444, 476864866,\
  -2056965928, -228458418, 1812370925, 453092731, -2113342271, -183516073, 1706088902, 314042704, -1950435094,\
  -54949764, 1658658271, 366619977, -1932296973, -69972891, 1303535960, 984961486, -1547960204, -725929758,\
  1256170817, 1037604311, -1529756563, -740887301, 1131014506, 879679996, -1385723834, -631195440, 1141124467,\
  855842277, -1442165665, -586318647, 1342533948, 654459306, -1106571248, -921952122, 1466479909, 544179635,\
  -1184443383, -832445281, 1591671054, 702138776, -1328506846, -942167884, 1504918807, 783551873, -1212326853,\
  -1061524307, -306674912, -1698712650, 62317068, 1957810842, -355121351, -1647151185, 81470997, 1943803523,\
  -480048366, -1805370492, 225274430, 2053790376, -468791541, -1828061283, 167816743, 2097651377, -267414716,\
  -2029476910, 503444072, 1762050814, -144550051, -2140837941, 426522225, 1852507879, -19653770, -1982649376,\
  282753626, 1742555852, -105259153, -1900089351, 397917763, 1622183637, -690576408, -1580100738, 953729732,\
  1340076626, -776247311, -1497606297, 1068828381, 1219638859, -670225446, -1358292148, 906185462, 1090812512,\
  -547295293, -1469587627, 829329135, 1181335161, -882789492, -1134132454, 628085408, 1382605366, -871598187,\
  -1156888829, 570562233, 1426400815, -977650754, -1296233688, 733239954, 1555261956, -1026031705, -1244606671,\
  752459403, 1541320221, -1687895376, -328994266, 1969922972, 40735498, -1677130071, -351390145, 1913087877,\
  83908371, -1782625662, -491226604, 2075208622, 213261112, -1831694693, -438977011, 2094854071, 198958881,\
  -2032938284, -237706686, 1759359992, 534414190, -2118248755, -155638181, 1873836001, 414664567, -2012718362,\
  -15766928, 1711684554, 285281116, -1889165569, -127750551, 1634467795, 376229701, -1609899400, -686959890,\
  1308918612, 956543938, -1486412191, -799009033, 1231636301, 1047427035, -1362007478, -640263460, 1088359270,\
  936918000, -1447252397, -558129467, 1202900863, 817233897, -1111625188, -893730166, 1404277552, 615818150,\
  -1160759803, -841546093, 1423857449, 601450431, -1285129682, -1000256840, 1567103746, 711928724, -1274298825,\
  -1022587231, 1510334235, 755167117]
  return me
end

----------------------------------------
-- Calculates CRC-32 checksum of string or bytearray
-- @param {bytearray|string} input
-- @return {bytearray} (4 bytes)
----------------------------------------
on crc32 (me, input)
  if stringP(input) then input = bytearray(input)
  crc = -1
  len = input.length
  repeat with i = 1 to len
    if (crc>0) then bitShift8 = crc/256
    else bitShift8 = bitAnd(crc,2147483647)/256+8388608
    crc = bitXor(bitShift8,me._CRC32Table[bitAnd(bitXor(crc,input[i]),255)+1])
  end repeat
  ba = bytearray()
  ba.endian = #bigEndian
  ba.writeInt32(bitXOr(crc,-1))
  ba.position = 1
  return ba
end

Using an "Xtra" (=binary plugin)

cx = Xtra("Crypto").new()
put cx.cx_crc32_string("The quick brown fox jumps over the lazy dog")
-- "414fa339"

Lua

Using Library

zlib.crc32

local compute=require"zlib".crc32()
local sum=compute("The quick brown fox jumps over the lazy dog")
print(string.format("0x%x", sum))
Output:

0x414fa339

Implementation

function crc32(buf, size)
  local crc = 0xFFFFFFFF
  local table = {}
  local rem, c

  -- calculate CRC-table
  for i = 0, 0xFF do
    rem = i
    for j = 1, 8 do
      if (rem & 1 == 1) then
        rem = rem >> 1
        rem = rem ~ 0xEDB88320
      else
        rem = rem >> 1
      end
    end
    table[i] = rem
  end

  for x = 1, size do
    c = buf[x]
    crc = (crc >> 8) ~ table[(crc & 0xFF) ~ c]
  end
  return crc ~ 0xFFFFFFFF
end


local str = "The quick brown fox jumps over the lazy dog"
local t = {}
for i = 1, #str do
  t[i] = str:byte(i)
end

print(string.format("CRC32: %x", crc32(t,#str)))
Output:

CRC32: 414fa339

M2000 Interpreter

Using Code

Module CheckIt {
      Function PrepareTable {
            Dim Base 0, table(256)
            For i = 0 To 255 {
                    k = i
                    For j = 0 To 7 {
                              If binary.and(k,1)=1 Then {
                                  k =binary.Xor(binary.shift(k, -1) ,  0xEDB88320)
                              }  Else k=binary.shift(k, -1)
                    }
                    table(i) = k
             }
             =table()      
      }       
      crctable=PrepareTable()
      crc32= lambda crctable (buf$) -> {
                crc =0xFFFFFFFF
                For i = 0 To Len(buf$) -1
                     crc = binary.xor(binary.shift(crc, -8), array(crctable, binary.xor(binary.and(crc, 0xff), asc(mid$(buf$, i+1, 1)))))
                Next i
                =0xFFFFFFFF-crc       
      }
      Print crc32("The quick brown fox jumps over the lazy dog")=0x414fa339
}
CheckIt

Using Api

Module CheckApi {
      Declare CRC32 LIB "ntdll.RtlComputeCrc32" {Long Zero, a$, long s}
      a$=Str$("The quick brown fox jumps over the lazy dog")
      l=len(a$)*2
      Hex Uint(CRC32(0,a$,l))
}
CheckApi

Mathematica / Wolfram Language

type="CRC32"; (*pick one out of 13 predefined hash types*)
StringForm[
"The "<>type<>" hash code of \"``\" is ``.",
s="The quick brown fox jumps over the lazy dog",
Hash[s,type,"HexString"]
]
Output:
The CRC32 hash code of "The quick brown fox jumps over the lazy dog" is 414fa339.

Neko

The NekoVM is a 31 bit machine; 30 signed. Loadable primitives handle 32bit integers. The zlib library API exposes a CRC-32 function, that expects and returns Int32.

/**
 <doc>CRC32 in Neko</doc>
**/

var int32_new = $loader.loadprim("std@int32_new", 1)
var update_crc32 = $loader.loadprim("zlib@update_crc32", 4)

var crc = int32_new(0)
var txt = "The quick brown fox jumps over the lazy dog"

crc = update_crc32(crc, txt, 0, $ssize(txt))
$print(crc, "\n")
Output:
prompt$ nekoc crc32.neko
prompt$ neko crc32.n
1095738169
prompt$ dc -e "$(neko crc32.n) 16op"
414FA339

NetRexx

Translation of: Java
/* NetRexx */
options replace format comments java crossref symbols binary

import java.util.zip.CRC32

toBeEncoded = String("The quick brown fox jumps over the lazy dog")
myCRC = CRC32()
myCRC.update(toBeEncoded.getBytes())
say "The CRC-32 value is :" Long.toHexString(myCRC.getValue()) "!"

return
Output:
The CRC-32 value is : 414fa339 !

Nim

import strutils

type TCrc32* = uint32
const InitCrc32* = TCrc32(0xffffffff)

proc createCrcTable(): array[0..255, TCrc32] =
  for i in 0..255:
    var rem = TCrc32(i)
    for j in 0..7:
      if (rem and 1) > 0: rem = (rem shr 1) xor TCrc32(0xedb88320)
      else: rem = rem shr 1
    result[i] = rem

# Table created at compile time
const crc32table = createCrcTable()

proc crc32(s: string): TCrc32 =
  result = InitCrc32
  for c in s:
    result = (result shr 8) xor crc32table[(result and 0xff) xor byte(c)]
  result = not result

echo crc32("The quick brown fox jumps over the lazy dog").int64.toHex(8)
Output:
414FA339

NOWUT

adapted from FreeBASIC

; link with PIOxxx.OBJ

        sectionbss

crctable.d:     resd 256

        sectiondata

havetable.b:    db 0
string:         db "The quick brown fox jumps over the lazy dog"
stringend:      
                db 13,10,0        ; carriage return and null terminator
                
        sectioncode

start!
        gosub initplatform

        beginfunc
        localvar crc.d

        callex ,printnt,"input = ".a
        callex ,printnt,string

        callex ,printnt,"The CRC-32 checksum = ".a
        callex crc,crc32,string,stringend
        callex ,printhexr,crc

        endfunc
        end

crc32:
        beginfunc bufend.d,buf.d
        localvar i.d,j.d,k.d,k2.d,crc.d

        ifunequal havetable,0,tabledone
        i=0
        whileless i,256

        k=i > j=8
        countdown j
        k2=k > k=_ shr 1
        ifequal k2 and 1,0,noxor > k=_ xor $EDB88320
noxor:
        nextcount

        crctable(i shl 2)=k
        i=_+1
        wend

        havetable=1
tabledone:

        crc=-1        

        whileless buf,bufend
        crc=_ shr 8 xor crctable(crc and $FF xor [buf].b shl 2)
        buf=_+1
        wend

        crc=_ xor -1
        endfunc crc
        returnex 8                        ; clean off 2 parameters from the stack
Output:
input = The quick brown fox jumps over the lazy dog
The CRC-32 checksum = 414FA339

Oberon-2

Works with: oo2c Version 2
MODULE CRC32;
IMPORT
  NPCT:Zlib,
  Strings,
  Out;
VAR
  s: ARRAY 128 OF CHAR;
BEGIN
  COPY("The quick brown fox jumps over the lazy dog",s);
  Out.Hex(Zlib.CRC32(0,s,0,Strings.Length(s)),0);Out.Ln
END CRC32.
Output:
414FA339

Objeck

class CRC32 {
  function : Main(args : String[]) ~ Nil {
    "The quick brown fox jumps over the lazy dog"->ToByteArray()->CRC32()->PrintLine();
  }
}
Output:
1095738169

OCaml

Library: camlzip
let () =
  let s = "The quick brown fox jumps over the lazy dog" in
  let crc = Zlib.update_crc 0l s 0 (String.length s) in
  Printf.printf "crc: %lX\n" crc

Running this code in interpreted mode:[[Media:Insert non-formatted text here]][[File:[Example.jpg][http://www.example.com link title]]]

$ ocaml unix.cma -I +zip zip.cma crc.ml
crc: 414FA339

Ol

(define (crc32 str)
   (bxor #xFFFFFFFF
      (fold (lambda (crc char)
               (let loop ((n 8) (crc crc) (bits char))
                  (if (eq? n 0)
                     crc
                     (let*((flag (band (bxor bits crc) 1))
                           (crc (>> crc 1))
                           (crc (if (eq? flag 0) crc (bxor crc #xEDB88320)))
                           (bits (>> bits 1)))
                        (loop (- n 1) crc bits)))))
         #xFFFFFFFF
         (string->list str))))

(print (number->string (crc32 "The quick brown fox jumps over the lazy dog") 16))
(print (number->string (crc32 (list->string (repeat #x00 32))) 16))
(print (number->string (crc32 (list->string (repeat #xFF 32))) 16))
(print (number->string (crc32 (list->string (iota 32))) 16))
Output:
414fa339
190a55ad
ff6cab0b
91267e8a

ooRexx

This Program shows how easy it is to use JAVA functionality from ooRexx. bsf4oorexx from Sourceforge https://sourceforge.net/projects/bsf4oorexx/ makes that possible.

/* ooRexx */
clzCRC32=bsf.importClass("java.util.zip.CRC32")
myCRC32 =clzCRC32~new
toBeEncoded="The quick brown fox jumps over the lazy dog"
myCRC32~update(BsfRawBytes(toBeEncoded))
numeric digits 20
say 'The CRC-32 value of "'toBeEncoded'" is:' myCRC32~getValue~d2x

::requires "BSF.CLS"    -- get Java bridge
Output:
The CRC-32 value of "The quick brown fox jumps over the lazy dog" is: 414FA339

PARI/GP

Using Linux system library (Linux only solution)

Library: libz.so
install("crc32", "lLsL", "crc32", "libz.so");
s = "The quick brown fox jumps over the lazy dog";
printf("%0x\n", crc32(0, s, #s))

Output:

414fa339

Pascal

Free Pascal

Program CheckCRC;
{$IFDEF fpc}{$mode Delphi}{$ENDIF}
{$IFDEF WINDOWS}{$APPTYPE CONSOLE}{$ENDIF}
uses
  sysutils,crc;
   
function CrcString(const mystring: string) : longword;
var
  crcvalue: longword;
begin
  crcvalue := crc32(0,nil,0);
  result := crc32(crcvalue, @mystring[1], length(mystring));
end;

var
  mytext: string;     
begin
  myText := 'The quick brown fox jumps over the lazy dog';
  writeln('crc32 = ', IntToHex(CrcString(mytext), 8));
end.

Output:

crc32 = 414FA339

Perl

#!/usr/bin/perl
use 5.010 ;
use strict ;
use warnings ;
use Digest::CRC qw( crc32 ) ;

my $crc = Digest::CRC->new( type => "crc32" ) ;
$crc->add ( "The quick brown fox jumps over the lazy dog" )  ;
say "The checksum is " . $crc->hexdigest( ) ;
Output:
The checksum is 414fa339

Phix

Included as demo\rosetta\crc32.exw, which also includes a thread-safe version

with javascript_semantics
sequence table
bool have_table = false
 
function crc32(string s)
    if not have_table then
        have_table = true
        table = repeat(0,256)
        for i=0 to 255 do
            atom rem = i
            for j=1 to 8 do
                if and_bits(rem,1) then
                    rem = xor_bits(floor(rem/2),#EDB88320)
                else
                    rem = floor(rem/2)
                end if
                if rem<0 then
                    rem += #100000000
                end if
            end for
            table[i+1] = rem
        end for
    end if
    atom crc = #FFFFFFFF
    for i=1 to length(s) do
        crc = xor_bits(floor(crc/#100),table[xor_bits(and_bits(crc,0xff),s[i])+1])
        if crc<0 then
            crc += #100000000
        end if
    end for
    return and_bits(not_bits(crc),#FFFFFFFF)
end function

string s = "The quick brown fox jumps over the lazy dog"
printf(1,"The CRC of %s is %08x\n",{s,crc32(s)})
Output:
The CRC of The quick brown fox jumps over the lazy dog is 414FA339

PHP

PHP has a built-in function crc32.

printf("%x\n", crc32("The quick brown fox jumps over the lazy dog"));
414fa339

PicoLisp

Library and implementation.

(setq *Table
   (mapcar
      '((N)
         (do 8
            (setq N
               (if (bit? 1 N)
                  (x| (>> 1 N) `(hex "EDB88320"))
                  (>> 1 N) ) ) ) )
      (range 0 255) ) )
 
(de crc32 (Lst)
   (let Crc `(hex "FFFFFFFF")
      (for I (chop Lst)
         (setq Crc
            (x|
               (get
                  *Table
                  (inc (x| (& Crc 255) (char I))) )
               (>> 8 Crc) ) ) )
      (x| `(hex "FFFFFFFF") Crc) ) )
 
(let Str "The quick brown fox jumps over the lazy dog"
   (println (hex (crc32 Str)))
   (println
      (hex (native "libz.so" "crc32" 'N 0 Str (length Str))) ) )
 
(bye)

Pike

string foo = "The quick brown fox jumps over the lazy dog";
write("0x%x\n", Gz.crc32(foo));
Output:
0x414fa339

PL/I

*process source attributes xref or(!) nest;
 crct: Proc Options(main);
 /*********************************************************************
 * 19.08.2013 Walter Pachl  derived from REXX
 *********************************************************************/
 Dcl (LEFT,LENGTH,RIGHT,SUBSTR,UNSPEC) Builtin;
 Dcl SYSPRINT Print;
 dcl tab(0:255) Bit(32);
 Call mk_tab;
 Call crc_32('The quick brown fox jumps over the lazy dog');
 Call crc_32('Generate CRC32 Checksum For Byte Array Example');

 crc_32: Proc(s);
 /*********************************************************************
 * compute checksum for s
 *********************************************************************/
 Dcl s Char(*);
 Dcl d   Bit(32);
 Dcl d1  Bit( 8);
 Dcl d2  Bit(24);
 Dcl cc  Char(1);
 Dcl ccb Bit(8);
 Dcl tib Bit(8);
 Dcl ti  Bin Fixed(16) Unsigned;
 Dcl k   Bin Fixed(16) Unsigned;
 d=(32)'1'b;
 Do k=1 To length(s);
    d1=right(d,8);
    d2=left(d,24);
    cc=substr(s,k,1);
    ccb=unspec(cc);
    tib=d1^ccb;
    Unspec(ti)=tib;
    d='00000000'b!!d2^tab(ti);
    End;
  d=d^(32)'1'b;
  Put Edit(s,'CRC_32=',b2x(d))(Skip,a(50),a,a);
  Put Edit('decimal ',b2d(d))(skip,x(49),a,f(10));
 End;

 b2x: proc(b) Returns(char(8));
 dcl b bit(32);
 dcl b4 bit(4);
 dcl i Bin Fixed(31);
 dcl r Char(8) Var init('');
 Do i=1 To 29 By 4;
   b4=substr(b,i,4);
   Select(b4);
     When('0000'b) r=r!!'0';
     When('0001'b) r=r!!'1';
     When('0010'b) r=r!!'2';
     When('0011'b) r=r!!'3';
     When('0100'b) r=r!!'4';
     When('0101'b) r=r!!'5';
     When('0110'b) r=r!!'6';
     When('0111'b) r=r!!'7';
     When('1000'b) r=r!!'8';
     When('1001'b) r=r!!'9';
     When('1010'b) r=r!!'A';
     When('1011'b) r=r!!'B';
     When('1100'b) r=r!!'C';
     When('1101'b) r=r!!'D';
     When('1110'b) r=r!!'E';
     When('1111'b) r=r!!'F';
     End;
   End;
 Return(r);
 End;

 b2d: Proc(b) Returns(Dec Fixed(15));
 Dcl b Bit(32);
 Dcl r Dec Fixed(15) Init(0);
 Dcl i Bin Fixed(16);
 Do i=1 To 32;
   r=r*2
   If substr(b,i,1) Then
     r=r+1;
   End;
 Return(r);
 End;

 mk_tab: Proc;
 dcl b32 bit(32);
 dcl lb  bit( 1);
 dcl ccc bit(32) Init('edb88320'bx);
 dcl (i,j) Bin Fixed(15);
 Do i=0 To 255;
   b32=(24)'0'b!!unspec(i);
   Do j=0 To 7;
     lb=right(b32,1);
     b32='0'b!!left(b32,31);
     If lb='1'b Then
       b32=b32^ccc;
     End;
   tab(i)=b32;
   End;
 End;
 End;
Output:
The quick brown fox jumps over the lazy dog       CRC_32=414FA339
                                                 decimal 1095738169
Generate CRC32 Checksum For Byte Array Example    CRC_32=D1370232
                                                 decimal 3510043186 

PowerBASIC

#COMPILE EXE
#DIM ALL
#COMPILER PBCC 6

' ***********

FUNCTION CRC32(BYVAL p AS BYTE PTR, BYVAL NumBytes AS DWORD) AS DWORD
  STATIC LUT() AS DWORD
  LOCAL i, j, k, crc AS DWORD

  IF ARRAYATTR(LUT(), 0) = 0 THEN
    REDIM LUT(0 TO 255)
    FOR i = 0 TO 255
      k = i
      FOR j = 0 TO 7
        IF (k AND 1) THEN
          SHIFT RIGHT k, 1
          k XOR= &HEDB88320
        ELSE
          SHIFT RIGHT k, 1
        END IF
      NEXT j
      LUT(i) = k
    NEXT i
  END IF

  crc = &HFFFFFFFF

  FOR i = 0 TO NumBytes - 1
    k = (crc AND &HFF& XOR @p[i])
    SHIFT RIGHT crc, 8
    crc XOR= LUT(k)
  NEXT i

  FUNCTION = NOT crc
END FUNCTION

' ***********

FUNCTION PBMAIN () AS LONG
  LOCAL s AS STRING
  LOCAL crc AS DWORD

  s = "The quick brown fox jumps over the lazy dog"
  CON.PRINT "Text:  " & s
  crc = CRC32(STRPTR(s), LEN(s))
  CON.PRINT "CRC32: " & HEX$(crc)
END FUNCTION
Output:
Text:  The quick brown fox jumps over the lazy dog
CRC32: 414FA339

PureBasic

Works with: PB Version 5.40
a$="The quick brown fox jumps over the lazy dog"

UseCRC32Fingerprint() : b$=StringFingerprint(a$, #PB_Cipher_CRC32)

OpenConsole()
PrintN("CRC32 Cecksum [hex] = "+UCase(b$))
PrintN("CRC32 Cecksum [dec] = "+Val("$"+b$))
Input()

End
Output:
CRC32 Cecksum [hex] = 414FA339
CRC32 Cecksum [dec] = 1095738169

Python

Library

zlib.crc32 and binascii.crc32 give identical results.

>>> s = 'The quick brown fox jumps over the lazy dog'
>>> import zlib
>>> hex(zlib.crc32(s))
'0x414fa339'

>>> import binascii
>>> hex(binascii.crc32(s))
'0x414fa339'

If you have Python 2.x, these functions might return a negative integer; you would need to use & 0xffffffff to get the same answer as Python 3.x. With Python 3.x, convert first the string to bytes, for instance with s.encode('UTF-8'), as these functions do not accept strings.

Implementation

Procedural

def create_table():
    a = []
    for i in range(256):
        k = i
        for j in range(8):
            if k & 1:
                k ^= 0x1db710640
            k >>= 1
        a.append(k)
    return a

def crc_update(buf, crc):
    crc ^= 0xffffffff
    for k in buf:
        crc = (crc >> 8) ^ crc_table[(crc & 0xff) ^ k]
    return crc ^ 0xffffffff
    
crc_table = create_table()
print(hex(crc_update(b"The quick brown fox jumps over the lazy dog", 0)))

Composition of pure functions

'''CRC-32 checksums for ascii strings'''

from functools import (reduce)
from itertools import (islice)


# crc32 :: String -> Int
def crc32(s):
    '''CRC-32 checksum for an ASCII encoded string'''
    def go(x):
        x2 = x >> 1
        return 0xedb88320 ^ x2 if x & 1 else x2
    table = [
        index(iterate(go)(n))(8)
        for n in range(0, 256)
    ]
    return reduce(
        lambda a, c: (a >> 8) ^ table[
            (a ^ ord(c)) & 0xff
        ],
        s,
        (0xffffffff)
    ) ^ 0xffffffff


# ------------------------- TEST -------------------------
# main :: IO ()
def main():
    '''Test'''
    print(
        format(
            crc32('The quick brown fox jumps over the lazy dog'),
            '02x'
        )
    )


# ----------------------- GENERIC ------------------------

# index (!!) :: [a] -> Int -> a
def index(xs):
    '''Item at given (zero-based) index.'''
    return lambda n: None if 0 > n else (
        xs[n] if (
            hasattr(xs, "__getitem__")
        ) else next(islice(xs, n, None))
    )


# iterate :: (a -> a) -> a -> Gen [a]
def iterate(f):
    '''An infinite list of repeated
       applications of f to x.
    '''
    def go(x):
        v = x
        while True:
            yield v
            v = f(v)
    return go


if __name__ == '__main__':
    main()
Output:
414fa339

QB64

Translation of: C
PRINT HEX$(crc32("The quick brown fox jumps over the lazy dog"))

FUNCTION crc32~& (buf AS STRING)
    STATIC table(255) AS _UNSIGNED LONG
    STATIC have_table AS _BYTE
    DIM crc AS _UNSIGNED LONG, k AS _UNSIGNED LONG
    DIM i AS LONG, j AS LONG

    IF have_table = 0 THEN
        FOR i = 0 TO 255
            k = i
            FOR j = 0 TO 7
                IF (k AND 1) THEN
                    k = _SHR(k, 1)
                    k = k XOR &HEDB88320
                ELSE
                    k = _SHR(k, 1)
                END IF
                table(i) = k
            NEXT
        NEXT
        have_table = -1
    END IF

    crc = NOT crc ' crc = &Hffffffff

    FOR i = 1 TO LEN(buf)
        crc = (_SHR(crc, 8)) XOR table((crc AND &HFF) XOR ASC(buf, i))
    NEXT

    crc32~& = NOT crc
END FUNCTION
Output:
414FA339

Quackery

Translation of: Forth
  [ table ]                      is crctable ( n --> n )

  256 times
    [ i^ 8 times
      [ dup 1 >> 
        swap 1 & if
          [ hex EDB88320 ^ ] ]
     ' crctable put ]

  [ hex FFFFFFFF swap
    witheach 
      [ over ^ hex FF & 
        crctable
        swap 8 >> ^ ] 
     hex FFFFFFFF ^ ]            is crc-32   ( [ --> n )

  $ "The quick brown fox jumps over the lazy dog" crc-32
  16 base put 
  echo 
  base release
Output:
414FA339

R

digest("The quick brown fox jumps over the lazy dog","crc32", serialize=F)
Output:
[1] "414fa339"

Racket

#lang racket
(define (bytes-crc32 data)
  (bitwise-xor
   (for/fold ([accum #xFFFFFFFF])
     ([byte  (in-bytes data)])
     (for/fold ([accum (bitwise-xor accum byte)])
       ([num (in-range 0 8)])
       (bitwise-xor (quotient accum 2)
                    (* #xEDB88320 (bitwise-and accum 1)))))
   #xFFFFFFFF))

(define (crc32 s)
  (bytes-crc32 (string->bytes/utf-8 s)))

(format "~x" (crc32 "The quick brown fox jumps over the lazy dog"))
Output:
"414fa339"

Raku

(formerly Perl 6)

Call to native function crc32 in zlib

use NativeCall;
 
sub crc32(int32 $crc, Buf $buf, int32 $len --> int32) is native('z') { * }
 
my $buf = 'The quick brown fox jumps over the lazy dog'.encode;
say crc32(0, $buf, $buf.bytes).fmt('%08x');

The libary name "z" resolves to /usr/lib/libz.so on a typical Linux system and /usr/lib/libz.dylib on Mac OS X, but may need to be changed for other platforms. Types may be platform-dependent as well. As written, the solution has been tested on Mac OS X 10.5.8 and Arch Linux 2016.08.01 x86_64.

Output:
414fa339

Pure Raku

A fairly generic implementation with no regard to execution speed:

sub crc(
    Blob $buf,
             # polynomial including leading term, default: ISO 3309/PNG/gzip
    :@poly = (1,0,0,0,0,0,1,0,0,1,1,0,0,0,0,0,1,0,0,0,1,1,1,0,1,1,0,1,1,0,1,1,1),
    :$n = @poly.end,      # degree of polynomial
    :@init = 1 xx $n,     # initial XOR bits
    :@fini = 1 xx $n,     # final XOR bits
    :@bitorder = 0..7,    # default: eat bytes LSB-first
    :@crcorder = 0..$n-1, # default: MSB of checksum is coefficient of x⁰
) {
    my @bit = flat ($buf.list X+& (1 X+< @bitorder))».so».Int, 0 xx $n;

    @bit[0   .. $n-1] «+^=» @init;
    @bit[$_  ..$_+$n] «+^=» @poly if @bit[$_] for 0..@bit.end-$n;
    @bit[*-$n..  *-1] «+^=» @fini;

    :2[@bit[@bit.end X- @crcorder]];
}

say crc('The quick brown fox jumps over the lazy dog'.encode('ascii')).base(16);
Output:
414FA339

REXX

/*REXX program computes the  CRC─32  (32 bit Cyclic Redundancy Check)  checksum  for a  */
/*─────────────────────────────────given string  [as described in ISO 3309, ITU─T V.42].*/
call show  'The quick brown fox jumps over the lazy dog'               /*the 1st string.*/
call show  'Generate CRC32 Checksum For Byte Array Example'            /* "  2nd    "   */
exit                                             /*stick a fork in it,  we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
CRC_32: procedure; parse arg !,$; c= 'edb88320'x /*2nd arg used for repeated invocations*/
                                  f= 'ffFFffFF'x /* [↓]  build an  8─bit  indexed table,*/
          do i=0  for 256;        z= d2c(i)      /*                  one byte at a time.*/
          r= right(z, 4, '0'x)                   /*insure the  "R"   is thirty─two bits.*/
                                                 /* [↓]  handle each rightmost byte bit.*/
            do j=0  for 8;       rb= x2b(c2x(r)) /*handle each bit of rightmost 8 bits. */
            r= x2c( b2x(0 || left(rb, 31) ) )    /*shift it right (an unsigned)  1  bit.*/
            if right(rb,1)  then r= bitxor(r, c) /*this is a bin bit for XOR grunt─work.*/
            end    /*j*/
          !.z= r                                 /*assign to an eight─bit index table.  */
          end      /*i*/
        $=bitxor( word($ '0000000'x, 1), f)      /*utilize the user's CRC or a default. */
          do k=1  for length(!  )                /*start number crunching the input data*/
          ?= bitxor(right($,1),  substr(!,k,1) )
          $= bitxor('0'x || left($, 3),  !.?)
          end   /*k*/
        return $                                 /*return with cyclic redundancy check. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
show:   procedure;   parse arg Xstring;   numeric digits 12;      say;     say
        checksum= bitxor(CRC_32(Xstring), 'ffFFffFF'x) /*invoke CRC_32 to create a CRC. */
        say center(' input string [length of' length(Xstring) "bytes] ", 79, '═')
        say Xstring;      say                          /*show the string on its own line*/
        say  "hex CRC─32 checksum ="   c2x(checksum)     left('', 15),
             "dec CRC─32 checksum ="   c2d(checksum)   /*show the CRC─32 in hex and dec.*/
        return
output   when using the internal default input:
══════════════════════ input string [length of 43 bytes] ══════════════════════
The quick brown fox jumps over the lazy dog

hex CRC-32 checksum = 414FA339                 dec CRC-32 checksum = 1095738169


══════════════════════ input string [length of 46 bytes] ══════════════════════
Generate CRC32 Checksum For Byte Array Example

hex CRC-32 checksum = D1370232                 dec CRC-32 checksum = 3510043186

RPL

Translation of: FreeBASIC
≪ → string
  ≪ 32 STWS                     @ set binary word size to 32 
     IFERRCRCtable’ RCL THEN
       { }
       0 255 FOR j
         j R→B
         0 7 START
           SR IF LAST #1 AND B→R THEN #EDB88320h XOR END
       NEXT + NEXTCRCtable’ STO
     END
     DROP #0 NOT
     1 string SIZE FOR j
       SRB SWAP
       #FFh AND string j DUP SUB NUM R→B XOR
       B→R 1 + ‘CRCtable’ SWAP GET XOR
       NEXT 
     NOT
≫ ≫ ‘CRC32’ STO 
"The quick brown fox jumps over the lazy dog" CRC32
Output:
1: # 414FA339h

Ruby

Use 'zlib' from standard library.

require 'zlib'
printf "0x%08x\n", Zlib.crc32('The quick brown fox jumps over the lazy dog')
# => 0x414fa339

Reimplement CRC-32 in Ruby, with comments to show the polynomials.

module CRC
  # Divisor is a polynomial of degree 32 with coefficients modulo 2.
  # We store Divisor in a 33-bit Integer; the polynomial is
  #   Divisor[32] + Divisor[31] * x + ... + Divisor[0] * x**32
  Divisor = [0, 1, 2, 4, 5, 7, 8, 10, 11, 12, 16, 22, 23, 26, 32] \
    .inject(0) {|sum, exponent| sum + (1 << (32 - exponent))}

  # This table gives the crc (without conditioning) of every possible
  # _octet_ from 0 to 255. Each _octet_ is a polynomial of degree 7,
  #   octet[7] + octet[6] * x + ... + octet[0] * x**7
  # Then remainder = Table[octet] is the remainder from
  # _octet_ times x**32 divided by Divisor,
  #   remainder[31] + remainder[30] + ... + remainder[0] * x**31
  Table = Array.new(256) do |octet|
    # Find remainder from polynomial long division.
    #    octet[ 7] * x**32 + ... +   octet[0] * x**39
    #  Divisor[32] * x**0  + ... + Divisor[0] * x**32
    remainder = octet
    (0..7).each do |i|
      # Find next term of quotient. To simplify the code,
      # we assume that Divisor[0] is 1, and we only check
      # remainder[i]. We save remainder, forget quotient.
      if remainder[i].zero?
        # Next term of quotient is 0 * x**(7 - i).
        # No change to remainder.
      else
        # Next term of quotient is 1 * x**(7 - i). Multiply
        # this term by Divisor, then subtract from remainder.
        #  * Multiplication uses left shift :<< to align
        #    the x**(39 - i) terms.
        #  * Subtraction uses bitwise exclusive-or :^.
        remainder ^= (Divisor << i)
      end
    end
    remainder >> 8      # Remove x**32 to x**39 terms.
  end

  module_function

  def crc32(string, crc = 0)
    # Pre-conditioning: Flip all 32 bits. Without this step, a string
    # preprended with extra "\0" would have same crc32 value.
    crc ^= 0xffff_ffff

    # Iterate octets to perform polynomial long division.
    string.each_byte do |octet|

      # Update _crc_ by continuing its polynomial long division.
      # Our current remainder is old _crc_ times x**8, plus
      # new _octet_ times x**32, which is
      #   crc[32] * x**8 + crc[31] * x**9 + ... + crc[8] * x**31 \
      #     + (crc[7] + octet[7]) * x**32 + ... \
      #     + (crc[0] + octet[0]) * x**39
      #
      # Our new _crc_ is the remainder from this polynomial divided by
      # Divisor. We split the terms into part 1 for x**8 to x**31, and
      # part 2 for x**32 to x**39, and divide each part separately.
      # Then remainder 1 is trivial, and remainder 2 is in our Table.

      remainder_1 = crc >> 8
      remainder_2 = Table[(crc & 0xff) ^ octet]

      # Our new _crc_ is sum of both remainders. (This sum never
      # overflows to x**32, so is not too big for Divisor.)
      crc = remainder_1 ^ remainder_2
    end

    # Post-conditioning: Flip all 32 bits. If we later update _crc_,
    # this step cancels the next pre-conditioning.
    crc ^ 0xffff_ffff
  end
end

printf "0x%08x\n", CRC.crc32("The quick brown fox jumps over the lazy dog")
# => 0x414fa339

Rust

This does not perform any caching of the lookup table for simplicity.

fn crc32_compute_table() -> [u32; 256] {
    let mut crc32_table = [0; 256];

    for n in 0..256 {
        crc32_table[n as usize] = (0..8).fold(n as u32, |acc, _| {
            match acc & 1 {
                1 => 0xedb88320 ^ (acc >> 1),
                _ => acc >> 1,
            }
        });
    }

    crc32_table
}

fn crc32(buf: &str) -> u32 {
    let crc_table = crc32_compute_table();

    !buf.bytes().fold(!0, |acc, octet| {
        (acc >> 8) ^ crc_table[((acc & 0xff) ^ octet as u32) as usize]
    })
}

fn main() {
    println!("{:x}", crc32("The quick brown fox jumps over the lazy dog"));
}
Output:
414fa339

Scala

Translation of: Java
import java.util.zip.CRC32
val crc=new CRC32
crc.update("The quick brown fox jumps over the lazy dog".getBytes)
println(crc.getValue.toHexString)  //> 414fa339

Seed7

$ include "seed7_05.s7i";
  include "crc32.s7i";

const proc: main is func
  begin
    writeln(ord(crc32("The quick brown fox jumps over the lazy dog")) radix 16 lpad0 8);
  end func;
Output:
414fa339

Shell

Bash

#!/usr/bin/env bash
declare -i -a CRC32_LOOKUP_TABLE

__generate_crc_lookup_table() {
  local -i -r LSB_CRC32_POLY=0xEDB88320 # The CRC32 polynomal LSB order
  local -i index byte lsb
  for index in {0..255}; do
    ((byte = 255 - index))
    for _ in {0..7}; do # 8-bit lsb shift
      ((lsb = byte & 0x01, byte = ((byte >> 1) & 0x7FFFFFFF) ^ (lsb == 0 ? LSB_CRC32_POLY : 0)))
    done
    ((CRC32_LOOKUP_TABLE[index] = byte))
  done
}
__generate_crc_lookup_table
typeset -r CRC32_LOOKUP_TABLE

crc32_string() {
  [[ ${#} -eq 1 ]] || return
  local -i i byte crc=0xFFFFFFFF index
  for ((i = 0; i < ${#1}; i++)); do
    byte=$(printf '%d' "'${1:i:1}") # Get byte value of character at i
    ((index = (crc ^ byte) & 0xFF, crc = (CRC32_LOOKUP_TABLE[index] ^ (crc >> 8)) & 0xFFFFFFFF))
  done
  echo $((crc ^ 0xFFFFFFFF))
}

printf 'The CRC32 of: %s\nis: 0x%08x\n' "${1}" "$(crc32_string "${1}")"

# crc32_string "The quick brown fox jumps over the lazy dog"
# yields 414fa339

POSIX

The POSIX Shell has no array type and no string indexation. It costs less to recompute polynomal shift for each character than indexing with external tools like awk or tr.

#!/usr/bin/env sh
# POSIX Shell CRC32 of string
# @Name: crc32.sh
# @Version: 1.0.1
# @Author: Léa Gris <lea.gris@noiraude.net>
# @Date: Wed, 27 Mar 2019
# @License: WTFPL http://www.wtfpl.net/

# POSIX Shell has no array or string index
# Implementing a pre-computed CRC32 byte indexed look-up table
# would cost more CPU cycles calling external tools like
# awk or tr to index records from a string.

# Computes the CRC32 of the input data stream
# <&1: The input data stream
# >&1: The CRC32 integer of the input data stream
crc32_stream() {
  crc=0xFFFFFFFF # The Initial CRC32 value
  p=0xedb88320   # The CRC32 polynomial
  r=0            # The polynomial reminder
  c=''           # The current character
  byte=0         # The byte value of the current character
  # Iterates each character of the input stream
  while c="$(dd bs=1 count=1 2>/dev/null)" && [ -n "$c" ]; do
    byte=$(printf '%d' "'$c")  # Converts the character into its byte value
    r=$(((crc & 0xff) ^ byte)) # XOR LSB of CRC with current byte
    # 8-bit lsb shift with XOR polynomial reminder when odd
    for _ in _ _ _ _ _ _ _ _; do
      t=$((r >> 1))
      r=$(((r & 1) ? t ^ p : t))
    done
    crc=$(((crc >> 8) ^ r)) # XOR MSB of CRC with Reminder
  done

  # Output CRC32 integer XOR mask 32 bits
  echo $((crc ^ 0xFFFFFFFF))
}

# Computes the CRC32 of the argument string
# 1: The argument string
# >&1: The CRC32 integer of the argument string
crc32_string() {
  [ $# -eq 1 ] || return # argument required
  # Streams with printf to prevent suffixing the string
  # with a newline, since echo -n is not available in POSIX Shell
  printf '%s' "$1" | crc32_stream
}

printf 'The CRC32 of: %s\nis: %08x\n' "$1" "$(crc32_string "$1")"

# crc32_string "The quick brown fox jumps over the lazy dog"
# yields 414fa339
Output:
bash ./crc32.sh "The quick brown fox jumps over the lazy dog"
The CRC32 of: The quick brown fox jumps over the lazy dog
is: 0x414fa339

Smalltalk

Works with: Smalltalk/X

the CRC32Stream utility class can do it for me:

CRC32Stream hashValueOf:'The quick brown fox jumps over the lazy dog'
Output:
1095738169 "which is 16r414FA339"

Swift

Using the zlib crc32 function available to Swift from libz.dylib.

import Foundation

let strData = "The quick brown fox jumps over the lazy dog".dataUsingEncoding(NSUTF8StringEncoding,
    allowLossyConversion: false)
let crc = crc32(uLong(0), UnsafePointer<Bytef>(strData!.bytes), uInt(strData!.length))

println(NSString(format:"%2X", crc))
Output:
414FA339

Tcl

package require Tcl 8.6

set data "The quick brown fox jumps over the lazy dog"
puts [format "%x" [zlib crc32 $data]]
Output:
414fa339

Alternatively, with older versions of Tcl:

Library: Tcllib (Package: crc32)
package require crc32
puts [format "%x" [crc::crc32 $data]]

With the same input data, it produces identical output.

TXR

Standard Library

(crc32 "The quick brown fox jumps over the lazy dog")
Output:
1095738169

FFI access to Zlib

(with-dyn-lib "libz.so.1"
  (deffi zlib-crc32 "crc32" ulong (ulong str uint)))
Output:
$ txr -i crc32-zlib.tl 
1> (let ((s "The quick brown fox jumps over the lazy dog"))
      (zlib-crc32 0 s (coded-length s)))
1095738169

Note: coded-length gives UTF-8 length; len yields a code point count. Since this is an ASCII string, the two agree.

Lisp Code

(defvarl crc-tab
  #(#x00000000 #x77073096 #xee0e612c #x990951ba #x076dc419 #x706af48f
    #xe963a535 #x9e6495a3 #x0edb8832 #x79dcb8a4 #xe0d5e91e #x97d2d988
    #x09b64c2b #x7eb17cbd #xe7b82d07 #x90bf1d91 #x1db71064 #x6ab020f2
    #xf3b97148 #x84be41de #x1adad47d #x6ddde4eb #xf4d4b551 #x83d385c7
    #x136c9856 #x646ba8c0 #xfd62f97a #x8a65c9ec #x14015c4f #x63066cd9
    #xfa0f3d63 #x8d080df5 #x3b6e20c8 #x4c69105e #xd56041e4 #xa2677172
    #x3c03e4d1 #x4b04d447 #xd20d85fd #xa50ab56b #x35b5a8fa #x42b2986c
    #xdbbbc9d6 #xacbcf940 #x32d86ce3 #x45df5c75 #xdcd60dcf #xabd13d59
    #x26d930ac #x51de003a #xc8d75180 #xbfd06116 #x21b4f4b5 #x56b3c423
    #xcfba9599 #xb8bda50f #x2802b89e #x5f058808 #xc60cd9b2 #xb10be924
    #x2f6f7c87 #x58684c11 #xc1611dab #xb6662d3d #x76dc4190 #x01db7106
    #x98d220bc #xefd5102a #x71b18589 #x06b6b51f #x9fbfe4a5 #xe8b8d433
    #x7807c9a2 #x0f00f934 #x9609a88e #xe10e9818 #x7f6a0dbb #x086d3d2d
    #x91646c97 #xe6635c01 #x6b6b51f4 #x1c6c6162 #x856530d8 #xf262004e
    #x6c0695ed #x1b01a57b #x8208f4c1 #xf50fc457 #x65b0d9c6 #x12b7e950
    #x8bbeb8ea #xfcb9887c #x62dd1ddf #x15da2d49 #x8cd37cf3 #xfbd44c65
    #x4db26158 #x3ab551ce #xa3bc0074 #xd4bb30e2 #x4adfa541 #x3dd895d7
    #xa4d1c46d #xd3d6f4fb #x4369e96a #x346ed9fc #xad678846 #xda60b8d0
    #x44042d73 #x33031de5 #xaa0a4c5f #xdd0d7cc9 #x5005713c #x270241aa
    #xbe0b1010 #xc90c2086 #x5768b525 #x206f85b3 #xb966d409 #xce61e49f
    #x5edef90e #x29d9c998 #xb0d09822 #xc7d7a8b4 #x59b33d17 #x2eb40d81
    #xb7bd5c3b #xc0ba6cad #xedb88320 #x9abfb3b6 #x03b6e20c #x74b1d29a
    #xead54739 #x9dd277af #x04db2615 #x73dc1683 #xe3630b12 #x94643b84
    #x0d6d6a3e #x7a6a5aa8 #xe40ecf0b #x9309ff9d #x0a00ae27 #x7d079eb1
    #xf00f9344 #x8708a3d2 #x1e01f268 #x6906c2fe #xf762575d #x806567cb
    #x196c3671 #x6e6b06e7 #xfed41b76 #x89d32be0 #x10da7a5a #x67dd4acc
    #xf9b9df6f #x8ebeeff9 #x17b7be43 #x60b08ed5 #xd6d6a3e8 #xa1d1937e
    #x38d8c2c4 #x4fdff252 #xd1bb67f1 #xa6bc5767 #x3fb506dd #x48b2364b
    #xd80d2bda #xaf0a1b4c #x36034af6 #x41047a60 #xdf60efc3 #xa867df55
    #x316e8eef #x4669be79 #xcb61b38c #xbc66831a #x256fd2a0 #x5268e236
    #xcc0c7795 #xbb0b4703 #x220216b9 #x5505262f #xc5ba3bbe #xb2bd0b28
    #x2bb45a92 #x5cb36a04 #xc2d7ffa7 #xb5d0cf31 #x2cd99e8b #x5bdeae1d
    #x9b64c2b0 #xec63f226 #x756aa39c #x026d930a #x9c0906a9 #xeb0e363f
    #x72076785 #x05005713 #x95bf4a82 #xe2b87a14 #x7bb12bae #x0cb61b38
    #x92d28e9b #xe5d5be0d #x7cdcefb7 #x0bdbdf21 #x86d3d2d4 #xf1d4e242
    #x68ddb3f8 #x1fda836e #x81be16cd #xf6b9265b #x6fb077e1 #x18b74777
    #x88085ae6 #xff0f6a70 #x66063bca #x11010b5c #x8f659eff #xf862ae69
    #x616bffd3 #x166ccf45 #xa00ae278 #xd70dd2ee #x4e048354 #x3903b3c2
    #xa7672661 #xd06016f7 #x4969474d #x3e6e77db #xaed16a4a #xd9d65adc
    #x40df0b66 #x37d83bf0 #xa9bcae53 #xdebb9ec5 #x47b2cf7f #x30b5ffe9
    #xbdbdf21c #xcabac28a #x53b39330 #x24b4a3a6 #xbad03605 #xcdd70693
    #x54de5729 #x23d967bf #xb3667a2e #xc4614ab8 #x5d681b02 #x2a6f2b94
    #xb40bbe37 #xc30c8ea1 #x5a05df1b #x2d02ef8d))

(defun crc32 (buf)
  (let ((crc #xffffffff)
        (l (len buf)))
    (each ((i 0..l))
      (set crc (logxor [crc-tab (logand (logxor crc [buf i]) #xff)]
                       (ash crc -8))))
    (logxor crc #xffffffff)))
Output:
$ ./txr -i crc.tl 
warning: (crc.tl:46) defun: redefining crc32, which is a built-in defun
1> (crc32 (buf-str "The quick brown fox jumps over the lazy dog"))
1095738169

Vala

Library

using ZLib.Utility;

void main() {
  var str = (uint8[])"The quick brown fox jumps over the lazy dog".to_utf8();
  stdout.printf("%lx\n", crc32(0, str));
}
Output:
414fa339

Implementation

public class Crc32
{
  private const uint32 s_generator = 0xedb88320u;

  public Crc32()
  {
    m_table = new uint32[256];
    uint32 rem;
    for (uint32 i = 0; i < 256; i++) {
      rem = i;
      for (uint32 j = 0; j < 8; j++) {
        if ((rem & 1) != 0) {
          rem >>= 1;
          rem ^= s_generator;
        } else 
          rem >>= 1;
      }
      m_table[i] = rem;
    }  
  }

  public uint32 get(string str) {
    uint32 crc = 0;
    crc = ~crc;
    for (int i = 0; i < str.length; i++) {
      crc = (crc >> 8) ^ m_table[(crc & 0xff) ^ str[i]];
    }
    return ~crc;
  }

  private uint32[] m_table;
}

void main() {
  var crc32 = new Crc32();
  stdout.printf("%x\n", crc32.get("The quick brown fox jumps over the lazy dog"));
}
Output:
414fa339

VAX Assembly

                           EDB88320  0000     1 poly:   .long   ^xedb88320                      ;crc32
                           00000044  0004     2 table:  .blkl   16
                                     0044     3 
         4C 58 21 0000004C'010E0000' 0044     4 fmt:    .ascid  "!XL"                           ;result format
36 35 34 33 32 31 00000057'010E0000' 004F     5 result: .ascid  "12345678"                      ; and buffer
                              38 37  005D       
                               0000  005F     6 .entry  crc,0
                         A0 AF   7F  0061     7         pushaq  table                           ;fill table
                         99 AF   DF  0064     8         pushal  poly                            ; for
              00000000'GF   02   FB  0067     9         calls   #2, g^lib$crc_table             ;  crc opcode
      2B'  FFFFFFFF 8F   93 AF   0B  006E    10         crc     table, #-1, s^#len, b^msg       ;table,init,len,string
                         98'AF       0077       
                       50   50   D2  0079    11         mcoml   r0, r0                          ;invert result
                                     007C    12         $fao_s	ctrstr = fmt, outbuf = result, p1 = r0 ; format
                         BF AF   7F  008D    13 	pushaq	result				;and show
              00000000'GF   01   FB  0090    14         calls   #1, g^lib$put_output            ;  result 414fa339
                                 04  0097    15         ret
                                     0098    16 
72 62 20 6B 63 69 75 71 20 65 68 54  0098    17 msg:    .ascii  "The quick brown fox jumps over the lazy dog"
70 6D 75 6A 20 78 6F 66 20 6E 77 6F  00A4       
6C 20 65 68 74 20 72 65 76 6F 20 73  00B0       
               67 6F 64 20 79 7A 61  00BC       
                           0000002B  00C3    18 len = .-msg
                                     00C3    19 .end	crc

VBScript

VBScript does'nt have bit rotation instructions and then bit to bit logic converts the default Double values to SIGNED 32 bit integers and back. A table driven implementation is required to speed things up. The code generates the table on the fly.

dim crctbl(255)
const crcc =&hEDB88320

sub gencrctable
for i= 0 to 255
   k=i
   for j=1 to 8
    if k and 1 then 
      k=(k and &h7fffffff)\2 or (&h40000000 and ((k and &h80000000)<>0)) 
      k=k xor crcc
    else 
      k=(k and &h7fffffff)\2 or (&h40000000 and ((k and &h80000000)<>0))
   end if
   next ' j
   crctbl(i)=k
 next
end sub
 
 function crc32 (buf) 
  dim r,r1,i 
  r=&hffffffff 
  for i=1 to len(buf) 
      r1=(r and &h7fffffff)\&h100 or (&h800000 and (r and &h80000000)<>0)
    r=r1 xor crctbl((asc(mid(buf,i,1))xor r) and 255) 
  next 
  crc32=r xor &hffffffff
end function

  
'414FA339 
gencrctable
wscript.stdout.writeline hex(crc32("The quick brown fox jumps over the lazy dog"))

Output

414FA339

Visual Basic

Works with: Visual Basic version 5
Works with: Visual Basic version 6
Works with: VBA version Access 97
Works with: VBA version 6.5
Works with: VBA version 7.1
Library: Win32

Not an ideal task for Visual Basic because the language lacks bit shifting operators (which can of course be emulated, but that's slow). Then again, since the only platform supported by VB is Microsoft Windows (32 Bit Subsystem), we can let the Windows API do the work for us. RtlComputeCrc32() was available since Windows XP and is still present in Windows 10.

Option Explicit
Declare Function RtlComputeCrc32 Lib "ntdll.dll" _
  (ByVal dwInitial As Long, pData As Any, ByVal iLen As Long) As Long
'--------------------------------------------------------------------
Sub Main()
Dim s As String
Dim b() As Byte
Dim l As Long
  
  s = "The quick brown fox jumps over the lazy dog"
  b() = StrConv(s, vbFromUnicode) 'convert Unicode to ASCII
  l = RtlComputeCrc32(0&, b(0), Len(s))
  Debug.Assert l = &H414FA339

End Sub

Visual Basic .NET

Allows the resumption of calculations, useful for processing a large file with a series of buffer reads.

Public Class Crc32

    ' Table for pre-calculated values.
    Shared table(255) As UInteger

    ' Initialize table
    Shared Sub New()
        For i As UInteger = 0 To table.Length - 1
            Dim te As UInteger = i ' table entry
            For j As Integer = 0 To 7
                If (te And 1) = 1 Then te = (te >> 1) Xor &HEDB88320UI Else te >>= 1
            Next
            table(i) = te
        Next
    End Sub

    ' Return checksum calculation for Byte Array,
    '  optionally resuming (used when breaking a large file into read-buffer-sized blocks).
    ' Call with Init = False to continue calculation.
    Public Shared Function cs(BA As Byte(), Optional Init As Boolean = True) As UInteger
        Static crc As UInteger
        If Init Then crc = UInteger.MaxValue
        For Each b In BA
            crc = (crc >> 8) Xor table((crc And &HFF) Xor b)
        Next
        Return Not crc
    End Function

End Class

Test:

    ' Returns a Byte Array from a string of ASCII characters.
    Function Str2BA(Str As String) As Byte()
        Return System.Text.Encoding.ASCII.GetBytes(Str)
    End Function

    ' Returns a Hex string from an UInteger, formatted to a number of digits,
    '  adding leading zeros If necessary.
    Function HexF(Value As UInteger, Digits As Integer) As String
        HexF = Hex(Value)
        If Len(HexF) < Digits Then HexF = StrDup(Digits - Len(HexF), "0") & HexF
    End Function

    ' Tests Crc32 class
    Sub Test()
        Dim Str As String = "The quick brown fox jumps over the lazy dog"
        Debug.Print("Input = """ & Str & """")
        ' Convert string to Byte Array, compute crc32, and display formatted result
        Debug.Print("Crc32 = " & HexF(Crc32.cs(Str2BA(Str)), 8))
        ' This next code demonstrates continuing a crc32 calculation when breaking the input
        ' into pieces, such as processing a large file by a series of buffer reads.
        Crc32.cs(Str2BA(Mid(Str, 1, 20)))
        Debug.Print("Crc32 = " & HexF(Crc32.cs(Str2BA(Mid(Str, 21)), False), 8))
    End Sub

Output:

Input = "The quick brown fox jumps over the lazy dog"
Crc32 = 414FA339
Crc32 = 414FA339

V (Vlang)

import hash.crc32

fn main() {
    text := "The quick brown fox jumps over the lazy dog"
    result := crc32.sum(text.bytes())
    println(result.hex())
}
Output:
414fa339

Wren

Translation of: Go
Library: Wren-fmt
import "./fmt" for Conv

class CRC32 {
    static init() {
        __table = List.filled(256, 0)
        for (i in 0..255) {
            var word = i
            for (j in 0..7) {
                if (word&1 == 1) {
                    word = (word >> 1) ^ 0xedb88320
                } else {
                    word = word >> 1
                }
            }
            __table[i] = word
         }
    }

    static compute(s) {
        var crc = ~0
        var le = s.bytes.count
        for (i in 0...le) {
            var crb = crc & 0xff
            crc = __table[crb^s[i].bytes[0]] ^ (crc >> 8)
        }
        return ~crc
    }
}

CRC32.init()
var crc = CRC32.compute("The quick brown fox jumps over the lazy dog")
System.print(Conv.hex(crc))
Output:
414fa339

XPL0

code HexOut=27;         \intrinsic routine
string 0;               \use zero-terminated strings

func CRC32(Str, Len);   \Return CRC-32 for given string
char Str;  int Len;     \byte array, number of bytes
int  I, J, R, C;
[R:= -1;                \initialize with all 1's
for J:= 0 to Len-1 do
    [C:= Str(J);
    for I:= 0 to 8-1 do \for each bit in byte...
        [if (R xor C) and 1 then R:= R>>1 xor $EDB88320
        else R:= R>>1;
        C:= C>>1;
        ];
    ];
return not R;
];

HexOut(0, CRC32("The quick brown fox jumps over the lazy dog", 43))
Output:
414FA339

zkl

Using zlib:

var [const] ZLib=Import("zeelib");
ZLib.calcCRC32(Data(Void,"The quick brown fox jumps over the lazy dog"));
//-->0x414fa339

Zig

const std = @import("std");
const Crc32Ieee = std.hash.Crc32;

pub fn main() !void {
    var res: u32 = Crc32Ieee.hash("The quick brown fox jumps over the lazy dog");
    std.debug.print("{x}\n", .{res});
}
Output:
414fa339