Add support for hexadecimal and binary literals. (#238)

Fixes #236

Author: metoule

src/DynamicExpresso.Core/Parsing/Parser.cs

@@ -28,6 +28,7 @@ public static Expression Parse(ParserArguments arguments)
 
 		private const NumberStyles ParseLiteralNumberStyle = NumberStyles.AllowLeadingSign;
 		private const NumberStyles ParseLiteralUnsignedNumberStyle = NumberStyles.AllowLeadingSign;
+		private const NumberStyles ParseLiteralHexNumberStyle = NumberStyles.HexNumber;
 		private const NumberStyles ParseLiteralDecimalNumberStyle = NumberStyles.AllowLeadingSign | NumberStyles.AllowDecimalPoint;
 		private const NumberStyles ParseLiteralDoubleNumberStyle = NumberStyles.AllowLeadingSign | NumberStyles.AllowDecimalPoint | NumberStyles.AllowExponent;
 		private static readonly CultureInfo ParseCulture = CultureInfo.InvariantCulture;
@@ -877,12 +878,31 @@ private Expression ParseIntegerLiteral()
 
 			text = text.Substring(0, numberEnd + 1);
 
-			// No suffix find, verify if DefaultNumberType.Long is specified
+			// No suffix found, verify if DefaultNumberType.Long is specified
 			if (_defaultNumberType == DefaultNumberType.Long) isLong = true;
 
 			if (text[0] != '-')
 			{
-				if (!ulong.TryParse(text, ParseLiteralUnsignedNumberStyle, ParseCulture, out ulong value))
+				ulong value;
+				if (text.StartsWith("0x") || text.StartsWith("0X"))
+				{
+					var hex = text.Substring(2);
+					if (!ulong.TryParse(hex, ParseLiteralHexNumberStyle, ParseCulture, out value))
+						throw CreateParseException(_token.pos, ErrorMessages.InvalidIntegerLiteral, text);
+				}
+				else if (text.StartsWith("0b") || text.StartsWith("0B"))
+				{
+					var binary = text.Substring(2);
+					try
+					{
+						value = Convert.ToUInt64(binary, 2);
+					}
+					catch (FormatException ex)
+					{
+						throw WrapWithParseException(_token.pos, ErrorMessages.InvalidIntegerLiteral, ex, text);
+					}
+				}
+				else if (!ulong.TryParse(text, ParseLiteralUnsignedNumberStyle, ParseCulture, out value))
 					throw CreateParseException(_token.pos, ErrorMessages.InvalidIntegerLiteral, text);
 
 				NextToken();
@@ -3005,12 +3025,39 @@ private void NextToken()
 							t = TokenId.IntegerLiteral;
 						}
 
+						// binary and hexadecimal integer literals
+						var canBeRealLiteral = true;
+						if (_parseChar == '0')
+						{
+							NextChar();
+							if (_parseChar == 'x' || _parseChar == 'X')
+							{
+								canBeRealLiteral = false;
+								do
+								{
+									NextChar();
+								} while (char.IsDigit(_parseChar) || (_parseChar >= 'a' && _parseChar <= 'f') || (_parseChar >= 'A' && _parseChar <= 'F'));
+							}
+							else if (_parseChar == 'b' || _parseChar == 'B')
+							{
+								canBeRealLiteral = false;
+								do
+								{
+									NextChar();
+								} while (_parseChar == '0' || _parseChar == '1');
+							}
+							else
+							{
+								PreviousChar();
+							}
+						}
+
 						do
 						{
 							NextChar();
 						} while (char.IsDigit(_parseChar));
 
-						if (_parseChar == '.')
+						if (canBeRealLiteral && _parseChar == '.')
 						{
 							NextChar();
 							if (char.IsDigit(_parseChar))
@@ -3028,7 +3075,7 @@ private void NextToken()
 							}
 						}
 
-						if (_parseChar == 'E' || _parseChar == 'e')
+						if (canBeRealLiteral && (_parseChar == 'E' || _parseChar == 'e'))
 						{
 							t = TokenId.RealLiteral;
 							NextChar();
@@ -3041,7 +3088,7 @@ private void NextToken()
 							} while (char.IsDigit(_parseChar));
 						}
 
-						if (_parseChar == 'D' || _parseChar == 'd' || _parseChar == 'F' || _parseChar == 'f' || _parseChar == 'M' || _parseChar == 'm')
+						if (canBeRealLiteral && (_parseChar == 'D' || _parseChar == 'd' || _parseChar == 'F' || _parseChar == 'f' || _parseChar == 'M' || _parseChar == 'm'))
 						{
 							t = TokenId.RealLiteral;
 							NextChar();
@@ -3050,12 +3097,14 @@ private void NextToken()
 						// 'U' | 'u' | 'L' | 'l' | 'UL' | 'Ul' | 'uL' | 'ul' | 'LU' | 'Lu' | 'lU' | 'lu'
 						if (_parseChar == 'U' || _parseChar == 'u')
 						{
+							t = TokenId.IntegerLiteral;
 							NextChar();
 							if (_parseChar == 'L' || _parseChar == 'l')
 								NextChar();
 						}
 						else if (_parseChar == 'L' || _parseChar == 'l')
 						{
+							t = TokenId.IntegerLiteral;
 							NextChar();
 							if (_parseChar == 'U' || _parseChar == 'u')
 								NextChar();
@@ -3104,9 +3153,9 @@ private void ValidateToken(TokenId t)
 				throw CreateParseException(_token.pos, ErrorMessages.SyntaxError);
 		}
 
-		private static Exception WrapWithParseException(int pos, string msg, Exception ex)
+		private static Exception WrapWithParseException(int pos, string format, Exception ex, params object[] args)
 		{
-			return new ParseException(msg, pos, ex);
+			return new ParseException(string.Format(format, args), pos, ex);
 		}
 
 		private static Exception CreateParseException(int pos, string format, params object[] args)

test/DynamicExpresso.UnitTest/LiteralsTest.cs

@@ -1,4 +1,4 @@
-using NUnit.Framework;
+using NUnit.Framework;
 using System.Threading;
 using System.Globalization;
 using DynamicExpresso.Exceptions;
@@ -353,6 +353,34 @@ public void Invalid_Numeric_Literals_wrong_suffix_x()
 			Assert.Throws<ParseException>(() => target.Eval("45G"));
 		}
 
+		[Test]
+		public void Binary_Literals()
+		{
+			var target = new Interpreter();
+
+			Assert.AreEqual(0b101ul, target.Eval("0b101ul"));
+			Assert.AreEqual(0B1111L, target.Eval("0B1111l"));
+			Assert.AreEqual(6, target.Eval("4 + 0b10"));
+
+			Assert.Throws<ParseException>(() => target.Eval("0b12"));
+			Assert.Throws<ParseException>(() => target.Eval("0b10.10"));
+			Assert.Throws<ParseException>(() => target.Eval("0b10d"));
+			Assert.Throws<ParseException>(() => target.Eval("0b10e"));
+		}
+
+		[Test]
+		public void Hexadecimal_Literals()
+		{
+			var target = new Interpreter();
+
+			Assert.AreEqual(0x012EFul, target.Eval("0x012EFul"));
+			Assert.AreEqual(0XAAe2L, target.Eval("0XAAe2l"));
+			Assert.AreEqual(165, target.Eval("4 + 0xA1"));
+
+			Assert.Throws<ParseException>(() => target.Eval("0x1Gl"));
+			Assert.Throws<ParseException>(() => target.Eval("0x12.12"));
+		}
+
 		[Test]
 		public void Calling_System_Method_On_Literals()
 		{