Parse optional commas after switch case identifiers

Parser/MParser.cs

@@ -680,8 +680,17 @@ namespace Parser
         {
             var caseKeyword = EatIdentifier("case");
             var caseId = ParseExpression();
+            var commas = new List<TokenNode>();
+            while (CurrentToken.Kind == TokenKind.Comma)
+            {
+                commas.Add(Factory.Token(EatToken()));
+            }
+            if (commas.Count == 0)
+            {
+                commas = null;
+            }
             var statementList = ParseStatements();
-            return Factory.SwitchCase(Factory.Token(caseKeyword), caseId, statementList);
+            return Factory.SwitchCase(Factory.Token(caseKeyword), caseId, statementList, commas);
         }
 
         private SwitchStatementNode ParseSwitchStatement()
@@ -829,10 +838,22 @@ namespace Parser
         {
             var tryKeyword = Factory.Token(EatIdentifier("try"));
             var tryBody = ParseStatements();
-            var catchKeyword = Factory.Token(EatIdentifier("catch"));
+            if (CurrentToken.PureToken.LiteralText == "catch")
-            var catchBody = ParseStatements();
+            {
-            var endKeyword = Factory.Token(EatIdentifier("end"));
+                var catchKeyword = Factory.Token(EatIdentifier("catch"));
-            return Factory.TryCatchStatement(tryKeyword, tryBody, catchKeyword, catchBody, endKeyword);
+                var catchBody = ParseStatements();
+                var endKeyword = Factory.Token(EatIdentifier("end"));
+                return Factory.TryCatchStatement(tryKeyword, tryBody, catchKeyword, catchBody, endKeyword);
+            }
+            else if (CurrentToken.PureToken.LiteralText == "end")
+            {
+                var endKeyword = Factory.Token(EatIdentifier("end"));
+                return Factory.TryCatchStatement(tryKeyword, tryBody, endKeyword);
+            }
+            else
+            {
+                throw new ParsingException($"Unexpected token {CurrentToken.PureToken} while parsing try/catch statement at {CurrentToken.PureToken.Position}.");
+            }
         }
 
         public StatementNode ParseStatementCore()

Parser/SyntaxFactory.cs

@@ -154,15 +154,20 @@ namespace Parser
         public SwitchCaseNode SwitchCase(
             TokenNode caseKeyword,
             ExpressionNode caseIdentifier,
-            StatementListNode statementList)
+            StatementListNode statementList,
+            List<TokenNode> optionalCommasAfterIdentifier)
         {
             var children = new List<SyntaxNode>
             {
                 caseKeyword,
-                caseIdentifier,
+                caseIdentifier
-                statementList
             };
-            var result = new SwitchCaseNode(children, caseKeyword, caseIdentifier, statementList);
+            if (optionalCommasAfterIdentifier != null)
+            {
+                children.AddRange(optionalCommasAfterIdentifier);
+            }
+            children.Add(statementList);
+            var result = new SwitchCaseNode(children, caseKeyword, caseIdentifier, statementList, optionalCommasAfterIdentifier);
             SetParent(result);
             return result;
         }
@@ -621,5 +626,27 @@ namespace Parser
             SetParent(result);
             return result;
         }
+
+        public TryCatchStatementNode TryCatchStatement(
+            TokenNode tryKeyword,
+            StatementListNode tryBody,
+            TokenNode endKeyword)
+        {
+            var children = new List<SyntaxNode>
+            {
+                tryKeyword,
+                tryBody,
+                endKeyword
+            };
+            var result = new TryCatchStatementNode(
+                children,
+                tryKeyword,
+                tryBody,
+                null,
+                null,
+                endKeyword);
+            SetParent(result);
+            return result;
+        }
     }
 }

Parser/SyntaxNode.cs

@@ -245,18 +245,21 @@ namespace Parser
     {
         public TokenNode CaseKeyword { get; }
         public ExpressionNode CaseIdentifier { get; }
+        public List<TokenNode> OptionalCommasAfterIdentifier { get; }
         public StatementListNode StatementList { get; }
 
         public SwitchCaseNode(
             List<SyntaxNode> children,
             TokenNode caseKeyword,
             ExpressionNode caseIdentifier,
-            StatementListNode statementList
+            StatementListNode statementList,
+            List<TokenNode> optionalCommasAfterIdentifier = null
             ) : base(children)
         {
             CaseKeyword = caseKeyword;
             CaseIdentifier = caseIdentifier;
             StatementList = statementList;
+            OptionalCommasAfterIdentifier = optionalCommasAfterIdentifier;
         }
     }