mirror of
https://github.com/roc-lang/roc.git
synced 2025-09-28 14:24:45 +00:00
1016 lines
28 KiB
Zig
1016 lines
28 KiB
Zig
const std = @import("std");
|
|
const utils = @import("utils.zig");
|
|
const RocResult = utils.RocResult;
|
|
const mem = std.mem;
|
|
|
|
const TAG_WIDTH = 8;
|
|
|
|
const EqFn = fn (?[*]u8, ?[*]u8) callconv(.C) bool;
|
|
const CompareFn = fn (?[*]u8, ?[*]u8, ?[*]u8) callconv(.C) u8;
|
|
const Opaque = ?[*]u8;
|
|
|
|
const Inc = fn (?[*]u8) callconv(.C) void;
|
|
const IncN = fn (?[*]u8, usize) callconv(.C) void;
|
|
const Dec = fn (?[*]u8) callconv(.C) void;
|
|
|
|
pub const RocList = extern struct {
|
|
bytes: ?[*]u8,
|
|
length: usize,
|
|
|
|
pub fn len(self: RocList) usize {
|
|
return self.length;
|
|
}
|
|
|
|
pub fn isEmpty(self: RocList) bool {
|
|
return self.len() == 0;
|
|
}
|
|
|
|
pub fn empty() RocList {
|
|
return RocList{ .bytes = null, .length = 0 };
|
|
}
|
|
|
|
pub fn isUnique(self: RocList) bool {
|
|
// the empty list is unique (in the sense that copying it will not leak memory)
|
|
if (self.isEmpty()) {
|
|
return true;
|
|
}
|
|
|
|
// otherwise, check if the refcount is one
|
|
const ptr: [*]usize = @ptrCast([*]usize, @alignCast(8, self.bytes));
|
|
return (ptr - 1)[0] == utils.REFCOUNT_ONE;
|
|
}
|
|
|
|
pub fn allocate(
|
|
alignment: u32,
|
|
length: usize,
|
|
element_size: usize,
|
|
) RocList {
|
|
const data_bytes = length * element_size;
|
|
|
|
return RocList{
|
|
.bytes = utils.allocateWithRefcount(data_bytes, alignment),
|
|
.length = length,
|
|
};
|
|
}
|
|
|
|
pub fn makeUnique(self: RocList, alignment: u32, element_width: usize) RocList {
|
|
if (self.isEmpty()) {
|
|
return self;
|
|
}
|
|
|
|
if (self.isUnique()) {
|
|
return self;
|
|
}
|
|
|
|
// unfortunately, we have to clone
|
|
var new_list = RocList.allocate(alignment, self.length, element_width);
|
|
|
|
var old_bytes: [*]u8 = @ptrCast([*]u8, self.bytes);
|
|
var new_bytes: [*]u8 = @ptrCast([*]u8, new_list.bytes);
|
|
|
|
const number_of_bytes = self.len() * element_width;
|
|
@memcpy(new_bytes, old_bytes, number_of_bytes);
|
|
|
|
// NOTE we fuse an increment of all keys/values with a decrement of the input dict
|
|
const data_bytes = self.len() * element_width;
|
|
utils.decref(alignment, self.bytes, data_bytes);
|
|
|
|
return new_list;
|
|
}
|
|
|
|
pub fn reallocate(
|
|
self: RocList,
|
|
alignment: u32,
|
|
new_length: usize,
|
|
element_width: usize,
|
|
) RocList {
|
|
if (self.bytes) |source_ptr| {
|
|
if (self.isUnique()) {
|
|
const new_source = utils.unsafeReallocate(source_ptr, alignment, self.len(), new_length, element_width);
|
|
|
|
return RocList{ .bytes = new_source, .length = new_length };
|
|
}
|
|
}
|
|
|
|
return self.reallocateFresh(alignment, new_length, element_width);
|
|
}
|
|
|
|
/// reallocate by explicitly making a new allocation and copying elements over
|
|
fn reallocateFresh(
|
|
self: RocList,
|
|
alignment: u32,
|
|
new_length: usize,
|
|
element_width: usize,
|
|
) RocList {
|
|
const old_length = self.length;
|
|
const delta_length = new_length - old_length;
|
|
|
|
const data_bytes = new_length * element_width;
|
|
const first_slot = utils.allocateWithRefcount(data_bytes, alignment);
|
|
|
|
// transfer the memory
|
|
|
|
if (self.bytes) |source_ptr| {
|
|
const dest_ptr = first_slot;
|
|
|
|
@memcpy(dest_ptr, source_ptr, old_length * element_width);
|
|
@memset(dest_ptr + old_length * element_width, 0, delta_length * element_width);
|
|
}
|
|
|
|
const result = RocList{
|
|
.bytes = first_slot,
|
|
.length = new_length,
|
|
};
|
|
|
|
utils.decref(alignment, self.bytes, old_length * element_width);
|
|
|
|
return result;
|
|
}
|
|
};
|
|
|
|
const Caller0 = fn (?[*]u8, ?[*]u8) callconv(.C) void;
|
|
const Caller1 = fn (?[*]u8, ?[*]u8, ?[*]u8) callconv(.C) void;
|
|
const Caller2 = fn (?[*]u8, ?[*]u8, ?[*]u8, ?[*]u8) callconv(.C) void;
|
|
const Caller3 = fn (?[*]u8, ?[*]u8, ?[*]u8, ?[*]u8, ?[*]u8) callconv(.C) void;
|
|
|
|
pub fn listReverse(list: RocList, alignment: u32, element_width: usize) callconv(.C) RocList {
|
|
if (list.bytes) |source_ptr| {
|
|
const size = list.len();
|
|
|
|
var i: usize = 0;
|
|
const end: usize = size - 1;
|
|
|
|
if (list.isUnique()) {
|
|
|
|
// Working from the front and back so
|
|
// we only need to go ~(n / 2) iterations.
|
|
// If the length is an odd number the middle
|
|
// element stays in the same place anyways.
|
|
while (i < (end - i)) : (i += 1) {
|
|
swapElements(source_ptr, element_width, i, end - i);
|
|
}
|
|
|
|
return list;
|
|
} else {
|
|
const output = RocList.allocate(alignment, size, element_width);
|
|
|
|
const target_ptr = output.bytes orelse unreachable;
|
|
|
|
while (i < size) : (i += 1) {
|
|
const last_position = end - i;
|
|
|
|
@memcpy(target_ptr + (i * element_width), source_ptr + (last_position * element_width), element_width);
|
|
}
|
|
|
|
utils.decref(alignment, list.bytes, size * element_width);
|
|
|
|
return output;
|
|
}
|
|
} else {
|
|
return RocList.empty();
|
|
}
|
|
}
|
|
|
|
pub fn listMap(
|
|
list: RocList,
|
|
caller: Caller1,
|
|
data: Opaque,
|
|
inc_n_data: IncN,
|
|
data_is_owned: bool,
|
|
alignment: u32,
|
|
old_element_width: usize,
|
|
new_element_width: usize,
|
|
) callconv(.C) RocList {
|
|
if (list.bytes) |source_ptr| {
|
|
const size = list.len();
|
|
var i: usize = 0;
|
|
const output = RocList.allocate(alignment, size, new_element_width);
|
|
const target_ptr = output.bytes orelse unreachable;
|
|
|
|
if (data_is_owned) {
|
|
inc_n_data(data, size);
|
|
}
|
|
|
|
while (i < size) : (i += 1) {
|
|
caller(data, source_ptr + (i * old_element_width), target_ptr + (i * new_element_width));
|
|
}
|
|
|
|
return output;
|
|
} else {
|
|
return RocList.empty();
|
|
}
|
|
}
|
|
|
|
pub fn listMapWithIndex(
|
|
list: RocList,
|
|
caller: Caller2,
|
|
data: Opaque,
|
|
inc_n_data: IncN,
|
|
data_is_owned: bool,
|
|
alignment: u32,
|
|
old_element_width: usize,
|
|
new_element_width: usize,
|
|
) callconv(.C) RocList {
|
|
if (list.bytes) |source_ptr| {
|
|
const size = list.len();
|
|
var i: usize = 0;
|
|
const output = RocList.allocate(alignment, size, new_element_width);
|
|
const target_ptr = output.bytes orelse unreachable;
|
|
|
|
if (data_is_owned) {
|
|
inc_n_data(data, size);
|
|
}
|
|
|
|
while (i < size) : (i += 1) {
|
|
caller(data, @ptrCast(?[*]u8, &i), source_ptr + (i * old_element_width), target_ptr + (i * new_element_width));
|
|
}
|
|
|
|
return output;
|
|
} else {
|
|
return RocList.empty();
|
|
}
|
|
}
|
|
|
|
fn decrementTail(list: RocList, start_index: usize, element_width: usize, dec: Dec) void {
|
|
if (list.bytes) |source| {
|
|
var i = start_index;
|
|
while (i < list.len()) : (i += 1) {
|
|
const element = source + i * element_width;
|
|
dec(element);
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn listMap2(
|
|
list1: RocList,
|
|
list2: RocList,
|
|
caller: Caller2,
|
|
data: Opaque,
|
|
inc_n_data: IncN,
|
|
data_is_owned: bool,
|
|
alignment: u32,
|
|
a_width: usize,
|
|
b_width: usize,
|
|
c_width: usize,
|
|
dec_a: Dec,
|
|
dec_b: Dec,
|
|
) callconv(.C) RocList {
|
|
const output_length = std.math.min(list1.len(), list2.len());
|
|
|
|
// if the lists don't have equal length, we must consume the remaining elements
|
|
// In this case we consume by (recursively) decrementing the elements
|
|
decrementTail(list1, output_length, a_width, dec_a);
|
|
decrementTail(list2, output_length, b_width, dec_b);
|
|
|
|
if (data_is_owned) {
|
|
inc_n_data(data, output_length);
|
|
}
|
|
|
|
if (list1.bytes) |source_a| {
|
|
if (list2.bytes) |source_b| {
|
|
const output = RocList.allocate(alignment, output_length, c_width);
|
|
const target_ptr = output.bytes orelse unreachable;
|
|
|
|
var i: usize = 0;
|
|
while (i < output_length) : (i += 1) {
|
|
const element_a = source_a + i * a_width;
|
|
const element_b = source_b + i * b_width;
|
|
const target = target_ptr + i * c_width;
|
|
caller(data, element_a, element_b, target);
|
|
}
|
|
|
|
return output;
|
|
} else {
|
|
return RocList.empty();
|
|
}
|
|
} else {
|
|
return RocList.empty();
|
|
}
|
|
}
|
|
|
|
pub fn listMap3(
|
|
list1: RocList,
|
|
list2: RocList,
|
|
list3: RocList,
|
|
caller: Caller3,
|
|
data: Opaque,
|
|
inc_n_data: IncN,
|
|
data_is_owned: bool,
|
|
alignment: u32,
|
|
a_width: usize,
|
|
b_width: usize,
|
|
c_width: usize,
|
|
d_width: usize,
|
|
dec_a: Dec,
|
|
dec_b: Dec,
|
|
dec_c: Dec,
|
|
) callconv(.C) RocList {
|
|
const smaller_length = std.math.min(list1.len(), list2.len());
|
|
const output_length = std.math.min(smaller_length, list3.len());
|
|
|
|
decrementTail(list1, output_length, a_width, dec_a);
|
|
decrementTail(list2, output_length, b_width, dec_b);
|
|
decrementTail(list3, output_length, c_width, dec_c);
|
|
|
|
if (data_is_owned) {
|
|
inc_n_data(data, output_length);
|
|
}
|
|
|
|
if (list1.bytes) |source_a| {
|
|
if (list2.bytes) |source_b| {
|
|
if (list3.bytes) |source_c| {
|
|
const output = RocList.allocate(alignment, output_length, d_width);
|
|
const target_ptr = output.bytes orelse unreachable;
|
|
|
|
var i: usize = 0;
|
|
while (i < output_length) : (i += 1) {
|
|
const element_a = source_a + i * a_width;
|
|
const element_b = source_b + i * b_width;
|
|
const element_c = source_c + i * c_width;
|
|
const target = target_ptr + i * d_width;
|
|
|
|
caller(data, element_a, element_b, element_c, target);
|
|
}
|
|
|
|
return output;
|
|
} else {
|
|
return RocList.empty();
|
|
}
|
|
} else {
|
|
return RocList.empty();
|
|
}
|
|
} else {
|
|
return RocList.empty();
|
|
}
|
|
}
|
|
|
|
pub fn listKeepIf(
|
|
list: RocList,
|
|
caller: Caller1,
|
|
data: Opaque,
|
|
inc_n_data: IncN,
|
|
data_is_owned: bool,
|
|
alignment: u32,
|
|
element_width: usize,
|
|
inc: Inc,
|
|
dec: Dec,
|
|
) callconv(.C) RocList {
|
|
if (list.bytes) |source_ptr| {
|
|
const size = list.len();
|
|
var i: usize = 0;
|
|
var output = RocList.allocate(alignment, list.len(), list.len() * element_width);
|
|
const target_ptr = output.bytes orelse unreachable;
|
|
|
|
if (data_is_owned) {
|
|
inc_n_data(data, size);
|
|
}
|
|
|
|
var kept: usize = 0;
|
|
while (i < size) : (i += 1) {
|
|
var keep = false;
|
|
const element = source_ptr + (i * element_width);
|
|
inc(element);
|
|
caller(data, element, @ptrCast(?[*]u8, &keep));
|
|
|
|
if (keep) {
|
|
@memcpy(target_ptr + (kept * element_width), element, element_width);
|
|
|
|
kept += 1;
|
|
} else {
|
|
dec(element);
|
|
}
|
|
}
|
|
|
|
if (kept == 0) {
|
|
// if the output is empty, deallocate the space we made for the result
|
|
utils.decref(alignment, output.bytes, size * element_width);
|
|
return RocList.empty();
|
|
} else {
|
|
output.length = kept;
|
|
|
|
return output;
|
|
}
|
|
} else {
|
|
return RocList.empty();
|
|
}
|
|
}
|
|
|
|
pub fn listKeepOks(
|
|
list: RocList,
|
|
caller: Caller1,
|
|
data: Opaque,
|
|
inc_n_data: IncN,
|
|
data_is_owned: bool,
|
|
alignment: u32,
|
|
before_width: usize,
|
|
result_width: usize,
|
|
after_width: usize,
|
|
dec_result: Dec,
|
|
) callconv(.C) RocList {
|
|
return listKeepResult(
|
|
list,
|
|
RocResult.isOk,
|
|
caller,
|
|
data,
|
|
inc_n_data,
|
|
data_is_owned,
|
|
alignment,
|
|
before_width,
|
|
result_width,
|
|
after_width,
|
|
dec_result,
|
|
);
|
|
}
|
|
|
|
pub fn listKeepErrs(
|
|
list: RocList,
|
|
caller: Caller1,
|
|
data: Opaque,
|
|
inc_n_data: IncN,
|
|
data_is_owned: bool,
|
|
alignment: u32,
|
|
before_width: usize,
|
|
result_width: usize,
|
|
after_width: usize,
|
|
dec_result: Dec,
|
|
) callconv(.C) RocList {
|
|
return listKeepResult(
|
|
list,
|
|
RocResult.isErr,
|
|
caller,
|
|
data,
|
|
inc_n_data,
|
|
data_is_owned,
|
|
alignment,
|
|
before_width,
|
|
result_width,
|
|
after_width,
|
|
dec_result,
|
|
);
|
|
}
|
|
|
|
pub fn listKeepResult(
|
|
list: RocList,
|
|
is_good_constructor: fn (RocResult) bool,
|
|
caller: Caller1,
|
|
data: Opaque,
|
|
inc_n_data: IncN,
|
|
data_is_owned: bool,
|
|
alignment: u32,
|
|
before_width: usize,
|
|
result_width: usize,
|
|
after_width: usize,
|
|
dec_result: Dec,
|
|
) RocList {
|
|
if (list.bytes) |source_ptr| {
|
|
const size = list.len();
|
|
var i: usize = 0;
|
|
var output = RocList.allocate(alignment, list.len(), list.len() * after_width);
|
|
const target_ptr = output.bytes orelse unreachable;
|
|
|
|
var temporary = @ptrCast([*]u8, utils.alloc(result_width, alignment));
|
|
|
|
if (data_is_owned) {
|
|
inc_n_data(data, size);
|
|
}
|
|
|
|
var kept: usize = 0;
|
|
while (i < size) : (i += 1) {
|
|
const before_element = source_ptr + (i * before_width);
|
|
caller(data, before_element, temporary);
|
|
|
|
const result = utils.RocResult{ .bytes = temporary };
|
|
|
|
const after_element = temporary + @sizeOf(i64);
|
|
if (is_good_constructor(result)) {
|
|
@memcpy(target_ptr + (kept * after_width), after_element, after_width);
|
|
kept += 1;
|
|
} else {
|
|
dec_result(temporary);
|
|
}
|
|
}
|
|
|
|
utils.dealloc(temporary, alignment);
|
|
|
|
if (kept == 0) {
|
|
utils.decref(alignment, output.bytes, size * after_width);
|
|
return RocList.empty();
|
|
} else {
|
|
output.length = kept;
|
|
return output;
|
|
}
|
|
} else {
|
|
return RocList.empty();
|
|
}
|
|
}
|
|
|
|
pub fn listWalk(
|
|
list: RocList,
|
|
caller: Caller2,
|
|
data: Opaque,
|
|
inc_n_data: IncN,
|
|
data_is_owned: bool,
|
|
accum: Opaque,
|
|
alignment: u32,
|
|
element_width: usize,
|
|
accum_width: usize,
|
|
output: Opaque,
|
|
) callconv(.C) void {
|
|
if (accum_width == 0) {
|
|
return;
|
|
}
|
|
|
|
if (list.isEmpty()) {
|
|
@memcpy(output orelse unreachable, accum orelse unreachable, accum_width);
|
|
return;
|
|
}
|
|
|
|
if (data_is_owned) {
|
|
inc_n_data(data, list.len());
|
|
}
|
|
|
|
const bytes_ptr: [*]u8 = utils.alloc(accum_width, alignment);
|
|
var b1 = output orelse unreachable;
|
|
var b2 = bytes_ptr;
|
|
|
|
@memcpy(b2, accum orelse unreachable, accum_width);
|
|
|
|
if (list.bytes) |source_ptr| {
|
|
var i: usize = 0;
|
|
const size = list.len();
|
|
while (i < size) : (i += 1) {
|
|
const element = source_ptr + i * element_width;
|
|
caller(data, element, b2, b1);
|
|
|
|
const temp = b1;
|
|
b2 = b1;
|
|
b1 = temp;
|
|
}
|
|
}
|
|
|
|
@memcpy(output orelse unreachable, b2, accum_width);
|
|
utils.dealloc(bytes_ptr, alignment);
|
|
}
|
|
|
|
pub fn listWalkBackwards(
|
|
list: RocList,
|
|
caller: Caller2,
|
|
data: Opaque,
|
|
inc_n_data: IncN,
|
|
data_is_owned: bool,
|
|
accum: Opaque,
|
|
alignment: u32,
|
|
element_width: usize,
|
|
accum_width: usize,
|
|
output: Opaque,
|
|
) callconv(.C) void {
|
|
if (accum_width == 0) {
|
|
return;
|
|
}
|
|
|
|
if (list.isEmpty()) {
|
|
@memcpy(output orelse unreachable, accum orelse unreachable, accum_width);
|
|
return;
|
|
}
|
|
|
|
if (data_is_owned) {
|
|
inc_n_data(data, list.len());
|
|
}
|
|
|
|
const bytes_ptr: [*]u8 = utils.alloc(accum_width, alignment);
|
|
var b1 = output orelse unreachable;
|
|
var b2 = bytes_ptr;
|
|
|
|
@memcpy(b2, accum orelse unreachable, accum_width);
|
|
|
|
if (list.bytes) |source_ptr| {
|
|
const size = list.len();
|
|
var i: usize = size;
|
|
while (i > 0) {
|
|
i -= 1;
|
|
const element = source_ptr + i * element_width;
|
|
caller(data, element, b2, b1);
|
|
|
|
const temp = b1;
|
|
b2 = b1;
|
|
b1 = temp;
|
|
}
|
|
}
|
|
|
|
@memcpy(output orelse unreachable, b2, accum_width);
|
|
utils.dealloc(bytes_ptr, alignment);
|
|
}
|
|
|
|
pub fn listWalkUntil(
|
|
list: RocList,
|
|
caller: Caller2,
|
|
data: Opaque,
|
|
inc_n_data: IncN,
|
|
data_is_owned: bool,
|
|
accum: Opaque,
|
|
alignment: u32,
|
|
element_width: usize,
|
|
accum_width: usize,
|
|
dec: Dec,
|
|
output: Opaque,
|
|
) callconv(.C) void {
|
|
// [ Continue a, Stop a ]
|
|
const CONTINUE: usize = 0;
|
|
|
|
if (accum_width == 0) {
|
|
return;
|
|
}
|
|
|
|
if (list.isEmpty()) {
|
|
@memcpy(output orelse unreachable, accum orelse unreachable, accum_width);
|
|
return;
|
|
}
|
|
|
|
const bytes_ptr: [*]u8 = utils.alloc(TAG_WIDTH + accum_width, alignment);
|
|
|
|
@memcpy(bytes_ptr + TAG_WIDTH, accum orelse unreachable, accum_width);
|
|
|
|
if (list.bytes) |source_ptr| {
|
|
var i: usize = 0;
|
|
const size = list.len();
|
|
while (i < size) : (i += 1) {
|
|
const element = source_ptr + i * element_width;
|
|
|
|
if (data_is_owned) {
|
|
inc_n_data(data, 1);
|
|
}
|
|
|
|
caller(data, element, bytes_ptr + TAG_WIDTH, bytes_ptr);
|
|
|
|
const usizes: [*]usize = @ptrCast([*]usize, @alignCast(8, bytes_ptr));
|
|
if (usizes[0] != 0) {
|
|
// decrement refcount of the remaining items
|
|
i += 1;
|
|
while (i < size) : (i += 1) {
|
|
dec(source_ptr + i * element_width);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
@memcpy(output orelse unreachable, bytes_ptr + TAG_WIDTH, accum_width);
|
|
utils.dealloc(bytes_ptr, alignment);
|
|
}
|
|
|
|
// List.contains : List k, k -> Bool
|
|
pub fn listContains(list: RocList, key: Opaque, key_width: usize, is_eq: EqFn) callconv(.C) bool {
|
|
if (list.bytes) |source_ptr| {
|
|
const size = list.len();
|
|
var i: usize = 0;
|
|
while (i < size) : (i += 1) {
|
|
const element = source_ptr + i * key_width;
|
|
if (is_eq(element, key)) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
pub fn listRepeat(count: usize, alignment: u32, element: Opaque, element_width: usize, inc_n_element: IncN) callconv(.C) RocList {
|
|
if (count == 0) {
|
|
return RocList.empty();
|
|
}
|
|
|
|
var output = RocList.allocate(alignment, count, element_width);
|
|
|
|
if (output.bytes) |target_ptr| {
|
|
// increment the element's RC N times
|
|
inc_n_element(element, count);
|
|
|
|
var i: usize = 0;
|
|
const source = element orelse unreachable;
|
|
while (i < count) : (i += 1) {
|
|
@memcpy(target_ptr + i * element_width, source, element_width);
|
|
}
|
|
|
|
return output;
|
|
} else {
|
|
unreachable;
|
|
}
|
|
}
|
|
|
|
pub fn listSingle(alignment: u32, element: Opaque, element_width: usize) callconv(.C) RocList {
|
|
var output = RocList.allocate(alignment, 1, element_width);
|
|
|
|
if (output.bytes) |target| {
|
|
if (element) |source| {
|
|
@memcpy(target, source, element_width);
|
|
}
|
|
}
|
|
|
|
return output;
|
|
}
|
|
|
|
pub fn listAppend(list: RocList, alignment: u32, element: Opaque, element_width: usize) callconv(.C) RocList {
|
|
const old_length = list.len();
|
|
var output = list.reallocate(alignment, old_length + 1, element_width);
|
|
|
|
if (output.bytes) |target| {
|
|
if (element) |source| {
|
|
@memcpy(target + old_length * element_width, source, element_width);
|
|
}
|
|
}
|
|
|
|
return output;
|
|
}
|
|
|
|
pub fn listDrop(
|
|
list: RocList,
|
|
alignment: u32,
|
|
element_width: usize,
|
|
drop_count: usize,
|
|
dec: Dec,
|
|
) callconv(.C) RocList {
|
|
if (list.bytes) |source_ptr| {
|
|
const size = list.len();
|
|
const keep_count = size - drop_count;
|
|
|
|
var i: usize = 0;
|
|
const iterations = std.math.min(drop_count, size);
|
|
|
|
while (i < iterations) : (i += 1) {
|
|
const element = source_ptr + i * element_width;
|
|
dec(element);
|
|
}
|
|
|
|
if (drop_count >= size) {
|
|
return RocList.empty();
|
|
}
|
|
|
|
const output = RocList.allocate(alignment, keep_count, element_width);
|
|
const target_ptr = output.bytes orelse unreachable;
|
|
|
|
@memcpy(target_ptr, source_ptr + drop_count * element_width, keep_count * element_width);
|
|
|
|
utils.decref(alignment, list.bytes, size * element_width);
|
|
|
|
return output;
|
|
} else {
|
|
return RocList.empty();
|
|
}
|
|
}
|
|
|
|
pub fn listRange(width: utils.IntWidth, low: Opaque, high: Opaque) callconv(.C) RocList {
|
|
const IntWidth = utils.IntWidth;
|
|
|
|
switch (width) {
|
|
IntWidth.U8 => {
|
|
return helper1(u8, low, high);
|
|
},
|
|
IntWidth.U16 => {
|
|
return helper1(u16, low, high);
|
|
},
|
|
IntWidth.U32 => {
|
|
return helper1(u32, low, high);
|
|
},
|
|
IntWidth.U64 => {
|
|
return helper1(u64, low, high);
|
|
},
|
|
IntWidth.U128 => {
|
|
return helper1(u128, low, high);
|
|
},
|
|
IntWidth.I8 => {
|
|
return helper1(i8, low, high);
|
|
},
|
|
IntWidth.I16 => {
|
|
return helper1(i16, low, high);
|
|
},
|
|
IntWidth.I32 => {
|
|
return helper1(i32, low, high);
|
|
},
|
|
IntWidth.I64 => {
|
|
return helper1(i64, low, high);
|
|
},
|
|
IntWidth.I128 => {
|
|
return helper1(i128, low, high);
|
|
},
|
|
IntWidth.Usize => {
|
|
return helper1(usize, low, high);
|
|
},
|
|
}
|
|
}
|
|
|
|
fn helper1(comptime T: type, low: Opaque, high: Opaque) RocList {
|
|
const ptr1 = @ptrCast(*T, @alignCast(@alignOf(T), low));
|
|
const ptr2 = @ptrCast(*T, @alignCast(@alignOf(T), high));
|
|
|
|
return listRangeHelp(T, ptr1.*, ptr2.*);
|
|
}
|
|
|
|
fn listRangeHelp(comptime T: type, low: T, high: T) RocList {
|
|
const Order = std.math.Order;
|
|
|
|
switch (std.math.order(low, high)) {
|
|
Order.gt => {
|
|
return RocList.empty();
|
|
},
|
|
|
|
Order.eq => {
|
|
const list = RocList.allocate(@alignOf(usize), 1, @sizeOf(T));
|
|
const buffer = @ptrCast([*]T, @alignCast(@alignOf(T), list.bytes orelse unreachable));
|
|
|
|
buffer[0] = low;
|
|
|
|
return list;
|
|
},
|
|
|
|
Order.lt => {
|
|
const length: usize = @intCast(usize, high - low);
|
|
const list = RocList.allocate(@alignOf(usize), length, @sizeOf(T));
|
|
|
|
const buffer = @ptrCast([*]T, @alignCast(@alignOf(T), list.bytes orelse unreachable));
|
|
|
|
var i: usize = 0;
|
|
var current = low;
|
|
|
|
while (i < length) {
|
|
buffer[i] = current;
|
|
|
|
i += 1;
|
|
current += 1;
|
|
}
|
|
|
|
return list;
|
|
},
|
|
}
|
|
}
|
|
|
|
fn partition(source_ptr: [*]u8, transform: Opaque, wrapper: CompareFn, element_width: usize, low: isize, high: isize) isize {
|
|
const pivot = source_ptr + (@intCast(usize, high) * element_width);
|
|
var i = (low - 1); // Index of smaller element and indicates the right position of pivot found so far
|
|
var j = low;
|
|
|
|
while (j <= high - 1) : (j += 1) {
|
|
const current_elem = source_ptr + (@intCast(usize, j) * element_width);
|
|
|
|
const ordering = wrapper(transform, current_elem, pivot);
|
|
const order = @intToEnum(utils.Ordering, ordering);
|
|
|
|
switch (order) {
|
|
utils.Ordering.LT => {
|
|
// the current element is smaller than the pivot; swap it
|
|
i += 1;
|
|
swapElements(source_ptr, element_width, @intCast(usize, i), @intCast(usize, j));
|
|
},
|
|
utils.Ordering.EQ, utils.Ordering.GT => {},
|
|
}
|
|
}
|
|
swapElements(source_ptr, element_width, @intCast(usize, i + 1), @intCast(usize, high));
|
|
return (i + 1);
|
|
}
|
|
|
|
fn quicksort(source_ptr: [*]u8, transform: Opaque, wrapper: CompareFn, element_width: usize, low: isize, high: isize) void {
|
|
if (low < high) {
|
|
// partition index
|
|
const pi = partition(source_ptr, transform, wrapper, element_width, low, high);
|
|
|
|
_ = quicksort(source_ptr, transform, wrapper, element_width, low, pi - 1); // before pi
|
|
_ = quicksort(source_ptr, transform, wrapper, element_width, pi + 1, high); // after pi
|
|
}
|
|
}
|
|
|
|
pub fn listSortWith(
|
|
input: RocList,
|
|
caller: CompareFn,
|
|
data: Opaque,
|
|
inc_n_data: IncN,
|
|
data_is_owned: bool,
|
|
alignment: u32,
|
|
element_width: usize,
|
|
) callconv(.C) RocList {
|
|
var list = input.makeUnique(alignment, element_width);
|
|
|
|
if (data_is_owned) {
|
|
inc_n_data(data, list.len());
|
|
}
|
|
|
|
if (list.bytes) |source_ptr| {
|
|
const low = 0;
|
|
const high: isize = @intCast(isize, list.len()) - 1;
|
|
quicksort(source_ptr, data, caller, element_width, low, high);
|
|
}
|
|
|
|
return list;
|
|
}
|
|
|
|
// SWAP ELEMENTS
|
|
|
|
inline fn swapHelp(width: usize, temporary: [*]u8, ptr1: [*]u8, ptr2: [*]u8) void {
|
|
@memcpy(temporary, ptr1, width);
|
|
@memcpy(ptr1, ptr2, width);
|
|
@memcpy(ptr2, temporary, width);
|
|
}
|
|
|
|
fn swap(width_initial: usize, p1: [*]u8, p2: [*]u8) void {
|
|
const threshold: comptime usize = 64;
|
|
|
|
var width = width_initial;
|
|
|
|
var ptr1 = p1;
|
|
var ptr2 = p2;
|
|
|
|
var buffer_actual: [threshold]u8 = undefined;
|
|
var buffer: [*]u8 = buffer_actual[0..];
|
|
|
|
while (true) {
|
|
if (width < threshold) {
|
|
swapHelp(width, buffer, ptr1, ptr2);
|
|
return;
|
|
} else {
|
|
swapHelp(threshold, buffer, ptr1, ptr2);
|
|
|
|
ptr1 += threshold;
|
|
ptr2 += threshold;
|
|
|
|
width -= threshold;
|
|
}
|
|
}
|
|
}
|
|
|
|
fn swapElements(source_ptr: [*]u8, element_width: usize, index_1: usize, index_2: usize) void {
|
|
const threshold: comptime usize = 64;
|
|
|
|
var buffer_actual: [threshold]u8 = undefined;
|
|
var buffer: [*]u8 = buffer_actual[0..];
|
|
|
|
var element_at_i = source_ptr + (index_1 * element_width);
|
|
var element_at_j = source_ptr + (index_2 * element_width);
|
|
|
|
return swap(element_width, element_at_i, element_at_j);
|
|
}
|
|
|
|
pub fn listJoin(list_of_lists: RocList, alignment: u32, element_width: usize) callconv(.C) RocList {
|
|
var total_length: usize = 0;
|
|
|
|
const slice_of_lists = @ptrCast([*]RocList, @alignCast(@alignOf(RocList), list_of_lists.bytes));
|
|
|
|
var i: usize = 0;
|
|
while (i < list_of_lists.len()) : (i += 1) {
|
|
total_length += slice_of_lists[i].len();
|
|
}
|
|
|
|
const output = RocList.allocate(alignment, total_length, element_width);
|
|
|
|
if (output.bytes) |target| {
|
|
var elements_copied: usize = 0;
|
|
|
|
i = 0;
|
|
while (i < list_of_lists.len()) : (i += 1) {
|
|
const list = slice_of_lists[i];
|
|
if (list.bytes) |source| {
|
|
@memcpy(target + elements_copied * element_width, source, list.len() * element_width);
|
|
elements_copied += list.len();
|
|
}
|
|
}
|
|
}
|
|
|
|
return output;
|
|
}
|
|
|
|
pub fn listConcat(list_a: RocList, list_b: RocList, alignment: u32, element_width: usize) callconv(.C) RocList {
|
|
if (list_a.isEmpty()) {
|
|
return list_b;
|
|
} else if (list_b.isEmpty()) {
|
|
return list_a;
|
|
} else if (!list_a.isEmpty() and list_a.isUnique()) {
|
|
const total_length: usize = list_a.len() + list_b.len();
|
|
|
|
if (list_a.bytes) |source| {
|
|
const new_source = utils.unsafeReallocate(
|
|
source,
|
|
alignment,
|
|
list_a.len(),
|
|
total_length,
|
|
element_width,
|
|
);
|
|
|
|
if (list_b.bytes) |source_b| {
|
|
@memcpy(new_source + list_a.len() * element_width, source_b, list_b.len() * element_width);
|
|
}
|
|
|
|
return RocList{ .bytes = new_source, .length = total_length };
|
|
}
|
|
}
|
|
const total_length: usize = list_a.len() + list_b.len();
|
|
|
|
const output = RocList.allocate(alignment, total_length, element_width);
|
|
|
|
if (output.bytes) |target| {
|
|
if (list_a.bytes) |source| {
|
|
@memcpy(target, source, list_a.len() * element_width);
|
|
}
|
|
if (list_b.bytes) |source| {
|
|
@memcpy(target + list_a.len() * element_width, source, list_b.len() * element_width);
|
|
}
|
|
}
|
|
|
|
return output;
|
|
}
|