Added support for the ?? (null-coalescing) operator

MathConverter/Parser.cs

@@ -73,7 +73,7 @@ private IEnumerable<AbstractSyntaxTree> ConverterParameter()
         }
         private AbstractSyntaxTree Conditional()
         {
-            return Conditional(ConditionalOr());
+            return Conditional(NullCoalescing());
         }
         private AbstractSyntaxTree Conditional(AbstractSyntaxTree e)
         {
@@ -85,12 +85,12 @@ private AbstractSyntaxTree Conditional(AbstractSyntaxTree e)
                     if (scanner.Peek().TokenType == TokenType.QuestionMark)
                         throw new ParsingException(scanner.Position, "The ?? operator is not supported.");
 
-                    var then = ConditionalOr();
+                    var then = NullCoalescing();
                     t = scanner.GetToken();
                     switch (t.TokenType)
                     {
                         case TokenType.Colon:
-                            return Conditional(new TernaryNode(e, then, ConditionalOr()));
+                            return Conditional(new TernaryNode(e, then, NullCoalescing()));
                         default:
                             throw new ParsingException(scanner.Position, "Could not find the ':' to terminate the ternary ('?:') statement");
                     }
@@ -99,6 +99,23 @@ private AbstractSyntaxTree Conditional(AbstractSyntaxTree e)
                     return e;
             }
         }
+        private AbstractSyntaxTree NullCoalescing()
+        {
+            return NullCoalescing(ConditionalOr());
+        }
+        private AbstractSyntaxTree NullCoalescing(AbstractSyntaxTree e)
+        {
+            var t = scanner.GetToken();
+
+            switch (t.TokenType)
+            {
+                case TokenType.DoubleQuestionMark:
+                    return NullCoalescing(new NullCoalescingNode(e, ConditionalOr()));
+                default:
+                    scanner.PutBackToken();
+                    return e;
+            }
+        }
         private AbstractSyntaxTree ConditionalOr()
         {
             return ConditionalOr(ConditionalAnd());

MathConverter/Properties/AssemblyInfo.cs

@@ -51,8 +51,8 @@
 // You can specify all the values or you can default the Build and Revision Numbers 
 // by using the '*' as shown below:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("1.2.0.0")]
-[assembly: AssemblyFileVersion("1.2.0.0")]
+[assembly: AssemblyVersion("1.2.1.0")]
+[assembly: AssemblyFileVersion("1.2.1.0")]
 
 [assembly: XmlnsPrefix("http://hexinnovation.com/math", "math")]
 [assembly: XmlnsDefinition("http://hexinnovation.com/math", "HexInnovation")]

MathConverter/Scanner.cs

@@ -102,7 +102,15 @@ private Token NextToken()
                             case 'z':
                                 return new Token(TokenType.Z);
                             case '?':
-                                return new Token(TokenType.QuestionMark);
+                                switch (_reader.Peek())
+                                {
+                                    case '?':
+                                        Position++;
+                                        _reader.Read();
+                                        return new Token(TokenType.DoubleQuestionMark);
+                                    default:
+                                        return new Token(TokenType.QuestionMark);
+                                }
                             case ':':
                                 return new Token(TokenType.Colon);
                             case '.':

MathConverter/SyntaxTree.cs

@@ -134,6 +134,23 @@ public override string ToString()
             return "(" + left + " && " + right + ")";
         }
     }
+
+    class NullCoalescingNode : BinaryNode
+    {
+        public NullCoalescingNode(AbstractSyntaxTree left, AbstractSyntaxTree right)
+            : base(left, right)
+        {
+
+        }
+        public override object Evaluate(object[] Parameters)
+        {
+            return (dynamic)left.Evaluate(Parameters) ?? (dynamic)right.Evaluate(Parameters);
+        }
+        public override string ToString()
+        {
+            return "(" + left + " ?? " + right + ")";
+        }
+    }
     class OrNode : BinaryNode
     {
         public OrNode(AbstractSyntaxTree left, AbstractSyntaxTree right)

MathConverter/Token.cs

@@ -68,6 +68,7 @@ enum TokenType
         LessThanEqual,
         GreaterThanEqual,
         QuestionMark,
+        DoubleQuestionMark,
         Colon,
         String,
         Or,

README.md

@@ -7,6 +7,16 @@ A WPF Converter class that does it all
 
 
 
+Installation:
+-------------
+
+`MathConverter` is available on [NuGet](https://www.nuget.org/packages/MathConverter/)
+
+To install MathConverter, run the following command in the [Package Manager Console](https://docs.microsoft.com/en-us/nuget/tools/package-manager-console):
+
+```
+PM> Install-Package MathConverter
+```
 
 
 What is MathConverter?
@@ -352,7 +362,7 @@ Just like in C#, you can embed strings within in an interpolated string. So `Mat
 Operators
 ---------
 
-The ternary conditional operator is just one of several operators we can use. In general, the operators used in MathConverter will follow [the standard C# rules regarding operator ordering](https://msdn.microsoft.com/en-us/library/aa691323(v=vs.71).aspx), meaning you can usually expect it to behave just like C#. But there are a few notable exceptions:
+The ternary conditional operator is just one of several operators we can use. In general, the operators used in MathConverter will follow [the standard C# rules regarding operator ordering](https://docs.microsoft.com/en-us/dotnet/articles/csharp/language-reference/operators/), meaning you can usually expect it to behave just like C#. But there are a few notable exceptions:
 
 * Since `MathConverter` is specifically designed to perform math calculations, the caret (`^`) operator does not perform the `XOR` operation. Rather, it is an exponent symbol. It uses [`System.Math.Pow`](https://msdn.microsoft.com/en-us/library/system.math.pow(v=vs.110).aspx) to evaluate expressions, and its precedence is just above multiplicative operations (`*`, `/`, and `%`).
 * The multiplication operator can often be safely ommitted. A `ConverterParameter` value of `xyz` will evaluate to `x*y*z`. The parameter `x2y` will evaluate to `x^2*y` (or equivalently, `xxy` or `x*x*y`). Similarly, `2x3` is equivalent to `2*x^3` or `2*x*x*x`. Note that `x(2)` is equivalent to `x*(2)`, in the same way that `x(y+z)` is equivalent to `x*(y+z)`.
@@ -364,7 +374,6 @@ The ternary conditional operator is just one of several operators we can use. In
     * Binary operations (`<<`, `>>`, `~`) are not supported.
     * The unary operators `++` and `--` are not supported, since they change the values of the inputs.
     * Primary operators (`x.y`, `f(x)`, `a[x]`, `new`, `typeof`, `checked`, `unchecked`) are not supported.
-    * The `??` operator is not listed in [the standard C# rules for operator ordering](https://msdn.microsoft.com/en-us/library/aa691323(v=vs.71).aspx), so `MathConverter` does not support it. See the `isnull` function in the next section.
 
 
 
@@ -373,7 +382,7 @@ The ternary conditional operator is just one of several operators we can use. In
 null
 ----
 
-`MathConverter` fully supportes `null` values. You can include `null` in the `ConverterParameter`, and it will evaluate to `null`. Also, any bindings will still work if the binding returns `null`. As previously mentioned, MathConverter does not support the `??` operator. It does, however, include the 2-value function `isnull`/`ifnull`. `MathConverter` evaluates the expression `isnull(x,y)` in the same way that it would evaluate the expression `x == null ? y : x`.
+`MathConverter` fully supportes `null` values. You can include `null` in the `ConverterParameter`, and it will evaluate to `null`. Also, any bindings will still work if the binding returns `null`. In addition to supporting the `??` null-coalescing operator, it also includes the 2-value function `isnull`/`ifnull`. `MathConverter` evaluates the expression `x ?? y` in the same way that it would evaluate the expressions `isnull(x,y)` or `x == null ? y : x`.
 
 `MathConverter` evaluates most of its values using the `dynamic` type. So `x+y` will yield `null` if `x = 3` and `y = null`. However, if `x = "Hello World"` and `y = null`, `x+y` will yield `"Hello World"`.