/// <summary>
/// 获取属性表达式
/// </summary>
/// <param name="expression">表达式</param>
/// <param name="property">属性信息</param>
/// <returns>属性表达式</returns>
internal static TmphPropertyExpression Get(TmphExpression expression, PropertyInfo property)
{
var propertyExpression = TmphTypePool<TmphPropertyExpression>.Pop() ?? new TmphPropertyExpression();
propertyExpression.PropertyInfo = property;
propertyExpression.set(expression);
return propertyExpression;
}
/// <summary>
/// 获取字段表达式
/// </summary>
/// <param name="expression">表达式</param>
/// <param name="field">字段信息</param>
/// <returns>字段表达式</returns>
internal static TmphFieldExpression Get(TmphExpression expression, FieldInfo field)
{
var fieldExpression = TmphTypePool<TmphFieldExpression>.Pop() ?? new TmphFieldExpression();
fieldExpression.FieldInfo = field;
fieldExpression.set(expression);
return fieldExpression;
}
/// <summary>
/// 委托关联表达式
/// </summary>
/// <param name="body">表达式主体</param>
/// <param name="parameters">参数</param>
protected void set(TmphExpression body, TmphParameterExpression[] parameters)
{
++(Body = body.SimpleExpression).ExpressionCount;
Parameters = parameters;
if (parameters != null)
{
foreach (var parameter in parameters) ++parameter.ExpressionCount;
}
}
/// <summary>
/// 转换表达式
/// </summary>
/// <param name="converter">表达式转换器</param>
/// <param name="expression">表达式</param>
private void convertConstant(Expression.TmphConverter converter, TmphExpression expression)
{
var value = ((TmphConstantExpression)expression).Value;
if (value != null)
{
var toString = TmphConstantConverter.Default[value.GetType()];
if (toString != null) toString(converter.Stream, value);
else TmphConstantConverter.ConvertConstantStringQuote(converter.Stream, value.ToString());
}
else TmphAjax.WriteNull(converter.Stream);
}
/// <summary>
/// 转换表达式
/// </summary>
/// <param name="converter">表达式转换器</param>
/// <param name="expression">表达式</param>
private void convertInSet(Expression.TmphConverter converter, TmphExpression expression)
{
var stream = converter.Stream;
var binaryExpression = (TmphBinaryExpression)expression;
var left = binaryExpression.Left;
converters[(int)left.NodeType](converter, left);
stream.WriteNotNull(" In(");
Action<TmphCharStream, object> toString = null;
var index = -1;
foreach (var value in (IEnumerable)((TmphConstantExpression)binaryExpression.Right).Value)
{
if (++index == 0) toString = TmphConstantConverter.Default[value.GetType()];
else stream.Write(',');
if (toString == null) TmphConstantConverter.ConvertConstantStringQuote(stream, value.ToString());
else toString(stream, value);
}
stream.Write(')');
}
/// <summary>
/// 转换表达式
/// </summary>
/// <param name="converter">表达式转换器</param>
/// <param name="expression">表达式</param>
private void convertPower(TmphConverter converter, TmphExpression expression)
{
TmphLog.Error.Throw(TmphLog.TmphExceptionType.ErrorOperation);
}
/// <summary>
/// 转换表达式
/// </summary>
/// <param name="converter">表达式转换器</param>
/// <param name="unaryExpression">表达式</param>
private void convertUnbox(TmphConverter converter, TmphExpression expression)
{
expression = ((TmphUnaryExpression)expression).Expression;
if (expression.IsSimple)
{
converters[(int)expression.NodeType](converter, expression);
}
else
{
converter.Stream.Write('(');
converters[(int)expression.NodeType](converter, expression);
converter.Stream.Write(')');
}
}
/// <summary>
/// 获取函数调用表达式
/// </summary>
/// <param name="method">函数信息</param>
/// <param name="instance">动态函数对象表达式</param>
/// <param name="arguments">调用参数</param>
/// <returns>函数调用表达式</returns>
internal static TmphMethodCallExpression Get(MethodInfo method, TmphExpression instance, TmphExpression[] arguments)
{
var expression = TmphTypePool<TmphMethodCallExpression>.Pop() ?? new TmphMethodCallExpression();
expression.set(method, instance, arguments);
return expression;
}
/// <summary>
/// 转换表达式
/// </summary>
/// <param name="converter">表达式转换器</param>
/// <param name="expression">表达式</param>
private void convertModulo(TmphConverter converter, TmphExpression expression)
{
convertBinaryExpression(converter, (TmphBinaryExpression)expression, '%');
}
/// <summary>
/// 成员表达式
/// </summary>
/// <param name="expression">表达式</param>
protected void set(TmphExpression expression)
{
++(Expression = expression.SimpleExpression).ExpressionCount;
IsSimple = true;
IsConstant = Expression.IsConstant;
}
/// <summary>
/// 转换表达式
/// </summary>
/// <param name="converter">表达式转换器</param>
/// <param name="expression">表达式</param>
private void convertAnd(TmphConverter converter, TmphExpression expression)
{
convertBinaryExpression(converter, (TmphBinaryExpression)expression, '&');
}
/// <summary>
/// 一元表达式
/// </summary>
/// <param name="type">表达式类型</param>
/// <param name="expression">表达式</param>
/// <param name="method">运算符重载函数</param>
protected void set(TmphExpressionType type, TmphExpression expression, MethodInfo method)
{
NodeType = type;
Method = method;
++(Expression = expression.SimpleExpression).ExpressionCount;
}
/// <summary>
/// 获取委托关联表达式
/// </summary>
/// <param name="body">表达式主体</param>
/// <param name="parameters">参数</param>
/// <returns>委托关联表达式</returns>
internal static TmphLambdaExpression Get(TmphExpression body, TmphParameterExpression[] parameters)
{
var expression = TmphTypePool<TmphLambdaExpression>.Pop() ?? new TmphLambdaExpression();
expression.set(body, parameters);
return expression;
}
/// <summary>
/// 转换表达式
/// </summary>
/// <param name="converter">表达式转换器</param>
/// <param name="expression">表达式</param>
private void convertExclusiveOr(TmphConverter converter, TmphExpression expression)
{
convertBinaryExpression(converter, (TmphBinaryExpression)expression, '^');
}
/// <summary>
/// 转换表达式
/// </summary>
/// <param name="converter">表达式转换器</param>
/// <param name="expression">表达式</param>
private void convertPropertyAccess(TmphConverter converter, TmphExpression expression)
{
var propertyExpression = (TmphPropertyExpression)expression;
convertMemberAccess(converter, propertyExpression, propertyExpression.PropertyInfo.Name);
}
/// <summary>
/// 转换表达式
/// </summary>
/// <param name="converter">表达式转换器</param>
/// <param name="expression">表达式</param>
private void convertFieldAccess(TmphConverter converter, TmphExpression expression)
{
var fieldExpression = (TmphFieldExpression)expression;
convertMemberAccess(converter, fieldExpression, fieldExpression.FieldInfo.Name);
}
/// <summary>
/// 转换表达式
/// </summary>
/// <param name="converter">表达式转换器</param>
/// <param name="expression">表达式</param>
private void convertRightShift(TmphConverter converter, TmphExpression expression)
{
convertBinaryExpression(converter, (TmphBinaryExpression)expression, '>', '>');
}
/// <summary>
/// 转换表达式
/// </summary>
/// <param name="converter">表达式转换器</param>
/// <param name="expression">表达式</param>
private void convertLeftShift(TmphConverter converter, TmphExpression expression)
{
convertBinaryExpression(converter, (TmphBinaryExpression)expression, '<', '<');
}
/// <summary>
/// 获取条件表达式
/// </summary>
/// <param name="test">测试条件</param>
/// <param name="ifTrue">真表达式</param>
/// <param name="ifFalse">假表达式</param>
/// <returns>条件表达式</returns>
internal static TmphConditionalExpression Get(TmphExpression test, TmphExpression ifTrue, TmphExpression ifFalse)
{
var expression = TmphTypePool<TmphConditionalExpression>.Pop() ?? new TmphConditionalExpression();
++(expression.Test = test.SimpleExpression).ExpressionCount;
++(expression.IfTrue = ifTrue.SimpleExpression).ExpressionCount;
++(expression.IfFalse = ifFalse.SimpleExpression).ExpressionCount;
return expression;
}
/// <summary>
/// 转换表达式
/// </summary>
/// <param name="converter">表达式转换器</param>
/// <param name="unaryExpression">表达式</param>
private void convertUnaryPlus(TmphConverter converter, TmphExpression expression)
{
expression = ((TmphUnaryExpression)expression).Expression;
converter.Stream.WriteNotNull("+(");
converters[(int)expression.NodeType](converter, expression);
converter.Stream.Write(')');
}
/// <summary>
/// 获取一元表达式
/// </summary>
/// <param name="type">表达式类型</param>
/// <param name="expression">表达式</param>
/// <param name="method">运算符重载函数</param>
/// <returns>一元表达式</returns>
internal static TmphUnaryExpression Get(TmphExpressionType type, TmphExpression expression, MethodInfo method)
{
var unaryExpression = TmphTypePool<TmphUnaryExpression>.Pop() ?? new TmphUnaryExpression();
unaryExpression.set(type, expression, method);
return unaryExpression;
}
/// <summary>
/// 转换表达式
/// </summary>
/// <param name="converter">表达式转换器</param>
/// <param name="unaryExpression">表达式</param>
private void convertIsFalse(TmphConverter converter, TmphExpression expression)
{
expression = ((TmphUnaryExpression)expression).Expression;
if (expression.IsSimple)
{
converters[(int)expression.NodeType](converter, expression);
converter.Stream.WriteNotNull("=0");
}
else
{
converter.Stream.Write('(');
converters[(int)expression.NodeType](converter, expression);
converter.Stream.WriteNotNull(")=0");
}
}
/// <summary>
/// 转换表达式
/// </summary>
/// <param name="converter">表达式转换器</param>
/// <param name="unaryExpression">表达式</param>
private void convertConvert(TmphConverter converter, TmphExpression expression)
{
var convertExpression = (TmphConvertExpression)expression;
converter.Stream.WriteNotNull("cast(");
converters[(int)convertExpression.Expression.NodeType](converter, convertExpression.Expression);
converter.Stream.WriteNotNull(" as ");
converter.Stream.WriteNotNull(convertExpression.ConvertType.formCSharpType().ToString());
converter.Stream.Write(')');
}
/// <summary>
/// 转换表达式
/// </summary>
/// <param name="converter">表达式转换器</param>
/// <param name="expression">表达式</param>
private void convertConditional(TmphConverter converter, TmphExpression expression)
{
var stream = converter.Stream;
var conditionalExpression = (TmphConditionalExpression)expression;
TmphExpression test = conditionalExpression.Test,
ifTrue = conditionalExpression.IfTrue,
ifFalse = conditionalExpression.IfFalse;
stream.WriteNotNull("case when ");
if (test.IsSimple)
{
converters[(int)test.NodeType](converter, test);
stream.Write('=');
stream.Write('1');
}
else converters[(int)test.NodeType](converter, test);
stream.WriteNotNull(" then ");
if (ifTrue.IsSimple) converters[(int)ifTrue.NodeType](converter, ifTrue);
else
{
stream.Write('(');
converters[(int)ifTrue.NodeType](converter, ifTrue);
stream.Write(')');
}
stream.WriteNotNull(" else ");
if (ifFalse.IsSimple) converters[(int)ifFalse.NodeType](converter, ifFalse);
else
{
stream.Write('(');
converters[(int)ifFalse.NodeType](converter, ifFalse);
stream.Write(')');
}
stream.WriteNotNull(" end");
}
/// <summary>
/// 清除数据
/// </summary>
protected void clear()
{
Expression.PushCountPool();
Expression = null;
}
/// <summary>
/// 转换表达式
/// </summary>
/// <param name="converter">表达式转换器</param>
/// <param name="expression">表达式</param>
private void convertCall(TmphConverter converter, TmphExpression expression)
{
var methodCallExpression = (TmphMethodCallExpression)expression;
var stream = converter.Stream;
stream.WriteNotNull(methodCallExpression.Method.Name);
stream.Write('(');
if (methodCallExpression.Arguments != null)
{
var isNext = false;
foreach (var argumentExpression in methodCallExpression.Arguments)
{
if (isNext) stream.Write(',');
converters[(int)argumentExpression.NodeType](converter, argumentExpression);
isNext = true;
}
}
stream.Write(')');
}
/// <summary>
/// 函数调用表达式
/// </summary>
/// <param name="method">函数信息</param>
/// <param name="instance">动态函数对象表达式</param>
/// <param name="arguments">调用参数</param>
private void set(MethodInfo method, TmphExpression instance, TmphExpression[] arguments)
{
Method = method;
if (instance != null) ++(Instance = instance.SimpleExpression).ExpressionCount;
if (arguments.length() != 0)
{
var index = 0;
foreach (var expression in arguments)
++(arguments[index++] = expression.SimpleExpression).ExpressionCount;
Arguments = arguments;
}
}
/// <summary>
/// 转换表达式
/// </summary>
/// <param name="converter">表达式转换器</param>
/// <param name="expression">表达式</param>
private void convertOrElse(TmphConverter converter, TmphExpression expression)
{
convertBinaryExpression(converter, (TmphBinaryExpression)expression, "or");
}
/// <summary>
/// 获取二元表达式
/// </summary>
/// <param name="type">表达式类型</param>
/// <param name="left">左表达式</param>
/// <param name="right">右表达式</param>
/// <param name="method">运算符重载函数</param>
/// <returns>二元表达式</returns>
internal static TmphBinaryExpression Get(TmphExpressionType type, TmphExpression left, TmphExpression right,
MethodInfo method)
{
var expression = TmphTypePool<TmphBinaryExpression>.Pop() ?? new TmphBinaryExpression();
expression.NodeType = type;
expression.Method = method;
++(expression.Left = left.SimpleExpression).ExpressionCount;
++(expression.Right = right.SimpleExpression).ExpressionCount;
return expression;
}
/// <summary>
/// 转换表达式
/// </summary>
/// <param name="converter">表达式转换器</param>
/// <param name="expression">表达式</param>
private void convertDivide(TmphConverter converter, TmphExpression expression)
{
convertBinaryExpression(converter, (TmphBinaryExpression)expression, '/');
}
