/// <summary>
/// Initializes a new instance of <see cref="SixParamsFunctionNode"/> class.
/// </summary>
/// <param name="nodeType">The type of the current node.</param>
/// <param name="parameter1">The function first parameter value.</param>
/// <param name="parameter2">The function second parameter value.</param>
/// <param name="parameter3">The function third parameter value.</param>
/// <param name="parameter4">The function fourth parameter value.</param>
/// <param name="parameter5">The function fifth parameter value.</param>
/// <param name="parameter6">The function sixth parameter value.</param>
protected SixParamsFunctionNode(ExpressionNodeType nodeType, ExpressionNode parameter1, ExpressionNode parameter2, ExpressionNode parameter3, ExpressionNode parameter4, ExpressionNode parameter5, ExpressionNode parameter6)
: this(nodeType)
{
if (parameter1 == null)
throw new ArgumentException("Parameter 'parameter1' should contain a value.", "parameter1");
if (parameter2 == null)
throw new ArgumentException("Parameter 'parameter2' should contain a value.", "parameter2");
if (parameter3 == null)
throw new ArgumentException("Parameter 'parameter3' should contain a value.", "parameter3");
if (parameter4 == null)
throw new ArgumentException("Parameter 'parameter4' should contain a value.", "parameter4");
if (parameter5 == null)
throw new ArgumentException("Parameter 'parameter5' should contain a value.", "parameter5");
if (parameter6 == null)
throw new ArgumentException("Parameter 'parameter6' should contain a value.", "parameter6");
Parameter1 = parameter1;
Parameter2 = parameter2;
Parameter3 = parameter3;
Parameter4 = parameter4;
Parameter5 = parameter5;
Parameter6 = parameter6;
}
/// <summary>
/// Devuelve si el tipo de nodo es un operador.
/// </summary>
/// <param name="nodeType">Tipo de nodo a validar.</param>
/// <returns>True si el tipo es un operador, false en caso contrario.</returns>
private static bool IsOperatorNode(ExpressionNodeType nodeType)
{
return(nodeType.In(
ExpressionNodeType.ArithmeticOperator,
ExpressionNodeType.LogicalOperator,
ExpressionNodeType.RelationalOperator));
}
/// <summary>
/// 构造节点实例
/// </summary>
/// <param name="value">操作数或运算符</param>
public ExpressionNode(string value)
{
this._Value = value;
this._Type = ParseNodeType(value);
this._PRI = GetNodeTypePRI(this.Type);
this._Numeric = null;
}
/// <summary>
/// Initializes a new instance of <see cref="SingleParamFunctionNode"/> class.
/// </summary>
/// <param name="nodeType">The type of the current node.</param>
/// <param name="parameter">The function parameter value.</param>
/// <exception cref="System.ArgumentException">Parameter 'parameter' should contain a value.;parameter</exception>
public SingleParamFunctionNode(ExpressionNodeType nodeType, ExpressionNode parameter)
: this(nodeType)
{
if (parameter == null)
throw new ArgumentException("Parameter 'parameter' should contain a value.", "parameter");
Parameter = parameter;
}
/// <summary>
/// Initializes a new instance of the <see cref="ExpressionObjectBase" /> class.
/// </summary>
/// <param name="type">The type.</param>
public ThreeInOneOutExpression(ExpressionNodeType type) : base(type)
{
Connector1In = new ConnectorIn(this);
Connector2In = new ConnectorIn(this);
Connector3In = new ConnectorIn(this);
ConnectorOut = new ConnectorOut(this);
}
/// <summary>
/// Devuelve si el tipo de nodo puede contener un valor.
/// </summary>
/// <param name="nodeType">Tipo de nodo a validar.</param>
/// <returns>True si el tipo puede contener un valor, false en caso contrario.</returns>
private static bool IsValueNode(ExpressionNodeType nodeType)
{
return(nodeType.In(
ExpressionNodeType.UnknownType,
ExpressionNodeType.StringType,
ExpressionNodeType.DateType,
ExpressionNodeType.ListType,
ExpressionNodeType.PropertyType));
}
protected IExpression CreateExpressionNode(ExpressionNodeType nodeType, string tokenName)
{
Type expressionType = GetExpressionNodeType(nodeType, tokenName);
if (expressionType != null)
{
return((IExpression)Activator.CreateInstance(expressionType));
}
return(null);
}
/// <summary>
/// Initializes a new instance of the <see cref="ExpressionObjectBase" /> class.
/// </summary>
/// <param name="type">The type.</param>
public TwoInOneOutExpression(ExpressionNodeType type)
: base(type)
{
_connector1In = new ConnectorIn(this);
_connector1In.PropertyChanged += OnConnectorPropertyChanged;
_connector2In = new ConnectorIn(this);
_connector2In.PropertyChanged += OnConnectorPropertyChanged;
_connectorOut = new ConnectorOut(this);
_connectorOut.PropertyChanged += OnConnectorPropertyChanged;
}
//
// Helper functions
//
internal static T Function <T>(ExpressionNodeType nodeType, params ExpressionNode [] expressionFunctionParams) where T : class
{
T newNode = ExpressionNode.CreateExpressionNode <T>();
(newNode as ExpressionNode)._nodeType = nodeType;
foreach (var param in expressionFunctionParams)
{
(newNode as ExpressionNode)._children.Add(param);
}
return(newNode);
}
/// <summary>
/// Initializes a new instance of <see cref="SingleParamFunctionNode"/> class.
/// </summary>
/// <param name="nodeType">The type of the current node.</param>
/// <param name="parameter1">The function first parameter value.</param>
/// <param name="parameter2">The function second parameter value.</param>
protected TwoParamsFunctionNode(ExpressionNodeType nodeType, ExpressionNode parameter1, ExpressionNode parameter2)
: this(nodeType)
{
if (parameter1 == null)
throw new ArgumentException("Parameter 'parameter1' should contain a value.", "parameter1");
if (parameter2 == null)
throw new ArgumentException("Parameter 'parameter2' should contain a value.", "parameter2");
Parameter1 = parameter1;
Parameter2 = parameter2;
}
internal JsUnaryExpression(ExpressionNodeType nodeType, JsExpression operand) : base(nodeType)
{
if (nodeType < ExpressionNodeType.UnaryFirst || nodeType > ExpressionNodeType.UnaryLast)
{
throw new ArgumentException("nodeType");
}
if (operand == null)
{
throw new ArgumentNullException("operand");
}
this.Operand = operand;
}
/// <summary>
/// 获取各节点类型的优先级
/// </summary>
/// <param name="nodeType"></param>
/// <returns></returns>
private static int GetNodeTypePRI(ExpressionNodeType nodeType)
{
switch (nodeType)
{
case ExpressionNodeType.LParentheses:
case ExpressionNodeType.RParentheses:
return(9);
//逻辑非是一元操作符,所以其优先级较高
case ExpressionNodeType.Not:
return(8);
case ExpressionNodeType.Mod:
return(7);
case ExpressionNodeType.MultiPly:
case ExpressionNodeType.Divide:
case ExpressionNodeType.Power:
return(6);
case ExpressionNodeType.Plus:
case ExpressionNodeType.Subtract:
return(5);
case ExpressionNodeType.LShift:
case ExpressionNodeType.RShift:
return(4);
case ExpressionNodeType.BitwiseAnd:
case ExpressionNodeType.BitwiseOr:
return(3);
case ExpressionNodeType.Equal:
case ExpressionNodeType.Unequal:
case ExpressionNodeType.GT:
case ExpressionNodeType.LT:
case ExpressionNodeType.GTOrEqual:
case ExpressionNodeType.LTOrEqual:
return(2);
case ExpressionNodeType.And:
case ExpressionNodeType.Or:
return(1);
default:
return(0);
}
}
internal JsBinaryExpression(ExpressionNodeType nodeType, JsExpression left, JsExpression right) : base(nodeType)
{
if (nodeType < ExpressionNodeType.BinaryFirst || nodeType > ExpressionNodeType.BinaryLast)
{
throw new ArgumentException("nodeType");
}
if (left == null)
{
throw new ArgumentNullException("left");
}
if (right == null)
{
throw new ArgumentNullException("right");
}
Left = left;
Right = right;
}
/// <summary>
/// Subchannelses the internal.
/// </summary>
/// <typeparam name="T">A class that derives from ExpressionNode.</typeparam>
/// <param name="subchannels">The subchannels.</param>
/// <returns>T.</returns>
protected internal T SubchannelsInternal <T>(params string[] subchannels)
where T : ExpressionNode
{
ExpressionNodeType swizzleNodeType = ExpressionNodeType.Swizzle;
T newNode;
switch (subchannels.GetLength(0))
{
case 1:
newNode = ExpressionFunctions.Function <ScalarNode>(swizzleNodeType, this) as T;
break;
case 2:
newNode = ExpressionFunctions.Function <Vector2Node>(swizzleNodeType, this) as T;
break;
case 3:
newNode = ExpressionFunctions.Function <Vector3Node>(swizzleNodeType, this) as T;
break;
case 4:
newNode = ExpressionFunctions.Function <Vector4Node>(swizzleNodeType, this) as T;
break;
case 6:
newNode = ExpressionFunctions.Function <Matrix3x2Node>(swizzleNodeType, this) as T;
break;
case 16:
newNode = ExpressionFunctions.Function <Matrix4x4Node>(swizzleNodeType, this) as T;
break;
default:
throw new Exception($"Invalid subchannel count ({subchannels.GetLength(0)})");
}
(newNode as ExpressionNode).Subchannels = subchannels;
return(newNode);
}
public Type GetExpressionNodeType(ExpressionNodeType nodeType, string tokenName)
{
_lock.AcquireReaderLock(TimeSpan.FromSeconds(10));
try
{
Dictionary <string, Type> tokens;
_nodeTable.TryGetValue(nodeType, out tokens);
if (tokens == null)
{
return(null);
}
if (tokens.ContainsKey(tokenName))
{
return(tokens[tokenName]);
}
return(null);
}
finally
{
_lock.ReleaseReaderLock();
}
}
private String RenderNode(ProgramNode node)
{
StringBuilder result = new StringBuilder();
ExpressionNodeType t = this.DetermineNodeType(node);
for (int i = 0; i < node.ChildNodes.Count; i++)
{
ProgramNode childNode = node.GetChildNode(i);
if (result.Length > 0)
{
result.Append(" ");
}
result.Append(RenderNode(childNode));
}
if (result.Length > 0)
{
result.Append(" ");
}
if (t == ExpressionNodeType.ConstVal)
{
result.Append(HandleConst(node));
}
else if (t == ExpressionNodeType.Variable)
{
result.Append(HandleVar(node));
}
else if (t == ExpressionNodeType.Function || t == ExpressionNodeType.Operator)
{
result.Append('[');
result.Append(node.Name);
result.Append(']');
}
return(result.ToString().Trim());
}
/// <summary>
/// Modifica la expresión del parámetro <paramref name="node"/> añadiendo primero los datos actuales a un nodo inferior.
/// </summary>
/// <param name="node">Nodo a modificar.</param>
/// <param name="parentType">Nuevo tipo</param>
/// <param name="parentOperator">Nuevo operador.</param>
private static void ApplyParentNode(ExpressionNode node, ExpressionNodeType parentType, ExpressionOperatorType parentOperator)
{
var rdo = new ExpressionNode(node.ExpressionTree)
{
// Mover la expresión debajo del operador.
Type = node.Type,
Operator = node.Operator,
StartIndex = node.StartIndex,
EndIndex = node.EndIndex,
FormattedText = node.FormattedText,
Locked = node.Locked,
};
rdo.Nodes.AddRange(node.Nodes);
node.Nodes.Clear();
node.Nodes.Add(rdo);
node.Type = parentType;
node.Operator = parentOperator;
node.EndIndex = null;
node.FormattedText = null;
node.Locked = false;
}
public void RegisterExpressionNodeType(Type expressionType, ExpressionNodeType nodeType,
params string[] tokenNames)
{
_lock.AcquireWriterLock(TimeSpan.FromSeconds(10));
try
{
Dictionary <string, Type> tokens;
_nodeTable.TryGetValue(nodeType, out tokens);
if (tokens == null)
{
tokens = new Dictionary <string, Type>(StringComparer.CurrentCultureIgnoreCase);
_nodeTable[nodeType] = tokens;
}
foreach (string tokenName in tokenNames)
{
tokens[tokenName] = expressionType;
}
}
finally
{
_lock.ReleaseWriterLock();
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ExpressionObjectBase" /> class.
/// </summary>
/// <param name="type">The type.</param>
public FunctionExpression(ExpressionNodeType type)
: base(type)
{
ConnectorOut = new ConnectorOut(this);
}
protected JsExpression(ExpressionNodeType nodeType)
{
NodeType = nodeType;
}
public static JsUnaryExpression Unary(ExpressionNodeType nodeType, JsExpression operand)
{
return(new JsUnaryExpression(nodeType, operand));
}
/// <summary>
/// 获取各节点类型的优先级
/// </summary>
/// <param name="nodeType"></param>
/// <returns></returns>
private static int GetNodeTypePRI(ExpressionNodeType nodeType)
{
switch (nodeType)
{
case ExpressionNodeType.LParentheses:
case ExpressionNodeType.RParentheses:
return 9;
//逻辑非是一元操作符,所以其优先级较高
case ExpressionNodeType.Not:
return 8;
case ExpressionNodeType.Mod:
return 7;
case ExpressionNodeType.MultiPly:
case ExpressionNodeType.Divide:
case ExpressionNodeType.Power:
return 6;
case ExpressionNodeType.Plus:
case ExpressionNodeType.Subtract:
return 5;
case ExpressionNodeType.LShift:
case ExpressionNodeType.RShift:
return 4;
case ExpressionNodeType.BitwiseAnd:
case ExpressionNodeType.BitwiseOr:
return 3;
case ExpressionNodeType.Equal:
case ExpressionNodeType.Unequal:
case ExpressionNodeType.GT:
case ExpressionNodeType.LT:
case ExpressionNodeType.GTOrEqual:
case ExpressionNodeType.LTOrEqual:
return 2;
case ExpressionNodeType.And:
case ExpressionNodeType.Or:
return 1;
default:
return 0;
}
}
private static string GetBinaryOperatorString(ExpressionNodeType oper)
{
switch (oper)
{
case ExpressionNodeType.Multiply: return("*");
case ExpressionNodeType.Divide: return("/");
case ExpressionNodeType.Modulo: return("%");
case ExpressionNodeType.Add: return("+");
case ExpressionNodeType.Subtract: return("-");
case ExpressionNodeType.LeftShift: return("<<");
case ExpressionNodeType.RightShiftSigned: return(">>");
case ExpressionNodeType.RightShiftUnsigned: return(">>>");
case ExpressionNodeType.Lesser: return("<");
case ExpressionNodeType.LesserOrEqual: return("<=");
case ExpressionNodeType.Greater: return(">");
case ExpressionNodeType.GreaterOrEqual: return(">=");
case ExpressionNodeType.In: return("in");
case ExpressionNodeType.InstanceOf: return("instanceof");
case ExpressionNodeType.Equal: return("==");
case ExpressionNodeType.NotEqual: return("!=");
case ExpressionNodeType.Same: return("===");
case ExpressionNodeType.NotSame: return("!==");
case ExpressionNodeType.BitwiseAnd: return("&");
case ExpressionNodeType.BitwiseXor: return("^");
case ExpressionNodeType.BitwiseOr: return("|");
case ExpressionNodeType.LogicalAnd: return("&&");
case ExpressionNodeType.LogicalOr: return("||");
case ExpressionNodeType.Assign: return("=");
case ExpressionNodeType.MultiplyAssign: return("*=");
case ExpressionNodeType.DivideAssign: return("/=");
case ExpressionNodeType.ModuloAssign: return("%=");
case ExpressionNodeType.AddAssign: return("+=");
case ExpressionNodeType.SubtractAssign: return("-=");
case ExpressionNodeType.LeftShiftAssign: return("<<=");
case ExpressionNodeType.RightShiftSignedAssign: return(">>=");
case ExpressionNodeType.RightShiftUnsignedAssign: return(">>>=");
case ExpressionNodeType.BitwiseAndAssign: return("&=");
case ExpressionNodeType.BitwiseOrAssign: return("|=");
case ExpressionNodeType.BitwiseXorAssign: return("^=");
case ExpressionNodeType.Index:
default:
throw new InvalidOperationException("Invalid operator " + oper.ToString());
}
}
public Expression(ExpressionNodeType nodeType)
{
NodeType = nodeType;
}
protected ArithmeticExpression(ExpressionNodeType nodeType) : base(nodeType)
{
}
protected ConditionalExpression(ExpressionNodeType nodeType) : base(nodeType)
{
}
public ArithmeticExpression(ExpressionNodeType nodeType)
: base(nodeType)
{
}
/// <summary>
/// Creates the type of the expression by.
/// </summary>
/// <param name="type">The type.</param>
/// <returns>IExpressionObjectBase.</returns>
/// <exception cref="System.ArgumentOutOfRangeException">Unknown node type: + type</exception>
public static IExpressionObjectBase CreateExpressionByType(ExpressionNodeType type)
{
switch (type)
{
case ExpressionNodeType.ToLower:
case ExpressionNodeType.ToUpper:
case ExpressionNodeType.Trim:
case ExpressionNodeType.Not:
case ExpressionNodeType.IsNull:
case ExpressionNodeType.Date:
case ExpressionNodeType.DateYear:
case ExpressionNodeType.DateQuarter:
case ExpressionNodeType.DateMonth:
case ExpressionNodeType.DateWeek:
case ExpressionNodeType.DateMonthName:
case ExpressionNodeType.DateDay:
case ExpressionNodeType.Count:
case ExpressionNodeType.HasNewItems:
case ExpressionNodeType.HasRemovedItems:
case ExpressionNodeType.BitwiseNot:
case ExpressionNodeType.Length:
case ExpressionNodeType.SetSampleDataNumeric:
case ExpressionNodeType.SetSampleDataBoolean:
return new OneInOneOutExpression(type);
case ExpressionNodeType.Add:
case ExpressionNodeType.Subtract:
case ExpressionNodeType.Multiply:
case ExpressionNodeType.Divide:
case ExpressionNodeType.Concat:
case ExpressionNodeType.IsGreater:
case ExpressionNodeType.IsGreaterOrEqual:
case ExpressionNodeType.IsLess:
case ExpressionNodeType.IsLessOrEqual:
case ExpressionNodeType.AreEqual:
case ExpressionNodeType.And:
case ExpressionNodeType.Or:
case ExpressionNodeType.Left:
case ExpressionNodeType.Right:
case ExpressionNodeType.AddDays:
case ExpressionNodeType.DateDiffDays:
case ExpressionNodeType.DateDiffHours:
case ExpressionNodeType.Max:
case ExpressionNodeType.Min:
case ExpressionNodeType.Average:
case ExpressionNodeType.Sum:
case ExpressionNodeType.BitwiseAnd:
case ExpressionNodeType.BitwiseOr:
case ExpressionNodeType.BitwiseXor:
case ExpressionNodeType.RegexMatch:
case ExpressionNodeType.AppraiserXBar:
case ExpressionNodeType.AppraiserRangeBar:
case ExpressionNodeType.PartAverage:
case ExpressionNodeType.SplitString:
return new TwoInOneOutExpression(type);
case ExpressionNodeType.If:
case ExpressionNodeType.SubString:
case ExpressionNodeType.FindFirst:
case ExpressionNodeType.AppraiserPartAverage:
case ExpressionNodeType.AppraiserPartRange:
return new ThreeInOneOutExpression(type);
case ExpressionNodeType.AboveCenterLine:
case ExpressionNodeType.BelowCenterLine:
case ExpressionNodeType.GoingDown:
case ExpressionNodeType.GoingUp:
case ExpressionNodeType.AlternatingUpAndDown:
case ExpressionNodeType.Same:
case ExpressionNodeType.FailedNumber:
case ExpressionNodeType.FailedPercent:
return new FourInOneOutExpression(type);
case ExpressionNodeType.ZoneAorBeyond:
case ExpressionNodeType.ZoneBorBeyond:
case ExpressionNodeType.ZoneCorBeyond:
return new FiveInOneOutExpression(type);
case ExpressionNodeType.LessThanLowerLimits:
case ExpressionNodeType.GreaterThanUpperLimits:
case ExpressionNodeType.Between:
return new SixInOneOutExpression(type);
case ExpressionNodeType.Constant:
return new ConstantExpression();
case ExpressionNodeType.Connection:
return new Connection();
case ExpressionNodeType.CustomFunction:
return new FunctionExpression(type);
case ExpressionNodeType.Destination:
case ExpressionNodeType.Result:
return new DestinationFieldList();
case ExpressionNodeType.SourceField:
return new SourceFieldList();
case ExpressionNodeType.Converter:
return new ConverterExpression();
case ExpressionNodeType.FormatValue:
return new FormatValueExpression();
case ExpressionNodeType.CrDisplayValue:
return new OneInOneOutExpression(type);
case ExpressionNodeType.ResultChoiceCategory:
return new OneInOneOutExpression(type);
case ExpressionNodeType.GetArrayItem:
return new GetArrayItemExpression();
case ExpressionNodeType.SkipItems:
return new SkipItemsExpression();
case ExpressionNodeType.TakeItems:
return new TakeItemsExpression();
case ExpressionNodeType.SetChecklistData:
return new SetChecklistDataExpression();
}
throw new ArgumentOutOfRangeException("Unknown node type: " + type);
}
/// <summary>
/// Initializes a new instance of the <see cref="ExpressionNode" /> class.
/// </summary>
protected ExpressionNode(ExpressionNodeType type)
{
_nodeType = type;
}
/// <summary>
/// Initializes a new instance of the <see cref="ExpressionObjectBase"/> class.
/// </summary>
/// <param name="type">The type.</param>
protected ExpressionObjectBase(ExpressionNodeType type)
: this()
{
Type = type;
}
protected AggregateFunction(ExpressionNodeType nodeType) : base(nodeType)
{
}
/// <summary>
/// Initializes a new instance of <see cref="FiveParamsFunctionNode" /> class.
/// </summary>
/// <param name="nodeType">
/// The type of the current node.
/// </param>
protected FiveParamsFunctionNode(ExpressionNodeType nodeType) : base(nodeType)
{
}
private void ToExpressionNodeThreeInOneOutFunctionTest(ExpressionNodeType nodeType, Type functionNode)
{
var obj = new ExpressionNodeFactory();
var connection1 = new Connection();
connection1.Source = new ConnectorOut(connection1);
connection1.Sink = new ConnectorIn(connection1);
var connection2 = new Connection();
connection2.Source = new ConnectorOut(connection2);
connection2.Sink = new ConnectorIn(connection2);
var connection3 = new Connection();
connection3.Source = new ConnectorOut(connection3);
connection3.Sink = new ConnectorIn(connection3);
var connection4 = new Connection();
connection4.Source = new ConnectorOut(connection4);
connection4.Sink = new ConnectorIn(connection4);
var destination = new DestinationFieldList { UniqueName = "Destination" };
destination.Fields.Add(new DestinationField(destination));
var source = new SourceFieldList();
source.Fields.Add(new SourceField(source) { Name = "Field" });
source.Fields.Add(new SourceField(source) { Name = "Field" });
source.Fields.Add(new SourceField(source) { Name = "Field" });
var func = new ThreeInOneOutExpression(nodeType) { UniqueName = "Function" };
func.Connector1In.Id = connection1.Sink.Id;
source.Fields[0].ConnectorOut.Id = connection1.Source.Id;
func.Connector2In.Id = connection2.Sink.Id;
source.Fields[1].ConnectorOut.Id = connection2.Source.Id;
func.Connector3In.Id = connection3.Sink.Id;
source.Fields[2].ConnectorOut.Id = connection3.Source.Id;
destination.Fields[0].ConnectorIn.Id = connection4.Sink.Id;
func.ConnectorOut.Id = connection4.Source.Id;
var objects = new List<IExpressionObjectBase>
{
source,
destination,
func,
connection1,
connection2,
connection3,
connection4
};
var destNode = obj.CreateExpressionNodes(objects);
Assert.AreEqual(functionNode, destNode.ResultNodes.FirstOrDefault().Expression.GetType());
}
/// <summary>
/// 计算节点的值
/// </summary>
/// <param name="nodeType">节点的类型</param>
/// <param name="data">要计算的值,有可能是两位或一位数</param>
/// <returns></returns>
private static object Calculate(ExpressionNodeType nodeType, object[] data)
{
decimal d1, d2;
bool b1, b2;
switch (nodeType)
{
case ExpressionNodeType.Plus:
d1 = ConvertToDecimal(data[0]);
d2 = ConvertToDecimal(data[1]);
return d1 + d2;
case ExpressionNodeType.Subtract:
d1 = ConvertToDecimal(data[0]);
d2 = ConvertToDecimal(data[1]);
return d1 - d2;
case ExpressionNodeType.MultiPly:
d1 = ConvertToDecimal(data[0]);
d2 = ConvertToDecimal(data[1]);
return d1 * d2;
case ExpressionNodeType.Divide:
d1 = ConvertToDecimal(data[0]);
d2 = ConvertToDecimal(data[1]);
if (d2 == 0) throw new DivideByZeroException();
return d1 / d2;
case ExpressionNodeType.Power:
d1 = ConvertToDecimal(data[0]);
d2 = ConvertToDecimal(data[1]);
return Math.Pow((double)d1, (double)d2);
case ExpressionNodeType.Mod:
d1 = ConvertToDecimal(data[0]);
d2 = ConvertToDecimal(data[1]);
if (d2 == 0) throw new DivideByZeroException();
return d1 % d2;
case ExpressionNodeType.BitwiseAnd:
d1 = ConvertToDecimal(data[0]);
d2 = ConvertToDecimal(data[1]);
return (int)d1 & (int)d2;
case ExpressionNodeType.BitwiseOr:
d1 = ConvertToDecimal(data[0]);
d2 = ConvertToDecimal(data[1]);
return (int)d1 | (int)d2;
case ExpressionNodeType.And:
b1 = ConvertToBool(data[0]);
b2 = ConvertToBool(data[1]);
return b1 && b2;
case ExpressionNodeType.Or:
b1 = ConvertToBool(data[0]);
b2 = ConvertToBool(data[1]);
return b1 || b2;
case ExpressionNodeType.Not:
b1 = ConvertToBool(data[0]);
return !b1;
case ExpressionNodeType.Equal:
d1 = ConvertToDecimal(data[0]);
d2 = ConvertToDecimal(data[1]);
return d1 == d2;
case ExpressionNodeType.Unequal:
d1 = ConvertToDecimal(data[0]);
d2 = ConvertToDecimal(data[1]);
return d1 != d2;
case ExpressionNodeType.GT:
d1 = ConvertToDecimal(data[0]);
d2 = ConvertToDecimal(data[1]);
return d1 > d2;
case ExpressionNodeType.LT:
d1 = ConvertToDecimal(data[0]);
d2 = ConvertToDecimal(data[1]);
return d1 < d2;
case ExpressionNodeType.GTOrEqual:
d1 = ConvertToDecimal(data[0]);
d2 = ConvertToDecimal(data[1]);
return d1 >= d2;
case ExpressionNodeType.LTOrEqual:
d1 = ConvertToDecimal(data[0]);
d2 = ConvertToDecimal(data[1]);
return d1 <= d2;
case ExpressionNodeType.LShift:
d1 = ConvertToDecimal(data[0]);
d2 = ConvertToDecimal(data[1]);
return (long)d1 << (int)d2;
case ExpressionNodeType.RShift:
d1 = ConvertToDecimal(data[0]);
d2 = ConvertToDecimal(data[1]);
return (long)d1 >> (int)d2;
default:
return 0;
}
}
protected ExpressionNode(ExpressionNodeType nodeType)
{
NodeType = nodeType;
}
internal static ExpressionNodeInfo GetNodeInfoFromType(ExpressionNodeType type)
{
return(_expressionNodeInfo[type]);
}
public ConditionalExpression(ExpressionNodeType nodeType)
: base(nodeType)
{
}
/// <summary>
/// Initializes a new instance of <see cref="SingleParamFunctionNode"/> class.
/// </summary>
/// <param name="nodeType">The type of the current node.</param>
public TwoParamsFunctionNode(ExpressionNodeType nodeType)
:base(nodeType)
{
}
static XmlExpressionNode()
{
XmlType = new ExpressionNodeType("xml");
}
public NodeTypeAttribute(ExpressionNodeType nodeType)
{
NodeType = nodeType;
}
/// <summary>
/// 判断是否是一元操作符节点
/// </summary>
/// <param name="nodeType"></param>
/// <returns></returns>
public static bool IsUnitaryNode(ExpressionNodeType nodeType)
{
return(nodeType == ExpressionNodeType.Plus || nodeType == ExpressionNodeType.Subtract);
}
/// <summary>
/// Initializes a new instance of <see cref="ExpressionNode"/> class.
/// </summary>
/// <param name="nodeType">Type of the node.</param>
protected ExpressionNode(ExpressionNodeType nodeType)
{
NodeType = nodeType;
}
/// <summary>
/// 判断是否是一元操作符节点
/// </summary>
/// <param name="nodeType"></param>
/// <returns></returns>
public static bool IsUnitaryNode(ExpressionNodeType nodeType)
{
return (nodeType == ExpressionNodeType.Plus || nodeType == ExpressionNodeType.Subtract);
}
/// <summary>
/// 计算节点的值
/// </summary>
/// <param name="nodeType">节点的类型</param>
/// <param name="data">要计算的值,有可能是两位或一位数</param>
/// <returns></returns>
private static object Calculate(ExpressionNodeType nodeType, object[] data)
{
decimal d1, d2;
bool b1, b2;
switch (nodeType)
{
case ExpressionNodeType.Plus:
d1 = ConvertToDecimal(data[0]);
d2 = ConvertToDecimal(data[1]);
return(d1 + d2);
case ExpressionNodeType.Subtract:
d1 = ConvertToDecimal(data[0]);
d2 = ConvertToDecimal(data[1]);
return(d1 - d2);
case ExpressionNodeType.MultiPly:
d1 = ConvertToDecimal(data[0]);
d2 = ConvertToDecimal(data[1]);
return(d1 * d2);
case ExpressionNodeType.Divide:
d1 = ConvertToDecimal(data[0]);
d2 = ConvertToDecimal(data[1]);
if (d2 == 0)
{
throw new DivideByZeroException();
}
return(d1 / d2);
case ExpressionNodeType.Power:
d1 = ConvertToDecimal(data[0]);
d2 = ConvertToDecimal(data[1]);
return(Math.Pow((double)d1, (double)d2));
case ExpressionNodeType.Mod:
d1 = ConvertToDecimal(data[0]);
d2 = ConvertToDecimal(data[1]);
if (d2 == 0)
{
throw new DivideByZeroException();
}
return(d1 % d2);
case ExpressionNodeType.BitwiseAnd:
d1 = ConvertToDecimal(data[0]);
d2 = ConvertToDecimal(data[1]);
return((int)d1 & (int)d2);
case ExpressionNodeType.BitwiseOr:
d1 = ConvertToDecimal(data[0]);
d2 = ConvertToDecimal(data[1]);
return((int)d1 | (int)d2);
case ExpressionNodeType.And:
b1 = ConvertToBool(data[0]);
b2 = ConvertToBool(data[1]);
return(b1 && b2);
case ExpressionNodeType.Or:
b1 = ConvertToBool(data[0]);
b2 = ConvertToBool(data[1]);
return(b1 || b2);
case ExpressionNodeType.Not:
b1 = ConvertToBool(data[0]);
return(!b1);
case ExpressionNodeType.Equal:
d1 = ConvertToDecimal(data[0]);
d2 = ConvertToDecimal(data[1]);
return(d1 == d2);
case ExpressionNodeType.Unequal:
d1 = ConvertToDecimal(data[0]);
d2 = ConvertToDecimal(data[1]);
return(d1 != d2);
case ExpressionNodeType.GT:
d1 = ConvertToDecimal(data[0]);
d2 = ConvertToDecimal(data[1]);
return(d1 > d2);
case ExpressionNodeType.LT:
d1 = ConvertToDecimal(data[0]);
d2 = ConvertToDecimal(data[1]);
return(d1 < d2);
case ExpressionNodeType.GTOrEqual:
d1 = ConvertToDecimal(data[0]);
d2 = ConvertToDecimal(data[1]);
return(d1 >= d2);
case ExpressionNodeType.LTOrEqual:
d1 = ConvertToDecimal(data[0]);
d2 = ConvertToDecimal(data[1]);
return(d1 <= d2);
case ExpressionNodeType.LShift:
d1 = ConvertToDecimal(data[0]);
d2 = ConvertToDecimal(data[1]);
return((long)d1 << (int)d2);
case ExpressionNodeType.RShift:
d1 = ConvertToDecimal(data[0]);
d2 = ConvertToDecimal(data[1]);
return((long)d1 >> (int)d2);
default:
return(0);
}
}
private static int GetPrecedence(ExpressionNodeType nodeType)
{
switch (nodeType)
{
case ExpressionNodeType.ArrayLiteral:
return(PrecedenceTerminal);
case ExpressionNodeType.LogicalAnd:
return(PrecedenceLogicalAnd);
case ExpressionNodeType.LogicalOr:
return(PrecedenceLogicalOr);
case ExpressionNodeType.NotEqual:
case ExpressionNodeType.Equal:
case ExpressionNodeType.Same:
case ExpressionNodeType.NotSame:
return(PrecedenceEquality);
case ExpressionNodeType.LesserOrEqual:
case ExpressionNodeType.GreaterOrEqual:
case ExpressionNodeType.Lesser:
case ExpressionNodeType.Greater:
case ExpressionNodeType.InstanceOf:
case ExpressionNodeType.In:
return(PrecedenceRelational);
case ExpressionNodeType.Subtract:
case ExpressionNodeType.Add:
return(PrecedenceAddition);
case ExpressionNodeType.Modulo:
case ExpressionNodeType.Divide:
case ExpressionNodeType.Multiply:
return(PrecedenceMultiply);
case ExpressionNodeType.BitwiseAnd:
return(PrecedenceBitwiseAnd);
case ExpressionNodeType.BitwiseOr:
return(PrecedenceBitwiseOr);
case ExpressionNodeType.BitwiseXor:
return(PrecedenceBitwiseXor);
case ExpressionNodeType.LeftShift:
case ExpressionNodeType.RightShiftSigned:
case ExpressionNodeType.RightShiftUnsigned:
return(PrecedenceBitwiseShift);
case ExpressionNodeType.Assign:
case ExpressionNodeType.MultiplyAssign:
case ExpressionNodeType.DivideAssign:
case ExpressionNodeType.ModuloAssign:
case ExpressionNodeType.AddAssign:
case ExpressionNodeType.SubtractAssign:
case ExpressionNodeType.LeftShiftAssign:
case ExpressionNodeType.RightShiftSignedAssign:
case ExpressionNodeType.RightShiftUnsignedAssign:
case ExpressionNodeType.BitwiseAndAssign:
case ExpressionNodeType.BitwiseOrAssign:
case ExpressionNodeType.BitwiseXorAssign:
return(PrecedenceAssignment);
case ExpressionNodeType.Comma:
return(PrecedenceComma);
case ExpressionNodeType.Conditional:
return(PrecedenceConditional);
case ExpressionNodeType.Number:
case ExpressionNodeType.String:
case ExpressionNodeType.Regexp:
case ExpressionNodeType.Null:
case ExpressionNodeType.Boolean:
return(PrecedenceTerminal);
case ExpressionNodeType.FunctionDefinition:
return(PrecedenceFunctionDefinition);
case ExpressionNodeType.Identifier:
case ExpressionNodeType.This:
return(PrecedenceTerminal);
case ExpressionNodeType.MemberAccess:
case ExpressionNodeType.New:
case ExpressionNodeType.Index:
case ExpressionNodeType.Invocation:
return(PrecedenceMemberOrNewOrInvocation);
case ExpressionNodeType.ObjectLiteral:
return(PrecedenceTerminal);
case ExpressionNodeType.PrefixPlusPlus:
case ExpressionNodeType.PrefixMinusMinus:
case ExpressionNodeType.PostfixPlusPlus:
case ExpressionNodeType.PostfixMinusMinus:
return(PrecedenceIncrDecr);
case ExpressionNodeType.TypeOf:
case ExpressionNodeType.LogicalNot:
case ExpressionNodeType.Negate:
case ExpressionNodeType.Positive:
case ExpressionNodeType.Delete:
case ExpressionNodeType.Void:
case ExpressionNodeType.BitwiseNot:
return(PrecedenceOtherUnary);
case ExpressionNodeType.TypeReference:
return(PrecedenceTerminal);
case ExpressionNodeType.Literal:
return(PrecedenceLiteral);
default:
throw new ArgumentException("nodeType");
}
}
protected FunctionBase(ExpressionNodeType nodeType) : base(nodeType)
{
Arguments = new List <IExpression>();
}
public static JsBinaryExpression Binary(ExpressionNodeType nodeType, JsExpression left, JsExpression right)
{
return(new JsBinaryExpression(nodeType, left, right));
}
/// <summary>
/// Converts from <see cref="ExpressionNode"/> to <see cref="Expression"/>
/// when the <see cref="ExpressionOperatorType"/> is a value expression.
/// </summary>
private Expression BuildValueExpression(ExpressionNode expression, ExpressionNodeType type)
{
Expression rdo;
string content;
PropertyInfo pi;
content = expression.FormattedText ?? expression.Text;
switch (type)
{
case ExpressionNodeType.StringType:
if (content.StartsWith("'") && content.EndsWith("'"))
{
content = content.Substring(1, content.Length - 2);
}
rdo = Expression.Constant(content);
break;
case ExpressionNodeType.DateType:
if (content.StartsWith("#") && content.EndsWith("#"))
{
content = content.Substring(1, content.Length - 2);
}
rdo = Expression.Constant(DateTime.Parse(content, CultureInfo.InvariantCulture));
break;
case ExpressionNodeType.PropertyType:
if (content.StartsWith("[") && content.EndsWith("]"))
{
content = content.Substring(1, content.Length - 2);
}
pi = ItemType.GetCachedProperties()[content];
rdo = Expression.Property(this.ParameterExpression, pi);
break;
case ExpressionNodeType.UnknownType:
Double dbl;
bool bln;
// Adivinar tipo. Probar número, boolean, propiedad... Al final, si no se identifica, dejar como object.
if (Double.TryParse(content, NumberStyles.Number, CultureInfo.InvariantCulture, out dbl))
{
rdo = Expression.Constant(dbl);
}
else if (Boolean.TryParse(content, out bln))
{
rdo = Expression.Constant(bln);
}
else if (Properties.TryGetValue(content, out pi))
{
rdo = BuildValueExpression(expression, ExpressionNodeType.PropertyType);
}
else
{
rdo = Expression.Constant(content, typeof(object)); // TODO: Mas averiguaciones.
}
break;
default:
throw new NotImplementedException(); // TODO: Tipo no permitido.
}
return(rdo);
}
/// <summary>
/// Initializes a new instance of <see cref="SingleParamFunctionNode"/> class.
/// </summary>
/// <param name="nodeType">The type of the current node.</param>
public SingleParamFunctionNode(ExpressionNodeType nodeType)
:base(nodeType)
{
}
public NodeTypeAttribute(ExpressionNodeType nodeType)
{
NodeType = nodeType;
}
