/// <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) { }