fix rust emitter

Author: aep

modules/ast/src/lib.zz

@@ -23,10 +23,10 @@ fn parse_v(err::Err+et mut *e, json::Parser+pt mut* p, void mut * user, char *k,
         switch v.t {
             json::ValueType::String => {
                 static_attest(safe(arg->pool));
-                static_attest(safe(v.buffer));
-                static_attest(nullterm(v.buffer));
-                char mut * dup = arg->pool->malloc(buffer::strlen(v.buffer));
-                memcpy(dup, v.buffer, buffer::strlen(v.buffer) + 1);
+                static_attest(safe(v.string));
+                static_attest(nullterm(v.string));
+                char mut * dup = arg->pool->malloc(buffer::strlen(v.string));
+                memcpy(dup, v.string, buffer::strlen(v.string) + 1);
                 arg->v.string = dup;
             }
             default => {
@@ -84,10 +84,10 @@ fn parse_t_other_value(err::Err+et mut *e, json::Parser+pt mut* p, void mut * us
   switch v.t {
     json::ValueType::String => {
       static_attest(safe(arg->pool));
-      static_attest(safe(v.buffer));
-      static_attest(nullterm(v.buffer));
-      char mut * dup = arg->pool->malloc(buffer::strlen(v.buffer));
-      memcpy(dup, v.buffer, buffer::strlen(v.buffer) + 1);
+      static_attest(safe(v.string));
+      static_attest(nullterm(v.string));
+      char mut * dup = arg->pool->malloc(buffer::strlen(v.string));
+      memcpy(dup, v.string, buffer::strlen(v.string) + 1);
       arg->v.string = dup;
     }
     default => {

modules/err/src/lib.zz

@@ -24,19 +24,19 @@ export struct Err+ {
 
 /// create a new error
 export fn make(Err+tail mut new*self)
-    where   tail > 0
     model   checked(*self)
 {
+    assert(tail > 0);
     memset(self, 0, sizeof(Err));
     buffer::clear(&(self->trace));
     static_attest(checked(*self));
 }
 
 /// ignore any previous errors and reset error state
 export fn ignore(Err+tail mut *self)
-    where   tail > 0
     model checked(*self)
 {
+    assert(tail > 0);
     memset(self, 0, sizeof(Err));
     buffer::clear(&self->trace);
     static_attest(checked(*self));

modules/hex/src/lib.zz

@@ -48,11 +48,11 @@ export fn print(u8 *data, usize l)
 }
 
 
-export fn dump_slice(slice::Slice *s)
+export fn dump_slice(slice::Slice s)
+    where slice::slice::integrity(&s)
 {
-    static_attest(s->size <= len(s->mem));
-    for (usize mut i = 0; i < s->size; i++) {
-        printf("%02x ", s->mem[i]);
+    for (usize mut i = 0; i < s.size; i++) {
+        printf("%02x ", s.mem[i]);
         if i % 16 == 15 {
             printf("\n");
         }

modules/json/src/lib.zz

@@ -19,7 +19,7 @@ pub enum ValueType {
 
 export struct Value {
     ValueType t;
-    char*   buffer;
+    char*   string;
     int     integer;
     usize   index;
 }
@@ -332,7 +332,7 @@ fn advance(Parser+tail mut *self, err::Err+et mut *e, char token)
                     Value val = Value{
                         index:  stack->index,
                         t:      ValueType::String,
-                        buffer: ((self->capture).mem + self->keylen),
+                        string: ((self->capture).mem + self->keylen),
                     };
                     de(e, self, stack->user, (self->capture).mem, val);
                     if err::check(e) {

modules/json/tests/b.zz

@@ -26,20 +26,20 @@ symbol InvalidValue;
 fn deserialize_charge(err::Err+et mut *e, json::Parser+pt mut* p, void mut *user, char *k, json::Value v)
     where err::checked(*e)
 {
-    printf("charge.>%s< == >%s< %u, %d [%zu]\n", k, v.buffer, v.t, v.integer, v.index);
+    printf("charge.>%s< == >%s< %u, %d [%zu]\n", k, v.string, v.t, v.integer, v.index);
 }
 
 fn deserialize_engine(err::Err+et mut *e, json::Parser+pt mut* p, void mut *user, char *k, json::Value v)
     where err::checked(*e)
     where nullterm(k)
-    where nullterm(v.buffer)
+    where nullterm(v.string)
 {
     let into = (Engine mut*)user;
-    printf("engine.>%s< == >%s< %d\n", k, v.buffer, v.integer);
+    printf("engine.>%s< == >%s< %d\n", k, v.string, v.integer);
     if buffer::cstr_eq("fuel", k) && v.t == json::ValueType::String{
-        if buffer::cstr_eq("dinosaurs", v.buffer) {
+        if buffer::cstr_eq("dinosaurs", v.string) {
             into->fuel = Fuel::Dinosaurs;
-        } else if buffer::cstr_eq("electric", v.buffer)  {
+        } else if buffer::cstr_eq("electric", v.string)  {
             into->fuel = Fuel::Electric;
         } else {
             err::fail(e, InvalidValue , "invalid fuel value %s", v);
@@ -57,7 +57,7 @@ fn deserialize_vehicle(err::Err+et mut *e, json::Parser+pt mut* p, void mut *use
     where nullterm(k)
 {
     let into = (Vehicle mut*)user;
-    printf("vehicle.>%s< == >%s< %d\n", k, v.buffer, v.integer);
+    printf("vehicle.>%s< == >%s< %d\n", k, v.string, v.integer);
 
     if buffer::cstr_eq("height", k) {
         into->height = v.integer;

modules/json/tests/print.zz

@@ -114,7 +114,7 @@ fn pretty(err::Err+et mut *e, json::Parser+pt mut* p, void mut * user, char *k,
             }
         }
         json::ValueType::String => {
-            printf("%s : %s\n", k, v.buffer);
+            printf("%s : %s\n", k, v.string);
         }
         json::ValueType::Integer => {
             printf("%s : %d\n", k, v.integer);

modules/slice/src/mut_slice.zz

@@ -1,5 +1,6 @@
 using <string.h> as c_string;
 using slice::{Slice};
+using slice as roslice;
 
 export struct MutSlice {
     u8 mut* mem;
@@ -9,6 +10,7 @@ export struct MutSlice {
 
 pub theory integrity(MutSlice mut*self) -> bool (
         safe(self->at)
+    &&  safe(self->mem)
     &&  len(self->mem) >= self->size
     &&  *self->at <= self->size
     &&  *self->at <= len(self->mem)
@@ -29,6 +31,19 @@ export fn make(MutSlice new mut*self, u8 mut*mem, usize size, usize mut *at)
     static_attest(self->size == len(self->mem));
 }
 
+export fn as_slice(MutSlice * self) -> Slice
+    where   integrity(self)
+    model   roslice::integrity(&return)
+{
+    let r = Slice {
+        mem:    self->mem,
+        size:   *self->at,
+    };
+    static_attest(roslice::integrity(&r));
+    return r;
+}
+
+
 export fn append_slice(MutSlice mut * self, Slice *other) -> bool
     where   integrity(self)
     model   integrity(self)

src/emitter_common.rs

@@ -0,0 +1,10 @@
+use std::path::PathBuf;
+use std::path::Path;
+
+pub fn path_rel<A: AsRef<Path>, B: AsRef<Path>> (base: A, src: B) -> PathBuf {
+    let mut src : PathBuf = src.as_ref().into();
+    if !src.is_absolute() {
+        src = src.canonicalize().expect(&format!("canonicalize {:?}", src));
+    }
+    return pathdiff::diff_paths(&src, base.as_ref()).expect(&format!("pathdiff {:?} ", src));
+}

src/emitter_rs.rs

@@ -3,9 +3,11 @@
 use super::ast;
 use super::flatten;
 use super::make;
+use super::emitter_common;
 use super::name::Name;
 use super::parser::{self, emit_error};
 use super::project::Project;
+use super::project;
 use std::collections::HashSet;
 use std::fs;
 use std::io::Write;
@@ -21,12 +23,14 @@ pub struct Emitter {
 }
 
 pub fn outname(_project: &Project, stage: &make::Stage, module: &flatten::Module) -> String {
-    format!("target/rust/{}.rs", module.name.0[1..].join("_"))
+    let td = project::target_dir();
+    td.join("rust").join(format!("{}.rs", module.name.0[1..].join("_"))).to_string_lossy().to_string()
 }
 
 pub fn make_module(make: &super::make::Make) {
-    let pdir_ = format!("target/rust/{}/", make.artifact.name);
-    let pdir = std::path::Path::new(&pdir_);
+    let td      = project::target_dir();
+    let pdir_   = td.join("rust").join(&make.artifact.name);
+    let pdir    = std::path::Path::new(&pdir_);
     std::fs::create_dir_all(&pdir).unwrap();
 
 
@@ -39,7 +43,14 @@ pub fn make_module(make: &super::make::Make) {
     write!(f, "    cc::Build::new()\n").unwrap();
 
     for step in &make.steps {
-        write!(f,"      .file(\"../../../{}\")\n", step.source.to_string_lossy()).unwrap();
+        write!(f,"      .file(\"{}\")\n",
+            emitter_common::path_rel(&pdir, &step.source).to_string_lossy().to_string()
+        ).unwrap();
+    }
+    for flag in &make.cincludes {
+        write!(f,"      .include(\"{}\")\n",
+            emitter_common::path_rel(&pdir, flag).to_string_lossy().to_string()
+        ).unwrap();
     }
     write!(f, "    .compile(\"{}\");\n", make.artifact.name).unwrap();
     write!(f, "}}\n").unwrap();
@@ -365,6 +376,7 @@ impl Emitter {
             _ => unreachable!(),
         };
         let shortname = Name::from(&ast.name).0.last().unwrap().clone();
+        write!(self.f, "#[derive(Clone)]\n").unwrap();
         write!(self.f, "#[repr(C)]\n").unwrap();
         write!(self.f, "pub enum {} {{\n", shortname).unwrap();
         for (name, literal) in names {
@@ -580,7 +592,7 @@ impl {name} {{
             }
         }
 
-        write!(self.f, "\n\n#[repr(C)]\npub struct {} {{\n", shortname).unwrap();
+        write!(self.f, "\n#[derive(Clone)]\n#[repr(C)]\npub struct {} {{\n", shortname).unwrap();
         for i in 0..fields.len() {
             let field = &fields[i];
 
@@ -666,7 +678,7 @@ impl {name} {{
 
         let shortname = Name::from(&ast.name).0.last().unwrap().clone();
 
-        write!(self.f, "#[repr(C)]\npub struct {sn} {{\n    pub ctx: *mut std::ffi::c_void,\n",
+        write!(self.f, "#[derive(Clone)]\n#[repr(C)]\npub struct {sn} {{\n    pub ctx: *mut std::ffi::c_void,\n",
                sn = shortname,
         ).unwrap();
 

src/lib.rs

@@ -15,6 +15,7 @@ pub mod emitter_js;
 pub mod emitter_py;
 pub mod emitter_rs;
 pub mod emitter_go;
+pub mod emitter_common;
 pub mod expand;
 pub mod export_make;
 pub mod export_cmake;
@@ -46,11 +47,11 @@ impl Error {
     }
 }
 
-#[derive(PartialEq)]
+#[derive(PartialEq, Debug)]
 pub enum BuildSet {
     Tests,
     Run,
-    Check,
+    Check(Option<std::path::PathBuf>),
     All,
     Export,
     Named(String),