package core:strconv

Source

Appends the string representation of an integer to a buffer with specified base, flags, and digit set.

Inputs
buf: The buffer to append the integer representation to x: The integer value to convert base: The base for the integer representation (2 <= base <= MAX_BASE) is_signed: A boolean indicating if the input should be treated as a signed integer bit_size: The bit size of the signed integer representation (8, 16, 32, or 64) digits: The digit set used for the integer representation flags: The Int_Flags bit set to control integer formatting

Returns
The string containing the integer representation appended to the buffer

Appends the string representation of a 128-bit integer to a buffer with specified base, flags, and digit set.

Inputs
buf: The buffer to append the integer representation to x: The 128-bit integer value to convert base: The base for the integer representation (2 <= base <= MAX_BASE) is_signed: A boolean indicating if the input should be treated as a signed integer bit_size: The bit size of the signed integer representation (8, 16, 32, 64, or 128) digits: The digit set used for the integer representation flags: The Int_Flags bit set to control integer formatting

Returns
The string containing the integer representation appended to the buffer

Appends a boolean value as a string to the given buffer

Inputs
buf: The buffer to append the boolean value to b: The boolean value to be appended

import "core:fmt"
import "core:strconv"
append_bool_example :: proc() {
	buf: [6]byte
	result := strconv.append_bool(buf[:], true)
	fmt.println(result, buf)
}

true [116, 114, 117, 101, 0, 0]

Returns
The resulting string after appending the boolean value

Appends a float64 value as a string to the given buffer with the specified format and precision

Inputs
buf: The buffer to append the float64 value to f: The float64 value to be appended fmt: The byte specifying the format to use for the conversion prec: The precision to use for the conversion bit_size: The size of the float in bits (32 or 64)

import "core:fmt"
import "core:strconv"
append_float_example :: proc() {
	buf: [8]byte
	result := strconv.append_float(buf[:], 3.14159, 'f', 2, 64)
	fmt.println(result, buf)
}

+3.14 [43, 51, 46, 49, 52, 0, 0, 0]

Returns
The resulting string after appending the float

Appends a signed integer value as a string to the given buffer with the specified base

Inputs
buf: The buffer to append the signed integer value to i: The signed integer value to be appended base: The base to use for converting the integer value

import "core:fmt"
import "core:strconv"
append_int_example :: proc() {
	buf: [4]byte
	result := strconv.append_int(buf[:], -42, 10)
	fmt.println(result, buf)
}

-42 [45, 52, 50, 0]

Returns
The resulting string after appending the signed integer value

Appends an unsigned integer value as a string to the given buffer with the specified base

Inputs
buf: The buffer to append the unsigned integer value to u: The unsigned integer value to be appended base: The base to use for converting the integer value

import "core:fmt"
import "core:strconv"
append_uint_example :: proc() {
	buf: [4]byte
	result := strconv.append_uint(buf[:], 42, 16)
	fmt.println(result, buf)
}

2a [50, 97, 0, 0]

Returns
The resulting string after appending the unsigned integer value

Converts a string to a float64 value

Inputs
s: The string to be converted

import "core:fmt"
import "core:strconv"
atof_example :: proc() {
	fmt.printfln("%.3f", strconv.atof("3.14"))
}

3.140

Returns
The resulting float64 value after converting the string

Converts a string to an integer value

Inputs
s: The string to be converted

import "core:fmt"
import "core:strconv"
atoi_example :: proc() {
	fmt.println(strconv.atoi("42"))
}

42

Returns
The resulting integer value

Converts a decimal floating-point number into a byte buffer with the given format

Inputs
buf: The byte buffer to store the formatted number shortest: If true, generates the shortest representation of the number neg: If true, the number is negative digs: The decimal number to be formatted precision: The number of digits after the decimal point fmt: The format specifier (accepted values: 'f', 'F', 'e', 'E', 'g', 'G')

Returns
A byte slice containing the formatted decimal floating-point number

Appends a float64 value as a string to the given buffer with the specified format and precision

Inputs
buf: The buffer to append the float64 value to f: The float64 value to be appended fmt: The byte specifying the format to use for the conversion prec: The precision to use for the conversion bit_size: The size of the float in bits (32 or 64)

import "core:fmt"
import "core:strconv"
append_float_example :: proc() {
	buf: [8]byte
	result := strconv.append_float(buf[:], 3.14159, 'f', 2, 64)
	fmt.println(result, buf)
}

+3.14 [43, 51, 46, 49, 52, 0, 0, 0]

Returns
The resulting string after appending the float

Converts a floating-point number to a string with the specified format and precision.

Inputs

buf: A byte slice to store the resulting string val: The floating-point value to be converted fmt: The formatting byte, accepted values are 'e', 'E', 'f', 'F', 'g', 'G' precision: The number of decimal places to round to bit_size: The size of the floating-point number in bits, valid values are 16, 32, 64

buf: [32]byte
val := 3.141592
fmt := 'f'
precision := 2
bit_size := 64
result := strconv.generic_ftoa(buf[:], val, fmt, precision, bit_size) -> "3.14"

Returns
A byte slice containing the formatted string

Determines whether the given unsigned 64-bit integer is a negative value by interpreting it as a signed integer with the specified bit size.

Inputs
x: The unsigned 64-bit integer to check for negativity is_signed: A boolean indicating if the input should be treated as a signed integer bit_size: The bit size of the signed integer representation (8, 16, 32, or 64)

Returns
u: The absolute value of the input integer neg: A boolean indicating whether the input integer is negative

Determines whether the given unsigned 128-bit integer is a negative value by interpreting it as a signed integer with the specified bit size.

Inputs
x: The unsigned 128-bit integer to check for negativity is_signed: A boolean indicating if the input should be treated as a signed integer bit_size: The bit size of the signed integer representation (8, 16, 32, 64, or 128)

Returns
u: The absolute value of the input integer neg: A boolean indicating whether the input integer is negative

Converts an integer value to a string and stores it in the given buffer

Inputs
buf: The buffer to store the resulting string i: The integer value to be converted

import "core:fmt"
import "core:strconv"
itoa_example :: proc() {
	buf: [4]byte
	result := strconv.itoa(buf[:], 42)
	fmt.println(result, buf) // "42"
}

42 [52, 50, 0, 0]

Returns
The resulting string after converting the integer value

Parses a boolean value from the input string

Inputs
s: The input string

- true: "1", "t", "T", "true", "TRUE", "True"
- false: "0", "f", "F", "false", "FALSE", "False"

n: An optional pointer to an int to store the length of the parsed substring (default: nil)

Returns result: The parsed boolean value (default: false) ok: A boolean indicating whether the parsing was successful

Parses a 128-bit complex number from a string

Inputs
str: The input string containing a 128-bit complex number. n: An optional pointer to an int to store the length of the parsed substring (default: nil).

import "core:fmt"
import "core:strconv"
parse_complex128_example :: proc() {
	n: int
	c, ok := strconv.parse_complex128("3+1i", &n)
	fmt.printfln("%v %i %t", c, n, ok)

	c, ok = strconv.parse_complex128("5+7i hellope", &n)
	fmt.printfln("%v %i %t", c, n, ok)
}

3+1i 4 true
5+7i 4 false

Returns
value: The parsed 128-bit complex number. ok: false if a complex number could not be found, or if the input string contained more than just the number.

Parses a 32-bit complex number from a string

Inputs
str: The input string containing a 32-bit complex number. n: An optional pointer to an int to store the length of the parsed substring (default: nil).

import "core:fmt"
import "core:strconv"
parse_complex32_example :: proc() {
	n: int
	c, ok := strconv.parse_complex32("3+1i", &n)
	fmt.printfln("%v %i %t", c, n, ok)

	c, ok = strconv.parse_complex32("5+7i hellope", &n)
	fmt.printfln("%v %i %t", c, n, ok)
}

3+1i 4 true
5+7i 4 false

Returns
value: The parsed 32-bit complex number. ok: false if a complex number could not be found, or if the input string contained more than just the number.

Parses a 64-bit complex number from a string

Inputs
str: The input string containing a 64-bit complex number. n: An optional pointer to an int to store the length of the parsed substring (default: nil).

import "core:fmt"
import "core:strconv"
parse_complex64_example :: proc() {
	n: int
	c, ok := strconv.parse_complex64("3+1i", &n)
	fmt.printfln("%v %i %t", c, n, ok)

	c, ok = strconv.parse_complex64("5+7i hellope", &n)
	fmt.printfln("%v %i %t", c, n, ok)
}

3+1i 4 true
5+7i 4 false

Returns
value: The parsed 64-bit complex number. ok: false if a complex number could not be found, or if the input string contained more than just the number.

Parses a 32-bit floating point number from a string

Inputs
s: The input string containing a 32-bit floating point number. n: An optional pointer to an int to store the length of the parsed substring (default: nil).

import "core:fmt"
import "core:strconv"
parse_f32_example :: proc() {
	n, ok := strconv.parse_f32("1234eee")
	fmt.printfln("%.3f %v", n, ok)

	n, ok = strconv.parse_f32("5678e2")
	fmt.printfln("%.3f %v", n, ok)
}

0.000 false
567800.000 true

Returns
value: The parsed 32-bit floating point number. ok: false if a base 10 float could not be found, or if the input string contained more than just the number.

Parses a 32-bit floating point number from a string and returns the parsed number, the length of the parsed substring, and a boolean indicating whether the parsing was successful

Inputs
str: The input string containing a 32-bit floating point number.

import "core:fmt"
import "core:strconv"
parse_f32_prefix_example :: proc() {
	n, _, ok := strconv.parse_f32_prefix("1234eee")
	fmt.printfln("%.3f %v", n, ok)

	n, _, ok = strconv.parse_f32_prefix("5678e2")
	fmt.printfln("%.3f %v", n, ok)
}

0.000 false
567800.000 true

Returns
value: The parsed 32-bit floating point number. nr: The length of the parsed substring. ok: A boolean indicating whether the parsing was successful.

Parses a 64-bit floating point number from a string

Inputs
str: The input string containing a 64-bit floating point number. n: An optional pointer to an int to store the length of the parsed substring (default: nil).

import "core:fmt"
import "core:strconv"
parse_f64_example :: proc() {
	n, ok := strconv.parse_f64("1234eee")
	fmt.printfln("%.3f %v", n, ok)

	n, ok = strconv.parse_f64("5678e2")
	fmt.printfln("%.3f %v", n, ok)
}

0.000 false
567800.000 true

Returns
value: The parsed 64-bit floating point number. ok: false if a base 10 float could not be found, or if the input string contained more than just the number.

Parses a 64-bit floating point number from a string and returns the parsed number, the length of the parsed substring, and a boolean indicating whether the parsing was successful

Inputs
str: The input string containing a 64-bit floating point number.

import "core:fmt"
import "core:strconv"
parse_f64_prefix_example :: proc() {
	n, _, ok := strconv.parse_f64_prefix("12.34eee")
	fmt.printfln("%.3f %v", n, ok)

	n, _, ok = strconv.parse_f64_prefix("12.34e2")
	fmt.printfln("%.3f %v", n, ok)

	n, _, ok = strconv.parse_f64_prefix("13.37 hellope")
	fmt.printfln("%.3f %v", n, ok)
}

0.000 false
1234.000 true
13.370 true

Returns
value: The parsed 64-bit floating point number. nr: The length of the parsed substring. ok: false if a base 10 float could not be found

Parses an integer value from a string in base 10, unless there's a prefix

Inputs
str: The input string containing the integer value n: An optional pointer to an int to store the length of the parsed substring (default: nil)

import "core:fmt"
import "core:strconv"
parse_i128_maybe_prefixed_example :: proc() {
	n, ok := strconv.parse_i128_maybe_prefixed("1234")
	fmt.println(n, ok)

	n, ok = strconv.parse_i128_maybe_prefixed("0xeeee")
	fmt.println(n, ok)
}

1234 true
61166 true

Returns
value: The parsed i128 value ok: false if a valid integer could not be found, or if the input string contained more than just the number.

Parses an integer value from a string in the given base, without any prefix

Inputs
str: The input string containing the integer value base: The base (radix) to use for parsing the integer (1-16) n: An optional pointer to an int to store the length of the parsed substring (default: nil)

import "core:fmt"
import "core:strconv"
parse_i128_of_base_example :: proc() {
	n, ok := strconv.parse_i128_of_base("-1234eeee", 10)
	fmt.println(n,ok)
}

-1234 false

Returns
value: The parsed i128 value ok: false if no numeric value of the appropriate base could be found, or if the input string contained more than just the number.

Parses an integer value from the input string in base 10, unless there's a prefix

Inputs str: The input string to parse the integer value from n: An optional pointer to an int to store the length of the parsed substring (default: nil)

import "core:fmt"
import "core:strconv"
parse_i64_maybe_prefixed_example :: proc() {
	n, ok := strconv.parse_i64_maybe_prefixed("1234")
	fmt.println(n,ok)

	n, ok = strconv.parse_i64_maybe_prefixed("0xeeee")
	fmt.println(n,ok)
}

1234 true
61166 true

Returns value: The parsed integer value ok: ok=false if a valid integer could not be found, or if the input string contained more than just the number.

Parses an integer value from the input string in the given base, without a prefix

Inputs str: The input string to parse the integer value from base: The base of the integer value to be parsed (must be between 1 and 16) n: An optional pointer to an int to store the length of the parsed substring (default: nil)

import "core:fmt"
import "core:strconv"
parse_i64_of_base_example :: proc() {
	n, ok := strconv.parse_i64_of_base("-1234e3", 10)
	fmt.println(n, ok)
}

-1234 false

Returns value: Parses an integer value from a string, in the given base, without a prefix. ok: ok=false if no numeric value of the appropriate base could be found, or if the input string contained more than just the number.

Parses a signed integer value from the input string, using the specified base or inferring the base from a prefix

Inputs s: The input string to parse base: The base of the number system to use for parsing (default: 0)

- If base is 0, it will be inferred based on the prefix in the input string (e.g. '0x' for hexadecimal)
- If base is not 0, it will be used for parsing regardless of any prefix in the input string

import "core:fmt"
import "core:strconv"
parse_int_example :: proc() {
	n, ok := strconv.parse_int("1234") // without prefix, inferred base 10
	fmt.println(n,ok)

	n, ok = strconv.parse_int("ffff", 16) // without prefix, explicit base
	fmt.println(n,ok)

	n, ok = strconv.parse_int("0xffff") // with prefix and inferred base
	fmt.println(n,ok)
}

1234 true
65535 true
65535 true

Returns value: The parsed int value ok: false if no appropriate value could be found, or if the input string contained more than just the number.

Parses a 128-bit quaternion from a string

Inputs
str: The input string containing a 128-bit quaternion. n: An optional pointer to an int to store the length of the parsed substring (default: nil).

import "core:fmt"
import "core:strconv"
parse_quaternion128_example :: proc() {
	n: int
	q, ok := strconv.parse_quaternion128("1+2i+3j+4k", &n)
	fmt.printfln("%v %i %t", q, n, ok)

	q, ok = strconv.parse_quaternion128("1+2i+3j+4k hellope", &n)
	fmt.printfln("%v %i %t", q, n, ok)
}

1+2i+3j+4k 10 true
1+2i+3j+4k 10 false

Returns
value: The parsed 128-bit quaternion. ok: false if a quaternion could not be found, or if the input string contained more than just the quaternion.

Parses a 256-bit quaternion from a string

Inputs
str: The input string containing a 256-bit quaternion. n: An optional pointer to an int to store the length of the parsed substring (default: nil).

import "core:fmt"
import "core:strconv"
parse_quaternion256_example :: proc() {
	n: int
	q, ok := strconv.parse_quaternion256("1+2i+3j+4k", &n)
	fmt.printfln("%v %i %t", q, n, ok)

	q, ok = strconv.parse_quaternion256("1+2i+3j+4k hellope", &n)
	fmt.printfln("%v %i %t", q, n, ok)
}

1+2i+3j+4k 10 true
1+2i+3j+4k 10 false

Returns
value: The parsed 256-bit quaternion. ok: false if a quaternion could not be found, or if the input string contained more than just the quaternion.

Parses a 64-bit quaternion from a string

Inputs
str: The input string containing a 64-bit quaternion. n: An optional pointer to an int to store the length of the parsed substring (default: nil).

import "core:fmt"
import "core:strconv"
parse_quaternion64_example :: proc() {
	n: int
	q, ok := strconv.parse_quaternion64("1+2i+3j+4k", &n)
	fmt.printfln("%v %i %t", q, n, ok)

	q, ok = strconv.parse_quaternion64("1+2i+3j+4k hellope", &n)
	fmt.printfln("%v %i %t", q, n, ok)
}

1+2i+3j+4k 10 true
1+2i+3j+4k 10 false

Returns
value: The parsed 64-bit quaternion. ok: false if a quaternion could not be found, or if the input string contained more than just the quaternion.

Parses an unsigned integer value from a string in base 10, unless there's a prefix

Inputs
str: The input string containing the integer value n: An optional pointer to an int to store the length of the parsed substring (default: nil)

import "core:fmt"
import "core:strconv"
parse_u128_maybe_prefixed_example :: proc() {
	n, ok := strconv.parse_u128_maybe_prefixed("1234")
	fmt.println(n, ok)

	n, ok = strconv.parse_u128_maybe_prefixed("5678eeee")
	fmt.println(n, ok)
}

1234 true
5678 false

Returns
value: The parsed u128 value ok: false if a valid integer could not be found, if the value was negative, or if the input string contained more than just the number.

Parses an unsigned integer value from a string in the given base, without any prefix

Inputs
str: The input string containing the integer value base: The base (radix) to use for parsing the integer (1-16) n: An optional pointer to an int to store the length of the parsed substring (default: nil)

import "core:fmt"
import "core:strconv"
parse_u128_of_base_example :: proc() {
	n, ok := strconv.parse_u128_of_base("1234eeee", 10)
	fmt.println(n, ok)

	n, ok = strconv.parse_u128_of_base("5678eeee", 16)
	fmt.println(n, ok)
}

1234 false
1450766062 true

Returns
value: The parsed u128 value ok: false if no numeric value of the appropriate base could be found, or if the input string contained more than just the number.

Parses an unsigned 64-bit integer value from the input string, using the specified base or inferring the base from a prefix

Inputs str: The input string to parse base: The base of the number system to use for parsing (default: 0)

- If base is 0, it will be inferred based on the prefix in the input string (e.g. '0x' for hexadecimal)
- If base is not 0, it will be used for parsing regardless of any prefix in the input string

n: An optional pointer to an int to store the length of the parsed substring (default: nil)

import "core:fmt"
import "core:strconv"
parse_u64_maybe_prefixed_example :: proc() {
	n, ok := strconv.parse_u64_maybe_prefixed("1234")
	fmt.println(n,ok)

	n, ok = strconv.parse_u64_maybe_prefixed("0xee")
	fmt.println(n,ok)
}

1234 true
238 true

Returns value: The parsed uint64 value ok: ok=false if a valid integer could not be found, if the value was negative, or if the input string contained more than just the number.

Parses an unsigned 64-bit integer value from the input string without a prefix, using the specified base

Inputs str: The input string to parse base: The base of the number system to use for parsing

- Must be between 1 and 16 (inclusive)

n: An optional pointer to an int to store the length of the parsed substring (default: nil)

import "core:fmt"
import "core:strconv"
parse_u64_of_base_example :: proc() {
	n, ok := strconv.parse_u64_of_base("1234e3", 10)
	fmt.println(n,ok)

	n, ok = strconv.parse_u64_of_base("5678eee",16)
	fmt.println(n,ok)
}

1234 false
90672878 true

Returns value: The parsed uint64 value ok: A boolean indicating whether the parsing was successful

Parses an unsigned integer value from the input string, using the specified base or inferring the base from a prefix

Inputs s: The input string to parse base: The base of the number system to use for parsing (default: 0, inferred)

- If base is 0, it will be inferred based on the prefix in the input string (e.g. '0x' for hexadecimal)
- If base is not 0, it will be used for parsing regardless of any prefix in the input string

import "core:fmt"
import "core:strconv"
parse_uint_example :: proc() {
	n, ok := strconv.parse_uint("1234") // without prefix, inferred base 10
	fmt.println(n,ok)

	n, ok = strconv.parse_uint("ffff", 16) // without prefix, explicit base
	fmt.println(n,ok)

	n, ok = strconv.parse_uint("0xffff") // with prefix and inferred base
	fmt.println(n,ok)
}

1234 true
65535 true
65535 true

Returns

value: The parsed uint value ok: false if no appropriate value could be found; the value was negative; he input string contained more than just the number

Appends a quoted string representation of the input string to a given byte slice and returns the result as a string

Inputs
buf: The byte slice to which the quoted string will be appended str: The input string to be quoted

!! ISSUE !! NOT EXPECTED -- "\"hello\"" was expected

import "core:fmt"
import "core:strconv"
quote_example :: proc() {
	buf: [20]byte
	result := strconv.quote(buf[:], "hello")
	fmt.println(result, buf)
}

"'h''e''l''l''o'" [34, 39, 104, 39, 39, 101, 39, 39, 108, 39, 39, 108, 39, 39, 111, 39, 34, 0, 0, 0]

Returns
The resulting string after appending the quoted string representation

Appends a quoted rune representation of the input rune to a given byte slice and returns the result as a string

Inputs
buf: The byte slice to which the quoted rune will be appended r: The input rune to be quoted

import "core:fmt"
import "core:strconv"
quote_rune_example :: proc() {
	buf: [4]byte
	result := strconv.quote_rune(buf[:], 'A')
	fmt.println(result, buf)
}

'A' [39, 65, 39, 0]

Returns
The resulting string after appending the quoted rune representation

Rounds the given decimal number to its shortest representation, considering the provided floating-point format

Inputs
d: The decimal number to round mant: The mantissa of the floating-point number exp: The exponent of the floating-point number flt: Pointer to the Float_Info structure containing information about the floating-point format

Unquotes a single character from the input string, considering the given quote character

Inputs
str: The input string containing the character to unquote quote: The quote character to consider (e.g., '"')

import "core:fmt"
import "core:strconv"
unquote_char_example :: proc() {
	src:="\'The\' raven"
	r, multiple_bytes, tail_string, success  := strconv.unquote_char(src,'\'')
	fmt.println("Source:", src)
	fmt.printf("r: <%v>, multiple_bytes:%v, tail_string:<%s>, success:%v\n",r, multiple_bytes, tail_string, success)
}

Source: 'The' raven
r: <'>, multiple_bytes:false, tail_string:<The' raven>, success:true

Returns
r: The unquoted rune multiple_bytes: A boolean indicating if the rune has multiple bytes tail_string: The remaining portion of the input string after unquoting the character success: A boolean indicating whether the unquoting was successful

Unquotes the input string considering any type of quote character and returns the unquoted string

Inputs
lit: The input string to unquote allocator: (default: context.allocator)

WARNING: This procedure gives unexpected results if the quotes are not the first and last characters.

import "core:fmt"
import "core:strconv"
unquote_string_example :: proc() {
	src:="\"The raven Huginn is black.\""
	s, allocated, ok := strconv.unquote_string(src)
	fmt.println(src)
	fmt.printf("Unquoted: <%s>, alloc:%v, ok:%v\n\n", s, allocated, ok)

	src="\'The raven Huginn\' is black."
	s, allocated, ok = strconv.unquote_string(src)
	fmt.println(src)
	fmt.printf("Unquoted: <%s>, alloc:%v, ok:%v\n\n", s, allocated, ok)

	src="The raven \'Huginn\' is black."
	s, allocated, ok = strconv.unquote_string(src) // Will produce undesireable results
	fmt.println(src)
	fmt.printf("Unquoted: <%s>, alloc:%v, ok:%v\n", s, allocated, ok) 
}

"The raven Huginn is black."
Unquoted: <The raven Huginn is black.>, alloc:false, ok:true

'The raven Huginn' is black.
Unquoted: <The raven Huginn' is black>, alloc:false, ok:true

The raven 'Huginn' is black.
Unquoted: <he raven 'Huginn' is black>, alloc:false, ok:true

Returns
res: The resulting unquoted string allocated: A boolean indicating if the resulting string was allocated using the provided allocator success: A boolean indicating whether the unquoting was successful

NOTE: If unquoting is unsuccessful, the allocated memory for the result will be freed.