Package core.conv

Packages

package core.conv

Custom_Format

Custom_Format :: struct {
    format: (&Format_Output, &Format, rawptr) -> void
}

Tag-type used to specify how to format a structure.

@conv.Custom_Format.{ format_structure }
TheStructure :: struct { ... }

Custom_Format_Proc

Custom_Format_Proc :: struct {
    type: type_expr
}

Tag-type used to specify that a certain procedure should be used to format a type.

@conv.Custom_Format_Proc.{ TheStructure }
format_structure :: (output: &conv.Format_Output, format: &conv.Format, data: &TheStructure) { ... }

Custom_Parse

Custom_Parse :: struct {
    parse: (rawptr, [] u8, Allocator) -> bool
}

Tag-type used to specify how to parse a structure.

@conv.Custom_Parse.{ parse_structure }
TheStructure :: struct { ... }

Custom_Parse_Proc

Custom_Parse_Proc :: struct {
    type: type_expr
}

Tag-type used to specify that a certain procedure should be used to parse a type.

@conv.Custom_Parse_Proc.{ TheStructure }
parse_structure :: (data: &TheStructure, input: str, allocator: Allocator) -> bool { ... }

Format

Format :: struct {
    pretty_printing: bool
    quote_strings: bool
    single_quote_strings: bool
    dereference: bool
    custom_format: bool
    interpret_numbers: bool
    unpack_any: bool
    digits_after_decimal: u32
    indentation: u32
    base: u64
    minimum_width: u32
}

Formatting options passed to a custom formatter.

Format_Flush_Callback

Format_Flush_Callback :: struct {
    data: rawptr
    func: (rawptr, [] u8) -> bool
}

Format_Output

Format_Output :: struct {
    data: [&] u8
    count: u32
    capacity: u32
    flush: Format_Flush_Callback
}

Passed to any custom formatter. Wraps outputting data to any source, using a flush callback function. Use write to output a string. When the internal buffer is filled, flush is called to empty the buffer to the final destination.

Methods

Format_Output.write

Format_Output.write :: (output: &Format_Output, c: u8) -> void

Format_Output.write :: (output: &Format_Output, s: [] u8) -> void

f64_to_str

f64_to_str :: (f: f64, buf: [] u8, digits_after_decimal: i32) -> [] u8

Converts a floating point number into a string, using the buffer provided.

This is better than what used to be, but still relies on converting the integer part of the float to an integer, which could overflow.

format

format :: (buffer: [] u8, format: [] u8, va: ..any) -> [] u8

format :: (output: &Format_Output, format: [] u8, va: ..any) -> [] u8

format :: (format: [] u8, va: ..any) -> [] u8

format :: (buffer: &[..] u8, format: [] u8, va: ..any) -> [] u8

Formats a string using the provided arguments and format specified string. This has many overloads to make it easy to work with.

format_any

format_any :: (output: &Format_Output, formatting: &Format, v: any) -> void

This procedure converts any value into a string, using the type information system. If a custom formatter is specified for the type, that is used instead. This procedure is generally not used directly; instead, through format or format_va.

format_va

format_va :: (buffer: [] u8, format: [] u8, va: [] any, flush: Format_Flush_Callback) -> [] u8

format_va :: (format: [] u8, va: [] any, allocator: Allocator) -> [] u8

format_va :: (buffer: &[..] u8, format: [] u8, va: [] any) -> [] u8

format_va :: (output: &Format_Output, format: [] u8, va: [] any) -> [] u8

Like format, but takes the arguments as an array of anys, not a variadic argument array.

i64_to_str

i64_to_str :: (n: i64, base: u64, buf: [] u8, min_length: i32, prefix: bool) -> [] u8

Converts an integer into a string using the buffer provided. Supports upto base 64. If prefix is true, binary numbers are prefixed with '0b' and hexadecimal numbers are prefixed with '0x'.

parse

parse :: ($T: type_expr, to_parse: str) -> ? T

Shortcut to parse a type T using parse_any.

parse_any

parse_any :: macro (v: &$T, to_parse: str, string_allocator) -> bool

parse_any :: (target: rawptr, data_type: type_expr, to_parse: [] u8, string_allocator: Allocator) -> bool

Parses many different types from a string into a value. Uses a custom parser if one has been specified for the type given.

parse_with_allocator

parse_with_allocator :: ($T: type_expr, to_parse: str, allocator: Allocator) -> ? T

Shortcut to parse a type T using parse_any, and specify an allocator.

register_custom_formatter

register_custom_formatter :: (formatter: (&Format_Output, &Format, &$T) -> void) -> void

Registers a formatting function for a particular type. This type is inferred from the type of the third argument in the given function.

register_custom_parser

register_custom_parser :: (parser: (&$T, str, Allocator) -> bool) -> void

Registers a parsing function for a particular type. This type is inferred from the type of the first argument in the given function.

str_to_f64

str_to_f64 :: macro (s: [] u8) -> f64

str_to_f64 :: (s: &[] u8) -> f64

Converts a string to a floating point number.

str_to_i64

str_to_i64 :: macro (s: [] u8, base: u32) -> i64

str_to_i64 :: (s: &[] u8, base: u32) -> i64

Converts a string into an integer. Works with positive and negative integers. If given a pointer to a string, will modify the string to extract the integer part.

u64_to_str

u64_to_str :: (n: u64, base: u64, buf: [] u8, min_length: i32, prefix: bool) -> [] u8

Converts an unsigned number into a string using the buffer provided. Behaves like i64_to_str.