ed/Odin
1
0
Fork 0
mirror of https://github.com/Ed94/Odin.git synced 2026-07-29 10:50:05 +00:00
Code Issues Packages Projects Releases Wiki Activity

Improved API. hash_file procs now just take a file handle instead of a path

Browse Source
This commit is contained in:
zhibog
2021-10-15 20:29:25 +02:00
parent ced0ea515c
commit f48ee00c2f
26 changed files with 696 additions and 794 deletions
Download Patch File Download Diff File Expand all files Collapse all files
core/crypto/blake/blake.odin
+41 -52
View File
@@ -15,6 +15,7 @@ import "core:os"
import "core:io"
import "../_ctx"
import "../util"
/*
Context initialization and switching between the Odin implementation and the bindings
@@ -105,11 +106,11 @@ hash_stream_224 :: proc(s: io.Stream) -> ([28]byte, bool) {
return _hash_impl->hash_stream_28(s)
}
// hash_file_224 will try to open the file provided by the given
// path and pass it to hash_stream to compute a hash
hash_file_224 :: proc(path: string, load_at_once: bool) -> ([28]byte, bool) {
// hash_file_224 will read the file provided by the given handle
// and compute a hash
hash_file_224 :: proc(hd: os.Handle, load_at_once := false) -> ([28]byte, bool) {
_create_blake256_ctx(true, ._28)
return _hash_impl->hash_file_28(path, load_at_once)
return _hash_impl->hash_file_28(hd, load_at_once)
}
hash_224 :: proc {
@@ -139,11 +140,11 @@ hash_stream_256 :: proc(s: io.Stream) -> ([32]byte, bool) {
return _hash_impl->hash_stream_32(s)
}
// hash_file_256 will try to open the file provided by the given
// path and pass it to hash_stream to compute a hash
hash_file_256 :: proc(path: string, load_at_once: bool) -> ([32]byte, bool) {
// hash_file_256 will read the file provided by the given handle
// and compute a hash
hash_file_256 :: proc(hd: os.Handle, load_at_once := false) -> ([32]byte, bool) {
_create_blake256_ctx(false, ._32)
return _hash_impl->hash_file_32(path, load_at_once)
return _hash_impl->hash_file_32(hd, load_at_once)
}
hash_256 :: proc {
@@ -173,11 +174,11 @@ hash_stream_384 :: proc(s: io.Stream) -> ([48]byte, bool) {
return _hash_impl->hash_stream_48(s)
}
// hash_file_384 will try to open the file provided by the given
// path and pass it to hash_stream to compute a hash
hash_file_384 :: proc(path: string, load_at_once: bool) -> ([48]byte, bool) {
// hash_file_384 will read the file provided by the given handle
// and compute a hash
hash_file_384 :: proc(hd: os.Handle, load_at_once := false) -> ([48]byte, bool) {
_create_blake512_ctx(true, ._48)
return _hash_impl->hash_file_48(path, load_at_once)
return _hash_impl->hash_file_48(hd, load_at_once)
}
hash_384 :: proc {
@@ -207,11 +208,11 @@ hash_stream_512 :: proc(s: io.Stream) -> ([64]byte, bool) {
return _hash_impl->hash_stream_64(s)
}
// hash_file_512 will try to open the file provided by the given
// path and pass it to hash_stream to compute a hash
hash_file_512 :: proc(path: string, load_at_once: bool) -> ([64]byte, bool) {
// hash_file_512 will read the file provided by the given handle
// and compute a hash
hash_file_512 :: proc(hd: os.Handle, load_at_once := false) -> ([64]byte, bool) {
_create_blake512_ctx(false, ._64)
return _hash_impl->hash_file_64(path, load_at_once)
return _hash_impl->hash_file_64(hd, load_at_once)
}
hash_512 :: proc {
@@ -267,15 +268,12 @@ hash_stream_odin_28 :: #force_inline proc(ctx: ^_ctx.Hash_Context, fs: io.Stream
}
}
hash_file_odin_28 :: #force_inline proc(ctx: ^_ctx.Hash_Context, path: string, load_at_once: bool) -> ([28]byte, bool) {
if hd, err := os.open(path); err == os.ERROR_NONE {
defer os.close(hd)
if !load_at_once {
return hash_stream_odin_28(ctx, os.stream_from_handle(hd))
} else {
if buf, read_ok := os.read_entire_file(path); read_ok {
return hash_bytes_odin_28(ctx, buf[:]), read_ok
}
hash_file_odin_28 :: #force_inline proc(ctx: ^_ctx.Hash_Context, hd: os.Handle, load_at_once := false) -> ([28]byte, bool) {
if !load_at_once {
return hash_stream_odin_28(ctx, os.stream_from_handle(hd))
} else {
if buf, ok := util.read_entire_file(hd); ok {
return hash_bytes_odin_28(ctx, buf[:]), ok
}
}
return [28]byte{}, false
@@ -311,15 +309,12 @@ hash_stream_odin_32 :: #force_inline proc(ctx: ^_ctx.Hash_Context, fs: io.Stream
}
}
hash_file_odin_32 :: #force_inline proc(ctx: ^_ctx.Hash_Context, path: string, load_at_once: bool) -> ([32]byte, bool) {
if hd, err := os.open(path); err == os.ERROR_NONE {
defer os.close(hd)
if !load_at_once {
return hash_stream_odin_32(ctx, os.stream_from_handle(hd))
} else {
if buf, read_ok := os.read_entire_file(path); read_ok {
return hash_bytes_odin_32(ctx, buf[:]), read_ok
}
hash_file_odin_32 :: #force_inline proc(ctx: ^_ctx.Hash_Context, hd: os.Handle, load_at_once := false) -> ([32]byte, bool) {
if !load_at_once {
return hash_stream_odin_32(ctx, os.stream_from_handle(hd))
} else {
if buf, ok := util.read_entire_file(hd); ok {
return hash_bytes_odin_32(ctx, buf[:]), ok
}
}
return [32]byte{}, false
@@ -355,15 +350,12 @@ hash_stream_odin_48 :: #force_inline proc(ctx: ^_ctx.Hash_Context, fs: io.Stream
}
}
hash_file_odin_48 :: #force_inline proc(ctx: ^_ctx.Hash_Context, path: string, load_at_once: bool) -> ([48]byte, bool) {
if hd, err := os.open(path); err == os.ERROR_NONE {
defer os.close(hd)
if !load_at_once {
return hash_stream_odin_48(ctx, os.stream_from_handle(hd))
} else {
if buf, read_ok := os.read_entire_file(path); read_ok {
return hash_bytes_odin_48(ctx, buf[:]), read_ok
}
hash_file_odin_48 :: #force_inline proc(ctx: ^_ctx.Hash_Context, hd: os.Handle, load_at_once := false) -> ([48]byte, bool) {
if !load_at_once {
return hash_stream_odin_48(ctx, os.stream_from_handle(hd))
} else {
if buf, ok := util.read_entire_file(hd); ok {
return hash_bytes_odin_48(ctx, buf[:]), ok
}
}
return [48]byte{}, false
@@ -399,15 +391,12 @@ hash_stream_odin_64 :: #force_inline proc(ctx: ^_ctx.Hash_Context, fs: io.Stream
}
}
hash_file_odin_64 :: #force_inline proc(ctx: ^_ctx.Hash_Context, path: string, load_at_once: bool) -> ([64]byte, bool) {
if hd, err := os.open(path); err == os.ERROR_NONE {
defer os.close(hd)
if !load_at_once {
return hash_stream_odin_64(ctx, os.stream_from_handle(hd))
} else {
if buf, read_ok := os.read_entire_file(path); read_ok {
return hash_bytes_odin_64(ctx, buf[:]), read_ok
}
hash_file_odin_64 :: #force_inline proc(ctx: ^_ctx.Hash_Context, hd: os.Handle, load_at_once := false) -> ([64]byte, bool) {
if !load_at_once {
return hash_stream_odin_64(ctx, os.stream_from_handle(hd))
} else {
if buf, ok := util.read_entire_file(hd); ok {
return hash_bytes_odin_64(ctx, buf[:]), ok
}
}
return [64]byte{}, false