ISemantic E(UnaryExpression x) { if (x is NewExpression) return E((NewExpression)x); else if (x is CastExpression) return E((CastExpression)x); else if (x is UnaryExpression_Cat) return E((UnaryExpression_Cat)x); else if (x is UnaryExpression_Increment) return E((UnaryExpression_Increment)x); else if (x is UnaryExpression_Decrement) return E((UnaryExpression_Decrement)x); else if (x is UnaryExpression_Add) return E((UnaryExpression_Add)x); else if (x is UnaryExpression_Sub) return E((UnaryExpression_Sub)x); else if (x is UnaryExpression_Not) return E((UnaryExpression_Not)x); else if (x is UnaryExpression_Mul) return E((UnaryExpression_Mul)x); else if (x is UnaryExpression_And) return E((UnaryExpression_And)x); else if (x is DeleteExpression) return E((DeleteExpression)x); else if (x is UnaryExpression_Type) return E((UnaryExpression_Type)x); return null; }
public void TestDoFoldConstantInPositiveSquareRoot() { AbstractExpr input = new UnaryExpression(Polynomial.CreateConstant(4), new PositiveSquareroot()); IAbstractExpr result = input.Accept(visitor, Ig.nore); Assert.AreNotEqual(input, result); Assert.AreEqual(Polynomial.CreateConstant(2), result); }
public void TestComplexExpression() { const string VAR_X = "x"; const string VAR_Y = "y"; const string VAR_Z = "z"; var ctx = new Context(); ctx.SetValue(VAR_X, true); ctx.SetValue(VAR_Y, true); ctx.SetValue(VAR_Z, false); var constExp = new ConstExpression(TRUE_TOKEN); var unaryExp = new UnaryExpression(constExp); Assert.AreEqual(false, unaryExp.Interpret(ctx)); var binaryExp = new BinaryExpression( new BinaryExpression(VAR_X, BinaryOp.And, unaryExp), BinaryOp.Or, new BinaryExpression(new UnaryExpression(VAR_Y), BinaryOp.And, VAR_Z)); Assert.AreEqual(false, binaryExp.Interpret(ctx)); }
void EmitUnaryExpression(UnaryExpression expr, MethodInfo method) { // Compute the operands VisitExpression(expr.Operand); // Call the operator method IL.Emit(OpCodes.Call, method); }
/// <summary> /// 获取简单表达式 /// </summary> /// <param name="binaryExpression">一元表达式</param> /// <returns>简单表达式</returns> private static Expression getSimpleIsTrue(UnaryExpression binaryExpression) { if (binaryExpression.Expression.IsConstant) { return new logicConstantExpression((bool)((ConstantExpression)binaryExpression.Expression).Value); } return binaryExpression; }
/// <summary> /// 获取简单表达式 /// </summary> /// <param name="binaryExpression">一元表达式</param> /// <returns>简单表达式</returns> private static Expression getSimpleNot(UnaryExpression binaryExpression) { if (binaryExpression.Expression.IsConstant) { return new ConstantExpression(!(bool)((ConstantExpression)binaryExpression.Expression).Value); } return binaryExpression; }
public override Expression VisitRefTypeExpression(RefTypeExpression reftypexp) { if (reftypexp == null) return null; Expression result = base.VisitRefTypeExpression (reftypexp); if (result != reftypexp) return result; UnaryExpression refanytype = new UnaryExpression(reftypexp.Operand, NodeType.Refanytype, SystemTypes.RuntimeTypeHandle, reftypexp.SourceContext); ExpressionList arguments = new ExpressionList(1); arguments.Add(refanytype); MemberBinding mb = new MemberBinding(null, Runtime.GetTypeFromHandle); return new MethodCall(mb, arguments, NodeType.Call, SystemTypes.Type); }
public bool Match(UnaryExpression unary) { if (unary.Operator == Operator.Neg) { bin = unary.Expression as BinaryExpression; if (bin != null && bin.Operator == Operator.ISub) return true; } return false; }
private void EmitThrow(UnaryExpression expr, CompilationFlags flags) { if (expr.Operand == null) { CheckRethrow(); _ilg.Emit(OpCodes.Rethrow); } else { EmitExpression(expr.Operand); _ilg.Emit(OpCodes.Throw); } EmitUnreachable(expr, flags); }
private void EmitThrow(UnaryExpression expr, EmitAs emitAs) { if (expr.Operand == null) { CheckRethrow(); _ilg.Emit(OpCodes.Rethrow); } else { EmitExpression(expr.Operand); _ilg.Emit(OpCodes.Throw); } if (emitAs != EmitAs.Void && expr.Type != typeof(void)) { _ilg.EmitDefault(expr.Type); } }
//CONFORMING private void EmitUnary(UnaryExpression node) { if (node.Method != null) { EmitUnaryMethod(node); } else if (node.NodeType == ExpressionType.NegateChecked && TypeUtils.IsInteger(node.Operand.Type)) { _ilg.EmitInt(0); _ilg.EmitConvertToType(typeof(int), node.Operand.Type, false); EmitExpression(node.Operand); EmitBinaryOperator(ExpressionType.SubtractChecked, node.Operand.Type, node.Operand.Type, node.Type, false); } else { EmitExpression(node.Operand); EmitUnaryOperator(node.NodeType, node.Operand.Type, node.Type); } }
private void EmitUnary(UnaryExpression node, CompilationFlags flags) { if (node.Method != null) { EmitUnaryMethod(node, flags); } else if (node.NodeType == ExpressionType.NegateChecked && TypeUtils.IsInteger(node.Operand.Type)) { EmitExpression(node.Operand); LocalBuilder loc = GetLocal(node.Operand.Type); _ilg.Emit(OpCodes.Stloc, loc); _ilg.EmitInt(0); _ilg.EmitConvertToType(typeof(int), node.Operand.Type, false); _ilg.Emit(OpCodes.Ldloc, loc); FreeLocal(loc); EmitBinaryOperator(ExpressionType.SubtractChecked, node.Operand.Type, node.Operand.Type, node.Type, false); } else { EmitExpression(node.Operand); EmitUnaryOperator(node.NodeType, node.Operand.Type, node.Type); } }
private void EmitQuote(UnaryExpression quote) { // emit the quoted expression as a runtime constant EmitConstant(quote.Operand, quote.Type); // Heuristic: only emit the tree rewrite logic if we have hoisted // locals. if (_scope.NearestHoistedLocals != null) { // HoistedLocals is internal so emit as System.Object EmitConstant(_scope.NearestHoistedLocals, typeof(object)); _scope.EmitGet(_scope.NearestHoistedLocals.SelfVariable); _ilg.Emit(OpCodes.Call, typeof(RuntimeOps).GetMethod("Quote")); if (quote.Type != typeof(Expression)) { _ilg.Emit(OpCodes.Castclass, quote.Type); } } }
//CONFORMING private void EmitQuote(UnaryExpression quote) { // emit the quoted expression as a runtime constant EmitConstant(quote.Operand, quote.Type); // Heuristic: only emit the tree rewrite logic if we have hoisted // locals. TODO: we could use an even smarter logic here by // detecting if any nodes actually need to be rewritten if (_scope.NearestHoistedLocals != null) { // HoistedLocals is internal so emit as System.Object EmitConstant(_scope.NearestHoistedLocals, typeof(object)); _scope.EmitGet(_scope.NearestHoistedLocals.SelfVariable); _ilg.EmitCall(typeof(RuntimeOps).GetMethod("Quote")); if (quote.Type != typeof(Expression)) { _ilg.Emit(OpCodes.Castclass, quote.Type); } } }
protected override Expression VisitUnary(UnaryExpression node) { Invoke(node.Method); return(base.VisitUnary(node)); }
public virtual TreeNode VisitUnaryExpression(UnaryExpression expression) { var operand = VisitExpression(expression.Operand); return(new TreeNode(expression.Method.Name, operand)); }
public virtual void VisitUnaryExpression(UnaryExpression unary) { unary.Expression.Accept(this); }
private IList <Inferred> InferUnaryExpression(UnaryExpression node, Scope scope) { return(Infer(node.Expression, scope)); }
public void UpdateDiffOperandDiffNode() { UnaryExpression op = Expression.PreDecrementAssign(Expression.Variable(typeof(int))); Assert.NotSame(op, op.Update(Expression.Variable(typeof(int)))); }
private string ProcessUnaryExpressionConvert(UnaryExpression unaryExpression, WhereQueryData data) { return(ProcessExpression(unaryExpression.Operand, data, unaryExpression.NodeType)); }
protected override object VisitUnary_Convert(UnaryExpression exp) { object operandValue = this.Visit(exp.Operand); //(int)null if (operandValue == null) { //(int)null if (exp.Type.IsValueType && !exp.Type.IsNullable()) { throw new NullReferenceException(); } return(null); } Type operandValueType = operandValue.GetType(); if (exp.Type == operandValueType || exp.Type.IsAssignableFrom(operandValueType)) { return(operandValue); } Type underlyingType; if (exp.Type.IsNullable(out underlyingType)) { //(int?)int if (underlyingType == operandValueType) { var constructor = exp.Type.GetConstructor(new Type[] { operandValueType }); var val = constructor.Invoke(new object[] { operandValue }); return(val); } else { //如果不等,则诸如:(long?)int / (long?)int? --> (long?)((long)int) / (long?)((long)int?) var c = Expression.MakeUnary(ExpressionType.Convert, Expression.Constant(operandValue), underlyingType); var cc = Expression.MakeUnary(ExpressionType.Convert, c, exp.Type); return(this.Visit(cc)); } } //(int)int? if (operandValueType.IsNullable(out underlyingType)) { if (underlyingType == exp.Type) { var pro = operandValueType.GetProperty("Value"); var val = pro.GetValue(operandValue, null); return(val); } else { //如果不等,则诸如:(long)int? --> (long)((long)int) var c = Expression.MakeUnary(ExpressionType.Convert, Expression.Constant(operandValue), underlyingType); var cc = Expression.MakeUnary(ExpressionType.Convert, c, exp.Type); return(this.Visit(cc)); } } //(long)int if (operandValue is IConvertible) { return(Convert.ChangeType(operandValue, exp.Type)); } throw new NotSupportedException(string.Format("Does not support the type '{0}' converted to type '{1}'.", operandValueType.FullName, exp.Type.FullName)); }
protected override object VisitUnary_Quote(UnaryExpression exp) { var e = ExpressionExtension.StripQuotes(exp); return(e); }
public bool VisitUnaryExpression(UnaryExpression unary) => unary.Expression.Accept(this);
private static Expression SelectStructuralProperties(Expression source, OeSelectItem root) { if (!root.HasNavigationItems) { return(source); } ParameterExpression parameter = Expression.Parameter(OeExpressionHelper.GetCollectionItemType(source.Type)); IReadOnlyList <MemberExpression> joins = OeExpressionHelper.GetPropertyExpressions(parameter); var newJoins = new Expression[joins.Count]; List <OeSelectItem> navigationItems = FlattenNavigationItems(root, true); for (int i = 0; i < navigationItems.Count; i++) { newJoins[i] = joins[i]; if (navigationItems[i].SelectItems.Count > 0) { var properties = new Expression[navigationItems[i].SelectItems.Count]; for (int j = 0; j < navigationItems[i].SelectItems.Count; j++) { if (navigationItems[i].SelectItems[j].EdmProperty is ComputeProperty computeProperty) { properties[j] = new ReplaceParameterVisitor(joins[i]).Visit(computeProperty.Expression); } else { PropertyInfo property = joins[i].Type.GetPropertyIgnoreCase(navigationItems[i].SelectItems[j].EdmProperty); properties[j] = Expression.Property(joins[i], property); } } Expression newTupleExpression = OeExpressionHelper.CreateTupleExpression(properties); if (i > 0 && navigationItems[i].EdmProperty.Type.IsNullable) { UnaryExpression nullConstant = Expression.Convert(OeConstantToVariableVisitor.NullConstantExpression, newTupleExpression.Type); newTupleExpression = Expression.Condition(Expression.Equal(joins[i], OeConstantToVariableVisitor.NullConstantExpression), nullConstant, newTupleExpression); } newJoins[i] = newTupleExpression; } } NewExpression newSelectorBody = OeExpressionHelper.CreateTupleExpression(newJoins); MethodInfo selectMethodInfo = OeMethodInfoHelper.GetSelectMethodInfo(parameter.Type, newSelectorBody.Type); LambdaExpression newSelector = Expression.Lambda(newSelectorBody, parameter); //Quirk EF Core 2.1.1 bug Take/Skip must be last in expression tree var skipTakeExpressions = new List <MethodCallExpression>(); while (source is MethodCallExpression callExpression && (callExpression.Method.Name == nameof(Enumerable.Skip) || callExpression.Method.Name == nameof(Enumerable.Take))) { skipTakeExpressions.Add(callExpression); source = callExpression.Arguments[0]; } source = Expression.Call(selectMethodInfo, source, newSelector); for (int i = skipTakeExpressions.Count - 1; i >= 0; i--) { MethodInfo skipTakeMethodInfo = skipTakeExpressions[i].Method.GetGenericMethodDefinition().MakeGenericMethod(newSelector.ReturnType); source = Expression.Call(skipTakeMethodInfo, source, skipTakeExpressions[i].Arguments[1]); } return(source); }
/// <summary> /// UnaryExpression visit method /// </summary> /// <param name="u">The UnaryExpression expression to visit</param> /// <returns>The visited UnaryExpression expression </returns> internal override Expression VisitUnary(UnaryExpression u) { throw new NotSupportedException(Strings.ALinq_UnaryNotSupported(u.NodeType.ToString())); }
internal string VisitTypeAs(UnaryExpression expression) { var operand = Visit(expression.Operand); return(string.IsNullOrEmpty(operand) ? $"cast({expression.Type.FullName})" : $"cast({operand}, {expression.Type.FullName})"); }
internal string VisitArrayLength(UnaryExpression expression) { return($"{Visit(expression.Operand)}/Length"); }
internal string VisitNegate(UnaryExpression expression) { return("-" + Visit(expression.Operand)); }
public void VisitUnaryExpression(UnaryExpression unaryExpr) { unaryExpr.Operand.AcceptWalker(this); }
private static string DealUnaryExpression(UnaryExpression exp, ref Dictionary <string, object> pms) { return(DealExpress(exp.Operand, ref pms)); }
public bool VisitUnaryExpression(UnaryExpression unary) { return(unary.Expression.Accept(this)); }
private void EmitUnaryMethod(UnaryExpression node, CompilationFlags flags) { if (node.IsLifted) { ParameterExpression v = Expression.Variable(node.Operand.Type.GetNonNullableType(), name: null); MethodCallExpression mc = Expression.Call(node.Method, v); Type resultType = mc.Type.GetNullableType(); EmitLift(node.NodeType, resultType, mc, new ParameterExpression[] { v }, new Expression[] { node.Operand }); _ilg.EmitConvertToType(resultType, node.Type, isChecked: false); } else { EmitMethodCallExpression(Expression.Call(node.Method, node.Operand), flags); } }
public void UpdateSameOperandSameNode() { UnaryExpression op = Expression.PreDecrementAssign(Expression.Variable(typeof(int))); Assert.Same(op, op.Update(op.Operand)); }
public override void Exit(UnaryExpression node) { level--; }
private static string BuildPath(UnaryExpression expression) { return(BuildPath(expression.Operand)); }
protected internal virtual void PostWalk(UnaryExpression node) { }
private bool CompareUnary(UnaryExpression a, UnaryExpression b) => Equals(a.Method, b.Method) && a.IsLifted == b.IsLifted && a.IsLiftedToNull == b.IsLiftedToNull && Compare(a.Operand, b.Operand);
private bool ParseStatement(Block/*!*/ block) { //parse instructions and put in expression tree until an assignment, void call, branch target, or branch is encountered StatementList statementList = block.Statements; Expression expr = null; Statement statement = null; bool transferStatement = false; int startingAddress = 0; #if !FxCop SourceContext sourceContext = new SourceContext(); sourceContext.StartPos = this.counter; #endif #if !ROTOR if (this.method.contextForOffset != null){ object sctx = this.method.contextForOffset[this.counter+1]; if (sctx != null) sourceContext = (SourceContext)sctx; } #endif while (true){ bool isStatement = false; startingAddress = this.counter+1; //Add one so that it is never zero (the latter means no entry to the TrivialHashtable) #if FxCop || ILOFFSETS this.ilOffset = this.counter; this.opCode = this.GetOpCode(); #else OpCode opCode = this.GetOpCode(); #endif #if FxCop if (this.handlerMap.TryGetValue(this.ilOffset, out expr)){ expr.sourceContext = sourceContext; expr.ILOffset = this.ilOffset; this.operandStack.Push(expr); } #endif switch (opCode){ case OpCode.Nop: statement = new Statement(NodeType.Nop); goto done; case OpCode.Break: statement = new Statement(NodeType.DebugBreak); goto done; case OpCode.Ldarg_0: expr = this.Parameters(0); break; case OpCode.Ldarg_1: expr = this.Parameters(1); break; case OpCode.Ldarg_2: expr = this.Parameters(2); break; case OpCode.Ldarg_3: expr = this.Parameters(3); break; case OpCode.Ldloc_0: expr = this.locals[0]; break; case OpCode.Ldloc_1: expr = this.locals[1]; break; case OpCode.Ldloc_2: expr = this.locals[2]; break; case OpCode.Ldloc_3: expr = this.locals[3]; break; case OpCode.Stloc_0: statement = new AssignmentStatement(this.locals[0], PopOperand()); goto done; case OpCode.Stloc_1: statement = new AssignmentStatement(this.locals[1], PopOperand()); goto done; case OpCode.Stloc_2: statement = new AssignmentStatement(this.locals[2], PopOperand()); goto done; case OpCode.Stloc_3: statement = new AssignmentStatement(this.locals[3], PopOperand()); goto done; case OpCode.Ldarg_S: expr = this.Parameters(this.GetByte()); break; case OpCode.Ldarga_S: expr = SetType(new UnaryExpression(this.Parameters(this.GetByte()), NodeType.AddressOf)); break; case OpCode.Starg_S: statement = new AssignmentStatement(this.Parameters(this.GetByte()), PopOperand()); goto done; case OpCode.Ldloc_S: expr = this.locals[this.GetByte()]; break; case OpCode.Ldloca_S: expr = SetType(new UnaryExpression(this.locals[this.GetByte()], NodeType.AddressOf)); break; case OpCode.Stloc_S: statement = new AssignmentStatement(this.locals[this.GetByte()], PopOperand()); goto done; case OpCode.Ldnull: expr = new Literal(null, CoreSystemTypes.Object); break; case OpCode.Ldc_I4_M1: expr = new Literal(-1, CoreSystemTypes.Int32); break; case OpCode.Ldc_I4_0: expr = new Literal(0, CoreSystemTypes.Int32); break; case OpCode.Ldc_I4_1: expr = new Literal(1, CoreSystemTypes.Int32); break; case OpCode.Ldc_I4_2: expr = new Literal(2, CoreSystemTypes.Int32); break; case OpCode.Ldc_I4_3: expr = new Literal(3, CoreSystemTypes.Int32); break; case OpCode.Ldc_I4_4: expr = new Literal(4, CoreSystemTypes.Int32); break; case OpCode.Ldc_I4_5: expr = new Literal(5, CoreSystemTypes.Int32); break; case OpCode.Ldc_I4_6: expr = new Literal(6, CoreSystemTypes.Int32); break; case OpCode.Ldc_I4_7: expr = new Literal(7, CoreSystemTypes.Int32); break; case OpCode.Ldc_I4_8: expr = new Literal(8, CoreSystemTypes.Int32); break; case OpCode.Ldc_I4_S: expr = new Literal((int)this.GetSByte(), CoreSystemTypes.Int32); break; case OpCode.Ldc_I4: expr = new Literal(this.GetInt32(), CoreSystemTypes.Int32); break; case OpCode.Ldc_I8: expr = new Literal(this.GetInt64(), CoreSystemTypes.Int64); break; case OpCode.Ldc_R4: expr = new Literal(this.GetSingle(), CoreSystemTypes.Single); break; case OpCode.Ldc_R8: expr = new Literal(this.GetDouble(), CoreSystemTypes.Double); break; case OpCode.Dup: statement = new ExpressionStatement(new Expression(NodeType.Dup)); goto done; case OpCode.Pop: statement = new ExpressionStatement(new UnaryExpression(PopOperand(), NodeType.Pop)); goto done; case OpCode.Jmp: expr = this.ParseCall(NodeType.Jmp, out isStatement); if (isStatement) goto done; break; case OpCode.Call: expr = this.ParseCall(NodeType.Call, out isStatement); if (isStatement) goto done; break; case OpCode.Calli: expr = this.ParseCalli(out isStatement); if (isStatement) goto done; break; case OpCode.Ret: Expression retVal = BodyParser.TypeIsVoid(this.method.ReturnType) ? null : PopOperand(); statement = new Return(retVal); transferStatement = true; goto done; case OpCode.Br_S: statement = this.ParseBranch(NodeType.Nop, 0, true, false); transferStatement = true; goto done; case OpCode.Brfalse_S: statement = this.ParseBranch(NodeType.LogicalNot, 1, true, false); transferStatement = true; goto done; case OpCode.Brtrue_S: statement = this.ParseBranch(NodeType.Nop, 1, true, false); transferStatement = true; goto done; case OpCode.Beq_S: statement = this.ParseBranch(NodeType.Eq, 2, true, false); transferStatement = true; goto done; case OpCode.Bge_S: statement = this.ParseBranch(NodeType.Ge, 2, true, false); transferStatement = true; goto done; case OpCode.Bgt_S: statement = this.ParseBranch(NodeType.Gt, 2, true, false); transferStatement = true; goto done; case OpCode.Ble_S: statement = this.ParseBranch(NodeType.Le, 2, true, false); transferStatement = true; goto done; case OpCode.Blt_S: statement = this.ParseBranch(NodeType.Lt, 2, true, false); transferStatement = true; goto done; case OpCode.Bne_Un_S: statement = this.ParseBranch(NodeType.Ne, 2, true, true); transferStatement = true; goto done; case OpCode.Bge_Un_S: statement = this.ParseBranch(NodeType.Ge, 2, true, true); transferStatement = true; goto done; case OpCode.Bgt_Un_S: statement = this.ParseBranch(NodeType.Gt, 2, true, true); transferStatement = true; goto done; case OpCode.Ble_Un_S: statement = this.ParseBranch(NodeType.Le, 2, true, true); transferStatement = true; goto done; case OpCode.Blt_Un_S: statement = this.ParseBranch(NodeType.Lt, 2, true, true); transferStatement = true; goto done; case OpCode.Br: statement = this.ParseBranch(NodeType.Nop, 0, false, false); transferStatement = true; goto done; case OpCode.Brfalse: statement = this.ParseBranch(NodeType.LogicalNot, 1, false, false); transferStatement = true; goto done; case OpCode.Brtrue: statement = this.ParseBranch(NodeType.Nop, 1, false, false); transferStatement = true; goto done; case OpCode.Beq: statement = this.ParseBranch(NodeType.Eq, 2, false, false); transferStatement = true; goto done; case OpCode.Bge: statement = this.ParseBranch(NodeType.Ge, 2, false, false); transferStatement = true; goto done; case OpCode.Bgt: statement = this.ParseBranch(NodeType.Gt, 2, false, false); transferStatement = true; goto done; case OpCode.Ble: statement = this.ParseBranch(NodeType.Le, 2, false, false); transferStatement = true; goto done; case OpCode.Blt: statement = this.ParseBranch(NodeType.Lt, 2, false, false); transferStatement = true; goto done; case OpCode.Bne_Un: statement = this.ParseBranch(NodeType.Ne, 2, false, true); transferStatement = true; goto done; case OpCode.Bge_Un: statement = this.ParseBranch(NodeType.Ge, 2, false, true); transferStatement = true; goto done; case OpCode.Bgt_Un: statement = this.ParseBranch(NodeType.Gt, 2, false, true); transferStatement = true; goto done; case OpCode.Ble_Un: statement = this.ParseBranch(NodeType.Le, 2, false, true); transferStatement = true; goto done; case OpCode.Blt_Un: statement = this.ParseBranch(NodeType.Lt, 2, false, true); transferStatement = true; goto done; case OpCode.Switch: statement = this.ParseSwitchInstruction(); transferStatement = true; goto done; case OpCode.Ldind_I1: expr = new AddressDereference(PopOperand(), CoreSystemTypes.Int8, this.isVolatile, this.alignment); break; case OpCode.Ldind_U1: expr = new AddressDereference(PopOperand(), CoreSystemTypes.UInt8, this.isVolatile, this.alignment); break; case OpCode.Ldind_I2: expr = new AddressDereference(PopOperand(), CoreSystemTypes.Int16, this.isVolatile, this.alignment); break; case OpCode.Ldind_U2: expr = new AddressDereference(PopOperand(), CoreSystemTypes.UInt16, this.isVolatile, this.alignment); break; case OpCode.Ldind_I4: expr = new AddressDereference(PopOperand(), CoreSystemTypes.Int32, this.isVolatile, this.alignment); break; case OpCode.Ldind_U4: expr = new AddressDereference(PopOperand(), CoreSystemTypes.UInt32, this.isVolatile, this.alignment); break; case OpCode.Ldind_I8: expr = new AddressDereference(PopOperand(), CoreSystemTypes.Int64, this.isVolatile, this.alignment); break; case OpCode.Ldind_I: expr = new AddressDereference(PopOperand(), CoreSystemTypes.IntPtr, this.isVolatile, this.alignment); break; case OpCode.Ldind_R4: expr = new AddressDereference(PopOperand(), CoreSystemTypes.Single, this.isVolatile, this.alignment); break; case OpCode.Ldind_R8: expr = new AddressDereference(PopOperand(), CoreSystemTypes.Double, this.isVolatile, this.alignment); break; case OpCode.Ldind_Ref: expr = new AddressDereference(PopOperand(), CoreSystemTypes.Object, this.isVolatile, this.alignment); break; case OpCode.Stind_Ref: statement = this.ParseStoreIndirect(CoreSystemTypes.Object); goto done; case OpCode.Stind_I1: statement = this.ParseStoreIndirect(CoreSystemTypes.Int8); goto done; case OpCode.Stind_I2: statement = this.ParseStoreIndirect(CoreSystemTypes.Int16); goto done; case OpCode.Stind_I4: statement = this.ParseStoreIndirect(CoreSystemTypes.Int32); goto done; case OpCode.Stind_I8: statement = this.ParseStoreIndirect(CoreSystemTypes.Int64); goto done; case OpCode.Stind_R4: statement = this.ParseStoreIndirect(CoreSystemTypes.Single); goto done; case OpCode.Stind_R8: statement = this.ParseStoreIndirect(CoreSystemTypes.Double); goto done; case OpCode.Add: expr = this.ParseBinaryOperation(NodeType.Add); break; case OpCode.Sub: expr = this.ParseBinaryOperation(NodeType.Sub); break; case OpCode.Mul: expr = this.ParseBinaryOperation(NodeType.Mul); break; case OpCode.Div: expr = this.ParseBinaryOperation(NodeType.Div); break; case OpCode.Div_Un: expr = this.ParseBinaryOperation(NodeType.Div_Un); break; case OpCode.Rem: expr = this.ParseBinaryOperation(NodeType.Rem); break; case OpCode.Rem_Un: expr = this.ParseBinaryOperation(NodeType.Rem_Un); break; case OpCode.And: expr = this.ParseBinaryOperation(NodeType.And); break; case OpCode.Or: expr = this.ParseBinaryOperation(NodeType.Or); break; case OpCode.Xor: expr = this.ParseBinaryOperation(NodeType.Xor); break; case OpCode.Shl: expr = this.ParseBinaryOperation(NodeType.Shl); break; case OpCode.Shr: expr = this.ParseBinaryOperation(NodeType.Shr); break; case OpCode.Shr_Un: expr = this.ParseBinaryOperation(NodeType.Shr_Un); break; case OpCode.Neg: expr = this.ParseUnaryOperation(NodeType.Neg); break; case OpCode.Not: expr = this.ParseUnaryOperation(NodeType.Not); break; case OpCode.Conv_I1: expr = new UnaryExpression(PopOperand(), NodeType.Conv_I1, CoreSystemTypes.Int8); break; case OpCode.Conv_I2: expr = new UnaryExpression(PopOperand(), NodeType.Conv_I2, CoreSystemTypes.Int16); break; case OpCode.Conv_I4: expr = new UnaryExpression(PopOperand(), NodeType.Conv_I4, CoreSystemTypes.Int32); break; case OpCode.Conv_I8: expr = new UnaryExpression(PopOperand(), NodeType.Conv_I8, CoreSystemTypes.Int64); break; case OpCode.Conv_R4: expr = new UnaryExpression(PopOperand(), NodeType.Conv_R4, CoreSystemTypes.Single); break; case OpCode.Conv_R8: expr = new UnaryExpression(PopOperand(), NodeType.Conv_R8, CoreSystemTypes.Double); break; case OpCode.Conv_U4: expr = new UnaryExpression(PopOperand(), NodeType.Conv_U4, CoreSystemTypes.UInt32); break; case OpCode.Conv_U8: expr = new UnaryExpression(PopOperand(), NodeType.Conv_U8, CoreSystemTypes.UInt64); break; case OpCode.Callvirt: expr = this.ParseCall(NodeType.Callvirt, out isStatement); if (isStatement) goto done; break; case OpCode.Cpobj: statement = this.ParseCopyObject(); goto done; case OpCode.Ldobj: expr = new AddressDereference(PopOperand(), (TypeNode)this.GetMemberFromToken(), this.isVolatile, this.alignment); break; case OpCode.Ldstr: expr = new Literal(this.GetStringFromToken(), CoreSystemTypes.String); break; case OpCode.Newobj: expr = this.ParseConstruct(); break; case OpCode.Castclass: expr = ParseTypeCheck(PopOperand(), (TypeNode)this.GetMemberFromToken(), NodeType.Castclass); break; case OpCode.Isinst: expr = ParseTypeCheck(PopOperand(), (TypeNode)this.GetMemberFromToken(), NodeType.Isinst); break; case OpCode.Conv_R_Un: expr = new UnaryExpression(PopOperand(), NodeType.Conv_R_Un, CoreSystemTypes.Double); break; case OpCode.Unbox: expr = ParseTypeCheck(PopOperand(), (TypeNode)this.GetMemberFromToken(), NodeType.Unbox); break; case OpCode.Throw: statement = new Throw(PopOperand()); transferStatement = true; goto done; case OpCode.Ldfld: expr = new MemberBinding(PopOperand(), this.GetMemberFromToken(), this.isVolatile, this.alignment); break; case OpCode.Ldflda: expr = SetType(new UnaryExpression(new MemberBinding(PopOperand(), this.GetMemberFromToken(), this.isVolatile, this.alignment), NodeType.AddressOf)); break; case OpCode.Stfld: statement = this.ParseStoreField(); goto done; case OpCode.Ldsfld: expr = new MemberBinding(null, this.GetMemberFromToken(), this.isVolatile, this.alignment); break; case OpCode.Ldsflda: expr = SetType(new UnaryExpression(new MemberBinding(null, this.GetMemberFromToken(), this.isVolatile, this.alignment), NodeType.AddressOf)); break; case OpCode.Stsfld: statement = new AssignmentStatement(new MemberBinding(null, this.GetMemberFromToken(), this.isVolatile, this.alignment), PopOperand()); goto done; case OpCode.Stobj: statement = this.ParseStoreIndirect((TypeNode)this.GetMemberFromToken()); goto done; case OpCode.Conv_Ovf_I1_Un: expr = new UnaryExpression(PopOperand(), NodeType.Conv_Ovf_I1_Un, CoreSystemTypes.Int8); break; case OpCode.Conv_Ovf_I2_Un: expr = new UnaryExpression(PopOperand(), NodeType.Conv_Ovf_I2_Un, CoreSystemTypes.Int16); break; case OpCode.Conv_Ovf_I4_Un: expr = new UnaryExpression(PopOperand(), NodeType.Conv_Ovf_I4_Un, CoreSystemTypes.Int32); break; case OpCode.Conv_Ovf_I8_Un: expr = new UnaryExpression(PopOperand(), NodeType.Conv_Ovf_I8_Un, CoreSystemTypes.Int64); break; case OpCode.Conv_Ovf_U1_Un: expr = new UnaryExpression(PopOperand(), NodeType.Conv_Ovf_U1_Un, CoreSystemTypes.UInt8); break; case OpCode.Conv_Ovf_U2_Un: expr = new UnaryExpression(PopOperand(), NodeType.Conv_Ovf_U2_Un, CoreSystemTypes.UInt16); break; case OpCode.Conv_Ovf_U4_Un: expr = new UnaryExpression(PopOperand(), NodeType.Conv_Ovf_U4_Un, CoreSystemTypes.UInt32); break; case OpCode.Conv_Ovf_U8_Un: expr = new UnaryExpression(PopOperand(), NodeType.Conv_Ovf_U8_Un, CoreSystemTypes.UInt64); break; case OpCode.Conv_Ovf_I_Un: expr = new UnaryExpression(PopOperand(), NodeType.Conv_Ovf_I_Un, CoreSystemTypes.IntPtr); break; case OpCode.Conv_Ovf_U_Un: expr = new UnaryExpression(PopOperand(), NodeType.Conv_Ovf_U_Un, CoreSystemTypes.UIntPtr); break; case OpCode.Box: TypeNode t = (TypeNode)this.GetMemberFromToken(); TypeNode bt = t is EnumNode ? CoreSystemTypes.Enum : CoreSystemTypes.ValueType; expr = new BinaryExpression(PopOperand(), new Literal(t, CoreSystemTypes.Type), NodeType.Box, bt); break; case OpCode.Newarr: expr = this.ParseNewArray(); break; case OpCode.Ldlen: expr = new UnaryExpression(PopOperand(), NodeType.Ldlen, CoreSystemTypes.UIntPtr); break; case OpCode.Ldelema: expr = this.ParseArrayElementLoadAddress(); break; case OpCode.Ldelem_I1: case OpCode.Ldelem_U1: case OpCode.Ldelem_I2: case OpCode.Ldelem_U2: case OpCode.Ldelem_I4: case OpCode.Ldelem_U4: case OpCode.Ldelem_I8: case OpCode.Ldelem_I: case OpCode.Ldelem_R4: case OpCode.Ldelem_R8: case OpCode.Ldelem_Ref: expr = this.ParseArrayElementLoad(opCode, null); break; case OpCode.Stelem_I: case OpCode.Stelem_I1: case OpCode.Stelem_I2: case OpCode.Stelem_I4: case OpCode.Stelem_I8: case OpCode.Stelem_R4: case OpCode.Stelem_R8: case OpCode.Stelem_Ref: statement = this.ParseArrayElementAssignment(opCode); goto done; case OpCode.Ldelem: expr = this.ParseArrayElementLoad(opCode, null); break; case OpCode.Stelem: statement = this.ParseArrayElementAssignment(opCode); goto done; case OpCode.Unbox_Any: expr = ParseTypeCheck(PopOperand(), (TypeNode)this.GetMemberFromToken(), NodeType.UnboxAny); break; case OpCode.Conv_Ovf_I1: expr = new UnaryExpression(PopOperand(), NodeType.Conv_Ovf_I1, CoreSystemTypes.Int8); break; case OpCode.Conv_Ovf_U1: expr = new UnaryExpression(PopOperand(), NodeType.Conv_Ovf_U1, CoreSystemTypes.UInt8); break; case OpCode.Conv_Ovf_I2: expr = new UnaryExpression(PopOperand(), NodeType.Conv_Ovf_I2, CoreSystemTypes.Int16); break; case OpCode.Conv_Ovf_U2: expr = new UnaryExpression(PopOperand(), NodeType.Conv_Ovf_U2, CoreSystemTypes.UInt16); break; case OpCode.Conv_Ovf_I4: expr = new UnaryExpression(PopOperand(), NodeType.Conv_Ovf_I4, CoreSystemTypes.Int32); break; case OpCode.Conv_Ovf_U4: expr = new UnaryExpression(PopOperand(), NodeType.Conv_Ovf_U4, CoreSystemTypes.UInt32); break; case OpCode.Conv_Ovf_I8: expr = new UnaryExpression(PopOperand(), NodeType.Conv_Ovf_I8, CoreSystemTypes.Int64); break; case OpCode.Conv_Ovf_U8: expr = new UnaryExpression(PopOperand(), NodeType.Conv_Ovf_U8, CoreSystemTypes.UInt64); break; case OpCode.Refanyval: expr = new BinaryExpression(PopOperand(), new Literal(this.GetMemberFromToken(), CoreSystemTypes.Type), NodeType.Refanyval, CoreSystemTypes.IntPtr); break; case OpCode.Ckfinite: expr = this.ParseUnaryOperation(NodeType.Ckfinite); break; case OpCode.Mkrefany: expr = new BinaryExpression(PopOperand(), new Literal(this.GetMemberFromToken(), CoreSystemTypes.Type), NodeType.Mkrefany, CoreSystemTypes.DynamicallyTypedReference); break; case OpCode.Ldtoken: expr = ParseLoadRuntimeMetadataToken(); break; case OpCode.Conv_U2: expr = new UnaryExpression(PopOperand(), NodeType.Conv_U2, CoreSystemTypes.UInt16); break; case OpCode.Conv_U1: expr = new UnaryExpression(PopOperand(), NodeType.Conv_U1, CoreSystemTypes.UInt8); break; case OpCode.Conv_I: expr = new UnaryExpression(PopOperand(), NodeType.Conv_I, CoreSystemTypes.IntPtr); break; case OpCode.Conv_Ovf_I: expr = new UnaryExpression(PopOperand(), NodeType.Conv_Ovf_I, CoreSystemTypes.IntPtr); break; case OpCode.Conv_Ovf_U: expr = new UnaryExpression(PopOperand(), NodeType.Conv_Ovf_U, CoreSystemTypes.UIntPtr); break; case OpCode.Add_Ovf: expr = this.ParseBinaryOperation(NodeType.Add_Ovf); break; case OpCode.Add_Ovf_Un: expr = this.ParseBinaryOperation(NodeType.Add_Ovf_Un); break; case OpCode.Mul_Ovf: expr = this.ParseBinaryOperation(NodeType.Mul_Ovf); break; case OpCode.Mul_Ovf_Un: expr = this.ParseBinaryOperation(NodeType.Mul_Ovf_Un); break; case OpCode.Sub_Ovf: expr = this.ParseBinaryOperation(NodeType.Sub_Ovf); break; case OpCode.Sub_Ovf_Un: expr = this.ParseBinaryOperation(NodeType.Sub_Ovf_Un); break; case OpCode.Endfinally: statement = new EndFinally(); transferStatement = true; goto done; case OpCode.Leave: statement = this.ParseBranch(NodeType.Nop, 0, false, false, true); transferStatement = true; goto done; case OpCode.Leave_S: statement = this.ParseBranch(NodeType.Nop, 0, true, false, true); transferStatement = true; goto done; case OpCode.Stind_I: statement = this.ParseStoreIndirect(CoreSystemTypes.IntPtr); goto done; case OpCode.Conv_U: expr = new UnaryExpression(PopOperand(), NodeType.Conv_U, CoreSystemTypes.UIntPtr); break; case OpCode.Arglist: expr = new Expression(NodeType.Arglist, CoreSystemTypes.ArgIterator); break; case OpCode.Ceq: expr = this.ParseBinaryComparison(NodeType.Ceq); break; case OpCode.Cgt: expr = this.ParseBinaryComparison(NodeType.Cgt); break; case OpCode.Cgt_Un: expr = this.ParseBinaryComparison(NodeType.Cgt_Un); break; case OpCode.Clt: expr = this.ParseBinaryComparison(NodeType.Clt); break; case OpCode.Clt_Un: expr = this.ParseBinaryComparison(NodeType.Clt_Un); break; case OpCode.Ldftn: expr = new UnaryExpression(new MemberBinding(null, this.GetMemberFromToken()), NodeType.Ldftn, CoreSystemTypes.IntPtr); break; case OpCode.Ldvirtftn: expr = new BinaryExpression(PopOperand(), new MemberBinding(null, this.GetMemberFromToken()), NodeType.Ldvirtftn, CoreSystemTypes.IntPtr); break; case OpCode.Ldarg: expr = this.Parameters((ushort)this.GetInt16()); break; case OpCode.Ldarga: expr = SetType(new UnaryExpression(this.Parameters((ushort)this.GetInt16()), NodeType.AddressOf)); break; case OpCode.Starg: statement = new AssignmentStatement(this.Parameters((ushort)this.GetInt16()), PopOperand()); goto done; case OpCode.Ldloc: expr = this.locals[(ushort)this.GetInt16()]; break; case OpCode.Ldloca: expr = SetType(new UnaryExpression(this.locals[(ushort)this.GetInt16()], NodeType.AddressOf)); break; case OpCode.Stloc: statement = new AssignmentStatement(this.locals[(ushort)this.GetInt16()], PopOperand()); goto done; case OpCode.Localloc: expr = new UnaryExpression(PopOperand(), NodeType.Localloc, CoreSystemTypes.Void); break; case OpCode.Endfilter: statement = new EndFilter(PopOperand()); transferStatement = true; goto done; case OpCode.Unaligned_: this.alignment = this.GetByte(); continue; case OpCode.Volatile_: this.isVolatile = true; continue; case OpCode.Tail_: this.isTailCall = true; continue; case OpCode.Initobj: statement = this.ParseInitObject(); goto done; case OpCode.Constrained_: this.constraint = this.GetMemberFromToken() as TypeNode; continue; case OpCode.Cpblk: expr = this.ParseTernaryOperation(NodeType.Cpblk); goto done; case OpCode.Initblk: expr = this.ParseTernaryOperation(NodeType.Initblk); goto done; case OpCode.Rethrow: statement = new Throw(null); statement.NodeType = NodeType.Rethrow; transferStatement = true; goto done; case OpCode.Sizeof: expr = new UnaryExpression(new Literal(this.GetMemberFromToken(), CoreSystemTypes.Type), NodeType.Sizeof, CoreSystemTypes.Int32); break; case OpCode.Refanytype: expr = new UnaryExpression(PopOperand(), NodeType.Refanytype, CoreSystemTypes.RuntimeTypeHandle); break; case OpCode.Readonly_: this.isReadOnly = true; continue; default: throw new InvalidMetadataException(ExceptionStrings.UnknownOpCode); } if (this.blockMap[this.counter+1] != null){ transferStatement = true; //Falls through to the next basic block, so implicitly a "transfer" statement goto done; } //^ assume expr != null; #if FxCop expr.sourceContext = sourceContext; #endif #if FxCop || ILOFFSETS expr.ILOffset = this.ilOffset; #endif this.operandStack.Push(expr); this.isReadOnly = false; this.isVolatile = false; this.isTailCall = false; this.alignment = -1; } done: for (int i = 0; i <= this.operandStack.top; i++){ Expression e = this.operandStack.elements[i]; //^ assume e != null; Statement s = new ExpressionStatement(e); #if FxCop s.SourceContext = this.sourceContext; #endif #if FxCop || ILOFFSETS s.ILOffset = this.ilOffset; #endif statementList.Add(s); } this.operandStack.top = -1; if (statement == null) { statement = new ExpressionStatement(expr); #if FxCop expr.sourceContext = this.sourceContext; #endif #if FxCop || ILOFFSETS expr.ILOffset = this.ilOffset; #endif } statement.SourceContext = sourceContext; #if FxCop || ILOFFSETS statement.ILOffset = this.ilOffset; #endif #if ILOFFSETS this.lastSourceContext = sourceContext; #endif statementList.Add(statement); if (transferStatement) return true; return this.blockMap[this.counter+1] != null; }
protected override Expression VisitUnary(UnaryExpression node) { return(Visit(node.Operand)); }
public void VisitUnaryExpression(UnaryExpression unary) { throw new NotImplementedException(); }
// UnaryExpression public virtual bool Walk(UnaryExpression node) { return true; }
// UnaryExpression public override bool Walk(UnaryExpression node) { return false; }
public gsScalarExpressionParserUnary(ScalarExpression expression, string columnAlias) : base(expression, columnAlias) { _ScalarExpression = expression as UnaryExpression; }
internal string VisitQuote(UnaryExpression expression) { return(Visit(expression.Operand)); }
public override bool Enter(UnaryExpression node) { Print("UnaryExpression Prefix: '{0}', Postfix: '{1}'", node.Prefix, node.Postfix); level++; return true; }
protected override Expression VisitUnary(UnaryExpression node) { _unarySpecified = true; return(base.VisitUnary(node)); // returning base because we want to continue further processing - ie subsequent call to VisitMethodCall }
// UnaryExpression protected internal virtual bool Walk(UnaryExpression node) { return true; }
protected virtual T VisitUnary_Negate(UnaryExpression exp) { throw new NotImplementedException(exp.ToString()); }
private static UnaryExpression/*!*/ SetType(UnaryExpression/*!*/ uex) { if (uex == null || uex.Operand == null) return uex; TypeNode elemType = uex.Operand.Type; if (elemType == null) return uex; uex.Type = elemType.GetReferenceType(); return uex; }
public void Visit(UnaryExpression node) { ReportError(node); }
public virtual Expression VisitUnaryExpression(UnaryExpression unaryExpression, UnaryExpression changes, UnaryExpression deletions, UnaryExpression insertions){ this.UpdateSourceContext(unaryExpression, changes); if (unaryExpression == null) return changes; if (changes != null){ if (deletions == null || insertions == null) Debug.Assert(false); else{ } }else if (deletions != null) return null; return unaryExpression; }
private static UnaryExpression Clone(UnaryExpression expression) { return(new UnaryExpression(expression.Operator, Clone(expression.Expression))); }
private void AddressOf(UnaryExpression node, Type type) { Debug.Assert(node.NodeType == ExpressionType.Unbox); Debug.Assert(type.GetTypeInfo().IsValueType); // Unbox leaves a pointer to the boxed value on the stack EmitExpression(node.Operand); _ilg.Emit(OpCodes.Unbox, type); }
private static bool IsConvertCharToInt(UnaryExpression expression) { return(expression.Type == typeof(int) && expression.Operand.Type == typeof(char)); }
public virtual void PostWalk(UnaryExpression node) { }
protected override Expression VisitUnary(UnaryExpression node) => node;
public override void PostWalk(UnaryExpression node) { }
public override void VisitUnaryExpression(UnaryExpression unary) { unary.Expression.Accept(this); EnsureTypeVariable(unary); }
/// <summary> /// Serializes an UnaryExpression to a string /// </summary> /// <param name="u">Expression to serialize</param> /// <returns>UnaryExpression</returns> internal override Expression VisitUnary(UnaryExpression u) { switch (u.NodeType) { case ExpressionType.Not: this.builder.Append(UriHelper.NOT); this.builder.Append(UriHelper.SPACE); this.VisitOperand(u.Operand); break; case ExpressionType.Negate: case ExpressionType.NegateChecked: this.builder.Append(UriHelper.SPACE); this.builder.Append(UriHelper.NEGATE); this.VisitOperand(u.Operand); break; case ExpressionType.Convert: case ExpressionType.ConvertChecked: if (u.Type != typeof(object)) { if (IsEnumTypeExpression(u)) { this.Visit(u.Operand); } else { this.builder.Append(UriHelper.CAST); this.builder.Append(UriHelper.LEFTPAREN); if (!this.IsImplicitInputReference(u.Operand)) { this.Visit(u.Operand); this.builder.Append(UriHelper.COMMA); } this.builder.Append(UriHelper.QUOTE); this.builder.Append(UriHelper.GetTypeNameForUri(u.Type, this.context)); this.builder.Append(UriHelper.QUOTE); this.builder.Append(UriHelper.RIGHTPAREN); } } else { if (!this.IsImplicitInputReference(u.Operand)) { this.Visit(u.Operand); } } break; case ExpressionType.TypeAs: if (u.Operand.NodeType == ExpressionType.TypeAs) { throw new NotSupportedException(Strings.ALinq_CannotUseTypeFiltersMultipleTimes); } this.Visit(u.Operand); if (!this.IsImplicitInputReference(u.Operand)) { // InputReferenceExpressions aren't emitted, so no leading slash is required this.builder.Append(UriHelper.FORWARDSLASH); } UriHelper.AppendTypeSegment(this.builder, u.Type, this.context, this.inPath, ref this.uriVersion); break; case ExpressionType.UnaryPlus: // no-op always ignore. break; default: this.cantTranslateExpression = true; break; } return(u); }