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/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),

src/main.rs

@@ -60,7 +60,13 @@ fn main() {
                         .takes_value(false)
                         .required(false)
                         .long("debug"),
-                ),
+                )
+                .arg(
+                    Arg::with_name("sourcefile")
+                        .takes_value(true)
+                        .required(false)
+                        .index(1),
+                )
         )
         .subcommand(
             SubCommand::with_name("build")
@@ -479,9 +485,15 @@ fn main() {
             return;
         }
         ("check", Some(submatches)) => {
+
+            let mut src = None;
+            if let Some(v) = submatches.value_of("sourcefile") {
+               src = Some(std::path::PathBuf::from(v).canonicalize().expect("sourcefile"));
+            }
+
             zz::parser::ERRORS_AS_JSON.store(true, Ordering::SeqCst);
             zz::build(
-                zz::BuildSet::Check,
+                zz::BuildSet::Check(src),
                 submatches.value_of("variant").unwrap_or("default"),
                 zz::make::Stage::test(),
                 false,

src/pipeline.rs

@@ -247,6 +247,13 @@ impl Pipeline {
                         ))
                     }
                     loader::Module::ZZ(ast) => {
+
+                        if let super::BuildSet::Check(Some(s)) = &buildset {
+                            if &ast.source != s {
+                                return None;
+                            }
+                        }
+
                         self.pb_doing("comp", hn.clone());
                         let r = self.do_emit(ast, &make);
                         self.pb_done("comp", hn);
@@ -270,6 +277,9 @@ impl Pipeline {
         if ABORT.load(Ordering::Relaxed) {
             std::process::exit(1);
         }
+        if let super::BuildSet::Check(_) = &buildset {
+            return;
+        }
 
         let mut main = Name::from(&artifact.main);
         if !main.is_absolute() {
@@ -295,6 +305,7 @@ impl Pipeline {
             }
         }
 
+
         for entry in std::fs::read_dir("./src").unwrap() {
             let entry = entry.unwrap();
             let path = entry.path();
@@ -314,16 +325,15 @@ impl Pipeline {
             }
         }
 
+
         make.build(&emitter::builtin(
             &self.project.project,
             &self.stage,
             &artifact,
             symbols,
         ));
 
-        if buildset != &super::BuildSet::Check {
-            make.link();
-        }
+        make.link();
     }
 
     fn to_buildcache(&self, cf: &emitter::CFile) {