bugfix: '??' precedence; added: writer_consumer_error, alloc.on_temp

diff --git a/core/alloc/alloc.onyx b/core/alloc/alloc.onyx
index 86854abe8646e37e54ec5794721b2678a102bfa7..25834be6d4ef37553bc95b15c2684f43f27e94d2 100644 (file)
--- a/core/alloc/alloc.onyx
+++ b/core/alloc/alloc.onyx
@@ -32,6 +32,13 @@ on_heap :: macro (v: $V) -> &V {
     return out;
 }
 
+on_temp :: macro (v: $V) -> &V {
+    out := cast(&V) raw_alloc(context.temp_allocator, sizeof V);
+    core.memory.set(out, 0, sizeof V);
+    *out = v;
+    return out;
+}
+
 TEMPORARY_ALLOCATOR_SIZE :: 1 << 16; // 16Kb
 
 // The global heap allocator, set up upon program intialization.

diff --git a/core/container/optional.onyx b/core/container/optional.onyx
index 30d458a97ef067b1ee507c9aaca008feb0362c0f..e4d961a3cbda5aa61bd5e03ba4406f1ca3a0f189 100644 (file)
--- a/core/container/optional.onyx
+++ b/core/container/optional.onyx
@@ -107,18 +107,18 @@ package core
     return o1.value == o2.value;
 }
 
-#operator ?? macro (opt: ?$T, catch: Code) -> T {
+#operator ?? macro (opt: ?$T, default: T) -> T {
     value := opt;
     if value do return value.value;
 
-    #unquote catch;
+    return default;
 }
 
-#operator ?? macro (opt: ?$T, default: T) -> T {
+#operator ?? macro (opt: ?$T, catch: Code) -> T {
     value := opt;
     if value do return value.value;
 
-    return default;
+    #unquote catch;
 }
 
 #operator ? macro (opt: ?$T) -> T {

diff --git a/core/io/writer.onyx b/core/io/writer.onyx
index 99ef801e610f1ac361028d3b9371998c525bd9a0..47da1f57f8b87d27ab66943025c3cc400e4906e0 100644 (file)
--- a/core/io/writer.onyx
+++ b/core/io/writer.onyx
@@ -11,6 +11,8 @@ use core {conv, string, memory}
 Writer :: struct {
     stream : &Stream;
 
+    error  : Error;
+
     buffer: [] u8;
     buffer_filled: u32;
 }
@@ -37,10 +39,19 @@ writer_free :: (w: &Writer) {
 writer_flush :: (w: &Writer) {
     if w.buffer_filled == 0 do return;
 
-    stream_write(w.stream, w.buffer[0 .. w.buffer_filled]);
+    err, bytes_wrote := stream_write(w.stream, w.buffer[0 .. w.buffer_filled]);
+    if err != .None {
+        w.error = err;
+    }
+
     w.buffer_filled = 0;
 }
 
+writer_consume_error :: (w: &Writer) -> Error {
+    defer w.error = .None;
+    return w.error;
+}
+
 writer_remaining_capacity :: (w: &Writer) -> u32 {
     return w.buffer.count - w.buffer_filled;
 }
@@ -54,7 +65,10 @@ string_builder :: (allocator := context.allocator) -> (Writer, &BufferStream) {
 
 write_byte :: (use writer: &Writer, byte: u8) {
     if buffer.count == 0 {
-        stream_write_byte(stream, byte);
+        if err := stream_write_byte(stream, byte); err != .None {
+            writer.error = err;
+        }
+
     } else {
         if writer_remaining_capacity(writer) == 0 {
             writer_flush(writer);
@@ -67,7 +81,9 @@ write_byte :: (use writer: &Writer, byte: u8) {
 
 write_str :: (use writer: &Writer, s: str) {
     if buffer.count == 0 {
-        stream_write(stream, s);
+        if err := stream_write(stream, s); err != .None {
+            writer.error = err;
+        }
 
     } elseif writer_remaining_capacity(writer) > s.count {
         memory.copy(&buffer[buffer_filled], s.data, s.count);
@@ -75,7 +91,9 @@ write_str :: (use writer: &Writer, s: str) {
 
     } else {
         writer_flush(writer);
-        stream_write(stream, s);
+        if err := stream_write(stream, s); err != .None {
+            writer.error = err;
+        }
     }
 }