Added pattern matching to Aphid.

Author: JohnLeitch

.gitattributes

@@ -169,6 +169,7 @@ Components.Aphid/Parser/NullExpression.cs -text
 Components.Aphid/Parser/NumberExpression.cs -text
 Components.Aphid/Parser/ObjectExpression.cs -text
 Components.Aphid/Parser/PartialFunctionExpression.cs -text
+Components.Aphid/Parser/PatternMatchingExpression.cs -text
 Components.Aphid/Parser/Statement.cs -text
 Components.Aphid/Parser/StringExpression.cs -text
 Components.Aphid/Parser/StringParser.cs -text

AphidCodeGenerator/Aphid.alx

@@ -64,8 +64,7 @@ ret
 
                 { regex: "\\|>", type: "PipelineOperator" },        
 
-                { regex: "$", type: "AsyncOperator" },
-                { regex: "$>", type: "JoinOperator" },
+                { regex: "$", type: "PatternMatchingOperator" },                
 
                 { regex: ";", type: "EndOfStatement" },
 

Components.Aphid.VSPackage/AphidScanner.cs

@@ -59,6 +59,7 @@ public bool ScanTokenAndProvideInfoAboutIt(TokenInfo tokenInfo, ref int state)
                 case AphidTokenType.functionOperator:
                 case AphidTokenType.LoadLibraryOperator:
                 case AphidTokenType.LoadScriptOperator:
+                case AphidTokenType.PatternMatchingOperator:
 
                     tokenInfo.Type = TokenType.Keyword;
                     tokenInfo.Color = TokenColor.Keyword;
@@ -67,7 +68,6 @@ public bool ScanTokenAndProvideInfoAboutIt(TokenInfo tokenInfo, ref int state)
                 case AphidTokenType.AdditionOperator:
                 case AphidTokenType.AndOperator:
                 case AphidTokenType.AssignmentOperator:
-                case AphidTokenType.AsyncOperator:
                 case AphidTokenType.BinaryAndOperator:
                 case AphidTokenType.BinaryOrOperator:
                 case AphidTokenType.ColonOperator:
@@ -80,7 +80,6 @@ public bool ScanTokenAndProvideInfoAboutIt(TokenInfo tokenInfo, ref int state)
                 case AphidTokenType.GreaterThanOperator:
                 case AphidTokenType.GreaterThanOrEqualOperator:
                 case AphidTokenType.IncrementOperator:
-                case AphidTokenType.JoinOperator:
                 case AphidTokenType.LessThanOperator:
                 case AphidTokenType.LessThanOrEqualOperator:                
                 case AphidTokenType.MinusEqualOperator:

Components.Aphid/Components.Aphid.csproj

@@ -87,6 +87,7 @@
     <Compile Include="Parser\AphidNodeCollection.cs" />
     <Compile Include="Parser\AphidParserException.cs" />
     <Compile Include="Parser\PartialFunctionExpression.cs" />
+    <Compile Include="Parser\PatternMatchingExpression.cs" />
     <Compile Include="Parser\StringParser.cs" />
     <Compile Include="Parser\ThisExpression.cs" />
     <Compile Include="Parser\UnaryOperatorExpression.cs" />

Components.Aphid/Interpreter/AphidInterpreter.cs

@@ -93,8 +93,8 @@ private AphidObject InterpretOrExpression(BinaryOperatorExpression expression)
 
         private AphidObject InterpretEqualityExpression(BinaryOperatorExpression expression)
         {
-            var left = InterpretExpression(expression.LeftOperand) as AphidObject;
-            var right = InterpretExpression(expression.RightOperand) as AphidObject;
+            var left = (AphidObject)InterpretExpression(expression.LeftOperand);
+            var right = (AphidObject)InterpretExpression(expression.RightOperand);
 
             bool val = left.Value != null ?
                 left.Value.Equals(right.Value) :
@@ -718,6 +718,34 @@ public AphidObject InterpretThisExpression()
             return _currentScope.Variables;
         }
 
+        public AphidObject InterpretPatternMatchingExpression(PatternMatchingExpression expression)
+        {
+            var left = (AphidObject)InterpretExpression(expression.TestExpression);
+            
+            foreach (var p in expression.Patterns)
+            {
+                if (p.Item1 != null)
+                {
+                    var right = (AphidObject)InterpretExpression(p.Item1);
+
+                    var b = left.Value != null ?
+                        left.Value.Equals(right.Value) :
+                        (null == right.Value && left.Count == 0 && right.Count == 0);
+
+                    if (b)
+                    {
+                        return ValueHelper.Wrap(InterpretExpression(p.Item2));
+                    }
+                }
+                else
+                {
+                    return ValueHelper.Wrap(InterpretExpression(p.Item2));
+                }
+            }
+
+            return new AphidObject();
+        }
+
         private object InterpretExpression(Expression expression)
         {
             if (expression is BinaryOperatorExpression)
@@ -801,6 +829,10 @@ private object InterpretExpression(Expression expression)
             {
                 return InterpretThisExpression();
             }
+            else if (expression is PatternMatchingExpression)
+            {
+                return InterpretPatternMatchingExpression(expression as PatternMatchingExpression);
+            }
             else
             {
                 throw new AphidRuntimeException("Unexpected expression {0}", expression);

Components.Aphid/Interpreter/AphidObject.g.cs

@@ -1,7 +1,7 @@
 //------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated by a tool.
-//     Runtime Version:4.0.30319.18033
+//     Runtime Version:4.0.30319.18046
 //
 //     Changes to this file may cause incorrect behavior and will be lost if
 //     the code is regenerated.

Components.Aphid/Lexer/AphidLexer.cs

@@ -17,7 +17,6 @@ public enum AphidTokenType : short
         AdditionOperator,
         AndOperator,
         AssignmentOperator,
-        AsyncOperator,
         BinaryAndOperator,
         BinaryOrOperator,
         breakKeyword,
@@ -43,7 +42,6 @@ public enum AphidTokenType : short
         ifKeyword,
         IncrementOperator,
         inKeyword,
-        JoinOperator,
         LeftBrace,
         LeftBracket,
         LeftParenthesis,
@@ -64,6 +62,7 @@ public enum AphidTokenType : short
         Number,
         OrEqualOperator,
         OrOperator,
+        PatternMatchingOperator,
         PipelineOperator,
         PlusEqualOperator,
         retKeyword,
@@ -520,21 +519,8 @@ private AphidTokenType GetToken()
                             return AphidTokenType.NotOperator;
 
                         case '$':
-                            if (charIndex < lastIndex)
-                            {
-                                currentChar = text[++charIndex];
-
-                                switch (currentChar)
-                                {
-                                    case '>':
 
-                                        return AphidTokenType.JoinOperator;
-
-                                }
-
-                                charIndex--;
-                            }
-                            return AphidTokenType.AsyncOperator;
+                            return AphidTokenType.PatternMatchingOperator;
 
                         case ';':
 
@@ -2129,6 +2115,7 @@ public List<AphidToken> GetAllTokens()
 
                 tokens.Add(new AphidToken(tokenType, lexeme, index));
 
+
                 lastIndex = charIndex;
             }
 

Components.Aphid/Parser/AphidParser.cs

@@ -253,6 +253,60 @@ public Expression ParseFactor()
                     NextToken();
                     break;
 
+                case AphidTokenType.PatternMatchingOperator:
+                    var matchExp = new PatternMatchingExpression();
+                    NextToken();
+                    Match(AphidTokenType.LeftParenthesis);
+                    matchExp.TestExpression = ParseExpression();
+                    Match(AphidTokenType.RightParenthesis);
+
+                    while (true)
+                    {
+                        var tests = new List<Expression>();
+
+                        while (true)
+                        {
+                            tests.Add(ParseExpression());
+
+                            if (_currentToken.TokenType == AphidTokenType.Comma)
+                            {
+                                NextToken();
+                            }
+                            else
+                            {
+                                break;
+                            }
+                        }
+
+                        if (_currentToken.TokenType == AphidTokenType.ColonOperator)
+                        {
+                            NextToken();
+
+                            var b = ParseExpression();
+
+                            foreach (var t in tests)
+                            {
+                                matchExp.Patterns.Add(new Tuple<Expression, Expression>(t, b));
+                            }
+                        }
+                        else
+                        {
+                            matchExp.Patterns.Add(new Tuple<Expression,Expression>(null, tests[0]));
+                        }
+
+                        if (_currentToken.TokenType == AphidTokenType.Comma)
+                        {
+                            NextToken();
+                        }
+                        else
+                        {
+                            break;
+                        }
+                    }
+
+                    exp = matchExp;
+                    break;
+
                 default:
                     throw new AphidParserException(_currentToken);
             }

Components.Aphid/Parser/PatternMatchingExpression.cs

@@ -0,0 +1,19 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Components.Aphid.Parser
+{
+    public class PatternMatchingExpression : Expression
+    {
+        public Expression TestExpression { get; set; }
+
+        public List<Tuple<Expression, Expression>> Patterns { get; set; }
+
+        public PatternMatchingExpression()
+        {
+            Patterns = new List<Tuple<Expression, Expression>>();
+        }
+    }
+}