Added missing parsers

firls-rs-macros/examples/filter_real_macro.rs

@@ -1,11 +1,8 @@
 use firls_rs::firls;
 use firls_rs_macros::firls_real;
 
-firls_real!(
-    13,
-    8000.0,
-    [(0.0, 1.0), (1900.0, 1.0), (3000.0, 0.0), (4000.0, 0.0)]
-);
+firls_real!(13, 8000.0, 1);
+//[(0.0, 1.0), (1900.0, 1.0), (3000.0, 0.0), (4000.0, 0.0)]);
 
 fn main() {
     let coeffs = firls(

firls-rs-macros/src/lib.rs

@@ -23,6 +23,7 @@ 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,
@@ -63,6 +64,60 @@ fn parse_frequency(freq: &Expr) -> Result<f32, syn::Error> {
     }
 }
 
+fn parse_gain(gain: &Expr) -> Result<f32, syn::Error> {
+    match gain {
+        Expr::Lit(expr) => match &expr.lit {
+            Lit::Float(float_lit) => float_lit.base10_parse(),
+            _ => Err(syn::Error::new(
+                expr.span(),
+                "expected float literal for gain",
+            )),
+        },
+        _ => Err(syn::Error::new(
+            gain.span(),
+            "gain should be a literal expression",
+        )),
+    }
+}
+
+fn parse_band_list(bands: &Expr) -> Result<Vec<(f32, f32)>, syn::Error> {
+    match bands {
+        Expr::Array(array_expr) => {
+            let mut result = Vec::new();
+            for elem in array_expr.elems.iter() {
+                let parsed_tuple = parse_band_tuple(elem)?;
+                result.push(parsed_tuple);
+            }
+            Ok(result)
+        }
+        _ => Err(syn::Error::new(
+            bands.span(),
+            "bands should be an array expression",
+        )),
+    }
+}
+
+fn parse_band_tuple(tuple: &Expr) -> Result<(f32, f32), syn::Error> {
+    match tuple {
+        Expr::Tuple(tuple_expr) => {
+            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",
+                ))
+            }
+        }
+        _ => Err(syn::Error::new(
+            tuple.span(),
+            "band points should be a tuple expression",
+        )),
+    }
+}
+
 #[proc_macro]
 pub fn firls_real(input: TokenStream) -> TokenStream {
     let input = parse_macro_input!(input as FirlsRealInput);