(keywords) add: logic

Author: t-webber

src/parser/keyword/mod.rs

@@ -3,8 +3,10 @@ mod types;
 
 use alloc::vec::IntoIter;
 
-use types::KeywordParsing;
+use types::controlflow::ControlFlowKeyword;
+use types::{KeywordParsing, PushInNode as _};
 
+use super::parse_content::parse_block;
 use super::state::ParsingState;
 use super::tree::node::Ast;
 use crate::errors::api::CompileError;
@@ -14,18 +16,15 @@ use crate::Location;
 #[allow(clippy::todo, reason = "not yet implemented")]
 pub fn handle_keyword(
     keyword: Keyword,
-    _current: &mut Ast,
-    _p_state: &mut ParsingState,
-    _tokens: &mut IntoIter<Token>,
-    _location: Location,
+    current: &mut Ast,
+    p_state: &mut ParsingState,
+    tokens: &mut IntoIter<Token>,
+    location: Location,
 ) -> Result<(), CompileError> {
-    let case_context = true; // node.is_in_case_context();
-    match KeywordParsing::from((keyword, case_context)) {
-        KeywordParsing::Nullptr => todo!(),
-        KeywordParsing::False => todo!(),
-        KeywordParsing::True => todo!(),
-        KeywordParsing::CtrlFlow(_) => todo!(),
-        KeywordParsing::Attr(_) => todo!(),
-        KeywordParsing::Func(_) => todo!(),
-    }
+    let case_context = ControlFlowKeyword::is_in_case_context(current);
+    let parsed_keyword = KeywordParsing::from((keyword, case_context));
+    parsed_keyword
+        .push_in_node(current)
+        .map_err(|msg| location.into_error(msg))?;
+    parse_block(tokens, p_state, current)
 }

src/parser/keyword/types/attributes.rs

@@ -1,13 +1,15 @@
 #![allow(clippy::arbitrary_source_item_ordering)]
 
+use super::super::Ast;
+use super::PushInNode;
+
 macro_rules! define_attribute_keywords {
     ($($name:ident: $($variant:ident)*,)*) => {
 
         pub enum AttributeKeyword {
             $($name($name),)*
         }
 
-
         impl From<UnsortedAttributeKeyword> for AttributeKeyword {
             fn from(value: UnsortedAttributeKeyword) -> Self {
                 match value {
@@ -16,6 +18,12 @@ macro_rules! define_attribute_keywords {
             }
         }
 
+        impl PushInNode for AttributeKeyword {
+            fn push_in_node(self, node: &mut Ast) -> Result<(), String> {
+                todo!()
+            }
+        }
+
         pub enum UnsortedAttributeKeyword {
             $($($variant,)*)*
         }

src/parser/keyword/types/controlflow.rs

@@ -1,3 +1,6 @@
+use super::super::Ast;
+use super::PushInNode;
+
 pub enum ControlFlowKeyword {
     Break,
     Case,
@@ -12,3 +15,15 @@ pub enum ControlFlowKeyword {
     Switch,
     While,
 }
+
+impl ControlFlowKeyword {
+    pub fn is_in_case_context(node: &Ast) -> bool {
+        todo!()
+    }
+}
+
+impl PushInNode for ControlFlowKeyword {
+    fn push_in_node(self, node: &mut Ast) -> Result<(), String> {
+        todo!()
+    }
+}

src/parser/keyword/types/functions.rs

@@ -1,3 +1,9 @@
+use core::fmt;
+
+use super::super::Ast;
+use super::PushInNode;
+use crate::parser::tree::Literal;
+
 pub enum FunctionKeyword {
     Alignof,
     Sizeof,
@@ -7,3 +13,24 @@ pub enum FunctionKeyword {
     UAlignof,
     UThreadLocal,
 }
+
+impl PushInNode for FunctionKeyword {
+    fn push_in_node(self, node: &mut Ast) -> Result<(), String> {
+        node.push_block_as_leaf(Ast::Leaf(Literal::Variable(self.to_string())))
+    }
+}
+
+#[expect(clippy::min_ident_chars)]
+impl fmt::Display for FunctionKeyword {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Alignof => "alignof".fmt(f),
+            Self::Sizeof => "sizeof".fmt(f),
+            Self::StaticAssert => "static_assert".fmt(f),
+            Self::Typeof => "typeof".fmt(f),
+            Self::TypeofUnqual => "typeof_unqual".fmt(f),
+            Self::UAlignof => "u_alignof".fmt(f),
+            Self::UThreadLocal => "u_thread_local".fmt(f),
+        }
+    }
+}

src/parser/keyword/types/mod.rs

@@ -1,14 +1,21 @@
-#![allow(dead_code, reason = "not yet implemented")]
+#![allow(
+    dead_code,
+    unused_variables,
+    clippy::todo,
+    reason = "not yet implemented"
+)]
 
-mod attributes;
-mod controlflow;
-mod functions;
+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::node::Ast;
 use crate::lexer::api::Keyword;
+use crate::parser::tree::Literal;
 
 pub enum KeywordParsing {
     Attr(Attr),
@@ -86,3 +93,20 @@ impl From<(Keyword, bool)> for KeywordParsing {
         }
     }
 }
+
+impl PushInNode for KeywordParsing {
+    fn push_in_node(self, node: &mut Ast) -> Result<(), String> {
+        match self {
+            Self::Func(func) => func.push_in_node(node),
+            Self::Attr(attr) => attr.push_in_node(node),
+            Self::CtrlFlow(ctrl) => ctrl.push_in_node(node),
+            Self::Nullptr => node.push_block_as_leaf(Ast::Leaf(Literal::Nullptr)),
+            Self::True => node.push_block_as_leaf(Ast::Leaf(Literal::ConstantBool(true))),
+            Self::False => node.push_block_as_leaf(Ast::Leaf(Literal::ConstantBool(false))),
+        }
+    }
+}
+
+pub trait PushInNode {
+    fn push_in_node(self, node: &mut Ast) -> Result<(), String>;
+}

src/parser/tree/mod.rs

@@ -97,8 +97,10 @@ impl fmt::Display for ListInitialiser {
 #[derive(Debug, PartialEq, Default)]
 pub enum Literal {
     Char(char),
+    ConstantBool(bool),
     #[default]
     Empty,
+    Nullptr,
     Number(Number),
     Str(String),
     Variable(String),
@@ -107,16 +109,14 @@ pub enum Literal {
 #[expect(clippy::min_ident_chars)]
 impl fmt::Display for Literal {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(
-            f,
-            "{}",
-            match self {
-                Self::Empty => "\u{2205} ".to_owned(),
-                Self::Variable(val) | Self::Str(val) => val.to_string(),
-                Self::Char(val) => val.to_string(),
-                Self::Number(val) => format!("{val}"),
-            }
-        )
+        match self {
+            Self::Empty => "\u{2205} ".fmt(f),
+            Self::Nullptr => "NULL".fmt(f),
+            Self::Char(val) => val.fmt(f),
+            Self::Number(val) => val.fmt(f),
+            Self::ConstantBool(val) => val.fmt(f),
+            Self::Variable(val) | Self::Str(val) => val.fmt(f),
+        }
     }
 }