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

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 Example: 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

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). Example: 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) } Output: 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). Example: 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) } Output: 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). Example: 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) } Output: 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). Example: 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) } Output: 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. Example: 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) } Output: 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). Example: 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) } Output: 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. Example: 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) } Output: 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) Example: 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) } Output: 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) Example: 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) } Output: -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) Example: 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) } Output: 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) Example: 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) } Output: -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 Example: 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) } Output: 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). Example: 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) } Output: 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). Example: 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) } Output: 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). Example: 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) } Output: 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) Example: 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) } Output: 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) Example: 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) } Output: 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) Example: 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) } Output: 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) Example: 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) } Output: 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 Example: 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) } Output: 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 Example: import "core:fmt" import "core:strconv" quote_example :: proc() { buf: [20]byte result := strconv.quote(buf[:], "hello") fmt.println(result, buf) } Output: "'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 Example: import "core:fmt" import "core:strconv" quote_rune_example :: proc() { buf: [4]byte result := strconv.quote_rune(buf[:], 'A') fmt.println(result, buf) } Output: 'A' [39, 65, 39, 0] **Returns** - The resulting string after writing 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., '"') Example: 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) } Output: 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. Example: 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) } Output: "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 Example: import "core:fmt" import "core:strconv" write_bool_example :: proc() { buf: [6]byte result := strconv.write_bool(buf[:], true) fmt.println(result, buf) } Output: 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) Example: 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) } Output: +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 Example: import "core:fmt" import "core:strconv" write_int_example :: proc() { buf: [4]byte result := strconv.write_int(buf[:], -42, 10) fmt.println(result, buf) } Output: -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 Example: import "core:fmt" import "core:strconv" write_uint_example :: proc() { buf: [4]byte result := strconv.write_uint(buf[:], 42, 16) fmt.println(result, buf) } Output: 2a [50, 97, 0, 0] **Returns** - The resulting string after writing the unsigned integer value