package core:strconv

Source

• decimal_to_float_bits
• hex_float_bits
• round_shortest

• write_bits
• write_bits_128

Disable with -define:STRCONV_FAST_FLOAT=false to drop the Eisel-Lemire step and its table.

NOTE(MatthiasH): direct lookup was always faster in benchmarks

Converts a decimal number to its floating-point representation with the given format and returns the resulting bits

Inputs

• d: Pointer to the decimal number to convert
• info: Pointer to the Float_Info structure containing information about the floating-point format

Returns

• b: The bits representing the floating-point number
• overflow: A boolean indicating whether an overflow occurred during conversion

Accepts '0'..='9', otherwise returns ok = false

Computes the T closest to w * 10^q, rounding ties to even.

w must be the exact decimal significand. When the input had more digits than fit in a u64, call this with both the truncated significand w and w + 1: if both calls return the same bits, the result is correct. Otherwise, use a slow path.

Inputs

• T: f32 or f64
• q: The decimal exponent
• w: The decimal significand

Returns

• The IEEE-754 bit pattern of the result, without the sign bit. An overflow gives the bit pattern of infinity.

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

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

Converts mantissa * 2^exp to the bits of the float type that info describes, rounded to nearest, ties to even. trunc means that the exact value is a little larger than mantissa * 2^exp (nonzero digits were dropped).

Returns

• float_bits: The bits of the float, with the sign.
• ok: false if the value overflows. Then float_bits is infinity.

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

Reports if all 8 bytes of v are ASCII digits

Returns the new position and mantissa

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.

Returns the new position, the mantissa and the number of digits

Converts 8 ASCII digits (the first digit in the lowest byte) to their value

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 directly to T, so the result is correctly rounded for both f32 and f64.

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
• n: An optional pointer to an int to store the length of the parsed substring (default: nil)

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.

Scans a decimal floating-point number at the start of s. A fast scanner for the decimal float syntax: [+-] digits [. digits] [(e|E) [+-] digits] It skips a _ between digits

Returns

• mantissa, exp: The value is mantissa * 10^exp. If trunc is true, the scanner dropped the significant digits after the first 19. Then the exact value is in the range [mantissa, mantissa + 1) * 10^exp.
• neg: The number has a minus sign.
• nr: The number of bytes in the number.
• ok: false if s is not a 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
• n: An optional pointer to an int to store the length of the parsed substring (default: nil)

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

Writes 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 written
• 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 writing the quoted string representation

Writes 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 written
• 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 writing the quoted rune representation

Loads 8 bytes starting at s[i] in little-endian order

Reads the first 19 significant digits of a decimal number again. The scanner uses it only if the number has more than 19 digits, because then the mantissa can overflow.

Inputs

• s, i: The input, and the position of the first digit before the ..
• end: The position after the last digit.
• int_digits: The number of digits before the ..
• e: The exponent after the e, or 0.

Returns

• mantissa, exp: The value is mantissa * 10^exp, without the digits that were not read again.
• trunc: true if the procedure did not read all the digits again.

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

Scans a hexadecimal floating-point number at the start of s. [+-] 0x hexdigits [. hexdigits] (p|P) [+-] digits A _ between digits is skipped

Returns

• mantissa, exp: The value is mantissa * 2^exp. If trunc is true, the significant hex digits after the first 16 were dropped, and at least one of them was not zero.
• neg: The number has a minus sign.
• nr: The number of bytes in the number.
• ok: false if s does not start with a hexadecimal float.

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.

Writes 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

Writes 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 written to the buffer

Writes a boolean value as a string to the given buffer

Inputs

• buf: The buffer to write the boolean value to
• b: The boolean value to be written

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

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

Returns

• The resulting string after writing the boolean value

ftoa C name deprecated, use write_float instead (same procedure)

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

Inputs

• buf: The buffer to write the float64 value to
• f: The float64 value to be written
• 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"
write_float_example :: proc() {
	buf: [8]byte
	result := strconv.write_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 writing the float

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

Inputs

• buf: The buffer to write the signed integer value to
• i: The signed integer value to be written
• base: The base to use for converting the integer value

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

-42 [45, 52, 50, 0]

Returns

• The resulting string after writing the signed integer value

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

Inputs

• buf: The buffer to write the unsigned integer value to
• u: The unsigned integer value to be written
• base: The base to use for converting the integer value

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

2a [50, 97, 0, 0]

Returns

• The resulting string after writing the unsigned integer value