handle the nesting comments

Author: orcalinux

scanner/build/scanner_test

@@ -105,13 +105,16 @@ namespace TINY
             void skipWhitespace();
 
             /**
-             * @brief Skips over comments in the input source code.
+             * @brief Skips over nested comments in the input source code.
              *
              * This method checks if the current position is at the start of a comment (indicated by a '{' character).
              * If it is, the method skips over all characters until it finds the corresponding closing '}'.
+             * It correctly handles **nested comments** by keeping track of the nesting levels.
+             * For each opening '{', it increases the nesting level, and for each closing '}', it decreases the nesting level.
+             * The comment is considered closed when the nesting level returns to zero.
              * After successfully skipping a comment, it also skips any whitespace characters that follow the comment.
-             * If the end of the input is reached before finding a closing '}', the method returns `true` to indicate
-             * that an unclosed comment was detected.
+             * If the end of the input is reached before all comments are closed (i.e., nesting level does not return to zero),
+             * the method returns `true` to indicate that an unclosed comment was detected.
              *
              * @return True if an unclosed comment was detected, false otherwise.
              */

scanner/include/scanner.hpp

@@ -10,6 +10,7 @@
 #include "scanner.hpp"
 #include <cctype>    // For character classification functions
 #include <stdexcept> // For exception handling (if needed)
+#include <stack>
 
 namespace TINY
 {
@@ -184,23 +185,39 @@ namespace TINY
         {
             if (pos < input.size() && peek() == '{')
             {
-                get(); // Consume '{'
-                while (pos < input.size() && peek() != '}')
-                {
-                    get(); // Consume characters inside the comment
-                }
-                if (pos < input.size())
-                {
-                    get();            // Consume '}'
-                    skipWhitespace(); // Skip any whitespace after the comment
-                    return false;     // Comment was successfully skipped
-                }
-                else
+                get(); // Consume initial '{'
+                std::stack<char> commentStack;
+                commentStack.push('{'); // Push the initial '{' onto the stack
+
+                while (pos < input.size())
                 {
-                    // EOF reached before closing '}'
-                    // Unclosed comment detected
-                    return true;
+                    char currentChar = get();
+
+                    if (currentChar == '{')
+                    {
+                        commentStack.push('{'); // Push nested '{' onto the stack
+                    }
+                    else if (currentChar == '}')
+                    {
+                        commentStack.pop(); // Pop a '{' from the stack
+
+                        if (commentStack.empty())
+                        {
+                            // All comments are closed
+                            skipWhitespace(); // Skip whitespace after comment
+                            return false;     // Comment was successfully skipped
+                        }
+                    }
+                    else if (currentChar == '\0')
+                    {
+                        // End of input reached unexpectedly
+                        return true; // Unclosed comment detected
+                    }
+                    // Continue consuming characters inside the comment
                 }
+
+                // EOF reached before all comments were closed
+                return true; // Unclosed comment detected
             }
             return false; // No comment to skip
         }

scanner/src/scanner.cpp

@@ -294,5 +294,78 @@ namespace TINY
             EXPECT_FALSE(scanner.hasMoreTokens());
         }
 
+        // New test case: Nested comments
+        TEST(ScannerTest, NestedComments)
+        {
+            // Input with nested comments
+            std::string input = "read x; { This is a { nested { comment } } } write y;";
+
+            Scanner scanner(input);
+
+            // Token: read
+            Token token1 = scanner.getNextToken();
+            EXPECT_EQ(token1.getType(), TokenType::READ);
+            EXPECT_EQ(token1.getValue(), "read");
+
+            // Token: x
+            Token token2 = scanner.getNextToken();
+            EXPECT_EQ(token2.getType(), TokenType::IDENTIFIER);
+            EXPECT_EQ(token2.getValue(), "x");
+
+            // Token: ;
+            Token token3 = scanner.getNextToken();
+            EXPECT_EQ(token3.getType(), TokenType::SEMICOLON);
+            EXPECT_EQ(token3.getValue(), ";");
+
+            // Nested comments are skipped, no tokens generated for them
+
+            // Token: write
+            Token token4 = scanner.getNextToken();
+            EXPECT_EQ(token4.getType(), TokenType::WRITE);
+            EXPECT_EQ(token4.getValue(), "write");
+
+            // Token: y
+            Token token5 = scanner.getNextToken();
+            EXPECT_EQ(token5.getType(), TokenType::IDENTIFIER);
+            EXPECT_EQ(token5.getValue(), "y");
+
+            // Token: ;
+            Token token6 = scanner.getNextToken();
+            EXPECT_EQ(token6.getType(), TokenType::SEMICOLON);
+            EXPECT_EQ(token6.getValue(), ";");
+
+            EXPECT_FALSE(scanner.hasMoreTokens());
+        }
+
+        // New test case: Unclosed nested comment
+        TEST(ScannerTest, UnclosedNestedComment)
+        {
+            // Input with an unclosed nested comment
+            std::string input = "read x; { Outer comment { Inner comment } write y;";
+
+            Scanner scanner(input);
+
+            // Token: read
+            Token token1 = scanner.getNextToken();
+            EXPECT_EQ(token1.getType(), TokenType::READ);
+            EXPECT_EQ(token1.getValue(), "read");
+
+            // Token: x
+            Token token2 = scanner.getNextToken();
+            EXPECT_EQ(token2.getType(), TokenType::IDENTIFIER);
+            EXPECT_EQ(token2.getValue(), "x");
+
+            // Token: ;
+            Token token3 = scanner.getNextToken();
+            EXPECT_EQ(token3.getType(), TokenType::SEMICOLON);
+            EXPECT_EQ(token3.getValue(), ";");
+
+            // Attempt to get next token, should return UNKNOWN due to unclosed comment
+            Token token4 = scanner.getNextToken();
+            EXPECT_EQ(token4.getType(), TokenType::UNKNOWN);
+            EXPECT_EQ(token4.getValue(), "Unclosed comment");
+
+            EXPECT_FALSE(scanner.hasMoreTokens());
+        }
     } // namespace SCANNER
 } // namespace TINY

scanner/test/scanner_test.cpp

@@ -25,6 +25,5 @@ namespace TINY
             EXPECT_EQ(token.toString(false), "if, IF");
             EXPECT_EQ(token.toString(true), "if, IF [Line: 1, Column: 1]");
         }
-
     } // namespace SCANNER
 } // namespace TINY