c

Author: alex-s168

PLATFORM/C/LIB/collections.lsts

@@ -66,18 +66,20 @@ let .find-first(list: t, elem: e): Maybe<U64> = (
    let found = false;
 
    let i = 0_u64;
+   let where = 0_u64;
    let len = list.length();
    while i < len {
       if list[i] == elem {
          found = true;
+         where = i;
          i = len; # break
       } else {
          i = i + 1;
       };
    };
 
    if found {
-      Some{i}
+      Some{where}
    } else {
       None{} :: Maybe<U64>
    }

PLATFORM/C/LIB/hashtable.lsts

@@ -2,6 +2,61 @@
 type HashtableEq<k,v> = HashtableEq { occupied: U64, capacity: U64, contents: Tuple<k,v>[] }
                       | HashtableEqEOF;
 
+let .clone(self: HashtableEq<k,v>): HashtableEq<k,v> = (
+   match self {
+      HashtableEq { occupied=occupied } => (
+         let contents = (self as Tag::HashtableEq).contents;
+         let new-sz = sizeof(Tuple<k,v>) * occupied;
+         let cpy = malloc(new-sz) as Tuple<k,v>[];
+
+         let i = 0;
+         while i < occupied {
+            cpy[i] = contents[i];
+            i = i + 1;
+         };
+
+         HashtableEq { occupied, occupied, cpy }
+      );
+
+      HashtableEqEOF {} => (HashtableEqEOF :: HashtableEq<k,v>);
+   }
+);
+
+type HashtableEqIter<k,v> = HashtableEqIter { table: HashtableEq<k,v>, idx: U64 };
+
+# for safety, we clone the table
+# All modifications done to the vector after creating the iterator will not be seen
+let .iter(self: HashtableEq<k,v>): HashtableEqIter<k,v> = (
+   let clone = self.clone();
+   clone.unsafe-iter()
+);
+
+# If you modify the table after creating the iterator, weird things will happen
+let .unsafe-iter(self: HashtableEq<k,v>): HashtableEqIter<k,v> = (
+   HashtableEqIter { self, 0_u64 }
+);
+
+let .next(p: Array<HashtableEqIter<k,v>,?>): Maybe<Tuple<k,v>> = (
+   let v = open(p);
+   match v.table {
+     HashtableEq { occupied=occupied } => (
+        if v.idx < occupied {
+           let contents = (v.table as Tag::HashtableEq).contents;
+           let val = contents[v.idx];
+           v.idx = v.idx + 1;
+           p[0] = v;
+           Some { val } :: Maybe<Tuple<k,v>>
+        } else {
+           None :: Maybe<Tuple<k,v>>
+        }
+     );
+
+     HashtableEqEOF {} => (
+        None :: Maybe<Tuple<k,v>>
+     );
+   };
+);
+
 let .lookup(table: HashtableEq<k,v>, key: k, default: v): v = (
    let capacity = (table as Tag::HashtableEq).capacity;
    if capacity > 0_u64 {

PLATFORM/C/LIB/io.lsts

@@ -1,6 +1,6 @@
 
 let .file-extension(path: CString): CString = (
-   let dot = path.find-last(46_u8);
+   let dot = path.find-last(c"."[0]);
    match dot {
       Some{content=content} => path.substring(content + 1);
       None{} => untern("");

SRC/plugins-frontends.lsts

@@ -3,6 +3,10 @@ let plugins-frontends-index = {} :: HashtableEq<CString,Arrow<CString,Nil>>;
 
 let plugin-null-frontend(fp: CString): Nil = (
    print("Unable to find a suitable frontend: \{fp}\n");
+   print("Registered frontends:\n");
+   for frontend in plugins-frontends-index.iter() {
+      print("- \{frontend.first}");
+   };
    exit(1);
 );