New grammar, sort of working

forge_core/src/ast.rs

@@ -12,14 +12,14 @@ pub enum Declaration {
 #[derive(PartialEq, Clone, Debug, Default)]
 pub struct Varinfo {
     pub typename: Option<String>,
-    pub size: Option<Node>,
+    pub size: Option<Expr>,
 }
 
 #[derive(PartialEq, Clone, Debug)]
 pub struct Global {
     pub name: String,
     pub typename: Option<String>,
-    pub size: Option<Node>,
+    pub size: Option<Expr>,
 }
 
 #[derive(PartialEq, Clone, Debug)]
@@ -32,13 +32,13 @@ pub struct Struct {
 pub struct Member {
     pub name: String,
     pub typename: Option<String>,
-    pub size: Option<Node>,
+    pub size: Option<Expr>,
 }
 
 #[derive(PartialEq, Clone, Debug)]
 pub struct Const {
     pub name: String,
-    pub value: Option<Node>,
+    pub value: Option<Expr>,
     pub string: Option<String>,
 }
 
@@ -48,9 +48,6 @@ pub struct Block(pub Vec<Statement>);
 #[derive(PartialEq, Clone, Debug)]
 pub struct Function {
     pub name: String,
-    pub org: Option<i32>,
-    pub typename: Option<String>,
-    pub inline: bool,
     pub args: Vec<Argname>,
     pub body: Block,
 }
@@ -65,7 +62,7 @@ pub struct Argname {
 pub enum Statement {
     Return(Return),
     Assignment(Assignment),
-    Call(Call),
+    Expr(Expr),
     VarDecl(VarDecl),
     Conditional(Conditional),
     WhileLoop(WhileLoop),
@@ -73,7 +70,7 @@ pub enum Statement {
 }
 
 #[derive(PartialEq, Clone, Debug)]
-pub struct Return(pub Option<Node>);
+pub struct Return(pub Option<Expr>);
 
 #[derive(PartialEq, Clone, Debug)]
 pub struct Assignment {
@@ -81,12 +78,6 @@ pub struct Assignment {
     pub rvalue: Rvalue,
 }
 
-#[derive(PartialEq, Clone, Debug)]
-pub struct Call {
-    pub name: String,
-    pub args: Vec<Rvalue>,
-}
-
 #[derive(PartialEq, Clone, Debug)]
 pub enum Lvalue {
     ArrayRef(ArrayRef),
@@ -95,7 +86,7 @@ pub enum Lvalue {
 
 #[derive(PartialEq, Clone, Debug)]
 pub enum Rvalue {
-    Expr(Node),
+    Expr(Expr),
     String(String),
 }
 
@@ -103,26 +94,26 @@ pub enum Rvalue {
 pub struct VarDecl {
     pub name: String,
     pub typename: Option<String>,
-    pub size: Option<Node>,
-    pub initial: Option<Node>,
+    pub size: Option<Expr>,
+    pub initial: Option<Expr>,
 }
 
 #[derive(PartialEq, Clone, Debug)]
 pub struct Conditional {
-    pub condition: Node,
+    pub condition: Expr,
     pub body: Block,
     pub alternative: Option<Block>,
 }
 
 #[derive(PartialEq, Clone, Debug)]
 pub struct WhileLoop {
-    pub condition: Node,
+    pub condition: Expr,
     pub body: Block,
 }
 
 #[derive(PartialEq, Clone, Debug)]
 pub struct RepeatLoop {
-    pub count: Node,
+    pub count: Expr,
     pub name: Option<String>,
     pub body: Block,
 }
@@ -154,55 +145,114 @@ pub enum Operator {
 pub enum Prefix {
     Neg,
     Not,
+    Address
+}
+
+#[derive(Debug, PartialEq, Clone)]
+pub enum Suffix {
+    Subscript(Expr),
+    Arglist(Vec<Rvalue>),
+    Member(String),
 }
 
 #[derive(PartialEq, Clone, Debug)]
-pub enum Node {
-    Number(i32),
-    Call(Call),
-    ArrayRef(ArrayRef),
-    Name(String),
-    Address(String),
-    Expr(BoxNode, Operator, BoxNode),
-    Prefix(Prefix, BoxNode),
+pub struct Expr {
+    pub lhs: Val,
+    pub op: Option<Operator>,
+    pub rhs: Option<BoxExpr>,
 }
 
-impl From<i32> for Node {
-    fn from(val: i32) -> Self {
-        Self::Number(val)
+#[derive(PartialEq, Clone, Debug)]
+pub enum Val {
+    Number(i32, Vec<Prefix>, Vec<Suffix>),
+    Name(String, Vec<Prefix>, Vec<Suffix>),
+    Expr(BoxExpr, Vec<Prefix>, Vec<Suffix>),
+}
+
+impl Val {
+    pub fn is_simple(&self) -> bool {
+        if let Self::Expr(expr, pre, suf) = &self {
+            pre.is_empty() && suf.is_empty() && expr.0.op.is_none()
+        } else {
+            false
+        }
+    }
+
+    pub fn inner_expr(self) -> Option<Expr> {
+        if let Self::Expr(expr, _, _) = self {
+            Some(expr.into())
+        } else { None }
     }
 }
 
-impl From<&str> for Node {
+impl From<i32> for Val {
+    fn from(val: i32) -> Self {
+        Self::Number(val, vec![], vec![])
+    }
+}
+
+impl From<&str> for Val {
     fn from(s: &str) -> Self {
-        Self::Name(String::from(s))
+        Self::Name(String::from(s), vec![], vec![])
+    }
+}
+
+impl From<Expr> for Val {
+    fn from(value: Expr) -> Self {
+        Self::Expr(value.into(), vec![], vec![])
+    }
+}
+
+impl From<BoxExpr> for Val {
+    fn from(value: BoxExpr) -> Self {
+        Self::Expr(value, vec![], vec![])
     }
 }
 
 #[repr(transparent)]
 #[derive(PartialEq, Clone, Debug)]
-pub struct BoxNode(pub Box<Node>);
+pub struct BoxExpr(pub Box<Expr>);
 
-impl From<i32> for BoxNode {
+impl From<Val> for Expr {
+    fn from(value: Val) -> Self {
+        Self {
+            lhs: value,
+            op: None,
+            rhs: None
+        }
+    }
+}
+
+impl From<i32> for BoxExpr {
     fn from(val: i32) -> Self {
-        BoxNode(Box::from(Node::Number(val)))
+        BoxExpr(Box::from(Expr::from(Val::from(val))))
     }
 }
 
-impl From<Node> for BoxNode {
-    fn from(val: Node) -> Self {
-        BoxNode(Box::from(val))
+impl From<Expr> for BoxExpr {
+    fn from(val: Expr) -> Self {
+        BoxExpr(Box::from(val))
     }
 }
 
-impl From<BoxNode> for Node {
-    fn from(val: BoxNode) -> Self {
+impl From<BoxExpr> for Expr {
+    fn from(val: BoxExpr) -> Self {
         *(val.0)
     }
 }
 
+impl From<i32> for Expr {
+    fn from(value: i32) -> Self {
+        Self {
+            lhs: Val::Number(value, vec![], vec![]),
+            op: None,
+            rhs: None
+        }
+    }
+}
+
 #[derive(PartialEq, Clone, Debug)]
 pub struct ArrayRef {
     pub name: String,
-    pub subscript: BoxNode,
+    pub subscript: BoxExpr,
 }