Real valued filters work

Cargo.lock

@@ -28,6 +28,8 @@ name = "firls-rs-macros"
 version = "0.1.0"
 dependencies = [
  "firls_rs",
+ "proc-macro2",
+ "quote",
  "syn 2.0.23",
 ]
 
@@ -160,9 +162,9 @@ checksum = "b4b27ab7be369122c218afc2079489cdcb4b517c0a3fc386ff11e1fedfcc2b35"
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.63"
+version = "1.0.64"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b368fba921b0dce7e60f5e04ec15e565b3303972b42bcfde1d0713b881959eb"
+checksum = "78803b62cbf1f46fde80d7c0e803111524b9877184cfe7c3033659490ac7a7da"
 dependencies = [
  "unicode-ident",
 ]

firls-rs-macros/Cargo.toml

@@ -8,4 +8,6 @@ proc-macro = true
 
 [dependencies]
 firls_rs = { path = "../firls-rs" }
+proc-macro2 = "1.0.64"
+quote = "1.0.29"
 syn = {version="2.0.23", features=["full"]}

firls-rs-macros/examples/filter_real_macro.rs

@@ -1,22 +1,17 @@
-use firls_rs::firls;
 use firls_rs_macros::firls_real;
 
-firls_real!(13, 8000.0, 1);
-//[(0.0, 1.0), (1900.0, 1.0), (3000.0, 0.0), (4000.0, 0.0)]);
+const COEFFS: [f32; 13] = firls_real!(
+    13,
+    8000.0,
+    [(0.0, 1.0), (1900.0, 1.0), (3000.0, 0.0), (7000.0, 0.0)]
+);
 
 fn main() {
-    let coeffs = firls(
-        13,
-        8000.0,
-        &vec![(0.0, 1.0), (1900.0, 1.0), (3000.0, 0.0), (4000.0, 0.0)],
-    )
-    .unwrap();
-
     println!("[");
-    for coeff in coeffs.iter() {
+    for coeff in COEFFS.iter() {
         println!("{},", coeff)
     }
     println!("]");
 
-    println!("Lenght: {}", coeffs.len());
+    println!("Lenght: {}", COEFFS.len());
 }

firls-rs-macros/src/lib.rs

@@ -1,13 +1,20 @@
 extern crate proc_macro;
+extern crate quote;
+
+use firls_rs::firls;
 use proc_macro::TokenStream;
-use syn::parse::{Parse, ParseStream, Parser};
-use syn::parse_macro_input;
+use proc_macro2::Span;
+use quote::quote;
+use syn::parse::{Parse, ParseStream};
 use syn::spanned::Spanned;
+use syn::{parse_macro_input};
 use syn::{punctuated::Punctuated, Expr, Lit, Token};
 
 struct FirlsRealInput {
     filter_len: usize,
-    sample_frequency: f32,
+    sampling_frequency: f32,
+    bands: Vec<(f32, f32)>,
+    span: Span,
 }
 
 impl Parse for FirlsRealInput {
@@ -21,13 +28,11 @@ impl Parse for FirlsRealInput {
             ));
         }
 
-        let filter_len = parse_filter_len(&arg_list[0])?;
-        let sample_frequency = parse_frequency(&arg_list[1])?;
-        let _bands = parse_band_list(&arg_list[2]);
-
         Ok(FirlsRealInput {
-            filter_len,
-            sample_frequency,
+            filter_len: parse_filter_len(&arg_list[0])?,
+            sampling_frequency: parse_frequency(&arg_list[1])?,
+            bands: parse_band_list(&arg_list[2])?,
+            span: arg_list.span(),
         })
     }
 }
@@ -100,14 +105,14 @@ fn parse_band_list(bands: &Expr) -> Result<Vec<(f32, f32)>, syn::Error> {
 fn parse_band_tuple(tuple: &Expr) -> Result<(f32, f32), syn::Error> {
     match tuple {
         Expr::Tuple(tuple_expr) => {
-            if tuple_expr.elems.len() != 2 {
+            if tuple_expr.elems.len() == 2 {
                 let freq = parse_frequency(&tuple_expr.elems[0])?;
                 let gain = parse_gain(&tuple_expr.elems[1])?;
                 Ok((freq, gain))
             } else {
                 Err(syn::Error::new(
                     tuple.span(),
-                    "band points should be a tuple expression",
+                    "band points should be a two element tuple",
                 ))
             }
         }
@@ -120,7 +125,23 @@ fn parse_band_tuple(tuple: &Expr) -> Result<(f32, f32), syn::Error> {
 
 #[proc_macro]
 pub fn firls_real(input: TokenStream) -> TokenStream {
-    let input = parse_macro_input!(input as FirlsRealInput);
+    let FirlsRealInput {
+        filter_len,
+        sampling_frequency,
+        bands,
+        span,
+    } = parse_macro_input!(input as FirlsRealInput);
 
-    "fn answer() -> u32 { 42 }".parse().unwrap()
+    let output = match firls(filter_len, sampling_frequency, &bands) {
+        Ok(coeffs) => {
+            quote! {
+                [
+                   #(#coeffs),*
+                ]
+            }
+        }
+        Err(msg) => syn::Error::new(span, msg).to_compile_error(),
+    };
+
+    proc_macro::TokenStream::from(output)
 }