(blocks) fix: successive blocks

t-webber · t-webber · commit 1d6640a7e9a9 · 2024-12-26T14:33:24.000+01:00
diff --git a/src/errors/display.rs b/src/errors/display.rs
@@ -16,7 +16,7 @@ pub fn display_errors(errors: Vec<CompileError>, files: &[(String, &str)], err_t
             .expect("Never happens: File of error doesn't exist");
         let code_line = code_lines
             .get(line_nb - 1)
-            .expect("Never happens: given line of file that doesn't exist");
+            .unwrap_or_else(|| panic!("Never happens: given line of file that doesn't exist: {filename}:{line_nb}:{column_nb}"));
         eprintln!("\n{filename}:{line_nb}:{column_nb}: {err_type} {err_lvl}: {message}");
         eprintln!("{line_nb:5} | {code_line}");
         eprintln!("{}^{}", " ".repeat(8 + column_nb - 1), "~".repeat(length));
diff --git a/src/errors/location.rs b/src/errors/location.rs
@@ -20,6 +20,7 @@ impl Location {
 
     pub(crate) fn incr_line(&mut self) {
         self.line += 1;
+        self.col = 1;
     }
 
     pub(crate) fn into_error(self, msg: String) -> CompileError {
@@ -33,11 +34,6 @@ impl Location {
         }
     }
 
-    pub(crate) fn new_line(&mut self) {
-        self.line += 1;
-        self.col = 1;
-    }
-
     pub(crate) fn to_error(&self, msg: String) -> CompileError {
         CompileError::from((self.to_owned(), msg, ErrorLevel::Error))
     }
diff --git a/src/lexer/lex_content.rs b/src/lexer/lex_content.rs
@@ -157,7 +157,7 @@ pub fn lex_file(content: &str, location: &mut Location) -> Res<Vec<Token>> {
 
     for line in content.lines() {
         lex_line(line, location, &mut lex_data, &mut lex_status);
-        location.new_line();
+        location.incr_line();
     }
 
     Res::from((lex_data.take_tokens(), lex_data.take_errors()))
@@ -190,7 +190,6 @@ fn lex_line(
             break;
         }
     }
-    location.incr_line();
     end_current(lex_status, lex_data, location);
     if line.trim_end().ends_with('\\') {
         if line.ends_with(char::is_whitespace) {
diff --git a/src/lexer/mod.rs b/src/lexer/mod.rs
@@ -3,6 +3,7 @@ pub mod api {
 
     pub use super::lex_content::lex_file;
     pub use super::numbers::api::Number;
+    pub use super::types::lexing_data::display_tokens;
     pub use super::types::tokens_types::{Symbol, Token, TokenValue};
 }
 mod end_state;
diff --git a/src/lexer/numbers/base/hexadecimal.rs b/src/lexer/numbers/base/hexadecimal.rs
@@ -123,12 +123,12 @@ fn get_hex_float_state(literal: &str, location: &Location) -> Result<HexFloatPar
             _ if float_parse.state == HexFloatParseState::Exponent => return Err(location.to_error(format!("{ERR_PREFIX}invalid character for exponent. Expected an ascii digit, but found '{ch}'"))),
             _ if ch.is_ascii_hexdigit() => float_parse.push(ch),
             '.' if float_parse.state == HexFloatParseState::Int => float_parse.state = HexFloatParseState::Decimal,
-            '.' if float_parse.state == HexFloatParseState::Decimal  => return Err(location.to_error(format!("{ERR_PREFIX}maximum one '.' in number constant, but 2 were found."))), 
-            '.' if float_parse.state == HexFloatParseState::Exponent  => return Err(location.to_error(format!("{ERR_PREFIX}exponent must be an integer, but found a period."))), 
-            'p' | 'P' if float_parse.state == HexFloatParseState::Exponent => return Err(location.to_error(format!("{ERR_PREFIX}maximum one 'p' in number constant, but 2 were found."))), 
+            '.' if float_parse.state == HexFloatParseState::Decimal  => return Err(location.to_error(format!("{ERR_PREFIX}maximum one '.' in number constant, but 2 were found."))),
+            '.' if float_parse.state == HexFloatParseState::Exponent  => return Err(location.to_error(format!("{ERR_PREFIX}exponent must be an integer, but found a period."))),
+            'p' | 'P' if float_parse.state == HexFloatParseState::Exponent => return Err(location.to_error(format!("{ERR_PREFIX}maximum one 'p' in number constant, but 2 were found."))),
             'p' | 'P'  => float_parse.state = HexFloatParseState::Exponent,
-            _ => return Err(location.to_error(format!("{ERR_PREFIX}invalid character '{ch}' found in number constant"))), 
-        };
+            _ => return Err(location.to_error(format!("{ERR_PREFIX}invalid character '{ch}' found in number constant"))),
+                };
     }
     Ok(float_parse)
 }
diff --git a/src/lexer/numbers/from_literal.rs b/src/lexer/numbers/from_literal.rs
@@ -70,18 +70,20 @@ fn get_number_type(literal: &str, location: &Location) -> Result<NumberType, Com
     for ch in chars {
         match ch {
             'u' | 'U' if unsigned => {
-                return Err(location.to_error("found 2 'u' characters.".to_owned()))
+                return Err(location.to_error("found 2 'u' characters.".to_owned()));
             }
             'u' | 'U' => unsigned = true,
             'l' | 'L' if l_count == 2 => {
                 return Err(location
-                    .to_error("found 3 'l' characters, but max is 2 (`long long`).".to_owned()))
+                    .to_error("found 3 'l' characters, but max is 2 (`long long`).".to_owned()));
             }
             'l' | 'L' => l_count += 1,
             'f' | 'F' if is_hex && !double_or_float => break,
             'f' | 'F' => float = true,
             'i' | 'I' => {
-                return Err(location.to_error("imaginary constants are a GCC extension.".to_owned()))
+                return Err(
+                    location.to_error("imaginary constants are a GCC extension.".to_owned())
+                );
             }
             _ => break,
         }
diff --git a/src/lexer/numbers/types.rs b/src/lexer/numbers/types.rs
@@ -34,7 +34,6 @@ macro_rules! define_nb_types {
             $($t($t),)*
         }
 
-        #[derive(Clone)]
         pub enum NumberType {
             $($t,)*
         }
diff --git a/src/lexer/types/escape_state.rs b/src/lexer/types/escape_state.rs
@@ -1,4 +1,4 @@
-#[derive(Debug, PartialEq, Eq, Clone)]
+#[derive(Debug, PartialEq, Eq)]
 pub enum EscapeSequence {
     Hexadecimal(String),
     Octal(String),
diff --git a/src/lexer/types/lexing_data.rs b/src/lexer/types/lexing_data.rs
@@ -52,3 +52,16 @@ impl LexingData {
         mem::take(&mut self.tokens)
     }
 }
+
+#[must_use]
+#[inline]
+pub fn display_tokens(tokens: &[Token]) -> String {
+    format!(
+        "[{}]",
+        tokens
+            .iter()
+            .map(|x| format!("{x}"))
+            .collect::<Vec<_>>()
+            .join(", ")
+    )
+}
diff --git a/src/lexer/types/lexing_state.rs b/src/lexer/types/lexing_state.rs
@@ -169,7 +169,9 @@ impl SymbolStatus {
         } else if self.third == NULL {
             self.third = value;
         } else {
-            panic!("This is not meant to happen. Called try_operator on none empty self, and no operator was returned. LexingData: {self:?}");
+            panic!(
+                "This is not meant to happen. Called try_operator on none empty self, and no operator was returned. LexingData: {self:?}"
+            );
         }
         op
     }
@@ -229,24 +231,26 @@ impl SymbolStatus {
 
         if let Some((nb_consumed, _)) = &result {
             match *nb_consumed {
-            0 => (), // two consecutive litterals
-            1 => {
-                self.first = self.second;
-                self.second = self.third;
-                self.third = NULL;
-            }
-            2 => {
-                self.first = self.third;
-                self.second = NULL;
-                self.third = NULL;
-            }
-            3 => {
-                self.first = NULL;
-                self.second = NULL;
-                self.third = NULL;
-            }
-            _ => panic!("his is not meant to happen. nb_consumed is defined only be having values of 0, 1, 2 or 3, not {nb_consumed}"),
-        };
+                0 => (), // two consecutive litterals
+                1 => {
+                    self.first = self.second;
+                    self.second = self.third;
+                    self.third = NULL;
+                }
+                2 => {
+                    self.first = self.third;
+                    self.second = NULL;
+                    self.third = NULL;
+                }
+                3 => {
+                    self.first = NULL;
+                    self.second = NULL;
+                    self.third = NULL;
+                }
+                _ => panic!(
+                    "his is not meant to happen. nb_consumed is defined only be having values of 0, 1, 2 or 3, not {nb_consumed}"
+                ),
+            };
         };
         result
     }
diff --git a/src/lexer/types/tokens_types.rs b/src/lexer/types/tokens_types.rs
@@ -58,6 +58,7 @@ pub enum Symbol {
     ShiftRightAssign,
 }
 
+#[derive(Debug)]
 pub struct Token {
     location: Location,
     value: TokenValue,
@@ -115,14 +116,14 @@ impl Token {
 }
 
 #[expect(clippy::min_ident_chars)]
-impl fmt::Debug for Token {
+impl fmt::Display for Token {
     #[inline]
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         self.value.fmt(f)
     }
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(PartialEq, Debug)]
 pub enum TokenValue {
     Char(char),
     Identifier(String),
@@ -131,3 +132,31 @@ pub enum TokenValue {
     Str(String),
     Symbol(Symbol),
 }
+
+impl TokenValue {
+    pub(self) const fn type_name(&self) -> &'static str {
+        match self {
+            Self::Char(_) => "Char",
+            Self::Identifier(_) => "Ident",
+            Self::Keyword(_) => "Keywd",
+            Self::Str(_) => "Str",
+            Self::Number(_) | Self::Symbol(_) => "\0",
+        }
+    }
+}
+
+#[expect(clippy::min_ident_chars)]
+impl fmt::Display for TokenValue {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Char(arg0) => f.debug_tuple(self.type_name()).field(arg0).finish(),
+            Self::Keyword(arg0) => f.debug_tuple(self.type_name()).field(arg0).finish(),
+            Self::Number(arg0) => f.debug_tuple(self.type_name()).field(arg0).finish(),
+            Self::Symbol(arg0) => f.debug_tuple(self.type_name()).field(arg0).finish(),
+            Self::Identifier(arg0) | Self::Str(arg0) => {
+                f.debug_tuple(self.type_name()).field(arg0).finish()
+            }
+        }
+    }
+}
diff --git a/src/lib.rs b/src/lib.rs
@@ -55,7 +55,7 @@ pub mod api {
     #![allow(clippy::pub_use, unused_imports)]
 
     pub use crate::errors::api::{Location, Res};
-    pub use crate::lexer::api::{lex_file, Number, TokenValue};
+    pub use crate::lexer::api::{display_tokens, lex_file, Number, TokenValue};
     pub use crate::parser::api::parse_tokens;
 }
 
diff --git a/src/parser/parse_content.rs b/src/parser/parse_content.rs
@@ -3,6 +3,7 @@ use alloc::vec::IntoIter;
 
 use super::state::ParsingState;
 use super::symbols::handle_symbol;
+use super::tree::blocks::Block;
 use super::tree::node::Node;
 use super::tree::Literal;
 use crate::errors::api::{CompileError, Location, Res};
@@ -16,7 +17,10 @@ fn clean_nodes(nodes: Vec<Node>) -> Node {
     if cleaned.len() == 1 {
         cleaned.pop().expect("len == 1")
     } else {
-        Node::Block(cleaned)
+        Node::Block(Block {
+            elts: cleaned,
+            full: true,
+        })
     }
 }
 
@@ -39,6 +43,7 @@ pub fn parse_block(
     current: &mut Node,
 ) -> Result<(), CompileError> {
     tokens.next().map_or(Ok(()), |token| {
+        println!("token = {token}\t\tCurrent = {current}");
         let (value, location) = token.into_value_location();
         match value {
             TokenValue::Char(ch) => {
diff --git a/src/parser/state.rs b/src/parser/state.rs
@@ -1,11 +1,11 @@
 #[derive(PartialEq, Eq, Debug)]
-pub enum Block {
+pub enum BlockState {
     Brace,
     Bracket,
     Parenthesis,
 }
 
 #[derive(Default, Debug)]
 pub struct ParsingState {
-    pub opened_blocks: Vec<Block>,
+    pub opened_blocks: Vec<BlockState>,
 }
diff --git a/src/parser/symbols/blocks.rs b/src/parser/symbols/blocks.rs
diff --git a/src/parser/symbols/one_symbol.rs b/src/parser/symbols/one_symbol.rs
diff --git a/src/parser/tree/blocks.rs b/src/parser/tree/blocks.rs
diff --git a/src/parser/tree/mod.rs b/src/parser/tree/mod.rs
diff --git a/src/parser/tree/node.rs b/src/parser/tree/node.rs
diff --git a/tests/numbers.rs b/tests/numbers.rs
diff --git a/tests/parser.rs b/tests/parser.rs

Original file line number	Diff line number	Diff line change
`@@ -20,6 +20,7 @@ impl Location {`
`20`	`20`
`21`	`21`	`pub(crate) fn incr_line(&mut self) {`
`22`	`22`	`self.line += 1;`
	`23`	`+ self.col = 1;`
`23`	`24`	`}`
`24`	`25`
`25`	`26`	`pub(crate) fn into_error(self, msg: String) -> CompileError {`
`@@ -33,11 +34,6 @@ impl Location {`
`33`	`34`	`}`
`34`	`35`	`}`
`35`	`36`
`36`		`- pub(crate) fn new_line(&mut self) {`
`37`		`- self.line += 1;`
`38`		`- self.col = 1;`
`39`		`- }`
`40`		`-`
`41`	`37`	`pub(crate) fn to_error(&self, msg: String) -> CompileError {`
`42`	`38`	`CompileError::from((self.to_owned(), msg, ErrorLevel::Error))`
`43`	`39`	`}`
Original file line number	Diff line number	Diff line change
`@@ -157,7 +157,7 @@ pub fn lex_file(content: &str, location: &mut Location) -> Res<Vec<Token>> {`
`157`	`157`
`158`	`158`	`for line in content.lines() {`
`159`	`159`	`lex_line(line, location, &mut lex_data, &mut lex_status);`
`160`		`- location.new_line();`
	`160`	`+ location.incr_line();`
`161`	`161`	`}`
`162`	`162`
`163`	`163`	`Res::from((lex_data.take_tokens(), lex_data.take_errors()))`
`@@ -190,7 +190,6 @@ fn lex_line(`
`190`	`190`	`break;`
`191`	`191`	`}`
`192`	`192`	`}`
`193`		`- location.incr_line();`
`194`	`193`	`end_current(lex_status, lex_data, location);`
`195`	`194`	`if line.trim_end().ends_with('\\') {`
`196`	`195`	`if line.ends_with(char::is_whitespace) {`
Original file line number	Diff line number	Diff line change
`@@ -3,6 +3,7 @@ pub mod api {`
`3`	`3`
`4`	`4`	`pub use super::lex_content::lex_file;`
`5`	`5`	`pub use super::numbers::api::Number;`
	`6`	`+ pub use super::types::lexing_data::display_tokens;`
`6`	`7`	`pub use super::types::tokens_types::{Symbol, Token, TokenValue};`
`7`	`8`	`}`
`8`	`9`	`mod end_state;`
Original file line number	Diff line number	Diff line change
`@@ -70,18 +70,20 @@ fn get_number_type(literal: &str, location: &Location) -> Result<NumberType, Com`
`70`	`70`	`for ch in chars {`
`71`	`71`	`match ch {`
`72`	`72`	`'u' \| 'U' if unsigned => {`
`73`		`- return Err(location.to_error("found 2 'u' characters.".to_owned()))`
	`73`	`+ return Err(location.to_error("found 2 'u' characters.".to_owned()));`
`74`	`74`	`}`
`75`	`75`	`'u' \| 'U' => unsigned = true,`
`76`	`76`	`'l' \| 'L' if l_count == 2 => {`
`77`	`77`	`return Err(location`
`78`		- .to_error("found 3 'l' characters, but max is 2 (`long long`).".to_owned()))
	`78`	+ .to_error("found 3 'l' characters, but max is 2 (`long long`).".to_owned()));
`79`	`79`	`}`
`80`	`80`	`'l' \| 'L' => l_count += 1,`
`81`	`81`	`'f' \| 'F' if is_hex && !double_or_float => break,`
`82`	`82`	`'f' \| 'F' => float = true,`
`83`	`83`	`'i' \| 'I' => {`
`84`		`- return Err(location.to_error("imaginary constants are a GCC extension.".to_owned()))`
	`84`	`+ return Err(`
	`85`	`+ location.to_error("imaginary constants are a GCC extension.".to_owned())`
	`86`	`+ );`
`85`	`87`	`}`
`86`	`88`	`_ => break,`
`87`	`89`	`}`
Original file line number	Diff line number	Diff line change
`@@ -34,7 +34,6 @@ macro_rules! define_nb_types {`
`34`	`34`	`$($t($t),)*`
`35`	`35`	`}`
`36`	`36`
`37`		`- #[derive(Clone)]`
`38`	`37`	`pub enum NumberType {`
`39`	`38`	`$($t,)*`
`40`	`39`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-#[derive(Debug, PartialEq, Eq, Clone)]`
	`1`	`+#[derive(Debug, PartialEq, Eq)]`
`2`	`2`	`pub enum EscapeSequence {`
`3`	`3`	`Hexadecimal(String),`
`4`	`4`	`Octal(String),`