new improved syntax to describe ubx protocol packets

Author: Dushistov

ublox_derive/Cargo.toml

@@ -1,15 +1,15 @@
 [package]
 name = "ublox_derive"
-version = "0.0.0"
+version = "0.0.1"
 authors = ["Lane Kolbly <lane@rscheme.org>"]
 edition = "2018"
 publish = false
 
-[lib]
-proc-macro = true
-
 [dependencies]
-proc-macro2 = "1.0"
 quote = "1.0"
-syn = { version = "1.0.14", features = ["extra-traits"] }
-heck = "0.3.1"
+syn = { version = "1.0.14", features = ["extra-traits", "parsing", "full"] }
+proc-macro2 = { version = "1.0", features = ["span-locations"] }
+log = "0.4"
+
+[dev-dependencies]
+which = { version = "3.0", default-features = false }

ublox_derive/src/error.rs

@@ -0,0 +1,47 @@
+use std::{fmt::Write, path::Path};
+use syn::Error;
+
+pub fn panic_on_parse_error((src_path, src_cnt): (&Path, &str), err: &Error) -> ! {
+    let span = err.span();
+    let start = span.start();
+    let end = span.end();
+
+    let mut code_problem = String::new();
+    let nlines = end.line - start.line + 1;
+    for (i, line) in src_cnt
+        .lines()
+        .skip(start.line - 1)
+        .take(nlines)
+        .enumerate()
+    {
+        code_problem.push_str(&line);
+        code_problem.push('\n');
+        if i == 0 && start.column > 0 {
+            write!(&mut code_problem, "{:1$}", ' ', start.column).expect("write to String failed");
+        }
+        let code_problem_len = if i == 0 {
+            if i == nlines - 1 {
+                end.column - start.column
+            } else {
+                line.len() - start.column - 1
+            }
+        } else if i != nlines - 1 {
+            line.len()
+        } else {
+            end.column
+        };
+        writeln!(&mut code_problem, "{:^^1$}", '^', code_problem_len).expect("Not enought memory");
+        if i == end.line {
+            break;
+        }
+    }
+
+    panic!(
+        "parsing of {name} failed\nerror: {err}\n{code_problem}\nAt {name}:{line_s}:{col_s}",
+        name = src_path.display(),
+        err = err,
+        code_problem = code_problem,
+        line_s = start.line,
+        col_s = start.column,
+    );
+}

ublox_derive/src/file_cache.rs

@@ -0,0 +1,47 @@
+/// To prevent modification time changing
+use std::{
+    fs::File,
+    io,
+    io::{Read, Write},
+    path::PathBuf,
+};
+
+/// Implement write cache in memory, and update file only if necessary
+pub struct FileWriteCache {
+    cnt: Vec<u8>,
+    path: PathBuf,
+}
+
+impl FileWriteCache {
+    pub fn new<P: Into<PathBuf>>(p: P) -> FileWriteCache {
+        let path = p.into();
+        FileWriteCache { cnt: vec![], path }
+    }
+
+    pub fn update_file_if_necessary(self) -> Result<(), io::Error> {
+        if let Ok(mut f) = File::open(&self.path) {
+            let mut cur_cnt = vec![];
+            f.read_to_end(&mut cur_cnt)?;
+            if cur_cnt == self.cnt {
+                return Ok(());
+            }
+        }
+        let mut f = File::create(&self.path)?;
+        f.write_all(&self.cnt)?;
+        Ok(())
+    }
+
+    pub fn replace_content(&mut self, bytes: Vec<u8>) {
+        self.cnt = bytes;
+    }
+}
+
+impl io::Write for FileWriteCache {
+    fn write(&mut self, data: &[u8]) -> Result<usize, io::Error> {
+        self.cnt.extend_from_slice(data);
+        Ok(data.len())
+    }
+    fn flush(&mut self) -> Result<(), io::Error> {
+        Ok(())
+    }
+}