lots of changes

Author: usbalbin

macros/Cargo.lock

@@ -7,6 +7,9 @@ edition = "2024"
 proc-macro2 = "1.0.95"
 quote = "1.0.40"
 syn = { version = "2", features = ["full"] }
+probe-plotter-common = { path = "../probe-plotter-common" }
+serde = { version = "1.0.219", features = ["derive"] }
+serde_json = "1.0.141"
 
 [lib]
-proc-macro = true
+proc-macro = true

macros/Cargo.toml

@@ -64,9 +64,9 @@ pub fn make_metric(args: TokenStream) -> TokenStream {
     .into()
 }
 
-pub fn make_inplace_thing(args: TokenStream) -> TokenStream {
+/*pub fn make_inplace_thing(args: TokenStream) -> TokenStream {
 
-}
+}*/
 
 /// Create a Setting instance that will be shown as a slider in the probe-plotter utility
 ///
@@ -139,13 +139,13 @@ fn hash(string: &str) -> u64 {
 /// struct Foo {
 ///     #[metric("bar / 33.1")]
 ///     bar: u8,
-/// 
+///
 ///     baz: Baz,
-/// 
+///
 ///     #[setting(0..=3, 1)]
 ///     quix: f32
 /// }
-/// 
+///
 /// #[derive(Plottable)]
 /// struct Baz {
 ///     #[metric("a * 3.0")]
@@ -159,16 +159,32 @@ pub fn impl_metricable(input: TokenStream) -> TokenStream {
     let ast: syn::ItemStruct = syn::parse(input).unwrap();
     let fields = ast.fields;
     let name = &ast.ident;
-    let fields = fields.iter().fold(String::new(), |acc, f| acc + &quote!([#f.ident, #f.ty]).to_string() + ",");
+
+    let fields: Vec<_> = fields
+        .iter()
+        .map(|f| {
+            let ty = &f.ty;
+            probe_plotter_common::symbol::Member {
+            name: f.ident.as_ref().unwrap().to_string(),
+            ty: quote!(#ty).to_string(),
+            offset: None,
+        }})
+        .collect();
+
     // TODO: move the static into some linker section so it does not occupy flash space
     // TODO: handle module paths and name spaces
-    let sym_name = format!(r#"{{"type":"Type",""ty":"{name}", fields: [{fields}]}}"#);
+    let sym_name = serde_json::to_string(&probe_plotter_common::symbol::Symbol::Type {
+        name: name.to_string(),
+        fields,
+    })
+    .unwrap();
+
     quote! {
         unsafe impl ::probe_plotter::metric::Metricable for #name {}
 
         #[allow(non_upper_case_globals)]
         #[unsafe(export_name = #sym_name)]
         static #name: u8 = 0;
-
-    }.into()
-}
+    }
+    .into()
+}

macros/src/lib.rs

@@ -0,0 +1,10 @@
+[package]
+name = "probe-plotter-common"
+version = "0.1.0"
+edition = "2024"
+publish = ["gitea"]
+
+[dependencies]
+serde = { version = "1.0.219", features = ["derive"] }
+serde_json = "1.0.141"
+shunting = { git = "https://github.com/usbalbin/tox", branch = "add-ln" }

probe-plotter-common/Cargo.toml

@@ -0,0 +1,135 @@
+use std::{collections::HashMap, fmt::Display};
+
+pub mod symbol;
+
+#[allow(non_camel_case_types)]
+#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, Copy, PartialEq, Hash, Eq)]
+pub enum PrimitiveType {
+    u8,
+    u16,
+    u32,
+    i8,
+    i16,
+    i32,
+    f32,
+}
+
+#[derive(serde::Serialize, serde::Deserialize, PartialEq, Clone, Hash, Eq)]
+pub struct Atype(String);
+
+impl Display for Atype {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.0.fmt(f)
+    }
+}
+
+pub type Types = HashMap<Atype, TypeDef>;
+
+pub enum TypeDef {
+    Struct {
+        name: Atype,
+        fields: Vec<symbol::Member>,
+    },
+    Enum {
+        name: Atype,
+        discriminator_type: PrimitiveType,
+        variants: Vec<EnumVariant>,
+    },
+}
+
+impl TypeDef {
+    fn size_of(&self, types: &Types) -> u64 {
+        match self {
+            TypeDef::Struct { name, fields } => fields
+                .last()
+                .map(|x| {
+                    x.offset.unwrap().next_multiple_of(x.ty.align_of(&types)) + x.ty.size_of(&types)
+                })
+                .unwrap_or(0),
+            TypeDef::Enum {
+                name,
+                discriminator_type,
+                variants,
+            } => todo!(),
+        }
+    }
+
+    fn align_of(&self, _types: &Types) -> u64 {
+        todo!()
+    }
+}
+
+pub struct EnumVariant {
+    pub name: String,
+    pub ty: PrimitiveType,
+    pub expr: shunting::RPNExpr,
+}
+
+impl Atype {
+    pub fn is_primitive(&self) -> bool {
+        ["u8", "u16", "u32", "i8", "i16", "i32", "f32"].contains(&self.0.as_ref())
+    }
+
+    pub fn size_of(&self, types: &Types) -> u64 {
+        match PrimitiveType::try_from(self) {
+            Ok(p) => p.size_of(),
+            Err(()) => types.get(self).unwrap().size_of(types),
+        }
+    }
+
+    pub fn align_of(&self, types: &Types) -> u64 {
+        match PrimitiveType::try_from(self) {
+            Ok(p) => p.align_of(),
+            Err(()) => types.get(self).unwrap().size_of(types),
+        }
+    }
+}
+
+impl TryFrom<&Atype> for PrimitiveType {
+    type Error = ();
+
+    fn try_from(t: &Atype) -> Result<PrimitiveType, Self::Error> {
+        match t.0.as_str() {
+            "u8" => Ok(PrimitiveType::u8),
+            "u16" => Ok(PrimitiveType::u16),
+            "u32" => Ok(PrimitiveType::u32),
+            "i8" => Ok(PrimitiveType::i8),
+            "i16" => Ok(PrimitiveType::i16),
+            "i32" => Ok(PrimitiveType::i32),
+            "f32" => Ok(PrimitiveType::f32),
+            _ => Err(()),
+        }
+    }
+}
+
+impl PrimitiveType {
+    pub fn size_of(&self) -> u64 {
+        match self {
+            PrimitiveType::u8 | PrimitiveType::i8 => 1,
+            PrimitiveType::u16 | PrimitiveType::i16 => 2,
+            PrimitiveType::u32 | PrimitiveType::i32 | PrimitiveType::f32 => 4,
+        }
+    }
+
+    pub fn align_of(&self) -> u64 {
+        match self {
+            PrimitiveType::u8 | PrimitiveType::i8 => 1,
+            PrimitiveType::u16 | PrimitiveType::i16 => 2,
+            PrimitiveType::u32 | PrimitiveType::i32 | PrimitiveType::f32 => 4,
+        }
+    }
+}
+
+impl Into<Atype> for &PrimitiveType {
+    fn into(self) -> Atype {
+        match self {
+            PrimitiveType::u8 => Atype("u8".to_string()),
+            PrimitiveType::u16 => Atype("u16".to_string()),
+            PrimitiveType::u32 => Atype("u32".to_string()),
+            PrimitiveType::i8 => Atype("i8".to_string()),
+            PrimitiveType::i16 => Atype("i16".to_string()),
+            PrimitiveType::i32 => Atype("i32".to_string()),
+            PrimitiveType::f32 => Atype("f32".to_string()),
+        }
+    }
+}

probe-plotter-common/src/lib.rs

@@ -1,9 +1,8 @@
-use serde::Deserialize;
 use std::ops::RangeInclusive;
 
-use crate::Type;
+use crate::{Atype, PrimitiveType};
 
-#[derive(Deserialize, PartialEq)]
+#[derive(serde::Serialize, serde::Deserialize, PartialEq)]
 #[serde(tag = "type")]
 pub enum Symbol {
     Metric {
@@ -13,33 +12,41 @@ pub enum Symbol {
         expr: String,
 
         /// Type of value, i32, u8 etc.
-        ty: Type,
+        ty: Atype,
     },
     Setting {
         name: String,
 
         /// Type of value, i32, u8 etc.
-        ty: Type,
+        ty: PrimitiveType,
 
         /// Range of valid values
         range: RangeInclusive<f64>,
 
         /// Step size
         step_size: f64,
     },
+
+    // {"type":"Type",""ty":"{name}", fields: [{fields}]}
+    Type {
+        name: Atype,
+        fields: Vec<Member>,
+    },
 }
 
 impl Symbol {
     pub fn name(&self) -> &str {
         match self {
             Symbol::Metric { name, .. } => name,
             Symbol::Setting { name, .. } => name,
+            _ => todo!(),
         }
     }
-    pub fn ty(&self) -> Type {
+    pub fn ty(&self) -> Atype {
         match self {
-            Symbol::Metric { ty, .. } => *ty,
-            Symbol::Setting { ty, .. } => *ty,
+            Symbol::Metric { ty, .. } => ty.clone(),
+            Symbol::Setting { ty, .. } => ty.into(),
+            Symbol::Type { name, .. } => name.clone(),
         }
     }
 }
@@ -52,3 +59,10 @@ impl Symbol {
         serde_json::from_str(raw).map_err(|_| InvalidSymbolError)
     }
 }
+
+#[derive(serde::Serialize, serde::Deserialize, PartialEq)]
+pub struct Member {
+    pub name: String,
+    pub ty: Atype,
+    pub offset: Option<u64>,
+}

probe-plotter-tools/src/symbol.rs probe-plotter-common/src/symbol.rsprobe-plotter-tools/src/symbol.rs renamed to probe-plotter-common/src/symbol.rs

@@ -22,3 +22,4 @@ mimalloc = "0.1.43"
 shunting = { git = "https://github.com/usbalbin/tox", branch = "add-ln" }
 defmt-decoder = "1.0.0"
 defmt-parser = "1.0.0"
+probe-plotter-common = { path = "../probe-plotter-common" }