Add rustfmt file & format source code

Author: Cryptjar

examples/printer/mod.rs

@@ -1,4 +1,3 @@
-
 //!
 //! Universal printer type.
 //!
@@ -27,6 +26,7 @@ impl Printer {
 		#[cfg(not(target_arch = "avr"))]
 		println!("{}", s);
 	}
+
 	pub fn print(&mut self, c: char) {
 		#[cfg(target_arch = "avr")]
 		ufmt::uwrite!(&mut self.0, "{}", c).void_unwrap();
@@ -35,4 +35,3 @@ impl Printer {
 		print!("{}", c);
 	}
 }
-

examples/uno-serial.rs

@@ -35,12 +35,10 @@
 #![cfg_attr(target_arch = "avr", no_std)]
 #![no_main]
 
-// Import a halting panic implementation for AVR
-#[cfg(target_arch = "avr")]
-use panic_halt as _;
 
-// Our library to be actually test here!
 use avr_progmem::progmem;
+#[cfg(target_arch = "avr")]
+use panic_halt as _; // halting panic implementation for AVR
 
 
 // The length of the below data block.
@@ -92,13 +90,12 @@ fn main() -> ! {
 	// Loop through the entire `TEXT` and print it char-by-char
 	let mut idx = 0;
 	loop {
-
 		printer.print(TEXT.load_at(idx) as char);
 
 		idx += 1;
 
 		if idx >= TEXT_LEN {
-			break
+			break;
 		}
 	}
 

rustfmt.toml

@@ -0,0 +1,24 @@
+# Custom Formatting Configuration
+# See: https://github.com/rust-lang/rustfmt/blob/master/Configurations.md
+# Notice, you need a nightly toolchain for correctly formatting
+
+hard_tabs = true                   # Use true tabs, no spaces for indentation
+edition = "2018"                   # not necessary for `cargo fmt`, but seems reasonable to have
+merge_derives = false              # Do not combine separate #[derives]
+newline_style = "Unix"
+use_field_init_shorthand = true    # Enforce using shorthand
+
+# Unstable stuff, which is nice to have:
+unstable_features = true           # Opt-in into nightly features
+blank_lines_upper_bound = 3        # Allow up to 3 blank lines between items
+match_block_trailing_comma = true  # Always add a comma in matches
+combine_control_expr = false       # Put control expressions in block format
+force_multiline_blocks = true      # Use blocks for multiline code
+format_macro_matchers = true       # (try) formatting macro_rules
+format_strings = true              # Line break long strings
+imports_layout = "Vertical"        # Each item on a separate line
+imports_granularity = "Item"       # Use a single import per module
+group_imports = "StdExternalCrate" # Group by std, external, self
+reorder_impl_items = true          # Put types first in impl blocks
+struct_lit_single_line = false     # Each field on a separate line
+

src/lib.rs

@@ -1,10 +1,9 @@
-
 // We don't need anything from std, and on AVR there is no std anyway.
 #![no_std]
-
+//
 // We need inline assembly for the `lpm` instruction.
 #![feature(llvm_asm)]
-
+//
 // We need const generics, however the `const_generics` feature is reported as
 // incomplete, thus we actually use the `min_const_generics` feature, which is
 // sufficient for us. However, min_const_generics in turn fails to work with
@@ -13,7 +12,6 @@
 #![cfg_attr(doc, feature(const_generics))]
 #![cfg_attr(not(doc), feature(min_const_generics))]
 
-
 //!
 //! Progmem utilities for the AVR architectures.
 //!
@@ -181,9 +179,9 @@
 //!
 
 
+use core::convert::TryInto;
 use core::mem::size_of;
 use core::mem::MaybeUninit;
-use core::convert::TryInto;
 
 use cfg_if::cfg_if;
 
@@ -293,9 +291,7 @@ impl<T: Copy> ProgMem<T> {
 		// This is safe, because the invariant of this struct demands that
 		// this value (i.e. self and thus also its inner value) are stored
 		// in the progmem domain, which is what `read_value` requires from us.
-		unsafe {
-			read_value(p_addr)
-		}
+		unsafe { read_value(p_addr) }
 	}
 
 	/// Return the raw pointer to the inner value.
@@ -310,8 +306,7 @@ impl<T: Copy> ProgMem<T> {
 }
 
 /// Utilities to work with an array in progmem.
-impl<T: Copy, const N: usize> ProgMem<[T;N]> {
-
+impl<T: Copy, const N: usize> ProgMem<[T; N]> {
 	/// Load a single element from the inner array.
 	///
 	/// This method is analog to a slice indexing `self.inner[idx]`, so the
@@ -340,9 +335,7 @@ impl<T: Copy, const N: usize> ProgMem<[T;N]> {
 		//
 		// Also notice that the slice-indexing above gives us a bounds check.
 		//
-		unsafe {
-			read_value(addr)
-		}
+		unsafe { read_value(addr) }
 	}
 
 	/// Loads a sub array from the inner array.
@@ -369,25 +362,23 @@ impl<T: Copy, const N: usize> ProgMem<[T;N]> {
 	/// However, this is currently just a implementation limitation, which may
 	/// be lifted in the future.
 	///
-	pub fn load_sub_array<const M: usize>(&self, start_idx: usize) -> [T;M] {
+	pub fn load_sub_array<const M: usize>(&self, start_idx: usize) -> [T; M] {
 		assert!(M <= N);
 
 		// Make sure that we convert from &[T] to &[T;M] without constructing
 		// an actual [T;M], because we MAY NOT LOAD THE DATA YET!
 		// Also notice, that this sub-slicing dose ensure that the bound are
 		// correct.
-		let slice: &[T] = &self.0[start_idx..(start_idx+M)];
-		let array: &[T;M] = slice.try_into().unwrap();
+		let slice: &[T] = &self.0[start_idx..(start_idx + M)];
+		let array: &[T; M] = slice.try_into().unwrap();
 
 		// This is safe, because the invariant of this struct demands that
 		// this value (i.e. self and thus also its inner value) are stored
 		// in the progmem domain, which is what `read_value` requires from us.
 		//
 		// Also notice that the sub-slicing above gives us a bounds check.
 		//
-		unsafe {
-			read_value(array)
-		}
+		unsafe { read_value(array) }
 	}
 }
 
@@ -586,8 +577,9 @@ pub unsafe fn read_byte(p_addr: *const u8) -> u8 {
 ///
 #[allow(dead_code)]
 unsafe fn read_byte_loop_raw<T>(p_addr: *const T, out: *mut T, len: u8)
-		where T: Sized + Copy {
-
+where
+	T: Sized + Copy,
+{
 	// Convert to byte pointers
 	let p_addr_bytes = p_addr as *const u8;
 	let out_bytes = out as *mut u8;
@@ -635,14 +627,13 @@ unsafe fn read_byte_loop_raw<T>(p_addr: *const T, out: *mut T, len: u8)
 /// `core::ptr::copy` and therefore the pointers must be aligned.
 ///
 unsafe fn read_asm_loop_raw<T>(p_addr: *const T, out: *mut T, len: u8) {
-
 	// Here are the general requirements essentially required by the AVR-impl
 	// However, assume, the non-AVR version is only used in tests, it makes a
 	// lot of sens to ensure the AVR requirements are held up.
 
 	// Loop head check, just return for zero iterations
 	if len == 0 || size_of::<T>() == 0 {
-		return
+		return;
 	}
 
 	// Get size in bytes of T
@@ -658,7 +649,7 @@ unsafe fn read_asm_loop_raw<T>(p_addr: *const T, out: *mut T, len: u8) {
 	let size_bytes = size_bytes as u8;
 
 
-	cfg_if!{
+	cfg_if! {
 		if #[cfg(target_arch = "avr")] {
 			// Only addresses below the 64 KiB limit are supported
 			// Apparently this is of no concern for architectures with true
@@ -748,9 +739,10 @@ unsafe fn read_asm_loop_raw<T>(p_addr: *const T, out: *mut T, len: u8) {
 /// must be aligned.
 ///
 unsafe fn read_value_raw<T>(p_addr: *const T, out: *mut T, len: u8)
-		where T: Sized + Copy {
-
-	cfg_if!{
+where
+	T: Sized + Copy,
+{
+	cfg_if! {
 		if #[cfg(feature = "lpm-asm-loop")] {
 			read_asm_loop_raw(p_addr, out, len)
 		} else {
@@ -934,8 +926,9 @@ pub unsafe fn read_slice(p: &[u8], out: &mut [u8]) {
 ///
 #[cfg_attr(feature = "dev", inline(never))]
 pub unsafe fn read_value<T>(p_addr: *const T) -> T
-		where T: Sized + Copy {
-
+where
+	T: Sized + Copy,
+{
 	// The use of an MaybeUninit allows us to correctly allocate the space
 	// required to hold one `T`, whereas we correctly comunicate that it is
 	// uninitialized to the compiler.
@@ -964,14 +957,3 @@ pub unsafe fn read_value<T>(p_addr: *const T) -> T
 	// initialized, and this call is sound.
 	buffer.assume_init()
 }
-
-
-
-
-#[cfg(test)]
-mod tests {
-    #[test]
-    fn it_works() {
-        assert_eq!(2 + 2, 4);
-    }
-}