bugfixes and code cleanup

diff --git a/core/container/iter.onyx b/core/container/iter.onyx
index b285c79d43b85d8310d0a931722744fffc8ea2ec..5687d486d52cd7373d524807cab61652027b108b 100644 (file)
--- a/core/container/iter.onyx
+++ b/core/container/iter.onyx
@@ -12,9 +12,7 @@ filter :: (it: Iterator($T), predicate: (T) -> bool) -> Iterator(T) {
     filter_iterator.iterator = it;
     filter_iterator.predicate = predicate;
 
-    next :: ($T: type_expr, data: rawptr) -> (T, bool) {
-        fi := cast(^FilterIterator(T)) data;
-
+    next :: ($T: type_expr, fi: ^FilterIterator(T)) -> (T, bool) {
         value, cont := fi.iterator.next(fi.iterator.data);
         if cont {
             while !fi.predicate(value) {
@@ -28,10 +26,9 @@ filter :: (it: Iterator($T), predicate: (T) -> bool) -> Iterator(T) {
         }
     }
 
-    close :: ($T: type_expr, data: rawptr) {
-        fi := cast(^FilterIterator(T)) data;
+    close :: ($T: type_expr, fi: ^FilterIterator(T)) {
         fi.iterator.close(fi.iterator.data);
-        cfree(data);
+        cfree(fi);
     }
 
     return .{
@@ -51,19 +48,16 @@ map :: (it: Iterator($T), transform: (T) -> $R) -> Iterator(R) {
     map_iterator.iterator = it;
     map_iterator.transform = transform;
 
-    next :: ($T: type_expr, $R: type_expr, data: rawptr) -> (R, bool) {
-        mi := cast(^MapIterator(T, R)) data;
-
+    next :: ($T: type_expr, $R: type_expr, mi: ^MapIterator(T, R)) -> (R, bool) {
         value, cont := mi.iterator.next(mi.iterator.data);
         if !cont do return value, false;
 
         return mi.transform(value), true;
     }
 
-    close :: ($T: type_expr, $R: type_expr, data: rawptr) {
-        mi := cast(^MapIterator(T, R)) data;
+    close :: ($T: type_expr, $R: type_expr, mi: ^MapIterator(T, R)) {
         mi.iterator.close(mi.iterator.data);
-        cfree(data);
+        cfree(mi);
     }
 
     return .{
@@ -83,18 +77,16 @@ take :: (it: Iterator($T), count: u32) -> Iterator(T) {
     take_iterator.iterator = it;
     take_iterator.remaining = count;
 
-    next :: ($T: type_expr, data: rawptr) -> (T, bool) {
-        ti := cast(^TakeIterator(T)) data;
+    next :: ($T: type_expr, ti: ^TakeIterator(T)) -> (T, bool) {
         if ti.remaining == 0 do return __zero_value(T), false;
 
         ti.remaining -= 1;
         return ti.iterator.next(ti.iterator.data);
     }
 
-    close :: ($T: type_expr, data: rawptr) {
-        ti := cast(^TakeIterator(T)) data;
+    close :: ($T: type_expr, ti: ^TakeIterator(T)) {
         ti.iterator.close(ti.iterator.data);
-        cfree(data);
+        cfree(ti);
     }
 
     return .{
@@ -114,19 +106,16 @@ take_while :: (it: Iterator($T), predicate: (T) -> bool) -> Iterator(T) {
     take_iterator.iterator = it;
     take_iterator.predicate = predicate;
 
-    next :: ($T: type_expr, data: rawptr) -> (T, bool) {
-        ti := cast(^TakeIterator(T)) data;
-
+    next :: ($T: type_expr, ti: ^TakeIterator(T)) -> (T, bool) {
         value, cont := ti.iterator.next(ti.iterator.data);
         if !cont do return value, false;
 
         return value, ti.predicate(value);
     }
 
-    close :: ($T: type_expr, data: rawptr) {
-        ti := cast(^TakeIterator(T)) data;
+    close :: ($T: type_expr, ti: ^TakeIterator(T)) {
         ti.iterator.close(ti.iterator.data);
-        cfree(data);
+        cfree(ti);
     }
 
     return .{
@@ -147,9 +136,7 @@ skip :: (it: Iterator($T), count: u32) -> Iterator(T) {
     skip_iterator.iterator = it;
     skip_iterator.to_skip = count;
 
-    next :: ($T: type_expr, data: rawptr) -> (T, bool) {
-        si := cast(^SkipIterator(T)) data;
-
+    next :: ($T: type_expr, si: ^SkipIterator(T)) -> (T, bool) {
         while !si.skipped && si.to_skip > 0 {
             si.to_skip -= 1;
             value, cont := si.iterator.next(si.iterator.data);
@@ -163,10 +150,9 @@ skip :: (it: Iterator($T), count: u32) -> Iterator(T) {
         return si.iterator.next(si.iterator.data);
     }
 
-    close :: ($T: type_expr, data: rawptr) {
-        si := cast(^SkipIterator(T)) data;
+    close :: ($T: type_expr, si: ^SkipIterator(T)) {
         si.iterator.close(si.iterator.data);
-        cfree(data);
+        cfree(si);
     }
 
     return .{
@@ -191,20 +177,17 @@ zip :: (left_iterator: Iterator($T), right_iterator: Iterator($R)) -> Iterator(Z
     zipped_iterator.iterator1 = left_iterator;
     zipped_iterator.iterator2 = right_iterator;
 
-    next :: ($T: type_expr, $R: type_expr, data: rawptr) -> (Zipped(T, R), bool) {
-        zi := cast(^ZippedIterator(T, R)) data;
-
+    next :: ($T: type_expr, $R: type_expr, zi: ^ZippedIterator(T, R)) -> (Zipped(T, R), bool) {
         v1, cont1 := zi.iterator1.next(zi.iterator1.data);
         v2, cont2 := zi.iterator2.next(zi.iterator2.data);
 
         return .{ v1, v2 }, cont1 && cont2;
     }
 
-    close :: ($T: type_expr, $R: type_expr, data: rawptr) {
-        zi := cast(^ZippedIterator(T, R)) data;
+    close :: ($T: type_expr, $R: type_expr, zi: ^ZippedIterator(T, R)) {
         zi.iterator1.close(zi.iterator1.data);
         zi.iterator2.close(zi.iterator2.data);
-        cfree(data);
+        cfree(zi);
     }
 
     return .{
@@ -216,8 +199,7 @@ zip :: (left_iterator: Iterator($T), right_iterator: Iterator($R)) -> Iterator(Z
 
 const :: (value: $T) -> Iterator(T) {
     next :: ($T: type_expr, data: rawptr) -> (T, bool) {
-        value := *(cast(^T) data);
-        return value, true;
+        return *(cast(^T) data), true;
     }
 
     allocated := cast(^T) calloc(sizeof T);

diff --git a/core/string.onyx b/core/string.onyx
index 422ac6ec2c3299863b2253387cae91765f439b67..66266453579dd63b001b5550007735dbab746d63 100644 (file)
--- a/core/string.onyx
+++ b/core/string.onyx
@@ -162,9 +162,9 @@ starts_with :: (s: str, prefix: str) -> bool {
 
 ends_with :: (s: str, suffix: str) -> bool {
     if s.count < suffix.count do return false;
-    while i := s.count - 1; i >= s.count - suffix.count {
-        if s[i] != suffix[i] do return false;
-        i -= 1;
+    while i := 0; i < suffix.count {
+        if s[s.count - 1 - i] != suffix[suffix.count - 1 - i] do return false;
+        i += 1;
     }
     return true;
 }

diff --git a/modules/js_events/js_events.js b/modules/js_events/js_events.js
index 4ef84a11c0e180db98ed536747bd9cb807f6f8d4..fe0d0fb779691acfa4ec475f6371aa575254cdf1 100644 (file)
--- a/modules/js_events/js_events.js
+++ b/modules/js_events/js_events.js
@@ -111,15 +111,18 @@ window.ONYX_MODULES.push({
 
             // ROBUSTNESS: Currently, this only gives the first file, which for a lot of purposes, will be enough.
             // But if multiple files are dropped, the application will only know about the first one.
-            ev.dataTransfer.items[0].getAsFile().arrayBuffer()
-                .then(response => {
-                    // 0 is assumed to be reserved in request_file.onyx.
-                    requested_file_data[0] = response;
-                    push_event_to_buffer(esp, event_size, 0x08, [0x01, 0, response.byteLength]);
-                })
-                .catch(error => {
-                    push_event_to_buffer(esp, event_size, 0x08, [0x02, 0, 0]);
-                });
+            var response = ev.dataTransfer.items[0].getAsFile();
+            response.arrayBuffer().then(data => {
+                // 0 is assumed to be reserved in request_file.onyx.
+                requested_file_data[0] = {
+                    name: response.name,
+                    data: data,
+                };
+                push_event_to_buffer(esp, event_size, 0x08, [0x01, 0, data.byteLength, response.name.length ]);
+            })
+            .catch(error => {
+                push_event_to_buffer(esp, event_size, 0x08, [0x02, 0, 0, 0]);
+            });
 
             return false;
         });
@@ -145,26 +148,34 @@ window.ONYX_MODULES.push({
         fetch(path)
             .then(response => response.arrayBuffer())
             .then(array_buffer => {
-                requested_file_data[fileid] = array_buffer;
+                requested_file_data[fileid] = {
+                    name: path,
+                    data: array_buffer,
+                };
 
-                push_event_to_buffer(esp, event_size, 0x09, [ 0x01, fileid, array_buffer.byteLength ]);
+                push_event_to_buffer(esp, event_size, 0x09, [ 0x01, fileid, array_buffer.byteLength, path.length ]);
             })
             .catch((error) => {
-                push_event_to_buffer(esp, event_size, 0x09, [ 0x02, fileid, 0 ]);
+                push_event_to_buffer(esp, event_size, 0x09, [ 0x02, fileid, 0, 0 ]);
             });
     },
 
-    get_requested_file_data(fileid, bufferptr, bufferlen) {
+    get_requested_file_data(fileid, bufferptr, bufferlen, nameptr, namelen) {
         var file_data = requested_file_data[fileid];
         if (file_data == null) return 0;
 
-        if (bufferlen < file_data.byteLength) return 0;
+        if (bufferlen < file_data.data.byteLength) return 0;
 
         let WASM_U8 = new Uint8Array(ONYX_MEMORY.buffer);
-        var u8_data = new Uint8Array(file_data);
+        var u8_data = new Uint8Array(file_data.data);
 
         WASM_U8.set(u8_data, bufferptr);
 
+        if (namelen >= file_data.name.length) {
+            var name_data = new TextEncoder().encode(file_data.name);
+            WASM_U8.set(name_data, nameptr);
+        }
+
         requested_file_data[fileid] = null;
         delete requested_file_data[fileid];
 

diff --git a/modules/js_events/js_events.onyx b/modules/js_events/js_events.onyx
index 6959e4253172579547034d251da4440d24081ccb..52bd996ca51678bef95cd66a934e992208f65174 100644 (file)
--- a/modules/js_events/js_events.onyx
+++ b/modules/js_events/js_events.onyx
@@ -82,8 +82,9 @@ FileEvent :: struct {
     Status :: enum (u32) { Success :: 0x01; Failed :: 0x02; };
     status : Status;
 
-    file_id : u32;
-    size    : u32;
+    file_id     : u32;
+    size        : u32;
+    name_length : u32;
 }
 
 Event :: struct #union {

diff --git a/modules/js_events/request_file.onyx b/modules/js_events/request_file.onyx
index e199cba1c3cbcac6cfdbfcc088bd50634f880660..bcddb23e4ebc3cefbd838fbed3de2c169ae38af1 100644 (file)
--- a/modules/js_events/request_file.onyx
+++ b/modules/js_events/request_file.onyx
@@ -13,8 +13,8 @@ request_file :: (filepath: str) -> u32 {
     return fileid;
 }
 
-get_requested_file_data :: (fileid: u32, buffer: [] u8) -> bool {
-    js_get_requested_file_data :: (fileid: u32, buffer: [] u8) -> u32 #foreign "js_events" "get_requested_file_data" ---;
+get_requested_file_data :: (fileid: u32, buffer: [] u8, name_buffer: [] u8 = .{ null, 0 } ) -> bool {
+    js_get_requested_file_data :: (fileid: u32, buffer: [] u8, name_buffer: [] u8) -> u32 #foreign "js_events" "get_requested_file_data" ---;
 
-    return js_get_requested_file_data(fileid, buffer) == 1;
-}
\ No newline at end of file
+    return js_get_requested_file_data(fileid, buffer, name_buffer) == 1;
+}