refactor bytes to copy on write if not unique

Author: TimWhiting

kklib/include/kklib/bytes.h

@@ -162,11 +162,6 @@ static inline int8_t kk_bytes_at(kk_bytes_t p, uint64_t i, kk_context_t* ctx){
   return (int8_t)buf[i];
 }
 
-static inline void kk_bytes_set(kk_bytes_t p, uint64_t i, int8_t b, kk_context_t* ctx){
-  uint8_t* buf = (uint8_t*)kk_bytes_buf_borrow(p, NULL, ctx);
-  buf[i] = (uint8_t)b;
-}
-
 /*--------------------------------------------------------------------------------------------------
   Length, compare
 --------------------------------------------------------------------------------------------------*/
@@ -200,6 +195,19 @@ static inline kk_bytes_t kk_bytes_copy(kk_bytes_t b, kk_context_t* ctx) {
   }
 }
 
+static inline kk_bytes_t kk_bytes_set(kk_bytes_t bytes, uint64_t i, int8_t b, kk_context_t* ctx){
+  if (kk_datatype_ptr_is_unique(bytes, ctx)) {
+    uint8_t* buf = (uint8_t*)kk_bytes_buf_borrow(bytes, NULL, ctx);
+    buf[i] = (uint8_t)b;
+    return bytes;
+  } else {
+    kk_bytes_t bytes_new = kk_bytes_copy(bytes, ctx);
+    uint8_t* buf = (uint8_t*)kk_bytes_buf_borrow(bytes_new, NULL, ctx);
+    buf[i] = (uint8_t)b;
+    return bytes_new;
+  }
+}
+
 static inline bool kk_bytes_ptr_eq_borrow(kk_bytes_t b1, kk_bytes_t b2) {
   return (kk_datatype_eq(b1, b2));
 }

lib/std/core.kk

@@ -25,6 +25,8 @@ pub import std/core/order
 pub import std/core/char
 pub import std/core/int
 pub import std/core/vector
+pub import std/core/bytes
+pub import std/core/bslice
 pub import std/core/string
 pub import std/core/sslice
 pub import std/core/list

lib/std/data/bslice.kk renamed to lib/std/core/bslice.kk

@@ -7,11 +7,17 @@
 ---------------------------------------------------------------------------*/
 
 // Byte slices
-module std/data/bslice
-import std/data/bytes
+module std/core/bslice
+import std/core/bytes
+import std/core/types
+import std/core/int
+import std/core/exn
+
+extern import 
+  c file "inline/bslice" 
 
 // A byte slice
-pub struct bslice 
+pub value struct bslice 
   bytes: bytes
   start: int
   len: int // The length of the slice
@@ -79,4 +85,18 @@ pub fun after(slice: bslice): bslice
 pub fun @index( ^b : bslice, i : int ) : exn int8
   val Bslice(bts, start, len, _) = b
   if i < 0 || i >= len then throw("index out of bounds", ExnRange)
-  bts.unsafe-index((start + i).ssize_t)
+  bts.unsafe-index((start + i).ssize_t)
+
+// Assigns the bytes starting at offset `i` to `new-value`, throws if there is not enough space or the index is invalid
+pub fun assign( b : bytes, i : int, new-value : bslice ) : exn bytes
+  val l = b.length.int
+  val size = new-value.len
+  if i < 0 || i > l then 
+    throw("index out of bounds", ExnRange)
+  elif size + i > l then
+    throw("size overflow", ExnRange)
+  else
+    assign(b, i.ssize_t, new-value)
+
+extern slice/assign(b : bytes, i : ssize_t, new-value : bslice ): bytes
+  c "kk_bslice_assign"

lib/std/data/bytes.kk renamed to lib/std/core/bytes.kk

@@ -7,7 +7,11 @@
 ---------------------------------------------------------------------------*/
 
 // Byte arrays
-module std/data/bytes
+module std/core/bytes
+import std/core/types
+import std/core/exn
+import std/core/bool
+import std/core/int
 
 // Create a new empty array of bytes
 pub extern empty(): bytes
@@ -27,7 +31,7 @@ pub extern string( bytes : bytes ) : string
 // Gets a view of the string as raw bytes
 pub extern string/bytes( s : string ) : bytes
   c  inline "#1.bytes"
-  js inline "new TextEncoder().encode(#1)"
+  js inline "(new TextEncoder()).encode(#1)"
 
 // Gets the length of the byte array
 pub extern length( ^b : bytes ) : ssize_t
@@ -51,6 +55,6 @@ pub extern unsafe-index( ^b : bytes, i : ssize_t ) : int8
   js inline "#1[#2]"
 
 // Assigns the byte at offset `i` to `new-value`
-pub extern byte/assign( ^b : bytes, i : ssize_t, new-value : int8 ) : ()
+pub extern byte/assign( b : bytes, i : ssize_t, new-value : int8 ) : bytes
   c  "kk_bytes_set"
   js inline "#1[#2] = #3"

lib/std/core/inline/bslice.c

@@ -0,0 +1,24 @@
+kk_bytes_t kk_bslice_assign( kk_bytes_t bytes, kk_ssize_t i, struct kk_std_core_bslice_Bslice bslice, kk_context_t* ctx ){
+  kk_ssize_t len;
+  const uint8_t* bslice_buf = kk_bytes_buf_borrow(bslice.bytes, &len, ctx);
+  kk_ssize_t slice_len = kk_integer_clamp_ssize_t_borrow(bslice.len, ctx);
+  kk_ssize_t slice_start = kk_integer_clamp_ssize_t_borrow(bslice.start, ctx);
+  if (kk_datatype_ptr_is_unique(bytes, ctx)) {
+    kk_info_message("kk_bslice_assign: unique\n");
+    uint8_t* buf = (uint8_t*)kk_bytes_buf_borrow(bytes, &len, ctx);
+    for (kk_ssize_t j = 0; j < slice_len; j++) {
+      buf[i + j] = bslice_buf[slice_start + j];
+    }
+    kk_std_core_bslice__bslice_drop(bslice,ctx);
+    return bytes;
+  } else {
+    kk_info_message("kk_bslice_assign: not unique\n");
+    kk_bytes_t bytes_new = kk_bytes_copy(bytes, ctx);
+    uint8_t* buf_new = (uint8_t*)kk_bytes_buf_borrow(bytes_new, NULL, ctx);
+    for (kk_ssize_t j = 0; j < slice_len; j++) {
+      buf_new[i + j] = bslice_buf[slice_start + j];
+    }
+    kk_std_core_bslice__bslice_drop(bslice,ctx);
+    return bytes_new;
+  }
+}

lib/std/core/inline/bslice.h

@@ -0,0 +1,11 @@
+
+/*---------------------------------------------------------------------------
+  Copyright 2020-2024, Microsoft Research, Daan Leijen. Tim Whiting.
+
+  This is free software; you can redistribute it and/or modify it under the
+  terms of the Apache License, Version 2.0. A copy of the License can be
+  found in the LICENSE file at the root of this distribution.
+---------------------------------------------------------------------------*/
+
+struct kk_std_core_bslice_Bslice;
+kk_bytes_t kk_bslice_assign( kk_bytes_t bytes, kk_ssize_t i, struct kk_std_core_bslice_Bslice bslice, kk_context_t* ctx );

src/Backend/C/FromCore.hs

@@ -2229,9 +2229,8 @@ genExprExternal tname formats [fieldDoc,argDoc] | getName tname == nameCFieldSet
 -- normal external
 genExprExternal tname formats argDocs0
   = do
-      ctarget <- getCTarget
       let name = getName tname
-          format = getFormat ctarget tname formats
+          format = getFormat tname formats
           argDocs = map (\argDoc -> if (all (\c -> isAlphaNum c || c == '_') (asString argDoc)) then argDoc else parens argDoc) argDocs0
       return $ case map (\fmt -> ppExternalF name fmt argDocs) $ lines format of
           [] -> ([],empty)

test/lib/bytes.kk

@@ -0,0 +1,7 @@
+
+
+fun main()  
+  val b1 = "Hello There".bytes
+  val new = "World".bytes.slice
+  val b2 = b1.assign(6, new)
+  println(b2.string) 

test/lib/bytes.kk.out

@@ -0,0 +1 @@
+Hello World