CRC-32: Difference between revisions

=={{header|11l}}==

{{trans|C}}

L(i) 256

UInt32 rem = i

L 8

rem >>= 1

rem (+)= EDB8'8320

 

F crc32(buf, =crc = UInt32(0))

L(k) buf

 

 

{{out}}

</pre>

 

=={{header|Ada}}==

{{works with|GNAT}}

with GNAT.CRC32; use GNAT.CRC32;

with Interfaces; use Interfaces;

num := Get_Value (crc);

IIO.Put (num, Base => 16); New_Line;

{{out}}

<pre>16#414FA339#</pre>

 

=={{header|ALGOL 68}}==

[0:255]BITS crc_table;

BOOL crc_table_computed := FALSE;

STRING s = "The quick brown fox jumps over the lazy dog";

print(("CRC32 OF ", s, " is: ", hex (crc (s)), newline))

 

{{out}}

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

 

=={{header|AutoHotkey}}==

===DllCall / WinAPI===

{

l := (enc = "CP1200" || enc = "UTF-16") ? 2 : 1, s := (StrPut(str, enc) - 1) * l

}

 

{{out}}

<pre>0x414fa339</pre>

 

===Implementation===

{

static table := []

}

 

{{out}}

<pre>0x414fa339</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>

 

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.

 

#include <stdio.h>

#include <string.h>

return 0;

 

=={{header|C sharp|C#}}==

/// <summary>

/// Performs 32-bit reversed cyclic redundancy checks.

#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"));

 

{{out}}

=={{header|C++}}==

 

#include <cstdint>

#include <numeric>

 

// These headers are only needed for main(), to demonstrate.

#include <iomanip>

#include <iostream>

 

 

}

 

{{out}}

<pre>

</pre>

{{libheader|boost}}

#include <string>

#include <iostream>

std::cout << "Checksum: " << std::hex << crc.checksum() << std::endl;

return 0;

{{out}}

<pre>

=={{header|Clojure}}==

{{trans|Java}}

str "The quick brown fox jumps over the lazy dog"]

(. crc update (. str getBytes))

 

{{out}}

=={{header|COBOL}}==

{{works with|GnuCOBOL}} {{libheader|zlib}}

identification division.

program-id. rosetta-crc32.

 

goback.

{{out}}

<pre>prompt$ cobc -xj crc32-zlib.cob -lz

=={{header|CoffeeScript}}==

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

crc32 = do ->

table =

crc = crc >>> 8 ^ table[(crc ^ c.charCodeAt 0) & 255]

(crc ^ -1) >>> 0

Test:

Output:

 

=={{header|Common Lisp}}==

{{libheader|Ironclad}}

(defun string-to-digest (str digest)

"Return the specified digest for the ASCII string as a hex string."

 

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

{{out}}

<pre>"414fa339"</pre>

BlackBox Component Builder<br/>

Require ZLib Subsystem

MODULE BbtComputeCRC32;

IMPORT ZlibCrc32,StdLog;

END Do;

END BbtComputeCRC32.

Execute: ^Q BbtComputeCRC32.Do<br/>

{{out}}

<pre>

0414FA339%16

</pre>

 

=={{header|D}}==

import std.stdio, std.digest.crc;

 

"The quick brown fox jumps over the lazy dog"

.crc32Of.crcHexString.writeln;

{{out}}

<pre>414FA339</pre>

 

=={{header|Delphi}}==

 

{$APPTYPE CONSOLE}

CRC := crc32(0, @Data[1], Length(Data));

WriteLn(Format('CRC32 = %8.8X', [CRC]));

{{out}}

<pre>CRC32 = 414FA339</pre>

 

=={{header|Elixir}}==

def crc32(str) do

IO.puts :erlang.crc32(str) |> Integer.to_string(16)

end

 

 

{{out}}

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">>)]).

 

{{out}}

16#414FA339

 

module Crc32 =

let result = crc32OfAscii testString

printfn "CRC32: 0x%x" result

 

{{out}}

ASCII Input: The quick brown fox jumps over the lazy dog

CRC32: 0x414fa339

 

=={{header|Factor}}==

 

=={{header|FBSL}}==

 

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

 

{{out}}

<pre>414FA339

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 ;

 

 

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

 

=={{header|Fortran}}==

use iso_fortran_env

implicit none

call update_crc(s, crc)

print "(Z8)", crc

 

=={{header|FreeBASIC}}==

{{trans|C}}

' compile with: fbc -s console

 

Print : Print "hit any key to end program"

Sleep

{{out}}

<pre>input = The quick brown fox jumps over the lazy dog

=={{header|Go}}==

===Library===

 

import (

result := crc32.ChecksumIEEE(s)

fmt.Printf("%X\n", result)

{{out}}

<pre>414FA339</pre>

 

===Implementation===

 

import "fmt"

func main() {

fmt.Printf("%0x\n", crc32("The quick brown fox jumps over the lazy dog"))

{{out}}

<pre>

 

=={{header|Groovy}}==

new java.util.zip.CRC32().with { update bytes; value }

Testing:

 

=={{header|Haskell}}==

Pure Haskell:

 

import Data.Word (Word32)

import Numeric (showHex)

 

main :: IO ()

{{Out}}

<pre>414fa339</pre>

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

 

import Numeric (showHex)

import Foreign.C

ptr <- newCString s

let r = zlib_crc32 0 ptr (genericLength s)

{{Out}}

<pre>414fa339</pre>

 

=={{header|Haxe}}==

 

class Main {

Sys.println(crc.hex());

}

 

{{out}}

=={{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.

 

procedure main()

ixor(crcL[iand(255,ixor(crc,ord(!s)))+1],ishift(crc,-8)))

return hexstring(ixor(crc,mask)) # return hexstring

 

{{libheader|Icon Programming Library}}

 

=={{header|J}}==

 

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'

 

=={{header|Java}}==

{{out}}

 

=={{header|JavaScript}}==

'use strict';

 

 

// crc32 :: String -> Int

const crc32 = str => {

// table :: [Int]

iterate(

x => (

);

};

 

 

// chars :: String -> [Char]

 

// enumFromTo :: Int -> Int -> [Int]

 

 

 

// iterate :: (a -> a) -> a -> Gen [a]

 

 

// showHex :: Int -> String

const showHex = n =>

 

// take :: Int -> [a] -> [a]

// take :: Int -> String -> String

xs.slice(0, n)

) : [].concat.apply([], Array.from({

result

);

{{Out}}

 

=={{header|Jsish}}==

From the shell

{{out}}

<pre>"414fa339"</pre>

=={{header|Julia}}==

===Using the zlib Library===

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

<pre>

414fa339

===Source Implementation===

{{works with|Julia|0.6}}

table = zeros(UInt32, 256)

 

assert(crc == 0x414fa339)

println("Message: ", str)

 

{{out}}

 

=={{header|Kotlin}}==

 

import java.util.zip.CRC32

println("The CRC-32 checksum of '$text' = ${"%x".format(value)}")

}

 

{{out}}

===Pure Lingo===

 

 

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

 

put crc32.toHexString(1, crc32.length)

 

Implementation:

 

-- @desc CRC-32 Class

-- @file parent script "CRC"

ba.position = 1

return ba

 

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

 

put cx.cx_crc32_string("The quick brown fox jumps over the lazy dog")

 

=={{header|Lua}}==

[https://github.com/brimworks/lua-zlib <code>zlib.crc32</code>]

 

local sum=compute("The quick brown fox jumps over the lazy dog")

print(string.format("0x%x", sum))

 

{{out}}

0x414fa339

 

=={{header|M2000 Interpreter}}==

===Using Code===

Module CheckIt {

Function PrepareTable {

}

CheckIt

 

===Using Api===

Module CheckApi {

Declare CRC32 LIB "ntdll.RtlComputeCrc32" {Long Zero, a$, long s}

}

CheckApi

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

StringForm[

"The "<>type<>" hash code of \"``\" is ``.",

Hash[s,type,"HexString"]

]

{{out}}

<pre>

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>

**/

 

crc = update_crc32(crc, txt, 0, $ssize(txt))

 

{{out}}

=={{header|NetRexx}}==

{{trans|Java}}

options replace format comments java crossref symbols binary

 

 

return

 

{{out}}

 

=={{header|Nim}}==

 

type TCrc32* = uint32

 

proc createCrcTable(): array[0..255, TCrc32] =

result = InitCrc32

for c in s:

result = not result

 

{{out}}

<pre>414FA339</pre>

 

=={{header|Oberon-2}}==

{{Works with|oo2c Version 2}}

MODULE CRC32;

IMPORT

Out.Hex(Zlib.CRC32(0,s,0,Strings.Length(s)),0);Out.Ln

END CRC32.

{{out}}

<pre>

 

=={{header|Objeck}}==

function : Main(args : String[]) ~ Nil {

"The quick brown fox jumps over the lazy dog"->ToByteArray()->CRC32()->PrintLine();

}

}

 

{{out}}

{{libheader|camlzip}}

 

let s = "The quick brown fox jumps over the lazy dog" in

let crc = Zlib.update_crc 0l s 0 (String.length s) in

 

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

$ ocaml unix.cma -I +zip zip.cma crc.ml

crc: 414FA339

</pre>

 

This Program shows how easy it is to use JAVA functionality from ooRexx.

bsf4oorexx from Sourceforge https://sourceforge.net/projects/bsf4oorexx/ makes that possible.

clzCRC32=bsf.importClass("java.util.zip.CRC32")

myCRC32 =clzCRC32~new

say 'The CRC-32 value of "'toBeEncoded'" is:' myCRC32~getValue~d2x

 

{{out}}

<pre>The CRC-32 value of "The quick brown fox jumps over the lazy dog" is: 414FA339</pre>

{{libheader|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:

<pre>414fa339</pre>

 

=={{header|Perl}}==

use 5.010 ;

use strict ;

$crc->add ( "The quick brown fox jumps over the lazy dog" ) ;

say "The checksum is " . $crc->hexdigest( ) ;

{{out}}

<pre>The checksum is 414fa339</pre>

=={{header|Phix}}==

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

{{out}}

<pre>

PHP has a built-in function [http://us2.php.net/manual/en/function.crc32.php crc32].

 

 

<pre>414fa339</pre>

Library and implementation.

 

(mapcar

'((N)

(hex (native "libz.so" "crc32" 'N 0 Str (length Str))) ) )

 

=={{header|Pike}}==

{{Out}}

<pre>

 

=={{header|PL/I}}==

crct: Proc Options(main);

/*********************************************************************

End;

End;

{{out}}

<pre>

 

=={{header|PowerBASIC}}==

#DIM ALL

#COMPILER PBCC 6

crc = CRC32(STRPTR(s), LEN(s))

CON.PRINT "CRC32: " & HEX$(crc)

{{out}}

<pre>Text: The quick brown fox jumps over the lazy dog

=={{header|PureBasic}}==

{{works with|PB Version 5.40}}

a$="The quick brown fox jumps over the lazy dog"

 

Input()

 

{{out}}<pre>CRC32 Cecksum [hex] = 414FA339

CRC32 Cecksum [dec] = 1095738169</pre>

[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.

 

>>> import zlib

>>> hex(zlib.crc32(s))

>>> import binascii

>>> hex(binascii.crc32(s))

 

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====

a = []

for i in range(256):

crc_table = create_table()

 

====Composition of pure functions====

 

from functools import (reduce)

(a ^ ord(c)) & 0xff

],

(0xffffffff)

) ^ 0xffffffff

 

 

# main :: IO ()

def main():

 

 

 

# index (!!) :: [a] -> Int -> a

# iterate :: (a -> a) -> a -> Gen [a]

def iterate(f):

def go(x):

v = x

yield v

v = f(v)

 

 

if __name__ == '__main__':

{{Out}}

<pre>414fa339</pre>

 

=={{header|R}}==

digest("The quick brown fox jumps over the lazy dog","crc32", serialize=F)

{{out}}

<pre>[1] "414fa339"</pre>

 

=={{header|Racket}}==

(define (bytes-crc32 data)

(bitwise-xor

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

 

{{out}}

<pre>"414fa339"</pre>

=== Call to native function crc32 in zlib ===

 

sub crc32(int32 $crc, Buf $buf, int32 $len --> int32) is native('z') { * }

my $buf = 'The quick brown fox jumps over the lazy dog'.encode;

 

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.

A fairly generic implementation with no regard to execution speed:

 

Blob $buf,

# polynomial including leading term, default: ISO 3309/PNG/gzip

}

 

 

{{out}}

 

=={{header|REXX}}==

/*─────────────────────────────────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.*/

say "hex CRC─32 checksum =" c2x(checksum) left('', 15),

"dec CRC─32 checksum =" c2d(checksum) /*show the CRC─32 in hex and dec.*/

{{out|output|text=&nbsp; when using the internal default input:}}

<pre>

 

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

</pre>

 

Use 'zlib' from standard library.

 

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

 

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

 

# Divisor is a polynomial of degree 32 with coefficients modulo 2.

# We store Divisor in a 33-bit Integer; the polynomial is

 

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

 

=={{header|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];

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

}

{{Output}}

<pre>

=={{header|Scala}}==

{{trans|Java}}

val crc=new CRC32

crc.update("The quick brown fox jumps over the lazy dog".getBytes)

 

=={{header|Seed7}}==

include "crc32.s7i";

 

begin

writeln(ord(crc32("The quick brown fox jumps over the lazy dog")) radix 16 lpad0 8);

 

{{out}}

=={{header|Shell}}==

===Bash===

declare -i -a CRC32_LOOKUP_TABLE

 

# 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 <code>awk</code> or <code>tr</code>.

# POSIX Shell CRC32 of string

# @Name: crc32.sh

 

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

{{out}}

<pre>bash ./crc32.sh "The quick brown fox jumps over the lazy dog"

{{works with|Smalltalk/X}}

the CRC32Stream utility class can do it for me:

{{out}}

1095738169 "which is 16r414FA339"

=={{header|Swift}}==

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

 

let strData = "The quick brown fox jumps over the lazy dog".dataUsingEncoding(NSUTF8StringEncoding,

let crc = crc32(uLong(0), UnsafePointer<Bytef>(strData!.bytes), uInt(strData!.length))

 

{{out}}

<pre>414FA339

 

=={{header|Tcl}}==

 

set data "The quick brown fox jumps over the lazy dog"

{{out}}

<pre>414fa339</pre>

Alternatively, with older versions of Tcl:

{{tcllib|crc32}}

With the same input data, it produces identical output.

 

=={{header|TXR}}==

===Standard Library===

{{out}}

<pre>1095738169</pre>

===FFI access to Zlib===

{{out}}

<pre>$ txr -i crc32-zlib.tl

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===

#(#x00000000 #x77073096 #xee0e612c #x990951ba #x076dc419 #x706af48f

#xe963a535 #x9e6495a3 #x0edb8832 #x79dcb8a4 #xe0d5e91e #x97d2d988

(let ((crc #xffffffff)

(l (len buf)))

(set crc (logxor [crc-tab (logand (logxor crc [buf i]) #xff)]

{{out}}

<pre>$ ./txr -i crc.tl

=={{header|Vala}}==

===Library===

 

void main() {

var str = (uint8[])"The quick brown fox jumps over the lazy dog".to_utf8();

stdout.printf("%lx\n", crc32(0, str));

{{out}}

<pre>

</pre>

===Implementation===

{

private const uint32 s_generator = 0xedb88320u;

var crc32 = new Crc32();

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

 

{{out}}

 

=={{header|VAX Assembly}}==

00000044 0004 2 table: .blkl 16

0044 3

67 6F 64 20 79 7A 61 00BC

0000002B 00C3 18 len = .-msg

 

=={{header|Visual Basic}}==

{{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.

Declare Function RtlComputeCrc32 Lib "ntdll.dll" _

(ByVal dwInitial As Long, pData As Any, ByVal iLen As Long) As Long

Debug.Assert l = &H414FA339

 

 

=={{header|Visual Basic .NET}}==

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

 

' Table for pre-calculated values.

End Function

 

Test:

Function Str2BA(Str As String) As Byte()

Return System.Text.Encoding.ASCII.GetBytes(Str)

Crc32.cs(Str2BA(Mid(Str, 1, 20)))

Debug.Print("Crc32 = " & HexF(Crc32.cs(Str2BA(Mid(Str, 21)), False), 8))

Output:

Crc32 = 414FA339

 

=={{header|Wren}}==

{{trans|Go}}

{{libheader|Wren-fmt}}

 

class CRC32 {

CRC32.init()

var crc = CRC32.compute("The quick brown fox jumps over the lazy dog")

 

{{out}}

 

=={{header|XPL0}}==

string 0; \use zero-terminated strings

 

];

 

 

{{out}}

=={{header|zkl}}==

Using zlib:

ZLib.calcCRC32(Data(Void,"The quick brown fox jumps over the lazy dog"));