Added Lua parser implementation and Lua BNF through macro_rules!;

Cargo.toml

@@ -19,7 +19,6 @@ log = "0.4"
 wgpu = "29.0.3"
 pollster = "0.4.0"
 console_error_panic_hook = "0.1.7"
-parse = { path = "./parse" }
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 console_error_panic_hook = "0.1.6"

src/lang.rs

@@ -55,27 +55,30 @@ macro_rules! definition {
 }
 
 macro_rules! implement {
-  {@begin $n:ident $i:ident $($t:tt)*} => {
-    implement!{@build ($i $n) {} {} $($t)*}
+  {@begin $n:ident structure $($t:tt)*} => {
+    implement!{@build (state result) (structure $n) {} {} $($t)*}
   };
-  {@build $m:tt $f:tt {$($f2:tt)*} $s:literal $($t:tt)*} => {
-    implement!{@build $m $f {
+  {@begin $n:ident enumeration ($m:ident ($($t2:tt)*)$($t:tt)*)} => {
+    implement!{@build (state result) (enumeration $m {} ($($t)*) $n) {} {} $($t2)*}
+  };
+  {@build ($st:ident $r:ident) $m:tt $f:tt {$($f2:tt)*} $s:literal $($t:tt)*} => {
+    implement!{@build ($st $r) $m $f {
       $($f2)*
-      state = state.trim_start();
-      if state.starts_with($s) {
-        state = &state[$s.len()..]
+      $st = $st.trim_start();
+      if $st.starts_with($s) {
+        $st = &$st[$s.len()..]
       } else {
-        return Err("error".into())
+        return Err("error".to_string())
       }
     } $($t)*}
   };
-  {@build $m:tt {$($f:tt)*} {$($f2:tt)*} $i:ident $($t:tt)*} => {
-    implement!{@build $m {$($f)*{$($f2)*}} {
-      let mut result;
-      match $i::take(state) {
+  {@build ($s:ident $r:ident) $m:tt {$($f:tt)*} {$($f2:tt)*} $i:ident $($t:tt)*} => {
+    implement!{@build ($s $r) $m {$($f)*{$($f2)*}} {
+      let $r;
+      match $i::consume($s) {
         Ok((r,s)) => {
-          state = s;
-          result = r;
+          $s = s;
+          $r = r;
         }
         Err(error) => {
           return Err(error);
@@ -83,36 +86,48 @@ macro_rules! implement {
       }
     } $($t)*}
   };
-  {@build ($($m:tt)*) {$($f:tt)*} {$($f2:tt)*} {$($r:tt)*} $($t:tt)*} => {
-    implement!{@build (vector {$($f)*{$($f2)*}} ($($t)*) $($m)*) {} {} $($r)*}
+  {@build $va:tt ($($m:tt)*) {$($f:tt)*} {$($f2:tt)*} {$($r:tt)*} $($t:tt)*} => {
+    implement!{@build $va (vector {$($f)*{$($f2)*}} ($($t)*) $($m)*) {} {} $($r)*}
   };
-  {@build ($($m:tt)*) {$($f:tt)*} {$($f2:tt)*} [$($r:tt)*] $($t:tt)*} => {
-    implement!{@build (option {$($f)*{$($f2)*}} ($($t)*) $($m)*) {} {} $($r)*}
+  {@build $va:tt ($($m:tt)*) {$($f:tt)*} {$($f2:tt)*} [$($r:tt)*] $($t:tt)*} => {
+    implement!{@build $va (option {$($f)*{$($f2)*}} ($($t)*) $($m)*) {} {} $($r)*}
   };
-  {@finish (option {$($l:tt)*} ($($t:tt)*) $($m:tt)*) {{$($f:tt)*}$({$($r:tt)*})*} } => {
-    implement!{@build ($($m)*) {$($l)*} {
-      let mut result;
-      let taker = |_state: &str| {
-        let mut state: &str = _state;
+  {@finish ($s:ident $re:ident) (option {$($l:tt)*} ($($t:tt)*) $($m:tt)*) {{$($f:tt)*}$({$($r:tt)*})*} } => {
+    implement!{@build ($s $re) ($($m)*) {$($l)*} {
+      let mut $re;
+      let taker = move |_state| {
+        let mut $s: &str = _state;
         $($f)*
-        Ok(($({$($r)*result}),*))
+        Ok(((
+          $({$($r)*$re}),*
+        ),$s))
       };
-      result = taker(state).ok();
+      match taker($s) {
+        Ok((r,s)) => {
+          $s = s;
+          $re = Some(r);
+        }
+        Err(error) => {
+          $re = None;
+        }
+      }
     } $($t)*}
   };
-  {@finish (vector {$($l:tt)*} ($($t:tt)*) $($m:tt)*) {{$($f:tt)*}$({$($r:tt)*})*} } => {
-    implement!{@build ($($m)*) {$($l)*} {
-      let mut result = Vec::new();
-      let taker = |_state: &str| {
-        let mut state: &str = _state;
+  {@finish ($s:ident $re:ident) (vector {$($l:tt)*} ($($t:tt)*) $($m:tt)*) {{$($f:tt)*}$({$($r:tt)*})*} } => {
+    implement!{@build ($s $re) ($($m)*) {$($l)*} {
+      let mut $re = Vec::new();
+      let taker = move |_state| {
+        let mut $s: &str = _state;
         $($f)*
-        Ok(($({$($r)*result}),*))
+        Ok(((
+          $({$($r)*$re}),*
+        ),$s))
       };
       loop {
-        match taker(state) {
+        match taker($s) {
           Ok((r,s)) => {
-            state = s;
-            result.push(r);
+            $s = s;
+            $re.push(r);
           }
           Err(error) => {
             break;
@@ -121,15 +136,63 @@ macro_rules! implement {
       }
     } $($t)*}
   };
-  {@build $m:tt {$($r:tt)*} $r2:tt} => {
-    implement!{@finish $m {$($r)*$r2}}
+  {@build $va:tt $m:tt {$($r:tt)*} $r2:tt} => {
+    implement!{@finish $va $m {$($r)*$r2}}
   };
-  {@finish (structure $n:ident) {{$($f:tt)*}$({$($r:tt)*})*} } => {
+  {@finish ($s:ident $re:ident) (structure $n:ident) {{$($f:tt)*}$({$($r:tt)*})*} } => {
     impl Parse for $n {
-      fn take(_state: &str) -> Result<(Self, &str), Error> where Self: Sized {
-        let mut state: &str = _state;
+      fn consume(_state: &str) -> Result<(Self, &str), Error> where Self: Sized {
+        let mut $s: &str = _state;
         $($f)*
-        Ok(($n($({$($r)*result.into()}),*),state))
+        Ok((
+          $n($({$($r)*$re.into()}),*),$s
+        ))
+      }
+    }
+  };
+  {@finish ($s:ident $re:ident) (enumeration $m2:ident {$($l:tt)*} ($m:ident ($($t2:tt)*)$($t:tt)*) $n:ident) {$f:tt$({$($r:tt)*})+} } => {
+    implement!{@build ($s $re) (enumeration $m {$($l)*{
+      $f
+      Ok((
+        $n::$m2($({$($r)*$re.into()}),+),$s
+      ))
+    }} ($($t)*) $n) {} {} $($t2)*}
+  };
+  {@finish ($s:ident $re:ident) (enumeration $m3:ident {$($l:tt)*} ($m:ident ($($t2:tt)*)$($t:tt)*) $n:ident) {$f:tt} } => {
+    implement!{@build ($s $re) (enumeration $m {$($l)*{
+      $f
+      Ok((
+        $n::$m3,$s
+      ))
+    }} ($($t)*) $n) {} {} $($t2)*}
+  };
+  {@finish ($s:ident $re:ident) (enumeration $m2:ident {$($l:tt)*} () $n:ident) {$f:tt$({$($r:tt)*})+}} => {
+    implement!{@finish ($s $re) (enumeration {$($l)*{
+      $f
+      Ok((
+        $n::$m2($({$($r)*$re.into()}),+),$s
+      ))
+    }} () $n)} // straight to below
+  };
+  {@finish ($s:ident $re:ident) (enumeration $m2:ident {$($l:tt)*} () $n:ident) {$f:tt}} => {
+    implement!{@finish ($s $re) (enumeration {$($l)*{
+      $f
+      Ok((
+        $n::$m2,$s
+      ))
+    }} () $n)} // straight to below
+  };
+  {@finish ($s:ident $re:ident) (enumeration {$($f:tt)*} () $n:ident)} => {
+    impl Parse for $n {
+      fn consume(_state: &str) -> Result<(Self, &str), Error> where Self: Sized {
+        let mut $s: &str = _state;
+        $(
+        let case = $f;
+        if case.is_ok() {
+          return case;
+        }
+        )*
+        Err("error".into())
       }
     }
   };
@@ -142,6 +205,7 @@ macro_rules! class {
   };
   ($i:ident{$($n:ident($($t:tt)*)),*}) => {
     definition!{@build ($i enumeration new () ($($n($($t)*))*)) () null ()}
+    implement!{@begin $i enumeration ($($n($($t)*))*)}
   }
 }
 macro_rules! parser {
@@ -155,11 +219,20 @@ struct Number(String);
 struct Name(String);
 type Error = String;
 trait Parse {
-  fn take(state: &str) -> Result<(Self, &str), Error>
+  fn consume(state: &str) -> Result<(Self, &str), Error>
   where Self: Sized;
 }
+
+impl Parse for Name {
+  fn consume(state: &str) -> Result<(Self, &str), Error>
+  where
+    Self: Sized
+  {
+    todo!()
+  }
+}
 impl Parse for String {
-  fn take(state: &str) -> Result<(Self, &str), Error>
+  fn consume(state: &str) -> Result<(Self, &str), Error>
   where
     Self: Sized
   {
@@ -167,31 +240,24 @@ impl Parse for String {
   }
 }
 
-fn g() -> Result<Chunk,()> {
-  Ok(Chunk(
+impl Parse for Number {
+  fn consume(state: &str) -> Result<(Self, &str), Error>
+  where
+    Self: Sized
   {
-      if 1 == 2 {
-        Box::new(Block(Vec::new(),None))
-      } else {
-        return Err(())
+    todo!()
   }
 }
-  ))
-}
 
-parser! {
-  Chunk3 ( "Pookie" Block "Dookie" );
-}
-
-parser! {
+parser!(
   Block2 ( {Statement} [Return] );
-}
+);
 
 parser! {
   // LiteralString -> "..."
   // LiteralNumber -> 0x... 123.456
   Chunk ( Block );
-    Block ( {Statement} [Return] );
+  Block ( {Statement} [Return Name] );
   Statement {
     Semicolon (";"),
     Assignment (Variables "=" Expressions),