1
0
mirror of https://github.com/vlang/v.git synced 2023-08-10 21:13:21 +03:00
v/vlib/builtin/int.v

440 lines
6.9 KiB
V
Raw Normal View History

2020-02-03 07:00:36 +03:00
// Copyright (c) 2019-2020 Alexander Medvednikov. All rights reserved.
2019-06-23 05:21:30 +03:00
// Use of this source code is governed by an MIT license
// that can be found in the LICENSE file.
2019-06-22 21:20:28 +03:00
module builtin
/*
// old function for reference
pub fn (nn int) str1() string {
mut n := nn
2019-06-22 21:20:28 +03:00
if n == 0 {
return '0'
}
max := 16
mut buf := vcalloc(max + 1)
2019-06-22 21:20:28 +03:00
mut len := 0
mut is_neg := false
2019-06-22 21:20:28 +03:00
if n < 0 {
n = -n
is_neg = true
}
// Fill the string from the end
for n > 0 {
d := n % 10
2020-02-08 00:10:48 +03:00
buf[max - len - 1] = d + int(`0`)
2019-06-22 21:20:28 +03:00
len++
n = n / 10
}
// Prepend - if it's negative
if is_neg {
buf[max - len - 1] = `-`
len++
}
2019-12-09 16:41:07 +03:00
buf[max] = `\0`
2019-06-22 21:20:28 +03:00
return tos(buf + max - len, len)
}
*/
// ----- value to string functions -----
/*
// old function for reference
pub fn ptr_str(ptr voidptr) string {
buf := malloc(sizeof(double) * 5 + 1) // TODO
C.sprintf((buf), '%p', ptr)
return tos(buf, vstrlen(buf))
}
*/
pub fn ptr_str(ptr voidptr) string {
buf1 := u64(ptr).hex()
return buf1
}
const(
digit_pairs = "00102030405060708090011121314151617181910212223242526272829203132333435363738393041424344454647484940515253545556575859506162636465666768696071727374757677787970818283848586878889809192939495969798999"
)
// This implementation is the quickest with gcc -O2
[inline]
pub fn (nn int) str_l(max int) string {
mut n := nn
mut d := 0
if n == 0 {
return '0'
}
mut buf := malloc(max + 1)
2020-03-25 02:17:39 +03:00
mut is_neg := false
if n < 0 {
n = -n
is_neg = true
}
mut index := max
buf[index--] = `\0`
for n > 0 {
n1 := n / 100
d = ((n - (n1 * 100)) << 1)
n = n1
2020-03-25 02:17:39 +03:00
buf[index--] = digit_pairs.str[d++]
buf[index--] = digit_pairs.str[d]
}
index++
2020-03-25 02:17:39 +03:00
// remove head zero
if d < 20 {
index++
}
// Prepend - if it's negative
if is_neg {
index--
buf[index] = `-`
}
2020-03-25 02:17:39 +03:00
C.memmove(buf,buf+index, (max-index)+1 )
return tos(buf, (max-index))
//return tos(buf + index, (max-index))
}
2019-06-22 21:20:28 +03:00
2019-12-19 23:52:45 +03:00
pub fn (n i8) str() string {
return int(n).str_l(5)
2019-12-19 23:52:45 +03:00
}
pub fn (n i16) str() string {
return int(n).str_l(7)
2019-12-19 23:52:45 +03:00
}
pub fn (n u16) str() string {
return int(n).str_l(7)
}
pub fn (n int) str() string {
return n.str_l(12)
2019-12-19 23:52:45 +03:00
}
2019-12-03 21:14:17 +03:00
pub fn (nn u32) str() string {
2019-12-19 23:52:45 +03:00
mut n := nn
mut d := u32(0)
2020-02-08 00:10:48 +03:00
if n == 0 {
return '0'
}
max := 12
mut buf := malloc(max + 1)
2020-03-25 02:17:39 +03:00
mut index := max
buf[index--] = `\0`
2020-02-08 00:10:48 +03:00
for n > 0 {
n1 := n / u32(100)
d = ((n - (n1 * u32(100))) << u32(1))
n = n1
buf[index--] = digit_pairs[d++]
buf[index--] = digit_pairs[d]
2019-06-22 21:20:28 +03:00
}
index++
2020-03-25 02:17:39 +03:00
// remove head zero
if d < u32(20) {
index++
2019-06-22 21:20:28 +03:00
}
2020-03-25 02:17:39 +03:00
C.memmove(buf,buf+index, (max-index)+1 )
return tos(buf, (max-index))
//return tos(buf + index, (max-index))
2019-06-22 21:20:28 +03:00
}
2019-12-19 23:52:45 +03:00
[inline]
pub fn (n any_int) str() string {
return i64(n).str()
}
pub fn (nn i64) str() string {
mut n := nn
mut d := i64(0)
2020-02-08 00:10:48 +03:00
if n == 0 {
2019-06-22 21:20:28 +03:00
return '0'
}
max := 20
mut buf := vcalloc(max + 1)
2020-03-25 02:17:39 +03:00
mut is_neg := false
2020-02-08 00:10:48 +03:00
if n < 0 {
2019-06-22 21:20:28 +03:00
n = -n
is_neg = true
}
mut index := max
buf[index--] = `\0`
2020-02-07 16:49:14 +03:00
for n > 0 {
n1 := n / i64(100)
d = ((n - (n1 * i64(100))) << i64(1))
n = n1
buf[index--] = digit_pairs[d++]
buf[index--] = digit_pairs[d]
}
index++
2020-03-25 02:17:39 +03:00
// remove head zero
if d < i64(20) {
index++
2019-06-22 21:20:28 +03:00
}
2019-06-22 21:20:28 +03:00
// Prepend - if it's negative
if is_neg {
index--
buf[index] = `-`
2019-06-22 21:20:28 +03:00
}
C.memmove(buf,buf+index, (max-index)+1 )
return tos(buf, (max-index))
//return tos(buf + index, (max-index))
2019-06-22 21:20:28 +03:00
}
pub fn (nn u64) str() string {
2019-12-19 23:52:45 +03:00
mut n := nn
mut d := u64(0)
2020-02-07 16:49:14 +03:00
if n == 0 {
return '0'
}
max := 20
mut buf := vcalloc(max + 1)
2020-03-25 02:17:39 +03:00
mut index := max
buf[index--] = `\0`
2020-02-07 16:49:14 +03:00
for n > 0 {
n1 := n / 100
d = ((n - (n1 * 100)) << 1)
n = n1
buf[index--] = digit_pairs[d++]
buf[index--] = digit_pairs[d]
}
index++
2020-03-25 02:17:39 +03:00
// remove head zero
if d < 20 {
index++
}
C.memmove(buf,buf+index, (max-index)+1 )
return tos(buf, (max-index))
//return tos(buf + index, (max-index))
}
pub fn (b bool) str() string {
2019-06-22 21:20:28 +03:00
if b {
return 'true'
}
return 'false'
}
// ----- value to hex string functions -----
/*
//old function for reference
pub fn (n int) hex1() string {
2019-12-19 23:52:45 +03:00
len := if n >= 0 { n.str().len + 3 } else { 11 }
hex := malloc(len) // 0x + \n
2020-02-07 16:49:14 +03:00
count := C.sprintf((hex), '0x%x', n)
2019-07-01 18:00:09 +03:00
return tos(hex, count)
2019-06-22 21:20:28 +03:00
}
*/
2019-06-22 21:20:28 +03:00
2020-04-02 18:16:17 +03:00
pub fn (nn byte) hex() string {
if nn == 0 {
return '0'
}
mut n := nn
max := 2
mut buf := malloc(max + 1)
mut index := max
buf[index--] = `\0`
for n > 0 {
d := n & 0xF
n = n >> 4
buf[index--] = if d < 10 { d + `0` } else { d + 87 }
}
//buf[index--] = `x`
//buf[index] = `0`
index++
return tos(buf + index, (max - index))
}
pub fn (nn i8) hex() string {
return byte(nn).hex()
}
pub fn (nn u16) hex() string {
if nn == 0 {
return '0'
}
2020-04-02 18:16:17 +03:00
mut n := nn
max := 5
mut buf := malloc(max + 1)
mut index := max
buf[index--] = `\0`
for n > 0 {
d := byte(n & 0xF)
2020-04-02 18:16:17 +03:00
n = n >> 4
buf[index--] = if d < 10 { d + `0` } else { d + 87 }
}
//buf[index--] = `x`
//buf[index] = `0`
index++
return tos(buf + index, (max - index))
}
pub fn (nn i16) hex() string {
return u16(nn).hex()
}
pub fn (nn u32) hex() string {
if nn == 0 {
return '0'
}
mut n := nn
max := 10
mut buf := malloc(max + 1)
mut index := max
buf[index--] = `\0`
for n > 0 {
d := byte(n & 0xF)
n = n >> 4
buf[index--] = if d < 10 { d + `0` } else { d + 87 }
}
//buf[index--] = `x`
//buf[index] = `0`
index++
return tos(buf + index, (max - index))
2019-06-22 21:20:28 +03:00
}
2020-04-02 18:16:17 +03:00
pub fn (nn int) hex() string {
return u32(nn).hex()
}
2020-06-18 15:14:09 +03:00
pub fn (n int) hex2() string {
return '0x' + n.hex()
}
pub fn (nn u64) hex() string {
2020-04-02 18:16:17 +03:00
if nn == 0 {
return '0'
}
mut n := nn
max := 18
mut buf := malloc(max + 1)
mut index := max
buf[index--] = `\0`
for n > 0 {
d := byte(n & 0xF)
n = n >> 4
buf[index--] = if d < 10 { d + `0` } else { d + 87 }
}
//buf[index--] = `x`
//buf[index] = `0`
index++
C.memmove(buf,buf+index, (max-index)+1 )
return tos(buf, (max-index))
//return tos(buf + index, (max-index))
}
pub fn (nn i64) hex() string {
2020-04-02 18:16:17 +03:00
return u64(nn).hex()
}
pub fn (nn any_int) hex() string {
return u64(nn).hex()
}
pub fn (nn voidptr) str() string {
return u64(nn).hex()
}
pub fn (nn byteptr) str() string {
return u64(nn).hex()
}
// ----- utilities functions -----
/*
2019-07-01 18:36:23 +03:00
pub fn (c rune) str() string {
2020-02-08 00:10:48 +03:00
fst_byte := int(c)>>8 * 3 & 0xff
2019-07-01 18:36:23 +03:00
len := utf8_char_len(fst_byte)
2019-12-19 23:52:45 +03:00
mut str := string{
2019-07-01 18:36:23 +03:00
len: len
str: malloc(len + 1)
}
for i in 0..len {
2020-02-08 00:10:48 +03:00
str.str[i] = int(c)>>8 * (3 - i) & 0xff
2019-07-01 18:36:23 +03:00
}
2020-03-11 01:21:26 +03:00
str.str[len] = `\0`
2019-07-01 18:36:23 +03:00
return str
2019-06-22 21:20:28 +03:00
}
*/
2019-07-01 18:36:23 +03:00
pub fn (c byte) str() string {
2019-12-19 23:52:45 +03:00
mut str := string{
str: malloc(2)
2020-05-18 22:38:06 +03:00
len: 1
2019-06-22 21:20:28 +03:00
}
str.str[0] = c
str.str[1] = `\0`
return str
}
2019-08-04 10:36:21 +03:00
pub fn (c byte) is_capital() bool {
return c >= `A` && c <= `Z`
}
2019-08-04 10:36:21 +03:00
2019-07-25 19:07:16 +03:00
pub fn (b []byte) clone() []byte {
mut res := []byte{len: b.len}
2020-02-18 22:47:19 +03:00
//mut res := make([]byte, {repeat:b.len})
for i in 0..b.len {
res[i] = b[i]
}
return res
}
2019-07-25 19:07:16 +03:00
// TODO generic
pub fn (a []byte) contains(val byte) bool {
for aa in a {
if aa == val {
return true
}
}
return false
}
// TODO generic
fn (ar []int) contains(val int) bool {
for s in ar {
if s == val {
return true
}
}
return false
}
// TODO generic
pub fn (a []u64) contains(val u64) bool {
for aa in a {
if aa == val {
return true
}
}
return false
}