(parser) add: control flow implementation

Author: t-webber

src/parser/keyword/attributes.rs

@@ -8,7 +8,6 @@ use super::super::tree::literal::{Literal, Variable};
 use super::super::tree::unary::Unary;
 use super::super::tree::{FunctionCall, ListInitialiser, Ternary};
 use super::Ast;
-use super::controlflow::ControlFlow as _;
 use super::types::PushInNode;
 use crate::lexer::api::Keyword;
 
@@ -84,8 +83,9 @@ impl PushInNode for AttributeKeyword {
                 }
                 | Ternary { success: arg, .. },
             ) => return self.push_in_node(arg),
-            Ast::ListInitialiser(ListInitialiser { full: true, .. })
-            | Ast::FunctionCall(FunctionCall { full: true, .. }) => {
+            Ast::ControlFlow(_)
+            | Ast::FunctionCall(FunctionCall { full: true, .. })
+            | Ast::ListInitialiser(ListInitialiser { full: true, .. }) => {
                 return Err(format!(
                     "Attribute {self} can only be placed before variables, but found {node}"
                 ));
@@ -96,15 +96,6 @@ impl PushInNode for AttributeKeyword {
                 Some(last) => return self.push_in_node(last),
                 None => elts.push(self.into_node()),
             },
-            Ast::ControlFlow(ctrl) => {
-                return if let Some(last) = ctrl.last_mut() {
-                    self.push_in_node(last)
-                } else {
-                    Err(format!(
-                        "Attribute {self} can only be placed before variables, but found {node}"
-                    ))
-                };
-            }
         }
         Ok(())
     }

src/parser/keyword/control_flow/keyword.rs

@@ -0,0 +1,76 @@
+use core::fmt;
+
+use super::node::ControlFlowNode;
+use crate::parser::tree::ast::Ast;
+
+#[derive(Debug, PartialEq, Eq)]
+pub enum ControlFlowKeyword {
+    // cases & loops
+    Break,
+    Case,
+    Continue,
+    Default,
+    Do,
+    Else,
+    Enum,
+    For,
+    Goto,
+    If,
+    Return,
+    Struct,
+    Switch,
+    Typedef,
+    Union,
+    While,
+}
+
+#[expect(clippy::min_ident_chars)]
+impl fmt::Display for ControlFlowKeyword {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Break => "break".fmt(f),
+            Self::Case => "case".fmt(f),
+            Self::Continue => "continue".fmt(f),
+            Self::Default => "default".fmt(f),
+            Self::Do => "do".fmt(f),
+            Self::Else => "else".fmt(f),
+            Self::Enum => "enum".fmt(f),
+            Self::For => "for".fmt(f),
+            Self::Goto => "goto".fmt(f),
+            Self::If => "if".fmt(f),
+            Self::Return => "return".fmt(f),
+            Self::Struct => "struct".fmt(f),
+            Self::Switch => "switch".fmt(f),
+            Self::Typedef => "typedef".fmt(f),
+            Self::Union => "union".fmt(f),
+            Self::While => "while".fmt(f),
+        }
+    }
+}
+
+impl From<ControlFlowKeyword> for ControlFlowNode {
+    fn from(keyword: ControlFlowKeyword) -> Self {
+        match keyword {
+            ControlFlowKeyword::Break
+            | ControlFlowKeyword::Return
+            | ControlFlowKeyword::Continue => Self::SemiColon(keyword),
+            ControlFlowKeyword::Case | ControlFlowKeyword::Default | ControlFlowKeyword::Goto => {
+                Self::ColonAst(keyword, None)
+            }
+            ControlFlowKeyword::For
+            | ControlFlowKeyword::While
+            | ControlFlowKeyword::Switch
+            | ControlFlowKeyword::If => Self::ParensBlock(keyword, None, None),
+            // block
+            ControlFlowKeyword::Do | ControlFlowKeyword::Else => {
+                Self::Ast(keyword, Box::from(Ast::Empty))
+            }
+            // special
+            ControlFlowKeyword::Typedef => Self::ControlFlow(keyword, None),
+
+            ControlFlowKeyword::Enum | ControlFlowKeyword::Union | ControlFlowKeyword::Struct => {
+                Self::IdentBlock(keyword, None, None)
+            }
+        }
+    }
+}

src/parser/keyword/control_flow/mod.rs

@@ -0,0 +1,49 @@
+pub mod keyword;
+pub mod node;
+
+use keyword::ControlFlowKeyword;
+use node::ControlFlowNode;
+
+use super::Ast;
+use super::types::PushInNode;
+use crate::parser::tree::blocks::Block;
+
+impl PushInNode for ControlFlowKeyword {
+    fn push_in_node(self, node: &mut Ast) -> Result<(), String> {
+        let block = Ast::Block(Block {
+            elts: vec![Ast::ControlFlow(ControlFlowNode::from(self))],
+            full: true,
+        });
+        node.push_braced_block(block);
+        Ok(())
+    }
+}
+
+pub fn is_node_case_context(node: &Ast) -> bool {
+    match node {
+            //
+            //
+            // true
+            Ast::ControlFlow(ctrl) if *ctrl.get_keyword() == ControlFlowKeyword::Case && !ctrl.is_full() => true,
+            //
+            //
+            // false
+            // empty
+            Ast::Empty
+            | Ast::Leaf(_)
+            | Ast::ParensBlock(_)
+            // control flows are not expressions
+            | Ast::Unary(_)
+            | Ast::Binary(_)
+            | Ast::Ternary(_)
+            | Ast::FunctionCall(_)
+            | Ast::ListInitialiser(_) |
+            Ast::ControlFlow(_)
+            // content is full
+            | Ast::Block(Block { full: true, .. }) => false,
+            //
+            //
+            // recurse
+            Ast::Block(Block { elts, full: false }) => elts.last().is_some_and(is_node_case_context),
+        }
+}

src/parser/keyword/control_flow/node.rs

@@ -0,0 +1,86 @@
+use super::keyword::ControlFlowKeyword;
+use crate::parser::tree::ast::{Ast, ParensBlock};
+use crate::parser::tree::blocks::Block;
+
+#[derive(Debug, PartialEq)]
+pub enum ControlFlowNode {
+    Ast(ControlFlowKeyword, Box<Ast>),
+    ColonAst(ControlFlowKeyword, Option<Box<Ast>>),
+    ControlFlow(ControlFlowKeyword, Option<Box<ControlFlowNode>>),
+    IdentBlock(ControlFlowKeyword, Option<String>, Option<Block>),
+    ParensBlock(ControlFlowKeyword, Option<ParensBlock>, Option<Block>),
+    SemiColon(ControlFlowKeyword),
+}
+
+impl ControlFlowNode {
+    pub const fn get_keyword(&self) -> &ControlFlowKeyword {
+        match self {
+            Self::Ast(control_flow_keyword, _)
+            | Self::ColonAst(control_flow_keyword, _)
+            | Self::ControlFlow(control_flow_keyword, _)
+            | Self::IdentBlock(control_flow_keyword, _, _)
+            | Self::ParensBlock(control_flow_keyword, _, _)
+            | Self::SemiColon(control_flow_keyword) => control_flow_keyword,
+        }
+    }
+
+    pub fn is_full(&self) -> bool {
+        match self {
+            Self::Ast(_, ast) => **ast != Ast::Empty,
+            Self::ColonAst(_, ast) => ast.as_ref().is_some_and(|node| **node != Ast::Empty),
+            Self::ControlFlow(_, control_flow_node) => control_flow_node
+                .as_ref()
+                .is_some_and(|node| node.is_full()),
+            Self::IdentBlock(_, ident, block) => ident.is_some() && block.is_some(),
+            Self::ParensBlock(_, parens_block, block) => parens_block.is_some() && block.is_some(),
+            Self::SemiColon(_) => true,
+        }
+    }
+
+    pub fn push_block_as_leaf(&mut self, node: Ast) -> Result<(), String> {
+        #[expect(clippy::wildcard_enum_match_arm)]
+        match self {
+            Self::Ast(_, ast) | Self::ColonAst(_, Some(ast)) if **ast == Ast::Empty => {
+                *ast = Box::new(node);
+            }
+            Self::ColonAst(_, None) => return Err("Missing colon after keyword.".to_owned()),
+            Self::ControlFlow(keyword, old_ctrl @ None) => {
+                if let Ast::ControlFlow(node_ctrl) = node {
+                    *old_ctrl = Some(Box::from(node_ctrl));
+                } else {
+                    return Err(format!("{keyword} expected a keyword but found {node}",));
+                }
+            }
+            Self::ParensBlock(keyword, old_parens @ None, _) => {
+                if let Ast::ParensBlock(node_parens) = node {
+                    *old_parens = Some(node_parens);
+                } else {
+                    return Err(format!(
+                        "{keyword} expected a parenthesised block but found {node}",
+                    ));
+                }
+            }
+            Self::ParensBlock(keyword, _, old_block @ None)
+            | Self::IdentBlock(keyword, _, old_block @ None) => {
+                if let Ast::Block(node_block) = node {
+                    *old_block = Some(node_block);
+                } else {
+                    return Err(format!(
+                        "{keyword} expected a braced block but found {node}",
+                    ));
+                }
+            }
+            _ => panic!("Tried to push not on full block, but it is not pushable"),
+        }
+        Ok(())
+    }
+
+    pub fn push_colon(&mut self) -> Result<(), String> {
+        if let Self::ColonAst(_, node @ None) = self {
+            *node = Some(Box::from(Ast::Empty));
+            Ok(())
+        } else {
+            Err("Found extra colon: illegal in control flow keyword context.".to_owned())
+        }
+    }
+}