mirror/v
1
0
Fork 0
mirror of https://github.com/vlang/v.git synced 2023-08-10 21:13:21 +03:00
Code Issues Projects Releases Wiki Activity

all: change optional to result in most of the libraries (#16123)

Browse Source
This commit is contained in:
yuyi
2022-10-21 03:14:33 +08:00
committed by GitHub
parent 0d368562f4
commit 51f4d99399
75 changed files with 439 additions and 446 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
.github/workflows/v_apps_and_modules_compile.yml vendored
View File

@ -81,16 +81,16 @@ jobs:
echo "Test libsodium"
VJOBS=1 v test ~/.vmodules/libsodium
- name: Build VEX
run: |
echo "Install Vex"
v install nedpals.vex
echo "Compile all of the Vex examples"
v should-compile-all ~/.vmodules/nedpals/vex/examples
echo "Compile the simple Vex example with -gc boehm -skip-unused"
v -gc boehm -skip-unused ~/.vmodules/nedpals/vex/examples/simple_example.v
echo "Run Vex Tests"
v test ~/.vmodules/nedpals/vex
## - name: Build VEX
## run: |
## echo "Install Vex"
## v install nedpals.vex
## echo "Compile all of the Vex examples"
## v should-compile-all ~/.vmodules/nedpals/vex/examples
## echo "Compile the simple Vex example with -gc boehm -skip-unused"
## v -gc boehm -skip-unused ~/.vmodules/nedpals/vex/examples/simple_example.v
## echo "Run Vex Tests"
## v test ~/.vmodules/nedpals/vex
- name: Build go2v
run: |

2
cmd/tools/vdoc/tests/vdoc_file_test.v
View File

@ -16,7 +16,7 @@ fn find_diff_cmd() string {
fn test_vet() {
os.setenv('VCOLORS', 'never', true)
os.chdir(vroot)?
os.chdir(vroot)!
test_dir := 'cmd/tools/vdoc/tests/testdata'
main_files := get_main_files_in_dir(test_dir)
fails := check_path(vexe, test_dir, main_files)

2
cmd/tools/vdoc/utils.v
View File

@ -70,7 +70,7 @@ fn set_output_type_from_str(format string) OutputType {
return output_type
}
fn get_ignore_paths(path string) ?[]string {
fn get_ignore_paths(path string) ![]string {
ignore_file_path := os.join_path(path, '.vdocignore')
ignore_content := os.read_file(ignore_file_path) or {
return error_with_code('ignore file not found.', 1)

6
examples/cli.v
View File

@ -41,7 +41,7 @@ fn main() {
cmd.parse(os.args)
}
fn greet_func(cmd Command) ? {
fn greet_func(cmd Command) ! {
language := cmd.flags.get_string('language') or { panic('Failed to get `language` flag: $err') }
times := cmd.flags.get_int('times') or { panic('Failed to get `times` flag: $err') }
name := cmd.args[0]
@ -69,10 +69,10 @@ fn greet_func(cmd Command) ? {
}
}
fn greet_pre_func(cmd Command) ? {
fn greet_pre_func(cmd Command) ! {
println('This is a function running before the main function.\n')
}
fn greet_post_func(cmd Command) ? {
fn greet_post_func(cmd Command) ! {
println('\nThis is a function running after the main function.')
}

2
examples/vpwgen.v
View File

@ -10,7 +10,7 @@ fn main() {
for _ in 0 .. repeats {
mut sb := strings.new_builder(blocksize)
for {
x := rand.read(blocksize)?
x := rand.read(blocksize)!
for c in x {
if c >= `0` && c <= `~` {
sb.write_u8(c)

6
vlib/arrays/README.md
View File

@ -9,8 +9,8 @@ import arrays
fn main() {
a := [1, 5, 7, 0, 9]
assert arrays.min(a)? == 0
assert arrays.max(a)? == 9
assert arrays.idx_min(a)? == 3
assert arrays.min(a)! == 0
assert arrays.max(a)! == 9
assert arrays.idx_min(a)! == 3
}
```

12
vlib/arrays/arrays.v
View File

@ -200,7 +200,7 @@ pub fn window<T>(array []T, attr WindowAttribute) [][]T {
// which means you can only pass array of numbers for now.
// TODO: Fix generic operator overloading detection issue.
// Example: arrays.sum<int>([1, 2, 3, 4, 5])? // => 15
pub fn sum<T>(array []T) ?T {
pub fn sum<T>(array []T) !T {
if array.len == 0 {
return error('Cannot sum up array of nothing.')
} else {
@ -222,8 +222,8 @@ pub fn sum<T>(array []T) ?T {
// returns the accumulated value in `acc`.
// returns an error if the array is empty.
// See also: [fold](#fold).
// Example: arrays.reduce([1, 2, 3, 4, 5], fn (t1 int, t2 int) int { return t1 * t2 })? // => 120
pub fn reduce<T>(array []T, reduce_op fn (acc T, elem T) T) ?T {
// Example: arrays.reduce([1, 2, 3, 4, 5], fn (t1 int, t2 int) int { return t1 * t2 })! // => 120
pub fn reduce<T>(array []T, reduce_op fn (acc T, elem T) T) !T {
if array.len == 0 {
return error('Cannot reduce array of nothing.')
} else {
@ -245,7 +245,7 @@ pub fn reduce<T>(array []T, reduce_op fn (acc T, elem T) T) ?T {
// returns the accumulated value in `acc`.
// returns an error if the array is empty.
// See also: [fold_indexed](#fold_indexed).
pub fn reduce_indexed<T>(array []T, reduce_op fn (idx int, acc T, elem T) T) ?T {
pub fn reduce_indexed<T>(array []T, reduce_op fn (idx int, acc T, elem T) T) !T {
if array.len == 0 {
return error('Cannot reduce array of nothing.')
} else {
@ -427,8 +427,8 @@ pub fn lower_bound<T>(array []T, val T) !T {
}
// returns the largest element <= val, requires `array` to be sorted
// Example: arrays.upper_bound([2, 4, 6, 8], 3)? // => 2
pub fn upper_bound<T>(array []T, val T) ?T {
// Example: arrays.upper_bound([2, 4, 6, 8], 3)! // => 2
pub fn upper_bound<T>(array []T, val T) !T {
if array.len == 0 {
return error('.upper_bound called on an empty array')
}

12
vlib/arrays/arrays_test.v
View File

@ -14,7 +14,7 @@ fn test_min() {
c := [u8(4), 9, 3, 1]
mut rb := min(c)!
assert rb == u8(1)
rb = min(c[..3])?
rb = min(c[..3])!
assert rb == u8(3)
}
@ -243,7 +243,7 @@ fn test_concat_string() {
fn test_binary_search() {
a := [1, 3, 3, 4, 5, 6, 7, 8, 10]
assert binary_search(a, 3)? == 1
assert binary_search(a, 3)! == 1
assert (binary_search(a, 0) or { -1 }) == -1
}
@ -251,18 +251,18 @@ fn test_lower_bound() {
a := [1, 3, 3, 4, 5, 6, 7, 8, 10]
b := []int{}
c := [1, 2, 3]
assert lower_bound(a, 2)? == 3
assert lower_bound(a, 2)! == 3
assert (lower_bound(b, 4) or { -1 }) == -1
assert lower_bound(c, 3)? == 3
assert lower_bound(c, 3)! == 3
}
fn test_upper_bound() {
a := [1, 3, 3, 4, 5, 6, 7, 8, 10]
b := []int{}
c := [1, 2, 3]
assert upper_bound(a, 9)? == 8
assert upper_bound(a, 9)! == 8
assert (upper_bound(b, 4) or { -1 }) == -1
assert upper_bound(c, 2)? == 2
assert upper_bound(c, 2)! == 2
}
fn test_rotate_right() {

4
vlib/cli/README.md
View File

@ -18,14 +18,14 @@ fn main() {
mut app := cli.Command{
name: 'example-app'
description: 'example-app'
execute: fn (cmd cli.Command) ? {
execute: fn (cmd cli.Command) ! {
println('hello app')
return
}
commands: [
cli.Command{
name: 'sub'
execute: fn (cmd cli.Command) ? {
execute: fn (cmd cli.Command) ! {
println('hello subcommand')
return
}

4
vlib/cli/command.v
View File

@ -2,7 +2,7 @@ module cli
import term
type FnCommandCallback = fn (cmd Command) ?
type FnCommandCallback = fn (cmd Command) !
// str returns the `string` representation of the callback.
pub fn (f FnCommandCallback) str() string {
@ -311,7 +311,7 @@ pub fn (cmd Command) execute_man() {
}
}
fn (cmds []Command) get(name string) ?Command {
fn (cmds []Command) get(name string) !Command {
for cmd in cmds {
if cmd.name == name {
return cmd

16
vlib/cli/command_test.v
View File

@ -30,7 +30,7 @@ fn test_if_subcommands_parse_args() {
cmd.parse(['command', 'subcommand', 'arg0', 'arg1'])
}
fn if_subcommands_parse_args_func(cmd cli.Command) ? {
fn if_subcommands_parse_args_func(cmd cli.Command) ! {
assert cmd.name == 'subcommand' && compare_arrays(cmd.args, ['arg0', 'arg1'])
}
@ -51,8 +51,8 @@ fn test_if_command_has_default_version_subcommand_if_version_is_set() {
assert has_command(cmd, 'version')
}
fn flag_should_be_set(cmd cli.Command) ? {
flag := cmd.flags.get_string('flag')?
fn flag_should_be_set(cmd cli.Command) ! {
flag := cmd.flags.get_string('flag')!
assert flag == 'value'
}
@ -95,10 +95,10 @@ fn test_if_flag_gets_set_with_long_arg() {
cmd.parse(['command', '--flag', 'value'])
}
fn flag_should_have_value_of_42(cmd cli.Command) ? {
flag := cmd.flags.get_string('flag')?
fn flag_should_have_value_of_42(cmd cli.Command) ! {
flag := cmd.flags.get_string('flag')!
assert flag == 'value'
value := cmd.flags.get_int('value')?
value := cmd.flags.get_int('value')!
assert value == 42
}
@ -135,7 +135,7 @@ fn test_if_required_flags_get_set() {
cmd.parse(['command', '-flag', 'value', '-value', '42'])
}
fn flag_is_set_in_subcommand(cmd cli.Command) ? {
fn flag_is_set_in_subcommand(cmd cli.Command) ! {
flag := cmd.flags.get_string('flag') or { panic(err) }
assert flag == 'value'
}
@ -197,7 +197,7 @@ fn test_command_setup() {
}
// helper functions
fn empty_func(cmd cli.Command) ? {
fn empty_func(cmd cli.Command) ! {
}
fn has_command(cmd cli.Command, name string) bool {

54
vlib/cli/flag.v
View File

@ -42,7 +42,7 @@ pub fn (flags []Flag) get_all_found() []Flag {
// get_bool returns `true` if the flag is set.
// get_bool returns an error if the `FlagType` is not boolean.
pub fn (flag Flag) get_bool() ?bool {
pub fn (flag Flag) get_bool() !bool {
if flag.flag != .bool {
return error('$flag.name: Invalid flag type `$flag.flag`, expected `bool`')
}
@ -54,14 +54,14 @@ pub fn (flag Flag) get_bool() ?bool {
// get_bool returns `true` if the flag specified in `name` is set.
// get_bool returns an error if the `FlagType` is not boolean.
pub fn (flags []Flag) get_bool(name string) ?bool {
flag := flags.get(name)?
pub fn (flags []Flag) get_bool(name string) !bool {
flag := flags.get(name)!
return flag.get_bool()
}
// get_int returns the `int` value argument of the flag.
// get_int returns an error if the `FlagType` is not integer.
pub fn (flag Flag) get_int() ?int {
pub fn (flag Flag) get_int() !int {
if flag.flag != .int {
return error('$flag.name: Invalid flag type `$flag.flag`, expected `int`')
}
@ -77,7 +77,7 @@ pub fn (flag Flag) get_int() ?int {
// get_ints returns the array of `int` value argument of the flag specified in `name`.
// get_ints returns an error if the `FlagType` is not integer.
pub fn (flag Flag) get_ints() ?[]int {
pub fn (flag Flag) get_ints() ![]int {
if flag.flag != .int_array {
return error('$flag.name: Invalid flag type `$flag.flag`, expected `int_array`')
}
@ -99,21 +99,21 @@ pub fn (flag Flag) get_ints() ?[]int {
// get_int returns the `int` value argument of the flag specified in `name`.
// get_int returns an error if the `FlagType` is not integer.
pub fn (flags []Flag) get_int(name string) ?int {
flag := flags.get(name)?
pub fn (flags []Flag) get_int(name string) !int {
flag := flags.get(name)!
return flag.get_int()
}
// get_ints returns the array of `int` value argument of the flag specified in `name`.
// get_ints returns an error if the `FlagType` is not integer.
pub fn (flags []Flag) get_ints(name string) ?[]int {
flag := flags.get(name)?
pub fn (flags []Flag) get_ints(name string) ![]int {
flag := flags.get(name)!
return flag.get_ints()
}
// get_float returns the `f64` value argument of the flag.
// get_float returns an error if the `FlagType` is not floating point.
pub fn (flag Flag) get_float() ?f64 {
pub fn (flag Flag) get_float() !f64 {
if flag.flag != .float {
return error('$flag.name: Invalid flag type `$flag.flag`, expected `float`')
}
@ -129,7 +129,7 @@ pub fn (flag Flag) get_float() ?f64 {
// get_floats returns the `f64` value argument of the flag.
// get_floats returns an error if the `FlagType` is not floating point.
pub fn (flag Flag) get_floats() ?[]f64 {
pub fn (flag Flag) get_floats() ![]f64 {
if flag.flag != .float_array {
return error('$flag.name: Invalid flag type `$flag.flag`, expected `float_array`')
}
@ -151,21 +151,21 @@ pub fn (flag Flag) get_floats() ?[]f64 {
// get_float returns the `f64` value argument of the flag specified in `name`.
// get_float returns an error if the `FlagType` is not floating point.
pub fn (flags []Flag) get_float(name string) ?f64 {
flag := flags.get(name)?
pub fn (flags []Flag) get_float(name string) !f64 {
flag := flags.get(name)!
return flag.get_float()
}
// get_floats returns the array of `f64` value argument of the flag specified in `name`.
// get_floats returns an error if the `FlagType` is not floating point.
pub fn (flags []Flag) get_floats(name string) ?[]f64 {
flag := flags.get(name)?
pub fn (flags []Flag) get_floats(name string) ![]f64 {
flag := flags.get(name)!
return flag.get_floats()
}
// get_string returns the `string` value argument of the flag.
// get_string returns an error if the `FlagType` is not string.
pub fn (flag Flag) get_string() ?string {
pub fn (flag Flag) get_string() !string {
if flag.flag != .string {
return error('$flag.name: Invalid flag type `$flag.flag`, expected `string`')
}
@ -181,7 +181,7 @@ pub fn (flag Flag) get_string() ?string {
// get_strings returns the array of `string` value argument of the flag.
// get_strings returns an error if the `FlagType` is not string.
pub fn (flag Flag) get_strings() ?[]string {
pub fn (flag Flag) get_strings() ![]string {
if flag.flag != .string_array {
return error('$flag.name: Invalid flag type `$flag.flag`, expected `string_array`')
}
@ -197,24 +197,24 @@ pub fn (flag Flag) get_strings() ?[]string {
// get_string returns the `string` value argument of the flag specified in `name`.
// get_string returns an error if the `FlagType` is not string.
pub fn (flags []Flag) get_string(name string) ?string {
flag := flags.get(name)?
pub fn (flags []Flag) get_string(name string) !string {
flag := flags.get(name)!
return flag.get_string()
}
// get_strings returns the `string` value argument of the flag specified in `name`.
// get_strings returns an error if the `FlagType` is not string.
pub fn (flags []Flag) get_strings(name string) ?[]string {
flag := flags.get(name)?
pub fn (flags []Flag) get_strings(name string) ![]string {
flag := flags.get(name)!
return flag.get_strings()
}
// parse parses flag values from arguments and return
// an array of arguments with all consumed elements removed.
fn (mut flag Flag) parse(args []string, posix_mode bool) ?[]string {
fn (mut flag Flag) parse(args []string, posix_mode bool) ![]string {
if flag.matches(args, posix_mode) {
if flag.flag == .bool {
new_args := flag.parse_bool(args)?
new_args := flag.parse_bool(args)!
return new_args
} else {
if flag.value.len > 0 && flag.flag != .int_array && flag.flag != .float_array
@ -222,7 +222,7 @@ fn (mut flag Flag) parse(args []string, posix_mode bool) ?[]string {
return error('The argument `$flag.name` accept only one value!')
}
new_args := flag.parse_raw(args)?
new_args := flag.parse_raw(args)!
return new_args
}
} else {
@ -239,7 +239,7 @@ fn (mut flag Flag) matches(args []string, posix_mode bool) bool {
|| (flag.abbrev != '' && args[0].starts_with('-$flag.abbrev='))
}
fn (mut flag Flag) parse_raw(args []string) ?[]string {
fn (mut flag Flag) parse_raw(args []string) ![]string {
if args[0].len > flag.name.len && args[0].contains('=') {
flag.value << args[0].split('=')[1]
return args[1..]
@ -250,7 +250,7 @@ fn (mut flag Flag) parse_raw(args []string) ?[]string {
return error('Missing argument for `$flag.name`')
}
fn (mut flag Flag) parse_bool(args []string) ?[]string {
fn (mut flag Flag) parse_bool(args []string) ![]string {
if args[0].len > flag.name.len && args[0].contains('=') {
flag.value = [args[0].split('=')[1]]
return args[1..]
@ -267,7 +267,7 @@ fn (mut flag Flag) parse_bool(args []string) ?[]string {
// get returns the `Flag` matching `name` or an error
// if it can't be found.
fn (flags []Flag) get(name string) ?Flag {
fn (flags []Flag) get(name string) !Flag {
for flag in flags {
if flag.name == name {
return flag

2
vlib/cli/help.v
View File

@ -29,7 +29,7 @@ fn help_cmd() Command {
}
// print_help_for_command outputs the help message of `help_cmd`.
pub fn print_help_for_command(help_cmd Command) ? {
pub fn print_help_for_command(help_cmd Command) ! {
if help_cmd.args.len > 0 {
mut cmd := help_cmd.parent
for arg in help_cmd.args {

2
vlib/cli/man.v
View File

@ -21,7 +21,7 @@ fn man_cmd() Command {
// print_manpage_for_command prints the manpage for the
// command or subcommand in `man_cmd` to stdout
pub fn print_manpage_for_command(man_cmd Command) ? {
pub fn print_manpage_for_command(man_cmd Command) ! {
if man_cmd.args.len > 0 {
mut cmd := man_cmd.parent
for arg in man_cmd.args {

2
vlib/cli/version.v
View File

@ -18,7 +18,7 @@ fn version_cmd() Command {
}
}
fn version_func(version_cmd Command) ? {
fn version_func(version_cmd Command) ! {
cmd := version_cmd.parent
version := '$cmd.name version $cmd.version'
println(version)

4
vlib/compress/compress.v
View File

@ -11,7 +11,7 @@ fn C.tinfl_decompress_mem_to_heap(source_buf voidptr, source_buf_len usize, out_
// compresses an array of bytes based on providing flags and returns the compressed bytes in a new array
// NB: this is a low level api, a high level implementation like zlib/gzip should be preferred
[manualfree]
pub fn compress(data []u8, flags int) ?[]u8 {
pub fn compress(data []u8, flags int) ![]u8 {
if u64(data.len) > compress.max_size {
return error('data too large ($data.len > $compress.max_size)')
}
@ -30,7 +30,7 @@ pub fn compress(data []u8, flags int) ?[]u8 {
// decompresses an array of bytes based on providing flags and returns the decompressed bytes in a new array
// NB: this is a low level api, a high level implementation like zlib/gzip should be preferred
[manualfree]
pub fn decompress(data []u8, flags int) ?[]u8 {
pub fn decompress(data []u8, flags int) ![]u8 {
mut out_len := usize(0)
address := C.tinfl_decompress_mem_to_heap(data.data, data.len, &out_len, flags)

6
vlib/compress/deflate/README.md
View File

@ -11,8 +11,8 @@ import compress.deflate
fn main() {
uncompressed := 'Hello world!'
compressed := deflate.compress(uncompressed.bytes())?
decompressed := deflate.decompress(compressed)?
compressed := deflate.compress(uncompressed.bytes())!
decompressed := deflate.decompress(compressed)!
assert decompressed == uncompressed.bytes()
}
```
```

4
vlib/compress/deflate/deflate.v
View File

@ -4,12 +4,12 @@ import compress
// compresses an array of bytes using deflate and returns the compressed bytes in a new array
// Example: compressed := deflate.compress(b)?
pub fn compress(data []u8) ?[]u8 {
pub fn compress(data []u8) ![]u8 {
return compress.compress(data, 0)
}
// decompresses an array of bytes using deflate and returns the decompressed bytes in a new array
// Example: decompressed := deflate.decompress(b)?
pub fn decompress(data []u8) ?[]u8 {
pub fn decompress(data []u8) ![]u8 {
return compress.decompress(data, 0)
}

6
vlib/compress/deflate/deflate_test.v
View File

@ -2,11 +2,11 @@ module deflate
const gzip_magic_numbers = [u8(0x1f), 0x8b]
fn test_gzip() ? {
fn test_gzip() {
uncompressed := 'Hello world!'
compressed := compress(uncompressed.bytes())?
compressed := compress(uncompressed.bytes())!
first2 := compressed[0..2]
assert first2 != deflate.gzip_magic_numbers
decompressed := decompress(compressed)?
decompressed := decompress(compressed)!
assert decompressed == uncompressed.bytes()
}

4
vlib/compress/gzip/README.md
View File

@ -11,8 +11,8 @@ import compress.gzip
fn main() {
uncompressed := 'Hello world!'
compressed := gzip.compress(uncompressed.bytes())?
decompressed := gzip.decompress(compressed)?
compressed := gzip.compress(uncompressed.bytes())!
decompressed := gzip.decompress(compressed)!
assert decompressed == uncompressed.bytes()
}
```

8
vlib/compress/gzip/gzip.v
View File

@ -8,8 +8,8 @@ import hash.crc32
// compresses an array of bytes using gzip and returns the compressed bytes in a new array
// Example: compressed := gzip.compress(b)?
pub fn compress(data []u8) ?[]u8 {
compressed := compress.compress(data, 0)?
pub fn compress(data []u8) ![]u8 {
compressed := compress.compress(data, 0)!
// header
mut result := [
u8(0x1f), // magic numbers (1F 8B)
@ -49,7 +49,7 @@ pub struct DecompressParams {
// decompresses an array of bytes using zlib and returns the decompressed bytes in a new array
// Example: decompressed := gzip.decompress(b)?
pub fn decompress(data []u8, params DecompressParams) ?[]u8 {
pub fn decompress(data []u8, params DecompressParams) ![]u8 {
if data.len < 18 {
return error('data is too short, not gzip compressed?')
} else if data[0] != 0x1f || data[1] != 0x8b {
@ -107,7 +107,7 @@ pub fn decompress(data []u8, params DecompressParams) ?[]u8 {
return error('data too short')
}
decompressed := compress.decompress(data[header_length..data.len - 8], 0)?
decompressed := compress.decompress(data[header_length..data.len - 8], 0)!
length_expected := (u32(data[data.len - 4]) << 24) | (u32(data[data.len - 3]) << 16) | (u32(data[data.len - 2]) << 8) | data[data.len - 1]
if params.verify_length && decompressed.len != length_expected {
return error('length verification failed, got $decompressed.len, expected $length_expected')

80
vlib/compress/gzip/gzip_test.v
View File

@ -2,14 +2,14 @@ module gzip
import hash.crc32
fn test_gzip() ? {
fn test_gzip() {
uncompressed := 'Hello world!'
compressed := compress(uncompressed.bytes())?
decompressed := decompress(compressed)?
compressed := compress(uncompressed.bytes())!
decompressed := decompress(compressed)!
assert decompressed == uncompressed.bytes()
}
fn assert_decompress_error(data []u8, reason string) ? {
fn assert_decompress_error(data []u8, reason string) ! {
decompress(data) or {
assert err.msg() == reason
return
@ -17,54 +17,54 @@ fn assert_decompress_error(data []u8, reason string) ? {
return error('did not error')
}
fn test_gzip_invalid_too_short() ? {
assert_decompress_error([]u8{}, 'data is too short, not gzip compressed?')?
fn test_gzip_invalid_too_short() {
assert_decompress_error([]u8{}, 'data is too short, not gzip compressed?')!
}
fn test_gzip_invalid_magic_numbers() ? {
assert_decompress_error([]u8{len: 100}, 'wrong magic numbers, not gzip compressed?')?
fn test_gzip_invalid_magic_numbers() {
assert_decompress_error([]u8{len: 100}, 'wrong magic numbers, not gzip compressed?')!
}
fn test_gzip_invalid_compression() ? {
fn test_gzip_invalid_compression() {
mut data := []u8{len: 100}
data[0] = 0x1f
data[1] = 0x8b
assert_decompress_error(data, 'gzip data is not compressed with DEFLATE')?
assert_decompress_error(data, 'gzip data is not compressed with DEFLATE')!
}
fn test_gzip_with_ftext() ? {
fn test_gzip_with_ftext() {
uncompressed := 'Hello world!'
mut compressed := compress(uncompressed.bytes())?
mut compressed := compress(uncompressed.bytes())!
compressed[4] |= 0b0000_0001 // FTEXT
decompressed := decompress(compressed)?
decompressed := decompress(compressed)!
assert decompressed == uncompressed.bytes()
}
fn test_gzip_with_fname() ? {
fn test_gzip_with_fname() {
uncompressed := 'Hello world!'
mut compressed := compress(uncompressed.bytes())?
mut compressed := compress(uncompressed.bytes())!
compressed[4] |= 0b0000_1000
compressed.insert(10, `h`)
compressed.insert(11, `i`)
compressed.insert(12, 0x00)
decompressed := decompress(compressed)?
decompressed := decompress(compressed)!
assert decompressed == uncompressed.bytes()
}
fn test_gzip_with_fcomment() ? {
fn test_gzip_with_fcomment() {
uncompressed := 'Hello world!'
mut compressed := compress(uncompressed.bytes())?
mut compressed := compress(uncompressed.bytes())!
compressed[4] |= 0b0001_0000
compressed.insert(10, `h`)
compressed.insert(11, `i`)
compressed.insert(12, 0x00)
decompressed := decompress(compressed)?
decompressed := decompress(compressed)!
assert decompressed == uncompressed.bytes()
}
fn test_gzip_with_fname_fcomment() ? {
fn test_gzip_with_fname_fcomment() {
uncompressed := 'Hello world!'
mut compressed := compress(uncompressed.bytes())?
mut compressed := compress(uncompressed.bytes())!
compressed[4] |= 0b0001_1000
compressed.insert(10, `h`)
compressed.insert(11, `i`)
@ -72,63 +72,63 @@ fn test_gzip_with_fname_fcomment() ? {
compressed.insert(10, `h`)
compressed.insert(11, `i`)
compressed.insert(12, 0x00)
decompressed := decompress(compressed)?
decompressed := decompress(compressed)!
assert decompressed == uncompressed.bytes()
}
fn test_gzip_with_fextra() ? {
fn test_gzip_with_fextra() {
uncompressed := 'Hello world!'
mut compressed := compress(uncompressed.bytes())?
mut compressed := compress(uncompressed.bytes())!
compressed[4] |= 0b0000_0100
compressed.insert(10, 2)
compressed.insert(11, `h`)
compressed.insert(12, `i`)
decompressed := decompress(compressed)?
decompressed := decompress(compressed)!
assert decompressed == uncompressed.bytes()
}
fn test_gzip_with_hcrc() ? {
fn test_gzip_with_hcrc() {
uncompressed := 'Hello world!'
mut compressed := compress(uncompressed.bytes())?
mut compressed := compress(uncompressed.bytes())!
compressed[4] |= 0b0000_0010
checksum := crc32.sum(compressed[..10])
compressed.insert(10, u8(checksum >> 24))
compressed.insert(11, u8(checksum >> 16))
compressed.insert(12, u8(checksum >> 8))
compressed.insert(13, u8(checksum))
decompressed := decompress(compressed)?
decompressed := decompress(compressed)!
assert decompressed == uncompressed.bytes()
}
fn test_gzip_with_invalid_hcrc() ? {
fn test_gzip_with_invalid_hcrc() {
uncompressed := 'Hello world!'
mut compressed := compress(uncompressed.bytes())?
mut compressed := compress(uncompressed.bytes())!
compressed[4] |= 0b0000_0010
checksum := crc32.sum(compressed[..10])
compressed.insert(10, u8(checksum >> 24))
compressed.insert(11, u8(checksum >> 16))
compressed.insert(12, u8(checksum >> 8))
compressed.insert(13, u8(checksum + 1))
assert_decompress_error(compressed, 'header checksum verification failed')?
assert_decompress_error(compressed, 'header checksum verification failed')!
}
fn test_gzip_with_invalid_checksum() ? {
fn test_gzip_with_invalid_checksum() {
uncompressed := 'Hello world!'
mut compressed := compress(uncompressed.bytes())?
mut compressed := compress(uncompressed.bytes())!
compressed[compressed.len - 5] += 1
assert_decompress_error(compressed, 'checksum verification failed')?
assert_decompress_error(compressed, 'checksum verification failed')!
}
fn test_gzip_with_invalid_length() ? {
fn test_gzip_with_invalid_length() {
uncompressed := 'Hello world!'
mut compressed := compress(uncompressed.bytes())?
mut compressed := compress(uncompressed.bytes())!
compressed[compressed.len - 1] += 1
assert_decompress_error(compressed, 'length verification failed, got 12, expected 13')?
assert_decompress_error(compressed, 'length verification failed, got 12, expected 13')!
}
fn test_gzip_with_invalid_flags() ? {
fn test_gzip_with_invalid_flags() {
uncompressed := 'Hello world!'
mut compressed := compress(uncompressed.bytes())?
mut compressed := compress(uncompressed.bytes())!
compressed[4] |= 0b1000_0000
assert_decompress_error(compressed, 'reserved flags are set, unsupported field detected')?
assert_decompress_error(compressed, 'reserved flags are set, unsupported field detected')!
}

4
vlib/compress/zlib/README.md
View File

@ -10,8 +10,8 @@ import compress.zlib
fn main() {
uncompressed := 'Hello world!'
compressed := zlib.compress(uncompressed.bytes())?
decompressed := zlib.decompress(compressed)?
compressed := zlib.compress(uncompressed.bytes())!
decompressed := zlib.decompress(compressed)!
assert decompressed == uncompressed.bytes()
}
```

4
vlib/compress/zlib/zlib.v
View File

@ -4,14 +4,14 @@ import compress
// compresses an array of bytes using zlib and returns the compressed bytes in a new array
// Example: compressed := zlib.compress(b)?
pub fn compress(data []u8) ?[]u8 {
pub fn compress(data []u8) ![]u8 {
// flags = TDEFL_WRITE_ZLIB_HEADER (0x01000)
return compress.compress(data, 0x01000)
}
// decompresses an array of bytes using zlib and returns the decompressed bytes in a new array
// Example: decompressed := zlib.decompress(b)?
pub fn decompress(data []u8) ?[]u8 {
pub fn decompress(data []u8) ![]u8 {
// flags = TINFL_FLAG_PARSE_ZLIB_HEADER (0x1)
return compress.decompress(data, 0x1)
}

6
vlib/compress/zlib/zlib_test.v
View File

@ -1,8 +1,8 @@
module zlib
fn test_zlib() ? {
fn test_zlib() {
uncompressed := 'Hello world!'
compressed := compress(uncompressed.bytes())?
decompressed := decompress(compressed)?
compressed := compress(uncompressed.bytes())!
decompressed := decompress(compressed)!
assert decompressed == uncompressed.bytes()
}

2
vlib/crypto/README.md
View File

@ -22,7 +22,7 @@ import crypto.rand
fn main() {
// remember to save this key somewhere if you ever want to decrypt your data
key := rand.bytes(32)?
key := rand.bytes(32)!
println('KEY: $key')
// this data is one block (16 bytes) big

42
vlib/crypto/ed25519/ed25519.v
View File

@ -50,7 +50,7 @@ pub fn (priv PrivateKey) equal(x []u8) bool {
}
// sign signs the given message with priv.
pub fn (priv PrivateKey) sign(message []u8) ?[]u8 {
pub fn (priv PrivateKey) sign(message []u8) ![]u8 {
/*
if opts.HashFunc() != crypto.Hash(0) {
return nil, errors.New("ed25519: cannot sign hashed message")
@ -60,13 +60,13 @@ pub fn (priv PrivateKey) sign(message []u8) ?[]u8 {
}
// sign`signs the message with privatekey and returns a signature
pub fn sign(privatekey PrivateKey, message []u8) ?[]u8 {
pub fn sign(privatekey PrivateKey, message []u8) ![]u8 {
mut signature := []u8{len: ed25519.signature_size}
sign_generic(mut signature, privatekey, message)?
sign_generic(mut signature, privatekey, message)!
return signature
}
fn sign_generic(mut signature []u8, privatekey []u8, message []u8) ? {
fn sign_generic(mut signature []u8, privatekey []u8, message []u8) ! {
if privatekey.len != ed25519.private_key_size {
panic('ed25519: bad private key length: $privatekey.len')
}
@ -74,31 +74,31 @@ fn sign_generic(mut signature []u8, privatekey []u8, message []u8) ? {
mut h := sha512.sum512(seed)
mut s := edwards25519.new_scalar()
s.set_bytes_with_clamping(h[..32])?
s.set_bytes_with_clamping(h[..32])!
mut prefix := h[32..]
mut mh := sha512.new()
mh.write(prefix)?
mh.write(message)?
mh.write(prefix)!
mh.write(message)!
mut msg_digest := []u8{cap: sha512.size}
msg_digest = mh.sum(msg_digest)
mut r := edwards25519.new_scalar()
r.set_uniform_bytes(msg_digest)?
r.set_uniform_bytes(msg_digest)!
mut rr := edwards25519.Point{}
rr.scalar_base_mult(mut r)
mut kh := sha512.new()
kh.write(rr.bytes())?
kh.write(publickey)?
kh.write(message)?
kh.write(rr.bytes())!
kh.write(publickey)!
kh.write(message)!
mut hram_digest := []u8{cap: sha512.size}
hram_digest = kh.sum(hram_digest)
mut k := edwards25519.new_scalar()
k.set_uniform_bytes(hram_digest)?
k.set_uniform_bytes(hram_digest)!
mut ss := edwards25519.new_scalar()
ss.multiply_add(k, s, r)
@ -108,7 +108,7 @@ fn sign_generic(mut signature []u8, privatekey []u8, message []u8) ? {
}
// verify reports whether sig is a valid signature of message by publickey.
pub fn verify(publickey PublicKey, message []u8, sig []u8) ?bool {
pub fn verify(publickey PublicKey, message []u8, sig []u8) !bool {
if publickey.len != ed25519.public_key_size {
return error('ed25519: bad public key length: $publickey.len')
}
@ -118,21 +118,21 @@ pub fn verify(publickey PublicKey, message []u8, sig []u8) ?bool {
}
mut aa := edwards25519.Point{}
aa.set_bytes(publickey)?
aa.set_bytes(publickey)!
mut kh := sha512.new()
kh.write(sig[..32])?
kh.write(publickey)?
kh.write(message)?
kh.write(sig[..32])!
kh.write(publickey)!
kh.write(message)!
mut hram_digest := []u8{cap: sha512.size}
hram_digest = kh.sum(hram_digest)
mut k := edwards25519.new_scalar()
k.set_uniform_bytes(hram_digest)?
k.set_uniform_bytes(hram_digest)!
mut ss := edwards25519.new_scalar()
ss.set_canonical_bytes(sig[32..])?
ss.set_canonical_bytes(sig[32..])!
// [S]B = R + [k]A --> [k](-A) + [S]B = R
mut minus_a := edwards25519.Point{}
@ -144,8 +144,8 @@ pub fn verify(publickey PublicKey, message []u8, sig []u8) ?bool {
}
// generate_key generates a public/private key pair entropy using `crypto.rand`.
pub fn generate_key() ?(PublicKey, PrivateKey) {
mut seed := rand.bytes(ed25519.seed_size)?
pub fn generate_key() !(PublicKey, PrivateKey) {
mut seed := rand.bytes(ed25519.seed_size)!
privatekey := new_key_from_seed(seed)
mut publickey := []u8{len: ed25519.public_key_size}

6
vlib/crypto/ed25519/examples/example.v
View File

@ -8,11 +8,11 @@ import crypto.ed25519
fn main() {
msg := 'Hello Girl'
publ, priv := ed25519.generate_key()?
publ, priv := ed25519.generate_key()!
m := msg.bytes()
sig := ed25519.sign(priv, m)?
sig := ed25519.sign(priv, m)!
println('=== Message ===')
println('Msg: $msg \nHash: $m')
@ -31,7 +31,7 @@ fn main() {
println('signature: R=${sig[0..32].hex()} s=${sig[32..64].hex()}')
println(' signature (Base64)=${base64.encode(sig)}')
rtn := ed25519.verify(publ, m, sig)?
rtn := ed25519.verify(publ, m, sig)!
if rtn {
println('Signature verified :$rtn')

30
vlib/crypto/ed25519/internal/ed25519_test.v
View File

@ -27,22 +27,22 @@ fn (z ZeroReader) read(mut buf []u8) ?int {
}
*/
fn test_sign_verify() ? {
fn test_sign_verify() {
// mut zero := ZeroReader{}
public, private := ed25519.generate_key()?
public, private := ed25519.generate_key()!
message := 'test message'.bytes()
sig := ed25519.sign(private, message)?
sig := ed25519.sign(private, message)!
res := ed25519.verify(public, message, sig) or { false }
assert res == true
wrongmessage := 'wrong message'.bytes()
res2 := ed25519.verify(public, wrongmessage, sig)?
res2 := ed25519.verify(public, wrongmessage, sig)!
assert res2 == false
}
fn test_equal() ? {
public, private := ed25519.generate_key()?
fn test_equal() {
public, private := ed25519.generate_key()!
assert public.equal(public) == true
@ -53,13 +53,13 @@ fn test_equal() ? {
}*/
assert private.equal(private) == true
otherpub, otherpriv := ed25519.generate_key()?
otherpub, otherpriv := ed25519.generate_key()!
assert public.equal(otherpub) == false
assert private.equal(otherpriv) == false
}
fn test_malleability() ? {
fn test_malleability() {
// https://tools.ietf.org/html/rfc8032#section-5.1.7 adds an additional test
// that s be in [0, order). This prevents someone from adding a multiple of
// order to s and obtaining a second valid signature for the same message.
@ -149,7 +149,7 @@ mut:
// This test read a lot of entries in `testdata/sign.input`
// so, maybe need a long time to finish.
// be quiet and patient
fn test_input_from_djb_ed25519_crypto_sign_input_with_syncpool() ? {
fn test_input_from_djb_ed25519_crypto_sign_input_with_syncpool() {
// contents := os.read_lines('testdata/sign.input') or { panic(err) } //[]string
mut pool_s := pool.new_pool_processor(
callback: worker_for_string_content
@ -174,10 +174,10 @@ fn test_input_from_djb_ed25519_crypto_sign_input_without_syncpool() ? {
lg.fatal('not contains len 5')
}*/
assert parts.len == 5
privbytes := hex.decode(parts[0])?
pubkey := hex.decode(parts[1])?
msg := hex.decode(parts[2])?
mut sig := hex.decode(parts[3])?
privbytes := hex.decode(parts[0])!
pubkey := hex.decode(parts[1])!
msg := hex.decode(parts[2])!
mut sig := hex.decode(parts[3])!
assert pubkey.len == public_key_size
sig = sig[..signature_size]
@ -185,10 +185,10 @@ fn test_input_from_djb_ed25519_crypto_sign_input_without_syncpool() ? {
copy(mut priv[..], privbytes)
copy(mut priv[32..], pubkey)
sig2 := ed25519.sign(priv[..], msg)?
sig2 := ed25519.sign(priv[..], msg)!
assert sig == sig2[..]
res := ed25519.verify(pubkey, msg, sig2)?
res := ed25519.verify(pubkey, msg, sig2)!
assert res == true
priv2 := new_key_from_seed(priv[..32])

2
vlib/crypto/ed25519/internal/edwards25519/element.v
View File

@ -624,7 +624,7 @@ pub fn (mut v Element) set(a Element) Element {
// Consistent with RFC 7748, the most significant bit (the high bit of the
// last byte) is ignored, and non-canonical values (2^255-19 through 2^255-1)
// are accepted. Note that this is laxer than specified by RFC 8032.
pub fn (mut v Element) set_bytes(x []u8) ?Element {
pub fn (mut v Element) set_bytes(x []u8) !Element {
if x.len != 32 {
return error('edwards25519: invalid edwards25519 element input size')
}

44
vlib/crypto/ed25519/internal/edwards25519/element_test.v
View File

@ -162,7 +162,7 @@ struct SqrtRatioTest {
r string
}
fn test_sqrt_ratio() ? {
fn test_sqrt_ratio() {
// From draft-irtf-cfrg-ristretto255-decaf448-00, Appendix A.4.
tests := [
@ -188,9 +188,9 @@ fn test_sqrt_ratio() ? {
mut elw := Element{}
mut elg := Element{}
u := elu.set_bytes(hex.decode(tt.u)?)?
v := elv.set_bytes(hex.decode(tt.v)?)?
want := elw.set_bytes(hex.decode(tt.r)?)?
u := elu.set_bytes(hex.decode(tt.u)!)!
v := elv.set_bytes(hex.decode(tt.v)!)!
want := elw.set_bytes(hex.decode(tt.r)!)!
mut got, was_square := elg.sqrt_ratio(u, v)
assert got.equal(want) != 0
@ -201,12 +201,12 @@ fn test_sqrt_ratio() ? {
}
}
fn test_set_bytes_normal() ? {
fn test_set_bytes_normal() {
for i in 0 .. 15 {
mut el := Element{}
mut random_inp := rand.bytes(32)?
mut random_inp := rand.bytes(32)!
el = el.set_bytes(random_inp.clone())?
el = el.set_bytes(random_inp.clone())!
random_inp[random_inp.len - 1] &= (1 << 7) - 1
// assert f1(random_inp, el) == true
@ -233,7 +233,7 @@ mut:
b []u8
}
fn test_set_bytes_from_dalek_test_vectors() ? {
fn test_set_bytes_from_dalek_test_vectors() {
mut tests := [
FeRTTest{
fe: Element{358744748052810, 1691584618240980, 977650209285361, 1429865912637724, 560044844278676}
@ -249,7 +249,7 @@ fn test_set_bytes_from_dalek_test_vectors() ? {
for _, mut tt in tests {
b := tt.fe.bytes()
mut el := Element{}
mut fe := el.set_bytes(tt.b)?
mut fe := el.set_bytes(tt.b)!
assert b == tt.b
assert fe.equal(tt.fe) == 1
@ -267,7 +267,7 @@ fn test_equal() {
assert eq1 == 0
}
fn test_invert() ? {
fn test_invert() {
mut x := Element{1, 1, 1, 1, 1}
mut one := Element{1, 0, 0, 0, 0}
mut xinv := Element{}
@ -278,9 +278,9 @@ fn test_invert() ? {
r.reduce()
assert one == r
bytes := rand.bytes(32) or { return err }
bytes := rand.bytes(32)!
x.set_bytes(bytes)?
x.set_bytes(bytes)!
xinv.invert(x)
r.multiply(x, xinv)
@ -363,26 +363,26 @@ fn (mut v Element) to_big_integer() big.Integer {
}
// from_big_integer sets v = n, and returns v. The bit length of n must not exceed 256.
fn (mut v Element) from_big_integer(n big.Integer) ?Element {
fn (mut v Element) from_big_integer(n big.Integer) !Element {
if n.binary_str().len > 32 * 8 {
return error('invalid edwards25519 element input size')
}
mut bytes, _ := n.bytes()
swap_endianness(mut bytes) // SHOULD I SWAP IT?
v.set_bytes(bytes)?
v.set_bytes(bytes)!
return v
}
fn (mut v Element) from_decimal_string(s string) ?Element {
num := big.integer_from_string(s)?
fn (mut v Element) from_decimal_string(s string) !Element {
num := big.integer_from_string(s)!
v = v.from_big_integer(num)?
v = v.from_big_integer(num)!
return v
}
fn test_bytes_big_equivalence() ? {
mut inp := rand.bytes(32)?
fn test_bytes_big_equivalence() {
mut inp := rand.bytes(32)!
el := Element{}
mut fe := el.generate_element()
mut fe1 := el.generate_element()
@ -404,15 +404,15 @@ fn test_bytes_big_equivalence() ? {
// assert big_equivalence(inp, fe, fe1) == true
}
fn test_decimal_constants() ? {
fn test_decimal_constants() {
sqrtm1string := '19681161376707505956807079304988542015446066515923890162744021073123829784752'
mut el := Element{}
mut exp := el.from_decimal_string(sqrtm1string)?
mut exp := el.from_decimal_string(sqrtm1string)!
assert sqrt_m1.equal(exp) == 1
dstring := '37095705934669439343138083508754565189542113879843219016388785533085940283555'
exp = el.from_decimal_string(dstring)?
exp = el.from_decimal_string(dstring)!
mut d := d_const
assert d.equal(exp) == 1

8
vlib/crypto/ed25519/internal/edwards25519/extra_test.v
View File

@ -44,12 +44,12 @@ fn test_bytes_montgomery() {
}
}*/
fn test_bytes_montgomery_sodium() ? {
fn test_bytes_montgomery_sodium() {
// Generated with libsodium.js 1.0.18
// crypto_sign_keypair().pubkey
pubkey := '3bf918ffc2c955dc895bf145f566fb96623c1cadbe040091175764b5fde322c0'
mut p := Point{}
p.set_bytes(hex.decode(pubkey)?)?
p.set_bytes(hex.decode(pubkey)!)!
// crypto_sign_ed25519_pk_to_curve25519(pubkey)
want := 'efc6c9d0738e9ea18d738ad4a2653631558931b0f1fde4dd58c436d19686dc28'
@ -113,9 +113,9 @@ fn fn_cofactor(mut data []u8) bool {
return p8.equal(pp) == 1
}
fn test_mult_by_cofactor() ? {
fn test_mult_by_cofactor() {
mut loworder := Point{}
mut data := rand.bytes(64)?
mut data := rand.bytes(64)!
assert fn_cofactor(mut data) == true
}

16
vlib/crypto/ed25519/internal/edwards25519/point.v
View File

@ -18,30 +18,30 @@ const (
gen_point = generator() or { panic(err) }
)
fn d_const_generate() ?Element {
fn d_const_generate() !Element {
mut v := Element{}
v.set_bytes(edwards25519.d_bytes)?
v.set_bytes(edwards25519.d_bytes)!
return v
}
fn d2_const_generate() ?Element {
fn d2_const_generate() !Element {
mut v := Element{}
v.add(edwards25519.d_const, edwards25519.d_const)
return v
}
// id_point_generate is the point at infinity.
fn id_point_generate() ?Point {
fn id_point_generate() !Point {
mut p := Point{}
p.set_bytes(edwards25519.id_bytes)?
p.set_bytes(edwards25519.id_bytes)!
return p
}
// generator is the canonical curve basepoint. See TestGenerator for the
// correspondence of this encoding with the values in RFC 8032.
fn generator() ?Point {
fn generator() !Point {
mut p := Point{}
p.set_bytes(edwards25519.gen_bytes)?
p.set_bytes(edwards25519.gen_bytes)!
return p
}
@ -117,7 +117,7 @@ fn (mut v ProjectiveP2) zero() ProjectiveP2 {
// Note that set_bytes accepts all non-canonical encodings of valid points.
// That is, it follows decoding rules that match most implementations in
// the ecosystem rather than RFC 8032.
pub fn (mut v Point) set_bytes(x []u8) ?Point {
pub fn (mut v Point) set_bytes(x []u8) !Point {
// Specifically, the non-canonical encodings that are accepted are
// 1) the ones where the edwards25519 element is not reduced (see the
// (*edwards25519.Element).set_bytes docs) and

10
vlib/crypto/ed25519/internal/edwards25519/point_test.v
View File

@ -4,7 +4,7 @@ import encoding.hex
const zero_point = Point{fe_zero, fe_zero, fe_zero, fe_zero}
fn test_invalid_encodings() ? {
fn test_invalid_encodings() {
// An invalid point, that also happens to have y > p.
invalid := 'efffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f'
inv_bytes := hex.decode(invalid) or { panic(err) }
@ -17,7 +17,7 @@ fn test_invalid_encodings() ? {
assert check_on_curve(p) == true
}
fn test_add_sub_neg_on_basepoint() ? {
fn test_add_sub_neg_on_basepoint() {
bgp := new_generator_point()
mut idp := new_identity_point()
mut checklhs := Point{}
@ -52,7 +52,7 @@ struct NonCanonicalTest {
canonical string
}
fn test_non_canonical_points() ? {
fn test_non_canonical_points() {
tests := [
// Points with x = 0 and the sign bit set. With x = 0 the curve equation
// gives y² = 1, so y = ±1. 1 has two valid encodings.
@ -96,11 +96,11 @@ fn test_non_canonical_points() ? {
// t.Run(tt.name, func(t *testing.T) {
// p1, err := new(Point).SetBytes(decodeHex(tt.encoding))
mut p1 := Point{}
p1.set_bytes(hex.decode(tt.encoding)?)?
p1.set_bytes(hex.decode(tt.encoding)!)!
// p2, err := new(Point).SetBytes(decodeHex(tt.canonical))
mut p2 := Point{}
p2.set_bytes(hex.decode(tt.canonical)?)?
p2.set_bytes(hex.decode(tt.canonical)!)!
assert p1.equal(p2) == 1
assert p1.bytes() == p2.bytes()

18
vlib/crypto/ed25519/internal/edwards25519/scalar.v
View File

@ -86,7 +86,7 @@ pub fn (mut s Scalar) set(x Scalar) Scalar {
// set_uniform_bytes sets s to an uniformly distributed value given 64 uniformly
// distributed random bytes. If x is not of the right length, set_uniform_bytes
// returns an error, and the receiver is unchanged.
pub fn (mut s Scalar) set_uniform_bytes(x []u8) ?Scalar {
pub fn (mut s Scalar) set_uniform_bytes(x []u8) !Scalar {
if x.len != 64 {
return error('edwards25519: invalid set_uniform_bytes input length')
}
@ -102,7 +102,7 @@ pub fn (mut s Scalar) set_uniform_bytes(x []u8) ?Scalar {
// set_canonical_bytes sets s = x, where x is a 32-byte little-endian encoding of
// s, and returns s. If x is not a canonical encoding of s, set_canonical_bytes
// returns an error, and the receiver is unchanged.
pub fn (mut s Scalar) set_canonical_bytes(x []u8) ?Scalar {
pub fn (mut s Scalar) set_canonical_bytes(x []u8) !Scalar {
if x.len != 32 {
return error('invalid scalar length')
}
@ -152,7 +152,7 @@ fn is_reduced(s Scalar) bool {
// expected as long as it is applied to points on the prime order subgroup, like
// in Ed25519. In fact, it is lost to history why RFC 8032 adopted the
// irrelevant RFC 7748 clamping, but it is now required for compatibility.
pub fn (mut s Scalar) set_bytes_with_clamping(x []u8) ?Scalar {
pub fn (mut s Scalar) set_bytes_with_clamping(x []u8) !Scalar {
// The description above omits the purpose of the high bits of the clamping
// for brevity, but those are also lost to reductions, and are also
// irrelevant to edwards25519 as they protect against a specific
@ -1070,7 +1070,7 @@ fn (mut s Scalar) signed_radix16() []i8 {
// utility function
// generate returns a valid (reduced modulo l) Scalar with a distribution
// weighted towards high, low, and edge values.
fn generate_scalar(size int) ?Scalar {
fn generate_scalar(size int) !Scalar {
/*
s := scZero
diceRoll := rand.Intn(100)
@ -1115,7 +1115,7 @@ fn generate_scalar(size int) ?Scalar {
// rand.Read(s.s[:16]) // read random bytes and fill buf
// using builtin rand.read([]buf)
rand.read(mut s.s[..16])
// buf := rand.read(s.s[..16].len)?
// buf := rand.read(s.s[..16].len)!
// copy(mut s.s[..16], buf)
/*
@ -1132,7 +1132,7 @@ fn generate_scalar(size int) ?Scalar {
// Read generates len(p) random bytes and writes them into p
// rand.Read(s.s[:16])
rand.read(mut s.s[..16])
// buf := rand.read(s.s[..16].len)?
// buf := rand.read(s.s[..16].len)!
// copy(mut s.s[..16], buf)
/*
@ -1148,7 +1148,7 @@ fn generate_scalar(size int) ?Scalar {
// of being out of the latter range).
// rand.Read(s.s[:])
rand.read(mut s.s[..])
// buf := crand.read(s.s.len)?
// buf := crand.read(s.s.len)!
// copy(mut s.s[..], buf)
/*
@ -1164,10 +1164,10 @@ fn generate_scalar(size int) ?Scalar {
type NotZeroScalar = Scalar
fn generate_notzero_scalar(size int) ?NotZeroScalar {
fn generate_notzero_scalar(size int) !NotZeroScalar {
mut s := Scalar{}
for s == edwards25519.sc_zero {
s = generate_scalar(size)?
s = generate_scalar(size)!
}
return NotZeroScalar(s)
}

14
vlib/crypto/ed25519/internal/edwards25519/scalar_alias_test.v
View File

@ -24,9 +24,9 @@ fn negate_aliasing(mut v Scalar, x Scalar) Scalar {
return v.negate(x)
}
fn test_check_aliasing_oneargs() ? {
x := generate_notzero_scalar(10)?
mut v := generate_notzero_scalar(10)?
fn test_check_aliasing_oneargs() {
x := generate_notzero_scalar(10)!
mut v := generate_notzero_scalar(10)!
out := check_aliasing_onearg(negate_aliasing, mut v, x)
assert out == true
}
@ -43,12 +43,12 @@ fn subtract_aliasing(mut v Scalar, x Scalar, y Scalar) Scalar {
return v.subtract(x, y)
}
fn test_check_aliasing_twoargs() ? {
fn test_check_aliasing_twoargs() {
fn_with_twoargs := [add_aliasing, multiply_aliasing, subtract_aliasing]
for f in fn_with_twoargs {
mut v := generate_notzero_scalar(10)?
x := generate_notzero_scalar(10)?
y := generate_notzero_scalar(10)?
mut v := generate_notzero_scalar(10)!
x := generate_notzero_scalar(10)!
y := generate_notzero_scalar(10)!
out := check_aliasing_twoargs(f, mut v, x, y)
assert out == true
}

30
vlib/crypto/ed25519/internal/edwards25519/scalar_test.v
View File

@ -68,7 +68,7 @@ fn fg(sc Scalar) bool {
return is_reduced(sc)
}
fn test_scalar_generate() ? {
fn test_scalar_generate() {
for i in 0 .. 15 {
sc := generate_scalar(1000) or { panic(err) }
@ -77,7 +77,7 @@ fn test_scalar_generate() ? {
}
//
fn test_scalar_set_canonical_bytes() ? {
fn test_scalar_set_canonical_bytes() {
for i in 0 .. 10 {
mut buf := rand.bytes(32) or { panic(err) }
mut sc := generate_scalar(1000) or { panic(err) }
@ -89,10 +89,10 @@ fn test_scalar_set_canonical_bytes() ? {
}
}
fn test_scalar_set_canonical_bytes_round_trip() ? {
fn test_scalar_set_canonical_bytes_round_trip() {
for i in 0 .. 10 {
mut sc1 := generate_scalar(2)?
mut sc2 := generate_scalar(6)?
mut sc1 := generate_scalar(2)!
mut sc2 := generate_scalar(6)!
sc2.set_canonical_bytes(sc1.bytes()) or { panic(err) }
assert sc1 == sc2
@ -105,7 +105,7 @@ const (
}
)
fn test_scalar_set_canonical_bytes_on_noncanonical_value() ? {
fn test_scalar_set_canonical_bytes_on_noncanonical_value() {
mut b := sc_minus_one.s
b[31] += 1
@ -115,16 +115,16 @@ fn test_scalar_set_canonical_bytes_on_noncanonical_value() ? {
assert s == sc_one
}
fn test_scalar_set_uniform_bytes() ? {
fn test_scalar_set_uniform_bytes() {
// mod, _ := new(big.Integer).SetString("27742317777372353535851937790883648493", 10)
mut mod := big.integer_from_string('27742317777372353535851937790883648493')?
mut mod := big.integer_from_string('27742317777372353535851937790883648493')!
// mod.Add(mod, new(big.Integer).Lsh(big.NewInt(1), 252))
mod = mod + big.integer_from_i64(1).lshift(252)
mut sc := generate_scalar(100)?
inp := rand.bytes(64)?
mut sc := generate_scalar(100)!
inp := rand.bytes(64)!
sc.set_uniform_bytes(inp[..])?
sc.set_uniform_bytes(inp[..])!
assert is_reduced(sc) == true
scbig := bigint_from_le_bytes(sc.s[..])
@ -189,10 +189,10 @@ fn test_scalar_set_bytes_with_clamping() {
assert want2 == got2
}
fn test_scalar_multiply_distributes_over_add() ? {
x := generate_scalar(100)?
y := generate_scalar(100)?
z := generate_scalar(100)?
fn test_scalar_multiply_distributes_over_add() {
x := generate_scalar(100)!
y := generate_scalar(100)!
z := generate_scalar(100)!
// Compute t1 = (x+y)*z
mut t1 := Scalar{}

4
vlib/crypto/ed25519/internal/edwards25519/scalarmult_test.v
View File

@ -91,11 +91,11 @@ fn test_scalar_mult_distributes_over_add() {
assert check.equal(r) == 1
}
fn test_scalarmult_non_identity_point() ? {
fn test_scalarmult_non_identity_point() {
// Check whether p.ScalarMult and q.ScalaBaseMult give the same,
// when p and q are originally set to the base point.
mut x := generate_scalar(5000)?
mut x := generate_scalar(5000)!
mut p := Point{}
mut q := Point{}

4
vlib/crypto/rand/crypto_rand_bytes_test.v
View File

@ -1,7 +1,7 @@
import crypto.rand
fn test_reading() ? {
a := rand.read(32)?
fn test_reading() {
a := rand.read(32)!
// dump(a.hex())
assert a.len == 32
mut histogram := [256]int{}

2
vlib/crypto/rand/rand.v
View File

@ -18,6 +18,6 @@ pub fn (err ReadError) msg() string {
// See also rand.bytes(), if you do not need really random bytes,
// but instead pseudo random ones, from a pseudo random generator
// that can be seeded, and that is usually faster.
pub fn bytes(bytes_needed int) ?[]u8 {
pub fn bytes(bytes_needed int) ![]u8 {
return read(bytes_needed)
}

2
vlib/crypto/rand/rand_darwin.c.v
View File

@ -11,7 +11,7 @@ module rand
fn C.SecRandomCopyBytes(rnd C.SecRandomRef, count usize, bytes voidptr) int
// read returns an array of `bytes_needed` random bytes read from the OS.
pub fn read(bytes_needed int) ?[]u8 {
pub fn read(bytes_needed int) ![]u8 {
mut buffer := []u8{len: bytes_needed}
status := C.SecRandomCopyBytes(C.SecRandomRef(0), bytes_needed, buffer.data)
if status != 0 {

2
vlib/crypto/rand/rand_default.c.v
View File

@ -4,6 +4,6 @@
module rand
// read returns an array of `bytes_needed` random bytes read from the OS.
pub fn read(bytes_needed int) ?[]u8 {
pub fn read(bytes_needed int) ![]u8 {
return error('rand.read is not implemented on this platform')
}

2
vlib/crypto/rand/rand_freebsd.c.v
View File

@ -9,7 +9,7 @@ module rand
fn C.arc4random_buf(p &byte, n usize)
// read returns an array of `bytes_needed` random bytes read from the OS.
pub fn read(bytes_needed int) ?[]u8 {
pub fn read(bytes_needed int) ![]u8 {
mut buffer := unsafe { malloc_noscan(bytes_needed) }
C.arc4random_buf(buffer, bytes_needed)
return unsafe { buffer.vbytes(bytes_needed) }

2
vlib/crypto/rand/rand_linux.c.v
View File

@ -10,7 +10,7 @@ const (
)
// read returns an array of `bytes_needed` random bytes read from the OS.
pub fn read(bytes_needed int) ?[]u8 {
pub fn read(bytes_needed int) ![]u8 {
mut buffer := unsafe { vcalloc_noscan(bytes_needed) }
mut bytes_read := 0
mut remaining_bytes := bytes_needed

2
vlib/crypto/rand/rand_openbsd.c.v
View File

@ -9,7 +9,7 @@ module rand
fn C.arc4random_buf(p &byte, n usize)
// read returns an array of `bytes_needed` random bytes read from the OS.
pub fn read(bytes_needed int) ?[]u8 {
pub fn read(bytes_needed int) ![]u8 {
mut buffer := unsafe { malloc_noscan(bytes_needed) }
C.arc4random_buf(buffer, bytes_needed)
return unsafe { buffer.vbytes(bytes_needed) }

2
vlib/crypto/rand/rand_solaris.c.v
View File

@ -13,7 +13,7 @@ const (
)
// read returns an array of `bytes_needed` random bytes read from the OS.
pub fn read(bytes_needed int) ?[]u8 {
pub fn read(bytes_needed int) ![]u8 {
mut buffer := unsafe { malloc_noscan(bytes_needed) }
mut bytes_read := 0
mut remaining_bytes := bytes_needed

2
vlib/crypto/rand/rand_windows.c.v
View File

@ -14,7 +14,7 @@ const (
)
// read returns an array of `bytes_needed` random bytes read from the OS.
pub fn read(bytes_needed int) ?[]u8 {
pub fn read(bytes_needed int) ![]u8 {
mut buffer := []u8{len: bytes_needed}
// use bcrypt_use_system_preferred_rng because we passed null as algo
status := C.BCryptGenRandom(0, buffer.data, bytes_needed, rand.bcrypt_use_system_preferred_rng)

4
vlib/crypto/rand/utils.v
View File

@ -8,7 +8,7 @@ import math.bits
import encoding.binary
// int_u64 returns a random unsigned 64-bit integer `u64` read from a real OS source of entropy.
pub fn int_u64(max u64) ?u64 {
pub fn int_u64(max u64) !u64 {
bitlen := bits.len_64(max)
if bitlen == 0 {
return u64(0)
@ -20,7 +20,7 @@ pub fn int_u64(max u64) ?u64 {
}
mut n := u64(0)
for {
mut bytes := read(k)?
mut bytes := read(k)!
bytes[0] &= u8(int(u64(1) << b) - 1)
x := bytes_to_u64(bytes)
n = x[0]

2
vlib/crypto/rc4/rc4.v
View File

@ -22,7 +22,7 @@ mut:
// new_cipher creates and returns a new Cipher. The key argument should be the
// RC4 key, at least 1 byte and at most 256 bytes.
pub fn new_cipher(key []u8) ?Cipher {
pub fn new_cipher(key []u8) !Cipher {
if key.len < 1 || key.len > 256 {
return error('crypto.rc4: invalid key size ' + key.len.str())
}

2
vlib/crypto/sha1/sha1.v
View File

@ -56,7 +56,7 @@ pub fn new() &Digest {
// write writes the contents of `p_` to the internal hash representation.
[manualfree]
pub fn (mut d Digest) write(p_ []u8) ?int {
pub fn (mut d Digest) write(p_ []u8) !int {
nn := p_.len
unsafe {
mut p := p_

2
vlib/crypto/sha256/sha256.v
View File

@ -90,7 +90,7 @@ pub fn new224() &Digest {
}
// write writes the contents of `p_` to the internal hash representation.
pub fn (mut d Digest) write(p_ []u8) ?int {
pub fn (mut d Digest) write(p_ []u8) !int {
unsafe {
mut p := p_
nn := p.len

2
vlib/crypto/sha512/sha512.v
View File

@ -149,7 +149,7 @@ fn new384() &Digest {
}
// write writes the contents of `p_` to the internal hash representation.
pub fn (mut d Digest) write(p_ []u8) ?int {
pub fn (mut d Digest) write(p_ []u8) !int {
unsafe {
mut p := p_
nn := p.len

2
vlib/encoding/base58/alphabet.v
View File

@ -42,7 +42,7 @@ pub fn (alphabet Alphabet) str() string {
// new_alphabet instantiates an Alphabet object based on
// the provided characters
pub fn new_alphabet(str string) ?Alphabet {
pub fn new_alphabet(str string) !Alphabet {
if str.len != 58 {
return error(@MOD + '.' + @FN + ': string must be 58 characters in length')
}

18
vlib/encoding/base58/base58.v
View File

@ -5,12 +5,12 @@ module base58
import math
// encode_int encodes any integer type to base58 string with Bitcoin alphabet
pub fn encode_int(input int) ?string {
pub fn encode_int(input int) !string {
return encode_int_walpha(input, btc_alphabet)
}
// encode_int_walpha any integer type to base58 string with custom alphabet
pub fn encode_int_walpha(input int, alphabet Alphabet) ?string {
pub fn encode_int_walpha(input int, alphabet Alphabet) !string {
if input <= 0 {
return error(@MOD + '.' + @FN + ': input must be greater than zero')
}
@ -97,12 +97,12 @@ pub fn encode_walpha_bytes(input []u8, alphabet Alphabet) []u8 {
}
// decode_int decodes base58 string to an integer with Bitcoin alphabet
pub fn decode_int(input string) ?int {
pub fn decode_int(input string) !int {
return decode_int_walpha(input, btc_alphabet)
}
// decode_int_walpha decodes base58 string to an integer with custom alphabet
pub fn decode_int_walpha(input string, alphabet Alphabet) ?int {
pub fn decode_int_walpha(input string, alphabet Alphabet) !int {
mut total := 0 // to hold the results
b58 := input.reverse()
for i, ch in b58 {
@ -121,27 +121,27 @@ pub fn decode_int_walpha(input string, alphabet Alphabet) ?int {
}
// decode decodes the base58 input string, using the Bitcoin alphabet
pub fn decode(str string) ?string {
pub fn decode(str string) !string {
return decode_walpha(str, btc_alphabet)
}
// decode_bytes decodes the base58 encoded input array, using the Bitcoin alphabet
pub fn decode_bytes(input []u8) ?[]u8 {
pub fn decode_bytes(input []u8) ![]u8 {
return decode_walpha_bytes(input, btc_alphabet)
}
// decode_walpha decodes the base58 encoded input string, using custom alphabet
pub fn decode_walpha(input string, alphabet Alphabet) ?string {
pub fn decode_walpha(input string, alphabet Alphabet) !string {
if input.len == 0 {
return ''
}
bin := input.bytes()
res := decode_walpha_bytes(bin, alphabet)?
res := decode_walpha_bytes(bin, alphabet)!
return res.bytestr()
}
// decode_walpha_bytes decodes the base58 encoded input array using a custom alphabet
pub fn decode_walpha_bytes(input []u8, alphabet Alphabet) ?[]u8 {
pub fn decode_walpha_bytes(input []u8, alphabet Alphabet) ![]u8 {
if input.len == 0 {
return []
}

35
vlib/encoding/base58/base58_test.v
View File

@ -1,41 +1,34 @@
module base58
fn main() {
test_encode_int() or {}
test_decode_int() or {}
test_encode_string()
test_fails() or {}
}
fn test_encode_int() ? {
fn test_encode_int() {
a := 0x24 // should be 'd' in base58
assert encode_int(a)? == 'd'
assert encode_int(a)! == 'd'
test_encode_int_walpha()?
test_encode_int_walpha()
}
fn test_encode_int_walpha() ? {
fn test_encode_int_walpha() {
// random alphabet
abc := new_alphabet('abcdefghij\$lmnopqrstuvwxyz0123456789_ABCDEFGHIJLMNOPQRSTUV') or {
panic(@MOD + '.' + @FN + ': this should never happen')
}
a := 0x24 // should be '_' in base58 with our custom alphabet
assert encode_int_walpha(a, abc)? == '_'
assert encode_int_walpha(a, abc)! == '_'
}
fn test_decode_int() ? {
fn test_decode_int() {
a := 'd'
assert decode_int(a)? == 0x24
assert decode_int(a)! == 0x24
test_decode_int_walpha()?
test_decode_int_walpha()
}
fn test_decode_int_walpha() ? {
fn test_decode_int_walpha() {
abc := new_alphabet('abcdefghij\$lmnopqrstuvwxyz0123456789_ABCDEFGHIJLMNOPQRSTUV') or {
panic(@MOD + '.' + @FN + ': this should never happen')
}
a := '_'
assert decode_int_walpha(a, abc)? == 0x24
assert decode_int_walpha(a, abc)! == 0x24
}
fn test_encode_string() {
@ -49,18 +42,18 @@ fn test_encode_string() {
assert encode_walpha(a, abc) == '0P7yfPSL0pQh2L5'
}
fn test_decode_string() ? {
fn test_decode_string() {
a := 'TtaR6twpTGu8VpY'
assert decode(a)? == 'lorem ipsum'
assert decode(a)! == 'lorem ipsum'
abc := new_alphabet('abcdefghij\$lmnopqrstuvwxyz0123456789_ABCDEFGHIJLMNOPQRSTUV') or {
panic(@MOD + '.' + @FN + ': this should never happen')
}
b := '0P7yfPSL0pQh2L5'
assert decode_walpha(b, abc)? == 'lorem ipsum'
assert decode_walpha(b, abc)! == 'lorem ipsum'
}
fn test_fails() ? {
fn test_fails() ! {
a := -238
b := 0
if z := encode_int(a) {

10
vlib/encoding/base58/base58_usage_test.v
View File

@ -1,7 +1,7 @@
import encoding.base58
import encoding.hex
fn test_encode() ? {
fn test_encode() {
for input, expected in {
'': ''
'6263': '2PMCRQ'
@ -14,20 +14,20 @@ fn test_encode() ? {
}
}
fn test_encode_int() ? {
fn test_encode_int() {
for input, expected in {
0x6263: '8VG'
0x61: '2g'
0x626262: 'a3gV'
0x636363: 'aPEr'
} {
output := base58.encode_int(input)?
output := base58.encode_int(input)!
println('> input: 0x${input:x} | => output: `$output`')
assert output == expected
}
}
fn test_decode() ? {
fn test_decode() {
for output, expected in {
'USm3fpXnKG5EUBx2ndxBDMPVciP5hGey2Jh4NDv6gmeo1LkMeiKrLJUUBk6Z': 'The quick brown fox jumps over the lazy dog.'
'11StV1DL6CwTryKyV': '\x00\x00hello world'
@ -35,7 +35,7 @@ fn test_decode() ? {
'14cxpo3MBCYYWCgF74SWTdcmxipnGUsPw3': hex.decode('0027b5891b01da2db74cde1689a97a2acbe23d5fb1c0205bf6')?.bytestr()
'3vQB7B6MrGQZaxCuFg4oh': hex.decode('68656c6c6f20776f726c64bc62d4b8')?.bytestr()
} {
input := base58.decode(output)?
input := base58.decode(output)!
println('> output: `$output` | decoded input: `$input` | bytes: $input.bytes().hex()')
assert input.bytes().hex() == expected.bytes().hex()
}

10
vlib/encoding/csv/reader.v
View File

@ -68,8 +68,8 @@ pub fn new_reader(data string, config ReaderConfig) &Reader {
// read reads a row from the CSV data.
// If successful, the result holds an array of each column's data.
pub fn (mut r Reader) read() ?[]string {
l := r.read_record()?
pub fn (mut r Reader) read() ![]string {
l := r.read_record()!
return l
}
@ -88,7 +88,7 @@ pub fn (mut r Reader) read() ?[]string {
// }
// return records
// }
fn (mut r Reader) read_line() ?string {
fn (mut r Reader) read_line() !string {
// last record
if r.row_pos == r.data.len {
return IError(&EndOfFileError{})
@ -119,7 +119,7 @@ fn (mut r Reader) read_line() ?string {
return line
}
fn (mut r Reader) read_record() ?[]string {
fn (mut r Reader) read_record() ![]string {
if r.delimiter == r.comment {
return IError(&CommentIsDelimiterError{})
}
@ -133,7 +133,7 @@ fn (mut r Reader) read_record() ?[]string {
mut i := -1
for {
if need_read {
l := r.read_line()?
l := r.read_line()!
if l.len <= 0 {
if keep_raw {
line += '\n'

2
vlib/encoding/csv/writer.v
View File

@ -28,7 +28,7 @@ pub fn new_writer(config WriterConfig) &Writer {
}
// write writes a single record
pub fn (mut w Writer) write(record []string) ?bool {
pub fn (mut w Writer) write(record []string) !bool {
if !valid_delim(w.delimiter) {
return IError(&InvalidDelimiterError{})
}

18
vlib/encoding/hex/hex.v
View File

@ -5,7 +5,7 @@ import strings
// decode converts a hex string into an array of bytes. The expected
// input format is 2 ASCII characters for each output byte. If the provided
// string length is not a multiple of 2, an implicit `0` is prepended to it.
pub fn decode(s string) ?[]u8 {
pub fn decode(s string) ![]u8 {
mut hex_str := s
if hex_str.len >= 2 {
if s[0] == `0` && (s[1] == `x` || s[1] == `X`) {
@ -15,24 +15,24 @@ pub fn decode(s string) ?[]u8 {
if hex_str.len == 0 {
return []u8{}
} else if hex_str.len == 1 {
return [char2nibble(hex_str[0])?]
return [char2nibble(hex_str[0])!]
} else if hex_str.len == 2 {
n1 := char2nibble(hex_str[0])?
n0 := char2nibble(hex_str[1])?
n1 := char2nibble(hex_str[0])!
n0 := char2nibble(hex_str[1])!
return [(n1 << 4) | n0]
}
// calculate the first byte depending on if hex_str.len is odd
mut val := char2nibble(hex_str[0])?
mut val := char2nibble(hex_str[0])!
if hex_str.len & 1 == 0 {
val = (val << 4) | char2nibble(hex_str[1])?
val = (val << 4) | char2nibble(hex_str[1])!
}
// set cap to hex_str.len/2 rounded up
mut bytes := []u8{len: 1, cap: (hex_str.len + 1) >> 1, init: val}
// iterate over every 2 bytes
// the start index depends on if hex_str.len is odd
for i := 2 - (hex_str.len & 1); i < hex_str.len; i += 2 {
n1 := char2nibble(hex_str[i])?
n0 := char2nibble(hex_str[i + 1])?
n1 := char2nibble(hex_str[i])!
n0 := char2nibble(hex_str[i + 1])!
bytes << (n1 << 4) | n0
}
return bytes
@ -52,7 +52,7 @@ pub fn encode(bytes []u8) string {
}
// char2nibble converts an ASCII hex character to it's hex value
fn char2nibble(b u8) ?u8 {
fn char2nibble(b u8) !u8 {
match b {
`0`...`9` { return b - u8(`0`) }
`A`...`F` { return b - u8(`A`) + 10 }

60
vlib/encoding/hex/hex_test.v
View File

@ -1,19 +1,19 @@
module hex
fn test_decode() ? {
assert decode('')? == []
assert decode('0')? == [u8(0x0)]
assert decode('f')? == [u8(0xf)]
assert decode('0f')? == [u8(0x0f)]
assert decode('ff')? == [u8(0xff)]
assert decode('123')? == [u8(0x1), 0x23]
assert decode('1234')? == [u8(0x12), 0x34]
assert decode('12345')? == [u8(0x1), 0x23, 0x45]
assert decode('0123456789abcdef')? == [u8(0x01), 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef]
assert decode('123456789ABCDEF')? == [u8(0x01), 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef]
fn test_decode() {
assert decode('')! == []
assert decode('0')! == [u8(0x0)]
assert decode('f')! == [u8(0xf)]
assert decode('0f')! == [u8(0x0f)]
assert decode('ff')! == [u8(0xff)]
assert decode('123')! == [u8(0x1), 0x23]
assert decode('1234')! == [u8(0x12), 0x34]
assert decode('12345')! == [u8(0x1), 0x23, 0x45]
assert decode('0123456789abcdef')! == [u8(0x01), 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef]
assert decode('123456789ABCDEF')! == [u8(0x01), 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef]
}
fn test_decode_fails() ? {
fn test_decode_fails() ! {
if x := decode('foo') {
return error('expected decode to fail, got $x')
}
@ -31,24 +31,24 @@ fn test_decode_fails() ? {
}
}
fn test_encode() ? {
assert encode(decode('')?) == ''
assert encode(decode('0')?) == '00'
assert encode(decode('f')?) == '0f'
assert encode(decode('0f')?) == '0f'
assert encode(decode('ff')?) == 'ff'
assert encode(decode('123')?) == '0123'
assert encode(decode('1234')?) == '1234'
assert encode(decode('12345')?) == '012345'
assert encode(decode('abcdef')?) == 'abcdef'
assert encode(decode('ABCDEF')?) == 'abcdef'
fn test_encode() {
assert encode(decode('')!) == ''
assert encode(decode('0')!) == '00'
assert encode(decode('f')!) == '0f'
assert encode(decode('0f')!) == '0f'
assert encode(decode('ff')!) == 'ff'
assert encode(decode('123')!) == '0123'
assert encode(decode('1234')!) == '1234'
assert encode(decode('12345')!) == '012345'
assert encode(decode('abcdef')!) == 'abcdef'
assert encode(decode('ABCDEF')!) == 'abcdef'
}
fn test_decode_0x() ? {
assert decode('0x')? == []
assert decode('0x0')? == [u8(0x0)]
assert decode('0X1234')? == [u8(0x12), 0x34]
assert decode('0x12345')? == [u8(0x1), 0x23, 0x45]
assert decode('0x0123456789abcdef')? == [u8(0x01), 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef]
assert decode('0X123456789ABCDEF')? == [u8(0x01), 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef]
fn test_decode_0x() {
assert decode('0x')! == []
assert decode('0x0')! == [u8(0x0)]
assert decode('0X1234')! == [u8(0x12), 0x34]
assert decode('0x12345')! == [u8(0x1), 0x23, 0x45]
assert decode('0x0123456789abcdef')! == [u8(0x01), 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef]
assert decode('0X123456789ABCDEF')! == [u8(0x01), 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef]
}

8
vlib/math/big/integer.v
View File

@ -154,17 +154,17 @@ pub fn integer_from_bytes(input []u8, config IntegerConfig) Integer {
// integer_from_string creates a new `big.Integer` from the decimal digits specified in the given string.
// For other bases, use `big.integer_from_radix` instead.
pub fn integer_from_string(characters string) ?Integer {
pub fn integer_from_string(characters string) !Integer {
return integer_from_radix(characters, 10)
}
// integer_from_radix creates a new `big.Integer` from the given string and radix.
pub fn integer_from_radix(all_characters string, radix u32) ?Integer {
pub fn integer_from_radix(all_characters string, radix u32) !Integer {
if radix < 2 || radix > 36 {
return error('Radix must be between 2 and 36 (inclusive)')
}
characters := all_characters.to_lower()
validate_string(characters, radix)?
validate_string(characters, radix)!
return match radix {
2 {
integer_from_special_string(characters, 1)
@ -179,7 +179,7 @@ pub fn integer_from_radix(all_characters string, radix u32) ?Integer {
}
[direct_array_access]
fn validate_string(characters string, radix u32) ? {
fn validate_string(characters string, radix u32) ! {
sign_present := characters[0] == `+` || characters[0] == `-`
start_index := if sign_present { 1 } else { 0 }

4
vlib/rand/README.md
View File

@ -16,7 +16,7 @@ rand.seed([u32(3110), 50714])
...
// Use the top-level functions
rand.u32n(100)?
rand.u32n(100)!
rand.int() // among others ...
```
@ -41,7 +41,7 @@ rng.seed(seed.time_seed_array(pcg32.seed_len))
...
// Use functions of your choice
rng.u32n(100)?
rng.u32n(100)!
rng.int() // among others ...
```

2
vlib/rand/config/config.v
View File

@ -36,7 +36,7 @@ pub:
}
// validate_for is a helper function for validating the configuration struct for the given array.
pub fn (config ShuffleConfigStruct) validate_for<T>(a []T) ? {
pub fn (config ShuffleConfigStruct) validate_for<T>(a []T) ! {
if config.start < 0 || config.start >= a.len {
return error("argument 'config.start' must be in range [0, a.len)")
}

110
vlib/rand/rand.v
View File

@ -26,7 +26,7 @@ mut:
// bytes returns a buffer of `bytes_needed` random bytes
[inline]
pub fn (mut rng PRNG) bytes(bytes_needed int) ?[]u8 {
pub fn (mut rng PRNG) bytes(bytes_needed int) ![]u8 {
if bytes_needed < 0 {
return error('can not read < 0 random bytes')
}
@ -44,7 +44,7 @@ pub fn (mut rng PRNG) read(mut buf []u8) {
// u32n returns a uniformly distributed pseudorandom 32-bit signed positive `u32` in range `[0, max)`.
[inline]
pub fn (mut rng PRNG) u32n(max u32) ?u32 {
pub fn (mut rng PRNG) u32n(max u32) !u32 {
if max == 0 {
return error('max must be positive integer')
}
@ -76,7 +76,7 @@ pub fn (mut rng PRNG) u32n(max u32) ?u32 {
// u64n returns a uniformly distributed pseudorandom 64-bit signed positive `u64` in range `[0, max)`.
[inline]
pub fn (mut rng PRNG) u64n(max u64) ?u64 {
pub fn (mut rng PRNG) u64n(max u64) !u64 {
if max == 0 {
return error('max must be positive integer')
}
@ -102,20 +102,20 @@ pub fn (mut rng PRNG) u64n(max u64) ?u64 {
// u32_in_range returns a uniformly distributed pseudorandom 32-bit unsigned `u32` in range `[min, max)`.
[inline]
pub fn (mut rng PRNG) u32_in_range(min u32, max u32) ?u32 {
pub fn (mut rng PRNG) u32_in_range(min u32, max u32) !u32 {
if max <= min {
return error('max must be greater than min')
}
return min + rng.u32n(max - min)?
return min + rng.u32n(max - min)!
}
// u64_in_range returns a uniformly distributed pseudorandom 64-bit unsigned `u64` in range `[min, max)`.
[inline]
pub fn (mut rng PRNG) u64_in_range(min u64, max u64) ?u64 {
pub fn (mut rng PRNG) u64_in_range(min u64, max u64) !u64 {
if max <= min {
return error('max must be greater than min')
}
return min + rng.u64n(max - min)?
return min + rng.u64n(max - min)!
}
// i8 returns a (possibly negative) pseudorandom 8-bit `i8`.
@ -156,39 +156,39 @@ pub fn (mut rng PRNG) int63() i64 {
// intn returns a pseudorandom `int` in range `[0, max)`.
[inline]
pub fn (mut rng PRNG) intn(max int) ?int {
pub fn (mut rng PRNG) intn(max int) !int {
if max <= 0 {
return error('max has to be positive.')
}
return int(rng.u32n(u32(max))?)
return int(rng.u32n(u32(max))!)
}
// i64n returns a pseudorandom int that lies in `[0, max)`.
[inline]
pub fn (mut rng PRNG) i64n(max i64) ?i64 {
pub fn (mut rng PRNG) i64n(max i64) !i64 {
if max <= 0 {
return error('max has to be positive.')
}
return i64(rng.u64n(u64(max))?)
return i64(rng.u64n(u64(max))!)
}
// int_in_range returns a pseudorandom `int` in range `[min, max)`.
[inline]
pub fn (mut rng PRNG) int_in_range(min int, max int) ?int {
pub fn (mut rng PRNG) int_in_range(min int, max int) !int {
if max <= min {
return error('max must be greater than min')
}
// This supports negative ranges like [-10, -5) because the difference is positive
return min + rng.intn(max - min)?
return min + rng.intn(max - min)!
}
// i64_in_range returns a pseudorandom `i64` in range `[min, max)`.
[inline]
pub fn (mut rng PRNG) i64_in_range(min i64, max i64) ?i64 {
pub fn (mut rng PRNG) i64_in_range(min i64, max i64) !i64 {
if max <= min {
return error('max must be greater than min')
}
return min + rng.i64n(max - min)?
return min + rng.i64n(max - min)!
}
// f32 returns a pseudorandom `f32` value in range `[0, 1)`.
@ -205,7 +205,7 @@ pub fn (mut rng PRNG) f64() f64 {
// f32n returns a pseudorandom `f32` value in range `[0, max]`.
[inline]
pub fn (mut rng PRNG) f32n(max f32) ?f32 {
pub fn (mut rng PRNG) f32n(max f32) !f32 {
if max < 0 {
return error('max has to be non-negative.')
}
@ -214,7 +214,7 @@ pub fn (mut rng PRNG) f32n(max f32) ?f32 {
// f64n returns a pseudorandom `f64` value in range `[0, max]`.
[inline]
pub fn (mut rng PRNG) f64n(max f64) ?f64 {
pub fn (mut rng PRNG) f64n(max f64) !f64 {
if max < 0 {
return error('max has to be non-negative.')
}
@ -223,20 +223,20 @@ pub fn (mut rng PRNG) f64n(max f64) ?f64 {
// f32_in_range returns a pseudorandom `f32` in range `[min, max]`.
[inline]
pub fn (mut rng PRNG) f32_in_range(min f32, max f32) ?f32 {
pub fn (mut rng PRNG) f32_in_range(min f32, max f32) !f32 {
if max < min {
return error('max must be greater than or equal to min')
}
return min + rng.f32n(max - min)?
return min + rng.f32n(max - min)!
}
// i64_in_range returns a pseudorandom `i64` in range `[min, max]`.
[inline]
pub fn (mut rng PRNG) f64_in_range(min f64, max f64) ?f64 {
pub fn (mut rng PRNG) f64_in_range(min f64, max f64) !f64 {
if max < min {
return error('max must be greater than or equal to min')
}
return min + rng.f64n(max - min)?
return min + rng.f64n(max - min)!
}
// ulid generates an Unique Lexicographically sortable IDentifier.
@ -275,7 +275,7 @@ pub fn (mut rng PRNG) ascii(len int) string {
}
// bernoulli returns true with a probability p. Note that 0 <= p <= 1.
pub fn (mut rng PRNG) bernoulli(p f64) ?bool {
pub fn (mut rng PRNG) bernoulli(p f64) !bool {
if p < 0 || p > 1 {
return error('$p is not a valid probability value.')
}
@ -284,13 +284,13 @@ pub fn (mut rng PRNG) bernoulli(p f64) ?bool {
// normal returns a normally distributed pseudorandom f64 in range `[0, 1)`.
// NOTE: Use normal_pair() instead if you're generating a lot of normal variates.
pub fn (mut rng PRNG) normal(conf config.NormalConfigStruct) ?f64 {
x, _ := rng.normal_pair(conf)?
pub fn (mut rng PRNG) normal(conf config.NormalConfigStruct) !f64 {
x, _ := rng.normal_pair(conf)!
return x
}
// normal_pair returns a pair of normally distributed pseudorandom f64 in range `[0, 1)`.
pub fn (mut rng PRNG) normal_pair(conf config.NormalConfigStruct) ?(f64, f64) {
pub fn (mut rng PRNG) normal_pair(conf config.NormalConfigStruct) !(f64, f64) {
if conf.sigma <= 0 {
return error('Standard deviation must be positive')
}
@ -315,7 +315,7 @@ pub fn (mut rng PRNG) normal_pair(conf config.NormalConfigStruct) ?(f64, f64) {
// binomial returns the number of successful trials out of n when the
// probability of success for each trial is p.
pub fn (mut rng PRNG) binomial(n int, p f64) ?int {
pub fn (mut rng PRNG) binomial(n int, p f64) !int {
if p < 0 || p > 1 {
return error('$p is not a valid probability value.')
}
@ -342,8 +342,8 @@ pub fn (mut rng PRNG) exponential(lambda f64) f64 {
// optional and the entire array is shuffled by default. Leave the end as 0 to
// shuffle all elements until the end.
[direct_array_access]
pub fn (mut rng PRNG) shuffle<T>(mut a []T, config config.ShuffleConfigStruct) ? {
config.validate_for(a)?
pub fn (mut rng PRNG) shuffle<T>(mut a []T, config config.ShuffleConfigStruct) ! {
config.validate_for(a)!
new_end := if config.end == 0 { a.len } else { config.end }
// We implement the Fisher-Yates shuffle:
@ -360,23 +360,23 @@ pub fn (mut rng PRNG) shuffle<T>(mut a []T, config config.ShuffleConfigStruct) ?
// shuffle_clone returns a random permutation of the elements in `a`.
// The permutation is done on a fresh clone of `a`, so `a` remains unchanged.
pub fn (mut rng PRNG) shuffle_clone<T>(a []T, config config.ShuffleConfigStruct) ?[]T {
pub fn (mut rng PRNG) shuffle_clone<T>(a []T, config config.ShuffleConfigStruct) ![]T {
mut res := a.clone()
rng.shuffle<T>(mut res, config)?
rng.shuffle<T>(mut res, config)!
return res
}
// choose samples k elements from the array without replacement.
// This means the indices cannot repeat and it restricts the sample size to be less than or equal to the size of the given array.
// Note that if the array has repeating elements, then the sample may have repeats as well.
pub fn (mut rng PRNG) choose<T>(array []T, k int) ?[]T {
pub fn (mut rng PRNG) choose<T>(array []T, k int) ![]T {
n := array.len
if k > n {
return error('Cannot choose $k elements without replacement from a $n-element array.')
}
mut results := []T{len: k}
mut indices := []int{len: n, init: it}
rng.shuffle<int>(mut indices)?
rng.shuffle<int>(mut indices)!
for i in 0 .. k {
results[i] = array[indices[i]]
}
@ -385,7 +385,7 @@ pub fn (mut rng PRNG) choose<T>(array []T, k int) ?[]T {
// element returns a random element from the given array.
// Note that all the positions in the array have an equal chance of being selected. This means that if the array has repeating elements, then the probability of selecting a particular element is not uniform.
pub fn (mut rng PRNG) element<T>(array []T) ?T {
pub fn (mut rng PRNG) element<T>(array []T) !T {
if array.len == 0 {
return error('Cannot choose an element from an empty array.')
}
@ -445,22 +445,22 @@ pub fn u64() u64 {
}
// u32n returns a uniformly distributed pseudorandom 32-bit signed positive `u32` in range `[0, max)`.
pub fn u32n(max u32) ?u32 {
pub fn u32n(max u32) !u32 {
return default_rng.u32n(max)
}
// u64n returns a uniformly distributed pseudorandom 64-bit signed positive `u64` in range `[0, max)`.
pub fn u64n(max u64) ?u64 {
pub fn u64n(max u64) !u64 {
return default_rng.u64n(max)
}
// u32_in_range returns a uniformly distributed pseudorandom 32-bit unsigned `u32` in range `[min, max)`.
pub fn u32_in_range(min u32, max u32) ?u32 {
pub fn u32_in_range(min u32, max u32) !u32 {
return default_rng.u32_in_range(min, max)
}
// u64_in_range returns a uniformly distributed pseudorandom 64-bit unsigned `u64` in range `[min, max)`.
pub fn u64_in_range(min u64, max u64) ?u64 {
pub fn u64_in_range(min u64, max u64) !u64 {
return default_rng.u64_in_range(min, max)
}
@ -475,7 +475,7 @@ pub fn int() int {
}
// intn returns a uniformly distributed pseudorandom 32-bit signed positive `int` in range `[0, max)`.
pub fn intn(max int) ?int {
pub fn intn(max int) !int {
return default_rng.intn(max)
}
@ -486,7 +486,7 @@ pub fn u8() u8 {
// int_in_range returns a uniformly distributed pseudorandom 32-bit signed int in range `[min, max)`.
// Both `min` and `max` can be negative, but we must have `min < max`.
pub fn int_in_range(min int, max int) ?int {
pub fn int_in_range(min int, max int) !int {
return default_rng.int_in_range(min, max)
}
@ -501,12 +501,12 @@ pub fn i64() i64 {
}
// i64n returns a uniformly distributed pseudorandom 64-bit signed positive `i64` in range `[0, max)`.
pub fn i64n(max i64) ?i64 {
pub fn i64n(max i64) !i64 {
return default_rng.i64n(max)
}
// i64_in_range returns a uniformly distributed pseudorandom 64-bit signed `i64` in range `[min, max)`.
pub fn i64_in_range(min i64, max i64) ?i64 {
pub fn i64_in_range(min i64, max i64) !i64 {
return default_rng.i64_in_range(min, max)
}
@ -526,27 +526,27 @@ pub fn f64() f64 {
}
// f32n returns a uniformly distributed 32-bit floating point in range `[0, max)`.
pub fn f32n(max f32) ?f32 {
pub fn f32n(max f32) !f32 {
return default_rng.f32n(max)
}
// f64n returns a uniformly distributed 64-bit floating point in range `[0, max)`.
pub fn f64n(max f64) ?f64 {
pub fn f64n(max f64) !f64 {
return default_rng.f64n(max)
}
// f32_in_range returns a uniformly distributed 32-bit floating point in range `[min, max)`.
pub fn f32_in_range(min f32, max f32) ?f32 {
pub fn f32_in_range(min f32, max f32) !f32 {
return default_rng.f32_in_range(min, max)
}
// f64_in_range returns a uniformly distributed 64-bit floating point in range `[min, max)`.
pub fn f64_in_range(min f64, max f64) ?f64 {
pub fn f64_in_range(min f64, max f64) !f64 {
return default_rng.f64_in_range(min, max)
}
// bytes returns a buffer of `bytes_needed` random bytes
pub fn bytes(bytes_needed int) ?[]u8 {
pub fn bytes(bytes_needed int) ![]u8 {
return default_rng.bytes(bytes_needed)
}
@ -599,26 +599,26 @@ pub fn ascii(len int) string {
// shuffle randomly permutates the elements in `a`. The range for shuffling is
// optional and the entire array is shuffled by default. Leave the end as 0 to
// shuffle all elements until the end.
pub fn shuffle<T>(mut a []T, config config.ShuffleConfigStruct) ? {
default_rng.shuffle<T>(mut a, config)?
pub fn shuffle<T>(mut a []T, config config.ShuffleConfigStruct) ! {
default_rng.shuffle<T>(mut a, config)!
}
// shuffle_clone returns a random permutation of the elements in `a`.
// The permutation is done on a fresh clone of `a`, so `a` remains unchanged.
pub fn shuffle_clone<T>(a []T, config config.ShuffleConfigStruct) ?[]T {
pub fn shuffle_clone<T>(a []T, config config.ShuffleConfigStruct) ![]T {
return default_rng.shuffle_clone<T>(a, config)
}
// choose samples k elements from the array without replacement.
// This means the indices cannot repeat and it restricts the sample size to be less than or equal to the size of the given array.
// Note that if the array has repeating elements, then the sample may have repeats as well.
pub fn choose<T>(array []T, k int) ?[]T {
pub fn choose<T>(array []T, k int) ![]T {
return default_rng.choose<T>(array, k)
}
// element returns a random element from the given array.
// Note that all the positions in the array have an equal chance of being selected. This means that if the array has repeating elements, then the probability of selecting a particular element is not uniform.
pub fn element<T>(array []T) ?T {
pub fn element<T>(array []T) !T {
return default_rng.element<T>(array)
}
@ -629,24 +629,24 @@ pub fn sample<T>(array []T, k int) []T {
}
// bernoulli returns true with a probability p. Note that 0 <= p <= 1.
pub fn bernoulli(p f64) ?bool {
pub fn bernoulli(p f64) !bool {
return default_rng.bernoulli(p)
}
// normal returns a normally distributed pseudorandom f64 in range `[0, 1)`.
// NOTE: Use normal_pair() instead if you're generating a lot of normal variates.
pub fn normal(conf config.NormalConfigStruct) ?f64 {
pub fn normal(conf config.NormalConfigStruct) !f64 {
return default_rng.normal(conf)
}
// normal_pair returns a pair of normally distributed pseudorandom f64 in range `[0, 1)`.
pub fn normal_pair(conf config.NormalConfigStruct) ?(f64, f64) {
pub fn normal_pair(conf config.NormalConfigStruct) !(f64, f64) {
return default_rng.normal_pair(conf)
}
// binomial returns the number of successful trials out of n when the
// probability of success for each trial is p.
pub fn binomial(n int, p f64) ?int {
pub fn binomial(n int, p f64) !int {
return default_rng.binomial(n, p)
}

4
vlib/rand/random_bytes_test.v
View File

@ -3,7 +3,7 @@ import rand
fn test_rand_bytes() {
mut randoms := []string{}
for i in 0 .. 100 {
x := rand.bytes(i)?.hex()
x := rand.bytes(i)!.hex()
if x.len > 0 {
randoms << x
}
@ -25,7 +25,7 @@ fn test_prng_rand_bytes() {
mut randoms := []string{}
mut rng := rand.get_current_rng()
for i in 0 .. 100 {
x := rng.bytes(i)?.hex()
x := rng.bytes(i)!.hex()
if x.len > 0 {
randoms << x
}

10
vlib/rand/random_numbers_test.v
View File

@ -358,11 +358,11 @@ fn test_shuffle_partial() {
mut a := [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
mut b := a.clone()
rand.shuffle(mut a, start: 4)?
rand.shuffle(mut a, start: 4)!
assert a[..4] == b[..4]
a = b.clone()
rand.shuffle(mut a, start: 3, end: 7)?
rand.shuffle(mut a, start: 3, end: 7)!
assert a[..3] == b[..3]
assert a[7..] == b[7..]
}
@ -386,7 +386,7 @@ fn test_choose() {
lengths := [1, 3, 4, 5, 6, 7]
a := ['one', 'two', 'three', 'four', 'five', 'six', 'seven']
for length in lengths {
b := rand.choose(a, length)?
b := rand.choose(a, length)!
assert b.len == length
for element in b {
assert element in a
@ -415,7 +415,7 @@ fn test_sample() {
fn test_element1() {
a := ['one', 'two', 'four', 'five', 'six', 'seven']
for _ in 0 .. 30 {
e := rand.element(a)?
e := rand.element(a)!
assert e in a
assert 'three' != e
}
@ -423,7 +423,7 @@ fn test_element1() {
fn test_element2() {
for _ in 0 .. 30 {
e := rand.element([1, 2, 5, 6, 7, 8])?
e := rand.element([1, 2, 5, 6, 7, 8])!
assert e in [1, 2, 5, 6, 7, 8]
assert 3 != e
assert 4 != e

14
vlib/readline/readline_default.c.v
View File

@ -23,7 +23,7 @@ struct Termios {
// an error if the line is empty.
// The `prompt` `string` is output as a prefix text for the input capturing.
// read_line_utf8 is the main method of the `readline` module and `Readline` struct.
pub fn (mut r Readline) read_line_utf8(prompt string) ?[]rune {
pub fn (mut r Readline) read_line_utf8(prompt string) ![]rune {
r.current = []rune{}
r.cursor = 0
r.prompt = prompt
@ -49,8 +49,8 @@ pub fn (mut r Readline) read_line_utf8(prompt string) ?[]rune {
// read_line does the same as `read_line_utf8` but returns user input as a `string`.
// (As opposed to `[]rune` returned by `read_line_utf8`).
pub fn (mut r Readline) read_line(prompt string) ?string {
s := r.read_line_utf8(prompt)?
pub fn (mut r Readline) read_line(prompt string) !string {
s := r.read_line_utf8(prompt)!
return s.string()
}
@ -63,9 +63,9 @@ pub fn (mut r Readline) read_line(prompt string) ?string {
// read_line_utf8 is the main method of the `readline` module and `Readline` struct.
// NOTE that this version of `read_line_utf8` is a standalone function without
// persistent functionalities (e.g. history).
pub fn read_line_utf8(prompt string) ?[]rune {
pub fn read_line_utf8(prompt string) ![]rune {
mut r := Readline{}
s := r.read_line_utf8(prompt)?
s := r.read_line_utf8(prompt)!
return s
}
@ -73,8 +73,8 @@ pub fn read_line_utf8(prompt string) ?[]rune {
// (As opposed to `[]rune` as returned by `read_line_utf8`).
// NOTE that this version of `read_line` is a standalone function without
// persistent functionalities (e.g. history).
pub fn read_line(prompt string) ?string {
pub fn read_line(prompt string) !string {
mut r := Readline{}
s := r.read_line(prompt)?
s := r.read_line(prompt)!
return s
}

6
vlib/readline/readline_js.js.v
View File

@ -15,7 +15,7 @@ struct Termios {}
// The `prompt` `string` is output as a prefix text for the input capturing.
// read_line_utf8 is the main method of the `readline` module and `Readline` struct.
pub fn (mut r Readline) read_line(prompt string) ?string {
pub fn (mut r Readline) read_line(prompt string) !string {
res := ''
print(prompt)
#const rl = $readline.createInterface({input: $process.stdin,output: $process.stdout,prompt: prompt.str})
@ -25,8 +25,8 @@ pub fn (mut r Readline) read_line(prompt string) ?string {
return res
}
pub fn read_line(prompt string) ?string {
pub fn read_line(prompt string) !string {
mut r := Readline{}
s := r.read_line(prompt)?
s := r.read_line(prompt)!
return s
}

14
vlib/readline/readline_linux.c.v
View File

@ -133,7 +133,7 @@ pub fn (r Readline) read_char() !int {
// an error if the line is empty.
// The `prompt` `string` is output as a prefix text for the input capturing.
// read_line_utf8 is the main method of the `readline` module and `Readline` struct.
pub fn (mut r Readline) read_line_utf8(prompt string) ?[]rune {
pub fn (mut r Readline) read_line_utf8(prompt string) ![]rune {
r.current = []rune{}
r.cursor = 0
r.prompt = prompt
@ -168,8 +168,8 @@ pub fn (mut r Readline) read_line_utf8(prompt string) ?[]rune {
// read_line does the same as `read_line_utf8` but returns user input as a `string`.
// (As opposed to `[]rune` returned by `read_line_utf8`).
pub fn (mut r Readline) read_line(prompt string) ?string {
s := r.read_line_utf8(prompt)?
pub fn (mut r Readline) read_line(prompt string) !string {
s := r.read_line_utf8(prompt)!
return s.string()
}
@ -182,9 +182,9 @@ pub fn (mut r Readline) read_line(prompt string) ?string {
// read_line_utf8 is the main method of the `readline` module and `Readline` struct.
// NOTE that this version of `read_line_utf8` is a standalone function without
// persistent functionalities (e.g. history).
pub fn read_line_utf8(prompt string) ?[]rune {
pub fn read_line_utf8(prompt string) ![]rune {
mut r := Readline{}
s := r.read_line_utf8(prompt)?
s := r.read_line_utf8(prompt)!
return s
}
@ -192,9 +192,9 @@ pub fn read_line_utf8(prompt string) ?[]rune {
// (As opposed to `[]rune` as returned by `read_line_utf8`).
// NOTE that this version of `read_line` is a standalone function without
// persistent functionalities (e.g. history).
pub fn read_line(prompt string) ?string {
pub fn read_line(prompt string) !string {
mut r := Readline{}
s := r.read_line(prompt)?
s := r.read_line(prompt)!
return s
}

14
vlib/readline/readline_windows.c.v
View File

@ -24,7 +24,7 @@ struct Termios {
// an error if the line is empty.
// The `prompt` `string` is output as a prefix text for the input capturing.
// read_line_utf8 is the main method of the `readline` module and `Readline` struct.
pub fn (mut r Readline) read_line_utf8(prompt string) ?[]rune {
pub fn (mut r Readline) read_line_utf8(prompt string) ![]rune {
r.current = []rune{}
r.cursor = 0
r.prompt = prompt
@ -47,8 +47,8 @@ pub fn (mut r Readline) read_line_utf8(prompt string) ?[]rune {
// read_line does the same as `read_line_utf8` but returns user input as a `string`.
// (As opposed to `[]rune` returned by `read_line_utf8`).
pub fn (mut r Readline) read_line(prompt string) ?string {
s := r.read_line_utf8(prompt)?
pub fn (mut r Readline) read_line(prompt string) !string {
s := r.read_line_utf8(prompt)!
return s.string()
}
@ -61,9 +61,9 @@ pub fn (mut r Readline) read_line(prompt string) ?string {
// read_line_utf8 is the main method of the `readline` module and `Readline` struct.
// NOTE that this version of `read_line_utf8` is a standalone function without
// persistent functionalities (e.g. history).
pub fn read_line_utf8(prompt string) ?[]rune {
pub fn read_line_utf8(prompt string) ![]rune {
mut r := Readline{}
s := r.read_line_utf8(prompt)?
s := r.read_line_utf8(prompt)!
return s
}
@ -71,8 +71,8 @@ pub fn read_line_utf8(prompt string) ?[]rune {
// (As opposed to `[]rune` as returned by `read_line_utf8`).
// NOTE that this version of `read_line` is a standalone function without
// persistent functionalities (e.g. history).
pub fn read_line(prompt string) ?string {
pub fn read_line(prompt string) !string {
mut r := Readline{}
s := r.read_line(prompt)?
s := r.read_line(prompt)!
return s
}

2
vlib/v/embed_file/decoder.v
View File

@ -2,7 +2,7 @@
module embed_file
interface Decoder {
decompress([]u8) ?[]u8
decompress([]u8) ![]u8
}
struct EmbedFileDecoders {

6
vlib/v/gen/c/coutput_test.v
View File

@ -22,7 +22,7 @@ fn test_out_files() {
println(term.colorize(term.green, '> testing whether .out files match:'))
os.chdir(vroot) or {}
output_path := os.join_path(os.temp_dir(), 'v', 'coutput', 'out')
os.mkdir_all(output_path)?
os.mkdir_all(output_path)!
defer {
os.rmdir_all(output_path) or {}
}
@ -50,7 +50,7 @@ fn test_out_files() {
panic(res.output)
}
mut found := res.output.trim_right('\r\n').replace('\r\n', '\n')
mut expected := os.read_file(out_path)?
mut expected := os.read_file(out_path)!
expected = expected.trim_right('\r\n').replace('\r\n', '\n')
if expected.contains('================ V panic ================') {
// panic include backtraces and absolute file paths, so can't do char by char comparison
@ -93,7 +93,7 @@ fn test_c_must_have_files() {
println(term.colorize(term.green, '> testing whether `.c.must_have` files match:'))
os.chdir(vroot) or {}
output_path := os.join_path(os.temp_dir(), 'v', 'coutput', 'c_must_have')
os.mkdir_all(output_path)?
os.mkdir_all(output_path)!
defer {
os.rmdir_all(output_path) or {}
}

2
vlib/v/gen/c/testdata/embed_with_prod_and_several_decoders.c.must_have vendored
View File

@ -3,7 +3,7 @@
{1, { .str=(byteptr)("embed.vv"), .len=8, .is_lit=1 }, { .str=(byteptr)("none"), .len=4, .is_lit=1 }, _v_embed_blob_1},
VV_LOCAL_SYMBOL void v__preludes__embed_file__zlib__init(void);
VV_LOCAL_SYMBOL _option_Array_u8 v__preludes__embed_file__zlib__ZLibDecoder_decompress(v__preludes__embed_file__zlib__ZLibDecoder _d1, Array_u8 data) {
VV_LOCAL_SYMBOL _result_Array_u8 v__preludes__embed_file__zlib__ZLibDecoder_decompress(v__preludes__embed_file__zlib__ZLibDecoder _d1, Array_u8 data) {
= compress__zlib__decompress(data);
res.compressed = v__embed_file__find_index_entry_by_path((voidptr)_v_embed_file_index, _SLIT("embed.vv"), _SLIT("zlib"))->data;

2
vlib/v/preludes/embed_file/zlib/embed_file_zlib.v
View File

@ -5,7 +5,7 @@ import v.embed_file
struct ZLibDecoder {}
fn (_ ZLibDecoder) decompress(data []u8) ?[]u8 {
fn (_ ZLibDecoder) decompress(data []u8) ![]u8 {
return zlib.decompress(data)
}

2
vlib/v/tests/repl/import_alias.repl
View File

@ -1,4 +1,4 @@
import compress.zlib as z
z.compress('hello world'.bytes())?
z.compress('hello world'.bytes())!
===output===
[120, 1, 1, 11, 0, 244, 255, 104, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100, 26, 11, 4, 93]