parser: allow for default generator

Author: remi-dupre

src/lib.rs

@@ -1,5 +1,6 @@
 pub mod input;
 pub mod parse;
+pub mod run;
 
 use std::cmp::min;
 use std::iter;
@@ -63,63 +64,14 @@ pub struct Opt {
     pub bench: bool,
 }
 
-#[macro_export]
-macro_rules! run_day {
-    (
-        { $i: expr, $curr_day: expr, $year: expr, $opt: expr },
-        { day $day: ident { gen $generator: ident { $( { sol $solution: ident } )* } } }
-    ) => {{
-        if stringify!($day) == $curr_day {
-            if $i != 0 { println!() }
-            let day = $curr_day[3..].parse().expect("days must be integers");
-            println!("Day {}", day);
-
-            let data = {
-                if $opt.stdin {
-                    let mut data = String::new();
-                    std::io::stdin().read_to_string(&mut data)
-                        .expect("failed to read from stdin");
-                    data
-                } else if let Some(path) = $opt.file.as_ref() {
-                    read_to_string(path)
-                        .expect("failed to read specified file")
-                } else {
-                    $crate::input::get_input($year, day).expect("could not fetch input")
-                }
-            };
-
-            let input = data.as_str();
-
-            // $(
-                let start = Instant::now();
-                let input = $day::$generator(&data);
-                let elapsed = start.elapsed();
-                $crate::print_with_duration("generator", None, elapsed);
-            // )?
-
-            $({
-                let start = Instant::now();
-                let response = $day::$solution(&input);
-                let elapsed = start.elapsed();
-
-                $crate::print_with_duration(
-                    stringify!($solution),
-                    Some(&format!("{}", response)),
-                    elapsed,
-                );
-            })+
-        }
-    }}
-}
-
 #[macro_export]
 macro_rules! main {
     ( year $year: expr; $( $tail: tt )* ) => {
         use std::fs::read_to_string;
         use std::io::Read;
         use std::time::Instant;
 
-        use $crate::{clap::Clap, parse, run_day};
+        use $crate::{clap::Clap, extract_day, parse, run_day};
 
         const YEAR: u16 = $year;
 

src/parse.rs

@@ -1,13 +1,21 @@
 // Call `apply` macro on this generated form of token tree;
-// $ctx, { day DAY { gen GENERATOR { { sol SOLUTION } { sol SOLUTION } } } }
+// $ctx, { day DAY { { gen GENERATOR } { { sol SOLUTION } { sol SOLUTION } } } }
 #[macro_export]
 macro_rules! parse {
     // Read day
     (
         day $apply: ident, $ctx: tt, $val: expr;
         $day: ident : $generator: ident => $( $tail: tt )*
     ) => {
-        $crate::parse!( sol $apply, $ctx, $val; { day $day { gen $generator { } } }; $( $tail )* )
+        $crate::parse!( sol $apply, $ctx, $val; { day $day { { gen $generator } { } } }; $( $tail )* )
+    };
+
+    // Read day: default generator
+    (
+        day $apply: ident, $ctx: tt, $val: expr;
+        $day: ident => $( $tail: tt )*
+    ) => {
+        $crate::parse!( sol $apply, $ctx, $val; { day $day { { gen_default } { } } }; $( $tail )* )
     };
 
     // Empty rules
@@ -16,12 +24,12 @@ macro_rules! parse {
     // Read solution
     (
         sol $apply: ident, $ctx: tt, $val: expr;
-        { day $day: tt { gen $generator: tt { $( $acc: tt )* } } } ;
+        { day $day: tt { $gen: tt { $( $acc: tt )* } } } ;
         $sol: ident $( $tail: tt )*
     ) => {
         $crate::parse!(
             post_sol $apply, $ctx, $val;
-            { day $day { gen $generator { $( $acc )* { sol $sol } } } };
+            { day $day { $gen { $( $acc )* { sol $sol } } } };
             $( $tail )*
         )
     };

src/run.rs

@@ -0,0 +1,58 @@
+#[macro_export]
+macro_rules! run_day {
+    (
+        { $i: expr, $curr_day: expr, $year: expr, $opt: expr },
+        { day $day: ident { $gen: tt { $( { sol $solution: ident } )* } } }
+    ) => {{
+        if stringify!($day) == $curr_day {
+            if $i != 0 { println!() }
+            let day = $curr_day[3..].parse().expect("days must be integers");
+            println!("Day {}", day);
+
+            let data = {
+                if $opt.stdin {
+                    let mut data = String::new();
+                    std::io::stdin().read_to_string(&mut data)
+                        .expect("failed to read from stdin");
+                    data
+                } else if let Some(path) = $opt.file.as_ref() {
+                    read_to_string(path)
+                        .expect("failed to read specified file")
+                } else {
+                    $crate::input::get_input($year, day).expect("could not fetch input")
+                }
+            };
+
+            let input = $crate::run_gen!($day, &data, $gen);
+
+            $({
+                let start = Instant::now();
+                let response = $day::$solution(&input);
+                let elapsed = start.elapsed();
+
+                $crate::print_with_duration(
+                    stringify!($solution),
+                    Some(&format!("{}", response)),
+                    elapsed,
+                );
+            })+
+        }
+    }}
+}
+
+#[macro_export]
+macro_rules! run_gen {
+    // No generator is needed: default begavior is to just pass input &str
+    ( $day: ident, $data: expr, { gen_default } ) => {{
+        $data
+    }};
+
+    // Run generator
+    ( $day: ident, $data: expr, { gen $generator: ident } ) => {{
+        let start = Instant::now();
+        let input = $day::$generator($data);
+        let elapsed = start.elapsed();
+        $crate::print_with_duration("generator", None, elapsed);
+        input
+    }};
+}