Merge pull request #1979 from andrew-johnson-4/lmcommon-start-merging-lib12-fdsuiiii

Lmcommon start merging lib12 fdsuiiii

Author: andrew4328

BOOTSTRAP/cli.c

@@ -31,3 +31,7 @@ let .retain(t: Type): Type = (
    };
    t
 );
+
+# TODO: remove
+let .release(tt: x[]): Nil = ();
+let .retain(tt: x[]): x[] = tt;

LM23COMMON/type-definition.lsts

@@ -363,6 +363,12 @@ let lsts-parse-type-conjugate(tokens: List<Token>): Tuple<Type,List<Token>> = (
       };
       if not(config-v3) and base==c"OwnedData" and args.length==1 {
          head(args);
+      } else if base==c"CompatOwnedData" and args.length==1 {
+         t1(c"OwnedData",head(args));
+      } else if base==c"CompatMustRetain" and args.length==0 {
+         t0(c"MustRetain");
+      } else if base==c"CompatMustRelease" and args.length==0 {
+         t0(c"MustRelease");
       } else TGround ( base, close(args) );
    };
    while lsts-parse-head(tokens) == c"[" or lsts-parse-head(tokens)==c"?" {
@@ -1093,7 +1099,6 @@ let lsts-parse-let(tokens: List<Token>): (AST, List<Token>) = (
    } else {
       mk-glb( with-location(mk-token(name),loc), return-term );
    };
-   if not(config-v3) and (name==c".retain" or name==c".release") then rvalue = mk-nil();
    (rvalue, tokens)
 );
 

PLUGINS/FRONTEND/LSTS/lsts-parse.lsts

@@ -33,3 +33,5 @@ import std/cmp.lsts;
 import std/print.lsts;
 import std/collections.lsts;
 import std/regex.lsts;
+import std/phi.lsts;
+import std/owned-data.lsts;

lib/std/default.lsts

@@ -197,3 +197,7 @@ let deep-hash(ts: List<t>): U64 = (
    for list t0 in ts { return = return + deep-hash(t0); };
    return;
 );
+
+# TODO: remove
+let .release(tt: List<x>): Nil = ();
+let .retain(tt: List<x>): List<x> = tt;

lib/std/list.lsts

@@ -30,3 +30,5 @@ import std/regex.lsts;
 import std/cmp.lsts;
 import std/print.lsts;
 import std/collections.lsts;
+import std/owned-data.lsts;
+import std/phi.lsts;

lib/std/minimal.lsts

@@ -0,0 +1,91 @@
+
+type OwnedData<t> = {
+   reference-count: USize,
+   occupied: USize,
+   capacity: USize,
+   data: t[]+FlexibleArrayMember
+};
+
+let mk-owned-data(tt: Type<t>, capacity: USize, occupied: USize): CompatOwnedData<t>[] = (
+   let od = safe-alloc(
+      # TODO: make sizeof return USize
+      (sizeof(CompatOwnedData<t>) as USize) + (sizeof(t) as USize) * capacity,
+      type(CompatOwnedData<t>)
+   );
+   od.reference-count = 1;
+   od.occupied = occupied;
+   od.capacity = capacity;
+   od
+);
+
+let mk-owned-data(tt: Type<t>, capacity: USize): CompatOwnedData<t>[] = (
+   mk-owned-data(tt, capacity, 0)
+);
+
+let $"[]"(od: CompatOwnedData<t>[], idx: USize): t = (
+   if (od as USize)==0
+   then fail(c"OwnedData [] Access Null Pointer");
+   if idx >= od.occupied then fail("OwnedData [\{idx}] Index Access Out of Bounds");
+   od.data[idx]
+);
+
+let $"set[]"(od: CompatOwnedData<t>[], idx: USize, val: t): Nil = (
+   if (od as USize)==0
+   then fail(c"OwnedData set[] Access Null Pointer");
+   if idx >= od.occupied then fail("OwnedData set[\{idx}] Index Access Out of Bounds");
+   if type(t) <: type(MustRelease) then od.data[idx].release;
+   od.data[idx] = val;
+);
+
+let .push(od: CompatOwnedData<t>[], d: t): Nil = (
+   if (od as USize)==0
+   then fail(c"OwnedData .push Into Null Pointer");
+   if od.occupied >= od.capacity
+   then fail(c"OwnedData .push Exceeds Maximum Length");
+   od.data[od.occupied] = d;
+   od.occupied = od.occupied + 1;
+);
+
+let .pop(od: CompatOwnedData<t>[]): t = (
+   if (od as USize)==0
+   then fail(c"OwnedData .pop From Null Pointer");
+   if od.occupied == 0
+   then fail(c"OwnedData .pop From Empty Data");
+   od.occupied = od.occupied - 1;
+   od.data[od.occupied]
+);
+
+let open(od: CompatOwnedData<t>[]): t = (
+   od[0];
+);
+
+let close-owned(d: t): CompatOwnedData<t>[] = (
+   let od = mk-owned-data(type(t), 1);
+   od.push(d);
+   od
+);
+
+let .release(od: CompatOwnedData<t>[]): Nil = (
+   if (od as USize)!=0 {
+      if od.reference-count==0 then fail(c"OwnedData.release called when reference count is already zero. This object has already been freed!");
+      od.reference-count = od.reference-count - 1;
+      if od.reference-count == 0 {
+         if type(t) <: type(MustRelease) {
+            let dlo = 0_sz;
+            let dhi = od.occupied;
+            while dlo < dhi {
+               od.data[dlo].release;
+               dlo = dlo + 1;
+            };
+         };
+         safe-free(od);
+      };
+   };
+);
+
+let .retain(od: CompatOwnedData<t>[]): Nil = (
+   if (od as USize)!=0 {
+      if od.reference-count==0 then fail(c"OwnedData.retain called when reference count is zero. This object has already been freed!");
+      od.reference-count = od.reference-count + 1;
+   }
+);

lib/std/owned-data.lsts

@@ -0,0 +1,21 @@
+
+type phi MustRelease = ToRelease{ promise:'a } | Released;
+
+let :Blob mark-as-released(x: x+(MustRelease::ToRelease<'a> ~> MustRelease::Released)+MustNotRetain): Nil = (
+   $":frame"($":frame"(x));
+   $":expression"($":expression"(x));
+);
+let :Blob mark-as-released(x: x+(MustRelease::Released ~> MustRelease::Released)+MustNotRetain): Nil = (
+   $":frame"($":frame"(x));
+   $":expression"($":expression"(x));
+);
+let :Blob mark-as-released(x: x): Nil = (
+   $":frame"($":frame"(x));
+   $":expression"($":expression"(x));
+);
+
+let :Blob destroy(x: x+MustNotRetain): Nil = (
+   $":frame"();
+   $":expression"(l"memset(&"; $":expression"(x); l",0,sizeof "; $":expression"(x); l");");
+);
+

lib/std/phi.lsts

@@ -262,3 +262,6 @@ let deep-hash(ts: Vector<t>): U64 = (
 # ignore, don't port to lib2
 # for compatibility in lmcommon
 let .buffer-into-string(c: Vector<U8>): Vector<U8> = c;
+
+let .release(v: Vector<x>): Nil = ();
+let .retain(v: Vector<x>): Vector<x> = v;

lib/std/vector.lsts

@@ -59,6 +59,12 @@ let open(od: OwnedData<t>[]): t = (
    od[0];
 );
 
+let close-owned(d: t): OwnedData<t>[] = (
+   let od = mk-owned-data(type(t), 1);
+   od.push(d);
+   od
+);
+
 let close(d: t): OwnedData<t>[] = (
    let od = mk-owned-data(type(t), 1);
    od.push(d);