CRC-32: Difference between revisions
Content deleted Content added
Added PascalABC.NET |
|||
| (242 intermediate revisions by more than 100 users not shown) | |||
Line 1:
{{
[[Category:Checksums]]
{{omit from|GUISS}}
{{omit from|Lilypond}}
{{omit from|TPP}}
;Task:
Demonstrate a method of deriving the [[wp:Computation of cyclic redundancy checks|Cyclic Redundancy Check]] from within the language.
The result should be in accordance with ISO 3309, [http://www.itu.int/rec/T-REC-V.42-200203-I/en ITU-T V.42], [http://tools.ietf.org/html/rfc1952 Gzip] and [http://www.w3.org/TR/2003/REC-PNG-20031110/ PNG].
Algorithms are described on [[wp:Cyclic redundancy check|Computation of CRC]] in Wikipedia.
This variant of CRC-32 uses LSB-first order, sets the initial CRC to FFFFFFFF<sub>16</sub>, and complements the final CRC.
For the purpose of this task, generate a CRC-32 checksum for the ASCII encoded string:
:: <big><big><code>The quick brown fox jumps over the lazy dog</code></big></big>
<br><br>
=={{header|11l}}==
{{trans|C}}
<syntaxhighlight lang=11l>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’)))</syntaxhighlight>
{{out}}
<pre>
414FA339
</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}}==
{{works with|GNAT}}
<syntaxhighlight lang=Ada>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;</syntaxhighlight>
{{out}}
<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}}==
<syntaxhighlight lang=algol68>
[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))
</syntaxhighlight>
{{out}}
<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}}==
===DllCall / WinAPI===
<syntaxhighlight lang=AutoHotkey>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")</syntaxhighlight>
{{out}}
<pre>0x414fa339</pre>
===Implementation===
<syntaxhighlight lang=AutoHotkey>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")</syntaxhighlight>
{{out}}
<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}}==
===Library===
Using [http://www.stillhq.com/gpg/source-modified-1.0.3/zlib/crc32.html zlib's crc32]:
<
#include <string.h>
#include <zlib.h>
Line 14 ⟶ 414:
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 [[{{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.
<syntaxhighlight lang=c>#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;
}</syntaxhighlight>
=={{header|C sharp|C#}}==
<syntaxhighlight lang=Csharp>
/// <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
}
</syntaxhighlight>
Test:
<syntaxhighlight lang=Csharp>
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"));
</syntaxhighlight>
{{out}}
414fa339
=={{header|C++}}==
<syntaxhighlight lang=cpp>#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';
}</syntaxhighlight>
{{out}}
<pre>
414fa339
</pre>
<pre>
"The quick brown fox jumps over the lazy dog"
(to hex ...)
54686520717569636B2062726F776E20666F78206A756D7073206F76657220746865206C617A7920646F67 414FA339
[other useful test vectors]
0000000000000000000000000000000000000000000000000000000000000000 190A55AD
FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF FF6CAB0B
000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F 91267E8A
</pre>
{{libheader|boost}}
<syntaxhighlight lang=cpp>#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;
}</syntaxhighlight>
{{out}}
<pre>
Checksum: 414fa339
</pre>
=={{header|Clojure}}==
{{trans|Java}}
<syntaxhighlight lang=clojure>(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))))</syntaxhighlight>
{{out}}
<pre>CRC-32('The quick brown fox jumps over the lazy dog') = 414fa339
</pre>
=={{header|COBOL}}==
{{works with|GnuCOBOL}} {{libheader|zlib}}
<syntaxhighlight lang=COBOL> *> 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.</syntaxhighlight>
{{out}}
<pre>prompt$ cobc -xj crc32-zlib.cob -lz
checksum: 414fa339
crc32 of "The quick brown fox jumps over the lazy dog" is 0x00000000414fa339
</pre>
=={{header|CoffeeScript}}==
Allows the specification of the initial CRC value, which defaults to 0xFFFFFFFF. Optimized for speed and terseness (then readability/indentation).
<syntaxhighlight lang=coffeescript>
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
</syntaxhighlight>
Test:
<syntaxhighlight lang=coffeescript>console.log (crc32 'The quick brown fox jumps over the lazy dog').toString 16</syntaxhighlight>
Output:
<syntaxhighlight lang=text>414fa339</syntaxhighlight>
=={{header|Common Lisp}}==
{{libheader|Ironclad}}
<syntaxhighlight lang=lisp>(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)
</syntaxhighlight>
{{out}}
<pre>"414fa339"</pre>
=={{header|Component Pascal}}==
BlackBox Component Builder<br/>
Require ZLib Subsystem
<syntaxhighlight lang=oberon2>
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.
</syntaxhighlight>
Execute: ^Q BbtComputeCRC32.Do<br/>
{{out}}
<pre>
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>
=={{header|D}}==
<syntaxhighlight lang=d>void main() {
import std.stdio, std.digest.crc;
"The quick brown fox jumps over the lazy dog"
.crc32Of.crcHexString.writeln;
}</syntaxhighlight>
{{out}}
<pre>414FA339</pre>
=={{header|Delphi}}==
<syntaxhighlight lang=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.</syntaxhighlight>
{{out}}
<pre>CRC32 = 414FA339</pre>
=={{header|EasyLang}}==
<syntaxhighlight lang=text>
func crc32 buf$[] .
for i = 0 to 0xff
rem = i
for j to 8
if bitand rem 1 = 1
rem = bitxor bitshift rem -1 0xedb88320
else
rem = bitshift rem -1
.
.
table[] &= rem
.
crc = 0xffffffff
for c$ in buf$[]
c = strcode c$
crb = bitxor bitand crc 0xff c
crc = bitxor (bitshift crc -8) table[crb + 1]
.
return bitnot crc
.
s$ = "The quick brown fox jumps over the lazy dog"
print crc32 strchars s$
</syntaxhighlight>
{{out}}
<pre>
1095738169
</pre>
=={{header|Elixir}}==
<syntaxhighlight lang=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")</syntaxhighlight>
{{out}}
<pre>
414FA339
</pre>
=={{header|Erlang}}==
Using the built-in crc32 implementation.
<syntaxhighlight lang=erlang>
-module(crc32).
-export([test/0]).
test() ->
io:fwrite("~.16#~n",[erlang:crc32(<<"The quick brown fox jumps over the lazy dog">>)]).
</syntaxhighlight>
{{out}}
<syntaxhighlight lang=erlang>
16#414FA339
</syntaxhighlight>
=={{header|F Sharp|F#}}==
<syntaxhighlight lang=fsharp>
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
</syntaxhighlight>
{{out}}
<syntaxhighlight lang=fsharp>
ASCII Input: The quick brown fox jumps over the lazy dog
CRC32: 0x414fa339
</syntaxhighlight>
=={{header|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 [https://github.com/slavapestov/factor/blob/master/core/checksums/crc32/crc32.factor core/checksums/crc32/crc32.factor].
=={{header|FBSL}}==
<syntaxhighlight lang=qbasic>#APPTYPE CONSOLE
PRINT HEX(CHECKSUM("The quick brown fox jumps over the lazy dog"))
PAUSE</syntaxhighlight>
{{out}}
<pre>414FA339
Press any key to continue...</pre>
=={{header|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.
<syntaxhighlight lang=forth>
: 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
</syntaxhighlight>
=={{header|Fortran}}==
<syntaxhighlight lang=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</syntaxhighlight>
=={{header|FreeBASIC}}==
{{trans|C}}
<syntaxhighlight lang=freebasic>' 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</syntaxhighlight>
{{out}}
<pre>input = The quick brown fox jumps over the lazy dog
The CRC-32 checksum = 414FA339</pre>
=={{header|Go}}==
===Library===
<
import (
Line 33 ⟶ 1,050:
result := crc32.ChecksumIEEE(s)
fmt.Printf("%X\n", result)
}</
{{out}}
<pre>414FA339</pre>
===Implementation===
<
import "fmt"
Line 67 ⟶ 1,085:
func main() {
fmt.Printf("%0x\n", crc32("The quick brown fox jumps over the lazy dog"))
}</
{{out}}
<pre>
414fa339
</pre>
=={{header|Groovy}}==
<syntaxhighlight lang=Groovy>def crc32(byte[] bytes) {
new java.util.zip.CRC32().with { update bytes; value }
}</syntaxhighlight>
Testing:
<syntaxhighlight lang=Groovy>assert '414FA339' == sprintf('%04X', crc32('The quick brown fox jumps over the lazy dog'.bytes))</syntaxhighlight>
=={{header|Haskell}}==
Pure Haskell:
<syntaxhighlight lang=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"</syntaxhighlight>
{{Out}}
<pre>414fa339</pre>
Using the zlib C library ( compile with "ghc -lz file.hs"):
<syntaxhighlight lang=haskell>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 ""</syntaxhighlight>
{{Out}}
<pre>414fa339</pre>
=={{header|Haxe}}==
<syntaxhighlight lang=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());
}
}</syntaxhighlight>
{{out}}
<pre>414FA339</pre>
=={{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.
<syntaxhighlight lang=Icon>link hexcvt,printf
procedure main()
Line 102 ⟶ 1,195:
}
crc := ixor(0,mask) #
every crc := iand(
ixor(crcL[iand(255,ixor(crc,ord(!s)))+1],ishift(crc,-8)))
return hexstring(ixor(crc,mask)) # return hexstring
end</syntaxhighlight>
{{libheader|Icon Programming Library}}
[http://www.cs.arizona.edu/icon/library/src/procs/hexcvt.icn hexcvt.
[http://www.cs.arizona.edu/icon/library/src/procs/printf.icn printf.
{{out}}
<pre>crc("The quick brown fox jumps over the lazy dog")=414FA339 - implementation is correct</pre>
=={{header|J}}==
<
_3199229127</
Other possible representations of this result:
<
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</
=={{header|Java}}==
<syntaxhighlight lang=Java>
import java.util.zip.CRC32;
</syntaxhighlight>
<syntaxhighlight lang=Java>
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());
}
</syntaxhighlight>
{{out}}
<pre>
414fa339
</pre>
=={{header|JavaScript}}==
<syntaxhighlight lang=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
);
})();</syntaxhighlight>
{{Out}}
<pre>0x414fa339</pre>
=={{header|Jsish}}==
From the shell
<syntaxhighlight lang=javascript># Util.crc32('The quick brown fox jumps over the lazy dog').toString(16);</syntaxhighlight>
{{out}}
<pre>"414fa339"</pre>
=={{header|jq}}==
'''Adapted from [[#Wren|Wren]]'''
'''Works with jq, the C implementation of jq'''
'''Works with gojq, the Go implementation of jq'''
The following program will also work with jaq, the Rust implementation
of jq, provided the relevant functions of the
[[:Category:jq/bitwise.jq| "bitwise" module]]
are included in place of the "include" directive, and that
the definition of `div` is modified to read as follows:
<syntaxhighlight lang=jq>
def div($j):
((. - (. % $j)) / $j) | round;
</syntaxhighlight>
<syntaxhighlight lang=jq>
include "bitwise" {search: "."}; # see above
# non-negative decimal integer to hex string
def hex:
def stream:
recurse(if . >= 16 then ./16|floor else empty end) | . % 16 ;
[stream] | reverse
| map(if . < 10 then 48 + . else . + 87 end) | implode ;
### CRC-32
def crc32Table:
reduce range(0; 256) as $i ([];
. + [reduce range(0; 8) as $j ($i;
if bitwise_and(.;1) == 1
then bitwise_xor(rightshift(1); 3988292384) # 0xedb88320
else rightshift( 1 )
end) ] );
# Input: an ASCII string
# Output: its CRC-32
def crc32:
explode as $s
| crc32Table as $table
| reduce range(0; $s|length) as $i (4294967295 ; # ~0
# 0xff is 255
bitwise_and(.; 255 ) as $crb
| bitwise_xor( $table[bitwise_xor($crb; $s[$i])] ; rightshift(8)) )
| flip(32) ;
def task:
crc32 | hex;
"The quick brown fox jumps over the lazy dog" | task
</syntaxhighlight>
{{output}}
<pre>
414fa339
</pre>
=={{header|Julia}}==
===Using the zlib Library===
<syntaxhighlight lang=julia>using Libz
println(string(Libz.crc32(UInt8.(b"The quick brown fox jumps over the lazy dog")), base=16))
</syntaxhighlight>{{out}}
<pre>
414fa339
</pre>
===Source Implementation===
{{works with|Julia|0.6}}
<syntaxhighlight lang=Julia>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))</syntaxhighlight>
{{out}}
<pre>Message: The quick brown fox jumps over the lazy dog
Checksum: 414fa339</pre>
=={{header|Kotlin}}==
<syntaxhighlight lang=scala>// 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)}")
}
}</syntaxhighlight>
{{out}}
<pre>
The CRC-32 checksum of 'The quick brown fox jumps over the lazy dog' = 414fa339
</pre>
=={{header|Lingo}}==
===Pure Lingo===
<syntaxhighlight lang=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"</syntaxhighlight>
Implementation:
<syntaxhighlight lang=lingo>--****************************************************************************
-- @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</syntaxhighlight>
===Using an "Xtra" (=binary plugin)===
<syntaxhighlight lang=lingo>cx = Xtra("Crypto").new()
put cx.cx_crc32_string("The quick brown fox jumps over the lazy dog")
-- "414fa339"</syntaxhighlight>
=={{header|Lua}}==
===Using Library===
[https://github.com/brimworks/lua-zlib <code>zlib.crc32</code>]
<syntaxhighlight lang=lua>local compute=require"zlib".crc32()
local sum=compute("The quick brown fox jumps over the lazy dog")
print(string.format("0x%x", sum))
</syntaxhighlight>
{{out}}
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}}==
===Using Code===
<syntaxhighlight lang=M2000 Interpreter>
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
</syntaxhighlight>
===Using Api===
<syntaxhighlight lang=M2000 Interpreter>
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
</syntaxhighlight>
=={{header|Mathematica}} / {{header|Wolfram Language}}==
<syntaxhighlight lang=Mathematica>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"]
]
</syntaxhighlight>
{{out}}
<pre>
The CRC32 hash code of "The quick brown fox jumps over the lazy dog" is 414fa339.
</pre>
=={{header|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.
<syntaxhighlight lang=ActionScript>/**
<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")</syntaxhighlight>
{{out}}
<pre>prompt$ nekoc crc32.neko
prompt$ neko crc32.n
1095738169
prompt$ dc -e "$(neko crc32.n) 16op"
414FA339</pre>
=={{header|NetRexx}}==
{{trans|Java}}
<syntaxhighlight lang=NetRexx>/* 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
</syntaxhighlight>
{{out}}
<pre>
The CRC-32 value is : 414fa339 !
</pre>
=={{header|Nim}}==
<syntaxhighlight lang=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)</syntaxhighlight>
{{out}}
<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}}==
{{Works with|oo2c Version 2}}
<syntaxhighlight lang=oberon2>
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.
</syntaxhighlight>
{{out}}
<pre>
414FA339
</pre>
=={{header|Objeck}}==
<syntaxhighlight lang=objeck>class CRC32 {
function : Main(args : String[]) ~ Nil {
"The quick brown fox jumps over the lazy dog"->ToByteArray()->CRC32()->PrintLine();
}
}
</syntaxhighlight>
{{out}}
<pre>
1095738169
</pre>
=={{header|OCaml}}==
{{libheader|camlzip}}
<syntaxhighlight lang=ocaml>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</syntaxhighlight>
Running this code in interpreted mode:<nowiki>[[Media:Insert non-formatted text here]][[File:[Example.jpg][http://www.example.com link title]]]</nowiki>
<pre>
$ ocaml unix.cma -I +zip zip.cma crc.ml
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>
=={{header|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.
<syntaxhighlight lang=oorexx>/* 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 </syntaxhighlight>
{{out}}
<pre>The CRC-32 value of "The quick brown fox jumps over the lazy dog" is: 414FA339</pre>
=={{header|PARI/GP}}==
Using Linux system library (Linux only solution)
{{libheader|libz.so}}
<syntaxhighlight lang=parigp>
install("crc32", "lLsL", "crc32", "libz.so");
s = "The quick brown fox jumps over the lazy dog";
printf("%0x\n", crc32(0, s, #s))
</syntaxhighlight>
Output:
<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|PascalABC.NET}}==
<syntaxhighlight lang="delphi">
type
TCrc32 = array[0..255] of longword;
function CreateCrcTable(): TCrc32;
begin
for var i: longword := 0 to 255 do
begin
var rem := i;
for var j := 0 to 7 do
if (rem and 1) > 0 then rem := (rem shr 1) xor $edb88320
else rem := rem shr 1;
result[i] := rem
end;
end;
const
Crc32Table = CreateCrcTable;
function Crc32(s: string): longword;
begin
result := $ffffffff;
foreach var c in s do
result := (result shr 8) xor Crc32Table[(result and $ff) xor byte(c)];
result := not result
end;
begin
writeln('crc32 = ', crc32('The quick brown fox jumps over the lazy dog').ToString('X'));
end.
</syntaxhighlight>
{{out}}
<pre>
crc32 = 414FA339
</pre>
=={{header|Perl}}==
<syntaxhighlight lang=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( ) ;
</syntaxhighlight>
{{out}}
<pre>The checksum is 414fa339</pre>
=={{header|Phix}}==
Included as demo\rosetta\crc32.exw, which also includes a thread-safe version
<!--<syntaxhighlight lang="phix">(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<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>
<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>
<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>
<span style="color: #000000;">have_table</span> <span style="color: #0000FF;">=</span> <span style="color: #004600;">true</span>
<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>
<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>
<span style="color: #004080;">atom</span> <span style="color: #000000;">rem</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">i</span>
<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>
<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>
<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>
<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>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<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>
<span style="color: #000000;">rem</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">#100000000</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<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>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<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>
<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>
<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>
<span style="color: #000000;">crc</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">#100000000</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<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>
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
<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>
<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>
<!--</syntaxhighlight>-->
{{out}}
<pre>
The CRC of The quick brown fox jumps over the lazy dog is 414FA339
</pre>
=={{header|PHP}}==
PHP has a built-in function [http://us2.php.net/manual/en/function.crc32.php crc32].
<syntaxhighlight lang=php>printf("%x\n", crc32("The quick brown fox jumps over the lazy dog"));</syntaxhighlight>
<pre>414fa339</pre>
=={{header|PicoLisp}}==
Library and implementation.
<syntaxhighlight lang=PicoLisp>(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)</syntaxhighlight>
=={{header|Pike}}==
<syntaxhighlight lang=Pike>string foo = "The quick brown fox jumps over the lazy dog";
write("0x%x\n", Gz.crc32(foo));</syntaxhighlight>
{{Out}}
<pre>
0x414fa339
</pre>
=={{header|PL/I}}==
<syntaxhighlight lang=pli>*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;</syntaxhighlight>
{{out}}
<pre>
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
</pre>
=={{header|PowerBASIC}}==
<syntaxhighlight lang=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</syntaxhighlight>
{{out}}
<pre>Text: The quick brown fox jumps over the lazy dog
CRC32: 414FA339</pre>
=={{header|PureBasic}}==
{{works with|PB Version 5.40}}
<syntaxhighlight lang=PureBasic>
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</syntaxhighlight>
{{out}}<pre>CRC32 Cecksum [hex] = 414FA339
CRC32 Cecksum [dec] = 1095738169</pre>
=={{header|Python}}==
===Library===
[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.
<syntaxhighlight lang=python>>>> s = 'The quick brown fox jumps over the lazy dog'
>>> import zlib
>>> hex(zlib.crc32(s))
'0x414fa339'
>>> import binascii
>>> hex(binascii.crc32(s))
'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.
===Implementation===
====Procedural====
<syntaxhighlight lang=python>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)))</syntaxhighlight>
====Composition of pure functions====
<syntaxhighlight lang=Python>'''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()</syntaxhighlight>
{{Out}}
<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}}==
<syntaxhighlight lang=R>
digest("The quick brown fox jumps over the lazy dog","crc32", serialize=F)
</syntaxhighlight>
{{out}}
<pre>[1] "414fa339"</pre>
=={{header|Racket}}==
<syntaxhighlight lang=scheme>#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"))</syntaxhighlight>
{{out}}
<pre>"414fa339"</pre>
=={{header|Raku}}==
(formerly Perl 6)
=== Call to native function crc32 in zlib ===
<syntaxhighlight lang=raku line>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');</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.
{{out}}
<pre>414fa339</pre>
=== Pure Raku ===
A fairly generic implementation with no regard to execution speed:
<syntaxhighlight lang=raku line>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);</syntaxhighlight>
{{out}}
<pre>414FA339</pre>
=={{header|REXX}}==
<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].*/
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</syntaxhighlight>
{{out|output|text= when using the internal default input:}}
<pre>
══════════════════════ 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
</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>
=={{header|Ruby}}==
Use 'zlib' from standard library.
<syntaxhighlight lang=ruby>require 'zlib'
printf "0x%08x\n", Zlib.crc32('The quick brown fox jumps over the lazy dog')
# => 0x414fa339</syntaxhighlight>
Reimplement CRC-32 in Ruby, with comments to show the polynomials.
<syntaxhighlight lang=ruby>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, 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
# octet[ 7] * x**32 + ... + octet[0] * x**39
# Divisor[32] * x**0 + ... + Divisor[0] * x**32
Line 158 ⟶ 2,614:
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|
#
# Our current
# new _octet_
# crc[32] * x**8 + crc[31] * x**9 + ... + crc[8] * x**31 \
#
# + (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]
#
#
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
Line 186 ⟶ 2,652:
printf "0x%08x\n", CRC.crc32("The quick brown fox jumps over the lazy dog")
# => 0x414fa339</
=={{header|Rust}}==
This does not perform any caching of the lookup table for simplicity.
<syntaxhighlight lang=rust>
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"));
}
</syntaxhighlight>
{{Output}}
<pre>
414fa339
</pre>
=={{header|Scala}}==
{{trans|Java}}
<syntaxhighlight lang=scala>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</syntaxhighlight>
=={{header|Seed7}}==
<syntaxhighlight lang=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;</syntaxhighlight>
{{out}}
<pre>
414fa339
</pre>
=={{header|Shell}}==
===Bash===
<syntaxhighlight lang=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
</syntaxhighlight>
===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 <code>awk</code> or <code>tr</code>.
<syntaxhighlight lang=bash>#!/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</syntaxhighlight>
{{out}}
<pre>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</pre>
=={{header|Smalltalk}}==
{{works with|Smalltalk/X}}
the CRC32Stream utility class can do it for me:
<syntaxhighlight lang=smalltalk>CRC32Stream hashValueOf:'The quick brown fox jumps over the lazy dog'</syntaxhighlight>
{{out}}
1095738169 "which is 16r414FA339"
=={{header|Swift}}==
Using the zlib crc32 function available to Swift from libz.dylib.
<syntaxhighlight lang=Swift>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))</syntaxhighlight>
{{out}}
<pre>414FA339
</pre>
=={{header|Tcl}}==
<
set data "The quick brown fox jumps over the lazy dog"
puts [format "%x" [zlib crc32 $data]]</
{{out}}
<pre>414fa339</pre>
Alternatively, with older versions of Tcl:
{{tcllib|crc32}}
<
puts [format "%x" [crc::crc32 $data]]</
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}}==
===Library===
<syntaxhighlight lang=vala>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));
}</syntaxhighlight>
{{out}}
<pre>
414fa339
</pre>
===Implementation===
<syntaxhighlight lang=vala>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"));
}</syntaxhighlight>
{{out}}
<pre>
414fa339
</pre>
=={{header|VAX Assembly}}==
<syntaxhighlight lang=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</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}}==
{{works with|Visual Basic|5}}
{{works with|Visual Basic|6}}
{{works with|VBA|Access 97}}
{{works with|VBA|6.5}}
{{works with|VBA|7.1}}
{{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.
<syntaxhighlight lang=vb>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</syntaxhighlight>
=={{header|Visual Basic .NET}}==
Allows the resumption of calculations, useful for processing a large file with a series of buffer reads.
<syntaxhighlight lang=vbnet>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</syntaxhighlight>
Test:
<syntaxhighlight lang=vbnet> ' 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</syntaxhighlight>
Output:
<syntaxhighlight lang=text>Input = "The quick brown fox jumps over the lazy dog"
Crc32 = 414FA339
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}}==
{{trans|Go}}
{{libheader|Wren-fmt}}
<syntaxhighlight lang="wren">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))</syntaxhighlight>
{{out}}
<pre>
414fa339
</pre>
=={{header|XPL0}}==
<syntaxhighlight lang=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))</syntaxhighlight>
{{out}}
<pre>
414FA339
</pre>
=={{header|zkl}}==
Using zlib:
<syntaxhighlight lang=zkl>var [const] ZLib=Import("zeelib");
ZLib.calcCRC32(Data(Void,"The quick brown fox jumps over the lazy dog"));
//-->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>
| |||