CRC-32: Difference between revisions
m
syntax highlighting fixup automation
Thundergnat (talk | contribs) m (syntax highlighting fixup automation) |
|||
Line 21:
=={{header|11l}}==
{{trans|C}}
<
L(i) 256
UInt32 rem = i
Line 38:
R (-)crc
print(hex(crc32(‘The quick brown fox jumps over the lazy dog’)))</
{{out}}
Line 46:
=={{header|6502 Assembly}}==
<
string EQU $EC
Line 158:
TXA
BNE loop4
RTS</
=={{header|Ada}}==
{{works with|GNAT}}
<
with GNAT.CRC32; use GNAT.CRC32;
with Interfaces; use Interfaces;
Line 174:
num := Get_Value (crc);
IIO.Put (num, Base => 16); New_Line;
end TestCRC;</
{{out}}
<pre>16#414FA339#</pre>
Line 180:
=={{header|Arturo}}==
<
{{out}}
Line 187:
=={{header|ALGOL 68}}==
<
[0:255]BITS crc_table;
BOOL crc_table_computed := FALSE;
Line 242:
STRING s = "The quick brown fox jumps over the lazy dog";
print(("CRC32 OF ", s, " is: ", hex (crc (s)), newline))
</syntaxhighlight>
{{out}}
Line 249:
=={{header|Applesoft BASIC}}==
===Implementation using Binary ASCII===
<
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"
Line 324:
960 DATA238,01000111101100101100111101111111
970 DATA181,10111011000010110100011100000011
980 DATA114,10111110000010110001000000010000</
===Using 6502 Assembly===
<
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
Line 353:
300 PRINT MID$ ("0123456789ABCDEF",B / 16 + 1,1);
310 B = (B - INT (B / 16) * 16) * 16
320 NEXT J,I</
=={{header|AutoHotkey}}==
===DllCall / WinAPI===
<
{
l := (enc = "CP1200" || enc = "UTF-16") ? 2 : 1, s := (StrPut(str, enc) - 1) * l
Line 365:
}
MsgBox % CRC32("The quick brown fox jumps over the lazy dog")</
{{out}}
<pre>0x414fa339</pre>
===Implementation===
<
{
static table := []
Line 385:
}
MsgBox % CRC32("The quick brown fox jumps over the lazy dog")</
{{out}}
<pre>0x414fa339</pre>
Line 392:
===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 402:
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>
Line 454:
return 0;
}</
=={{header|C sharp|C#}}==
<
/// <summary>
/// Performs 32-bit reversed cyclic redundancy checks.
Line 528:
#endregion
}
</syntaxhighlight>
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"));
</syntaxhighlight>
{{out}}
Line 543:
=={{header|C++}}==
<
#include <array>
#include <cstdint>
Line 604:
std::cout << std::hex << std::setw(8) << std::setfill('0') << crc(s.begin(), s.end()) << '\n';
}
</syntaxhighlight>
{{out}}
<pre>
Line 620:
</pre>
{{libheader|boost}}
<
#include <string>
#include <iostream>
Line 632:
std::cout << "Checksum: " << std::hex << crc.checksum() << std::endl;
return 0;
}</
{{out}}
<pre>
Line 640:
=={{header|Clojure}}==
{{trans|Java}}
<
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))))</
{{out}}
Line 651:
=={{header|COBOL}}==
{{works with|GnuCOBOL}} {{libheader|zlib}}
<
identification division.
program-id. rosetta-crc32.
Line 687:
goback.
end program rosetta-crc32.</
{{out}}
<pre>prompt$ cobc -xj crc32-zlib.cob -lz
Line 696:
=={{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 =
Line 710:
crc = crc >>> 8 ^ table[(crc ^ c.charCodeAt 0) & 255]
(crc ^ -1) >>> 0
</syntaxhighlight>
Test:
<
Output:
<syntaxhighlight lang=text>414fa339</
=={{header|Common Lisp}}==
{{libheader|Ironclad}}
<
(defun string-to-digest (str digest)
"Return the specified digest for the ASCII string as a hex string."
Line 726:
(string-to-digest "The quick brown fox jumps over the lazy dog" :crc32)
</syntaxhighlight>
{{out}}
<pre>"414fa339"</pre>
Line 733:
BlackBox Component Builder<br/>
Require ZLib Subsystem
<
MODULE BbtComputeCRC32;
IMPORT ZlibCrc32,StdLog;
Line 746:
END Do;
END BbtComputeCRC32.
</syntaxhighlight>
Execute: ^Q BbtComputeCRC32.Do<br/>
{{out}}
Line 754:
=={{header|Crystal}}==
<
require "digest/crc32";
p Digest::CRC32.checksum("The quick brown fox jumps over the lazy dog").to_s(16)
</syntaxhighlight>
{{out}}
<pre>
Line 765:
=={{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}
Line 789:
CRC := crc32(0, @Data[1], Length(Data));
WriteLn(Format('CRC32 = %8.8X', [CRC]));
end.</
{{out}}
<pre>CRC32 = 414FA339</pre>
=={{header|Elixir}}==
<
def crc32(str) do
IO.puts :erlang.crc32(str) |> Integer.to_string(16)
Line 800:
end
Test.crc32("The quick brown fox jumps over the lazy dog")</
{{out}}
Line 810:
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">>)]).
</syntaxhighlight>
{{out}}
<
16#414FA339
</syntaxhighlight>
=={{header|F Sharp|F#}}==
<
module Crc32 =
Line 863:
let result = crc32OfAscii testString
printfn "CRC32: 0x%x" result
</syntaxhighlight>
{{out}}
<
ASCII Input: The quick brown fox jumps over the lazy dog
CRC32: 0x414fa339
</syntaxhighlight>
=={{header|Factor}}==
Line 882:
=={{header|FBSL}}==
<
PRINT HEX(CHECKSUM("The quick brown fox jumps over the lazy dog"))
PAUSE</
{{out}}
<pre>414FA339
Line 895:
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 ;
Line 907:
$ffffffff s" The quick brown fox jumps over the lazy dog" crcbuf $ffffffff xor hex. bye \ $414FA339
</syntaxhighlight>
=={{header|Fortran}}==
<
use iso_fortran_env
implicit none
Line 954:
call update_crc(s, crc)
print "(Z8)", crc
end program</
=={{header|FreeBASIC}}==
{{trans|C}}
<
' compile with: fbc -s console
Line 1,007:
Print : Print "hit any key to end program"
Sleep
End</
{{out}}
<pre>input = The quick brown fox jumps over the lazy dog
Line 1,015:
=={{header|Go}}==
===Library===
<
import (
Line 1,026:
result := crc32.ChecksumIEEE(s)
fmt.Printf("%X\n", result)
}</
{{out}}
<pre>414FA339</pre>
===Implementation===
<
import "fmt"
Line 1,061:
func main() {
fmt.Printf("%0x\n", crc32("The quick brown fox jumps over the lazy dog"))
}</
{{out}}
<pre>
Line 1,068:
=={{header|Groovy}}==
<
new java.util.zip.CRC32().with { update bytes; value }
}</
Testing:
<
=={{header|Haskell}}==
Line 1,078:
Pure Haskell:
<
import Data.Word (Word32)
import Numeric (showHex)
Line 1,103:
main :: IO ()
main = putStrLn $ crc32 "The quick brown fox jumps over the lazy dog"</
{{Out}}
<pre>414fa339</pre>
Line 1,110:
Using the zlib C library ( compile with "ghc -lz file.hs"):
<
import Numeric (showHex)
import Foreign.C
Line 1,122:
ptr <- newCString s
let r = zlib_crc32 0 ptr (genericLength s)
putStrLn $ showHex r ""</
{{Out}}
<pre>414fa339</pre>
=={{header|Haxe}}==
<
class Main {
Line 1,135:
Sys.println(crc.hex());
}
}</
{{out}}
Line 1,143:
=={{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()
Line 1,175:
ixor(crcL[iand(255,ixor(crc,ord(!s)))+1],ishift(crc,-8)))
return hexstring(ixor(crc,mask)) # return hexstring
end</
{{libheader|Icon Programming Library}}
Line 1,185:
=={{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}}==
<
public class CRCMaker {
Line 1,206:
System.out.println( "The CRC-32 value is : " + Long.toHexString( myCRC.getValue( ) ) + " !" ) ;
}
}</
{{out}}
<pre>The CRC-32 value is : 414fa339 !</pre>
=={{header|JavaScript}}==
<
'use strict';
Line 1,308:
result
);
})();</
{{Out}}
<pre>0x414fa339</pre>
Line 1,314:
=={{header|Jsish}}==
From the shell
<
{{out}}
<pre>"414fa339"</pre>
Line 1,320:
=={{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
Line 1,329:
===Source Implementation===
{{works with|Julia|0.6}}
<
table = zeros(UInt32, 256)
Line 1,359:
assert(crc == 0x414fa339)
println("Message: ", str)
println("Checksum: ", hex(crc))</
{{out}}
Line 1,366:
=={{header|Kotlin}}==
<
import java.util.zip.CRC32
Line 1,377:
println("The CRC-32 checksum of '$text' = ${"%x".format(value)}")
}
}</
{{out}}
Line 1,388:
===Pure Lingo===
<
crc32 = crcObj.crc32("The quick brown fox jumps over the lazy dog")
Line 1,396:
put crc32.toHexString(1, crc32.length)
-- "41 4f a3 39"</
Implementation:
<
-- @desc CRC-32 Class
-- @file parent script "CRC"
Line 1,466:
ba.position = 1
return ba
end</
===Using an "Xtra" (=binary plugin)===
<
put cx.cx_crc32_string("The quick brown fox jumps over the lazy dog")
-- "414fa339"</
=={{header|Lua}}==
Line 1,478:
[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))
</syntaxhighlight>
{{out}}
0x414fa339
===Implementation===
<
function crc32(buf, size)
local crc = 0xFFFFFFFF
Line 1,521:
print(string.format("CRC32: %x", crc32(t,#str)))
</syntaxhighlight>
{{out}}
CRC32: 414fa339
Line 1,527:
=={{header|M2000 Interpreter}}==
===Using Code===
<
Module CheckIt {
Function PrepareTable {
Line 1,553:
}
CheckIt
</syntaxhighlight>
===Using Api===
<
Module CheckApi {
Declare CRC32 LIB "ntdll.RtlComputeCrc32" {Long Zero, a$, long s}
Line 1,564:
}
CheckApi
</syntaxhighlight>
=={{header|Mathematica}} / {{header|Wolfram Language}}==
<
StringForm[
"The "<>type<>" hash code of \"``\" is ``.",
Line 1,573:
Hash[s,type,"HexString"]
]
</syntaxhighlight>
{{out}}
<pre>
Line 1,582:
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>
**/
Line 1,593:
crc = update_crc32(crc, txt, 0, $ssize(txt))
$print(crc, "\n")</
{{out}}
Line 1,604:
=={{header|NetRexx}}==
{{trans|Java}}
<
options replace format comments java crossref symbols binary
Line 1,615:
return
</syntaxhighlight>
{{out}}
Line 1,623:
=={{header|Nim}}==
<
type TCrc32* = uint32
Line 1,645:
result = not result
echo crc32("The quick brown fox jumps over the lazy dog").int64.toHex(8)</
{{out}}
<pre>414FA339</pre>
Line 1,651:
=={{header|NOWUT}}==
adapted from FreeBASIC
<
sectionbss
Line 1,714:
endfunc crc
returnex 8 ; clean off 2 parameters from the stack
</syntaxhighlight>
{{out}}
<pre>input = The quick brown fox jumps over the lazy dog
Line 1,721:
=={{header|Oberon-2}}==
{{Works with|oo2c Version 2}}
<
MODULE CRC32;
IMPORT
Line 1,733:
Out.Hex(Zlib.CRC32(0,s,0,Strings.Length(s)),0);Out.Ln
END CRC32.
</syntaxhighlight>
{{out}}
<pre>
Line 1,740:
=={{header|Objeck}}==
<
function : Main(args : String[]) ~ Nil {
"The quick brown fox jumps over the lazy dog"->ToByteArray()->CRC32()->PrintLine();
}
}
</syntaxhighlight>
{{out}}
Line 1,756:
{{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
Printf.printf "crc: %lX\n" crc</
Running this code in interpreted mode:<nowiki>[[Media:Insert non-formatted text here]][[File:[Example.jpg][http://www.example.com link title]]]</nowiki>
Line 1,769:
=={{header|Ol}}==
<
(define (crc32 str)
(bxor #xFFFFFFFF
Line 1,788:
(print (number->string (crc32 (list->string (repeat #xFF 32))) 16))
(print (number->string (crc32 (list->string (iota 32))) 16))
</syntaxhighlight>
{{Out}}
<pre>
Line 1,800:
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
Line 1,808:
say 'The CRC-32 value of "'toBeEncoded'" is:' myCRC32~getValue~d2x
::requires "BSF.CLS" -- get Java bridge </
{{out}}
<pre>The CRC-32 value of "The quick brown fox jumps over the lazy dog" is: 414FA339</pre>
Line 1,817:
{{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))
</syntaxhighlight>
Output:
Line 1,827:
=={{header|Perl}}==
<
use 5.010 ;
use strict ;
Line 1,836:
$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>
Line 1,842:
=={{header|Phix}}==
Included as demo\rosetta\crc32.exw, which also includes a thread-safe version
<!--<
<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>
Line 1,878:
<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>
<!--</
{{out}}
<pre>
Line 1,887:
PHP has a built-in function [http://us2.php.net/manual/en/function.crc32.php crc32].
<
<pre>414fa339</pre>
Line 1,894:
Library and implementation.
<
(mapcar
'((N)
Line 1,920:
(hex (native "libz.so" "crc32" 'N 0 Str (length Str))) ) )
(bye)</
=={{header|Pike}}==
<
write("0x%x\n", Gz.crc32(foo));</
{{Out}}
<pre>
Line 1,931:
=={{header|PL/I}}==
<
crct: Proc Options(main);
/*********************************************************************
Line 2,028:
End;
End;
End;</
{{out}}
<pre>
Line 2,038:
=={{header|PowerBASIC}}==
<
#DIM ALL
#COMPILER PBCC 6
Line 2,085:
crc = CRC32(STRPTR(s), LEN(s))
CON.PRINT "CRC32: " & HEX$(crc)
END FUNCTION</
{{out}}
<pre>Text: The quick brown fox jumps over the lazy dog
Line 2,092:
=={{header|PureBasic}}==
{{works with|PB Version 5.40}}
<
a$="The quick brown fox jumps over the lazy dog"
Line 2,102:
Input()
End</
{{out}}<pre>CRC32 Cecksum [hex] = 414FA339
CRC32 Cecksum [dec] = 1095738169</pre>
Line 2,110:
[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))
Line 2,117:
>>> import binascii
>>> hex(binascii.crc32(s))
'0x414fa339'</
If you have Python 2.x, these functions might return a negative integer; you would need to use <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):
Line 2,140:
crc_table = create_table()
print(hex(crc_update(b"The quick brown fox jumps over the lazy dog", 0)))</
====Composition of pure functions====
<
from functools import (reduce)
Line 2,206:
if __name__ == '__main__':
main()</
{{Out}}
<pre>414fa339</pre>
Line 2,212:
=={{header|QB64}}==
{{trans|C}}
<
PRINT HEX$(crc32("The quick brown fox jumps over the lazy dog"))
Line 2,245:
crc32~& = NOT crc
END FUNCTION
</syntaxhighlight>
{{Out}}
<pre>414FA339</pre>
Line 2,253:
{{trans|Forth}}
<
256 times
Line 2,272:
16 base put
echo
base release</
{{out}}
Line 2,279:
=={{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}}==
<
(define (bytes-crc32 data)
(bitwise-xor
Line 2,300:
(bytes-crc32 (string->bytes/utf-8 s)))
(format "~x" (crc32 "The quick brown fox jumps over the lazy dog"))</
{{out}}
<pre>"414fa339"</pre>
Line 2,309:
=== Call to native function crc32 in zlib ===
<syntaxhighlight lang=raku
sub crc32(int32 $crc, Buf $buf, int32 $len --> int32) is native('z') { * }
my $buf = 'The quick brown fox jumps over the lazy dog'.encode;
say crc32(0, $buf, $buf.bytes).fmt('%08x');</
The libary name "z" resolves to <tt>/usr/lib/libz.so</tt> on a typical Linux system and <tt>/usr/lib/libz.dylib</tt> on Mac OS X, but may need to be changed for other platforms. Types may be platform-dependent as well. As written, the solution has been tested on Mac OS X 10.5.8 and Arch Linux 2016.08.01 x86_64.
Line 2,325:
A fairly generic implementation with no regard to execution speed:
<syntaxhighlight lang=raku
Blob $buf,
# polynomial including leading term, default: ISO 3309/PNG/gzip
Line 2,344:
}
say crc('The quick brown fox jumps over the lazy dog'.encode('ascii')).base(16);</
{{out}}
Line 2,350:
=={{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.*/
Line 2,380:
say "hex CRC─32 checksum =" c2x(checksum) left('', 15),
"dec CRC─32 checksum =" c2d(checksum) /*show the CRC─32 in hex and dec.*/
return</
{{out|output|text= when using the internal default input:}}
<pre>
Line 2,398:
Use 'zlib' from standard library.
<
printf "0x%08x\n", Zlib.crc32('The quick brown fox jumps over the lazy dog')
# => 0x414fa339</
Reimplement CRC-32 in Ruby, with comments to show the polynomials.
<
# Divisor is a polynomial of degree 32 with coefficients modulo 2.
# We store Divisor in a 33-bit Integer; the polynomial is
Line 2,478:
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.
<
fn crc32_compute_table() -> [u32; 256] {
let mut crc32_table = [0; 256];
Line 2,509:
println!("{:x}", crc32("The quick brown fox jumps over the lazy dog"));
}
</syntaxhighlight>
{{Output}}
<pre>
Line 2,517:
=={{header|Scala}}==
{{trans|Java}}
<
val crc=new CRC32
crc.update("The quick brown fox jumps over the lazy dog".getBytes)
println(crc.getValue.toHexString) //> 414fa339</
=={{header|Seed7}}==
<
include "crc32.s7i";
Line 2,529:
begin
writeln(ord(crc32("The quick brown fox jumps over the lazy dog")) radix 16 lpad0 8);
end func;</
{{out}}
Line 2,538:
=={{header|Shell}}==
===Bash===
<
declare -i -a CRC32_LOOKUP_TABLE
Line 2,569:
# 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>.
<
# POSIX Shell CRC32 of string
# @Name: crc32.sh
Line 2,625:
# crc32_string "The quick brown fox jumps over the lazy dog"
# yields 414fa339</
{{out}}
<pre>bash ./crc32.sh "The quick brown fox jumps over the lazy dog"
Line 2,634:
{{works with|Smalltalk/X}}
the CRC32Stream utility class can do it for me:
<
{{out}}
1095738169 "which is 16r414FA339"
Line 2,640:
=={{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,
Line 2,646:
let crc = crc32(uLong(0), UnsafePointer<Bytef>(strData!.bytes), uInt(strData!.length))
println(NSString(format:"%2X", crc))</
{{out}}
<pre>414FA339
Line 2,652:
=={{header|Tcl}}==
<
set data "The quick brown fox jumps over the lazy dog"
puts [format "%x" [zlib crc32 $data]]</
{{out}}
<pre>414fa339</pre>
Line 2,661:
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===
<
{{out}}
<pre>1095738169</pre>
===FFI access to Zlib===
<
(deffi zlib-crc32 "crc32" ulong (ulong str uint)))</
{{out}}
<pre>$ txr -i crc32-zlib.tl
Line 2,680:
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
Line 2,731:
(set crc (logxor [crc-tab (logand (logxor crc [buf i]) #xff)]
(ash crc -8))))
(logxor crc #xffffffff)))</
{{out}}
Line 2,741:
=={{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>
Line 2,752:
</pre>
===Implementation===
<
{
private const uint32 s_generator = 0xedb88320u;
Line 2,788:
var crc32 = new Crc32();
stdout.printf("%x\n", crc32.get("The quick brown fox jumps over the lazy dog"));
}</
{{out}}
Line 2,796:
=={{header|VAX Assembly}}==
<
00000044 0004 2 table: .blkl 16
0044 3
Line 2,819:
67 6F 64 20 79 7A 61 00BC
0000002B 00C3 18 len = .-msg
00C3 19 .end crc</
=={{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
Line 2,856:
gencrctable
wscript.stdout.writeline hex(crc32("The quick brown fox jumps over the lazy dog"))
</syntaxhighlight>
Output
<pre>
Line 2,870:
{{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
Line 2,884:
Debug.Assert l = &H414FA339
End Sub</
=={{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.
Line 2,916:
End Function
End Class</
Test:
<
Function Str2BA(Str As String) As Byte()
Return System.Text.Encoding.ASCII.GetBytes(Str)
Line 2,940:
Crc32.cs(Str2BA(Mid(Str, 1, 20)))
Debug.Print("Crc32 = " & HexF(Crc32.cs(Str2BA(Mid(Str, 21)), False), 8))
End Sub</
Output:
<syntaxhighlight lang=text>Input = "The quick brown fox jumps over the lazy dog"
Crc32 = 414FA339
Crc32 = 414FA339</
=={{header|Wren}}==
{{trans|Go}}
{{libheader|Wren-fmt}}
<
class CRC32 {
Line 2,980:
CRC32.init()
var crc = CRC32.compute("The quick brown fox jumps over the lazy dog")
System.print(Conv.hex(crc))</
{{out}}
Line 2,988:
=={{header|XPL0}}==
<
string 0; \use zero-terminated strings
Line 3,006:
];
HexOut(0, CRC32("The quick brown fox jumps over the lazy dog", 43))</
{{out}}
Line 3,015:
=={{header|zkl}}==
Using zlib:
<
ZLib.calcCRC32(Data(Void,"The quick brown fox jumps over the lazy dog"));
//-->0x414fa339</
|