format

asm/src/data/literal.rs

@@ -1,6 +1,6 @@
+use std::borrow::Cow;
 use std::fmt::{self, Display, Formatter};
 use std::sync::atomic::AtomicU32;
-use std::borrow::Cow;
 
 pub type DebugMsg = Cow<'static, str>;
 

asm/src/data/mask.rs

@@ -15,7 +15,7 @@ impl Default for Mask {
     fn default() -> Self {
         Mask {
             len: 64,
-            offset: 0
+            offset: 0,
         }
     }
 }
@@ -44,7 +44,7 @@ impl Mask {
             // create the invalid mask to display it in the error
             return Err(AsmError::BadMask(Mask {
                 len,
-                offset
+                offset,
             }));
         }
 

asm/src/data/mod.rs

@@ -1,20 +1,19 @@
-use super::error::AsmError;
+use std::convert::TryFrom;
+use std::fmt::{Debug, Display, Formatter};
+use std::fmt;
 
+use literal::Addr;
+pub use mask::Mask;
+pub use reg::Register;
+
+use crate::data::literal::{as_signed, Value};
+
+use super::error::AsmError;
 
 pub mod literal;
 pub mod reg;
 pub mod mask;
 
-pub use reg::Register;
-pub use mask::Mask;
-use literal::Addr;
-
-use std::convert::TryFrom;
-
-use crate::data::literal::{Value, as_signed};
-use std::fmt::{Debug, Formatter, Display};
-use std::fmt;
-
 /// Data source disposition
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub enum DataDisp {

asm/src/data/reg.rs

@@ -1,4 +1,5 @@
 use std::fmt::{self, Display, Formatter};
+
 use crate::error::Error;
 
 /// Register name

asm/src/error.rs

@@ -1,9 +1,10 @@
-use crate::instr::{Cond};
-use crate::data::{Mask, Register};
-use thiserror::Error;
 use std::borrow::Cow;
-use crate::data::literal::Label;
 
+use thiserror::Error;
+
+use crate::data::{Mask, Register};
+use crate::data::literal::Label;
+use crate::instr::Cond;
 
 /// csn_asm unified error type
 #[derive(Error, Debug)]

asm/src/instr/flatten.rs

@@ -1,9 +1,10 @@
-use std::sync::atomic::AtomicU32;
-use crate::instr::{HLOp, Instr, Cond, Routine, Op};
-use crate::error::{Error, AsmError};
 use std::collections::HashMap;
-use crate::data::literal::{Label, Value};
+use std::sync::atomic::AtomicU32;
+
 use crate::data::{Rd, SrcDisp};
+use crate::data::literal::{Label, Value};
+use crate::error::{AsmError, Error};
+use crate::instr::{Cond, HLOp, Instr, Op, Routine};
 
 /// A trait for something that can turn into multiple instructions
 pub trait Flatten {

asm/src/instr/mod.rs

@@ -1,17 +1,14 @@
-mod op;
+pub use cond::Cond;
-mod cond;
-mod flatten;
-
 pub use flatten::Flatten;
 pub use flatten::lower;
-
 pub use op::HLOp;
 pub use op::Op;
-pub use cond::Cond;
-use crate::data::literal::{RoutineName};
-
 
+use crate::data::literal::RoutineName;
 
+mod op;
+mod cond;
+mod flatten;
 
 /// A higher-level instruction
 #[derive(Debug, Clone, Eq, PartialEq)]

asm/src/instr/op.rs

@@ -1,10 +1,10 @@
 use crate::data::{
-    Wr, Rd,
+    literal::DebugMsg, literal::Label,
-    literal::Label,
     literal::RoutineName,
-    literal::DebugMsg,
+    Rd,
+    Wr,
 };
-use crate::instr::{Cond};
+use crate::instr::Cond;
 
 /// A higher level simple opration
 #[derive(Clone, Debug, Eq, PartialEq)]
@@ -64,9 +64,11 @@ pub enum Op {
     Or { dst: Wr, a: Rd, b: Rd },
     Xor { dst: Wr, a: Rd, b: Rd },
     Cpl { dst: Wr, a: Rd },
-    Rol { dst: Wr, a: Rd, n: Rd }, // Rotate (with wrap-around)
+    Rol { dst: Wr, a: Rd, n: Rd },
+    // Rotate (with wrap-around)
     Ror { dst: Wr, a: Rd, n: Rd },
-    Lsl { dst: Wr, a: Rd, n: Rd }, // Shift
+    Lsl { dst: Wr, a: Rd, n: Rd },
+    // Shift
     Lsr { dst: Wr, a: Rd, n: Rd },
     Asr { dst: Wr, a: Rd, n: Rd },
 }

asm/src/lib.rs

@@ -1,11 +1,11 @@
+use crate::instr::{lower, Op};
+
 pub mod data;
 pub mod error;
 pub mod instr;
 pub mod parse;
 pub mod patches;
 
-use crate::instr::{Op, lower};
-
 /// Parse a program from string and assemble a low level instruction sequence from it.
 pub fn assemble(source: &str) -> Result<Vec<Op>, error::Error> {
     let parsed = parse::parse(source)?;
@@ -14,12 +14,13 @@ pub fn assemble(source : &str) -> Result<Vec<Op>, error::Error> {
 
 #[cfg(test)]
 mod tests {
-    use crate::parse::{parse, parse_instructions};
-    use crate::instr::{HLOp, Op, Flatten, Instr, lower};
-    use crate::data::{Wr, DstDisp, Register, SrcDisp, Rd};
-    use crate::data::literal::{Addr, Label};
     use std::sync::atomic::AtomicU32;
+
+    use crate::data::{DstDisp, Rd, Register, SrcDisp, Wr};
+    use crate::data::literal::{Addr, Label};
+    use crate::instr::{Flatten, HLOp, Instr, lower, Op};
     use crate::instr::Cond;
+    use crate::parse::{parse, parse_instructions};
 
     #[test]
     fn test_parse_empty() {
@@ -187,14 +188,14 @@ mod tests {
                                     Wr::new(DstDisp::Register(Register::Gen(0))),
                                     Rd::new(SrcDisp::Register(Register::Gen(0))),
                                 )),
-                                branches: None
+                                branches: None,
                             },
                             Instr {
                                 op: HLOp::L(Op::Mov(
                                     Wr::new(DstDisp::Register(Register::Gen(1))),
                                     Rd::new(SrcDisp::Register(Register::Gen(2))),
                                 )),
-                                branches: None
+                                branches: None,
                             }
                         ]
                     ),
@@ -206,18 +207,18 @@ mod tests {
                                     Wr::new(DstDisp::Register(Register::Gen(0))),
                                     Rd::new(SrcDisp::Register(Register::Gen(0))),
                                 )),
-                                branches: None
+                                branches: None,
                             },
                             Instr {
                                 op: HLOp::L(Op::Mov(
                                     Wr::new(DstDisp::Register(Register::Gen(1))),
                                     Rd::new(SrcDisp::Register(Register::Gen(1))),
                                 )),
-                                branches: None
+                                branches: None,
                             }
                         ]
                     )
-                ])
+                ]),
             }
             , parsed);
     }

asm/src/parse/mod.rs

@@ -1,9 +1,10 @@
+use std::sync::atomic::AtomicU32;
 
-use crate::instr::{Routine, HLOp, Flatten};
+pub use parse_instr::parse_instructions;
-use crate::error::Error;
+use parse_routines::parse_routines;
-
 
-use std::sync::atomic::AtomicU32;
+use crate::error::Error;
+use crate::instr::{Flatten, HLOp, Routine};
 use crate::parse::sexp_expect::expect_list;
 
 mod parse_cond;
@@ -13,9 +14,6 @@ mod parse_routines;
 mod sexp_expect;
 mod parse_op;
 
-use parse_routines::parse_routines;
-pub use parse_instr::parse_instructions;
-
 pub fn parse(source: &str) -> Result<Vec<HLOp>, Error> {
     let root = sexp::parse(source)?;
 

asm/src/parse/parse_cond.rs

@@ -1,8 +1,9 @@
-use crate::parse::sexp_expect::{expect_list, expect_string_atom};
 use sexp::Sexp;
-use crate::instr::{Cond, Instr};
+
 use crate::error::Error;
+use crate::instr::{Cond, Instr};
 use crate::parse::parse_instr::parse_instructions;
+use crate::parse::sexp_expect::{expect_list, expect_string_atom};
 use crate::patches::TryRemove;
 
 pub fn parse_cond_branch(tok: Sexp) -> Result<(Cond, Vec<Instr>), Error> {

asm/src/parse/parse_data.rs

@@ -1,8 +1,10 @@
-use sexp::{Sexp, Atom};
-use crate::data::{DataDisp, Rd, Wr, DstDisp, SrcDisp, reg};
-use crate::error::Error;
-use crate::data::literal::{Addr, Label};
 use std::convert::TryFrom;
+
+use sexp::{Atom, Sexp};
+
+use crate::data::{DataDisp, DstDisp, Rd, reg, SrcDisp, Wr};
+use crate::data::literal::{Addr, Label};
+use crate::error::Error;
 use crate::parse::sexp_expect::expect_string_atom;
 
 /// Parse a label
@@ -24,7 +26,7 @@ pub fn parse_data_disp(tok: Option<Sexp>) -> Result<DataDisp, Error> {
     match &tok {
         Sexp::Atom(Atom::I(val)) => {
             Ok(DataDisp::Immediate(unsafe { std::mem::transmute(*val) }))
-        },
+        }
         Sexp::Atom(Atom::S(s)) => {
             if s == "_" {
                 return Ok(DataDisp::Discard);
@@ -42,10 +44,10 @@ pub fn parse_data_disp(tok: Option<Sexp>) -> Result<DataDisp, Error> {
             } else {
                 Ok(DataDisp::Register(reg::parse_reg(s)?))
             }
-        },
+        }
         _ => {
             Err(Error::Parse(format!("bad data disp: {:?}", tok).into()))
-        },
+        }
     }
 }
 

asm/src/parse/parse_instr.rs

@@ -1,11 +1,11 @@
 use sexp::Sexp;
-use crate::instr::{Instr};
-use crate::error::Error;
-use crate::parse::parse_cond::{parse_cond_branch};
-
 
+use crate::error::Error;
+use crate::instr::Instr;
+use crate::parse::parse_cond::parse_cond_branch;
 use crate::parse::sexp_expect::{expect_list, expect_string_atom};
 use crate::patches::SexpIsA;
+
 use super::parse_op::parse_op;
 
 pub fn parse_instructions(instrs: Vec<Sexp>) -> Result<Vec<Instr>, Error> {
@@ -43,7 +43,7 @@ pub fn parse_instructions(instrs: Vec<Sexp>) -> Result<Vec<Instr>, Error> {
 
         parsed.push(Instr {
             op: parse_op(name.as_str(), far, arg_tokens.into_iter())?,
-            branches
+            branches,
         });
     }
     Ok(parsed)

asm/src/parse/parse_op.rs

@@ -1,11 +1,12 @@
-use crate::instr::{HLOp, Op};
 use sexp::Sexp;
+
+use crate::data::{Rd, Wr};
+use crate::data::literal::{Label, RoutineName};
 use crate::error::Error;
-use crate::data::literal::{RoutineName, Label};
+use crate::instr::{HLOp, Op};
-use crate::parse::sexp_expect::expect_string_atom;
-use crate::parse::parse_data::{parse_rd, parse_wr, parse_label};
 use crate::parse::parse_cond::parse_cond;
-use crate::data::{Rd, Wr};
+use crate::parse::parse_data::{parse_label, parse_rd, parse_wr};
+use crate::parse::sexp_expect::expect_string_atom;
 
 pub fn parse_op(keyword: &str, far: bool, mut arg_tokens: impl ExactSizeIterator<Item=Sexp> + Clone) -> Result<HLOp, Error> {
     Ok(match keyword {

asm/src/parse/parse_routines.rs

@@ -1,8 +1,9 @@
-use crate::parse::parse_instr::parse_instructions;
-use crate::instr::Routine;
-use crate::data::literal::RoutineName;
 use sexp::Sexp;
+
+use crate::data::literal::RoutineName;
 use crate::error::Error;
+use crate::instr::Routine;
+use crate::parse::parse_instr::parse_instructions;
 use crate::parse::sexp_expect::{expect_list, expect_string_atom};
 use crate::patches::TryRemove;
 

asm/src/parse/sexp_expect.rs

@@ -1,4 +1,5 @@
-use sexp::{Sexp, Atom};
+use sexp::{Atom, Sexp};
+
 use crate::error::Error;
 
 pub fn expect_list(expr: Option<Sexp>, allow_empty: bool) -> Result<Vec<Sexp>, Error> {

asm/src/patches/mod.rs

@@ -1,5 +1,6 @@
+pub use sexp_is_a::SexpIsA;
+pub use try_remove::TryRemove;
+
 mod try_remove;
 mod sexp_is_a;
 
-pub use try_remove::TryRemove;
-pub use sexp_is_a::SexpIsA;

crsn/src/main.rs

@@ -2,9 +2,10 @@
 extern crate log;
 
 use simple_logger::SimpleLogger;
-use runtime::run_thread::{RunThread, ThreadToken};
+
-use runtime::program::Program;
 use asm::data::literal::Addr;
+use runtime::program::Program;
+use runtime::run_thread::{RunThread, ThreadToken};
 
 fn main() {
     SimpleLogger::new().init().unwrap();

runtime/src/exec/mod.rs

@@ -1,10 +1,13 @@
-use crate::run_thread::{RunThread};
+use std::ops::Rem;
-use asm::instr::{Op};
+
+use num_traits::PrimInt;
+
+use asm::data::literal::Addr;
+use asm::instr::Op;
+
 use crate::fault::Fault;
 use crate::frame::StackFrame;
-use asm::data::literal::{Addr};
+use crate::run_thread::RunThread;
-use std::ops::{Rem};
-use num_traits::PrimInt;
 
 pub type CyclesSpent = usize;
 

runtime/src/fault.rs

@@ -1,8 +1,9 @@
 use thiserror::Error;
+
 // use super::span::MemorySpan;
 // use crate::run_thread::ThreadToken;
 // use crate::mlock::ClaimId;
-use asm::data::literal::{DebugMsg, RoutineName, Label};
+use asm::data::literal::{DebugMsg, Label, RoutineName};
 use asm::data::Register;
 
 #[derive(Error, Debug)]

runtime/src/frame.rs

@@ -1,12 +1,10 @@
+use asm::data::{DstDisp, Rd, Register, SrcDisp, Wr};
 use asm::data::literal::{Addr, Value};
-use asm::data::{Rd, SrcDisp, Register, Wr, DstDisp};
+use status::StatusFlags;
-use crate::fault::Fault;
-
-
 
+use crate::fault::Fault;
 
 mod status;
-use status::StatusFlags;
 
 pub const REG_COUNT: usize = 8;
 

runtime/src/frame/status.rs

@@ -1,6 +1,7 @@
 use std::fmt::{Display, Formatter};
 use std::fmt;
-use asm::data::literal::{Value, is_positive, is_negative};
+
+use asm::data::literal::{is_negative, is_positive, Value};
 use asm::instr::Cond;
 
 #[derive(Default, Clone, Debug)]

runtime/src/lib.rs

@@ -1,4 +1,5 @@
-#[macro_use] extern crate log;
+#[macro_use]
+extern crate log;
 
 pub mod run_thread;
 // pub mod mlock;

runtime/src/mlock.rs

@@ -1,8 +1,9 @@
-use std::sync::atomic::{AtomicU32, Ordering};
 use std::fmt;
 use std::fmt::Formatter;
-use crate::run_thread::ThreadToken;
+use std::sync::atomic::{AtomicU32, Ordering};
+
 use crate::fault::Fault;
+use crate::run_thread::ThreadToken;
 use crate::span::MemorySpan;
 
 /// Records memory claims and protects from illegal access

runtime/src/program.rs

@@ -1,8 +1,10 @@
-use asm::instr::{Op};
-use asm::data::literal::{Addr, RoutineName, Label};
-use crate::fault::Fault;
 use std::collections::HashMap;
 
+use asm::data::literal::{Addr, Label, RoutineName};
+use asm::instr::Op;
+
+use crate::fault::Fault;
+
 #[derive(Clone, Debug)]
 pub struct Program {
     ops: Vec<Op>,

runtime/src/run_thread.rs

@@ -1,14 +1,11 @@
-use std::time::Duration;
 use std::thread::JoinHandle;
+use std::time::Duration;
 
-use asm::data::literal::{Addr};
+use asm::data::literal::Addr;
-
-
-
 
+use crate::exec::EvalRes;
 use crate::frame::StackFrame;
 use crate::program::Program;
-use crate::exec::EvalRes;
 
 const CYCLE_TIME: Duration = Duration::from_millis(0);
 //const CYCLE_TIME : Duration = Duration::from_millis(100);

runtime/src/span.rs

@@ -1,5 +1,3 @@
-
-
 use asm::data::literal::Addr;
 
 #[derive(Debug, Clone, Copy)]