using System;
|
using System.Collections;
|
using System.Collections.Generic;
|
using System.Globalization;
|
using System.Linq;
|
using System.Linq.Expressions;
|
using System.Reflection;
|
using System.Text;
|
using DynamicExpresso.Exceptions;
|
using DynamicExpresso.Reflection;
|
using DynamicExpresso.Resolution;
|
using DynamicExpresso.Resources;
|
using Microsoft.CSharp.RuntimeBinder;
|
|
// Code based on the Dynamic.cs file of the DynamicQuery sample by Microsoft
|
// http://msdn.microsoft.com/en-us/vstudio/bb894665.aspx
|
// http://weblogs.asp.net/scottgu/archive/2008/01/07/dynamic-linq-part-1-using-the-linq-dynamic-query-library.aspx
|
//
|
// Copyright (C) Microsoft Corporation. All rights reserved.
|
|
namespace DynamicExpresso.Parsing
|
{
|
internal class Parser
|
{
|
public static Expression Parse(ParserArguments arguments)
|
{
|
return new Parser(arguments).Parse();
|
}
|
|
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;
|
|
private readonly ParserArguments _arguments;
|
|
// Working context implementation
|
//ParameterExpression it;
|
|
private int _parsePosition;
|
private readonly string _expressionText;
|
private readonly int _expressionTextLength;
|
private char _parseChar;
|
private Token _token;
|
|
private readonly MemberFinder _memberFinder;
|
|
private readonly DefaultNumberType _defaultNumberType;
|
|
private Parser(ParserArguments arguments)
|
{
|
_arguments = arguments;
|
|
_memberFinder = new MemberFinder(arguments);
|
|
_defaultNumberType = arguments.Settings.DefaultNumberType;
|
|
_expressionText = arguments.ExpressionText ?? string.Empty;
|
_expressionTextLength = _expressionText.Length;
|
SetTextPos(0);
|
NextToken();
|
}
|
|
private Expression Parse()
|
{
|
var expr = ParseExpressionSegment(_arguments.ExpressionReturnType);
|
|
ValidateToken(TokenId.End, ErrorMessages.SyntaxError);
|
return expr;
|
}
|
|
private Expression ParseExpressionSegment(Type returnType)
|
{
|
var errorPos = _token.pos;
|
var expression = ParseExpressionSegment();
|
|
if (returnType != typeof(void))
|
{
|
return GenerateConversion(expression, returnType, errorPos);
|
}
|
|
return expression;
|
}
|
|
private Expression ParseExpressionSegment()
|
{
|
// The following methods respect the operator precedence as defined in
|
// MSDN C# "Operator precedence and associativity"
|
// https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/operators/
|
|
try
|
{
|
if (_arguments.Settings.LambdaExpressions)
|
{
|
var lambdaExpr = ParseLambdaExpression();
|
if (lambdaExpr != null)
|
return lambdaExpr;
|
}
|
|
return ParseAssignment();
|
}
|
catch (InvalidOperationException ex)
|
{
|
throw WrapWithParseException(_token.pos, ErrorMessages.InvalidOperation, ex);
|
}
|
}
|
|
// => operator
|
private Expression ParseLambdaExpression()
|
{
|
// in case the expression is not a lambda, we have to restart parsing
|
var originalPos = _token.pos;
|
var isLambda = false;
|
try
|
{
|
var parameters = ParseLambdaParameterList();
|
ValidateToken(TokenId.LambdaArrow);
|
|
var startExpr = _parsePosition;
|
|
// decide where the lambda expression body ends:
|
// it's the first unmatched parenthesis, curly bracket, of comma
|
var parenCount = 0;
|
var inLambdaBody = true;
|
while (inLambdaBody)
|
{
|
NextToken();
|
if (_token.id == TokenId.End)
|
inLambdaBody = false;
|
if (_token.id == TokenId.OpenParen || _token.id == TokenId.OpenCurlyBracket)
|
parenCount++;
|
if (_token.id == TokenId.CloseParen || _token.id == TokenId.CloseCurlyBracket)
|
parenCount--;
|
|
// lambda is a function parameter
|
if (parenCount == 0 && _token.id == TokenId.Comma)
|
inLambdaBody = false;
|
|
// body closure
|
if (parenCount < 0)
|
inLambdaBody = false;
|
}
|
|
var lambdaBodyExp = _expressionText.Substring(startExpr, _token.pos - startExpr);
|
isLambda = true;
|
return new InterpreterExpression(_arguments, lambdaBodyExp, parameters);
|
}
|
catch (ParseException)
|
{
|
if (isLambda)
|
{
|
throw;
|
}
|
// not a lambda, return to the saved position
|
SetTextPos(originalPos);
|
NextToken();
|
|
return null;
|
}
|
}
|
|
private ParameterWithPosition[] ParseLambdaParameterList()
|
{
|
var hasOpenParen = _token.id == TokenId.OpenParen;
|
if (hasOpenParen)
|
NextToken();
|
|
var parameters = _token.id != TokenId.CloseParen ? ParseLambdaParameters() : new ParameterWithPosition[0];
|
if (hasOpenParen)
|
{
|
ValidateToken(TokenId.CloseParen, ErrorMessages.CloseParenOrCommaExpected);
|
NextToken();
|
}
|
|
if (!hasOpenParen && parameters.Length > 1)
|
throw new ParseException(ErrorMessages.MultipleLambdaParametersWithoutBrace, _parsePosition);
|
|
return parameters;
|
}
|
|
private ParameterWithPosition[] ParseLambdaParameters()
|
{
|
var argList = new List<ParameterWithPosition>();
|
while (true)
|
{
|
argList.Add(ParseLambdaParameter());
|
if (_token.id != TokenId.Comma) break;
|
NextToken();
|
}
|
return argList.ToArray();
|
}
|
|
private ParameterWithPosition ParseLambdaParameter()
|
{
|
ValidateToken(TokenId.Identifier);
|
var name = _token.text;
|
|
var pos = _token.pos;
|
if (TryParseKnownType(name, out var type))
|
{
|
ValidateToken(TokenId.Identifier);
|
name = _token.text;
|
}
|
else
|
{
|
type = typeof(object);
|
}
|
|
NextToken();
|
return new ParameterWithPosition(pos, name, type);
|
}
|
|
// = operator
|
private Expression ParseAssignment()
|
{
|
var left = ParseConditional();
|
if (_token.id == TokenId.Equal)
|
{
|
if (!_arguments.Settings.AssignmentOperators.HasFlag(AssignmentOperators.AssignmentEqual))
|
throw new AssignmentOperatorDisabledException("=", _token.pos);
|
|
Func<Expression, Expression> assignLeftDynamic = null;
|
if (!IsWritable(left) && !IsDynamicWritable(left, out assignLeftDynamic))
|
throw ParseException.Create(_token.pos, ErrorMessages.ExpressionMustBeWritable);
|
|
NextToken();
|
var right = ParseAssignment();
|
|
var promoted = ExpressionUtils.PromoteExpression(right, left.Type);
|
if (promoted == null)
|
throw ParseException.Create(_token.pos, ErrorMessages.CannotConvertValue,
|
TypeUtils.GetTypeName(right.Type), TypeUtils.GetTypeName(left.Type));
|
|
left = assignLeftDynamic == null
|
? Expression.Assign(left, promoted)
|
: assignLeftDynamic(promoted);
|
}
|
return left;
|
}
|
|
// ?: operator
|
private Expression ParseConditional()
|
{
|
var errorPos = _token.pos;
|
var expr = ParseConditionalOr();
|
if (_token.id == TokenId.QuestionQuestion)
|
{
|
NextToken();
|
var exprRight = ParseExpressionSegment();
|
if (TypeUtils.IsNullableType(expr.Type))
|
{
|
// expr.HasValue ? expr.Value : exprRight
|
expr = GenerateConditional(GenerateGetNullableHasValue(expr), GenerateGetNullableValue(expr), exprRight, errorPos);
|
}
|
else
|
{
|
// expr == null ? exprRight : expr
|
expr = GenerateConditional(GenerateEqual(expr, ParserConstants.NullLiteralExpression), exprRight, expr, errorPos);
|
}
|
}
|
else if (_token.id == TokenId.Question)
|
{
|
NextToken();
|
var expr1 = ParseExpressionSegment();
|
ValidateToken(TokenId.Colon, ErrorMessages.ColonExpected);
|
NextToken();
|
var expr2 = ParseExpressionSegment();
|
expr = GenerateConditional(expr, expr1, expr2, errorPos);
|
}
|
return expr;
|
}
|
|
// || operator
|
private Expression ParseConditionalOr()
|
{
|
var left = ParseConditionalAnd();
|
while (_token.id == TokenId.DoubleBar)
|
{
|
NextToken();
|
var right = ParseConditionalAnd();
|
CheckAndPromoteOperands(ParseSignatures.LogicalSignatures, ref left, ref right);
|
left = GenerateBinary(ExpressionType.OrElse, left, right);
|
}
|
return left;
|
}
|
|
// && operator
|
private Expression ParseConditionalAnd()
|
{
|
var left = ParseLogicalOr();
|
while (_token.id == TokenId.DoubleAmphersand)
|
{
|
NextToken();
|
var right = ParseLogicalOr();
|
CheckAndPromoteOperands(ParseSignatures.LogicalSignatures, ref left, ref right);
|
left = GenerateBinary(ExpressionType.AndAlso, left, right);
|
}
|
return left;
|
}
|
|
// | operator
|
private Expression ParseLogicalOr()
|
{
|
var left = ParseLogicalXor();
|
while (_token.id == TokenId.Bar)
|
{
|
NextToken();
|
var right = ParseLogicalXor();
|
CheckAndPromoteOperands(ParseSignatures.LogicalSignatures, ref left, ref right);
|
left = GenerateBinary(ExpressionType.Or, left, right);
|
}
|
return left;
|
}
|
|
// ^ operator
|
private Expression ParseLogicalXor()
|
{
|
var left = ParseLogicalAnd();
|
while (_token.id == TokenId.Caret)
|
{
|
NextToken();
|
var right = ParseLogicalAnd();
|
CheckAndPromoteOperands(ParseSignatures.LogicalSignatures, ref left, ref right);
|
left = GenerateBinary(ExpressionType.ExclusiveOr, left, right);
|
}
|
return left;
|
}
|
|
// & operator
|
private Expression ParseLogicalAnd()
|
{
|
var left = ParseComparison();
|
while (_token.id == TokenId.Amphersand)
|
{
|
NextToken();
|
var right = ParseComparison();
|
CheckAndPromoteOperands(ParseSignatures.LogicalSignatures, ref left, ref right);
|
left = GenerateBinary(ExpressionType.And, left, right);
|
}
|
return left;
|
}
|
|
// ==, !=, >, >=, <, <= operators
|
private Expression ParseComparison()
|
{
|
var left = ParseTypeTesting();
|
while (_token.id == TokenId.DoubleEqual || _token.id == TokenId.ExclamationEqual ||
|
_token.id == TokenId.GreaterThan || _token.id == TokenId.GreaterThanEqual ||
|
_token.id == TokenId.LessThan || _token.id == TokenId.LessThanEqual)
|
{
|
var op = _token;
|
NextToken();
|
var right = ParseShift();
|
var isEquality = op.id == TokenId.DoubleEqual || op.id == TokenId.ExclamationEqual;
|
|
//if (isEquality && !left.Type.IsValueType && !right.Type.IsValueType)
|
//{
|
// if (left.Type != right.Type)
|
// {
|
// if (left.Type.IsAssignableFrom(right.Type))
|
// {
|
// right = Expression.Convert(right, left.Type);
|
// }
|
// else if (right.Type.IsAssignableFrom(left.Type))
|
// {
|
// left = Expression.Convert(left, right.Type);
|
// }
|
// else
|
// {
|
// throw ParseException.Create(op.pos, ErrorMessages.IncompatibleOperands,
|
// op.text, TypeUtils.GetTypeName(left.Type), TypeUtils.GetTypeName(right.Type));
|
// }
|
// }
|
//}
|
//else if (IsEnumType(left.Type) || IsEnumType(right.Type))
|
//{
|
// if (left.Type != right.Type)
|
// {
|
// Expression e;
|
// if ((e = PromoteExpression(right, left.Type, true)) != null)
|
// {
|
// right = e;
|
// }
|
// else if ((e = PromoteExpression(left, right.Type, true)) != null)
|
// {
|
// left = e;
|
// }
|
// else
|
// {
|
// throw ParseException.Create(op.pos, ErrorMessages.IncompatibleOperands,
|
// op.text, TypeUtils.GetTypeName(left.Type), TypeUtils.GetTypeName(right.Type));
|
// }
|
// }
|
//}
|
//else
|
//{
|
// CheckAndPromoteOperands(isEquality ? ParseSignatures.EqualitySignatures : ParseSignatures.RelationalSignatures,
|
// op.text, ref left, ref right, op.pos);
|
//}
|
|
CheckAndPromoteOperands(
|
isEquality ? ParseSignatures.EqualitySignatures : ParseSignatures.RelationalSignatures,
|
ref left,
|
ref right);
|
|
switch (op.id)
|
{
|
case TokenId.DoubleEqual:
|
left = GenerateEqual(left, right);
|
break;
|
case TokenId.ExclamationEqual:
|
left = GenerateNotEqual(left, right);
|
break;
|
case TokenId.GreaterThan:
|
left = GenerateGreaterThan(left, right);
|
break;
|
case TokenId.GreaterThanEqual:
|
left = GenerateGreaterThanEqual(left, right);
|
break;
|
case TokenId.LessThan:
|
left = GenerateLessThan(left, right);
|
break;
|
case TokenId.LessThanEqual:
|
left = GenerateLessThanEqual(left, right);
|
break;
|
}
|
}
|
return left;
|
}
|
|
// is, as operators
|
private Expression ParseTypeTesting()
|
{
|
var left = ParseShift();
|
while (_token.text == ParserConstants.KeywordIs
|
|| _token.text == ParserConstants.KeywordAs)
|
{
|
var typeOperator = _token.text;
|
|
var op = _token;
|
NextToken();
|
|
if (!TryParseKnownType(_token.text, out var knownType))
|
throw ParseException.Create(op.pos, ErrorMessages.TypeIdentifierExpected);
|
|
if (typeOperator == ParserConstants.KeywordIs)
|
left = Expression.TypeIs(left, knownType);
|
else if (typeOperator == ParserConstants.KeywordAs)
|
left = Expression.TypeAs(left, knownType);
|
else
|
throw ParseException.Create(_token.pos, ErrorMessages.SyntaxError);
|
}
|
|
return left;
|
}
|
|
// +, -, & operators
|
private Expression ParseAdditive()
|
{
|
var left = ParseMultiplicative();
|
while (_token.id == TokenId.Plus || _token.id == TokenId.Minus)
|
{
|
var op = _token;
|
NextToken();
|
var right = ParseMultiplicative();
|
switch (op.id)
|
{
|
case TokenId.Plus:
|
if (left.Type == typeof(string) || right.Type == typeof(string))
|
{
|
left = GenerateStringConcat(left, right);
|
}
|
else
|
{
|
CheckAndPromoteOperands(ParseSignatures.AddSignatures, ref left, ref right);
|
left = GenerateBinary(ExpressionType.Add, left, right);
|
}
|
break;
|
case TokenId.Minus:
|
CheckAndPromoteOperands(ParseSignatures.SubtractSignatures, ref left, ref right);
|
left = GenerateBinary(ExpressionType.Subtract, left, right);
|
break;
|
}
|
}
|
return left;
|
}
|
|
// << , >> operators
|
private Expression ParseShift()
|
{
|
var left = ParseAdditive();
|
while (IsShiftOperator(out var shiftType))
|
{
|
NextToken();
|
var right = ParseAdditive();
|
CheckAndPromoteOperands(ParseSignatures.ShiftSignatures, ref left, ref right);
|
left = GenerateBinary(shiftType, left, right);
|
}
|
return left;
|
}
|
|
/// <summary>
|
/// Returns true if and only if the current token is in fact a shift operator.
|
/// In that case <paramref name="shiftType"/> is set to the proper expression type.
|
/// If the function returns false, <paramref name="shiftType"/> shouldn't be used.
|
/// </summary>
|
public bool IsShiftOperator(out ExpressionType shiftType)
|
{
|
// >> is not a token, because it conflicts with generics such as List<List<int>>
|
if (_token.id == TokenId.GreaterThan && _parseChar == '>')
|
{
|
NextToken(); // consume next >
|
shiftType = ExpressionType.RightShift;
|
return true;
|
}
|
// << could be a token, but is not for symmetry
|
else if (_token.id == TokenId.LessThan && _parseChar == '<')
|
{
|
NextToken(); // consume next <
|
shiftType = ExpressionType.LeftShift;
|
return true;
|
}
|
|
// dummy expression type that shouldn't be used
|
shiftType = ExpressionType.DebugInfo;
|
return false;
|
}
|
|
// *, /, % operators
|
private Expression ParseMultiplicative()
|
{
|
var left = ParseUnary();
|
while (_token.id == TokenId.Asterisk || _token.id == TokenId.Slash ||
|
_token.id == TokenId.Percent)
|
{
|
var op = _token;
|
NextToken();
|
var right = ParseUnary();
|
|
CheckAndPromoteOperands(ParseSignatures.ArithmeticSignatures, ref left, ref right);
|
|
switch (op.id)
|
{
|
case TokenId.Asterisk:
|
left = GenerateBinary(ExpressionType.Multiply, left, right);
|
break;
|
case TokenId.Slash:
|
left = GenerateBinary(ExpressionType.Divide, left, right);
|
break;
|
case TokenId.Percent:
|
left = GenerateBinary(ExpressionType.Modulo, left, right);
|
break;
|
}
|
}
|
return left;
|
}
|
|
// +,-, ! unary operators
|
private Expression ParseUnary()
|
{
|
if (_token.id == TokenId.Minus || _token.id == TokenId.Plus ||
|
_token.id == TokenId.Exclamation || _token.id == TokenId.Tilde)
|
{
|
var op = _token;
|
NextToken();
|
if (_token.id == TokenId.IntegerLiteral ||
|
_token.id == TokenId.RealLiteral)
|
{
|
if (op.id == TokenId.Minus)
|
{
|
_token.text = "-" + _token.text;
|
_token.pos = op.pos;
|
return ParsePrimary();
|
}
|
|
if (op.id == TokenId.Plus)
|
{
|
_token.text = "+" + _token.text;
|
_token.pos = op.pos;
|
return ParsePrimary();
|
}
|
}
|
var expr = ParseUnary();
|
if (op.id == TokenId.Minus)
|
{
|
CheckAndPromoteOperand(ParseSignatures.NegationSignatures, ref expr);
|
expr = GenerateUnary(ExpressionType.Negate, expr);
|
}
|
else if (op.id == TokenId.Plus)
|
{
|
|
}
|
else if (op.id == TokenId.Exclamation)
|
{
|
CheckAndPromoteOperand(ParseSignatures.NotSignatures, ref expr);
|
expr = GenerateUnary(ExpressionType.Not, expr);
|
}
|
else if (op.id == TokenId.Tilde)
|
{
|
CheckAndPromoteOperand(ParseSignatures.BitwiseComplementSignatures, ref expr);
|
expr = GenerateUnary(ExpressionType.OnesComplement, expr);
|
}
|
return expr;
|
}
|
return ParsePrimary();
|
}
|
|
private Expression GenerateUnary(ExpressionType unaryType, Expression expr)
|
{
|
if (IsDynamicExpression(expr))
|
return GenerateUnaryDynamic(unaryType, expr);
|
|
// enum unary operations are not resolved properly by Linq
|
var unaryOps = new[] { ExpressionType.OnesComplement };
|
if (expr.Type.IsEnum && unaryOps.Contains(unaryType))
|
return GenerateUnaryEnums(unaryType, expr);
|
|
// find the overloaded unary operator
|
string opName;
|
switch (unaryType)
|
{
|
case ExpressionType.Negate: opName = "op_UnaryNegation"; break;
|
case ExpressionType.Not: opName = "op_LogicalNot"; break;
|
case ExpressionType.OnesComplement: opName = "op_OnesComplement"; break;
|
default: opName = null; break;
|
}
|
|
var applicableMethod = FindUnaryOperator(opName, expr);
|
|
MethodInfo operatorMethod = null;
|
if (applicableMethod != null)
|
{
|
operatorMethod = applicableMethod.MethodBase as MethodInfo;
|
expr = applicableMethod.PromotedParameters[0];
|
}
|
|
// if no operator was found, the default Linq resolution will occur
|
return Expression.MakeUnary(unaryType, expr, null, operatorMethod);
|
}
|
|
private Expression GenerateUnaryEnums(ExpressionType unaryType, Expression expr)
|
{
|
var enumType = expr.Type;
|
var underlyingType = enumType.GetEnumUnderlyingType();
|
expr = Expression.Convert(expr, underlyingType);
|
return Expression.MakeUnary(unaryType, expr, enumType);
|
}
|
|
private Expression GenerateUnaryDynamic(ExpressionType unaryType, Expression expr)
|
{
|
var binder = Microsoft.CSharp.RuntimeBinder.Binder.UnaryOperation(
|
CSharpBinderFlags.None,
|
unaryType,
|
typeof(Parser),
|
new CSharpArgumentInfo[] {
|
CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null)}
|
);
|
|
return Expression.Dynamic(binder, typeof(object), expr);
|
}
|
|
private MethodData FindUnaryOperator(string operatorName, Expression expr)
|
{
|
if (operatorName == null)
|
return null;
|
|
var errorPos = _token.pos;
|
var type = expr.Type;
|
var args = new[] { expr };
|
|
// try to find the user defined operator on both operands
|
var applicableMethods = _memberFinder.FindMethods(type, operatorName, true, args);
|
if (applicableMethods.Count > 1)
|
throw ParseException.Create(errorPos, ErrorMessages.AmbiguousUnaryOperatorInvocation, operatorName, TypeUtils.GetTypeName(type));
|
|
MethodData userDefinedOperator = null;
|
if (applicableMethods.Count == 1)
|
userDefinedOperator = applicableMethods[0];
|
|
return userDefinedOperator;
|
}
|
|
private Expression ParsePrimary()
|
{
|
var tokenPos = _token.pos;
|
var expr = ParsePrimaryStart();
|
while (true)
|
{
|
if (_token.id == TokenId.Dot)
|
{
|
NextToken();
|
expr = ParseMemberAccess(expr);
|
}
|
// special case for ?. and ?[ operators
|
else if (_token.id == TokenId.Question && (_parseChar == '.' || _parseChar == '['))
|
{
|
NextToken();
|
|
if (_token.id == TokenId.Dot)
|
{
|
NextToken();
|
|
// ?. operator changes value types to nullable types
|
// the member access should be resolved on the underlying type
|
var memberAccess = GenerateNullableTypeConversion(ParseMemberAccess(GenerateGetNullableValue(expr)));
|
var nullExpr = ParserConstants.NullLiteralExpression;
|
CheckAndPromoteOperands(ParseSignatures.EqualitySignatures, ref expr, ref nullExpr);
|
expr = GenerateConditional(GenerateEqual(expr, nullExpr), ParserConstants.NullLiteralExpression, memberAccess, _token.pos);
|
}
|
else if (_token.id == TokenId.OpenBracket)
|
{
|
// ?[ operator changes value types to nullable types
|
// the member access should be resolved on the underlying type
|
var elementAccess = GenerateNullableTypeConversion(ParseElementAccess(GenerateGetNullableValue(expr)));
|
var nullExpr = ParserConstants.NullLiteralExpression;
|
CheckAndPromoteOperands(ParseSignatures.EqualitySignatures, ref expr, ref nullExpr);
|
expr = GenerateConditional(GenerateEqual(expr, nullExpr), ParserConstants.NullLiteralExpression, elementAccess, _token.pos);
|
}
|
}
|
else if (_token.id == TokenId.OpenBracket)
|
{
|
expr = ParseElementAccess(expr);
|
}
|
else if (_token.id == TokenId.OpenParen)
|
{
|
if (expr is LambdaExpression lambda)
|
return ParseLambdaInvocation(lambda, tokenPos);
|
|
if (expr is MethodGroupExpression methodGroup)
|
expr = ParseMethodGroupInvocation(methodGroup, tokenPos);
|
else if (typeof(Delegate).IsAssignableFrom(expr.Type))
|
expr = ParseDelegateInvocation(expr, tokenPos);
|
else
|
throw ParseException.Create(tokenPos, ErrorMessages.InvalidMethodCall, TypeUtils.GetTypeName(expr.Type));
|
}
|
else
|
{
|
break;
|
}
|
}
|
return expr;
|
}
|
|
/// <summary>
|
/// Generate a call to the HasValue property of the Nullable type */
|
/// </summary>
|
private Expression GenerateGetNullableHasValue(Expression expr)
|
{
|
if (!TypeUtils.IsNullableType(expr.Type))
|
return expr;
|
return GeneratePropertyOrFieldExpression(expr.Type, expr, _token.pos, "HasValue");
|
}
|
|
/// <summary>
|
/// Generate a call to the Value property of the Nullable type */
|
/// </summary>
|
private Expression GenerateGetNullableValue(Expression expr)
|
{
|
if (!TypeUtils.IsNullableType(expr.Type))
|
return expr;
|
return GeneratePropertyOrFieldExpression(expr.Type, expr, _token.pos, "Value");
|
}
|
|
private Expression ParsePrimaryStart()
|
{
|
switch (_token.id)
|
{
|
case TokenId.Identifier:
|
return ParseIdentifier();
|
case TokenId.CharLiteral:
|
return ParseCharLiteral();
|
case TokenId.StringLiteral:
|
return ParseStringLiteral();
|
case TokenId.IntegerLiteral:
|
return ParseIntegerLiteral();
|
case TokenId.RealLiteral:
|
return ParseRealLiteral();
|
case TokenId.OpenParen:
|
return ParseParenExpression();
|
case TokenId.End:
|
return Expression.Empty();
|
default:
|
throw ParseException.Create(_token.pos, ErrorMessages.ExpressionExpected);
|
}
|
}
|
|
private Expression ParseCharLiteral()
|
{
|
ValidateToken(TokenId.CharLiteral);
|
var s = _token.text.Substring(1, _token.text.Length - 2);
|
|
s = EvalEscapeStringLiteral(s);
|
|
if (s.Length != 1)
|
throw ParseException.Create(_token.pos, ErrorMessages.InvalidCharacterLiteral);
|
|
NextToken();
|
return CreateLiteral(s[0]);
|
}
|
|
private Expression ParseStringLiteral()
|
{
|
ValidateToken(TokenId.StringLiteral);
|
var s = _token.text.Substring(1, _token.text.Length - 2);
|
|
s = EvalEscapeStringLiteral(s);
|
|
//int start = 0;
|
//while (true)
|
//{
|
// int i = s.IndexOf(quote, start);
|
// if (i < 0)
|
// break;
|
// s = s.Remove(i, 1);
|
// start = i + 1;
|
//}
|
|
NextToken();
|
return CreateLiteral(s);
|
}
|
|
private string EvalEscapeStringLiteral(string source)
|
{
|
// most of the string will not have escape sequences; avoid allocation if possible
|
if (source.IndexOf('\\') < 0)
|
return source;
|
|
var builder = new StringBuilder(source.Length);
|
for (var i = 0; i < source.Length; i++)
|
{
|
var c = source[i];
|
if (c == '\\')
|
{
|
if ((i + 1) == source.Length)
|
throw ParseException.Create(_token.pos, ErrorMessages.InvalidEscapeSequence);
|
|
builder.Append(EvalEscapeChar(source[++i]));
|
}
|
else
|
builder.Append(c);
|
}
|
|
return builder.ToString();
|
}
|
|
private char EvalEscapeChar(char source)
|
{
|
switch (source)
|
{
|
case '\'':
|
case '"':
|
case '\\':
|
return source;
|
case '0':
|
return '\0';
|
case 'a':
|
return '\a';
|
case 'b':
|
return '\b';
|
case 'f':
|
return '\f';
|
case 'n':
|
return '\n';
|
case 'r':
|
return '\r';
|
case 't':
|
return '\t';
|
case 'v':
|
return '\v';
|
default:
|
throw ParseException.Create(_token.pos, ErrorMessages.InvalidEscapeSequence);
|
}
|
}
|
|
private Expression ParseIntegerLiteral()
|
{
|
ValidateToken(TokenId.IntegerLiteral);
|
var text = _token.text;
|
|
var isUnsigned = false;
|
var isLong = false;
|
var numberEnd = text.Length - 1;
|
for (; numberEnd >= 0; numberEnd--)
|
{
|
var chr = text[numberEnd];
|
if (chr == 'U' || chr == 'u')
|
isUnsigned = true;
|
else if (chr == 'L' || chr == 'l')
|
isLong = true;
|
else
|
break;
|
}
|
|
text = text.Substring(0, numberEnd + 1);
|
|
// No suffix found, verify if DefaultNumberType.Long is specified
|
if (_defaultNumberType == DefaultNumberType.Long) isLong = true;
|
|
if (text[0] != '-')
|
{
|
ulong value;
|
if (text.StartsWith("0x") || text.StartsWith("0X"))
|
{
|
var hex = text.Substring(2);
|
if (!ulong.TryParse(hex, ParseLiteralHexNumberStyle, ParseCulture, out value))
|
throw ParseException.Create(_token.pos, ErrorMessages.InvalidIntegerLiteral, text);
|
}
|
else if (text.StartsWith("0b") || text.StartsWith("0B"))
|
{
|
var binary = text.Substring(2);
|
if (string.IsNullOrEmpty(binary))
|
throw ParseException.Create(_token.pos, ErrorMessages.InvalidIntegerLiteral, text);
|
|
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 ParseException.Create(_token.pos, ErrorMessages.InvalidIntegerLiteral, text);
|
|
NextToken();
|
|
if (!isUnsigned && !isLong && value <= int.MaxValue)
|
return CreateLiteral((int)value);
|
if (!isLong && value <= uint.MaxValue)
|
return CreateLiteral((uint)value);
|
if (!isUnsigned && value <= long.MaxValue)
|
return CreateLiteral((long)value);
|
|
return CreateLiteral(value);
|
}
|
else
|
{
|
if (!long.TryParse(text, ParseLiteralNumberStyle, ParseCulture, out var value))
|
throw ParseException.Create(_token.pos, ErrorMessages.InvalidIntegerLiteral, text);
|
|
NextToken();
|
|
if (!isLong && value >= int.MinValue && value <= int.MaxValue)
|
return CreateLiteral((int)value);
|
|
return CreateLiteral(value);
|
}
|
}
|
|
private Expression ParseRealLiteral()
|
{
|
ValidateToken(TokenId.RealLiteral);
|
var text = _token.text;
|
object value = null;
|
var last = text[text.Length - 1];
|
|
if (last == 'F' || last == 'f')
|
{
|
if (float.TryParse(text.Substring(0, text.Length - 1), ParseLiteralDecimalNumberStyle, ParseCulture, out var f))
|
value = f;
|
}
|
else if (last == 'M' || last == 'm')
|
{
|
if (decimal.TryParse(text.Substring(0, text.Length - 1), ParseLiteralDecimalNumberStyle, ParseCulture, out var dc))
|
value = dc;
|
}
|
else if (last == 'D' || last == 'd')
|
{
|
if (double.TryParse(text.Substring(0, text.Length - 1), ParseLiteralDoubleNumberStyle, ParseCulture, out var d))
|
value = d;
|
}
|
else
|
{
|
// No suffix find, use DefaultNumberType settigns if specified (Double default)
|
if (_defaultNumberType == DefaultNumberType.Decimal)
|
{
|
if (decimal.TryParse(text, ParseLiteralDecimalNumberStyle, ParseCulture, out var dc))
|
value = dc;
|
}
|
else if (_defaultNumberType == DefaultNumberType.Single)
|
{
|
if (float.TryParse(text, ParseLiteralDecimalNumberStyle, ParseCulture, out var f))
|
value = f;
|
}
|
else
|
{
|
if (double.TryParse(text, ParseLiteralDoubleNumberStyle, ParseCulture, out var d))
|
value = d;
|
}
|
}
|
|
if (value == null)
|
throw ParseException.Create(_token.pos, ErrorMessages.InvalidRealLiteral, text);
|
|
NextToken();
|
|
return CreateLiteral(value);
|
}
|
|
private static Expression CreateLiteral(object value)
|
{
|
var expr = Expression.Constant(value);
|
|
return expr;
|
}
|
|
private Expression ParseParenExpression()
|
{
|
ValidateToken(TokenId.OpenParen, ErrorMessages.OpenParenExpected);
|
NextToken();
|
var innerParenthesesExpression = ParseExpressionSegment();
|
ValidateToken(TokenId.CloseParen, ErrorMessages.CloseParenOrOperatorExpected);
|
|
if (innerParenthesesExpression is ConstantExpression constExp && constExp.Value is Type constType)
|
{
|
NextToken();
|
|
// we're in a cast expression, the next expression can only be a unary expression
|
var nextExpression = ParseUnary();
|
|
// cast: (constType)nextExpression
|
return Expression.Convert(nextExpression, constType);
|
}
|
|
NextToken();
|
return innerParenthesesExpression;
|
}
|
|
private Expression ParseIdentifier()
|
{
|
ValidateToken(TokenId.Identifier);
|
|
// Working context implementation
|
//if (token.text == ParserConstants.keywordIt)
|
// return ParseIt();
|
|
if (_token.text == ParserConstants.KeywordNew)
|
return ParseNew();
|
if (_token.text == ParserConstants.KeywordTypeof)
|
return ParseTypeof();
|
if (_token.text == ParserConstants.KeywordDefault)
|
return ParseDefaultOperator();
|
|
if (_arguments.TryGetIdentifier(_token.text, out var keywordExpression))
|
{
|
NextToken();
|
return keywordExpression;
|
}
|
|
if (_arguments.TryGetParameters(_token.text, out var parameterExpression))
|
{
|
NextToken();
|
return parameterExpression;
|
}
|
|
if (TryParseKnownType(_token.text, out var knownType))
|
{
|
return ParseTypeKeyword(knownType);
|
}
|
|
var token = _token;
|
|
try
|
{
|
if (_arguments.TryGetIdentifier(LanguageConstants.This, out var thisKeywordExpression))
|
{
|
return ParseMemberAccess(thisKeywordExpression);
|
}
|
|
if (_arguments.TryGetParameters(LanguageConstants.This, out var thisParameterExpression))
|
{
|
return ParseMemberAccess(thisParameterExpression);
|
}
|
}
|
catch (ParseException)
|
{
|
// ignore
|
}
|
|
// Working context implementation
|
//if (it != null)
|
// return ParseMemberAccess(null, it);
|
|
throw new UnknownIdentifierException(token.text, token.pos);
|
}
|
|
// Working context implementation
|
//Expression ParseIt()
|
//{
|
// if (it == null)
|
// throw ParseError(ErrorMessages.NoItInScope);
|
// NextToken();
|
// return it;
|
//}
|
|
//Expression ParseIif()
|
//{
|
// int errorPos = token.pos;
|
// NextToken();
|
// Expression[] args = ParseArgumentList();
|
// if (args.Length != 3)
|
// throw ParseError(errorPos, ErrorMessages.IifRequiresThreeArgs);
|
// return GenerateConditional(args[0], args[1], args[2], errorPos);
|
//}
|
|
private Expression ParseTypeof()
|
{
|
var errorPos = _token.pos;
|
NextToken();
|
var args = ParseArgumentList();
|
if (args.Length != 1)
|
throw ParseException.Create(errorPos, ErrorMessages.TypeofRequiresOneArg);
|
|
if (!(args[0] is ConstantExpression constExp && constExp.Value is Type))
|
throw ParseException.Create(errorPos, ErrorMessages.TypeofRequiresAType);
|
|
return constExp;
|
}
|
|
private Expression ParseDefaultOperator()
|
{
|
NextToken();
|
|
ValidateToken(TokenId.OpenParen, ErrorMessages.OpenParenExpected);
|
NextToken();
|
ValidateToken(TokenId.Identifier);
|
var type = ParseKnownType();
|
ValidateToken(TokenId.CloseParen, ErrorMessages.CloseParenOrCommaExpected);
|
NextToken();
|
|
return Expression.Default(type);
|
}
|
|
private Expression GenerateConditional(Expression test, Expression expr1, Expression expr2, int errorPos)
|
{
|
if (IsDynamicExpression(test))
|
return GenerateConditionalDynamic(test, expr1, expr2, errorPos);
|
|
if (test.Type != typeof(bool))
|
throw ParseException.Create(errorPos, ErrorMessages.FirstExprMustBeBool);
|
if (expr1.Type != expr2.Type)
|
{
|
var expr1As2 = expr2 != ParserConstants.NullLiteralExpression ? ExpressionUtils.PromoteExpression(expr1, expr2.Type) : null;
|
var expr2As1 = expr1 != ParserConstants.NullLiteralExpression ? ExpressionUtils.PromoteExpression(expr2, expr1.Type) : null;
|
if (expr1As2 != null && expr2As1 == null)
|
{
|
expr1 = expr1As2;
|
}
|
else if (expr2As1 != null && expr1As2 == null)
|
{
|
expr2 = expr2As1;
|
}
|
else
|
{
|
var type1 = expr1 != ParserConstants.NullLiteralExpression ? expr1.Type.Name : "null";
|
var type2 = expr2 != ParserConstants.NullLiteralExpression ? expr2.Type.Name : "null";
|
if (expr1As2 != null)
|
throw ParseException.Create(errorPos, ErrorMessages.BothTypesConvertToOther, type1, type2);
|
|
throw ParseException.Create(errorPos, ErrorMessages.NeitherTypeConvertsToOther, type1, type2);
|
}
|
}
|
return Expression.Condition(test, expr1, expr2);
|
}
|
|
private Expression GenerateConditionalDynamic(Expression test, Expression expr1, Expression expr2, int errorPos)
|
{
|
var casted = ConvertBoolExpression(test);
|
|
return GenerateConditional(casted, expr1, expr2, errorPos);
|
}
|
|
private Expression ParseNew()
|
{
|
NextToken();
|
ValidateToken(TokenId.Identifier, ErrorMessages.IdentifierExpected);
|
|
var newType = ParseKnownType();
|
var args = new Expression[0];
|
|
if (newType.IsArray)
|
{
|
if (newType.GetArrayRank() != 1)
|
throw ParseException.Create(_token.pos, ErrorMessages.UnsupportedMultidimensionalArrays, newType);
|
|
args = ParseArrayInitializerList();
|
return Expression.NewArrayInit(newType.GetElementType(), args);
|
}
|
|
if (_token.id == TokenId.OpenParen)
|
args = ParseArgumentList();
|
else
|
{
|
// no aguments: expect an object initializer
|
ValidateToken(TokenId.OpenCurlyBracket, ErrorMessages.OpenCurlyBracketExpected);
|
}
|
|
var applicableConstructors = MethodResolution.FindBestMethod(newType.GetConstructors(), args);
|
if (applicableConstructors.Count == 0)
|
throw ParseException.Create(_token.pos, ErrorMessages.NoApplicableConstructor, newType);
|
|
if (applicableConstructors.Count > 1)
|
throw ParseException.Create(_token.pos, ErrorMessages.AmbiguousConstructorInvocation, newType);
|
|
var constructor = applicableConstructors[0];
|
var newExpr = Expression.New((ConstructorInfo)constructor.MethodBase, constructor.PromotedParameters);
|
|
if (_token.id == TokenId.OpenCurlyBracket)
|
return ParseWithObjectInitializer(newExpr, newType);
|
|
return newExpr;
|
}
|
|
private Expression[] ParseArrayInitializerList()
|
{
|
return ParseArgumentList(TokenId.OpenCurlyBracket, ErrorMessages.OpenCurlyBracketExpected,
|
TokenId.CloseCurlyBracket, ErrorMessages.CloseCurlyBracketExpected,
|
allowTrailingComma: true);
|
}
|
|
private Expression ParseWithObjectInitializer(NewExpression newExpr, Type newType)
|
{
|
ValidateToken(TokenId.OpenCurlyBracket, ErrorMessages.OpenCurlyBracketExpected);
|
NextToken();
|
var initializedInstance = ParseMemberAndInitializerList(newExpr, newType);
|
ValidateToken(TokenId.CloseCurlyBracket, ErrorMessages.CloseCurlyBracketExpected);
|
NextToken();
|
return initializedInstance;
|
}
|
|
private Expression ParseMemberAndInitializerList(NewExpression newExpr, Type newType)
|
{
|
var originalPos = _token.pos;
|
var bindingList = new List<MemberBinding>();
|
var actions = new List<Expression>();
|
var instance = Expression.Variable(newType);
|
var allowCollectionInit = typeof(IEnumerable).IsAssignableFrom(newType);
|
while (true)
|
{
|
if (_token.id == TokenId.CloseCurlyBracket) break;
|
if (_token.id != TokenId.Identifier)
|
{
|
ParseCollectionInitalizer(newType, originalPos, bindingList, actions, instance, allowCollectionInit);
|
}
|
else
|
{
|
ParsePossibleMemberBinding(newType, bindingList, actions, instance, allowCollectionInit);
|
}
|
if (_token.id != TokenId.Comma) break;
|
NextToken();
|
}
|
if (bindingList.Count == 0)
|
{
|
actions.Insert(0, Expression.Assign(instance, newExpr));
|
actions.Add(instance);
|
return Expression.Block(new ParameterExpression[] { instance }, actions);
|
}
|
return Expression.MemberInit(newExpr, bindingList);
|
}
|
|
private void ParsePossibleMemberBinding(Type newType, List<MemberBinding> bindingList, List<Expression> actions, ParameterExpression instance, bool allowCollectionInit)
|
{
|
ValidateToken(TokenId.Identifier, ErrorMessages.IdentifierExpected);
|
|
var propertyOrFieldName = _token.text;
|
var member = _memberFinder.FindPropertyOrField(newType, propertyOrFieldName, false);
|
var pos = _token.pos;
|
if (allowCollectionInit)
|
{
|
NextToken();
|
//new T(){Prop = 1}
|
//new T(){{variable = 2}}
|
if (_token.id == TokenId.Equal && member != null)
|
{
|
if (actions.Count > 0)
|
{
|
throw ParseException.Create(pos, ErrorMessages.InvalidInitializerMemberDeclarator);
|
}
|
}
|
else if (_token.id != TokenId.Equal || _arguments.TryGetIdentifier(propertyOrFieldName, out _) || _arguments.TryGetParameters(propertyOrFieldName, out _))
|
{
|
SetTextPos(pos);
|
NextToken();
|
ParseCollectionInitalizer(newType, pos, bindingList, actions, instance, allowCollectionInit);
|
return;
|
}
|
SetTextPos(pos);
|
NextToken();
|
}
|
if (member == null)
|
{
|
throw ParseException.Create(pos, ErrorMessages.UnknownPropertyOrField, propertyOrFieldName, TypeUtils.GetTypeName(newType));
|
}
|
NextToken();
|
|
ValidateToken(TokenId.Equal, ErrorMessages.EqualExpected);
|
NextToken();
|
|
var value = ParseExpressionSegment();
|
bindingList.Add(Expression.Bind(member, value));
|
}
|
|
private void ParseCollectionInitalizer(Type newType, int originalPos, List<MemberBinding> bindingList, List<Expression> actions, ParameterExpression instance, bool allowCollectionInit)
|
{
|
if (!allowCollectionInit)
|
{
|
throw ParseException.Create(_token.pos, ErrorMessages.CollectionInitializationNotSupported, newType, typeof(IEnumerable));
|
}
|
if (bindingList.Count > 0)
|
{
|
throw ParseException.Create(originalPos, ErrorMessages.InvalidInitializerMemberDeclarator);
|
}
|
if (_token.id == TokenId.OpenCurlyBracket)
|
{
|
var pos = _token.pos;
|
NextToken();
|
|
if (_token.id == TokenId.Identifier)
|
{
|
var identifierName = _token.text;
|
NextToken();
|
if (_token.id == TokenId.Equal && !_arguments.TryGetIdentifier(identifierName, out _) && !_arguments.TryGetParameters(identifierName, out _))
|
{
|
throw ParseException.Create(_token.pos, ErrorMessages.InvalidInitializerMemberDeclarator);
|
}
|
else
|
{
|
SetTextPos(pos);
|
NextToken();
|
}
|
}
|
else
|
{
|
SetTextPos(pos);
|
ParseExpressionSegment();
|
}
|
actions.Add(ParseMethodInvocation(newType, instance, _token.pos, "Add", TokenId.OpenCurlyBracket, ErrorMessages.OpenCurlyBracketExpected, TokenId.CloseCurlyBracket, ErrorMessages.CloseCurlyBracketExpected));
|
}
|
else
|
{
|
var args = new[] { ParseExpressionSegment() };
|
var addMethod = ParseNormalMethodInvocation(newType, instance, _token.pos, "Add", args);
|
if (addMethod == null)
|
{
|
throw ParseException.Create(_token.pos, ErrorMessages.UnableToFindAppropriateAddMethod, TypeUtils.GetTypeName(newType));
|
}
|
actions.Add(addMethod);
|
}
|
}
|
|
private Expression ParseLambdaInvocation(LambdaExpression lambda, int errorPos)
|
{
|
return ParseInvocation(lambda, errorPos, ErrorMessages.ArgsIncompatibleWithLambda);
|
}
|
|
private Expression ParseDelegateInvocation(Expression delegateExp, int errorPos)
|
{
|
return ParseInvocation(delegateExp, errorPos, ErrorMessages.ArgsIncompatibleWithDelegate);
|
}
|
|
private Expression ParseInvocation(Expression expr, int errorPos, string error)
|
{
|
var args = ParseArgumentList();
|
|
var invokeMethod = MemberFinder.FindInvokeMethod(expr.Type);
|
if (invokeMethod != null)
|
{
|
var invokeMethodData = MethodData.Gen(invokeMethod);
|
if (MethodResolution.CheckIfMethodIsApplicableAndPrepareIt(invokeMethodData, args))
|
return Expression.Invoke(expr, invokeMethodData.PromotedParameters);
|
}
|
|
throw ParseException.Create(errorPos, error);
|
}
|
|
private Expression ParseMethodGroupInvocation(MethodGroupExpression methodGroup, int errorPos)
|
{
|
var args = ParseArgumentList();
|
|
// find the best delegates that can be used with the provided arguments
|
// we can either use the method directly, or the Invoke method of the delegate
|
var usedInvokeMethod = false;
|
var candidates = methodGroup.Overloads;
|
var applicableMethods = MethodResolution.FindBestMethod(candidates.Select(_ => _.Method), args);
|
|
// no method found: retry with the delegate's method
|
// (the parameters might be different, e.g. params array, default value, etc)
|
if (applicableMethods.Count == 0)
|
{
|
usedInvokeMethod = true;
|
applicableMethods = MethodResolution.FindBestMethod(candidates.Select(_ => _.InvokeMethod), args);
|
}
|
|
if (applicableMethods.Count == 0)
|
{
|
if (args.Any(IsDynamicExpression))
|
{
|
// TODO: we could try to find the best method by using the dynamic binder
|
var candidatesWithSameArgumentCount = candidates.Where(_ => _.Method.GetParameters().Length == args.Length).ToList();
|
if (candidatesWithSameArgumentCount.Count == 1)
|
return ParseDynamicMethodGroupInvocation(candidatesWithSameArgumentCount[0].Delegate, args);
|
}
|
|
throw ParseException.Create(errorPos, ErrorMessages.ArgsIncompatibleWithDelegate);
|
}
|
|
if (applicableMethods.Count > 1)
|
throw ParseException.Create(errorPos, ErrorMessages.AmbiguousDelegateInvocation);
|
|
var applicableMethod = applicableMethods[0];
|
var usedDelegate = methodGroup.FindUsedOverload(usedInvokeMethod, applicableMethod);
|
return Expression.Invoke(Expression.Constant(usedDelegate), applicableMethod.PromotedParameters);
|
}
|
|
private Type ParseKnownType()
|
{
|
var name = _token.text;
|
var errorPos = _token.pos;
|
if (!TryParseKnownType(name, out var type))
|
throw new UnknownIdentifierException(name, errorPos);
|
|
return type;
|
}
|
|
private bool TryParseKnownType(string name, out Type type)
|
{
|
// if the type is unknown, we need to restart parsing
|
var originalPos = _token.pos;
|
|
// the name might reference a generic type, with an aliased name (e.g. List<T> = MyList instead of List`1)
|
// it can also reference a generic type for which we don't know the arity yet (and therefore the name doesn't contain the `n suffix)
|
if (_arguments.TryGetKnownType(name, out type) || _arguments.HasKnownGenericTypeDefinition(name))
|
{
|
type = ParseKnownGenericType(name, type);
|
}
|
|
type = ParseTypeModifiers(type);
|
|
if (type == null)
|
{
|
// type name couldn't be parsed: restore position
|
SetTextPos(originalPos);
|
NextToken();
|
return false;
|
}
|
|
return true;
|
}
|
|
private Type ParseKnownGenericType(string name, Type type)
|
{
|
NextToken();
|
if (_token.id == TokenId.LessThan)
|
{
|
var typeArguments = ParseTypeArgumentList();
|
var rank = typeArguments.Count;
|
|
// if no type was registered with the simple name, try the full generic name
|
if (type == null && !_arguments.TryGetKnownType(name + $"`{rank}", out type))
|
return null;
|
|
if (rank != type.GetGenericArguments().Length)
|
throw new ArgumentException(ErrorMessages.GenericArgumentCountMismatch);
|
|
// there are actual type arguments: instantiate the proper generic type
|
if (typeArguments.All(_ => _ != null))
|
type = type.MakeGenericType(typeArguments.ToArray());
|
|
NextToken();
|
}
|
|
return type;
|
}
|
|
// we found a known type identifier, check if it has some modifiers
|
private Type ParseTypeModifiers(Type type)
|
{
|
// type modifiers require the base type to be known
|
if (type == null)
|
return null;
|
|
var errorPos = _token.pos;
|
if (_token.id == TokenId.Question)
|
{
|
if (!type.IsValueType || TypeUtils.IsNullableType(type))
|
throw ParseException.Create(errorPos, ErrorMessages.TypeHasNoNullableForm, TypeUtils.GetTypeName(type));
|
type = typeof(Nullable<>).MakeGenericType(type);
|
|
NextToken();
|
type = ParseTypeModifiers(type);
|
}
|
else if (_token.id == TokenId.OpenBracket)
|
{
|
type = ParseArrayRankSpecifier(type);
|
}
|
|
return type;
|
}
|
|
private Type ParseArrayRankSpecifier(Type type)
|
{
|
ValidateToken(TokenId.OpenBracket);
|
|
// An array type of the form T[R][R1]...[Rn] is an array with rank R and an element type T[R1]...[Rn]
|
// => we need to parse all rank specifiers in one pass, and create the array from right to left
|
var ranks = new Stack<int>();
|
while (_token.id == TokenId.OpenBracket)
|
{
|
NextToken();
|
var rank = 1;
|
while (_token.id == TokenId.Comma)
|
{
|
rank++;
|
NextToken();
|
}
|
|
ValidateToken(TokenId.CloseBracket, ErrorMessages.CloseBracketOrCommaExpected);
|
ranks.Push(rank);
|
NextToken();
|
}
|
|
while (ranks.Count > 0)
|
{
|
var rank = ranks.Pop();
|
type = rank == 1 ? type.MakeArrayType() : type.MakeArrayType(rank);
|
}
|
|
return type;
|
}
|
|
private List<Type> ParseTypeArgumentList()
|
{
|
ValidateToken(TokenId.LessThan);
|
NextToken();
|
|
List<Type> args;
|
if (_token.id == TokenId.Identifier)
|
args = ParseTypeArguments();
|
else
|
{
|
var arity = ParseUnboundTypeArity();
|
args = new List<Type>(new Type[arity]);
|
}
|
|
ValidateToken(TokenId.GreaterThan, ErrorMessages.CloseTypeArgumentListExpected);
|
return args;
|
}
|
|
private List<Type> ParseTypeArguments()
|
{
|
var genericArguments = new List<Type>();
|
while (true)
|
{
|
ValidateToken(TokenId.Identifier);
|
genericArguments.Add(ParseKnownType());
|
if (_token.id != TokenId.Comma) break;
|
NextToken();
|
}
|
|
return genericArguments;
|
}
|
|
private int ParseUnboundTypeArity()
|
{
|
var rank = 1;
|
while (_token.id == TokenId.Comma)
|
{
|
rank++;
|
NextToken();
|
}
|
|
return rank;
|
}
|
|
private Expression ParseTypeKeyword(Type type)
|
{
|
//if (token.id == TokenId.OpenParen)
|
//{
|
// return ParseTypeConstructor(type, errorPos);
|
//}
|
|
if (_token.id == TokenId.CloseParen)
|
{
|
return Expression.Constant(type);
|
}
|
|
ValidateToken(TokenId.Dot, ErrorMessages.DotOrOpenParenExpected);
|
NextToken();
|
return ParseMemberAccess(type, null);
|
}
|
|
//private Expression ParseTypeConstructor(Type type, int errorPos)
|
//{
|
// Expression[] args = ParseArgumentList();
|
// MethodBase method;
|
// switch (FindBestMethod(type.GetConstructors(), args, out method))
|
// {
|
// case 0:
|
// if (args.Length == 1)
|
// return GenerateConversion(args[0], type, errorPos);
|
// throw ParseError(errorPos, ErrorMessages.NoMatchingConstructor, TypeUtils.GetTypeName(type));
|
// case 1:
|
// return Expression.New((ConstructorInfo)method, args);
|
// default:
|
// throw ParseError(errorPos, ErrorMessages.AmbiguousConstructorInvocation, TypeUtils.GetTypeName(type));
|
// }
|
//}
|
|
private Expression GenerateConversion(Expression expr, Type type, int errorPos)
|
{
|
var exprType = expr.Type;
|
if (exprType == type)
|
{
|
return expr;
|
}
|
|
//if (exprType.IsValueType && type.IsValueType)
|
//{
|
// if ((IsNullableType(exprType) || IsNullableType(type)) &&
|
// GetNonNullableType(exprType) == GetNonNullableType(type))
|
// return Expression.Convert(expr, type);
|
// if ((IsNumericType(exprType) || IsEnumType(exprType)) &&
|
// (IsNumericType(type)) || IsEnumType(type))
|
// return Expression.ConvertChecked(expr, type);
|
//}
|
|
//if (exprType.IsAssignableFrom(type) || type.IsAssignableFrom(exprType) ||
|
// exprType.IsInterface || type.IsInterface)
|
//{
|
// return Expression.Convert(expr, type);
|
//}
|
|
// generic type was not fully resolved; try to find a type in the inheritance hierarchy
|
// that matches the generic type definition
|
if (type.ContainsGenericParameters)
|
{
|
var typeDef = type.GetGenericTypeDefinition();
|
var interfaces = exprType.GetInterfaces().ToList();
|
for (var nextType = exprType.BaseType; nextType != null; nextType = nextType.BaseType)
|
{
|
interfaces.Add(nextType);
|
}
|
|
foreach (var inherited in interfaces)
|
{
|
if (inherited.IsGenericType && inherited.GetGenericTypeDefinition() == typeDef)
|
type = inherited;
|
}
|
}
|
|
try
|
{
|
if (expr is InterpreterExpression ie)
|
{
|
return ie.EvalAs(type);
|
}
|
|
return Expression.ConvertChecked(expr, type);
|
}
|
catch (InvalidOperationException)
|
{
|
throw ParseException.Create(errorPos, ErrorMessages.CannotConvertValue,
|
TypeUtils.GetTypeName(exprType), TypeUtils.GetTypeName(type));
|
}
|
}
|
|
private Expression ParseMemberAccess(Expression instance)
|
{
|
return ParseMemberAccess(null, instance);
|
}
|
|
private Expression ParseMemberAccess(Type type, Expression instance)
|
{
|
if (instance != null) type = instance.Type;
|
var errorPos = _token.pos;
|
var id = GetIdentifier();
|
NextToken();
|
if (_token.id == TokenId.OpenParen)
|
return ParseMethodInvocation(type, instance, errorPos, id);
|
|
return GeneratePropertyOrFieldExpression(type, instance, errorPos, id);
|
}
|
|
private Expression GeneratePropertyOrFieldExpression(Type type, Expression instance, int errorPos, string propertyOrFieldName)
|
{
|
var member = _memberFinder.FindPropertyOrField(type, propertyOrFieldName, instance == null);
|
if (member != null)
|
{
|
return member is PropertyInfo ?
|
Expression.Property(instance, (PropertyInfo)member) :
|
Expression.Field(instance, (FieldInfo)member);
|
}
|
|
if (TypeUtils.IsDynamicType(type) || IsDynamicExpression(instance))
|
return ParseDynamicProperty(instance, propertyOrFieldName);
|
|
throw ParseException.Create(errorPos, ErrorMessages.UnknownPropertyOrField, propertyOrFieldName, TypeUtils.GetTypeName(type));
|
}
|
|
private Expression ParseMethodInvocation(Type type, Expression instance, int errorPos, string methodName)
|
{
|
return ParseMethodInvocation(type, instance, errorPos, methodName, TokenId.OpenParen, ErrorMessages.OpenParenExpected, TokenId.CloseParen, ErrorMessages.CloseParenOrCommaExpected);
|
|
}
|
|
private Expression ParseMethodInvocation(Type type, Expression instance, int errorPos, string methodName, TokenId open, string openExpected, TokenId close, string closeExpected)
|
{
|
var args = ParseArgumentList(open, openExpected, close, closeExpected);
|
|
var methodInvocationExpression = ParseNormalMethodInvocation(type, instance, errorPos, methodName, args);
|
if (methodInvocationExpression == null && instance != null)
|
{
|
methodInvocationExpression = ParseExtensionMethodInvocation(type, instance, errorPos, methodName, args);
|
}
|
|
if (methodInvocationExpression != null)
|
return methodInvocationExpression;
|
|
if (TypeUtils.IsDynamicType(type) || IsDynamicExpression(instance) || args.Any(IsDynamicExpression))
|
return ParseDynamicMethodInvocation(type, instance, methodName, args);
|
|
throw new NoApplicableMethodException(methodName, TypeUtils.GetTypeName(type), errorPos);
|
}
|
|
private Expression ParseExtensionMethodInvocation(Type type, Expression instance, int errorPos, string methodName, Expression[] args)
|
{
|
var extensionMethodsArguments = new Expression[args.Length + 1];
|
extensionMethodsArguments[0] = instance;
|
args.CopyTo(extensionMethodsArguments, 1);
|
|
var extensionMethods = _memberFinder.FindExtensionMethods(methodName, extensionMethodsArguments);
|
if (extensionMethods.Count > 1)
|
throw ParseException.Create(errorPos, ErrorMessages.AmbiguousMethodInvocation, methodName, TypeUtils.GetTypeName(type));
|
|
if (extensionMethods.Count == 1)
|
{
|
var method = extensionMethods[0];
|
|
return Expression.Call((MethodInfo)method.MethodBase, method.PromotedParameters);
|
}
|
|
return null;
|
}
|
|
private Expression ParseNormalMethodInvocation(Type type, Expression instance, int errorPos, string methodName, Expression[] args)
|
{
|
var applicableMethods = _memberFinder.FindMethods(type, methodName, instance == null, args);
|
if (applicableMethods.Count > 1)
|
throw ParseException.Create(errorPos, ErrorMessages.AmbiguousMethodInvocation, methodName, TypeUtils.GetTypeName(type));
|
|
if (applicableMethods.Count == 1)
|
{
|
var method = applicableMethods[0];
|
|
return Expression.Call(instance, (MethodInfo)method.MethodBase, method.PromotedParameters);
|
}
|
|
return null;
|
}
|
|
//static Type FindGenericType(Type generic, Type type)
|
//{
|
// while (type != null && type != typeof(object))
|
// {
|
// if (type.IsGenericType && type.GetGenericTypeDefinition() == generic) return type;
|
// if (generic.IsInterface)
|
// {
|
// foreach (Type intfType in type.GetInterfaces())
|
// {
|
// Type found = FindGenericType(generic, intfType);
|
// if (found != null) return found;
|
// }
|
// }
|
// type = type.BaseType;
|
// }
|
// return null;
|
//}
|
|
//Expression ParseAggregate(Expression instance, Type elementType, string methodName, int errorPos)
|
//{
|
// ParameterExpression outerIt = it;
|
// ParameterExpression innerIt = Expression.Parameter(elementType, "");
|
// it = innerIt;
|
// Expression[] args = ParseArgumentList();
|
// it = outerIt;
|
// MethodBase signature;
|
// if (FindMethod(typeof(IEnumerableSignatures), methodName, false, args, out signature) != 1)
|
// throw ParseError(errorPos, ErrorMessages.NoApplicableAggregate, methodName);
|
// Type[] typeArgs;
|
// if (signature.Name == "Min" || signature.Name == "Max")
|
// {
|
// typeArgs = new Type[] { elementType, args[0].Type };
|
// }
|
// else
|
// {
|
// typeArgs = new Type[] { elementType };
|
// }
|
// if (args.Length == 0)
|
// {
|
// args = new Expression[] { instance };
|
// }
|
// else
|
// {
|
// args = new Expression[] { instance, Expression.Lambda(args[0], innerIt) };
|
// }
|
// return Expression.Call(typeof(Enumerable), signature.Name, typeArgs, args);
|
//}
|
|
private static Expression ParseDynamicProperty(Expression instance, string propertyOrFieldName)
|
{
|
return Expression.Dynamic(new LateGetMemberCallSiteBinder(propertyOrFieldName), typeof(object), instance);
|
}
|
|
private static Expression ParseDynamicMethodInvocation(Type type, Expression instance, string methodName, Expression[] args)
|
{
|
var argsDynamic = args.ToList();
|
var isStatic = instance == null;
|
argsDynamic.Insert(0, !isStatic ? instance : Expression.Constant(type));
|
return Expression.Dynamic(new LateInvokeMethodCallSiteBinder(methodName, isStatic), typeof(object), argsDynamic);
|
}
|
|
private Expression ParseDynamicMethodGroupInvocation(Delegate @delegate, Expression[] args)
|
{
|
var argsDynamic = args.ToList();
|
argsDynamic.Insert(0, Expression.Constant(@delegate));
|
return Expression.Dynamic(new LateInvokeDelegateCallSiteBinder(), typeof(object), argsDynamic);
|
}
|
|
private static Expression ParseDynamicIndex(Expression instance, Expression[] args)
|
{
|
var argsDynamic = args.ToList();
|
argsDynamic.Insert(0, instance);
|
return Expression.Dynamic(new LateGetIndexCallSiteBinder(), typeof(object), argsDynamic);
|
}
|
|
private Expression[] ParseArgumentList(TokenId openToken, string missingOpenTokenMsg,
|
TokenId closeToken, string missingCloseTokenMsg,
|
bool allowTrailingComma = false)
|
{
|
ValidateToken(openToken, missingOpenTokenMsg);
|
NextToken();
|
var argList = new List<Expression>();
|
while (_token.id != closeToken)
|
{
|
argList.Add(ParseExpressionSegment());
|
if (_token.id != TokenId.Comma) break;
|
NextToken();
|
if (!allowTrailingComma && _token.id == closeToken)
|
throw ParseException.Create(_token.pos, missingCloseTokenMsg);
|
}
|
ValidateToken(closeToken, missingCloseTokenMsg);
|
NextToken();
|
return argList.ToArray();
|
}
|
|
private Expression[] ParseArgumentList()
|
{
|
return ParseArgumentList(TokenId.OpenParen, ErrorMessages.OpenParenExpected,
|
TokenId.CloseParen, ErrorMessages.CloseParenOrCommaExpected);
|
}
|
|
private Expression ParseElementAccess(Expression expr)
|
{
|
var errorPos = _token.pos;
|
var args = ParseArgumentList(TokenId.OpenBracket, ErrorMessages.OpenParenExpected,
|
TokenId.CloseBracket, ErrorMessages.CloseBracketOrCommaExpected);
|
if (expr.Type.IsArray)
|
{
|
if (expr.Type.GetArrayRank() != args.Length)
|
throw ParseException.Create(errorPos, ErrorMessages.IncorrectNumberOfIndexes);
|
|
for (var i = 0; i < args.Length; i++)
|
{
|
args[i] = ExpressionUtils.PromoteExpression(args[i], typeof(int));
|
if (args[i] == null)
|
throw ParseException.Create(errorPos, ErrorMessages.InvalidIndex);
|
}
|
|
return Expression.ArrayAccess(expr, args);
|
}
|
|
if (TypeUtils.IsDynamicType(expr.Type) || IsDynamicExpression(expr))
|
return ParseDynamicIndex(expr, args);
|
|
var applicableMethods = _memberFinder.FindIndexer(expr.Type, args);
|
if (applicableMethods.Count == 0)
|
{
|
throw ParseException.Create(errorPos, ErrorMessages.NoApplicableIndexer,
|
TypeUtils.GetTypeName(expr.Type));
|
}
|
|
if (applicableMethods.Count > 1)
|
{
|
throw ParseException.Create(errorPos, ErrorMessages.AmbiguousIndexerInvocation,
|
TypeUtils.GetTypeName(expr.Type));
|
}
|
|
var indexer = (IndexerData)applicableMethods[0];
|
return Expression.Property(expr, indexer.Indexer, indexer.PromotedParameters);
|
}
|
|
private bool IsDynamicExpression(Expression instance)
|
{
|
return instance != null &&
|
(instance.NodeType == ExpressionType.Dynamic ||
|
(_arguments.Settings.LateBindObject && instance.Type == typeof(object)));
|
}
|
|
//static bool IsEnumType(Type type)
|
//{
|
// return GetNonNullableType(type).IsEnum;
|
//}
|
|
private void CheckAndPromoteOperand(MethodBase[] unarySignatures, ref Expression expr)
|
{
|
var args = PrepareOperandArguments(unarySignatures, new[] { expr });
|
|
expr = args[0];
|
}
|
|
private void CheckAndPromoteOperands(MethodBase[] binarySignatures, ref Expression left, ref Expression right)
|
{
|
// if one of the operands is the nullable version of the other, promote the non-nullablte to the nullable version
|
if (TypeUtils.TryGetNonNullableType(left.Type, out var nonNullableLeftType) && nonNullableLeftType == right.Type)
|
right = GenerateNullableTypeConversion(right);
|
else if (TypeUtils.TryGetNonNullableType(right.Type, out var nonNullableRightType) && nonNullableRightType == left.Type)
|
left = GenerateNullableTypeConversion(left);
|
|
var args = PrepareOperandArguments(binarySignatures, new[] { left, right });
|
|
left = args[0];
|
right = args[1];
|
}
|
|
private IList<Expression> PrepareOperandArguments(MethodBase[] signatures, Expression[] args)
|
{
|
var applicableMethods = MethodResolution.FindBestMethod(signatures, args);
|
if (applicableMethods.Count == 1)
|
return applicableMethods[0].PromotedParameters;
|
|
return args;
|
}
|
|
private static bool IsWritable(Expression expression)
|
{
|
switch (expression.NodeType)
|
{
|
case ExpressionType.Index:
|
var indexer = ((IndexExpression)expression).Indexer;
|
return indexer == null || indexer.CanWrite;
|
case ExpressionType.MemberAccess:
|
var member = ((MemberExpression)expression).Member;
|
var prop = member as PropertyInfo;
|
if (prop != null)
|
return prop.CanWrite;
|
else
|
{
|
var field = (FieldInfo)member;
|
return !(field.IsInitOnly || field.IsLiteral);
|
}
|
case ExpressionType.Parameter:
|
return true;
|
}
|
|
return false;
|
}
|
|
private static bool IsDynamicWritable(Expression expression, out Func<Expression, Expression> toWritableExpression)
|
{
|
toWritableExpression = null;
|
if (expression.NodeType != ExpressionType.Dynamic)
|
return false;
|
|
var dynamicExpression = (DynamicExpression)expression;
|
if (!(dynamicExpression.Binder is IConvertibleToWritableBinder convertibleBinder))
|
return false;
|
|
toWritableExpression = value => Expression.Dynamic(convertibleBinder.ToWritableBinder(), typeof(object), dynamicExpression.Arguments.Concat(new[] { value }));
|
return true;
|
}
|
|
private Expression GenerateEqual(Expression left, Expression right)
|
{
|
return GenerateBinary(ExpressionType.Equal, left, right);
|
}
|
|
private Expression GenerateNotEqual(Expression left, Expression right)
|
{
|
return GenerateBinary(ExpressionType.NotEqual, left, right);
|
}
|
|
private Expression GenerateGreaterThan(Expression left, Expression right)
|
{
|
if (left.Type == typeof(string))
|
{
|
return Expression.GreaterThan(
|
GenerateStaticMethodCall("Compare", left, right),
|
Expression.Constant(0)
|
);
|
}
|
return GenerateBinary(ExpressionType.GreaterThan, left, right);
|
}
|
|
private Expression GenerateGreaterThanEqual(Expression left, Expression right)
|
{
|
if (left.Type == typeof(string))
|
{
|
return Expression.GreaterThanOrEqual(
|
GenerateStaticMethodCall("Compare", left, right),
|
Expression.Constant(0)
|
);
|
}
|
return GenerateBinary(ExpressionType.GreaterThanOrEqual, left, right);
|
}
|
|
private Expression GenerateLessThan(Expression left, Expression right)
|
{
|
if (left.Type == typeof(string))
|
{
|
return Expression.LessThan(
|
GenerateStaticMethodCall("Compare", left, right),
|
Expression.Constant(0)
|
);
|
}
|
|
return GenerateBinary(ExpressionType.LessThan, left, right);
|
}
|
|
private Expression GenerateLessThanEqual(Expression left, Expression right)
|
{
|
if (left.Type == typeof(string))
|
{
|
return Expression.LessThanOrEqual(
|
GenerateStaticMethodCall("Compare", left, right),
|
Expression.Constant(0)
|
);
|
}
|
return GenerateBinary(ExpressionType.LessThanOrEqual, left, right);
|
}
|
|
private Expression GenerateBinary(ExpressionType binaryType, Expression left, Expression right)
|
{
|
if (IsDynamicExpression(left) || IsDynamicExpression(right))
|
return GenerateBinaryDynamic(binaryType, left, right);
|
|
// enum bitwise operations are not resolved properly by Linq
|
var bitwiseOps = new[] { ExpressionType.Or, ExpressionType.And };
|
if (left.Type.IsEnum && right.Type == left.Type && bitwiseOps.Contains(binaryType))
|
return GenerateBinaryEnums(binaryType, left, right);
|
|
// find the overloaded binary operator
|
string opName;
|
|
var liftToNull = true;
|
switch (binaryType)
|
{
|
case ExpressionType.OrElse: opName = "op_BitwiseOr"; break;
|
case ExpressionType.Or: opName = "op_BitwiseOr"; break;
|
case ExpressionType.ExclusiveOr: opName = "op_ExclusiveOr"; break;
|
case ExpressionType.AndAlso: opName = "op_BitwiseAnd"; break;
|
case ExpressionType.And: opName = "op_BitwiseAnd"; break;
|
case ExpressionType.Add: opName = "op_Addition"; break;
|
case ExpressionType.Subtract: opName = "op_Subtraction"; break;
|
case ExpressionType.Multiply: opName = "op_Multiply"; break;
|
case ExpressionType.Divide: opName = "op_Division"; break;
|
case ExpressionType.Modulo: opName = "op_Modulus"; break;
|
case ExpressionType.RightShift: opName = "op_RightShift"; break;
|
case ExpressionType.LeftShift: opName = "op_LeftShift"; break;
|
case ExpressionType.Equal: opName = "op_Equality"; liftToNull = false; break;
|
case ExpressionType.NotEqual: opName = "op_Inequality"; liftToNull = false; break;
|
case ExpressionType.GreaterThan: opName = "op_GreaterThan"; liftToNull = false; break;
|
case ExpressionType.GreaterThanOrEqual: opName = "op_GreaterThanOrEqual"; liftToNull = false; break;
|
case ExpressionType.LessThan: opName = "op_LessThan"; liftToNull = false; break;
|
case ExpressionType.LessThanOrEqual: opName = "op_LessThanOrEqual"; liftToNull = false; break;
|
default: opName = null; break;
|
}
|
|
var applicableMethod = FindBinaryOperator(opName, left, right);
|
|
MethodInfo operatorMethod = null;
|
if (applicableMethod != null)
|
{
|
operatorMethod = applicableMethod.MethodBase as MethodInfo;
|
left = applicableMethod.PromotedParameters[0];
|
right = applicableMethod.PromotedParameters[1];
|
}
|
|
if (binaryType == ExpressionType.OrElse)
|
{
|
UnaryExpression convert = Expression.Convert(left, typeof(bool));
|
|
ConstantExpression trueValue = Expression.Constant(true);
|
// 使用 Condition 实现短路
|
return Expression.Condition(convert, trueValue, Expression.Convert(right, typeof(bool)));
|
}
|
|
|
// if no operator was found, the default Linq resolution will occur
|
return Expression.MakeBinary(binaryType, left, right, liftToNull, operatorMethod);
|
}
|
|
public static bool ConvertBool(object obj)
|
{
|
try
|
{
|
var flags = BindingFlags.Public | BindingFlags.DeclaredOnly | BindingFlags.Static;
|
var type = obj.GetType();
|
var m = type.GetMethod("ToBool", flags);
|
if (m == null)
|
{
|
return (bool)obj;
|
}
|
return (bool)m.Invoke(null, new[] { obj });
|
}
|
catch (Exception ex)
|
{
|
return (bool)obj;
|
}
|
}
|
|
private static Expression ConvertBoolExpression(Expression expression)
|
{
|
var flags = BindingFlags.Public | BindingFlags.DeclaredOnly | BindingFlags.Static;
|
var m = typeof(Parser).GetMethod("ConvertBool", flags);
|
return Expression.Call(null, m, new[] { expression });
|
}
|
|
private Expression GenerateBinaryDynamic(ExpressionType binaryType, Expression left, Expression right)
|
{
|
//binary binder for dynamic type does not support AndAlso and OrElse as valid operations
|
if (binaryType == ExpressionType.AndAlso || binaryType == ExpressionType.OrElse)
|
{
|
if (IsDynamicExpression(left))
|
{
|
//left = Expression.Convert(left, typeof(bool));
|
left = ConvertBoolExpression(left);
|
}
|
|
if (IsDynamicExpression(right))
|
{
|
//right = Expression.Convert(right, typeof(bool));
|
right = ConvertBoolExpression(right);
|
}
|
|
return Expression.MakeBinary(binaryType, left, right);
|
}
|
|
var binder = Microsoft.CSharp.RuntimeBinder.Binder.BinaryOperation(
|
CSharpBinderFlags.None,
|
binaryType,
|
typeof(Parser),
|
new CSharpArgumentInfo[] {
|
CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null),
|
CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null)}
|
);
|
|
return Expression.Dynamic(binder, typeof(object), left, right);
|
}
|
|
private Expression GenerateBinaryEnums(ExpressionType binaryType, Expression left, Expression right)
|
{
|
var enumType = left.Type;
|
var underlyingType = enumType.GetEnumUnderlyingType();
|
left = Expression.Convert(left, underlyingType);
|
right = Expression.Convert(right, underlyingType);
|
|
var op = Expression.MakeBinary(binaryType, left, right);
|
return Expression.Convert(op, enumType);
|
}
|
|
private MethodData FindBinaryOperator(string operatorName, Expression left, Expression right)
|
{
|
if (operatorName == null)
|
return null;
|
|
var errorPos = _token.pos;
|
var leftType = left.Type;
|
var rightType = right.Type;
|
// it's a lambda to avoid useless allocation
|
ParseException CreateAmbiguousOperatorException() => ParseException.Create(errorPos, ErrorMessages.AmbiguousBinaryOperatorInvocation, operatorName, TypeUtils.GetTypeName(leftType), TypeUtils.GetTypeName(rightType));
|
|
var args = new[] { left, right };
|
|
MethodData userDefinedOperator = null;
|
|
// try to find the user defined operator on both operands
|
var opOnLeftType = _memberFinder.FindMethods(leftType, operatorName, true, args);
|
if (opOnLeftType.Count > 1)
|
throw CreateAmbiguousOperatorException();
|
|
if (opOnLeftType.Count == 1)
|
userDefinedOperator = opOnLeftType[0];
|
|
if (leftType != rightType)
|
{
|
var opOnRightType = _memberFinder.FindMethods(rightType, operatorName, true, args);
|
if (opOnRightType.Count > 1)
|
throw CreateAmbiguousOperatorException();
|
|
MethodData rightOperator = null;
|
if (opOnRightType.Count == 1)
|
rightOperator = opOnRightType[0];
|
|
// we found a matching user defined operator on either type, but it might be the same method
|
if (userDefinedOperator != null && rightOperator != null && !ReferenceEquals(userDefinedOperator.MethodBase, rightOperator.MethodBase))
|
throw CreateAmbiguousOperatorException();
|
|
// we didn't find an operator on the left type, but we found one on the right type
|
if (userDefinedOperator == null && rightOperator != null)
|
userDefinedOperator = rightOperator;
|
}
|
|
return userDefinedOperator;
|
}
|
|
private static Expression GenerateStringConcat(Expression left, Expression right)
|
{
|
var leftObj = GenerateStringConcatOperand(left);
|
var rightObj = GenerateStringConcatOperand(right);
|
|
return Expression.Call(
|
null,
|
ReflectionExtensions.StringConcatMethod,
|
new[] { leftObj, rightObj });
|
}
|
|
private static Expression ToStringOrNull(Expression expression)
|
{
|
var nullableExpression = GenerateNullableTypeConversion(expression);
|
|
var expressionTypeNullConstant = Expression.Constant(null, nullableExpression.Type);
|
var stringNullConstant = Expression.Constant(null, typeof(string));
|
|
Expression condition = Expression.Equal(
|
nullableExpression,
|
expressionTypeNullConstant);
|
|
return Expression.Condition(
|
condition,
|
stringNullConstant,
|
Expression.Call(expression, ReflectionExtensions.ObjectToStringMethod));
|
}
|
|
private static Expression GenerateStringConcatOperand(Expression expression)
|
{
|
return expression.Type != typeof(string)
|
? ToStringOrNull(expression)
|
: expression;
|
}
|
|
private static Expression GenerateStaticMethodCall(string methodName, Expression left, Expression right)
|
{
|
var staticMethod = left.Type.GetMethod(methodName, new[] { left.Type, right.Type });
|
return Expression.Call(null, staticMethod, new[] { left, right });
|
}
|
|
private void SetTextPos(int pos)
|
{
|
_parsePosition = pos;
|
_parseChar = _parsePosition < _expressionTextLength ? _expressionText[_parsePosition] : '\0';
|
}
|
|
private void NextChar()
|
{
|
if (_parsePosition < _expressionTextLength)
|
_parsePosition++;
|
|
_parseChar = _parsePosition < _expressionTextLength ? _expressionText[_parsePosition] : '\0';
|
}
|
|
private void PreviousChar()
|
{
|
SetTextPos(_parsePosition - 1);
|
}
|
|
private void NextToken()
|
{
|
while (char.IsWhiteSpace(_parseChar))
|
NextChar();
|
|
TokenId t;
|
var tokenPos = _parsePosition;
|
switch (_parseChar)
|
{
|
case '!':
|
NextChar();
|
if (_parseChar == '=')
|
{
|
NextChar();
|
t = TokenId.ExclamationEqual;
|
}
|
else
|
{
|
t = TokenId.Exclamation;
|
}
|
break;
|
case '%':
|
NextChar();
|
t = TokenId.Percent;
|
break;
|
case '&':
|
NextChar();
|
if (_parseChar == '&')
|
{
|
NextChar();
|
t = TokenId.DoubleAmphersand;
|
}
|
else
|
{
|
t = TokenId.Amphersand;
|
}
|
break;
|
case '(':
|
NextChar();
|
t = TokenId.OpenParen;
|
break;
|
case ')':
|
NextChar();
|
t = TokenId.CloseParen;
|
break;
|
case '*':
|
NextChar();
|
t = TokenId.Asterisk;
|
break;
|
case '+':
|
NextChar();
|
t = TokenId.Plus;
|
break;
|
case ',':
|
NextChar();
|
t = TokenId.Comma;
|
break;
|
case '-':
|
NextChar();
|
t = TokenId.Minus;
|
break;
|
case '~':
|
NextChar();
|
t = TokenId.Tilde;
|
break;
|
case '.':
|
NextChar();
|
|
if (char.IsDigit(_parseChar))
|
{
|
t = TokenId.RealLiteral;
|
do
|
{
|
NextChar();
|
} while (char.IsDigit(_parseChar));
|
if (_parseChar == 'E' || _parseChar == 'e')
|
{
|
t = TokenId.RealLiteral;
|
NextChar();
|
if (_parseChar == '+' || _parseChar == '-')
|
NextChar();
|
ValidateDigit();
|
do
|
{
|
NextChar();
|
} while (char.IsDigit(_parseChar));
|
}
|
if (_parseChar == 'F' || _parseChar == 'f' || _parseChar == 'M' || _parseChar == 'm')
|
NextChar();
|
break;
|
}
|
|
t = TokenId.Dot;
|
break;
|
case '/':
|
NextChar();
|
t = TokenId.Slash;
|
break;
|
case ':':
|
NextChar();
|
t = TokenId.Colon;
|
break;
|
case '<':
|
NextChar();
|
if (_parseChar == '=')
|
{
|
NextChar();
|
t = TokenId.LessThanEqual;
|
}
|
else
|
{
|
t = TokenId.LessThan;
|
}
|
break;
|
case '=':
|
NextChar();
|
if (_parseChar == '=')
|
{
|
NextChar();
|
t = TokenId.DoubleEqual;
|
}
|
else if (_parseChar == '>')
|
{
|
NextChar();
|
t = TokenId.LambdaArrow;
|
}
|
else
|
{
|
t = TokenId.Equal;
|
}
|
break;
|
case '>':
|
NextChar();
|
if (_parseChar == '=')
|
{
|
NextChar();
|
t = TokenId.GreaterThanEqual;
|
}
|
else
|
{
|
t = TokenId.GreaterThan;
|
}
|
break;
|
case '?':
|
NextChar();
|
if (_parseChar == '?')
|
{
|
NextChar();
|
t = TokenId.QuestionQuestion;
|
}
|
else
|
{
|
t = TokenId.Question;
|
}
|
break;
|
case '[':
|
NextChar();
|
t = TokenId.OpenBracket;
|
break;
|
case ']':
|
NextChar();
|
t = TokenId.CloseBracket;
|
break;
|
case '{':
|
NextChar();
|
t = TokenId.OpenCurlyBracket;
|
break;
|
case '}':
|
NextChar();
|
t = TokenId.CloseCurlyBracket;
|
break;
|
case '|':
|
NextChar();
|
if (_parseChar == '|')
|
{
|
NextChar();
|
t = TokenId.DoubleBar;
|
}
|
else
|
{
|
t = TokenId.Bar;
|
}
|
break;
|
case '"':
|
NextChar();
|
var isEscapeS = false;
|
var isEndS = _parseChar == '\"';
|
while (_parsePosition < _expressionTextLength && !isEndS)
|
{
|
isEscapeS = _parseChar == '\\' && !isEscapeS;
|
NextChar();
|
isEndS = (_parseChar == '\"' && !isEscapeS);
|
}
|
|
if (_parsePosition == _expressionTextLength)
|
throw ParseException.Create(_parsePosition, ErrorMessages.UnterminatedStringLiteral);
|
|
NextChar();
|
|
t = TokenId.StringLiteral;
|
break;
|
case '\'':
|
NextChar();
|
var isEscapeC = false;
|
var isEndC = false;
|
while (_parsePosition < _expressionTextLength && !isEndC)
|
{
|
isEscapeC = _parseChar == '\\' && !isEscapeC;
|
NextChar();
|
isEndC = (_parseChar == '\'' && !isEscapeC);
|
}
|
|
if (_parsePosition == _expressionTextLength)
|
throw ParseException.Create(_parsePosition, ErrorMessages.UnterminatedStringLiteral);
|
|
NextChar();
|
|
t = TokenId.CharLiteral;
|
break;
|
case '^':
|
NextChar();
|
t = TokenId.Caret;
|
break;
|
default:
|
|
if (char.IsLetter(_parseChar) || _parseChar == '@' || _parseChar == '_')
|
{
|
do
|
{
|
NextChar();
|
} while (char.IsLetterOrDigit(_parseChar) || _parseChar == '_');
|
t = TokenId.Identifier;
|
break;
|
}
|
|
if (char.IsDigit(_parseChar))
|
{
|
//RealLiteral if DefaultNumberType settings is set to real type
|
if (_defaultNumberType == DefaultNumberType.Single || _defaultNumberType == DefaultNumberType.Double || _defaultNumberType == DefaultNumberType.Decimal)
|
{
|
t = TokenId.RealLiteral;
|
}
|
else
|
{
|
//IntegerLiteral by default
|
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'));
|
|
PreviousChar();
|
}
|
else if (_parseChar == 'b' || _parseChar == 'B')
|
{
|
canBeRealLiteral = false;
|
do
|
{
|
NextChar();
|
} while (_parseChar == '0' || _parseChar == '1');
|
|
PreviousChar();
|
}
|
else
|
{
|
PreviousChar();
|
}
|
}
|
|
do
|
{
|
NextChar();
|
} while (char.IsDigit(_parseChar));
|
|
if (canBeRealLiteral && _parseChar == '.')
|
{
|
NextChar();
|
if (char.IsDigit(_parseChar))
|
{
|
t = TokenId.RealLiteral;
|
do
|
{
|
NextChar();
|
} while (char.IsDigit(_parseChar));
|
}
|
else
|
{
|
PreviousChar();
|
break;
|
}
|
}
|
|
if (canBeRealLiteral && (_parseChar == 'E' || _parseChar == 'e'))
|
{
|
t = TokenId.RealLiteral;
|
NextChar();
|
if (_parseChar == '+' || _parseChar == '-')
|
NextChar();
|
ValidateDigit();
|
do
|
{
|
NextChar();
|
} while (char.IsDigit(_parseChar));
|
}
|
|
if (canBeRealLiteral && (_parseChar == 'D' || _parseChar == 'd' || _parseChar == 'F' || _parseChar == 'f' || _parseChar == 'M' || _parseChar == 'm'))
|
{
|
t = TokenId.RealLiteral;
|
NextChar();
|
}
|
|
// '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();
|
}
|
|
break;
|
}
|
if (_parsePosition == _expressionTextLength)
|
{
|
if (_token.id == TokenId.End)
|
throw new InvalidOperationException(ErrorMessages.NextTokenAtEnd);
|
|
t = TokenId.End;
|
break;
|
}
|
throw ParseException.Create(_parsePosition, ErrorMessages.InvalidCharacter, _parseChar);
|
}
|
_token.id = t;
|
_token.text = _expressionText.Substring(tokenPos, _parsePosition - tokenPos);
|
_token.pos = tokenPos;
|
}
|
|
private string GetIdentifier()
|
{
|
ValidateToken(TokenId.Identifier, ErrorMessages.IdentifierExpected);
|
var id = _token.text;
|
if (id.Length > 1 && id[0] == '@')
|
id = id.Substring(1);
|
return id;
|
}
|
|
private void ValidateDigit()
|
{
|
if (!char.IsDigit(_parseChar))
|
throw ParseException.Create(_parsePosition, ErrorMessages.DigitExpected);
|
}
|
|
// ReSharper disable once UnusedParameter.Local
|
private void ValidateToken(TokenId t, string errorMessage)
|
{
|
if (_token.id != t)
|
throw ParseException.Create(_token.pos, errorMessage);
|
}
|
|
// ReSharper disable once UnusedParameter.Local
|
private void ValidateToken(TokenId t)
|
{
|
if (_token.id != t)
|
throw ParseException.Create(_token.pos, ErrorMessages.SyntaxError);
|
}
|
|
private static Exception WrapWithParseException(int pos, string format, Exception ex, params object[] args)
|
{
|
return new ParseException(string.Format(format, args), pos, ex);
|
}
|
|
private static Expression GenerateNullableTypeConversion(Expression expr)
|
{
|
var exprType = expr.Type;
|
|
if (!exprType.IsValueType || TypeUtils.IsNullableType(exprType))
|
{
|
return expr;
|
}
|
|
var conversionType = TypeUtils.MakeNullable(exprType);
|
return Expression.Convert(expr, conversionType);
|
}
|
}
|
}
|
