(parser) add: array subscripts

Author: t-webber

.gitignore

@@ -3,4 +3,5 @@
 *.lock
 *.old
 *.old.*
-!.github
+!.github
+debug.rs

Cargo.toml

@@ -8,9 +8,9 @@ repository = "https://www.github.com/t-webber/ccompiler"
 
 [dependencies]
 
-[[bin]]
-name = "lib"
-path = "src/lib.rs"
+# [[bin]]
+# name = "lib"
+# path = "src/lib.rs"
 
 
 [features]

src/lib.rs

@@ -64,26 +64,3 @@ pub mod prelude {
     pub use crate::lexer::lex_file;
     pub use crate::parser::parse_tokens;
 }
-
-use std::fs;
-
-use errors::location::Location;
-use lexer::lex_file;
-use parser::parse_tokens;
-
-#[expect(clippy::panic, clippy::print_stdout, clippy::use_debug)]
-fn main() {
-    let path = ".files/test.c";
-    let content: &str = &fs::read_to_string(path).unwrap_or_else(|_| {
-        panic!(
-            "The provided path is incorrect. No file found at {}.",
-            &path
-        )
-    });
-    let files: &[(String, &str)] = &[(path.to_owned(), content)];
-    let mut location = Location::from(path);
-    let tokens = lex_file(content, &mut location).unwrap_or_display(files, "lexer");
-    println!("Tokens = \n{:?}", &tokens);
-    let ast = parse_tokens(tokens).unwrap_or_display(files, "parser");
-    println!("Ast = \n{}", &ast);
-}

src/parser/mod.rs

@@ -49,7 +49,7 @@ fn parse_block(
             TokenValue::Symbol(symbol) => {
                 handle_symbol(&symbol, current, p_state, tokens, location)
             }
-            TokenValue::Keyword(_) => todo!(),
+            TokenValue::Keyword(key) => todo!("{key:?}"),
         }
     })
 }

src/parser/state.rs

@@ -1,8 +1,6 @@
 #[derive(Default)]
 pub struct ParsingState {
-    pub parenthesis: usize,
-    pub brackets: usize,
-    pub braces: usize,
     pub ternary: usize,
     pub wanting_colon: bool,
+    pub closing_bracket: bool,
 }

src/parser/symbols.rs

@@ -14,7 +14,7 @@ fn safe_decr(counter: &mut usize, ch: char) -> Result<TodoState, String> {
     *counter = counter
         .checked_sub(1)
         .ok_or_else(|| format!("Mismactched closing '{ch}'"))?;
-    Ok(TodoState::CloseParens)
+    Ok(TodoState::CloseBlock)
 }
 
 fn handle_double_binary(
@@ -39,18 +39,18 @@ fn handle_double_unary(
 // TODO: check for nested
 enum TodoState {
     None,
-    OpenParens,
-    CloseParens,
-    SemiColon,
+    OpenBlock,
     CloseBlock,
+    OpenBracket,
+    CloseBracket,
 }
 
 use {BinaryOperator as BOp, UnaryOperator as UOp};
 
 fn handle_one_symbol(
     symbol: &Symbol,
     current: &mut Node,
-    p_state: &mut ParsingState,
+    p_state: &ParsingState,
 ) -> Result<TodoState, String> {
     #[allow(clippy::enum_glob_use)]
     use Symbol::*;
@@ -104,9 +104,7 @@ fn handle_one_symbol(
         Interrogation => current.push_op(TernaryOperator)?,
 
         Colon => current.handle_colon()?,
-        //
-        SemiColon => return Ok(TodoState::SemiColon),
-        // parenthesis
+        // braces & blocks
         BraceOpen if *current == Node::Empty => *current = Node::Block(vec![]),
         BraceOpen => {
             current.push_block_as_leaf(Node::ListInitialiser(ListInitialiser::default()))?;
@@ -116,12 +114,10 @@ fn handle_one_symbol(
                 return Ok(TodoState::CloseBlock);
             }
         }
-        BracketOpen | BracketClose => todo!(),
-        ParenthesisOpen => {
-            p_state.parenthesis += 1;
-            return Ok(TodoState::OpenParens);
-        }
-        ParenthesisClose => return safe_decr(&mut p_state.parenthesis, ')'),
+        BracketOpen => return Ok(TodoState::OpenBracket),
+        BracketClose => return Ok(TodoState::CloseBracket),
+        ParenthesisOpen => return Ok(TodoState::OpenBlock),
+        SemiColon | ParenthesisClose => return Ok(TodoState::CloseBlock),
     }
     Ok(TodoState::None)
 }
@@ -135,7 +131,7 @@ pub fn handle_symbol(
 ) -> Result<(), CompileError> {
     // TODO: i can't believe this works
     match handle_one_symbol(symbol, current, p_state).map_err(|err| to_error!(location, "{err}"))? {
-        TodoState::OpenParens => {
+        TodoState::OpenBlock => {
             let mut parenthesized_block = Node::Empty;
             parse_block(tokens, p_state, &mut parenthesized_block)?;
             current
@@ -144,6 +140,28 @@ pub fn handle_symbol(
             parse_block(tokens, p_state, current)
         }
         TodoState::None => parse_block(tokens, p_state, current),
-        TodoState::CloseParens | TodoState::CloseBlock | TodoState::SemiColon => Ok(()),
+        TodoState::CloseBlock => Ok(()),
+        TodoState::OpenBracket => {
+            let mut bracket_node = Node::Empty;
+            parse_block(tokens, p_state, &mut bracket_node)?;
+            if p_state.closing_bracket {
+                current
+                    .push_op(BOp::ArraySubscript)
+                    .map_err(|err| to_error!(location, "{err}"))?;
+                current
+                    .push_block_as_leaf(bracket_node)
+                    .map_err(|err| to_error!(location, "{err}"))?;
+                parse_block(tokens, p_state, current)
+            } else {
+                Err(to_error!(
+                    location,
+                    "Expected expression found block, as argument of an array subscript."
+                ))
+            }
+        }
+        TodoState::CloseBracket => {
+            p_state.closing_bracket = true;
+            Ok(())
+        }
     }
 }