ed/Odin
1
0
Fork 0
mirror of https://github.com/Ed94/Odin.git synced 2026-08-04 22:58:46 +00:00
Code Issues Packages Projects Releases Wiki Activity

Allow for overloading of polymorphic procedures

Browse Source
This commit is contained in:
Ginger Bill
2017-07-04 22:42:25 +01:00
parent 689a0c0b49
commit 188bc28f6a
11 changed files with 203 additions and 122 deletions
Download Patch File Download Diff File Expand all files Collapse all files
core/_preload.odin
+39 -41
View File
@@ -255,50 +255,51 @@ resize :: proc(ptr: rawptr, old_size, new_size: int, alignment: int = DEFAULT_AL
return a.procedure(a.data, AllocatorMode.Resize, new_size, alignment, ptr, old_size, 0);
}
// append :: proc(s: ^[]$T, args: ..T) -> int {
// if s == nil {
// return 0;
// }
// slice := ^raw.Slice(s);
// arg_len := len(args);
// if arg_len <= 0 {
// return slice.len;
// }
// arg_len = min(slice.cap-slice.len, arg_len);
// if arg_len > 0 {
// data := ^T(slice.data);
// assert(data != nil);
// sz :: size_of(T);
// __mem_copy(data + slice.len, &args[0], sz*arg_len);
// slice.len += arg_len;
// }
// return slice.len;
// }
append :: proc(array: ^[]$T, args: ..T) -> int {
if array == nil {
return 0;
}
slice := ^raw.Slice(array);
arg_len := len(args);
if arg_len <= 0 {
return slice.len;
}
// append :: proc(a: ^[dynamic]$T, args: ..T) -> int {
// array := ^raw.DynamicArray(a);
arg_len = min(slice.cap-slice.len, arg_len);
if arg_len > 0 {
data := ^T(slice.data);
assert(data != nil);
sz :: size_of(T);
__mem_copy(data + slice.len, &args[0], sz*arg_len);
slice.len += arg_len;
}
return slice.len;
}
// arg_len := len(args);
// if arg_len <= 0 || items == nil {
// return array.len;
// }
append :: proc(array_: ^[dynamic]$T, args: ..T) -> int {
array := ^raw.DynamicArray(array_);
arg_len := len(args);
if arg_len <= 0 {
return array.len;
}
// ok := true;
// if array.cap <= array.len+arg_len {
// cap := 2 * array.cap + max(8, arg_len);
// ok = __dynamic_array_reserve(array, size_of(T), align_of(T), cap);
// }
// // TODO(bill): Better error handling for failed reservation
// if !ok do return array.len;
ok := true;
if array.cap <= array.len+arg_len {
cap := 2 * array.cap + max(8, arg_len);
ok = __dynamic_array_reserve(array, size_of(T), align_of(T), cap);
}
// TODO(bill): Better error handling for failed reservation
if !ok do return array.len;
// data := ^T(array.data);
// assert(data != nil);
// __mem_copy(data + array.len, items, size_of(T) * arg_len);
// array.len += arg_len;
// return array.len;
// }
data := ^T(array.data);
assert(data != nil);
__mem_copy(data + array.len, &args[0], size_of(T) * arg_len);
array.len += arg_len;
return array.len;
}
copy :: proc(dst, src: []$T) -> int #cc_contextless {
n := max(0, min(len(dst), len(src)));
@@ -309,12 +310,10 @@ copy :: proc(dst, src: []$T) -> int #cc_contextless {
new :: proc(T: type) -> ^T #inline do return ^T(alloc(size_of(T), align_of(T)));
/*
free :: proc(array: [dynamic]$T) do free_ptr(^raw.DynamicArray(&array).data);
free :: proc(slice: []$T) do free_ptr(^raw.Slice(&slice).data);
free :: proc(str: string) do free_ptr(^raw.String(&str).data);
free :: proc(ptr: rawptr) do free_ptr(ptr);
*/
@@ -814,7 +813,6 @@ __dynamic_map_add_entry :: proc(using h: __MapHeader, key: __MapKey) -> int {
return prev;
}
__dynamic_map_delete :: proc(using h: __MapHeader, key: __MapKey) {
fr := __dynamic_map_find(h, key);
if fr.entry_index >= 0 {
core/fmt.odin
+5 -5
View File
@@ -70,17 +70,17 @@ write_string :: proc(buf: ^StringBuffer, s: string) {
write_bytes :: proc(buf: ^StringBuffer, data: []u8) {
match b in buf {
case StringBuffer.Static:
append(b.buf, ..data);
append(&b.buf, ..data);
case StringBuffer.Dynamic:
append(b.buf, ..data);
append(&b.buf, ..data);
}
}
write_byte :: proc(buf: ^StringBuffer, data: u8) {
match b in buf {
case StringBuffer.Static:
append(b.buf, data);
append(&b.buf, data);
case StringBuffer.Dynamic:
append(b.buf, data);
append(&b.buf, data);
}
}
write_rune :: proc(buf: ^StringBuffer, r: rune) {
@@ -484,7 +484,7 @@ fmt_bool :: proc(using fi: ^FmtInfo, b: bool, verb: rune) {
fmt_write_padding :: proc(fi: ^FmtInfo, width: int) {
if width <= 0 do return;
pad_byte: u8 = fi.space ? ' ' : '0';
pad_byte := u8(fi.space ? ' ' : '0');
data := string_buffer_data(fi.buf^);
count := min(width, cap(data)-len(data));
core/os_windows.odin
+8 -8
View File
@@ -103,8 +103,8 @@ open :: proc(path: string, mode: int = O_RDONLY, perm: u32 = 0) -> (Handle, Errn
handle := Handle(win32.create_file_a(&buf[0], access, share_mode, sa, create_mode, win32.FILE_ATTRIBUTE_NORMAL, nil));
if handle != INVALID_HANDLE do return handle, ERROR_NONE;
err := win32.get_last_error();
return INVALID_HANDLE, Errno(err);
err := Errno(win32.get_last_error());
return INVALID_HANDLE, err;
}
close :: proc(fd: Handle) {
@@ -126,8 +126,8 @@ write :: proc(fd: Handle, data: []u8) -> (int, Errno) {
e := win32.write_file(win32.Handle(fd), &data[total_write], to_write, &single_write_length, nil);
if single_write_length <= 0 || e == win32.FALSE {
err := win32.get_last_error();
return int(total_write), Errno(e);
err := Errno(win32.get_last_error());
return int(total_write), err;
}
total_write += i64(single_write_length);
}
@@ -148,8 +148,8 @@ read :: proc(fd: Handle, data: []u8) -> (int, Errno) {
e := win32.read_file(win32.Handle(fd), &data[total_read], to_read, &single_read_length, nil);
if single_read_length <= 0 || e == win32.FALSE {
err := win32.get_last_error();
return int(total_read), Errno(e);
err := Errno(win32.get_last_error());
return int(total_read), err;
}
total_read += i64(single_read_length);
}
@@ -170,8 +170,8 @@ seek :: proc(fd: Handle, offset: i64, whence: int) -> (i64, Errno) {
dw_ptr := win32.set_file_pointer(win32.Handle(fd), lo, &hi, w);
if dw_ptr == win32.INVALID_SET_FILE_POINTER {
err := win32.get_last_error();
return 0, Errno(err);
err := Errno(win32.get_last_error());
return 0, err;
}
return i64(hi)<<32 + i64(dw_ptr), ERROR_NONE;
}
core/strconv.odin
+10 -10
View File
@@ -191,7 +191,7 @@ parse_f64 :: proc(s: string) -> f64 {
append_bool :: proc(buf: []u8, b: bool) -> string {
s := b ? "true" : "false";
append(buf, ..[]u8(s));
append(&buf, ..[]u8(s));
return string(buf);
}
@@ -257,7 +257,7 @@ generic_ftoa :: proc(buf: []u8, val: f64, fmt: u8, prec, bit_size: int) -> []u8
} else {
s = "+Inf";
}
append(buf, ..[]u8(s));
append(&buf, ..[]u8(s));
return buf;
case 0: // denormalized
@@ -304,29 +304,29 @@ generic_ftoa :: proc(buf: []u8, val: f64, fmt: u8, prec, bit_size: int) -> []u8
format_digits :: proc(buf: []u8, shortest: bool, neg: bool, digs: DecimalSlice, prec: int, fmt: u8) -> []u8 {
match fmt {
case 'f', 'F':
append(buf, neg ? '-' : '+');
append(&buf, neg ? '-' : '+');
// integer, padded with zeros when needed
if digs.decimal_point > 0 {
m := min(digs.count, digs.decimal_point);
append(buf, ..digs.digits[0..<m]);
append(&buf, ..digs.digits[0..<m]);
for ; m < digs.decimal_point; m++ {
append(buf, '0');
append(&buf, '0');
}
} else {
append(buf, '0');
append(&buf, '0');
}
// fractional part
if prec > 0 {
append(buf, '.');
append(&buf, '.');
for i in 0..<prec {
c: u8 = '0';
if j := digs.decimal_point + i; 0 <= j && j < digs.count {
c = digs.digits[j];
}
append(buf, c);
append(&buf, c);
}
}
@@ -342,7 +342,7 @@ format_digits :: proc(buf: []u8, shortest: bool, neg: bool, digs: DecimalSlice,
}
c := [2]u8{'%', fmt};
append(buf, ..c[..]);
append(&buf, ..c[..]);
return buf;
}
@@ -492,7 +492,7 @@ append_bits :: proc(buf: []u8, u: u128, base: int, is_signed: bool, bit_size: in
i--; a[i] = ' ';
}
append(buf, ..a[i..]);
append(&buf, ..a[i..]);
return string(buf);
}