Globals work, sizes are no longer part of the grammar

forge_core/src/parser/ast_nodes/global.rs

@@ -6,9 +6,9 @@ impl AstNode for Global {
     fn from_pair(pair: Pair) -> Self {
         let mut inner = pair.into_inner().peekable();
         let name = String::from(inner.next().unwrap().as_str());
-        let size = inner.next().map(Expr::from_pair);
+        let initial = inner.next().map(Expr::from_pair);
 
-        Global { name, size }
+        Global { name, initial }
     }
 }
 
@@ -23,18 +23,18 @@ mod test {
             Global::from_str("global foo;"),
             Ok(Global {
                 name: "foo".into(),
-                size: None,
+                initial: None,
             })
         )
     }
 
     #[test]
-    fn parse_global_arrays() {
+    fn parse_global_vars() {
         assert_eq!(
-            Global::from_str("global foo[10];"),
+            Global::from_str("global foo = 10;"),
             Ok(Global {
                 name: "foo".into(),
-                size: Some(10.into()),
+                initial: Some(10.into()),
             })
         );
     }

forge_core/src/parser/ast_nodes/var_decl.rs

@@ -1,23 +1,14 @@
 use crate::ast::{Expr, VarDecl};
-use crate::parser::{AstNode, Pair, PairExt, PestRule};
+use crate::parser::{AstNode, Pair, PestRule};
 
 impl AstNode for VarDecl {
     const RULE: PestRule = PestRule::var_decl;
     fn from_pair(pair: Pair) -> Self {
         let mut inner = pair.into_inner();
         let name = String::from(inner.next().unwrap().as_str());
-        let mut size = None;
-        let mut initial = None;
+        let initial = inner.next().map(Expr::from_pair);
 
-        for p in inner {
-            match p.as_rule() {
-                PestRule::size => { size = Some(Expr::from_pair(p.first())) }
-                PestRule::expr => { initial = Some(Expr::from_pair(p)) }
-                _ => unreachable!()
-            }
-        }
-
-        Self { name, size, initial }
+        Self { name, initial }
     }
 }
 
@@ -33,7 +24,6 @@ mod test {
             Statement::from_str("var blah;"),
             Ok(Statement::VarDecl(VarDecl {
                 name: "blah".into(),
-                size: None,
                 initial: None,
             }))
         );
@@ -42,10 +32,9 @@ mod test {
     #[test]
     fn parse_var_decl_with_value() {
         assert_eq!(
-            VarDecl::from_str("var blah[7] = 35"),
+            VarDecl::from_str("var blah = 35"),
             Ok(VarDecl {
                 name: "blah".into(),
-                size: Some(7.into()),
                 initial: Some(35.into()),
             })
         );

forge_core/src/parser/forge.pest

@@ -91,7 +91,6 @@ return_stmt = { "return" ~ expr? }
 conditional = { "if" ~ "(" ~ expr ~ ")" ~ block ~ ("else" ~ block)? }
 while_loop  = { "while" ~ "(" ~ expr ~ ")" ~ block }
 repeat_loop = { "repeat" ~ "(" ~ expr ~ ")" ~ name? ~ block }
-var_decl    = { "var" ~ name ~ size? ~ ("=" ~ expr)? }
-global      = { "global" ~ name ~ size? ~ ";" }
-size        = { "[" ~ expr ~ "]" }
+var_decl    = { "var" ~ name ~ ("=" ~ expr)? }
+global      = { "global" ~ name ~ ("=" ~ expr)? ~ ";" }
 const_decl  = { "const" ~ name ~ "=" ~ (string | expr) ~ ";" }