Skip to content

core/bytes

bytes

Types

2

Buffer :: struct {
	buf:       [dynamic]u8,
	off:       int,
	last_read: Read_Op,
}

A Buffer is a variable-sized buffer of bytes with a io.Stream interface The zero value for Buffer is an empty buffer ready to use.

Reader :: struct {
	s:         []u8,
	i:         i64,
	prev_rune: int,
}

Constants

1

MIN_READ :: 512Source

Procedures

125

alias :: proc(a: []u8, b: []u8) -> (bool)Source

alias returns true if and only if (⟺) a and b have a non-zero length, and any part of a overlaps with b.

alias_inexactly :: proc(a: []u8, b: []u8) -> (bool)Source

alias_inexactly returns true if and only if (⟺) a and b have a non-zero length, the base pointer of a and b are NOT equal, and any part of a overlaps with b (ie: alias(a, b) with an exception that returns false for a == b, b = a[:len(a)-69] and similar conditions).

buffer_capacity :: proc(b: ^Buffer) -> (int)Source

buffer_destroy :: proc(b: ^Buffer)Source

buffer_grow :: proc(b: ^Buffer, n: int, loc = #caller_location)Source

buffer_init :: proc(b: ^Buffer, buf: []u8, loc = #caller_location)Source

buffer_init_allocator :: proc(b: ^Buffer, len: int, cap: int, allocator: mem.Allocator = context.allocator, loc = #caller_location)

buffer_init_string :: proc(b: ^Buffer, s: string, loc = #caller_location)Source

buffer_is_empty :: proc(b: ^Buffer) -> (bool)Source

buffer_length :: proc(b: ^Buffer) -> (int)Source

buffer_next :: proc(b: ^Buffer, n: int) -> ([]u8)Source

buffer_read :: proc(b: ^Buffer, p: []u8) -> (n: int, err: io.Error)Source

buffer_read_at :: proc(b: ^Buffer, p: []u8, offset: int) -> (n: int, err: io.Error)Source

buffer_read_byte :: proc(b: ^Buffer) -> (io.Error, u8)Source

buffer_read_bytes :: proc(b: ^Buffer, delim: u8) -> (line: []u8, err: io.Error)Source

buffer_read_from :: proc(b: ^Buffer, r: io.Reader) -> (n: i64, err: io.Error)Source

buffer_read_ptr :: proc(b: ^Buffer, ptr: rawptr, size: int) -> (n: int, err: io.Error)Source

buffer_read_rune :: proc(b: ^Buffer) -> (r: rune, size: int, err: io.Error)Source

buffer_read_slice :: proc(b: ^Buffer, slice: S) -> (n: int, err: io.Error)Source

buffer_read_string :: proc(b: ^Buffer, delim: u8) -> (line: string, err: io.Error)Source

buffer_reset :: proc(b: ^Buffer)Source

buffer_seek :: proc(b: ^Buffer, offset: i64, whence: io.Seek_From) -> (io.Error, i64)Source

buffer_to_bytes :: proc(b: ^Buffer) -> ([]u8)Source

buffer_to_stream :: proc(b: ^Buffer) -> (s: io.Stream)Source

buffer_to_string :: proc(b: ^Buffer) -> (string)Source

buffer_truncate :: proc(b: ^Buffer, n: int)Source

buffer_unread_byte :: proc(b: ^Buffer) -> (io.Error)Source

buffer_unread_rune :: proc(b: ^Buffer) -> (io.Error)Source

buffer_write :: proc(b: ^Buffer, p: []u8, loc = #caller_location) -> (n: int, err: io.Error)Source

buffer_write_at :: proc(b: ^Buffer, p: []u8, offset: int, loc = #caller_location) -> (n: int, err: io.Error)Source

buffer_write_byte :: proc(b: ^Buffer, c: u8, loc = #caller_location) -> (io.Error)Source

buffer_write_ptr :: proc(b: ^Buffer, ptr: rawptr, size: int, loc = #caller_location) -> (n: int, err: io.Error)Source

buffer_write_rune :: proc(b: ^Buffer, r: rune, loc = #caller_location) -> (n: int, err: io.Error)Source

buffer_write_slice :: proc(b: ^Buffer, slice: S, loc = #caller_location) -> (n: int, err: io.Error)Source

buffer_write_string :: proc(b: ^Buffer, s: string, loc = #caller_location) -> (n: int, err: io.Error)Source

buffer_write_to :: proc(b: ^Buffer, w: io.Writer) -> (n: i64, err: io.Error)Source

center_justify :: proc(str: []u8, length: int, pad: []u8, allocator: mem.Allocator = context.allocator, loc = #caller_location) -> ([]u8)

NOTE(bill): Because Americans exist

centre_justify :: proc(str: []u8, length: int, pad: []u8, allocator: mem.Allocator = context.allocator, loc = #caller_location) -> ([]u8)

centre_justify returns a byte slice with a pad byte slice at boths sides if the str's rune length is smaller than length

clone :: proc(s: []u8, allocator: mem.Allocator = context.allocator, loc = #caller_location) -> ([]u8)Source

clone_safe :: proc(s: []u8, allocator: mem.Allocator = context.allocator, loc = #caller_location) -> (data: []u8, err: runtime.Allocator_Error)

compare :: proc(lhs: []u8, rhs: []u8) -> (int)Source

Compares two []byte, returning a value representing which one comes first lexiographically. Returns: -1 for lhs, 1 for rhs, or 0 if they are equal.

concatenate :: proc(a: [][]u8, allocator: mem.Allocator = context.allocator, loc = #caller_location) -> ([]u8)Source

concatenate_safe :: proc(a: [][]u8, allocator: mem.Allocator = context.allocator, loc = #caller_location) -> (data: []u8, err: runtime.Allocator_Error)

contains :: proc(s: []u8, substr: []u8) -> (bool)Source

contains_any :: proc(s: []u8, chars: []u8) -> (bool)Source

contains_rune :: proc(s: []u8, r: rune) -> (int)Source

count :: proc(s: []u8, substr: []u8) -> (int)Source

equal :: proc(a: []u8, b: []u8) -> (bool)Source

equal_fold :: proc(u: []u8, v: []u8) -> (bool)Source

expand_tabs :: proc(s: []u8, tab_size: int, allocator: mem.Allocator = context.allocator, loc = #caller_location) -> ([]u8)

fields :: proc(s: []u8, allocator: mem.Allocator = context.allocator, loc = #caller_location) -> ([][]u8)Source

fields splits the byte slice s around each instance of one or more consecutive white space character, defined by unicode.is_space returning a slice of subslices of s or an empty slice if s only contains white space

fields_proc :: proc(s: []u8, f: proc() -> (bool), allocator: mem.Allocator = context.allocator, loc = #caller_location) -> ([][]u8)

fields_proc splits the byte slice s at each run of unicode code points ch satisfying f(ch) returns a slice of subslices of s If all code points in s satisfy f(ch) or string is empty, an empty slice is returned

fields_proc makes no guarantee about the order in which it calls f(ch) it assumes that f always returns the same value for a given ch

has_prefix :: proc(s: []u8, prefix: []u8) -> (bool)Source

has_suffix :: proc(s: []u8, suffix: []u8) -> (bool)Source

index :: proc(s: []u8, substr: []u8) -> (int)Source

index_any :: proc(s: []u8, chars: []u8) -> (int)Source

index_byte :: proc(s: []u8, c: u8) -> (index: int)Source

Scan a slice of bytes for a specific byte.

This procedure safely handles slices of any length, including empty slices.

Inputs:

data: A slice of bytes.
c: The byte to search for.

Returns:

index: The index of the byte c, or -1 if it was not found.

index_proc :: proc(s: []u8, p: proc() -> (bool), truth: untyped boolean = true) -> (int)Source

index_proc_with_state :: proc(s: []u8, p: proc() -> (bool), state: rawptr, truth: untyped boolean = true) -> (int)Source

index_rune :: proc(s: []u8, r: rune) -> (int)Source

is_ascii_space :: proc(r: rune) -> (bool)Source

is_in_cutset :: proc(state: rawptr, r: rune) -> (bool)Source

is_null :: proc(r: rune) -> (bool)Source

is_space :: proc(r: rune) -> (bool)Source

join :: proc(a: [][]u8, sep: []u8, allocator: mem.Allocator = context.allocator, loc = #caller_location) -> ([]u8)Source

join_safe :: proc(a: [][]u8, sep: []u8, allocator: mem.Allocator = context.allocator, loc = #caller_location) -> (data: []u8, err: runtime.Allocator_Error)

last_index :: proc(s: []u8, substr: []u8) -> (int)Source

last_index_any :: proc(s: []u8, chars: []u8) -> (int)Source

last_index_byte :: proc(s: []u8, c: u8) -> (int)Source

Scan a slice of bytes for a specific byte, starting from the end and working backwards to the start.

This procedure safely handles slices of any length, including empty slices.

Inputs:

data: A slice of bytes.
c: The byte to search for.

Returns:

index: The index of the byte c, or -1 if it was not found.

last_index_proc :: proc(s: []u8, p: proc() -> (bool), truth: untyped boolean = true) -> (int)Source

last_index_proc_with_state :: proc(s: []u8, p: proc() -> (bool), state: rawptr, truth: untyped boolean = true) -> (int)Source

left_justify :: proc(str: []u8, length: int, pad: []u8, allocator: mem.Allocator = context.allocator, loc = #caller_location) -> ([]u8)

left_justify returns a byte slice with a pad byte slice at left side if the str's rune length is smaller than length

partition :: proc(str: []u8, sep: []u8) -> (head: []u8, match: []u8, tail: []u8)Source

ptr_from_bytes :: proc(str: []u8) -> (^u8)Source

ptr_from_slice :: proc(str: []u8) -> (^u8)Source

reader_init :: proc(r: ^Reader, s: []u8) -> (io.Stream)Source

reader_length :: proc(r: ^Reader) -> (int)Source

reader_read :: proc(r: ^Reader, p: []u8) -> (n: int, err: io.Error)Source

reader_read_at :: proc(r: ^Reader, p: []u8, off: i64) -> (n: int, err: io.Error)Source

reader_read_byte :: proc(r: ^Reader) -> (io.Error, u8)Source

reader_read_ptr :: proc(r: ^Reader, data: rawptr, len: int) -> (n: int, err: io.Error)Source

reader_read_ptr_at :: proc(r: ^Reader, data: rawptr, len: int, off: i64) -> (n: int, err: io.Error)Source

reader_read_rune :: proc(r: ^Reader) -> (ch: rune, size: int, err: io.Error)Source

reader_read_slice :: proc(r: ^Reader, slice: T) -> (n: int, err: io.Error)Source

reader_read_slice_at :: proc(r: ^Reader, slice: T, off: i64) -> (n: int, err: io.Error)Source

reader_seek :: proc(r: ^Reader, offset: i64, whence: io.Seek_From) -> (io.Error, i64)Source

reader_size :: proc(r: ^Reader) -> (i64)Source

reader_to_stream :: proc(r: ^Reader) -> (s: io.Stream)Source

reader_unread_byte :: proc(r: ^Reader) -> (io.Error)Source

reader_unread_rune :: proc(r: ^Reader) -> (io.Error)Source

reader_write_to :: proc(r: ^Reader, w: io.Writer) -> (n: i64, err: io.Error)Source

remove :: proc(s: []u8, key: []u8, n: int, allocator: mem.Allocator = context.allocator, loc = #caller_location) -> (output: []u8, was_allocation: bool)

remove_all :: proc(s: []u8, key: []u8, allocator: mem.Allocator = context.allocator, loc = #caller_location) -> (output: []u8, was_allocation: bool)

repeat :: proc(s: []u8, count: int, allocator: mem.Allocator = context.allocator, loc = #caller_location) -> ([]u8)Source

replace :: proc(
	s:         []u8,
	old:       []u8,
	new:       []u8,
	n:         int,
	allocator: mem.Allocator = context.allocator,
	loc:       _ = #caller_location,
) -> (output: []u8, was_allocation: bool)

if n < 0, no limit on the number of replacements

replace_all :: proc(s: []u8, old: []u8, new: []u8, allocator: mem.Allocator = context.allocator, loc = #caller_location) -> (output: []u8, was_allocation: bool)

reverse :: proc(s: []u8, allocator: mem.Allocator = context.allocator, loc = #caller_location) -> ([]u8)Source

right_justify :: proc(str: []u8, length: int, pad: []u8, allocator: mem.Allocator = context.allocator, loc = #caller_location) -> ([]u8)

right_justify returns a byte slice with a pad byte slice at right side if the str's rune length is smaller than length

rune_count :: proc(s: []u8) -> (int)Source

scrub :: proc(s: []u8, replacement: []u8, allocator: mem.Allocator = context.allocator, loc = #caller_location) -> ([]u8)

Scrubs invalid utf-8 characters and replaces them with the replacement string Adjacent invalid bytes are only replaced once

split :: proc(s: []u8, sep: []u8, allocator: mem.Allocator = context.allocator, loc = #caller_location) -> ([][]u8)Source

split_after :: proc(s: []u8, sep: []u8, allocator: mem.Allocator = context.allocator, loc = #caller_location) -> ([][]u8)

split_after_iterator :: proc(s: ^[]u8, sep: []u8) -> ([]u8, bool)Source

split_after_n :: proc(s: []u8, sep: []u8, n: int, allocator: mem.Allocator = context.allocator, loc = #caller_location) -> ([][]u8)

split_iterator :: proc(s: ^[]u8, sep: []u8) -> ([]u8, bool)Source

split_multi :: proc(s: []u8, substrs: [][]u8, skip_empty: untyped boolean = false, allocator: mem.Allocator = context.allocator, loc = #caller_location) -> ([][]u8)

split_multi_iterator :: proc(s: ^[]u8, substrs: [][]u8, skip_empty: untyped boolean = false) -> ([]u8, bool)Source

split_n :: proc(s: []u8, sep: []u8, n: int, allocator: mem.Allocator = context.allocator, loc = #caller_location) -> ([][]u8)

trim :: proc(s: []u8, cutset: []u8) -> ([]u8)Source

trim_left :: proc(s: []u8, cutset: []u8) -> ([]u8)Source

trim_left_null :: proc(s: []u8) -> ([]u8)Source

trim_left_proc :: proc(s: []u8, p: proc() -> (bool)) -> ([]u8)Source

trim_left_proc_with_state :: proc(s: []u8, p: proc() -> (bool), state: rawptr) -> ([]u8)Source

trim_left_space :: proc(s: []u8) -> ([]u8)Source

trim_null :: proc(s: []u8) -> ([]u8)Source

trim_prefix :: proc(s: []u8, prefix: []u8) -> ([]u8)Source

trim_right :: proc(s: []u8, cutset: []u8) -> ([]u8)Source

trim_right_null :: proc(s: []u8) -> ([]u8)Source

trim_right_proc :: proc(s: []u8, p: proc() -> (bool)) -> ([]u8)Source

trim_right_proc_with_state :: proc(s: []u8, p: proc() -> (bool), state: rawptr) -> ([]u8)Source

trim_right_space :: proc(s: []u8) -> ([]u8)Source

trim_space :: proc(s: []u8) -> ([]u8)Source

trim_suffix :: proc(s: []u8, suffix: []u8) -> ([]u8)Source

truncate_to_byte :: proc(str: []u8, b: u8) -> ([]u8)Source

truncate_to_rune :: proc(str: []u8, r: rune) -> ([]u8)Source