From 7d924679a61ed786f42b007ef7ab6f15b0d87f46 Mon Sep 17 00:00:00 2001 From: Alexander Medvednikov Date: Thu, 14 Nov 2019 10:00:22 +0300 Subject: [PATCH] []: update all examples and tests --- examples/tetris/tetris.v | 2 +- tools/vrepl.v | 4 +- vlib/builtin/array_test.v | 4 +- vlib/crypto/aes/aes_cbc.v | 2 +- vlib/crypto/sha1/sha1block_generic.v | 2 +- vlib/crypto/sha256/sha256.v | 436 +++++++++++------------ vlib/crypto/sha256/sha256_test.v | 3 +- vlib/crypto/sha256/sha256block_generic.v | 318 ++++++++--------- vlib/crypto/sha512/sha512block_generic.v | 2 +- vlib/flag/flag_test.v | 6 +- 10 files changed, 390 insertions(+), 389 deletions(-) diff --git a/examples/tetris/tetris.v b/examples/tetris/tetris.v index c273ea4afb..db0272abd9 100644 --- a/examples/tetris/tetris.v +++ b/examples/tetris/tetris.v @@ -174,7 +174,7 @@ fn (g mut Game) init_game() { g.parse_tetros() rand.seed(time.now().uni) g.generate_tetro() - g.field = []array_int // TODO: g.field = [][]int + g.field = [] // TODO: g.field = [][]int // Generate the field, fill it with 0's, add -1's on each edge for i := 0; i < FieldHeight + 2; i++ { mut row := [0].repeat(FieldWidth + 2) diff --git a/tools/vrepl.v b/tools/vrepl.v index 6ea5877cc8..70623e6d53 100644 --- a/tools/vrepl.v +++ b/tools/vrepl.v @@ -143,7 +143,7 @@ pub fn run_repl() []string { os.write_file(file, source_code) s := os.exec('"$vexe" run $file -repl') or { rerror(err) - return []string + return [] } print_output(s) } @@ -160,7 +160,7 @@ pub fn run_repl() []string { s := os.exec('"$vexe" run $temp_file -repl') or { println("SDFSDF") rerror(err) - return []string + return [] } if !func_call && s.exit_code == 0 && !temp_flag { for r.temp_lines.len > 0 { diff --git a/vlib/builtin/array_test.v b/vlib/builtin/array_test.v index 25099ef15f..89ad3093c9 100644 --- a/vlib/builtin/array_test.v +++ b/vlib/builtin/array_test.v @@ -65,7 +65,7 @@ struct K { } fn test_empty() { - mut chunks := [] + mut chunks := []Chunk a := Chunk{} assert chunks.len == 0 chunks << a @@ -346,7 +346,7 @@ fn (t Test) str() string { fn test_struct_print() { mut a := Test { a: 'Test', - b: []Test2 + b: [] } b := Test2 { one: 1, diff --git a/vlib/crypto/aes/aes_cbc.v b/vlib/crypto/aes/aes_cbc.v index 4f6ef040ca..d023ed6248 100644 --- a/vlib/crypto/aes/aes_cbc.v +++ b/vlib/crypto/aes/aes_cbc.v @@ -70,7 +70,7 @@ pub fn (x mut AesCbc) encrypt_blocks(dst mut []byte, src_ []byte) { // Move to the next block with this block as the next iv. iv = dst[..x.block_size] if x.block_size >= src.len { - src = []byte + src = [] } else { src = src[x.block_size..] } diff --git a/vlib/crypto/sha1/sha1block_generic.v b/vlib/crypto/sha1/sha1block_generic.v index d915b0fb06..33cf25ded2 100644 --- a/vlib/crypto/sha1/sha1block_generic.v +++ b/vlib/crypto/sha1/sha1block_generic.v @@ -109,7 +109,7 @@ fn block_generic(dig mut Digest, p_ []byte) { h4 += e if chunk >= p.len { - p = []byte + p = [] } else { p = p[chunk..] } diff --git a/vlib/crypto/sha256/sha256.v b/vlib/crypto/sha256/sha256.v index 0126973682..d77196ad5c 100644 --- a/vlib/crypto/sha256/sha256.v +++ b/vlib/crypto/sha256/sha256.v @@ -1,218 +1,218 @@ -// Copyright (c) 2019 Alexander Medvednikov. All rights reserved. -// Use of this source code is governed by an MIT license -// that can be found in the LICENSE file. - -// Package sha256 implements the SHA224 and SHA256 hash algorithms as defined -// in FIPS 180-4. - -// Based off: https://github.com/golang/go/tree/master/src/crypto/sha256 -// Last commit: https://github.com/golang/go/commit/3ce865d7a0b88714cc433454ae2370a105210c01 - -module sha256 - -import encoding.binary - -const ( - // The size of a SHA256 checksum in bytes. - size = 32 - // The size of a SHA224 checksum in bytes. - size224 = 28 - // The blocksize of SHA256 and SHA224 in bytes. - block_size = 64 -) - -const ( - chunk = 64 - init0 = 0x6A09E667 - init1 = 0xBB67AE85 - init2 = 0x3C6EF372 - init3 = 0xA54FF53A - init4 = 0x510E527F - init5 = 0x9B05688C - init6 = 0x1F83D9AB - init7 = 0x5BE0CD19 - init0_224 = 0xC1059ED8 - init1_224 = 0x367CD507 - init2_224 = 0x3070DD17 - init3_224 = 0xF70E5939 - init4_224 = 0xFFC00B31 - init5_224 = 0x68581511 - init6_224 = 0x64F98FA7 - init7_224 = 0xBEFA4FA4 -) - -// digest represents the partial evaluation of a checksum. -struct Digest { -mut: - h []u32 - x []byte - nx int - len u64 - is224 bool // mark if this digest is SHA-224 -} - -fn (d mut Digest) reset() { - d.h = [u32(0)].repeat(8) - d.x = [byte(0)].repeat(chunk) - if !d.is224 { - d.h[0] = u32(init0) - d.h[1] = u32(init1) - d.h[2] = u32(init2) - d.h[3] = u32(init3) - d.h[4] = u32(init4) - d.h[5] = u32(init5) - d.h[6] = u32(init6) - d.h[7] = u32(init7) - } else { - d.h[0] = u32(init0_224) - d.h[1] = u32(init1_224) - d.h[2] = u32(init2_224) - d.h[3] = u32(init3_224) - d.h[4] = u32(init4_224) - d.h[5] = u32(init5_224) - d.h[6] = u32(init6_224) - d.h[7] = u32(init7_224) - } - d.nx = 0 - d.len = 0 -} - -// new returns a new Digest (implementing hash.Hash) computing the SHA256 checksum. -pub fn new() &Digest { - mut d := &Digest{} - d.reset() - return d -} - -// new224 returns a new Digest (implementing hash.Hash) computing the SHA224 checksum. -pub fn new224() &Digest { - mut d := &Digest{} - d.is224 = true - d.reset() - return d -} - -fn (d mut Digest) write(p_ []byte) int { - mut p := p_ - nn := p.len - d.len += u64(nn) - if d.nx > 0 { - n := copy(d.x[d.nx..], p) - d.nx += n - if d.nx == chunk { - block(mut d, d.x) - d.nx = 0 - } - if n >= p.len { - p = []byte - } else { - p = p[n..] - } - } - if p.len >= chunk { - n := p.len &~ (chunk - 1) - block(mut d, p[..n]) - if n >= p.len { - p = []byte - } else { - p = p[n..] - } - } - if p.len > 0 { - d.nx = copy(d.x, p) - } - return nn -} - -fn (d &Digest) sum(b_in []byte) []byte { - // Make a copy of d so that caller can keep writing and summing. - mut d0 := *d - hash := d0.checksum() - mut b_out := b_in.clone() - if d0.is224 { - for b in hash[..size224] { - b_out << b - } - } else { - for b in hash { - b_out << b - } - } - return b_out -} - -fn (d mut Digest) checksum() []byte { - mut len := d.len - // Padding. Add a 1 bit and 0 bits until 56 bytes mod 64. - mut tmp := [byte(0)].repeat(64) - tmp[0] = 0x80 - if int(len)%64 < 56 { - d.write(tmp[..56-int(len)%64]) - } else { - d.write(tmp[..64+56-int(len)%64]) - } - - // Length in bits. - len <<= u64(3) - binary.big_endian_put_u64(mut tmp, len) - d.write(tmp[..8]) - - if d.nx != 0 { - panic('d.nx != 0') - } - - digest := [byte(0)].repeat(size) - - binary.big_endian_put_u32(mut digest, d.h[0]) - binary.big_endian_put_u32(mut digest[4..], d.h[1]) - binary.big_endian_put_u32(mut digest[8..], d.h[2]) - binary.big_endian_put_u32(mut digest[12..], d.h[3]) - binary.big_endian_put_u32(mut digest[16..], d.h[4]) - binary.big_endian_put_u32(mut digest[20..], d.h[5]) - binary.big_endian_put_u32(mut digest[24..], d.h[6]) - if !d.is224 { - binary.big_endian_put_u32(mut digest[28..], d.h[7]) - } - - return digest -} - -// sum256 returns the SHA256 checksum of the data. -pub fn sum(data []byte) []byte { - return sum256(data) -} - -// sum256 returns the SHA256 checksum of the data. -pub fn sum256(data []byte) []byte { - mut d := new() - d.write(data) - return d.checksum() -} - -// sum224 returns the SHA224 checksum of the data. -pub fn sum224(data []byte) []byte { - mut d := new224() - d.write(data) - sum := d.checksum() - mut sum224 := [byte(0)].repeat(size224) - copy(sum224, sum[..size224]) - return sum224 -} - -fn block(dig mut Digest, p []byte) { - // For now just use block_generic until we have specific - // architecture optimized versions - block_generic(mut dig, p) -} - -pub fn (d &Digest) size() int { - if !d.is224 { - return size - } - return size224 -} - -pub fn (d &Digest) block_size() int { return block_size } - -pub fn hexhash(s string) string { return sum256(s.bytes()).hex() } -pub fn hexhash_224(s string) string { return sum224(s.bytes()).hex() } +// Copyright (c) 2019 Alexander Medvednikov. All rights reserved. +// Use of this source code is governed by an MIT license +// that can be found in the LICENSE file. + +// Package sha256 implements the SHA224 and SHA256 hash algorithms as defined +// in FIPS 180-4. + +// Based off: https://github.com/golang/go/tree/master/src/crypto/sha256 +// Last commit: https://github.com/golang/go/commit/3ce865d7a0b88714cc433454ae2370a105210c01 + +module sha256 + +import encoding.binary + +const ( + // The size of a SHA256 checksum in bytes. + size = 32 + // The size of a SHA224 checksum in bytes. + size224 = 28 + // The blocksize of SHA256 and SHA224 in bytes. + block_size = 64 +) + +const ( + chunk = 64 + init0 = 0x6A09E667 + init1 = 0xBB67AE85 + init2 = 0x3C6EF372 + init3 = 0xA54FF53A + init4 = 0x510E527F + init5 = 0x9B05688C + init6 = 0x1F83D9AB + init7 = 0x5BE0CD19 + init0_224 = 0xC1059ED8 + init1_224 = 0x367CD507 + init2_224 = 0x3070DD17 + init3_224 = 0xF70E5939 + init4_224 = 0xFFC00B31 + init5_224 = 0x68581511 + init6_224 = 0x64F98FA7 + init7_224 = 0xBEFA4FA4 +) + +// digest represents the partial evaluation of a checksum. +struct Digest { +mut: + h []u32 + x []byte + nx int + len u64 + is224 bool // mark if this digest is SHA-224 +} + +fn (d mut Digest) reset() { + d.h = [u32(0)].repeat(8) + d.x = [byte(0)].repeat(chunk) + if !d.is224 { + d.h[0] = u32(init0) + d.h[1] = u32(init1) + d.h[2] = u32(init2) + d.h[3] = u32(init3) + d.h[4] = u32(init4) + d.h[5] = u32(init5) + d.h[6] = u32(init6) + d.h[7] = u32(init7) + } else { + d.h[0] = u32(init0_224) + d.h[1] = u32(init1_224) + d.h[2] = u32(init2_224) + d.h[3] = u32(init3_224) + d.h[4] = u32(init4_224) + d.h[5] = u32(init5_224) + d.h[6] = u32(init6_224) + d.h[7] = u32(init7_224) + } + d.nx = 0 + d.len = 0 +} + +// new returns a new Digest (implementing hash.Hash) computing the SHA256 checksum. +pub fn new() &Digest { + mut d := &Digest{} + d.reset() + return d +} + +// new224 returns a new Digest (implementing hash.Hash) computing the SHA224 checksum. +pub fn new224() &Digest { + mut d := &Digest{} + d.is224 = true + d.reset() + return d +} + +fn (d mut Digest) write(p_ []byte) int { + mut p := p_ + nn := p.len + d.len += u64(nn) + if d.nx > 0 { + n := copy(d.x[d.nx..], p) + d.nx += n + if d.nx == chunk { + block(mut d, d.x) + d.nx = 0 + } + if n >= p.len { + p = [] + } else { + p = p[n..] + } + } + if p.len >= chunk { + n := p.len &~ (chunk - 1) + block(mut d, p[..n]) + if n >= p.len { + p = [] + } else { + p = p[n..] + } + } + if p.len > 0 { + d.nx = copy(d.x, p) + } + return nn +} + +fn (d &Digest) sum(b_in []byte) []byte { + // Make a copy of d so that caller can keep writing and summing. + mut d0 := *d + hash := d0.checksum() + mut b_out := b_in.clone() + if d0.is224 { + for b in hash[..size224] { + b_out << b + } + } else { + for b in hash { + b_out << b + } + } + return b_out +} + +fn (d mut Digest) checksum() []byte { + mut len := d.len + // Padding. Add a 1 bit and 0 bits until 56 bytes mod 64. + mut tmp := [byte(0)].repeat(64) + tmp[0] = 0x80 + if int(len)%64 < 56 { + d.write(tmp[..56-int(len)%64]) + } else { + d.write(tmp[..64+56-int(len)%64]) + } + + // Length in bits. + len <<= u64(3) + binary.big_endian_put_u64(mut tmp, len) + d.write(tmp[..8]) + + if d.nx != 0 { + panic('d.nx != 0') + } + + digest := [byte(0)].repeat(size) + + binary.big_endian_put_u32(mut digest, d.h[0]) + binary.big_endian_put_u32(mut digest[4..], d.h[1]) + binary.big_endian_put_u32(mut digest[8..], d.h[2]) + binary.big_endian_put_u32(mut digest[12..], d.h[3]) + binary.big_endian_put_u32(mut digest[16..], d.h[4]) + binary.big_endian_put_u32(mut digest[20..], d.h[5]) + binary.big_endian_put_u32(mut digest[24..], d.h[6]) + if !d.is224 { + binary.big_endian_put_u32(mut digest[28..], d.h[7]) + } + + return digest +} + +// sum256 returns the SHA256 checksum of the data. +pub fn sum(data []byte) []byte { + return sum256(data) +} + +// sum256 returns the SHA256 checksum of the data. +pub fn sum256(data []byte) []byte { + mut d := new() + d.write(data) + return d.checksum() +} + +// sum224 returns the SHA224 checksum of the data. +pub fn sum224(data []byte) []byte { + mut d := new224() + d.write(data) + sum := d.checksum() + mut sum224 := [byte(0)].repeat(size224) + copy(sum224, sum[..size224]) + return sum224 +} + +fn block(dig mut Digest, p []byte) { + // For now just use block_generic until we have specific + // architecture optimized versions + block_generic(mut dig, p) +} + +pub fn (d &Digest) size() int { + if !d.is224 { + return size + } + return size224 +} + +pub fn (d &Digest) block_size() int { return block_size } + +pub fn hexhash(s string) string { return sum256(s.bytes()).hex() } +pub fn hexhash_224(s string) string { return sum224(s.bytes()).hex() } diff --git a/vlib/crypto/sha256/sha256_test.v b/vlib/crypto/sha256/sha256_test.v index 282bbfa2ce..adf48fb95a 100644 --- a/vlib/crypto/sha256/sha256_test.v +++ b/vlib/crypto/sha256/sha256_test.v @@ -5,5 +5,6 @@ import crypto.sha256 fn test_crypto_sha256() { - assert sha256.sum('This is a sha256 checksum.'.bytes()).hex() == 'dc7163299659529eae29683eb1ffec50d6c8fc7275ecb10c145fde0e125b8727' + assert sha256.sum('This is a sha256 checksum.'.bytes()).hex() == + 'dc7163299659529eae29683eb1ffec50d6c8fc7275ecb10c145fde0e125b8727' } diff --git a/vlib/crypto/sha256/sha256block_generic.v b/vlib/crypto/sha256/sha256block_generic.v index 5eaf2014d8..2b890586fa 100644 --- a/vlib/crypto/sha256/sha256block_generic.v +++ b/vlib/crypto/sha256/sha256block_generic.v @@ -1,159 +1,159 @@ -// Copyright (c) 2019 Alexander Medvednikov. All rights reserved. -// Use of this source code is governed by an MIT license -// that can be found in the LICENSE file. - -// SHA256 block step. -// This is the generic version with no architecture optimizations. -// In its own file so that an architecture -// optimized verision can be substituted - -module sha256 - -import math.bits - -const ( - _k = [ - 0x428a2f98, - 0x71374491, - 0xb5c0fbcf, - 0xe9b5dba5, - 0x3956c25b, - 0x59f111f1, - 0x923f82a4, - 0xab1c5ed5, - 0xd807aa98, - 0x12835b01, - 0x243185be, - 0x550c7dc3, - 0x72be5d74, - 0x80deb1fe, - 0x9bdc06a7, - 0xc19bf174, - 0xe49b69c1, - 0xefbe4786, - 0x0fc19dc6, - 0x240ca1cc, - 0x2de92c6f, - 0x4a7484aa, - 0x5cb0a9dc, - 0x76f988da, - 0x983e5152, - 0xa831c66d, - 0xb00327c8, - 0xbf597fc7, - 0xc6e00bf3, - 0xd5a79147, - 0x06ca6351, - 0x14292967, - 0x27b70a85, - 0x2e1b2138, - 0x4d2c6dfc, - 0x53380d13, - 0x650a7354, - 0x766a0abb, - 0x81c2c92e, - 0x92722c85, - 0xa2bfe8a1, - 0xa81a664b, - 0xc24b8b70, - 0xc76c51a3, - 0xd192e819, - 0xd6990624, - 0xf40e3585, - 0x106aa070, - 0x19a4c116, - 0x1e376c08, - 0x2748774c, - 0x34b0bcb5, - 0x391c0cb3, - 0x4ed8aa4a, - 0x5b9cca4f, - 0x682e6ff3, - 0x748f82ee, - 0x78a5636f, - 0x84c87814, - 0x8cc70208, - 0x90befffa, - 0xa4506ceb, - 0xbef9a3f7, - 0xc67178f2, - ] -) - -fn block_generic(dig mut Digest, p_ []byte) { - mut p := p_ - - mut w := [u32(0)].repeat(64) - - mut h0 := dig.h[0] - mut h1 := dig.h[1] - mut h2 := dig.h[2] - mut h3 := dig.h[3] - mut h4 := dig.h[4] - mut h5 := dig.h[5] - mut h6 := dig.h[6] - mut h7 := dig.h[7] - - for p.len >= chunk { - // Can interlace the computation of w with the - // rounds below if needed for speed. - for i := 0; i < 16; i++ { - j := i * 4 - w[i] = u32(p[j]<<24) | u32(p[j+1]<<16) | u32(p[j+2]<<8) | u32(p[j+3]) - } - for i := 16; i < 64; i++ { - v1 := w[i-2] - t1 := (bits.rotate_left_32(v1, -17)) ^ (bits.rotate_left_32(v1, -19)) ^ (v1 >> 10) - v2 := w[i-15] - t2 := (bits.rotate_left_32(v2, -7)) ^ (bits.rotate_left_32(v2, -18)) ^ (v2 >> 3) - w[i] = t1 + w[i-7] + t2 + w[i-16] - } - - mut a := h0 - mut b := h1 - mut c := h2 - mut d := h3 - mut e := h4 - mut f := h5 - mut g := h6 - mut h := h7 - - for i := 0; i < 64; i++ { - t1 := h + ((bits.rotate_left_32(e, -6)) ^ (bits.rotate_left_32(e, -11)) ^ (bits.rotate_left_32(e, -25))) + ((e & f) ^ (~e & g)) + u32(_k[i]) + w[i] - t2 := ((bits.rotate_left_32(a, -2)) ^ (bits.rotate_left_32(a, -13)) ^ (bits.rotate_left_32(a, -22))) + ((a & b) ^ (a & c) ^ (b & c)) - - h = g - g = f - f = e - e = d + t1 - d = c - c = b - b = a - a = t1 + t2 - } - - h0 += a - h1 += b - h2 += c - h3 += d - h4 += e - h5 += f - h6 += g - h7 += h - - if chunk >= p.len { - p = []byte - } else { - p = p[chunk..] - } - } - - dig.h[0] = h0 - dig.h[1] = h1 - dig.h[2] = h2 - dig.h[3] = h3 - dig.h[4] = h4 - dig.h[5] = h5 - dig.h[6] = h6 - dig.h[7] = h7 -} +// Copyright (c) 2019 Alexander Medvednikov. All rights reserved. +// Use of this source code is governed by an MIT license +// that can be found in the LICENSE file. + +// SHA256 block step. +// This is the generic version with no architecture optimizations. +// In its own file so that an architecture +// optimized verision can be substituted + +module sha256 + +import math.bits + +const ( + _k = [ + 0x428a2f98, + 0x71374491, + 0xb5c0fbcf, + 0xe9b5dba5, + 0x3956c25b, + 0x59f111f1, + 0x923f82a4, + 0xab1c5ed5, + 0xd807aa98, + 0x12835b01, + 0x243185be, + 0x550c7dc3, + 0x72be5d74, + 0x80deb1fe, + 0x9bdc06a7, + 0xc19bf174, + 0xe49b69c1, + 0xefbe4786, + 0x0fc19dc6, + 0x240ca1cc, + 0x2de92c6f, + 0x4a7484aa, + 0x5cb0a9dc, + 0x76f988da, + 0x983e5152, + 0xa831c66d, + 0xb00327c8, + 0xbf597fc7, + 0xc6e00bf3, + 0xd5a79147, + 0x06ca6351, + 0x14292967, + 0x27b70a85, + 0x2e1b2138, + 0x4d2c6dfc, + 0x53380d13, + 0x650a7354, + 0x766a0abb, + 0x81c2c92e, + 0x92722c85, + 0xa2bfe8a1, + 0xa81a664b, + 0xc24b8b70, + 0xc76c51a3, + 0xd192e819, + 0xd6990624, + 0xf40e3585, + 0x106aa070, + 0x19a4c116, + 0x1e376c08, + 0x2748774c, + 0x34b0bcb5, + 0x391c0cb3, + 0x4ed8aa4a, + 0x5b9cca4f, + 0x682e6ff3, + 0x748f82ee, + 0x78a5636f, + 0x84c87814, + 0x8cc70208, + 0x90befffa, + 0xa4506ceb, + 0xbef9a3f7, + 0xc67178f2, + ] +) + +fn block_generic(dig mut Digest, p_ []byte) { + mut p := p_ + + mut w := [u32(0)].repeat(64) + + mut h0 := dig.h[0] + mut h1 := dig.h[1] + mut h2 := dig.h[2] + mut h3 := dig.h[3] + mut h4 := dig.h[4] + mut h5 := dig.h[5] + mut h6 := dig.h[6] + mut h7 := dig.h[7] + + for p.len >= chunk { + // Can interlace the computation of w with the + // rounds below if needed for speed. + for i := 0; i < 16; i++ { + j := i * 4 + w[i] = u32(p[j]<<24) | u32(p[j+1]<<16) | u32(p[j+2]<<8) | u32(p[j+3]) + } + for i := 16; i < 64; i++ { + v1 := w[i-2] + t1 := (bits.rotate_left_32(v1, -17)) ^ (bits.rotate_left_32(v1, -19)) ^ (v1 >> 10) + v2 := w[i-15] + t2 := (bits.rotate_left_32(v2, -7)) ^ (bits.rotate_left_32(v2, -18)) ^ (v2 >> 3) + w[i] = t1 + w[i-7] + t2 + w[i-16] + } + + mut a := h0 + mut b := h1 + mut c := h2 + mut d := h3 + mut e := h4 + mut f := h5 + mut g := h6 + mut h := h7 + + for i := 0; i < 64; i++ { + t1 := h + ((bits.rotate_left_32(e, -6)) ^ (bits.rotate_left_32(e, -11)) ^ (bits.rotate_left_32(e, -25))) + ((e & f) ^ (~e & g)) + u32(_k[i]) + w[i] + t2 := ((bits.rotate_left_32(a, -2)) ^ (bits.rotate_left_32(a, -13)) ^ (bits.rotate_left_32(a, -22))) + ((a & b) ^ (a & c) ^ (b & c)) + + h = g + g = f + f = e + e = d + t1 + d = c + c = b + b = a + a = t1 + t2 + } + + h0 += a + h1 += b + h2 += c + h3 += d + h4 += e + h5 += f + h6 += g + h7 += h + + if chunk >= p.len { + p = [] + } else { + p = p[chunk..] + } + } + + dig.h[0] = h0 + dig.h[1] = h1 + dig.h[2] = h2 + dig.h[3] = h3 + dig.h[4] = h4 + dig.h[5] = h5 + dig.h[6] = h6 + dig.h[7] = h7 +} diff --git a/vlib/crypto/sha512/sha512block_generic.v b/vlib/crypto/sha512/sha512block_generic.v index ede3eca5a1..c6a8aef109 100644 --- a/vlib/crypto/sha512/sha512block_generic.v +++ b/vlib/crypto/sha512/sha512block_generic.v @@ -158,7 +158,7 @@ fn block_generic(dig mut Digest, p_ []byte) { h7 += h if Chunk >= p.len { - p = []byte + p = [] } else { p = p[Chunk..] } diff --git a/vlib/flag/flag_test.v b/vlib/flag/flag_test.v index 4e2bf7de0b..afea40be20 100644 --- a/vlib/flag/flag_test.v +++ b/vlib/flag/flag_test.v @@ -144,7 +144,7 @@ fn test_finalize_returns_error_for_unknown_flags() { } fn test_allow_to_build_usage_message() { - mut fp := flag.new_flag_parser([]string) + mut fp := flag.new_flag_parser([]) fp.limit_free_args(1, 4) fp.application('flag_tool') fp.version('v0.0.0') @@ -177,7 +177,7 @@ fn test_allow_to_build_usage_message() { } fn test_if_no_description_given_usage_message_does_not_contain_descpription() { - mut fp := flag.new_flag_parser([]string) + mut fp := flag.new_flag_parser([]) fp.application('flag_tool') fp.version('v0.0.0') @@ -187,7 +187,7 @@ fn test_if_no_description_given_usage_message_does_not_contain_descpription() { } fn test_if_no_options_given_usage_message_does_not_contain_options() { - mut fp := flag.new_flag_parser([]string) + mut fp := flag.new_flag_parser([]) fp.application('flag_tool') fp.version('v0.0.0')