(parser) add: control flow support

Author: t-webber

src/parser/keyword/types/attributes.rs src/parser/keyword/attributes.rssrc/parser/keyword/types/attributes.rs renamed to src/parser/keyword/attributes.rs

@@ -2,14 +2,15 @@
 
 use core::fmt;
 
-use super::super::Ast;
-use super::PushInNode;
+use super::super::tree::binary::Binary;
+use super::super::tree::blocks::Block;
+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;
-use crate::parser::tree::binary::Binary;
-use crate::parser::tree::blocks::Block;
-use crate::parser::tree::literal::{Literal, Variable};
-use crate::parser::tree::unary::Unary;
-use crate::parser::tree::{FunctionCall, ListInitialiser, Ternary};
 
 macro_rules! define_attribute_keywords {
     ($($name:ident: $($variant:ident)*,)*) => {
@@ -86,7 +87,7 @@ impl PushInNode for AttributeKeyword {
             Ast::ListInitialiser(ListInitialiser { full: true, .. })
             | Ast::FunctionCall(FunctionCall { full: true, .. }) => {
                 return Err(format!(
-                    "Attributes can only be placed before variables, but found {self}"
+                    "Attribute {self} can only be placed before variables, but found {node}"
                 ));
             }
             Ast::ListInitialiser(ListInitialiser { elts, .. })
@@ -95,6 +96,15 @@ 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/controlflow.rs

@@ -0,0 +1,155 @@
+#![expect(clippy::arbitrary_source_item_ordering)]
+#![allow(
+    clippy::todo,
+    unused_variables,
+    clippy::needless_pass_by_ref_mut,
+    clippy::needless_pass_by_value,
+    reason = "not yet implemented"
+)]
+
+use super::Ast;
+use super::types::PushInNode;
+use crate::parser::tree::blocks::Block;
+
+pub trait ControlFlow {
+    fn is_full(&self) -> bool;
+    fn last(&self) -> Option<&Ast>;
+    fn last_mut(&mut self) -> Option<&mut Ast>;
+}
+
+macro_rules! define_control_flows {
+    ($($pascal:tt,)*) => {
+        #[derive(Debug, PartialEq, Eq)]
+        pub enum ControlFlowKeyword {
+            $($pascal,)*
+        }
+
+        #[derive(Debug, PartialEq)]
+        pub enum ControlFlowNode {
+            $($pascal($pascal),)*
+        }
+
+
+        impl ControlFlow for ControlFlowNode {
+            fn is_full(&self) -> bool {
+                match self {
+                    $(Self::$pascal(val) => val.is_full(),)*
+                }
+            }
+
+            fn last(&self) -> Option<&Ast> {
+                match self {
+                    $(Self::$pascal(val) => val.last(),)*
+                }
+            }
+
+            fn last_mut(&mut self) -> Option<&mut Ast> {
+                match self {
+                    $(Self::$pascal(val) => val.last_mut(),)*
+                }
+            }
+        }
+
+        $(
+            #[derive(Debug, PartialEq)]
+            pub struct $pascal {
+                full: bool,
+                last: Box<Ast>//TODO: this is fake
+            }
+
+            impl ControlFlow for $pascal {
+                fn is_full(&self) -> bool {
+                    self.full
+                }
+
+                fn last(&self) -> Option<&Ast> {
+                    if self.full {
+                        None
+                    } else {
+                        Some(&self.last)
+                    }
+                }
+
+                fn last_mut(&mut self) -> Option<&mut Ast> {
+                    if self.full {
+                        None
+                    } else {
+                        Some(&mut self.last)
+                    }
+                }
+
+
+            }
+        )*
+    };
+}
+
+define_control_flows! {
+    // cases & loops
+    Break,
+    Case,
+    Continue,
+    Default,
+    Do,
+    For,
+    Goto,
+    Switch,
+    While,
+    // condition
+    Else,
+    If,
+    // user defined types
+    Typedef,
+    Struct,
+    Union,
+    Enum,
+    //
+    Return,
+}
+
+impl ControlFlowNode {
+    pub fn push_colon(&mut self) -> Result<(), String> {
+        todo!()
+    }
+    pub fn push_block_as_leaf(&mut self) -> Result<(), String> {
+        todo!()
+    }
+    pub fn push_op<T>(&mut self, op: T) -> Result<(), String> {
+        todo!()
+    }
+}
+
+pub fn is_in_case_context(node: &Ast) -> bool {
+    match node {
+            //
+            //
+            // true
+            Ast::ControlFlow(ControlFlowNode::Case(case)) if !case.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(_)
+            // content is full
+            | Ast::Block(Block { full: true, .. }) => false,
+            //
+            //
+            // recurse
+            Ast::Block(Block { elts, full: false }) => elts.last().is_some_and(is_in_case_context),
+            Ast::ControlFlow(ctrl ) => ctrl.last().is_some_and(is_in_case_context),
+        }
+}
+
+impl PushInNode for ControlFlowKeyword {
+    fn push_in_node(self, node: &mut Ast) -> Result<(), String> {
+        todo!()
+    }
+}

src/parser/keyword/types/functions.rs src/parser/keyword/functions.rssrc/parser/keyword/types/functions.rs renamed to src/parser/keyword/functions.rs

@@ -1,7 +1,7 @@
 use core::fmt;
 
-use super::super::Ast;
-use super::PushInNode;
+use super::Ast;
+use super::types::PushInNode;
 use crate::parser::tree::literal::{Literal, Variable};
 
 #[derive(Debug, PartialEq, Eq)]

src/parser/keyword/mod.rs

@@ -1,9 +1,12 @@
 extern crate alloc;
+pub mod attributes;
+pub mod controlflow;
+pub mod functions;
 pub mod types;
 
 use alloc::vec::IntoIter;
 
-use types::controlflow::ControlFlowKeyword;
+use controlflow::is_in_case_context;
 use types::{KeywordParsing, PushInNode as _};
 
 use super::parse_content::parse_block;
@@ -21,7 +24,7 @@ pub fn handle_keyword(
     tokens: &mut IntoIter<Token>,
     location: Location,
 ) -> Result<(), CompileError> {
-    let case_context = ControlFlowKeyword::is_in_case_context(current);
+    let case_context = is_in_case_context(current);
     let parsed_keyword = KeywordParsing::from((keyword, case_context));
     parsed_keyword
         .push_in_node(current)

src/parser/keyword/types/mod.rs src/parser/keyword/types.rssrc/parser/keyword/types/mod.rs renamed to src/parser/keyword/types.rs

@@ -1,19 +1,7 @@
-#![allow(
-    dead_code,
-    unused_variables,
-    clippy::todo,
-    reason = "not yet implemented"
-)]
-
-pub mod attributes;
-pub mod controlflow;
-pub mod functions;
-
-use attributes::{AttributeKeyword as Attr, UnsortedAttributeKeyword as UnsortedAttr};
-use controlflow::ControlFlowKeyword as CtrlFlow;
-use functions::FunctionKeyword as Func;
-
 use super::super::tree::ast::Ast;
+use super::attributes::{AttributeKeyword as Attr, UnsortedAttributeKeyword as UnsortedAttr};
+use super::controlflow::ControlFlowKeyword as CtrlFlow;
+use super::functions::FunctionKeyword as Func;
 use crate::lexer::api::Keyword;
 use crate::parser::tree::literal::Literal;
 

src/parser/keyword/types/controlflow.rs

@@ -66,6 +66,7 @@ pub fn handle_colon(current: &mut Ast) -> Result<(), String> {
             elts: vec,
             full: false,
         }) => handle_colon(vec.last_mut().expect("Created with one elt")),
+        Ast::ControlFlow(ctrl) => ctrl.push_colon(),
     }
 }