protected override IExpression ConvertUnary(IUnaryExpression iue) { iue = (IUnaryExpression)base.ConvertUnary(iue); if (iue.Operator == UnaryOperator.BooleanNot) { if (iue.Expression is ILiteralExpression expr) { if (expr.Value is bool b) { return(Builder.LiteralExpr(!b)); } } else if (iue.Expression is IUnaryExpression iue2) { if (iue2.Operator == UnaryOperator.BooleanNot) // double negation { return(iue2.Expression); } } else if (iue.Expression is IBinaryExpression ibe) { if (Recognizer.TryNegateOperator(ibe.Operator, out BinaryOperator negatedOp)) { // replace !(i==0) with (i != 0) return(Builder.BinaryExpr(ibe.Left, negatedOp, ibe.Right)); } } } return(iue); }
public override IExpression Visit(IUnaryExpression expr, int context) { return(new UnaryExpression { Operator = expr.Operator, Operand = Anonymize(expr.Operand) }); }
/// <summary> /// Creates a type assertion like 'x : YourType'. /// </summary> public static IExpression TypeAssertion(ITypeNode type, IUnaryExpression expression) { var result = new TypeAssertion(); result.Type = type; result.Expression = expression; return(result); }
private static void WriteUnary(LanguageWriter w, IUnaryExpression exp) { bool post = false; string opName; switch (exp.Operator) { case UnaryOperator.Negate: opName = "-"; break; case UnaryOperator.BooleanNot: opName = "!"; break; case UnaryOperator.BitwiseNot: opName = "~"; break; case UnaryOperator.PreIncrement: opName = "++"; break; case UnaryOperator.PreDecrement: opName = "--"; break; case UnaryOperator.PostIncrement: opName = "++"; post = true; break; case UnaryOperator.PostDecrement: opName = "--"; post = true; break; default: throw new System.NotSupportedException( "指定した種類の単項演算には対応していません: " + exp.Operator.ToString() ); } // 書込 if (post) { WriteExpression(w, exp.Expression, PREC_POST > GetExpressionPrecedence(exp.Expression)); w.Write(opName); } else { w.Write(opName); WriteExpression(w, exp.Expression, PREC_PRE > GetExpressionPrecedence(exp.Expression)); } }
protected override IExpression ConvertUnary(IUnaryExpression iue) { var copy = (IUnaryExpression)base.ConvertUnary(iue); if (NeedsIntermediate(copy.Expression)) { // TODO this breaks things //copy.Expression = MakeIntermediateVariable(copy.Expression); } return(copy); }
public void Visit(IUnaryExpression expr, SSTPrintingContext c) { if (expr.Operator == UnaryOperator.PostIncrement || expr.Operator == UnaryOperator.PostDecrement) { expr.Operand.Accept(this, c); c.Text(expr.Operator.ToPrettyString()); } else { c.Text(expr.Operator.ToPrettyString()); expr.Operand.Accept(this, c); } }
public override bool Equals(object obj) { if (this == obj) { return(true); } IUnaryExpression expr = obj as IUnaryExpression; if (expr == null) { return(false); } return(Expression.Equals(expr.Expression) && Operator.Equals(expr.Operator)); }
private static IExpression HandleOp(IUnaryExpression op) { var e1 = op.Value; var e1s = e1.Simplify(); if (e1s != e1) { switch (op) { case Neg _: return(new Neg(e1s).Simplify()); } } return(op); }
public static IExpression Simplify(IUnaryExpression e) { if (e.Operator == UnaryOperator.BooleanNot) { var be = e.Expression as IBinaryExpression; if (be != null) { var be2 = InvertBoolOrRelation(be); if (!ReferenceEquals(be2, be)) { return(be2); } } var e2 = Simplify(e.Expression); if (!ReferenceEquals(e2, e.Expression)) { return(new UnaryExpression(e2, UnaryOperator.BooleanNot)); } } return(e); }
public ConditionBinding(IExpression condition) { lhs = condition; rhs = Builder.LiteralExpr(true); if (condition is IBinaryExpression) { IBinaryExpression ibe = (IBinaryExpression)condition; if ((ibe.Operator == BinaryOperator.IdentityEquality) || (ibe.Operator == BinaryOperator.ValueEquality)) { lhs = ibe.Left; rhs = ibe.Right; } } else if (condition is IUnaryExpression) { IUnaryExpression iue = (IUnaryExpression)condition; if (iue.Operator == UnaryOperator.BooleanNot) { lhs = iue.Expression; rhs = Builder.LiteralExpr(false); } } }
public override void VisitUnaryExpression(IUnaryExpression value) { switch (value.Operator) { case UnaryOperator.Negate: case UnaryOperator.BooleanNot: _formatter.Write("!"); VisitExpression(value.Expression); break; case UnaryOperator.BitwiseNot: _formatter.Write("-bnot "); VisitExpression(value.Expression); break; case UnaryOperator.PreIncrement: _formatter.Write("++"); VisitExpression(value.Expression); break; case UnaryOperator.PreDecrement: _formatter.Write("--"); VisitExpression(value.Expression); break; case UnaryOperator.PostIncrement: VisitExpression(value.Expression); _formatter.Write("++"); break; case UnaryOperator.PostDecrement: VisitExpression(value.Expression); _formatter.Write("--"); break; } }
public override bool IsAvailable(JetBrains.Util.IUserDataHolder cache) { var awaitExpression = provider.GetSelectedElement<IAwaitExpression>(true, false); if (awaitExpression != null && awaitExpression.AwaitKeyword == provider.SelectedElement) { awaitedExpression = awaitExpression.Task; var typeElement = (awaitedExpression?.Type() as IDeclaredType)?.GetTypeElement(); if (typeElement != null) { var hasConfigureAwaitMethod = typeElement.Methods.Any( method => { Debug.Assert(method != null); if (method.ShortName == configureAwaitMethodName && method.Parameters.Count == 1) { Debug.Assert(method.Parameters[0] != null); return method.Parameters[0].Type.IsBool(); } return false; }); if (hasConfigureAwaitMethod) { return true; } } } awaitedExpression = null; return false; }
public virtual void VisitUnaryExpression(IUnaryExpression e) { VisitExpression(e.Expression); }
public int Visit(IUnaryExpression expr, int context) { throw new NotImplementedException(); }
protected abstract IExpression VisitUnary(IUnaryExpression unaryExpression);
public virtual void VisitUnaryExpression(IUnaryExpression value) { VisitExpression(value.Expression); }
public object Evaluate(IExpression expr) { if (expr is IObjectCreateExpression) { return(Evaluate((IObjectCreateExpression)expr)); } else if (expr is ILiteralExpression) { return(((ILiteralExpression)expr).Value); } else if (expr is ICastExpression) { return(Evaluate(((ICastExpression)expr).Expression)); } else if (expr is ICheckedExpression) { return(Evaluate(((ICheckedExpression)expr).Expression)); } else if (expr is IBinaryExpression) { IBinaryExpression ibe = (IBinaryExpression)expr; object left = Evaluate(ibe.Left); object right = Evaluate(ibe.Right); Type type = left.GetType(); return(Microsoft.ML.Probabilistic.Compiler.Reflection.Invoker.InvokeStatic(type, binaryOperatorNames[(int)ibe.Operator], left, right)); } else if (expr is IUnaryExpression) { IUnaryExpression iue = (IUnaryExpression)expr; object target = Evaluate(iue.Expression); Type type = target.GetType(); return(Microsoft.ML.Probabilistic.Compiler.Reflection.Invoker.InvokeStatic(type, unaryOperatorNames[(int)iue.Operator], target)); } else if (expr is IMethodInvokeExpression) { IMethodInvokeExpression imie = (IMethodInvokeExpression)expr; object[] args = EvaluateAll(imie.Arguments); return(Invoke(imie.Method, args)); } else if (expr is IArrayCreateExpression) { IArrayCreateExpression iace = (IArrayCreateExpression)expr; Type t = Builder.ToType(iace.Type); int[] lens = new int[iace.Dimensions.Count]; for (int i = 0; i < lens.Length; i++) { lens[i] = (int)Evaluate(iace.Dimensions[i]); } // TODO: evaluate initializer if (iace.Initializer != null) { throw new NotImplementedException("IArrayCreateExpression has an initializer block"); } return(Array.CreateInstance(t, lens)); } else if (expr is IFieldReferenceExpression) { IFieldReferenceExpression ifre = (IFieldReferenceExpression)expr; if (ifre.Target is ITypeReferenceExpression) { ITypeReferenceExpression itre = (ITypeReferenceExpression)ifre.Target; Type type = Builder.ToType(itre.Type); FieldInfo info = type.GetField(ifre.Field.Name); return(info.GetValue(null)); } else { object target = Evaluate(ifre.Target); FieldInfo info = target.GetType().GetField(ifre.Field.Name); return(info.GetValue(target)); } } else { throw new InferCompilerException("Could not evaluate: " + expr); } }
protected override Action<ITextControl> ExecutePsiTransaction(ISolution solution, IProgressIndicator progress) { Debug.Assert(awaitedExpression != null); try { using (WriteLockCookie.Create()) { var factory = CSharpElementFactory.GetInstance(provider.PsiModule); ModificationUtil.ReplaceChild( awaitedExpression, factory.CreateExpression($"$0.{configureAwaitMethodName}(false)", awaitedExpression)); } return _ => { }; } finally { awaitedExpression = null; } }
protected override IExpression VisitUnary(IUnaryExpression unaryExpression) { if ((object)unaryExpression == null) throw new ArgumentNullException("unaryExpression"); switch (unaryExpression.UnaryOperator) { case UnaryOperator.Not: this.Strings.Append(" NOT "); this.Visit(unaryExpression.TheExpression); break; case UnaryOperator.IsNull: this.Visit(unaryExpression.TheExpression); this.Strings.Append(" IS NULL "); break; case UnaryOperator.IsNotNull: this.Visit(unaryExpression.TheExpression); this.Strings.Append(" IS NOT NULL "); break; case UnaryOperator.Neg: this.Strings.Append(" - "); this.Visit(unaryExpression.TheExpression); break; case UnaryOperator.Pos: this.Strings.Append(" + "); this.Visit(unaryExpression.TheExpression); break; case UnaryOperator.Incr: this.Strings.Append(" ("); this.Visit(unaryExpression.TheExpression); this.Strings.Append(" + 1) "); break; case UnaryOperator.Decr: this.Strings.Append(" ("); this.Visit(unaryExpression.TheExpression); this.Strings.Append(" - 1) "); break; case UnaryOperator.BComp: this.Strings.Append(" ~ "); this.Visit(unaryExpression.TheExpression); break; default: throw new NotSupportedException(string.Format("The unary operator '{0}' is not supported.", unaryExpression.UnaryOperator)); } return unaryExpression; }
public virtual void VisitUnaryExpression(IUnaryExpression value) { this.VisitExpression(value.Expression); }
private void WriteUnaryExpression(IUnaryExpression expression, IFormatter formatter) { switch (expression.Operator) { case UnaryOperator.BitwiseNot: formatter.WriteKeyword("!"); this.WriteExpression(expression.Expression, formatter); break; case UnaryOperator.BooleanNot: formatter.WriteKeyword("!"); this.WriteExpression(expression.Expression, formatter); break; case UnaryOperator.Negate: formatter.Write("-"); this.WriteExpression(expression.Expression, formatter); break; case UnaryOperator.PreIncrement: formatter.Write("++"); this.WriteExpression(expression.Expression, formatter); break; case UnaryOperator.PreDecrement: formatter.Write("--"); this.WriteExpression(expression.Expression, formatter); break; case UnaryOperator.PostIncrement: this.WriteExpression(expression.Expression, formatter); formatter.Write("++"); break; case UnaryOperator.PostDecrement: this.WriteExpression(expression.Expression, formatter); formatter.Write("--"); break; default: throw new NotSupportedException(expression.Operator.ToString()); } }
protected override IExpression VisitUnary(IUnaryExpression unaryExpression) { DescriptionAttribute descriptionAttribute; FieldInfo fieldInfo; if ((object)unaryExpression == null) throw new ArgumentNullException("unaryExpression"); fieldInfo = typeof(UnaryOperator).GetField(unaryExpression.UnaryOperator.ToString()); if ((object)fieldInfo == null) throw new NotSupportedException(string.Format("The unary operator '{0}' is not supported.", unaryExpression.UnaryOperator)); descriptionAttribute = Reflexion.GetOneAttribute<DescriptionAttribute>(fieldInfo); if ((object)descriptionAttribute == null) throw new NotSupportedException(string.Format("The unary operator '{0}' is not described.", unaryExpression.UnaryOperator)); if (unaryExpression.UnaryOperator == UnaryOperator.Not) this.Visit(unaryExpression.TheExpression); this.Strings.Append(descriptionAttribute.Description); if (unaryExpression.UnaryOperator != UnaryOperator.Not) this.Visit(unaryExpression.TheExpression); return unaryExpression; }
public virtual void Visit(IUnaryExpression expr, TContext context) { expr.Operand.Accept(this, context); }
//=========================================================== // Expression 分岐 //=========================================================== public virtual void WriteExpression(IExpression expression) { if (expression == null) { return; } mwg.Reflector.CppCli.ExpressionWriter.WriteExpression(this, expression, false); #if FALSE #pragma warning disable 612 IMemberInitializerExpression expression3 = expression as IMemberInitializerExpression; if (expression3 != null) { this.WriteMemberInitializerExpression(expression3); return; } IAddressOutExpression expression27 = expression as IAddressOutExpression; if (expression27 != null) { this.WriteAddressOutExpression(expression27); return; } IAddressReferenceExpression expression26 = expression as IAddressReferenceExpression; if (expression26 != null) { this.WriteAddressReferenceExpression(expression26); return; } IDelegateCreateExpression iDelegateCreateExpression = expression as IDelegateCreateExpression; if (iDelegateCreateExpression != null) { this.WriteDelegateCreateExpression(iDelegateCreateExpression); return; } IMethodInvokeExpression iMethodInvokeExpression = expression as IMethodInvokeExpression; if (iMethodInvokeExpression != null) { this.WriteMethodInvokeExpression(iMethodInvokeExpression); return; } IVariableDeclarationExpression expression15 = expression as IVariableDeclarationExpression; if (expression15 != null) { this.WriteVariableDeclaration(expression15.Variable); return; } ITypeOfExpression iTypeOfExpression = expression as ITypeOfExpression; if (iTypeOfExpression != null) { this.WriteTypeOfExpression(iTypeOfExpression); return; } ISnippetExpression iSnippetExpression = expression as ISnippetExpression; if (iSnippetExpression != null) { this.WriteSnippetExpression(iSnippetExpression); return; } IUnaryExpression iUnaryExpression = expression as IUnaryExpression; if (iUnaryExpression != null) { this.WriteUnaryExpression(iUnaryExpression); return; } IObjectCreateExpression iObjectCreateExpression = expression as IObjectCreateExpression; if (iObjectCreateExpression != null) { this.WriteObjectCreateExpression(iObjectCreateExpression); return; } IVariableReferenceExpression iVariableReferenceExpression = expression as IVariableReferenceExpression; if (iVariableReferenceExpression != null) { this.WriteVariableReferenceExpression(iVariableReferenceExpression); return; } IThisReferenceExpression expression12 = expression as IThisReferenceExpression; if (expression12 != null) { this.WriteThisReferenceExpression(expression12); return; } ITryCastExpression iTryCastExpression = expression as ITryCastExpression; if (iTryCastExpression != null) { this.WriteTryCastExpression(iTryCastExpression); return; } IConditionExpression expression9 = expression as IConditionExpression; if (expression9 != null) { this.WriteConditionExpression(expression9); return; } IFieldReferenceExpression iFieldReferenceExpression = expression as IFieldReferenceExpression; if (iFieldReferenceExpression != null) { this.WriteFieldReferenceExpression(iFieldReferenceExpression); return; } IPropertyIndexerExpression iPropertyIndexerExpression = expression as IPropertyIndexerExpression; if (iPropertyIndexerExpression != null) { this.WritePropertyIndexerExpression(iPropertyIndexerExpression); return; } ITypeReferenceExpression iTypeReferenceExpression = expression as ITypeReferenceExpression; if (iTypeReferenceExpression != null) { this.WriteTypeReferenceExpression(iTypeReferenceExpression); return; } IMethodReferenceExpression iMethodReferenceExpression = expression as IMethodReferenceExpression; if (iMethodReferenceExpression != null) { this.WriteMethodReferenceExpression(iMethodReferenceExpression); return; } IPropertyReferenceExpression iPropertyReferenceExpression = expression as IPropertyReferenceExpression; if (iPropertyReferenceExpression != null) { this.WritePropertyReferenceExpression(iPropertyReferenceExpression); return; } ICastExpression expression5 = expression as ICastExpression; if (expression5 != null) { this.WriteCastExpression(expression5); return; } ICanCastExpression iCanCastExpression = expression as ICanCastExpression; if (iCanCastExpression != null) { this.WriteCanCastExpression(iCanCastExpression); return; } ICastExpression iCastExpression = expression as ICastExpression; if (iCastExpression != null) { this.WriteCastExpression(iCastExpression); return; } ILiteralExpression literalExpression = expression as ILiteralExpression; if (literalExpression != null) { this.WriteLiteralExpression(literalExpression); return; } IBinaryExpression iBinaryExpression = expression as IBinaryExpression; if (iBinaryExpression != null) { mwg.Reflector.CppCli.ExpressionWriter.WriteExpression(this, expression, true); //this.WriteBinaryExpression(iBinaryExpression); return; } IArrayIndexerExpression expression30 = expression as IArrayIndexerExpression; if (expression30 != null) { this.WriteArrayIndexerExpression(expression30); return; } IAddressDereferenceExpression expression29 = expression as IAddressDereferenceExpression; if (expression29 != null) { this.WriteAddressDereferenceExpression(expression29); return; } IAddressOfExpression expression28 = expression as IAddressOfExpression; if (expression28 != null) { this.WriteAddressOfExpression(expression28); return; } IArgumentListExpression expression25 = expression as IArgumentListExpression; if (expression25 != null) { this.WriteArgumentListExpression(expression25); return; } IBaseReferenceExpression iBaseReferenceExpression = expression as IBaseReferenceExpression; if (iBaseReferenceExpression != null) { this.WriteBaseReferenceExpression(iBaseReferenceExpression); return; } IArgumentReferenceExpression expression13 = expression as IArgumentReferenceExpression; if (expression13 != null) { this.WriteArgumentReferenceExpression(expression13); return; } IArrayCreateExpression expression10 = expression as IArrayCreateExpression; if (expression10 != null) { this.WriteArrayCreateExpression(expression10); return; } IAssignExpression iAssignExpression = expression as IAssignExpression; if (iAssignExpression != null) { this.WriteAssignExpression(iAssignExpression); return; } IBlockExpression expression2 = expression as IBlockExpression; if (expression2 != null) { this.WriteBlockExpression(expression2); return; } #pragma warning restore 612 this.Write(expression.ToString()); #endif }
/// <summary> /// Only converts the contained statements in a for loop, leaving the initializer, /// condition and increment statements unchanged. /// </summary> /// <remarks>This method includes a number of checks to ensure the loop is valid e.g. that the initializer, condition and increment /// are all of the appropriate form.</remarks> protected override IStatement ConvertFor(IForStatement ifs) { IForStatement fs = Builder.ForStmt(); context.SetPrimaryOutput(fs); // Check condition is valid fs.Condition = ifs.Condition; if ((!(fs.Condition is IBinaryExpression)) || (((IBinaryExpression)fs.Condition).Operator != BinaryOperator.LessThan)) { Error("For statement condition must be of the form 'indexVar<loopSize', was " + fs.Condition); } // Check increment is valid fs.Increment = ifs.Increment; IExpressionStatement ies = fs.Increment as IExpressionStatement; bool validIncrement = false; if (ies != null) { if (ies.Expression is IAssignExpression) { IAssignExpression iae = (IAssignExpression)ies.Expression; IBinaryExpression ibe = RemoveCast(iae.Expression) as IBinaryExpression; validIncrement = (ibe != null) && (ibe.Operator == BinaryOperator.Add); } else if (ies.Expression is IUnaryExpression) { IUnaryExpression iue = (IUnaryExpression)ies.Expression; validIncrement = (iue.Operator == UnaryOperator.PostIncrement); } } if (!validIncrement) { Error("For statement increment must be of the form 'varname++' or 'varname=varname+1', was " + fs.Increment + "."); } // Check initializer is valid fs.Initializer = ifs.Initializer; ies = fs.Initializer as IExpressionStatement; if (ies == null) { Error("For statement initializer must be an expression statement, was " + fs.Initializer.GetType()); } else { if (!(ies.Expression is IAssignExpression)) { Error("For statement initializer must be an assignment, was " + fs.Initializer.GetType().Name); } else { IAssignExpression iae2 = (IAssignExpression)ies.Expression; if (!(iae2.Target is IVariableDeclarationExpression)) { Error("For statement initializer must be a variable declaration, was " + iae2.Target.GetType().Name); } if (!Recognizer.IsLiteral(iae2.Expression, 0)) { Error("Loop index must start at 0, was " + iae2.Expression); } } } fs.Body = ConvertBlock(ifs.Body); return(fs); }
public virtual IExpression TransformUnaryExpression(IUnaryExpression value) { value.Expression = this.TransformExpression(value.Expression); return value; }