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

Returns
The resulting string after appending the boolean value

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]

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)

Returns
The resulting string after appending the float

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]

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

Returns
The resulting string after appending the signed 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]

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

Returns
The resulting string after appending the unsigned 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]

Converts a string to a float64 value

Inputs
s: The string to be converted

Returns
The resulting float64 value after converting the string

import "core:fmt"
import "core:strconv"
atof_example :: proc() {
	fmt.println(strconv.atof("3.14"))
}

3.140

Converts a string to an integer value

Inputs
s: The string to be converted

Returns
The resulting integer value

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

42

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)

Returns
The resulting string after appending the float

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]

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

Returns
A byte slice containing the formatted string

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"

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

Returns
The resulting string after converting the integer value

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]

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 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).

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.

import "core:fmt"
import "core:strconv"
parse_f32_example :: proc() {
	n, ok := strconv.parse_f32("1234eee")
	fmt.println(n, ok)

	n, ok = strconv.parse_f32("5678e2")
	fmt.println(n, ok)
}

0.000 false
567800.000 true

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.

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.

import "core:fmt"
import "core:strconv"
parse_f32_prefix_example :: proc() {
	n, _, ok := strconv.parse_f32_prefix("1234eee")
	fmt.println(n, ok)

	n, _, ok = strconv.parse_f32_prefix("5678e2")
	fmt.println(n, ok)
}

0.000 false
567800.000 true

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).

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.

import "core:fmt"
import "core:strconv"
parse_f64_example :: proc() {
	n, ok := strconv.parse_f64("1234eee")
	fmt.println(n, ok)

	n, ok = strconv.parse_f64("5678e2")
	fmt.println(n, ok)
}

0.000 false
567800.000 true

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.

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, or if the input string contained more than just the number.

import "core:fmt"
import "core:strconv"
parse_f64_prefix_example :: proc() {
	n, _, ok := strconv.parse_f64_prefix("12.34eee")
	fmt.println(n, ok)

	n, _, ok = strconv.parse_f64_prefix("12.34e2")
	fmt.println(n, ok)
}

0.000 false
1234.000 true

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)

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.

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

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)

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.

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

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)

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.

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

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)

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.

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

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

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.

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

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)

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.

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

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)

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.

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

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)

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.

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

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)

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

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

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

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

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

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

Returns
The resulting string after appending the quoted string representation

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]

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

Returns
The resulting string after appending the quoted rune representation

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]

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., '"')

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

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

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.

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.

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