refactor(Errors): encapsulate and cleanup error logging

Dimitry-bit · Dimitry-bit · commit 27ac9e7b2538 · 2024-12-24T06:17:30.000+02:00
diff --git a/src/TinyCompiler/Compiler.cs b/src/TinyCompiler/Compiler.cs
@@ -1,4 +1,4 @@
-﻿using System.Collections.Generic;
+using System.Collections.Generic;
 
 namespace TinyCompiler
 {
@@ -9,23 +9,23 @@ public static class Compiler
 
         public static void Compile(string sourceCode)
         {
-            Errors.Error_List.Clear();
+            Errors.Clear();
             TokenStream.Clear();
             treeRoot = null;
 
             //Scanner
             Scanner scanner = new Scanner(sourceCode);
             TokenStream = scanner.Scan();
             if (Errors.HasError()) {
-                Errors.Error_List.Add($"Compilation failed, found {Errors.Error_List.Count} error{(Errors.Error_List.Count == 1 ? "" : "s")}.");
+                Errors.ReportError($"========== compile: {Errors.Count()} lex error ==========");
                 return;
             }
 
             //Parser
             Parser parser = new Parser(TokenStream);
             treeRoot = parser.Parse();
             if (Errors.HasError()) {
-                Errors.Error_List.Add($"Compilation failed, found {Errors.Error_List.Count} error{(Errors.Error_List.Count == 1 ? "" : "s")}.");
+                Errors.ReportError($"========== compile: {Errors.Count()} parse error ==========");
                 return;
             }
 
diff --git a/src/TinyCompiler/Errors.cs b/src/TinyCompiler/Errors.cs
@@ -5,13 +5,21 @@ namespace TinyCompiler
 {
     public static class Errors
     {
-        public static List<string> Error_List = new List<string>();
+        private static readonly List<string> ErrorList = new List<string>();
 
-        public static void Add(int lineNumber, string msg)
+        public static List<string> GetAll() => ErrorList;
+
+        public static int Count() => ErrorList.Count();
+
+        public static bool HasError() => ErrorList.Any();
+
+        public static void Clear() => ErrorList.Clear();
+
+        public static void ReportError(string msg) => ErrorList.Add(msg);
+
+        public static void ReportError(int lineNumber, string msg)
         {
-            Error_List.Add($"[Line {lineNumber}]: {msg}.");
+            ReportError($"line:{lineNumber}: error: {msg}");
         }
-
-        public static bool HasError() => Error_List.Any();
     }
 }
diff --git a/src/TinyCompiler/Parser.cs b/src/TinyCompiler/Parser.cs
@@ -58,14 +58,17 @@ private Node Program() {
                 // Add main function
                 if (IsAtEnd())
                 {
-                    Error(PreviousToken(), "Expected main function.");
+                    Error(PreviousToken(), "expected main function");
                 }
                 else
                 {
                     n.Children.Add(Func());
                 }
             }
-            catch (ParseError) { }
+            catch (ParseError)
+            {
+                Errors.ReportError("parser: found fatal error... stopping");
+            }
 
             return n;
         }
@@ -84,7 +87,7 @@ private Node FuncDecl() {
 
             n.Children.Add(Datatype());
             n.Children.Add(Consume(TokenClass.Identifier));
-            n.Children.Add(Consume(TokenClass.LeftParen, "Expect '(' after function name."));
+            n.Children.Add(Consume(TokenClass.LeftParen, "expected '(' after function name"));
 
             Node parameters = new Node("Parameters");
             while (!Check(TokenClass.RightParen))
@@ -93,12 +96,12 @@ private Node FuncDecl() {
 
                 if (!Check(TokenClass.RightParen))
                 {
-                    parameters.Children.Add(Consume(TokenClass.Comma, "Expect ',' between parameters."));
+                    parameters.Children.Add(Consume(TokenClass.Comma, "expected ',' between parameters"));
                 }
             }
             n.Children.Add(parameters);
 
-            n.Children.Add(Consume(TokenClass.RightParen, "Expect ')' after parameters."));
+            n.Children.Add(Consume(TokenClass.RightParen, "expected ')' after parameters"));
 
             return n;
         }
@@ -107,27 +110,27 @@ private Node Param() {
             Node n = new Node("Parameter");
 
             n.Children.Add(Datatype());
-            n.Children.Add(Consume(TokenClass.Identifier, "Expect parameter name."));
+            n.Children.Add(Consume(TokenClass.Identifier, "expected parameter name"));
 
             return n;
         }
 
         private Node FuncBody() {
             Node n = new Node("Function Body");
 
-            n.Children.Add(Consume(TokenClass.LeftBrace, "Expect '{' before function body."));
+            n.Children.Add(Consume(TokenClass.LeftBrace, "expected '{' before function body"));
             n.Children.Add(Stmts());
             n.Children.Add(RetStmt());
-            n.Children.Add(Consume(TokenClass.RightBrace, "Expect '}' after function body."));
+            n.Children.Add(Consume(TokenClass.RightBrace, "expected '}' after function body"));
 
             return n;
         }
 
         private Node FuncCall() {
             Node n = new Node("Function Call");
 
-            n.Children.Add(Consume(TokenClass.Identifier, "Expect function name."));
-            n.Children.Add(Consume(TokenClass.LeftParen, "Expect '(' after function name."));
+            n.Children.Add(Consume(TokenClass.Identifier, "expected function name"));
+            n.Children.Add(Consume(TokenClass.LeftParen, "expected '(' after function name"));
 
             Node args = new Node("Arguments");
             while (!Check(TokenClass.RightParen))
@@ -136,12 +139,12 @@ private Node FuncCall() {
 
                 if (!Check(TokenClass.RightParen))
                 {
-                    args.Children.Add(Consume(TokenClass.Comma, "Expect ',' between arguments."));
+                    args.Children.Add(Consume(TokenClass.Comma, "expected ',' between arguments"));
                 }
             }
             n.Children.Add(args);
 
-            n.Children.Add(Consume(TokenClass.RightParen, "Expect ')' after arguments."));
+            n.Children.Add(Consume(TokenClass.RightParen, "expected ')' after arguments"));
 
             return n;
         }
@@ -161,7 +164,7 @@ private Node Datatype() {
                 return n;
             }
 
-            throw Error(Peek(), "Expected 'int', 'float', or 'string'.");
+            throw Error(Peek(), "expected 'int', 'float', or 'string'");
         }
 
         private Node Stmt() {
@@ -198,7 +201,7 @@ private Node Stmt() {
                         n.Children.Add(Consume(TokenClass.Semicolon));
                         break;
                     default:
-                        throw Error(Peek(), "Expect statement.");
+                        throw Error(Peek(), "expected statement");
                         break;
                 }
 
@@ -358,7 +361,7 @@ private Node Cond() {
             }
             else
             {
-                Error(Peek(), "Expected conditional operator.");
+                Error(Peek(), "expected '<', '>', '<>', or '=' operator");
             }
             n.Children.Add(Expr());
 
@@ -470,7 +473,7 @@ private Node Factor()
             }
             else
             {
-                Error(Peek(), "Expected number, string, identifier, or (expression).");
+                Error(Peek(), "expected number, string, identifier, or (expression)");
             }
 
             return n;
@@ -595,18 +598,18 @@ private Node Consume(TokenClass type, string message)
 
         private Node Consume(TokenClass type)
         {
-            return Consume(type, $"Expected '{type.ToString().ToLowerInvariant()}'.");
+            return Consume(type, $"expected '{type.ToString().ToLowerInvariant()}'");
         }
 
         private ParseError Error(Token token, string message)
         {
             if (IsAtEnd())
             {
-                Errors.Error_List.Add($"[line {token.line}] Error at end: {message}");
+                Errors.ReportError(token.line, $"at end: {message}");
             }
             else
             {
-                Errors.Error_List.Add($"[line {token.line}] Error: at '{token.lex}': {message}");
+                Errors.ReportError(token.line, $"at '{token.lex}': {message}");
             }
 
             return new ParseError();
diff --git a/src/TinyCompiler/Scanner.cs b/src/TinyCompiler/Scanner.cs
@@ -131,7 +131,7 @@ public List<Token> Scan()
                         }
                         else
                         {
-                            Errors.Add(_linenumber, $"unexpected lexeme '{c}'");
+                            Errors.ReportError(_linenumber, $"unexpected lexeme '{c}'");
                         }
                         break;
                 }
@@ -163,7 +163,7 @@ private void ReadNumber()
                     Read();
             } else if (char.IsLetter(Peek())) {
                 Read();
-                Errors.Add(_linenumber, "illegal identifier");
+                Errors.ReportError(_linenumber, "illegal identifier");
                 return;
             }
 
@@ -188,7 +188,7 @@ private void ReadString()
             if (Match('"'))
                 AddToken(TokenClass.StringLiteral);
             else
-                Errors.Add(_linenumber, "unterminated string, expected '\"'");
+                Errors.ReportError(_linenumber, "unterminated string, expected '\"'");
         }
 
         private void ReadComment()
@@ -209,7 +209,7 @@ private void ReadComment()
             if (Peek() == '/')
                 Read();
             else
-                Errors.Add(_linenumber, "unterminated comment, expected '*/'");
+                Errors.ReportError(_linenumber, "unterminated comment, expected '*/'");
         }
 
         private void AddToken(TokenClass type)
diff --git a/src/TinyCompiler/WindowForm.cs b/src/TinyCompiler/WindowForm.cs
@@ -58,10 +58,7 @@ private void PopulateTokensTable()
         private void PrintErrors()
         {
             tfErrors.Clear();
-            foreach (var error in Errors.Error_List)
-            {
-                tfErrors.Text += error + "\r\n";
-            }
+            tfErrors.Text = string.Join("\r\n", Errors.GetAll());
         }
 
         private void PopulateParseTree()
@@ -80,7 +77,7 @@ private void btnClear_Click(object sender, System.EventArgs e)
 
             // Reset Global Data
             Compiler.TokenStream.Clear();
-            Errors.Error_List.Clear();
+            Errors.Clear();
         }
 
         private static TreeNode PrintParaseTree(Node root)

Original file line number	Diff line number	Diff line change
`@@ -5,13 +5,21 @@ namespace TinyCompiler`
`5`	`5`	`{`
`6`	`6`	`public static class Errors`
`7`	`7`	`{`
`8`		`- public static List<string> Error_List = new List<string>();`
	`8`	`+ private static readonly List<string> ErrorList = new List<string>();`
`9`	`9`
`10`		`- public static void Add(int lineNumber, string msg)`
	`10`	`+ public static List<string> GetAll() => ErrorList;`
	`11`	`+`
	`12`	`+ public static int Count() => ErrorList.Count();`
	`13`	`+`
	`14`	`+ public static bool HasError() => ErrorList.Any();`
	`15`	`+`
	`16`	`+ public static void Clear() => ErrorList.Clear();`
	`17`	`+`
	`18`	`+ public static void ReportError(string msg) => ErrorList.Add(msg);`
	`19`	`+`
	`20`	`+ public static void ReportError(int lineNumber, string msg)`
`11`	`21`	`{`
`12`		`- Error_List.Add($"[Line {lineNumber}]: {msg}.");`
	`22`	`+ ReportError($"line:{lineNumber}: error: {msg}");`
`13`	`23`	`}`
`14`		`-`
`15`		`- public static bool HasError() => Error_List.Any();`
`16`	`24`	`}`
`17`	`25`	`}`
Original file line number	Diff line number	Diff line change
`@@ -58,14 +58,17 @@ private Node Program() {`
`58`	`58`	`// Add main function`
`59`	`59`	`if (IsAtEnd())`
`60`	`60`	`{`
`61`		`- Error(PreviousToken(), "Expected main function.");`
	`61`	`+ Error(PreviousToken(), "expected main function");`
`62`	`62`	`}`
`63`	`63`	`else`
`64`	`64`	`{`
`65`	`65`	`n.Children.Add(Func());`
`66`	`66`	`}`
`67`	`67`	`}`
`68`		`- catch (ParseError) { }`
	`68`	`+ catch (ParseError)`
	`69`	`+ {`
	`70`	`+ Errors.ReportError("parser: found fatal error... stopping");`
	`71`	`+ }`
`69`	`72`
`70`	`73`	`return n;`
`71`	`74`	`}`
`@@ -84,7 +87,7 @@ private Node FuncDecl() {`
`84`	`87`
`85`	`88`	`n.Children.Add(Datatype());`
`86`	`89`	`n.Children.Add(Consume(TokenClass.Identifier));`
`87`		`- n.Children.Add(Consume(TokenClass.LeftParen, "Expect '(' after function name."));`
	`90`	`+ n.Children.Add(Consume(TokenClass.LeftParen, "expected '(' after function name"));`
`88`	`91`
`89`	`92`	`Node parameters = new Node("Parameters");`
`90`	`93`	`while (!Check(TokenClass.RightParen))`
`@@ -93,12 +96,12 @@ private Node FuncDecl() {`
`93`	`96`
`94`	`97`	`if (!Check(TokenClass.RightParen))`
`95`	`98`	`{`
`96`		`- parameters.Children.Add(Consume(TokenClass.Comma, "Expect ',' between parameters."));`
	`99`	`+ parameters.Children.Add(Consume(TokenClass.Comma, "expected ',' between parameters"));`
`97`	`100`	`}`
`98`	`101`	`}`
`99`	`102`	`n.Children.Add(parameters);`
`100`	`103`
`101`		`- n.Children.Add(Consume(TokenClass.RightParen, "Expect ')' after parameters."));`
	`104`	`+ n.Children.Add(Consume(TokenClass.RightParen, "expected ')' after parameters"));`
`102`	`105`
`103`	`106`	`return n;`
`104`	`107`	`}`
`@@ -107,27 +110,27 @@ private Node Param() {`
`107`	`110`	`Node n = new Node("Parameter");`
`108`	`111`
`109`	`112`	`n.Children.Add(Datatype());`
`110`		`- n.Children.Add(Consume(TokenClass.Identifier, "Expect parameter name."));`
	`113`	`+ n.Children.Add(Consume(TokenClass.Identifier, "expected parameter name"));`
`111`	`114`
`112`	`115`	`return n;`
`113`	`116`	`}`
`114`	`117`
`115`	`118`	`private Node FuncBody() {`
`116`	`119`	`Node n = new Node("Function Body");`
`117`	`120`
`118`		`- n.Children.Add(Consume(TokenClass.LeftBrace, "Expect '{' before function body."));`
	`121`	`+ n.Children.Add(Consume(TokenClass.LeftBrace, "expected '{' before function body"));`
`119`	`122`	`n.Children.Add(Stmts());`
`120`	`123`	`n.Children.Add(RetStmt());`
`121`		`- n.Children.Add(Consume(TokenClass.RightBrace, "Expect '}' after function body."));`
	`124`	`+ n.Children.Add(Consume(TokenClass.RightBrace, "expected '}' after function body"));`
`122`	`125`
`123`	`126`	`return n;`
`124`	`127`	`}`
`125`	`128`
`126`	`129`	`private Node FuncCall() {`
`127`	`130`	`Node n = new Node("Function Call");`
`128`	`131`
`129`		`- n.Children.Add(Consume(TokenClass.Identifier, "Expect function name."));`
`130`		`- n.Children.Add(Consume(TokenClass.LeftParen, "Expect '(' after function name."));`
	`132`	`+ n.Children.Add(Consume(TokenClass.Identifier, "expected function name"));`
	`133`	`+ n.Children.Add(Consume(TokenClass.LeftParen, "expected '(' after function name"));`
`131`	`134`
`132`	`135`	`Node args = new Node("Arguments");`
`133`	`136`	`while (!Check(TokenClass.RightParen))`
`@@ -136,12 +139,12 @@ private Node FuncCall() {`
`136`	`139`
`137`	`140`	`if (!Check(TokenClass.RightParen))`
`138`	`141`	`{`
`139`		`- args.Children.Add(Consume(TokenClass.Comma, "Expect ',' between arguments."));`
	`142`	`+ args.Children.Add(Consume(TokenClass.Comma, "expected ',' between arguments"));`
`140`	`143`	`}`
`141`	`144`	`}`
`142`	`145`	`n.Children.Add(args);`
`143`	`146`
`144`		`- n.Children.Add(Consume(TokenClass.RightParen, "Expect ')' after arguments."));`
	`147`	`+ n.Children.Add(Consume(TokenClass.RightParen, "expected ')' after arguments"));`
`145`	`148`
`146`	`149`	`return n;`
`147`	`150`	`}`
`@@ -161,7 +164,7 @@ private Node Datatype() {`
`161`	`164`	`return n;`
`162`	`165`	`}`
`163`	`166`
`164`		`- throw Error(Peek(), "Expected 'int', 'float', or 'string'.");`
	`167`	`+ throw Error(Peek(), "expected 'int', 'float', or 'string'");`
`165`	`168`	`}`
`166`	`169`
`167`	`170`	`private Node Stmt() {`
`@@ -198,7 +201,7 @@ private Node Stmt() {`
`198`	`201`	`n.Children.Add(Consume(TokenClass.Semicolon));`
`199`	`202`	`break;`
`200`	`203`	`default:`
`201`		`- throw Error(Peek(), "Expect statement.");`
	`204`	`+ throw Error(Peek(), "expected statement");`
`202`	`205`	`break;`
`203`	`206`	`}`
`204`	`207`
`@@ -358,7 +361,7 @@ private Node Cond() {`
`358`	`361`	`}`
`359`	`362`	`else`
`360`	`363`	`{`
`361`		`- Error(Peek(), "Expected conditional operator.");`
	`364`	`+ Error(Peek(), "expected '<', '>', '<>', or '=' operator");`
`362`	`365`	`}`
`363`	`366`	`n.Children.Add(Expr());`
`364`	`367`
`@@ -470,7 +473,7 @@ private Node Factor()`
`470`	`473`	`}`
`471`	`474`	`else`
`472`	`475`	`{`
`473`		`- Error(Peek(), "Expected number, string, identifier, or (expression).");`
	`476`	`+ Error(Peek(), "expected number, string, identifier, or (expression)");`
`474`	`477`	`}`
`475`	`478`
`476`	`479`	`return n;`
`@@ -595,18 +598,18 @@ private Node Consume(TokenClass type, string message)`
`595`	`598`
`596`	`599`	`private Node Consume(TokenClass type)`
`597`	`600`	`{`
`598`		`- return Consume(type, $"Expected '{type.ToString().ToLowerInvariant()}'.");`
	`601`	`+ return Consume(type, $"expected '{type.ToString().ToLowerInvariant()}'");`
`599`	`602`	`}`
`600`	`603`
`601`	`604`	`private ParseError Error(Token token, string message)`
`602`	`605`	`{`
`603`	`606`	`if (IsAtEnd())`
`604`	`607`	`{`
`605`		`- Errors.Error_List.Add($"[line {token.line}] Error at end: {message}");`
	`608`	`+ Errors.ReportError(token.line, $"at end: {message}");`
`606`	`609`	`}`
`607`	`610`	`else`
`608`	`611`	`{`
`609`		`- Errors.Error_List.Add($"[line {token.line}] Error: at '{token.lex}': {message}");`
	`612`	`+ Errors.ReportError(token.line, $"at '{token.lex}': {message}");`
`610`	`613`	`}`
`611`	`614`
`612`	`615`	`return new ParseError();`
Original file line number	Diff line number	Diff line change
`@@ -131,7 +131,7 @@ public List<Token> Scan()`
`131`	`131`	`}`
`132`	`132`	`else`
`133`	`133`	`{`
`134`		`- Errors.Add(_linenumber, $"unexpected lexeme '{c}'");`
	`134`	`+ Errors.ReportError(_linenumber, $"unexpected lexeme '{c}'");`
`135`	`135`	`}`
`136`	`136`	`break;`
`137`	`137`	`}`
`@@ -163,7 +163,7 @@ private void ReadNumber()`
`163`	`163`	`Read();`
`164`	`164`	`} else if (char.IsLetter(Peek())) {`
`165`	`165`	`Read();`
`166`		`- Errors.Add(_linenumber, "illegal identifier");`
	`166`	`+ Errors.ReportError(_linenumber, "illegal identifier");`
`167`	`167`	`return;`
`168`	`168`	`}`
`169`	`169`
`@@ -188,7 +188,7 @@ private void ReadString()`
`188`	`188`	`if (Match('"'))`
`189`	`189`	`AddToken(TokenClass.StringLiteral);`
`190`	`190`	`else`
`191`		`- Errors.Add(_linenumber, "unterminated string, expected '\"'");`
	`191`	`+ Errors.ReportError(_linenumber, "unterminated string, expected '\"'");`
`192`	`192`	`}`
`193`	`193`
`194`	`194`	`private void ReadComment()`
`@@ -209,7 +209,7 @@ private void ReadComment()`
`209`	`209`	`if (Peek() == '/')`
`210`	`210`	`Read();`
`211`	`211`	`else`
`212`		`- Errors.Add(_linenumber, "unterminated comment, expected '*/'");`
	`212`	`+ Errors.ReportError(_linenumber, "unterminated comment, expected '*/'");`
`213`	`213`	`}`
`214`	`214`
`215`	`215`	`private void AddToken(TokenClass type)`
Original file line number	Diff line number	Diff line change
`@@ -58,10 +58,7 @@ private void PopulateTokensTable()`
`58`	`58`	`private void PrintErrors()`
`59`	`59`	`{`
`60`	`60`	`tfErrors.Clear();`
`61`		`- foreach (var error in Errors.Error_List)`
`62`		`- {`
`63`		`- tfErrors.Text += error + "\r\n";`
`64`		`- }`
	`61`	`+ tfErrors.Text = string.Join("\r\n", Errors.GetAll());`
`65`	`62`	`}`
`66`	`63`
`67`	`64`	`private void PopulateParseTree()`
`@@ -80,7 +77,7 @@ private void btnClear_Click(object sender, System.EventArgs e)`
`80`	`77`
`81`	`78`	`// Reset Global Data`
`82`	`79`	`Compiler.TokenStream.Clear();`
`83`		`- Errors.Error_List.Clear();`
	`80`	`+ Errors.Clear();`
`84`	`81`	`}`
`85`	`82`
`86`	`83`	`private static TreeNode PrintParaseTree(Node root)`