Multiple stable memory regions (and a new primitive type Region).

src/mo_frontend/coverage.ml

@@ -94,6 +94,7 @@ let pick_val vs = function
   | T.Blob
   | T.Error
   | T.Principal
+  | T.Region
   | T.Float -> Any
 
 let rec expand_notval t n vs : desc list =

src/mo_idl/mo_to_idl.ml

@@ -71,6 +71,7 @@ let prim p =
   | Text -> I.PrimT I.Text
   | Blob -> I.BlobT
   | Principal -> I.PrincipalT
+  | Region -> assert false
   | Error -> assert false
 
 let rec typ t =

src/mo_types/arrange_type.ml

@@ -38,6 +38,7 @@ let prim = function
   | Blob -> Atom "Blob"
   | Error -> Atom "Error"
   | Principal -> Atom "Principal"
+  | Region -> Atom "Region"
 
 let con c = Atom (Type.string_of_con c)
 

src/mo_types/typ_hash.ml

@@ -91,6 +91,7 @@ let prim = function
   | Blob -> "B"
   | Error -> "E"
   | Principal -> "P"
+  | Region -> "R"
 
 let rec go = function
   | Prim p -> ((Nullary, prim p), [])

src/mo_types/type.ml

@@ -38,6 +38,7 @@ type prim =
   | Blob (* IR use: Packed representation, vec u8 IDL type *)
   | Error
   | Principal
+  | Region
 
 type t = typ
 and typ =
@@ -88,6 +89,7 @@ let tag_prim = function
   | Blob -> 15
   | Error -> 16
   | Principal -> 17
+  | Region -> 18
 
 let tag_func_sort = function
   | Local -> 0
@@ -313,6 +315,7 @@ let blob = Prim Blob
 let error = Prim Error
 let char = Prim Char
 let principal = Prim Principal
+let region = Prim Region
 
 let fields flds =
   List.sort compare_field
@@ -367,6 +370,7 @@ let prim = function
   | "Blob" -> Blob
   | "Error" -> Error
   | "Principal" -> Principal
+  | "Region" -> Region
   | s -> raise (Invalid_argument ("Type.prim: " ^ s))
 
 let seq = function [t] -> t | ts -> Tup ts
@@ -703,7 +707,7 @@ let rec span = function
   | Con _ as t -> span (promote t)
   | Prim Null -> Some 1
   | Prim Bool -> Some 2
-  | Prim (Nat | Int | Float | Text | Blob | Error | Principal) -> None
+  | Prim (Nat | Int | Float | Text | Blob | Error | Principal | Region) -> None
   | Prim (Nat8 | Int8) -> Some 0x100
   | Prim (Nat16 | Int16) -> Some 0x10000
   | Prim (Nat32 | Int32 | Nat64 | Int64 | Char) -> None  (* for all practical purposes *)
@@ -1417,6 +1421,7 @@ let string_of_prim = function
   | Blob -> "Blob"
   | Error -> "Error"
   | Principal -> "Principal"
+  | Region -> "Region"
 
 let string_of_obj_sort = function
   | Object -> ""

src/mo_types/type.mli

@@ -30,6 +30,7 @@ type prim =
   | Blob (* IR use: Packed representation, vec u8 IDL type *)
   | Error
   | Principal
+  | Region
 
 type t = typ
 
@@ -93,6 +94,7 @@ val blob : typ
 val error : typ
 val char : typ
 val principal : typ
+val region : typ
 
 val sum : (lab * typ) list -> typ
 val obj : obj_sort -> (lab * typ) list -> typ

src/prelude/prelude.mo

@@ -23,3 +23,4 @@ type Text = prim "Text";
 type Blob = prim "Blob";
 type Error = prim "Error";
 type Principal = prim "Principal";
+type Region = prim "Region";

src/prelude/prim.mo

@@ -36,6 +36,7 @@ module Types = {
   public type Blob = prim "Blob";
   public type Error = prim "Error";
   public type Principal = prim "Principal";
+  public type Memory = prim "Memory";
 };
 
 func abs(x : Int) : Nat { (prim "abs" : Int -> Nat) x };
@@ -370,6 +371,77 @@ func stableMemoryStoreBlob(offset : Nat64, val :  Blob) : () =
 func stableVarQuery() : shared query () -> async {size : Nat64} =
   (prim "stableVarQuery" : () -> (shared query () -> async {size : Nat64})) () ;
 
+// multiple-stable memory
+
+func multStableMemoryNew() : Memory =
+  (prim "multStableMemoryNew" : () -> Memory) ();
+
+func multStableMemorySize(Memory : m) : Nat64 =
+  (prim "multStableMemorySize" : Memory -> Nat64) m;
+
+func multStableMemoryGrow(Memory : m, pages : Nat64) : Nat64 =
+  (prim "multStableMemoryGrow" : (Memory, Nat64) -> Nat64) (m, pages);
+
+func multStableMemoryLoadNat32(Memory : m, offset : Nat64) : Nat32 =
+  (prim "multStableMemoryLoadNat32" : (Memory, Nat64) -> Nat32) (m, offset);
+
+func multStableMemoryStoreNat32(Memory : m, offset : Nat64, val : Nat32) : () =
+  (prim "multStableMemoryStoreNat32" : (Memory, Nat64, Nat32) -> ()) (m, offset, val);
+
+func multStableMemoryLoadNat8(Memory : m, offset : Nat64) : Nat8 =
+  (prim "multStableMemoryLoadNat8" : (Memory, Nat64) -> Nat8) (m, offset);
+
+func multStableMemoryStoreNat8(Memory : m, offset : Nat64, val : Nat8) : () =
+  (prim "multStableMemoryStoreNat8" : (Memory, Nat64, Nat8) -> ()) (m, offset, val);
+
+func multStableMemoryLoadNat16(Memory : m, offset : Nat64) : Nat16 =
+  (prim "multStableMemoryLoadNat16" : (Memory, Nat64) -> Nat16) (m, offset);
+
+func multStableMemoryStoreNat16(Memory : m, offset : Nat64, val : Nat16) : () =
+  (prim "multStableMemoryStoreNat16" : (Memory, Nat64, Nat16) -> ()) (m, offset, val);
+
+func multStableMemoryLoadNat64(Memory : m, offset : Nat64) : Nat64 =
+  (prim "multStableMemoryLoadNat64" : (Memory, Nat64) -> Nat64) (m, offset);
+
+func multStableMemoryStoreNat64(Memory : m, offset : Nat64, val : Nat64) : () =
+  (prim "multStableMemoryStoreNat64" : (Memory, Nat64, Nat64) -> ()) (m, offset, val);
+
+func multStableMemoryLoadInt32(Memory : m, offset : Nat64) : Int32 =
+  (prim "multStableMemoryLoadInt32" : (Memory, Nat64) -> Int32) (m, offset);
+
+func multStableMemoryStoreInt32(Memory : m, offset : Nat64, val : Int32) : () =
+  (prim "multStableMemoryStoreInt32" : (Memory, Nat64, Int32) -> ()) (m, offset, val);
+
+func multStableMemoryLoadInt8(Memory : m, offset : Nat64) : Int8 =
+  (prim "multStableMemoryLoadInt8" : (Memory, Nat64) -> Int8) (m, offset);
+
+func multStableMemoryStoreInt8(Memory : m, offset : Nat64, val : Int8) : () =
+  (prim "multStableMemoryStoreInt8" : (Memory, Nat64, Int8) -> ()) (m, offset, val);
+
+func multStableMemoryLoadInt16(Memory : m, offset : Nat64) : Int16 =
+  (prim "multStableMemoryLoadInt16" : (Memory, Nat64) -> Int16) (m, offset);
+
+func multStableMemoryStoreInt16(Memory : m, offset : Nat64, val : Int16) : () =
+  (prim "multStableMemoryStoreInt16" : (Memory, Nat64, Int16) -> ()) (m, offset, val);
+
+func multStableMemoryLoadInt64(Memory : m, offset : Nat64) : Int64 =
+  (prim "multStableMemoryLoadInt64" : (Memory, Nat64) -> Int64) (m, offset);
+
+func multStableMemoryStoreInt64(Memory : m, offset : Nat64, val : Int64) : () =
+  (prim "multStableMemoryStoreInt64" : (Memory, Nat64, Int64) -> ()) (m, offset, val);
+
+func multStableMemoryLoadFloat(Memory : m, offset : Nat64) : Float =
+  (prim "multStableMemoryLoadFloat" : (Memory, Nat64) -> Float) (m, offset);
+
+func multStableMemoryStoreFloat(Memory : m, offset : Nat64, val :  Float) : () =
+  (prim "multStableMemoryStoreFloat" : (Memory, Nat64, Float) -> ()) (m, offset, val);
+
+func multStableMemoryLoadBlob(Memory : m, offset : Nat64, size : Nat) : Blob =
+  (prim "multStableMemoryLoadBlob" : (Memory, Nat64, Nat) -> Blob) (m, offset, size);
+
+func multStableMemoryStoreBlob(Memory : m, offset : Nat64, val :  Blob) : () =
+  (prim "multStableMemoryStoreBlob" : (Memory, Nat64, Blob) -> ()) (m, offset, val);
+
 
 let call_raw = @call_raw;