public virtual object VisitAssignmentExpression(AssignmentExpression assignmentExpression, object data) { Debug.Assert((assignmentExpression != null)); Debug.Assert((assignmentExpression.Left != null)); Debug.Assert((assignmentExpression.Right != null)); assignmentExpression.Left.AcceptVisitor(this, data); return assignmentExpression.Right.AcceptVisitor(this, data); }
public override void VisitAssignmentExpression(AssignmentExpression expression) { base.VisitAssignmentExpression (expression); Identifier identifier = expression.FindIdentifier(); if (identifier == null) return; switch (expression.Operator) { case AssignmentOperatorType.BitwiseOr: case AssignmentOperatorType.BitwiseAnd: case AssignmentOperatorType.ExclusiveOr: case AssignmentOperatorType.Add: case AssignmentOperatorType.Subtract: case AssignmentOperatorType.Divide: case AssignmentOperatorType.Modulus: case AssignmentOperatorType.Multiply: case AssignmentOperatorType.ShiftLeft: case AssignmentOperatorType.ShiftRight: case AssignmentOperatorType.Assign: this.lineMap[this.id++] = expression.StartLocation.Line; break; } }
public override void VisitAssignmentExpression(AssignmentExpression expression) { base.VisitAssignmentExpression (expression); Identifier identifier = expression.FindIdentifier(); if (identifier == null) return; switch (expression.Operator) { case AssignmentOperatorType.BitwiseOr: case AssignmentOperatorType.BitwiseAnd: case AssignmentOperatorType.ExclusiveOr: case AssignmentOperatorType.Add: case AssignmentOperatorType.Subtract: case AssignmentOperatorType.Divide: case AssignmentOperatorType.Modulus: case AssignmentOperatorType.Multiply: case AssignmentOperatorType.ShiftLeft: case AssignmentOperatorType.ShiftRight: { BinaryOperatorType op = GetComplexAssignOperator (expression.Operator); Expression right = new BinaryOperatorExpression (new IdentifierExpression (identifier.Name), op, expression.Right.Clone()); expression.Operator = AssignmentOperatorType.Assign; expression.Right = GetAssignmentExpression (identifier, right); break; } case AssignmentOperatorType.Assign: expression.Right = GetAssignmentExpression (identifier, expression.Right); break; } }
public override IEnumerable<CodeAction> GetActions(RefactoringContext context) { if (context.IsSomethingSelected) { yield break; } AstType type; var varInitializer = GetVariableDeclarationStatement(context, out type); if (varInitializer == null) yield break; var statement = varInitializer.GetParent<Statement>(); var declaration = varInitializer.GetParent<VariableDeclarationStatement>(); if (declaration == null || (declaration.Modifiers & Modifiers.Const) != 0) yield break; var selectedNode = varInitializer.GetNodeAt(context.Location) ?? varInitializer; yield return new CodeAction(context.TranslateString("Split local variable declaration and assignment"), script => { var assign = new AssignmentExpression (new IdentifierExpression (varInitializer.Name), AssignmentOperatorType.Assign, varInitializer.Initializer.Clone()); if (declaration != null && declaration.Type.IsVar()) script.Replace(declaration.Type, type); if (declaration.Parent is ForStatement) { script.InsertBefore(statement, new VariableDeclarationStatement (type, varInitializer.Name)); script.Replace(declaration, assign); } else { script.Replace(varInitializer, new IdentifierExpression (varInitializer.Name)); script.InsertAfter(statement, new ExpressionStatement (assign)); } }, selectedNode); }
public override void Visit(AssignmentExpression expression) { outStream.Write(printFuncName + "("); expression.Left.Accept(this); switch (expression.AssignmentOperator) { case AssignmentOperator.Add: outStream.Write(" += "); break; case AssignmentOperator.And: outStream.Write(" &= "); break; case AssignmentOperator.Assign: outStream.Write(" = "); break; case AssignmentOperator.Divide: outStream.Write(" /= "); break; case AssignmentOperator.Modulo: outStream.Write(" %= "); break; case AssignmentOperator.Multiply: outStream.Write(" *= "); break; case AssignmentOperator.Or: outStream.Write(" |= "); break; case AssignmentOperator.ShiftLeft: outStream.Write(" <<= "); break; case AssignmentOperator.ShiftRight: outStream.Write(" >>= "); break; case AssignmentOperator.Substract: outStream.Write(" -= "); break; case AssignmentOperator.UnsignedRightShift: outStream.Write(" >>>= "); break; case AssignmentOperator.XOr: outStream.Write(" ^= "); break; } expression.Right.Accept(this); outStream.Write(", \"{0}\")", TempName); //int currentTempCounter = tempCounter++; //outStream.Write("{0}{1} = ", tempVarName, currentTempCounter); //expression.Right.Accept(this); //outStream.WriteLine(";"); //outStream.WriteLine("{0}{1};\nprint({0}{1});", tempVarName, currentTempCounter, tempVarName, currentTempCounter); }
public override void VisitAssignmentExpression (AssignmentExpression assignmentExpression) { base.VisitAssignmentExpression (assignmentExpression); if (assignmentExpression.Operator != AssignmentOperatorType.Assign) return; if (!(assignmentExpression.Left is IdentifierExpression) && !(assignmentExpression.Left is MemberReferenceExpression)) return; var resolveResult = ctx.Resolve (assignmentExpression.Left); var memberResolveResult = resolveResult as MemberResolveResult; if (memberResolveResult != null) { var memberResolveResult2 = ctx.Resolve (assignmentExpression.Right) as MemberResolveResult; if (memberResolveResult2 == null || !AreEquivalent(memberResolveResult, memberResolveResult2)) return; } else if (resolveResult is LocalResolveResult) { if (!assignmentExpression.Left.Match (assignmentExpression.Right).Success) return; } else { return; } AstNode node; Action<Script> action; if (assignmentExpression.Parent is ExpressionStatement) { node = assignmentExpression.Parent; action = script => script.Remove (assignmentExpression.Parent); } else { node = assignmentExpression; action = script => script.Replace (assignmentExpression, assignmentExpression.Left.Clone ()); } AddIssue (node, ctx.TranslateString ("CS1717:Assignment made to same variable"), new [] { new CodeAction (ctx.TranslateString ("Remove assignment"), action) }); }
public IEnumerable<CodeAction> GetActions(RefactoringContext context) { if (context.IsSomethingSelected) { yield break; } AstType type; var varDecl = GetVariableDeclarationStatement(context, out type); if (varDecl == null) { yield break; } yield return new CodeAction(context.TranslateString("Split local variable declaration and assignment"), script => { var assign = new AssignmentExpression (new IdentifierExpression (varDecl.Variables.First().Name), AssignmentOperatorType.Assign, varDecl.Variables.First().Initializer.Clone()); var newVarDecl = (VariableDeclarationStatement)varDecl.Clone(); newVarDecl.Role = BlockStatement.StatementRole; if (newVarDecl.Type.IsMatch(new SimpleType ("var"))) { newVarDecl.Type = type; } newVarDecl.Variables.First().Initializer = Expression.Null; script.InsertBefore(varDecl, newVarDecl); script.Replace(varDecl, varDecl.Parent is ForStatement ? (AstNode)assign : new ExpressionStatement (assign)); }, varDecl.Variables.First ().AssignToken); }
private static string GetNewEqualityTestCode(AssignmentExpression assignmentExpression) { RelationalOperation relationalOperation = new RelationalOperation(assignmentExpression.LeftSide.Clone() as Expression, RelationalOperator.Equality, assignmentExpression.RightSide.Clone() as Expression); string newEqualityTest = CodeRush.Language.GenerateElement(relationalOperation); return newEqualityTest; }
public ArgumentsInfo(IEmitter emitter, AssignmentExpression assignmentExpression, OperatorResolveResult operatorResolveResult, IMethod method) { this.Emitter = emitter; this.Expression = assignmentExpression; this.OperatorResolveResult = operatorResolveResult; this.BuildOperatorArgumentsList(new Expression[] { assignmentExpression.Left, assignmentExpression.Right }, operatorResolveResult.UserDefinedOperatorMethod ?? method); this.BuildOperatorTypedArguments(); }
public override void VisitAssignmentExpression(AssignmentExpression assignmentExpression) { // assignment is right-associative ParenthesizeIfRequired(assignmentExpression.Left, Assignment + 1); if (InsertParenthesesForReadability) { ParenthesizeIfRequired(assignmentExpression.Right, RelationalAndTypeTesting + 1); } else { ParenthesizeIfRequired(assignmentExpression.Right, Assignment); } base.VisitAssignmentExpression(assignmentExpression); }
public override Expression VisitAssignmentExpression(AssignmentExpression assign) { AssignmentStatement stat = assign.AssignmentStatement as AssignmentStatement; if (stat != null) { stat.Target = this.VisitExpression(stat.Target); stat.Source = this.VisitExpression(stat.Source); } this.composers.Clear(); if (stat != null) { this.composers.Add(this.GetComposer(stat.Target)); this.composers.Add(this.GetComposer(stat.Source)); } return (Expression) this.Compose(assign, this.composers); }
public override object VisitAssignmentExpression(AssignmentExpression assignmentExpression, object data) { var ns = assignmentExpression.GetCurrentNamespace(); var variable = assignmentExpression.Left.GetIdentifier(); var fullVariableName = ns + "." + variable; if(_codebaseDeclarations.Any(a => a.FullName == fullVariableName && a.DeclarationClassType == TypeDeclarationKind.Event) && assignmentExpression.Operator == AssignmentOperatorType.Add) { UnlockWith(assignmentExpression); } return base.VisitAssignmentExpression(assignmentExpression, data); }
public void EqualityInAssignment() { Expression expr = new AssignmentExpression( new IdentifierExpression("cond"), new BinaryOperatorExpression( new IdentifierExpression("a"), BinaryOperatorType.Equality, new IdentifierExpression("b") ) ); Assert.AreEqual("cond = a == b", InsertRequired(expr)); Assert.AreEqual("cond = (a == b)", InsertReadable(expr)); }
public override object VisitAssignmentExpression(AssignmentExpression assignmentExpression, object data) { if (assignmentExpression.Right is PrimitiveExpression) { PrimitiveExpression prim = (PrimitiveExpression)assignmentExpression.Right; int number; if (int.TryParse(prim.LiteralValue, out number)) { if (number == 666) UnlockWith(assignmentExpression); } } return base.VisitAssignmentExpression(assignmentExpression, data); }
public AssignmentExpression ConvertToInitializer(AssignmentExpression assignmentExpression, ref IList<AstNode> statements) { if (assignmentExpression == null) throw new ArgumentNullException("assignmentExpression"); if (statements == null) throw new ArgumentNullException("statements"); if (!(assignmentExpression.Right is ObjectCreateExpression)) throw new ArgumentException("assignmentExpression.Right must be an ObjectCreateExpression", "assignmentExpression"); Initialize(assignmentExpression.Left); accessPaths [mainAccessPath] = assignmentExpression.Right.Clone(); Convert(statements); statements = ReplacementNodeHelper.GetReplacedNodes(accessPaths [mainAccessPath]); return new AssignmentExpression(new IdentifierExpression(mainAccessPath.RootName), accessPaths [mainAccessPath]); }
public IEnumerable<CodeAction> GetActions(RefactoringContext context) { //TODO: implement variable assignment & ctor param var varInit = context.GetNode<VariableInitializer>(); if (varInit != null) { AstType type = varInit.GetPrevNode() as AstType; if (type == null) yield break; if (varInit.Parent is FieldDeclaration) yield break; if (CannotExtractField(varInit)) yield break; yield return new CodeAction("Extract field", s=>{ var name = varInit.Name; FieldDeclaration field = new FieldDeclaration(){ ReturnType = type.Clone(), Variables = { new VariableInitializer(name) } }; AstNode nodeToRemove = RemoveDeclaration(varInit) ? varInit.Parent : type; s.Remove(nodeToRemove, true); s.InsertWithCursor(context.TranslateString("Extract field"),Script.InsertPosition.Before,field); s.FormatText(varInit.Parent); }); } var idntf = context.GetNode<Identifier>(); if (idntf == null) yield break; var paramDec = idntf.Parent as ParameterDeclaration; if (paramDec != null) { var ctor = paramDec.Parent as ConstructorDeclaration; if (ctor == null) yield break; MemberReferenceExpression thisField = new MemberReferenceExpression(new ThisReferenceExpression(), idntf.Name, new AstType[]{}); var assign = new AssignmentExpression(thisField, AssignmentOperatorType.Assign, new IdentifierExpression(idntf.Name)); var statement = new ExpressionStatement(assign); var type = (idntf.GetPrevNode() as AstType).Clone(); FieldDeclaration field = new FieldDeclaration(){ ReturnType = type.Clone(), Variables = { new VariableInitializer(idntf.Name) } }; yield return new CodeAction("Extract field", s=>{ s.InsertWithCursor(context.TranslateString("Extract field"),Script.InsertPosition.Before,field); s.AddTo(ctor.Body, statement); }); } }
public void Run (RefactoringContext context) { AstType type; var varDecl = GetVariableDeclarationStatement (context, out type); var assign = new AssignmentExpression (new IdentifierExpression (varDecl.Variables.First ().Name), AssignmentOperatorType.Assign, varDecl.Variables.First ().Initializer.Clone ()); var newVarDecl = (VariableDeclarationStatement)varDecl.Clone (); if (newVarDecl.Type.IsMatch (new SimpleType ("var"))) newVarDecl.Type = type; newVarDecl.Variables.First ().Initializer = Expression.Null; using (var script = context.StartScript ()) { script.InsertBefore (varDecl, newVarDecl); script.Replace (varDecl, varDecl.Parent is ForStatement ? (AstNode)assign : new ExpressionStatement (assign)); } }
ResolveResult ResolveAssignment (RefactoringOptions options, AssignmentExpression assignment) { var resolver = options.GetResolver (); var data = options.GetTextEditorData (); string expression; if (assignment.Left is IdentifierExpression) { expression = ((IdentifierExpression)assignment.Left).Identifier; } else { var left = assignment.Left; expression = data.GetTextBetween (left.StartLocation.Line, left.StartLocation.Column, left.EndLocation.Line, left.EndLocation.Column); } return resolver.Resolve (new ExpressionResult (expression), resolvePosition); }
public virtual void Visit(AssignmentExpression expression) { logVisit(expression); }
public override object TrackedVisitAssignmentExpression(AssignmentExpression assignmentExpression, object data) { if (this.FoundResourceSet == null && // skip if already found to improve performance assignmentExpression.Op == AssignmentOperatorType.Assign && this.PositionAvailable && (!this.isLocalVariable || this.resourceManagerMember.Region.IsInside(this.CurrentNodeStartLocation.Y, this.CurrentNodeStartLocation.X)) // skip if local variable is out of scope ) { IMember resolvedMember = null; ResolveResult rr = this.Resolve(assignmentExpression.Left); if (rr != null) { // Support both local variables and member variables MemberResolveResult mrr = rr as MemberResolveResult; if (mrr != null) { resolvedMember = mrr.ResolvedMember; } else { LocalResolveResult lrr = rr as LocalResolveResult; if (lrr != null) { resolvedMember = lrr.Field; } } } if (resolvedMember != null) { #if DEBUG LoggingService.Debug("ResourceToolkit: BclNRefactoryResourceResolver: Resolved member: " + resolvedMember.ToString()); #endif // HACK: The GetType()s are necessary because the DOM IComparable implementations try to cast the parameter object to their own interface type which may fail. if (resolvedMember.GetType().Equals(this.resourceManagerMember.GetType()) && resolvedMember.CompareTo(this.resourceManagerMember) == 0) { #if DEBUG LoggingService.Debug("ResourceToolkit: BclNRefactoryResourceResolver found assignment to field: " + assignmentExpression.ToString()); #endif data = true; // Resolving the property association only makes sense if // there is a possible relationship between the return types // of the resolved member and the member we are looking for. } else if (this.compilationUnit != null && !this.isLocalVariable && IsTypeRelationshipPossible(resolvedMember, this.resourceManagerMember)) { if (this.resourceManagerMember is IProperty && resolvedMember is IField) { // Find out if the resourceManagerMember is a property whose get block returns the value of the resolved member. // We might already have found this association in the // resourceManagerFieldAccessedByProperty field. this.TryResolveResourceManagerProperty(); if (this.resourceManagerFieldAccessedByProperty != null && this.resourceManagerFieldAccessedByProperty.CompareTo(resolvedMember) == 0) { #if DEBUG LoggingService.Debug("ResourceToolkit: BclNRefactoryResourceResolver found assignment to field: " + assignmentExpression.ToString()); #endif data = true; } } else if (this.resourceManagerMember is IField && resolvedMember is IProperty) { // Find out if the resolved member is a property whose set block assigns the value to the resourceManagerMember. PropertyFieldAssociationVisitor visitor = new PropertyFieldAssociationVisitor((IField)this.resourceManagerMember, this.FileName, this.FileContent); this.compilationUnit.AcceptVisitor(visitor, null); if (visitor.AssociatedProperty != null && visitor.AssociatedProperty.CompareTo(resolvedMember) == 0) { #if DEBUG LoggingService.Debug("ResourceToolkit: BclNRefactoryResourceResolver found assignment to property: " + assignmentExpression.ToString()); #endif data = true; } } } } } return(base.TrackedVisitAssignmentExpression(assignmentExpression, data)); }
/// <summary> /// Returns the string representation of the underlying syntax, not including its leading and trailing trivia. /// </summary> /// <returns></returns> public override string ToString() { return(AssignmentExpression?.ToString() ?? ""); }
public object VisitAssignmentExpression(AssignmentExpression assignmentExpression, object data) { throw new NotImplementedException(); }
public abstract T Visit(AssignmentExpression node);
public virtual object VisitAssignmentExpression(AssignmentExpression assignmentExpression, object data) { throw new global::System.NotImplementedException("AssignmentExpression"); }
/// <summary> /// 式中のメンバアクセス、定数等を解析する。 /// </summary> /// <param name="syntax"></param> /// <param name="semanticModel"></param> /// <returns></returns> Expression ParseExpression(ExpressionSyntax syntax, SemanticModel semanticModel) { if (syntax == null) { return(null); } var mae = syntax as MemberAccessExpressionSyntax; var gns = syntax as GenericNameSyntax; var le = syntax as LiteralExpressionSyntax; var ie = syntax as InvocationExpressionSyntax; var oce = syntax as ObjectCreationExpressionSyntax; var ce = syntax as CastExpressionSyntax; var thise = syntax as ThisExpressionSyntax; var ae = syntax as AssignmentExpressionSyntax; var pe = syntax as ParenthesizedExpressionSyntax; var ine = syntax as IdentifierNameSyntax; var eae = syntax as ElementAccessExpressionSyntax; var be = syntax as BinaryExpressionSyntax; var preue = syntax as PrefixUnaryExpressionSyntax; var poue = syntax as PostfixUnaryExpressionSyntax; var basee = syntax as BaseExpressionSyntax; var ace = syntax as ArrayCreationExpressionSyntax; var sace = syntax as StackAllocArrayCreationExpressionSyntax; var iee = syntax as InitializerExpressionSyntax; /* * var coe = syntax as ConditionalExpressionSyntax; * var sle = syntax as SimpleLambdaExpressionSyntax; * var ple = syntax as ParenthesizedLambdaExpressionSyntax; * var oase = syntax as OmittedArraySizeExpressionSyntax; * var iace = syntax as ImplicitArrayCreationExpressionSyntax; * * var qua = syntax as QualifiedNameSyntax; * var predf = syntax as PredefinedTypeSyntax; */ // 自己の型を解析 TypeInfo?selfTypeInfo = null; selfTypeInfo = semanticModel.GetTypeInfo(syntax); var selfType = ParseType(syntax, selfTypeInfo, semanticModel); if (mae != null) { MemberAccessExpression exp = new MemberAccessExpression(); exp.SelfType = selfType; exp.Internal = syntax; exp.Name = mae.Name.ToString(); if (mae.Name is GenericNameSyntax) { var gns_ = mae.Name as GenericNameSyntax; exp.Types = gns_.TypeArgumentList.Arguments.Select(_ => ParseType(_, semanticModel)).ToArray(); } TypeInfo?parentType = null; if (mae.Expression != null) { parentType = semanticModel.GetTypeInfo(mae.Expression); } // 種類を取得 var symbol = semanticModel.GetSymbolInfo(mae); var methodSymbol = symbol.Symbol as IMethodSymbol; var propertySymbol = symbol.Symbol as IPropertySymbol; // 親の種類を探索 List <ClassDef> classDefPs = new List <ClassDef>(); EnumDef enumDefP = null; InterfaceDef interfaceDefP = null; StructDef structDefP = null; // プロパティである if (propertySymbol != null) { exp.IsProperty = true; } if (parentType.HasValue && parentType.Value.Type != null) { if (parentType.Value.Type.TypeKind == TypeKind.Interface) { var memName = mae.Name.ToString(); var sym = semanticModel.GetSymbolInfo(mae); var name_ = parentType.Value.Type.Name; var namespace_ = Utils.ToStr(parentType.Value.Type.ContainingNamespace); interfaceDefP = definitions.Interfaces.Where(_ => _.Namespace == namespace_ && _.Name == name_).FirstOrDefault(); } else if (parentType.Value.Type.TypeKind == TypeKind.Class) { var memName = mae.Name.ToString(); var sym = semanticModel.GetSymbolInfo(mae); var name_ = parentType.Value.Type.Name; var namespace_ = Utils.ToStr(parentType.Value.Type.ContainingNamespace); classDefPs = definitions.FindTypeWithBases(namespace_, name_).OfType <ClassDef>().ToList(); } else if (parentType.Value.Type.TypeKind == TypeKind.Enum) { var enumName = selfTypeInfo.Value.Type.Name; var namespace_ = Utils.ToStr(selfTypeInfo.Value.Type.ContainingNamespace); enumDefP = definitions.Enums.Where(_ => _.Namespace == namespace_ && _.Name == enumName).FirstOrDefault(); } else if (parentType.Value.Type.TypeKind == TypeKind.Struct) { var memName = mae.Name.ToString(); var sym = semanticModel.GetSymbolInfo(mae); var name_ = parentType.Value.Type.Name; var namespace_ = Utils.ToStr(parentType.Value.Type.ContainingNamespace); structDefP = definitions.Structs.Where(_ => _.Namespace == namespace_ && _.Name == name_).FirstOrDefault(); } } // 親から子を探索 if (interfaceDefP != null) { if (methodSymbol != null) { var method = interfaceDefP.Methods.Where(_ => { if (_.Name != methodSymbol.Name) { return(false); } if (_.Parameters.Count() != methodSymbol.Parameters.Count()) { return(false); } for (int i = 0; i < _.Parameters.Count(); i++) { if (_.Parameters[i].Name != methodSymbol.Parameters[i].Name) { return(false); } // TODO 正しい変換 //if(_.Parameters[i].Type != methodSymbol.Parameters[i].Type) } return(true); }).FirstOrDefault(); if (method != null) { exp.Name = null; exp.Method = method; } } else if (propertySymbol != null) { var prop = interfaceDefP.Properties.Where(_ => { if (_.Name != propertySymbol.Name) { return(false); } return(true); }).FirstOrDefault(); if (prop != null) { exp.Name = null; exp.Property = prop; } } } else if (classDefPs.Count > 0) { if (methodSymbol != null) { foreach (var classDefP in classDefPs) { var method = classDefP.Methods.Where(_ => { if (_.Name != methodSymbol.Name) { return(false); } if (_.Parameters.Count() != methodSymbol.Parameters.Count()) { return(false); } for (int i = 0; i < _.Parameters.Count(); i++) { if (_.Parameters[i].Name != methodSymbol.Parameters[i].Name) { return(false); } // TODO 正しい変換 //if(_.Parameters[i].Type != methodSymbol.Parameters[i].Type) } return(true); }).FirstOrDefault(); if (method != null) { exp.Name = null; exp.Class = classDefP; exp.Method = method; // staticの場合走査停止 if (method.IsStatic) { return(exp); } break; } } } else if (propertySymbol != null) { foreach (var classDefP in classDefPs) { var prop = classDefP.Properties.Where(_ => { if (_.Name != propertySymbol.Name) { return(false); } return(true); }).FirstOrDefault(); if (prop != null) { exp.Name = null; exp.Class = classDefP; exp.Property = prop; break; } } } } else if (structDefP != null) { if (propertySymbol != null) { var prop = structDefP.Properties.Where(_ => { if (_.Name != propertySymbol.Name) { return(false); } return(true); }).FirstOrDefault(); if (prop != null) { exp.Name = null; exp.Struct = structDefP; exp.Property = prop; } } } else if (enumDefP != null) { var name = mae.Name.ToString(); exp.EnumMember = enumDefP.Members.Where(_ => _.Name == name).FirstOrDefault(); if (exp.EnumMember != null) { exp.Enum = enumDefP; exp.Name = null; } } else { // 代替処理 if (propertySymbol != null) { exp.Property = new PropertyDef(); exp.Property.Name = exp.Name; } } if (exp.EnumMember != null) { // enumのメンバーだった場合、親は必ずenumなのでこれ以上走査しない } else if (mae.Expression != null) { exp.Expression = ParseExpression(mae.Expression, semanticModel); } return(exp); } else if (gns != null) { var symbol = semanticModel.GetSymbolInfo(gns); var methodSymbol = symbol.Symbol as IMethodSymbol; var fieldSymbol = symbol.Symbol as IFieldSymbol; var propertySymbol = symbol.Symbol as IPropertySymbol; var exp = new GenericNameExpression(); exp.SelfType = selfType; exp.Internal = syntax; exp.Name = gns.Identifier.ValueText; if (methodSymbol != null) { exp.IsMethod = true; } if (propertySymbol != null) { exp.IsProperty = true; } exp.Types = gns.TypeArgumentList.Arguments.Select(_ => ParseType(_, semanticModel)).ToArray(); return(exp); } else if (le != null) { var text = le.GetText().ToString(); var exp = new LiteralExpression(); exp.SelfType = selfType; exp.Internal = syntax; exp.Text = text; return(exp); } else if (ie != null) { var exp = new InvocationExpression(); exp.SelfType = selfType; exp.Internal = syntax; exp.Method = ParseExpression(ie.Expression, semanticModel); exp.Args = ie.ArgumentList.Arguments.Select(_ => ParseExpression(_.Expression, semanticModel)).ToArray(); return(exp); } else if (oce != null) { var exp = new ObjectCreationExpression(); exp.SelfType = selfType; exp.Internal = syntax; exp.Type = ParseType(oce.Type, semanticModel); if (oce.ArgumentList != null) { exp.Args = oce.ArgumentList.Arguments.Select(_ => ParseExpression(_.Expression, semanticModel)).ToArray(); } else { exp.Args = new Expression[0]; } return(exp); } else if (ce != null) { var exp = new CastExpression(); exp.SelfType = selfType; exp.Internal = syntax; exp.Type = ParseType(ce.Type, semanticModel); exp.Expression = ParseExpression(ce.Expression, semanticModel); return(exp); } else if (thise != null) { var exp = new ThisExpression(); exp.SelfType = selfType; exp.Internal = syntax; return(exp); } else if (ae != null) { var exp = new AssignmentExpression(); exp.SelfType = selfType; exp.Internal = syntax; if (ae.Kind() == SyntaxKind.AddAssignmentExpression) { exp.Type = AssignmentExpression.OperatorType.Add; } if (ae.Kind() == SyntaxKind.SubtractAssignmentExpression) { exp.Type = AssignmentExpression.OperatorType.Substract; } if (ae.Kind() == SyntaxKind.SimpleAssignmentExpression) { exp.Type = AssignmentExpression.OperatorType.Simple; } if (ae.Kind() == SyntaxKind.DivideAssignmentExpression) { exp.Type = AssignmentExpression.OperatorType.Divide; } if (ae.Kind() == SyntaxKind.ModuloAssignmentExpression) { exp.Type = AssignmentExpression.OperatorType.Modulo; } exp.Temp = ae.Kind(); exp.Target = ParseExpression(ae.Left, semanticModel); exp.Expression = ParseExpression(ae.Right, semanticModel); return(exp); } else if (pe != null) { // ()の構文 return(ParseExpression(pe.Expression, semanticModel)); } else if (ine != null) { var symbol = semanticModel.GetSymbolInfo(ine); var methodSymbol = symbol.Symbol as IMethodSymbol; var fieldSymbol = symbol.Symbol as IFieldSymbol; var propertySymbol = symbol.Symbol as IPropertySymbol; var exp = new IdentifierNameExpression(); exp.SelfType = selfType; exp.Internal = syntax; exp.Name = ine.Identifier.Text; if (selfTypeInfo?.Type != null) { exp.Type = ParseType(selfTypeInfo.Value.Type); } if (methodSymbol != null) { exp.IsMethod = true; } if (propertySymbol != null) { exp.IsProperty = true; } return(exp); } else if (eae != null) { if (eae.ArgumentList.Arguments.Count() != 1) { throw new ParseException("多次元配列は使用禁止です。"); } var value_ = eae.Expression; var arg = eae.ArgumentList.Arguments[0].Expression; var exp = new ElementAccessExpression(); exp.SelfType = selfType; exp.Internal = syntax; exp.Value = ParseExpression(value_, semanticModel); exp.Arg = ParseExpression(arg, semanticModel); return(exp); } else if (be != null) { var exp = new BinaryExpression(); exp.SelfType = selfType; exp.Internal = syntax; exp.Left = ParseExpression(be.Left, semanticModel); exp.Right = ParseExpression(be.Right, semanticModel); if (be.Kind() == SyntaxKind.AddExpression) { exp.Operator = BinaryExpression.OperatorType.Add; } if (be.Kind() == SyntaxKind.SubtractExpression) { exp.Operator = BinaryExpression.OperatorType.Subtract; } if (be.Kind() == SyntaxKind.IsExpression) { exp.Operator = BinaryExpression.OperatorType.Is; } if (be.Kind() == SyntaxKind.AsExpression) { exp.Operator = BinaryExpression.OperatorType.As; } if (be.Kind() == SyntaxKind.EqualsExpression) { exp.Operator = BinaryExpression.OperatorType.Equals; } if (be.Kind() == SyntaxKind.NotEqualsExpression) { exp.Operator = BinaryExpression.OperatorType.NotEquals; } if (be.Kind() == SyntaxKind.LogicalAndExpression) { exp.Operator = BinaryExpression.OperatorType.LogicalAnd; } if (be.Kind() == SyntaxKind.LogicalOrExpression) { exp.Operator = BinaryExpression.OperatorType.LogicalOr; } if (be.Kind() == SyntaxKind.GreaterThanExpression) { exp.Operator = BinaryExpression.OperatorType.GreaterThan; } if (be.Kind() == SyntaxKind.GreaterThanOrEqualExpression) { exp.Operator = BinaryExpression.OperatorType.GreaterThanOrEqual; } if (be.Kind() == SyntaxKind.LessThanExpression) { exp.Operator = BinaryExpression.OperatorType.LessThan; } if (be.Kind() == SyntaxKind.LessThanOrEqualExpression) { exp.Operator = BinaryExpression.OperatorType.LessThanOrEqual; } if (be.Kind() == SyntaxKind.MultiplyExpression) { exp.Operator = BinaryExpression.OperatorType.Multiply; } if (be.Kind() == SyntaxKind.DivideExpression) { exp.Operator = BinaryExpression.OperatorType.Divide; } if (be.Kind() == SyntaxKind.ModuloExpression) { exp.Operator = BinaryExpression.OperatorType.Modulo; } if (exp.Operator == BinaryExpression.OperatorType.None) { var span_ = syntax.SyntaxTree.GetLineSpan(syntax.Span); Console.WriteLine(string.Format("{0} : {1} には未対応です。", span_, be.Kind())); } return(exp); } else if (preue != null) { var exp = new PrefixUnaryExpression(); exp.SelfType = selfType; exp.Internal = syntax; exp.Expression = ParseExpression(preue.Operand, semanticModel); switch (preue.Kind()) { case SyntaxKind.LogicalNotExpression: exp.Type = PrefixUnaryExpression.OperatorType.LogicalNot; break; case SyntaxKind.UnaryPlusExpression: exp.Type = PrefixUnaryExpression.OperatorType.UnaryPlus; break; case SyntaxKind.UnaryMinusExpression: exp.Type = PrefixUnaryExpression.OperatorType.UnaryMinus; break; case SyntaxKind.PreIncrementExpression: exp.Type = PrefixUnaryExpression.OperatorType.PreIncrement; break; default: throw new Exception(); break; } return(exp); } else if (poue != null) { var exp = new PostfixUnaryExpression(); exp.SelfType = selfType; exp.Internal = syntax; exp.Operand = ParseExpression(poue.Operand, semanticModel); if (poue.Kind() == SyntaxKind.PostIncrementExpression) { exp.Type = PostfixUnaryExpression.OperatorType.PostIncrement; } if (poue.Kind() == SyntaxKind.PostDecrementExpression) { exp.Type = PostfixUnaryExpression.OperatorType.PostDecrement; } return(exp); } else if (basee != null) { var exp = new BaseExpression(); exp.SelfType = selfType; exp.Internal = syntax; return(exp); } else if (iee != null) { var exp = new InitializerExpression(); exp.SelfType = selfType; exp.Internal = syntax; var expressions = iee.Expressions.Select(_ => _).ToArray(); exp.Expressions = expressions.Select(_ => ParseExpression(_, semanticModel)).ToArray(); return(exp); } else if (ace != null || sace != null) { // stackallocも含め、配列の確保として扱う。 ArrayTypeSyntax ats = null; if (ace != null) { ats = ace.Type; } if (sace != null) { ats = sace.Type as ArrayTypeSyntax; } var exp = new ObjectArrayCreationExpression(); exp.SelfType = selfType; exp.Internal = syntax; exp.Type = ParseType(ats.ElementType, semanticModel); exp.Args = ats.RankSpecifiers.Select(_ => ParseExpression(_.Sizes.FirstOrDefault(), semanticModel)).ToArray(); return(exp); } else if (syntax is PredefinedTypeSyntax) { var s = syntax as PredefinedTypeSyntax; var exp = new TypeExpression(); exp.SelfType = selfType; exp.Internal = syntax; return(exp); } else if (syntax is QualifiedNameSyntax) { var s = syntax as QualifiedNameSyntax; var exp = new TypeExpression(); exp.SelfType = selfType; exp.Internal = syntax; return(exp); } var span = syntax.SyntaxTree.GetLineSpan(syntax.Span); Console.WriteLine(string.Format("{0} : {1} には未対応です。", span, syntax.GetType())); return(null); }
protected abstract T CompileAssignmentExpression(AssignmentExpression expression);
public static Expression ConvertExpression(RenderState render, Method method, Expression s, VHDLType target, Mono.Cecil.TypeReference targetsource, bool fromCast) { var svhdl = render.VHDLType(s); // Deal with pesky integers that overflow the 32bit VHDL specs if (IsTooLargeIntegerLiteral(s, target)) { svhdl = render.TypeScope.StdLogicVectorEquivalent(target); } // Already the real target type, just return it if (svhdl == target) { return(s); } // Stuff we do not care about if (!svhdl.IsStdLogicVector && !svhdl.IsUnsigned && !svhdl.IsSigned && svhdl.IsArray && target.IsArray && render.TypeScope.GetByName(svhdl.ElementName) == render.TypeScope.GetByName(target.ElementName)) { return(s); } // Array lengths var targetlengthstr = string.IsNullOrWhiteSpace(target.Alias) ? target.Length.ToString() : target.Alias + "'length"; if (target == VHDLTypes.SYSTEM_BOOL) { // Boolean to std_logic is fine if (string.Equals("STD_LOGIC", svhdl.Name, StringComparison.OrdinalIgnoreCase)) { return(s); } // Source is numeric, and output is bool if (svhdl.IsNumeric || svhdl.IsStdLogicVector) { var zero = new PrimitiveExpression() { SourceExpression = s.SourceExpression, SourceResultType = s.SourceResultType, Value = 0 }; var eval = new BinaryOperatorExpression() { Parent = s.Parent, Name = s.Name, SourceExpression = s.SourceExpression, SourceResultType = s.SourceResultType.LoadType(typeof(bool)), Left = s, Operator = ICSharpCode.Decompiler.CSharp.Syntax.BinaryOperatorType.InEquality, Right = zero }; zero.Parent = eval; s.ReplaceWith(eval); s.Parent = eval; return(eval); } else if (svhdl == VHDLTypes.BOOL) { var truexp = new PrimitiveExpression() { Value = true, SourceExpression = s.SourceExpression, SourceResultType = s.SourceResultType.LoadType(typeof(bool)), }; var falseexp = new PrimitiveExpression() { Value = false, SourceExpression = s.SourceExpression, SourceResultType = s.SourceResultType.LoadType(typeof(bool)), }; var eval = new ConditionalExpression() { ConditionExpression = s, TrueExpression = truexp, FalseExpression = falseexp, SourceExpression = s.SourceExpression, SourceResultType = truexp.SourceResultType }; truexp.Parent = eval; falseexp.Parent = eval; s.ReplaceWith(eval); s.Parent = eval; return(eval); } else { throw new Exception(string.Format("Unexpected conversion from {0} to {1}", svhdl, target)); } } else if (svhdl == VHDLTypes.INTEGER && (target.IsStdLogicVector || target.IsNumeric)) { if (target.IsSigned && target.IsNumeric) { return(WrapExpression(render, s, string.Format("TO_SIGNED({0}, {1})", "{0}", targetlengthstr), target)); } else if (target.IsUnsigned && target.IsNumeric) { return(WrapExpression(render, s, string.Format("TO_UNSIGNED({0}, {1})", "{0}", targetlengthstr), target)); } else if (target.IsStdLogicVector) { return(WrapExpression(render, s, string.Format("STD_LOGIC_VECTOR(TO_UNSIGNED({0}, {1}))", "{0}", targetlengthstr), target)); } else { throw new Exception(string.Format("Unexpected conversion from {0} to {1}", svhdl, target)); } } else if (target.IsNumeric && !svhdl.IsEnum) { if (svhdl.IsStdLogicVector || svhdl.IsSigned || svhdl.IsUnsigned) { var str = "{0}"; var resized = false; Variable tmpvar = null; if (target.Length != svhdl.Length) { if (svhdl.IsVHDLSigned) { // Resizing with signed is bad because we may chop the upper bit resized = true; str = string.Format("SIGNED(resize(UNSIGNED({0}), {1}))", str, targetlengthstr); } else if (svhdl.IsVHDLUnsigned) { resized = true; str = string.Format("resize({0}, {1})", str, targetlengthstr); } else if (svhdl.IsSystemSigned) { // Resizing with signed is bad because we may chop the upper bit str = string.Format("SIGNED(resize(UNSIGNED({0}), {1}))", str, targetlengthstr); svhdl = render.TypeScope.NumericEquivalent(svhdl); resized = true; } else if (svhdl.IsSystemUnsigned) { str = string.Format("resize(UNSIGNED({0}), {1})", str, targetlengthstr); svhdl = render.TypeScope.NumericEquivalent(svhdl); resized = true; } else if (target.Length > svhdl.Length) { // This must be a variable as bit concatenation is only allowed in assignment statements: // http://stackoverflow.com/questions/209458/concatenating-bits-in-vhdl tmpvar = render.RegisterTemporaryVariable(method, targetsource); render.TypeLookup[tmpvar] = target; var iexp = new IdentifierExpression() { Name = tmpvar.Name, Target = tmpvar, SourceExpression = s.SourceExpression, SourceResultType = targetsource }; string wstr; if (render.Config.USE_EXPLICIT_CONCATENATION_OPERATOR) { wstr = string.Format("IEEE.STD_LOGIC_1164.\"&\"(\"{0}\", {1})", new string('0', target.Length - svhdl.Length), "{0}"); } else { wstr = string.Format("\"{0}\" & {1}", new string('0', target.Length - svhdl.Length), "{0}"); } s.ReplaceWith(iexp); var asstm = new ExpressionStatement() { Expression = new AssignmentExpression() { Left = iexp.Clone(), Right = new CustomNodes.ConversionExpression() { Expression = s, SourceExpression = s.SourceExpression, SourceResultType = targetsource, WrappingTemplate = wstr, }, Operator = ICSharpCode.Decompiler.CSharp.Syntax.AssignmentOperatorType.Assign, SourceExpression = s.SourceExpression, SourceResultType = targetsource }, }; s.PrependStatement(asstm); asstm.UpdateParents(); resized = true; s = iexp; } } if (svhdl.IsVHDLSigned != target.IsSigned || svhdl.IsVHDLUnsigned != target.IsUnsigned) { str = string.Format("{1}({0})", str, target.IsSigned ? "SIGNED" : "UNSIGNED"); } if (target.Length != svhdl.Length && !resized) { str = string.Format("resize({0}, {1})", str, targetlengthstr); } return(WrapExpression(render, s, str, target)); } /*if (svhdl.IsStdLogicVector && target.IsSigned) * return new VHDLConvertedExpression(s, target, "SIGNED({0})"); * else if (svhdl.IsStdLogicVector && target.IsUnsigned) * return new VHDLConvertedExpression(s, target, "UNSIGNED({0})"); * else*/ throw new Exception(string.Format("Unexpected conversion from {0} to {1}", svhdl, target)); } else if (target.IsStdLogicVector) { if (svhdl.IsNumeric) { if (svhdl.Length == target.Length) { return(WrapExpression(render, s, "STD_LOGIC_VECTOR({0})", target)); } else { if (!fromCast) { Console.WriteLine("WARN: Incompatible array lengths, from {0} to {1}", svhdl, target); } //throw new Exception(string.Format("Incompatible array lengths, from {0} to {1}", svhdl, target)); if (target.Length < svhdl.Length && svhdl.IsNumericSigned) { return(WrapExpression(render, s, string.Format("STD_LOGIC_VECTOR(resize(UNSIGNED({0}), {1}))", "{0}", targetlengthstr), target)); } else { return(WrapExpression(render, s, string.Format("STD_LOGIC_VECTOR(resize({0}, {1}))", "{0}", targetlengthstr), target)); } } } else if (svhdl.IsStdLogicVector) { if (target.Length == svhdl.Length) { render.TypeLookup[s] = target; return(s); } if (!fromCast) { Console.WriteLine("WARN: Incompatible array lengths, from {0} to {1}", svhdl, target); } //throw new Exception(string.Format("Incompatible array lengths, from {0} to {1}", svhdl, target)); if (target.Length < svhdl.Length) { // If the expression is a simple identifier, we can select bits from it // otherwise we need to inject a variable with the expression // and select the required bits from it if (!(s is IdentifierExpression || s is MemberReferenceExpression || s is IndexerExpression)) { var tmp = render.RegisterTemporaryVariable(method, s.SourceResultType); render.TypeLookup[tmp] = svhdl; var aleft = new IdentifierExpression() { Name = tmp.Name, Target = tmp, SourceExpression = s.SourceExpression, SourceResultType = s.SourceResultType }; var aexp = new AssignmentExpression() { Left = aleft, Right = s, SourceExpression = s.SourceExpression, SourceResultType = s.SourceResultType }; var astm = new ExpressionStatement() { Expression = aexp, Parent = method, }; var iexp = new IdentifierExpression() { SourceExpression = s.SourceExpression, SourceResultType = s.SourceResultType, Target = tmp }; s.ReplaceWith(iexp); s.PrependStatement(astm); astm.UpdateParents(); return(WrapExpression(render, iexp, string.Format("{0}({1} downto 0)", "{0}", target.Length - 1), target)); } return(WrapExpression(render, s, string.Format("{0}({1} downto 0)", "{0}", target.Length - 1), target)); } else if (svhdl.IsSigned) { return(WrapExpression(render, s, string.Format("STD_LOGIC_VECTOR(resize(SIGNED({0}), {1}))", "{0}", targetlengthstr), target)); } else if (svhdl.IsUnsigned) { return(WrapExpression(render, s, string.Format("STD_LOGIC_VECTOR(resize(UNSIGNED({0}), {1}))", "{0}", targetlengthstr), target)); } else { var tmp = render.RegisterTemporaryVariable(method, targetsource); render.TypeLookup[tmp] = target; var iexp = new IdentifierExpression() { Name = tmp.Name, Target = tmp, SourceExpression = s.SourceExpression, SourceResultType = targetsource }; render.TypeLookup[iexp] = target; string wexpr; if (render.Config.USE_EXPLICIT_CONCATENATION_OPERATOR) { wexpr = string.Format("IEEE.STD_LOGIC_1164.\"&\"(\"{0}\", {1})", new string('0', target.Length - svhdl.Length), "{0}"); } else { wexpr = string.Format("\"{0}\" & {1}", new string('0', target.Length - svhdl.Length), "{0}"); } s.ReplaceWith(iexp); var asstm = new ExpressionStatement(); s.PrependStatement(asstm); var asexp = new AssignmentExpression() { Left = iexp.Clone(), Operator = ICSharpCode.Decompiler.CSharp.Syntax.AssignmentOperatorType.Assign, Right = new CustomNodes.ConversionExpression() { Expression = s, SourceExpression = s.SourceExpression, SourceResultType = targetsource, WrappingTemplate = wexpr }, SourceExpression = s.SourceExpression, SourceResultType = targetsource }; render.TypeLookup[asexp.Left] = target; render.TypeLookup[asexp.Right] = target; asexp.Left.SourceResultType = targetsource; asexp.Right.SourceResultType = targetsource; asstm.Expression = asexp; asstm.UpdateParents(); return(iexp); } } else if (svhdl.IsSigned || svhdl.IsUnsigned) { if (target.Length == svhdl.Length) { return(WrapExpression(render, s, string.Format("STD_LOGIC_VECTOR({0})", "{0}"), target)); } else { return(WrapExpression(render, s, string.Format("STD_LOGIC_VECTOR(resize({0}, {1}))", "{0}", targetlengthstr), target)); } } else { throw new Exception(string.Format("Unexpected conversion from {0} to {1}", svhdl.Name, target.Name)); } } else if (target == VHDLTypes.INTEGER && (svhdl.IsStdLogicVector || svhdl.IsNumeric)) { if (svhdl.IsNumeric) { return(WrapExpression(render, s, "TO_INTEGER({0})", target)); } if (svhdl.IsSigned) { return(WrapExpression(render, s, "TO_INTEGER(SIGNED({0}))", target)); } else { return(WrapExpression(render, s, "TO_INTEGER(UNSIGNED({0}))", target)); } } else if (target == VHDLTypes.INTEGER && (svhdl.IsSystemSigned || svhdl.IsSystemUnsigned)) { return(WrapExpression(render, s, "TO_INTEGER({0})", target)); } else if (target == VHDLTypes.BOOL && svhdl == VHDLTypes.SYSTEM_BOOL) { return(WrapInParenthesis(render, WrapExpression(render, s, "{0} = '1'", target))); } else if ((target.IsSigned || target.IsUnsigned) && svhdl.IsStdLogicVector) { if (target.Length == svhdl.Length) { return(WrapExpression(render, s, string.Format("{1}({0})", "{0}", target.IsSigned ? "SIGNED" : "UNSIGNED"), target)); } else { return(WrapExpression(render, s, string.Format("resize({1}({0}), {2})", "{0}", target.IsSigned ? "SIGNED" : "UNSIGNED", targetlengthstr), target)); } } else if ((target.IsSigned || target.IsUnsigned) && svhdl == VHDLTypes.INTEGER) { if (target.IsSigned) { return(WrapExpression(render, s, string.Format("TO_SIGNED({0}, {1})", "{0}", target.Length), target)); } else if (target.IsUnsigned) { return(WrapExpression(render, s, string.Format("TO_UNSIGNED({0}, {1})", "{0}", target.Length), target)); } else { throw new Exception("Unexpected case"); } } else if ((svhdl.IsSigned || svhdl.IsUnsigned) && (target.IsSigned || target.IsUnsigned)) { if (target.Length == svhdl.Length) { if (svhdl.IsSigned == target.IsSigned) { return(s); } else { return(WrapExpression(render, s, string.Format("{1}({0})", "{0}", target.IsSigned ? "SIGNED" : "UNSIGNED"), target)); } } else { if (svhdl.IsSigned == target.IsSigned) { return(WrapExpression(render, s, string.Format("resize({0}, {1})", "{0}", targetlengthstr), target)); } else if (svhdl.IsSigned && svhdl.Length > target.Length) { return(WrapExpression(render, s, string.Format("resize(UNSIGNED({0}), {1})", "{0}", targetlengthstr), target)); } else { return(WrapExpression(render, s, string.Format("{2}(resize({0}, {1}))", "{0}", targetlengthstr, target.IsSigned ? "SIGNED" : "UNSIGNED"), target)); } } } else if (target.IsEnum && (svhdl.IsSigned || svhdl.IsUnsigned || svhdl == VHDLTypes.INTEGER)) { if (target.IsIrregularEnum) { return(WrapExpression(render, s, string.Format("fromValue_{1}({0})", svhdl == VHDLTypes.INTEGER ? "{0}" : "TO_INTEGER({0})", target.ToSafeVHDLName()), target)); } else { return(WrapExpression(render, s, string.Format("{1}'VAL({0})", svhdl == VHDLTypes.INTEGER ? "{0}" : "TO_INTEGER({0})", target.ToSafeVHDLName()), target)); } } else if (svhdl.IsEnum && (target.IsSigned || target.IsUnsigned || target == VHDLTypes.INTEGER)) { Expression wrapped; if (target.IsIrregularEnum) { wrapped = WrapExpression(render, s, string.Format("toValue_{1}({0})", "{0}", svhdl.ToSafeVHDLName()), target); } else { wrapped = WrapExpression(render, s, string.Format("{1}'POS({0})", "{0}", svhdl.ToSafeVHDLName()), target); } render.TypeLookup[wrapped] = VHDLTypes.INTEGER; if (target != VHDLTypes.INTEGER) { wrapped = ConvertExpression(render, method, wrapped, target, targetsource, false); } return(wrapped); } else { throw new Exception(string.Format("Unexpected target type: {0} for source: {1}", target, svhdl)); } }
protected void VisitAssignmentExpression() { AssignmentExpression assignmentExpression = this.AssignmentExpression; var oldAssigment = this.Emitter.IsAssignment; var oldAssigmentType = this.Emitter.AssignmentType; string variable = null; bool needReturnValue = !(assignmentExpression.Parent is ExpressionStatement); if (needReturnValue && assignmentExpression.Parent is LambdaExpression) { var lambdarr = this.Emitter.Resolver.ResolveNode(assignmentExpression.Parent, this.Emitter) as LambdaResolveResult; if (lambdarr != null && lambdarr.ReturnType.Kind == TypeKind.Void) { needReturnValue = false; } } var delegateAssigment = false; bool isEvent = false; var initCount = this.Emitter.Writers.Count; var asyncExpressionHandling = this.Emitter.AsyncExpressionHandling; this.WriteAwaiters(assignmentExpression.Left); this.WriteAwaiters(assignmentExpression.Right); var leftResolverResult = this.Emitter.Resolver.ResolveNode(assignmentExpression.Left, this.Emitter); var rightResolverResult = this.Emitter.Resolver.ResolveNode(assignmentExpression.Right, this.Emitter); var rr = this.Emitter.Resolver.ResolveNode(assignmentExpression, this.Emitter); var orr = rr as OperatorResolveResult; bool isDecimal = Helpers.IsDecimalType(rr.Type, this.Emitter.Resolver); bool isLong = Helpers.Is64Type(rr.Type, this.Emitter.Resolver); var expectedType = this.Emitter.Resolver.Resolver.GetExpectedType(assignmentExpression); bool isDecimalExpected = Helpers.IsDecimalType(expectedType, this.Emitter.Resolver); bool isLongExpected = Helpers.Is64Type(expectedType, this.Emitter.Resolver); bool isUserOperator = this.IsUserOperator(orr); bool isUint = rr.Type.IsKnownType(KnownTypeCode.UInt16) || rr.Type.IsKnownType(KnownTypeCode.UInt32) || rr.Type.IsKnownType(KnownTypeCode.UInt64); var charToString = -1; if (orr != null && orr.Type.IsKnownType(KnownTypeCode.String)) { for (int i = 0; i < orr.Operands.Count; i++) { var crr = orr.Operands[i] as ConversionResolveResult; if (crr != null && crr.Input.Type.IsKnownType(KnownTypeCode.Char)) { charToString = i; } } } var memberTargetrr = leftResolverResult as MemberResolveResult; bool isField = (memberTargetrr != null && memberTargetrr.Member is IField && (memberTargetrr.TargetResult is ThisResolveResult || memberTargetrr.TargetResult is LocalResolveResult)) || leftResolverResult is ThisResolveResult || leftResolverResult is LocalResolveResult || leftResolverResult is ConstantResolveResult; var rightMemberTargetrr = rightResolverResult as MemberResolveResult; bool isRightSimple = (rightMemberTargetrr != null && rightMemberTargetrr.Member is IField && (rightMemberTargetrr.TargetResult is ThisResolveResult || rightMemberTargetrr.TargetResult is LocalResolveResult)) || rightResolverResult is ThisResolveResult || rightResolverResult is LocalResolveResult || rightResolverResult is ConstantResolveResult; var needTempVar = needReturnValue && (!isRightSimple && !isField || assignmentExpression.Operator != AssignmentOperatorType.Assign); /*if (assignmentExpression.Operator == AssignmentOperatorType.Any) * { * needTempVar = false; * }*/ if (needReturnValue) { if (needTempVar) { variable = this.GetTempVarName(); this.Write("(" + variable + " = "); var oldValue1 = this.Emitter.ReplaceAwaiterByVar; this.Emitter.ReplaceAwaiterByVar = true; assignmentExpression.Right.AcceptVisitor(this.Emitter); this.Emitter.ReplaceAwaiterByVar = oldValue1; this.Write(", "); } else { this.Write("("); } } if (assignmentExpression.Operator == AssignmentOperatorType.Divide && this.Emitter.Rules.Integer == IntegerRule.Managed && !(this.Emitter.IsJavaScriptOverflowMode && !ConversionBlock.InsideOverflowContext(this.Emitter, assignmentExpression)) && !isLong && !isLongExpected && ( (Helpers.IsIntegerType(leftResolverResult.Type, this.Emitter.Resolver) && Helpers.IsIntegerType(rightResolverResult.Type, this.Emitter.Resolver)) || (Helpers.IsIntegerType(this.Emitter.Resolver.Resolver.GetExpectedType(assignmentExpression.Left), this.Emitter.Resolver) && Helpers.IsIntegerType(this.Emitter.Resolver.Resolver.GetExpectedType(assignmentExpression.Right), this.Emitter.Resolver)) )) { this.Emitter.IsAssignment = true; this.Emitter.AssignmentType = AssignmentOperatorType.Assign; var oldValue1 = this.Emitter.ReplaceAwaiterByVar; this.Emitter.ReplaceAwaiterByVar = true; this.AcceptLeftExpression(assignmentExpression.Left, memberTargetrr); if (this.Emitter.Writers.Count == initCount) { this.Write(" = "); } this.Emitter.ReplaceAwaiterByVar = oldValue1; this.Emitter.AssignmentType = oldAssigmentType; this.Emitter.IsAssignment = oldAssigment; this.Write(JS.Types.BRIDGE_INT + "." + JS.Funcs.Math.DIV + "("); assignmentExpression.Left.AcceptVisitor(this.Emitter); this.Write(", "); oldValue1 = this.Emitter.ReplaceAwaiterByVar; this.Emitter.ReplaceAwaiterByVar = true; assignmentExpression.Right.AcceptVisitor(this.Emitter); this.Write(")"); this.Emitter.ReplaceAwaiterByVar = oldValue1; this.Emitter.AsyncExpressionHandling = asyncExpressionHandling; if (this.Emitter.Writers.Count > initCount) { this.PopWriter(); } if (needReturnValue && !isField) { if (needTempVar) { this.Write(", " + variable); } else { this.Write(", "); this.Emitter.IsAssignment = false; assignmentExpression.Right.AcceptVisitor(this.Emitter); this.Emitter.IsAssignment = oldAssigment; } } if (needReturnValue) { this.Write(")"); } return; } if (assignmentExpression.Operator == AssignmentOperatorType.Multiply && this.Emitter.Rules.Integer == IntegerRule.Managed && !(this.Emitter.IsJavaScriptOverflowMode && !ConversionBlock.InsideOverflowContext(this.Emitter, assignmentExpression)) && !isLong && !isLongExpected && ( (Helpers.IsInteger32Type(leftResolverResult.Type, this.Emitter.Resolver) && Helpers.IsInteger32Type(rightResolverResult.Type, this.Emitter.Resolver) && Helpers.IsInteger32Type(rr.Type, this.Emitter.Resolver)) || (Helpers.IsInteger32Type(this.Emitter.Resolver.Resolver.GetExpectedType(assignmentExpression.Left), this.Emitter.Resolver) && Helpers.IsInteger32Type(this.Emitter.Resolver.Resolver.GetExpectedType(assignmentExpression.Right), this.Emitter.Resolver) && Helpers.IsInteger32Type(rr.Type, this.Emitter.Resolver)) )) { this.Emitter.IsAssignment = true; this.Emitter.AssignmentType = AssignmentOperatorType.Assign; var oldValue1 = this.Emitter.ReplaceAwaiterByVar; this.Emitter.ReplaceAwaiterByVar = true; this.AcceptLeftExpression(assignmentExpression.Left, memberTargetrr); if (this.Emitter.Writers.Count == initCount) { this.Write(" = "); } this.Emitter.ReplaceAwaiterByVar = oldValue1; this.Emitter.AssignmentType = oldAssigmentType; this.Emitter.IsAssignment = oldAssigment; isUint = NullableType.GetUnderlyingType(rr.Type).IsKnownType(KnownTypeCode.UInt32); this.Write(JS.Types.BRIDGE_INT + "." + (isUint ? JS.Funcs.Math.UMUL : JS.Funcs.Math.MUL) + "("); assignmentExpression.Left.AcceptVisitor(this.Emitter); this.Write(", "); oldValue1 = this.Emitter.ReplaceAwaiterByVar; this.Emitter.ReplaceAwaiterByVar = true; assignmentExpression.Right.AcceptVisitor(this.Emitter); if (ConversionBlock.IsInCheckedContext(this.Emitter, assignmentExpression)) { this.Write(", 1"); } this.Write(")"); this.Emitter.ReplaceAwaiterByVar = oldValue1; this.Emitter.AsyncExpressionHandling = asyncExpressionHandling; if (this.Emitter.Writers.Count > initCount) { this.PopWriter(); } if (needReturnValue && !isField) { if (needTempVar) { this.Write(", " + variable); } else { this.Write(", "); this.Emitter.IsAssignment = false; assignmentExpression.Right.AcceptVisitor(this.Emitter); this.Emitter.IsAssignment = oldAssigment; } } if (needReturnValue) { this.Write(")"); } return; } bool templateDelegateAssigment = false; if (assignmentExpression.Operator == AssignmentOperatorType.Add || assignmentExpression.Operator == AssignmentOperatorType.Subtract) { var add = assignmentExpression.Operator == AssignmentOperatorType.Add; if (this.Emitter.Validator.IsDelegateOrLambda(leftResolverResult)) { delegateAssigment = true; var leftMemberResolveResult = leftResolverResult as MemberResolveResult; if (leftMemberResolveResult != null) { isEvent = leftMemberResolveResult.Member is IEvent; this.Emitter.IsAssignment = true; this.Emitter.AssignmentType = assignmentExpression.Operator; templateDelegateAssigment = !string.IsNullOrWhiteSpace(this.Emitter.GetInline(leftMemberResolveResult.Member)); this.Emitter.IsAssignment = false; } if (!isEvent) { this.Emitter.IsAssignment = true; this.Emitter.AssignmentType = AssignmentOperatorType.Assign; this.AcceptLeftExpression(assignmentExpression.Left, memberTargetrr); this.Emitter.IsAssignment = false; if (this.Emitter.Writers.Count == initCount) { this.Write(" = "); } this.Write(add ? JS.Funcs.BRIDGE_COMBINE : JS.Funcs.BRIDGE_REMOVE); this.WriteOpenParentheses(); } } } bool nullable = orr != null && orr.IsLiftedOperator; string root = JS.Types.SYSTEM_NULLABLE + "."; bool special = nullable; this.Emitter.IsAssignment = true; this.Emitter.AssignmentType = assignmentExpression.Operator; var oldValue = this.Emitter.ReplaceAwaiterByVar; this.Emitter.ReplaceAwaiterByVar = true; bool thisAssignment = leftResolverResult is ThisResolveResult; if (!thisAssignment) { if (special || (isDecimal && isDecimalExpected) || (isLong && isLongExpected) || isUserOperator) { this.Emitter.AssignmentType = AssignmentOperatorType.Assign; } if (delegateAssigment && !isEvent) { this.Emitter.IsAssignment = false; } this.AcceptLeftExpression(assignmentExpression.Left, memberTargetrr); if (delegateAssigment) { this.Emitter.IsAssignment = true; } } else { this.Write("("); } this.Emitter.ReplaceAwaiterByVar = oldValue; this.Emitter.AssignmentType = oldAssigmentType; this.Emitter.IsAssignment = oldAssigment; if (this.Emitter.Writers.Count == initCount && !delegateAssigment && !thisAssignment) { this.WriteSpace(); } if (isDecimal && isDecimalExpected) { if (this.Emitter.Writers.Count == initCount) { this.Write("= "); } oldValue = this.Emitter.ReplaceAwaiterByVar; this.Emitter.ReplaceAwaiterByVar = true; this.HandleDecimal(rr, variable); if (this.Emitter.Writers.Count > initCount) { this.PopWriter(); } if (needTempVar) { this.Write(", " + variable + ")"); } else if (needReturnValue) { if (!isField) { this.Write(", "); this.Emitter.IsAssignment = false; assignmentExpression.Right.AcceptVisitor(this.Emitter); this.Emitter.IsAssignment = oldAssigment; } this.Write(")"); } this.Emitter.ReplaceAwaiterByVar = oldValue; return; } if (isLong && isLongExpected) { if (this.Emitter.Writers.Count == initCount) { this.Write("= "); } oldValue = this.Emitter.ReplaceAwaiterByVar; this.Emitter.ReplaceAwaiterByVar = true; this.HandleLong(rr, variable, isUint); if (this.Emitter.Writers.Count > initCount) { this.PopWriter(); } if (needTempVar) { this.Write(", " + variable + ")"); } else if (needReturnValue) { if (!isField) { this.Write(", "); this.Emitter.IsAssignment = false; assignmentExpression.Right.AcceptVisitor(this.Emitter); this.Emitter.IsAssignment = oldAssigment; } this.Write(")"); } this.Emitter.ReplaceAwaiterByVar = oldValue; return; } if (this.ResolveOperator(assignmentExpression, orr, initCount, thisAssignment)) { if (thisAssignment) { this.Write(")." + JS.Funcs.CLONE + "(this)"); } else if (needReturnValue) { this.Write(")"); } return; } bool isBool = NullableType.IsNullable(rr.Type) ? NullableType.GetUnderlyingType(rr.Type).IsKnownType(KnownTypeCode.Boolean) : rr.Type.IsKnownType(KnownTypeCode.Boolean); if (!delegateAssigment) { if (!special) { switch (assignmentExpression.Operator) { case AssignmentOperatorType.Assign: break; case AssignmentOperatorType.Add: this.Write("+"); break; case AssignmentOperatorType.BitwiseAnd: if (!isBool) { this.Write("&"); } break; case AssignmentOperatorType.BitwiseOr: if (!isBool) { this.Write("|"); } break; case AssignmentOperatorType.Divide: this.Write("/"); break; case AssignmentOperatorType.ExclusiveOr: this.Write("^"); break; case AssignmentOperatorType.Modulus: this.Write("%"); break; case AssignmentOperatorType.Multiply: this.Write("*"); break; case AssignmentOperatorType.ShiftLeft: this.Write("<<"); break; case AssignmentOperatorType.ShiftRight: this.Write(isUint ? ">>>" : ">>"); break; case AssignmentOperatorType.Subtract: this.Write("-"); break; default: throw new EmitterException(assignmentExpression, "Unsupported assignment operator: " + assignmentExpression.Operator.ToString()); } } if (special) { if (this.Emitter.Writers.Count == initCount) { this.Write("= "); } this.Write(root); switch (assignmentExpression.Operator) { case AssignmentOperatorType.Assign: break; case AssignmentOperatorType.Add: this.Write(JS.Funcs.Math.ADD); break; case AssignmentOperatorType.BitwiseAnd: this.Write(isBool ? JS.Funcs.Math.AND : JS.Funcs.Math.BAND); break; case AssignmentOperatorType.BitwiseOr: this.Write(isBool ? JS.Funcs.Math.OR : JS.Funcs.Math.BOR); break; case AssignmentOperatorType.Divide: this.Write(JS.Funcs.Math.DIV); break; case AssignmentOperatorType.ExclusiveOr: this.Write(JS.Funcs.Math.XOR); break; case AssignmentOperatorType.Modulus: this.Write(JS.Funcs.Math.MOD); break; case AssignmentOperatorType.Multiply: this.Write(JS.Funcs.Math.MUL); break; case AssignmentOperatorType.ShiftLeft: this.Write(JS.Funcs.Math.SL); break; case AssignmentOperatorType.ShiftRight: this.Write(isUint ? JS.Funcs.Math.SRR : JS.Funcs.Math.SR); break; case AssignmentOperatorType.Subtract: this.Write(JS.Funcs.Math.SUB); break; default: throw new EmitterException(assignmentExpression, "Unsupported assignment operator: " + assignmentExpression.Operator.ToString()); } this.WriteOpenParentheses(); assignmentExpression.Left.AcceptVisitor(this.Emitter); this.Write(", "); } if (this.Emitter.Writers.Count == initCount && !thisAssignment && !special) { this.Write("= "); } } else if (!isEvent) { this.WriteComma(); } if (!special && isBool && (assignmentExpression.Operator == AssignmentOperatorType.BitwiseAnd || assignmentExpression.Operator == AssignmentOperatorType.BitwiseOr)) { this.Write("!!("); assignmentExpression.Left.AcceptVisitor(this.Emitter); this.Write(assignmentExpression.Operator == AssignmentOperatorType.BitwiseAnd ? " & " : " | "); } oldValue = this.Emitter.ReplaceAwaiterByVar; this.Emitter.ReplaceAwaiterByVar = true; if (charToString == 1) { this.Write(JS.Funcs.STRING_FROMCHARCODE + "("); } if (needTempVar) { int pos = this.Emitter.Output.Length; this.Write(variable); Helpers.CheckValueTypeClone(rr, assignmentExpression.Right, this, pos); } else { var wrap = assignmentExpression.Operator != AssignmentOperatorType.Assign && this.Emitter.Writers.Count > initCount && !AssigmentExpressionHelper.CheckIsRightAssigmentExpression(assignmentExpression); if (wrap) { this.WriteOpenParentheses(); } assignmentExpression.Right.AcceptVisitor(this.Emitter); if (wrap) { this.WriteCloseParentheses(); } } if (!special && isBool && (assignmentExpression.Operator == AssignmentOperatorType.BitwiseAnd || assignmentExpression.Operator == AssignmentOperatorType.BitwiseOr)) { this.WriteCloseParentheses(); } if (charToString == 1) { this.WriteCloseParentheses(); } if (special) { this.WriteCloseParentheses(); } if (thisAssignment) { this.Write(")." + JS.Funcs.CLONE + "(this)"); } this.Emitter.ReplaceAwaiterByVar = oldValue; this.Emitter.AsyncExpressionHandling = asyncExpressionHandling; if (this.Emitter.Writers.Count > initCount) { var writerCount = this.Emitter.Writers.Count; for (int i = initCount; i < writerCount; i++) { this.PopWriter(); } } if (delegateAssigment && !templateDelegateAssigment) { this.WriteCloseParentheses(); } if (needTempVar) { this.Write(", " + variable + ")"); } else if (needReturnValue) { if (!isField) { this.Write(", "); this.Emitter.IsAssignment = false; assignmentExpression.Right.AcceptVisitor(this.Emitter); this.Emitter.IsAssignment = oldAssigment; } this.Write(")"); } }
protected override void VisitAssignmentExpression(AssignmentExpression assignmentExpression) { VisitingAssignmentExpression?.Invoke(this, assignmentExpression); base.VisitAssignmentExpression(assignmentExpression); VisitedAssignmentExpression?.Invoke(this, assignmentExpression); }
private bool IsMatch(AssignmentExpression uoe, AssignmentExpression r_uoe) { return(uoe.Op == r_uoe.Op); }
void ConvertForStatement(ForStatement forStatement) { // ForStatement -> ForNextStatement when for-loop is simple // only the following forms of the for-statement are allowed: // for (TypeReference name = start; name < oneAfterEnd; name += step) // for (name = start; name < oneAfterEnd; name += step) // for (TypeReference name = start; name <= end; name += step) // for (name = start; name <= end; name += step) // for (TypeReference name = start; name > oneAfterEnd; name -= step) // for (name = start; name > oneAfterEnd; name -= step) // for (TypeReference name = start; name >= end; name -= step) // for (name = start; name >= end; name -= step) // check if the form is valid and collect TypeReference, name, start, end and step if (forStatement.Initializers.Count != 1) { return; } if (forStatement.Iterator.Count != 1) { return; } ExpressionStatement statement = forStatement.Iterator[0] as ExpressionStatement; if (statement == null) { return; } AssignmentExpression iterator = statement.Expression as AssignmentExpression; if (iterator == null || (iterator.Op != AssignmentOperatorType.Add && iterator.Op != AssignmentOperatorType.Subtract)) { return; } IdentifierExpression iteratorIdentifier = iterator.Left as IdentifierExpression; if (iteratorIdentifier == null) { return; } PrimitiveExpression stepExpression = iterator.Right as PrimitiveExpression; if (stepExpression == null || !(stepExpression.Value is int)) { return; } int step = (int)stepExpression.Value; if (iterator.Op == AssignmentOperatorType.Subtract) { step = -step; } BinaryOperatorExpression condition = forStatement.Condition as BinaryOperatorExpression; if (condition == null || !(condition.Left is IdentifierExpression)) { return; } if ((condition.Left as IdentifierExpression).Identifier != iteratorIdentifier.Identifier) { return; } Expression end; if (iterator.Op == AssignmentOperatorType.Subtract) { if (condition.Op == BinaryOperatorType.GreaterThanOrEqual) { end = condition.Right; } else if (condition.Op == BinaryOperatorType.GreaterThan) { end = Expression.AddInteger(condition.Right, 1); } else { return; } } else { if (condition.Op == BinaryOperatorType.LessThanOrEqual) { end = condition.Right; } else if (condition.Op == BinaryOperatorType.LessThan) { end = Expression.AddInteger(condition.Right, -1); } else { return; } } Expression start; TypeReference typeReference = null; LocalVariableDeclaration varDecl = forStatement.Initializers[0] as LocalVariableDeclaration; if (varDecl != null) { if (varDecl.Variables.Count != 1 || varDecl.Variables[0].Name != iteratorIdentifier.Identifier || varDecl.Variables[0].Initializer == null) { return; } typeReference = varDecl.GetTypeForVariable(0); start = varDecl.Variables[0].Initializer; } else { statement = forStatement.Initializers[0] as ExpressionStatement; if (statement == null) { return; } AssignmentExpression assign = statement.Expression as AssignmentExpression; if (assign == null || assign.Op != AssignmentOperatorType.Assign) { return; } if (!(assign.Left is IdentifierExpression)) { return; } if ((assign.Left as IdentifierExpression).Identifier != iteratorIdentifier.Identifier) { return; } start = assign.Right; } ReplaceCurrentNode( new ForNextStatement { TypeReference = typeReference, VariableName = iteratorIdentifier.Identifier, Start = start, End = end, Step = (step == 1) ? null : new PrimitiveExpression(step, step.ToString(System.Globalization.NumberFormatInfo.InvariantInfo)), EmbeddedStatement = forStatement.EmbeddedStatement }); }
static bool CanMoveVariableUseIntoSubBlock(Statement stmt, string variableName, bool allowPassIntoLoops) { if (!allowPassIntoLoops && (stmt is ForStatement || stmt is ForeachStatement || stmt is DoWhileStatement || stmt is WhileStatement)) { return(false); } ForStatement forStatement = stmt as ForStatement; if (forStatement != null && forStatement.Initializers.Count == 1) { // for-statement is special case: we can move variable declarations into the initializer ExpressionStatement es = forStatement.Initializers.Single() as ExpressionStatement; if (es != null) { AssignmentExpression ae = es.Expression as AssignmentExpression; if (ae != null && ae.Operator == AssignmentOperatorType.Assign) { IdentifierExpression ident = ae.Left as IdentifierExpression; if (ident != null && ident.Identifier == variableName) { return(!UsesVariable(ae.Right, variableName)); } } } } UsingStatement usingStatement = stmt as UsingStatement; if (usingStatement != null) { // using-statement is special case: we can move variable declarations into the initializer AssignmentExpression ae = usingStatement.ResourceAcquisition as AssignmentExpression; if (ae != null && ae.Operator == AssignmentOperatorType.Assign) { IdentifierExpression ident = ae.Left as IdentifierExpression; if (ident != null && ident.Identifier == variableName) { return(!UsesVariable(ae.Right, variableName)); } } } IfElseStatement ies = stmt as IfElseStatement; if (ies != null) { foreach (var child in IfElseChainChildren(ies)) { if (!(child is BlockStatement) && UsesVariable(child, variableName)) { return(false); } } return(true); } // We can move the variable into a sub-block only if the variable is used in only that sub-block (and not in expressions such as the loop condition) for (AstNode child = stmt.FirstChild; child != null; child = child.NextSibling) { if (!(child is BlockStatement) && UsesVariable(child, variableName)) { if (HasNestedBlocks(child)) { // catch clauses/switch sections can contain nested blocks for (AstNode grandchild = child.FirstChild; grandchild != null; grandchild = grandchild.NextSibling) { if (!(grandchild is BlockStatement) && UsesVariable(grandchild, variableName)) { return(false); } } } else { return(false); } } } return(true); }
public virtual S VisitAssignmentExpression(AssignmentExpression assignmentExpression, T data) { return(VisitChildren(assignmentExpression, data)); }
public virtual void VisitAssignmentExpression(AssignmentExpression assignmentExpression) { VisitExpression(assignmentExpression.Left.As <Expression>()); VisitExpression(assignmentExpression.Right.As <Expression>()); }
public override void VisitAssignmentExpression(AssignmentExpression assignmentExpression) { new AssignmentBlock(this, assignmentExpression).Emit(); }
protected virtual string VisitAssignment(AssignmentExpression exp, out object resultObj) { resultObj = null; return(null); }
public override void VisitAssignmentExpression(AssignmentExpression assignmentExpression) { base.VisitAssignmentExpression(assignmentExpression); Check(assignmentExpression.Left); }
public virtual Expression VisitAssignmentExpression(AssignmentExpression assignment, AssignmentExpression changes, AssignmentExpression deletions, AssignmentExpression insertions){ this.UpdateSourceContext(assignment, changes); if (assignment == null) return changes; if (changes != null){ if (deletions == null || insertions == null) Debug.Assert(false); else{ assignment.AssignmentStatement = this.VisitAssignmentStatement(assignment.AssignmentStatement as AssignmentStatement, changes.AssignmentStatement as AssignmentStatement, deletions.AssignmentStatement as AssignmentStatement, insertions.AssignmentStatement as AssignmentStatement); } }else if (deletions != null) return null; return assignment; }
public IEnumerable <CodeAction> GetActions(RefactoringContext context) { //TODO: implement variable assignment & ctor param var varInit = context.GetNode <VariableInitializer>(); if (varInit != null) { AstType type = varInit.GetPrevNode() as AstType; if (type == null) { yield break; } if (varInit.Parent is FieldDeclaration) { yield break; } if (CannotExtractField(varInit)) { yield break; } yield return(new CodeAction(context.TranslateString("Assign to new field"), s => { var name = varInit.Name; FieldDeclaration field = new FieldDeclaration() { ReturnType = type.Clone(), Variables = { new VariableInitializer(name) } }; AstNode nodeToRemove = RemoveDeclaration(varInit) ? varInit.Parent : type; s.Remove(nodeToRemove, true); s.InsertWithCursor(context.TranslateString("Insert new field"), Script.InsertPosition.Before, field); s.FormatText(varInit.Parent); })); } var idntf = context.GetNode <Identifier>(); if (idntf == null) { yield break; } var paramDec = idntf.Parent as ParameterDeclaration; if (paramDec != null) { var ctor = paramDec.Parent as ConstructorDeclaration; if (ctor == null) { yield break; } MemberReferenceExpression thisField = new MemberReferenceExpression(new ThisReferenceExpression(), idntf.Name, new AstType[] {}); var assign = new AssignmentExpression(thisField, AssignmentOperatorType.Assign, new IdentifierExpression(idntf.Name)); var statement = new ExpressionStatement(assign); var type = (idntf.GetPrevNode() as AstType).Clone(); FieldDeclaration field = new FieldDeclaration() { ReturnType = type.Clone(), Variables = { new VariableInitializer(idntf.Name) } }; yield return(new CodeAction(context.TranslateString("Assign to new field"), s => { s.InsertWithCursor(context.TranslateString("Insert new field"), Script.InsertPosition.Before, field); s.AddTo(ctor.Body, statement); })); } }
public override object Visit (CompoundAssign compoundAssign) { var result = new AssignmentExpression (); int opLength = 2; switch (compoundAssign.Op) { case Binary.Operator.Multiply: result.AssignmentOperatorType = AssignmentOperatorType.Multiply; break; case Binary.Operator.Division: result.AssignmentOperatorType = AssignmentOperatorType.Divide; break; case Binary.Operator.Modulus: result.AssignmentOperatorType = AssignmentOperatorType.Modulus; break; case Binary.Operator.Addition: result.AssignmentOperatorType = AssignmentOperatorType.Add; break; case Binary.Operator.Subtraction: result.AssignmentOperatorType = AssignmentOperatorType.Subtract; break; case Binary.Operator.LeftShift: result.AssignmentOperatorType = AssignmentOperatorType.ShiftLeft; opLength = 3; break; case Binary.Operator.RightShift: result.AssignmentOperatorType = AssignmentOperatorType.ShiftRight; opLength = 3; break; case Binary.Operator.BitwiseAnd: result.AssignmentOperatorType = AssignmentOperatorType.BitwiseAnd; break; case Binary.Operator.BitwiseOr: result.AssignmentOperatorType = AssignmentOperatorType.BitwiseOr; break; case Binary.Operator.ExclusiveOr: result.AssignmentOperatorType = AssignmentOperatorType.ExclusiveOr; break; } result.AddChild ((INode)compoundAssign.Target.Accept (this), AssignmentExpression.LeftExpressionRole); result.AddChild (new CSharpTokenNode (Convert (compoundAssign.Location), opLength), AssignmentExpression.OperatorRole); result.AddChild ((INode)compoundAssign.Source.Accept (this), AssignmentExpression.RightExpressionRole); return result; }
public virtual void Visit(AssignmentExpression expression, TContext context) { VisitAssignmentLeftNode(expression.Left, context); VisitExpression(expression.Right, context); }
CodeAction CreateFromStatements(RefactoringContext context, List<AstNode> statements) { if (!(statements [0].Parent is Statement)) return null; return new CodeAction(context.TranslateString("Extract method"), script => { string methodName = "NewMethod"; var method = new MethodDeclaration() { ReturnType = new PrimitiveType("void"), Name = methodName, Body = new BlockStatement() }; bool usesNonStaticMember = false; foreach (var node in statements) { usesNonStaticMember |= StaticVisitor.UsesNotStaticMember(context, node); if (node is Statement) { method.Body.Add((Statement)node.Clone()); } else { method.Body.AddChildUnsafe (node.Clone (), node.Role); } } if (!usesNonStaticMember) method.Modifiers |= Modifiers.Static; var target = new IdentifierExpression(methodName); var invocation = new InvocationExpression(target); var usedVariables = VariableLookupVisitor.Analyze(context, statements); var inExtractedRegion = new VariableUsageAnalyzation (context, usedVariables); var lastStatement = statements [statements.Count - 1]; var stmt = statements [0].GetParent<BlockStatement>(); while (stmt.GetParent<BlockStatement> () != null) { stmt = stmt.GetParent<BlockStatement>(); } inExtractedRegion.SetAnalyzedRange(statements [0], lastStatement); stmt.AcceptVisitor (inExtractedRegion); var beforeExtractedRegion = new VariableUsageAnalyzation (context, usedVariables); beforeExtractedRegion.SetAnalyzedRange(statements [0].Parent, statements [0], true, false); stmt.AcceptVisitor (beforeExtractedRegion); var afterExtractedRegion = new VariableUsageAnalyzation (context, usedVariables); afterExtractedRegion.SetAnalyzedRange(lastStatement, stmt.Statements.Last(), false, true); stmt.AcceptVisitor (afterExtractedRegion); usedVariables.Sort ((l, r) => l.Region.Begin.CompareTo (r.Region.Begin)); IVariable generatedReturnVariable = null; foreach (var variable in usedVariables) { if ((variable is IParameter) || beforeExtractedRegion.Has (variable) || !afterExtractedRegion.Has (variable)) continue; generatedReturnVariable = variable; method.ReturnType = context.CreateShortType (variable.Type); method.Body.Add (new ReturnStatement (new IdentifierExpression (variable.Name))); break; } int parameterOutCount = 0; foreach (var variable in usedVariables) { if (!(variable is IParameter) && !beforeExtractedRegion.Has (variable) && !afterExtractedRegion.Has (variable)) continue; if (variable == generatedReturnVariable) continue; Expression argumentExpression = new IdentifierExpression(variable.Name); ParameterModifier mod = ParameterModifier.None; if (inExtractedRegion.GetStatus (variable) == VariableState.Changed) { if (beforeExtractedRegion.GetStatus (variable) == VariableState.None) { mod = ParameterModifier.Out; argumentExpression = new DirectionExpression(FieldDirection.Out, argumentExpression); parameterOutCount++; } else { mod = ParameterModifier.Ref; argumentExpression = new DirectionExpression(FieldDirection.Ref, argumentExpression); } } method.Parameters.Add(new ParameterDeclaration(context.CreateShortType(variable.Type), variable.Name, mod)); invocation.Arguments.Add(argumentExpression); } ParameterDeclaration parameterToTransform = null; bool transformParameterToReturn = method.ReturnType is PrimitiveType && ((PrimitiveType)method.ReturnType).Keyword == "void" && parameterOutCount == 1; if(transformParameterToReturn) { parameterToTransform = method.Parameters.First(p => p.ParameterModifier == ParameterModifier.Out); parameterToTransform.Remove(); var argumentExpression = invocation.Arguments.OfType<DirectionExpression>().First(a => a.FieldDirection == FieldDirection.Out); argumentExpression.Remove(); method.ReturnType = parameterToTransform.Type.Clone(); var argumentDecl = new VariableDeclarationStatement(parameterToTransform.Type.Clone(),parameterToTransform.Name); method.Body.InsertChildBefore(method.Body.First(),argumentDecl,BlockStatement.StatementRole); method.Body.Add(new ReturnStatement (new IdentifierExpression (parameterToTransform.Name))); } script .InsertWithCursor(context.TranslateString("Extract method"), Script.InsertPosition.Before, method) .ContinueScript(delegate { foreach (var node in statements.Skip (1)) { if (node is NewLineNode) continue; script.Remove(node); } foreach (var variable in usedVariables) { if ((variable is IParameter) || beforeExtractedRegion.Has (variable) || !afterExtractedRegion.Has (variable)) continue; if (variable == generatedReturnVariable) continue; script.InsertBefore (statements [0], new VariableDeclarationStatement (context.CreateShortType(variable.Type), variable.Name)); } Statement invocationStatement; if (generatedReturnVariable != null) { invocationStatement = new VariableDeclarationStatement (new SimpleType ("var"), generatedReturnVariable.Name, invocation); } else if(transformParameterToReturn) { invocationStatement = new AssignmentExpression(new IdentifierExpression(parameterToTransform.Name), invocation); } else { invocationStatement = invocation; } script.Replace(statements [0], invocationStatement); script.Link(target, method.NameToken); }); }, statements.First ().StartLocation, statements.Last ().EndLocation); }
public virtual void VisitAssignmentExpression(AssignmentExpression assignmentExpression) { if (this.ThrowException) { throw (Exception)this.CreateException(assignmentExpression); } }
/// <inheritdoc /> public override void Visit(AssignmentExpression assignmentExpression) { VisitDynamic(assignmentExpression.Target); WriteSpace().Write(assignmentExpression.Operator.ConvertToString()).WriteSpace(); VisitDynamic(assignmentExpression.Value); }
public override StringBuilder VisitAssignmentExpression(AssignmentExpression assignmentExpression, int data) { var result = assignmentExpression.Left.AcceptVisitor(this, data); switch (assignmentExpression.Operator) { case AssignmentOperatorType.Assign: result.Append(" = "); break; case AssignmentOperatorType.Add: result.Append(" += "); break; case AssignmentOperatorType.BitwiseAnd: result.Append(" &= "); break; case AssignmentOperatorType.BitwiseOr: result.Append(" |= "); break; case AssignmentOperatorType.Divide: result.Append(" /= "); break; case AssignmentOperatorType.ExclusiveOr: result.Append(" ^= "); break; case AssignmentOperatorType.Modulus: result.Append(" %= "); break; case AssignmentOperatorType.Multiply: result.Append(" *= "); break; case AssignmentOperatorType.ShiftLeft: result.Append(" <<= "); break; case AssignmentOperatorType.ShiftRight: result.Append(" >>= "); break; case AssignmentOperatorType.Subtract: result.Append(" -= "); break; default: throw new NotImplementedException(); } result.Append(assignmentExpression.Right.AcceptVisitor(this, data)); return result; }
protected bool ResolveOperator(AssignmentExpression assignmentExpression, OperatorResolveResult orr, int initCount) { var method = orr != null ? orr.UserDefinedOperatorMethod : null; if (method != null) { var inline = this.Emitter.GetInline(method); if (!string.IsNullOrWhiteSpace(inline)) { if (this.Emitter.Writers.Count == initCount) { this.Write("= "); } new InlineArgumentsBlock(this.Emitter, new ArgumentsInfo(this.Emitter, assignmentExpression, orr, method), inline).Emit(); if (this.Emitter.Writers.Count > initCount) { this.PopWriter(); } return(true); } else if (!this.Emitter.Validator.IsIgnoreType(method.DeclaringTypeDefinition)) { if (this.Emitter.Writers.Count == initCount) { this.Write("= "); } if (orr.IsLiftedOperator) { this.Write(Bridge.Translator.Emitter.ROOT + ".Nullable.lift("); } this.Write(BridgeTypes.ToJsName(method.DeclaringType, this.Emitter)); this.WriteDot(); this.Write(OverloadsCollection.Create(this.Emitter, method).GetOverloadName()); if (orr.IsLiftedOperator) { this.WriteComma(); } else { this.WriteOpenParentheses(); } new ExpressionListBlock(this.Emitter, new Expression[] { assignmentExpression.Left, assignmentExpression.Right }, null).Emit(); this.WriteCloseParentheses(); if (this.Emitter.Writers.Count > initCount) { this.PopWriter(); } return(true); } } return(false); }
public void VisitAssignmentExpression(AssignmentExpression assignmentExpression) { throw new NotImplementedException(); }
/// <summary> /// Applies the transformation /// </summary> /// <returns>The transformed item.</returns> /// <param name="el">The item to visit.</param> public ASTItem Transform(ASTItem el) { var uoe = el as UnaryOperatorExpression; if (uoe == null) { return(el); } var incr = new[] { ICSharpCode.Decompiler.CSharp.Syntax.UnaryOperatorType.Increment, ICSharpCode.Decompiler.CSharp.Syntax.UnaryOperatorType.Decrement, ICSharpCode.Decompiler.CSharp.Syntax.UnaryOperatorType.PostIncrement, ICSharpCode.Decompiler.CSharp.Syntax.UnaryOperatorType.PostDecrement }.Contains(uoe.Operator); if (!incr) { return(el); } var cnst = new PrimitiveExpression() { SourceExpression = uoe.SourceExpression, SourceResultType = uoe.SourceResultType.LoadType(typeof(int)), Value = 1 }; State.TypeLookup[cnst] = VHDLTypes.INTEGER; var boe = new BinaryOperatorExpression() { Left = uoe.Operand.Clone(), Right = cnst, SourceExpression = uoe.SourceExpression, SourceResultType = uoe.SourceResultType, Operator = uoe.Operator == ICSharpCode.Decompiler.CSharp.Syntax.UnaryOperatorType.Decrement || uoe.Operator == ICSharpCode.Decompiler.CSharp.Syntax.UnaryOperatorType.PostDecrement ? ICSharpCode.Decompiler.CSharp.Syntax.BinaryOperatorType.Subtract : ICSharpCode.Decompiler.CSharp.Syntax.BinaryOperatorType.Add }; State.TypeLookup[boe] = State.VHDLType(uoe.Operand); // Prepare an assignment expresion var ase = new AssignmentExpression() { Left = uoe.Operand.Clone(), Right = boe, Operator = ICSharpCode.Decompiler.CSharp.Syntax.AssignmentOperatorType.Assign, SourceExpression = uoe.SourceExpression, SourceResultType = uoe.SourceResultType }; var exps = new ExpressionStatement() { Expression = ase, }; exps.UpdateParents(); if (uoe.Operator == ICSharpCode.Decompiler.CSharp.Syntax.UnaryOperatorType.PostIncrement || uoe.Operator == ICSharpCode.Decompiler.CSharp.Syntax.UnaryOperatorType.PostDecrement) { if (uoe.Parent is ExpressionStatement || uoe.Parent is ForStatement) { // Simple "i++;" statements are replaced with i = i + 1 uoe.ReplaceWith(ase); return(ase); } else { // More complicated are split uoe.AppendStatement(exps); // Remove the operator now, as the assignment happens after uoe.ReplaceWith(uoe.Operand); return(exps); } } else { // If the left-hand-side is also the target, we can just replace // with the binary operator without needing a temporary variable if (uoe.Operand.GetTarget() != null && boe.Parent is AssignmentExpression && ((AssignmentExpression)boe.Parent).Left.GetTarget() == uoe.Operand.GetTarget()) { uoe.ReplaceWith(boe); return(boe); } else { // TODO: Can have more complex cases where // the expression is use multiple times in the same statement and some need the updated version, // others the non-updated version. // To support this, we need to seek for references to the target // and replace the references with the correct pre/post versions uoe.PrependStatement(exps); uoe.ReplaceWith(boe); return(boe); } } }
public override object Visit(CompoundAssign compoundAssign) { var result = new AssignmentExpression(); switch (compoundAssign.Op) { case Binary.Operator.Multiply: result.Operator = AssignmentOperatorType.Multiply; break; case Binary.Operator.Division: result.Operator = AssignmentOperatorType.Divide; break; case Binary.Operator.Modulus: result.Operator = AssignmentOperatorType.Modulus; break; case Binary.Operator.Addition: result.Operator = AssignmentOperatorType.Add; break; case Binary.Operator.Subtraction: result.Operator = AssignmentOperatorType.Subtract; break; case Binary.Operator.LeftShift: result.Operator = AssignmentOperatorType.ShiftLeft; break; case Binary.Operator.RightShift: result.Operator = AssignmentOperatorType.ShiftRight; break; case Binary.Operator.BitwiseAnd: result.Operator = AssignmentOperatorType.BitwiseAnd; break; case Binary.Operator.BitwiseOr: result.Operator = AssignmentOperatorType.BitwiseOr; break; case Binary.Operator.ExclusiveOr: result.Operator = AssignmentOperatorType.ExclusiveOr; break; } if (compoundAssign.Target != null) result.AddChild((Expression)compoundAssign.Target.Accept(this), AssignmentExpression.LeftRole); var location = LocationsBag.GetLocations(compoundAssign); if (location != null) { var r = AssignmentExpression.GetOperatorRole(result.Operator); result.AddChild(new CSharpTokenNode(Convert(location [0]), r), r); } if (compoundAssign.Source != null) result.AddChild((Expression)compoundAssign.Source.Accept(this), AssignmentExpression.RightRole); return result; }
public void VisitAssignment(AssignmentExpression assignment) { assignment.Left.AcceptWalker(this); assignment.Right.AcceptWalker(this); }
public override object Visit(SimpleAssign simpleAssign) { var result = new AssignmentExpression(); result.Operator = AssignmentOperatorType.Assign; if (simpleAssign.Target != null) result.AddChild((Expression)simpleAssign.Target.Accept(this), AssignmentExpression.LeftRole); var location = LocationsBag.GetLocations(simpleAssign); if (location != null) result.AddChild(new CSharpTokenNode(Convert(location [0]), AssignmentExpression.AssignRole), AssignmentExpression.AssignRole); if (simpleAssign.Source != null) { result.AddChild((Expression)simpleAssign.Source.Accept(this), AssignmentExpression.RightRole); } return result; }
protected override void VisitAssignmentExpression(AssignmentExpression assignmentExpression) { // left side skipped (imports are read-only) Visit(assignmentExpression.Right); }
public virtual void VisitAssignmentExpression (AssignmentExpression assignmentExpression) { VisitChildren (assignmentExpression); }
protected override CodeAction GetAction(RefactoringContext context, IfElseStatement node) { var match = ActionPattern.Match(node.Condition); if (!match.Success) { return(null); } var conditionExpression = match.Get <BinaryOperatorExpression>(expressionGroupName).Single(); bool isEqualityComparison = conditionExpression.Operator == BinaryOperatorType.Equality; Expression comparedNode = match.Get <Expression>(comparedNodeGroupName).Single(); Statement contentStatement; if (isEqualityComparison) { contentStatement = node.TrueStatement; if (!IsEmpty(node.FalseStatement)) { return(null); } } else { contentStatement = node.FalseStatement; if (!IsEmpty(node.TrueStatement)) { return(null); } } contentStatement = GetSimpleStatement(contentStatement); if (contentStatement == null) { return(null); } var leftExpressionPattern = PatternHelper.OptionalParentheses(comparedNode); var expressionPattern = new AssignmentExpression(leftExpressionPattern, AssignmentOperatorType.Assign, new AnyNode(valueOnNullGroupName)); var statementPattern = new ExpressionStatement(PatternHelper.OptionalParentheses(expressionPattern)); var statementMatch = statementPattern.Match(contentStatement); if (!statementMatch.Success) { return(null); } var rightSide = statementMatch.Get <Expression>(valueOnNullGroupName).Single(); return(new CodeAction(context.TranslateString("Convert if statement to ?? expression"), script => { var previousNode = node.GetPrevSibling(sibling => sibling is Statement); var previousDeclaration = previousNode as VariableDeclarationStatement; if (previousDeclaration != null && previousDeclaration.Variables.Count() == 1) { var variable = previousDeclaration.Variables.First(); var comparedNodeIdentifierExpression = comparedNode as IdentifierExpression; if (comparedNodeIdentifierExpression != null && comparedNodeIdentifierExpression.Identifier == variable.Name) { script.Replace(variable.Initializer, new BinaryOperatorExpression(variable.Initializer.Clone(), BinaryOperatorType.NullCoalescing, rightSide.Clone())); script.Remove(node); return; } } var previousExpressionStatement = previousNode as ExpressionStatement; if (previousExpressionStatement != null) { var previousAssignment = previousExpressionStatement.Expression as AssignmentExpression; if (previousAssignment != null && comparedNode.IsMatch(previousAssignment.Left)) { var newExpression = new BinaryOperatorExpression(previousAssignment.Right.Clone(), BinaryOperatorType.NullCoalescing, rightSide.Clone()); script.Replace(previousAssignment.Right, newExpression); script.Remove(node); return; } } var coalescedExpression = new BinaryOperatorExpression(comparedNode.Clone(), BinaryOperatorType.NullCoalescing, rightSide.Clone()); var newAssignment = new ExpressionStatement(new AssignmentExpression(comparedNode.Clone(), coalescedExpression)); script.Replace(node, newAssignment); }, node)); }
public override object Visit (SimpleAssign simpleAssign) { var result = new AssignmentExpression (); result.AssignmentOperatorType = AssignmentOperatorType.Assign; if (simpleAssign.Target != null) result.AddChild ((INode)simpleAssign.Target.Accept (this), AssignmentExpression.LeftExpressionRole); result.AddChild (new CSharpTokenNode (Convert (simpleAssign.Location), 1), AssignmentExpression.OperatorRole); if (simpleAssign.Source != null) { result.AddChild ((INode)simpleAssign.Source.Accept (this), AssignmentExpression.RightExpressionRole); } return result; }
public JsValue EvaluateAssignmentExpression(AssignmentExpression assignmentExpression) { var lref = EvaluateExpression(assignmentExpression.Left) as Reference; JsValue rval = _engine.GetValue(EvaluateExpression(assignmentExpression.Right)); if (lref == null) { throw new JavaScriptException(_engine.ReferenceError); } if (assignmentExpression.Operator == AssignmentOperator.Assign) // "=" { if (lref.IsStrict() && lref.GetBase().TryCast <EnvironmentRecord>() != null && (lref.GetReferencedName() == "eval" || lref.GetReferencedName() == "arguments")) { throw new JavaScriptException(_engine.SyntaxError); } _engine.PutValue(lref, rval); return(rval); } JsValue lval = _engine.GetValue(lref); switch (assignmentExpression.Operator) { case AssignmentOperator.PlusAssign: var lprim = TypeConverter.ToPrimitive(lval); var rprim = TypeConverter.ToPrimitive(rval); if (lprim.IsString() || rprim.IsString()) { lval = TypeConverter.ToString(lprim) + TypeConverter.ToString(rprim); } else { lval = TypeConverter.ToNumber(lprim) + TypeConverter.ToNumber(rprim); } break; case AssignmentOperator.MinusAssign: lval = TypeConverter.ToNumber(lval) - TypeConverter.ToNumber(rval); break; case AssignmentOperator.TimesAssign: if (lval == Undefined.Instance || rval == Undefined.Instance) { lval = Undefined.Instance; } else { lval = TypeConverter.ToNumber(lval) * TypeConverter.ToNumber(rval); } break; case AssignmentOperator.DivideAssign: lval = Divide(lval, rval); break; case AssignmentOperator.ModuloAssign: if (lval == Undefined.Instance || rval == Undefined.Instance) { lval = Undefined.Instance; } else { lval = TypeConverter.ToNumber(lval) % TypeConverter.ToNumber(rval); } break; case AssignmentOperator.BitwiseAndAssign: lval = TypeConverter.ToInt32(lval) & TypeConverter.ToInt32(rval); break; case AssignmentOperator.BitwiseOrAssign: lval = TypeConverter.ToInt32(lval) | TypeConverter.ToInt32(rval); break; case AssignmentOperator.BitwiseXOrAssign: lval = TypeConverter.ToInt32(lval) ^ TypeConverter.ToInt32(rval); break; case AssignmentOperator.LeftShiftAssign: lval = TypeConverter.ToInt32(lval) << (int)(TypeConverter.ToUint32(rval) & 0x1F); break; case AssignmentOperator.RightShiftAssign: lval = TypeConverter.ToInt32(lval) >> (int)(TypeConverter.ToUint32(rval) & 0x1F); break; case AssignmentOperator.UnsignedRightShiftAssign: lval = (uint)TypeConverter.ToInt32(lval) >> (int)(TypeConverter.ToUint32(rval) & 0x1F); break; default: throw new NotImplementedException(); } _engine.PutValue(lref, lval); return(lval); }
public void VisitAssignmentExpression(AssignmentExpression assignmentExpression) { StartNode(assignmentExpression); assignmentExpression.Left.AcceptVisitor(this); Space(policy.SpaceAroundAssignment); WriteToken(AssignmentExpression.GetOperatorRole(assignmentExpression.Operator)); Space(policy.SpaceAroundAssignment); assignmentExpression.Right.AcceptVisitor(this); EndNode(assignmentExpression); }
protected void VisitAssignmentExpression() { AssignmentExpression assignmentExpression = this.AssignmentExpression; var oldAssigment = this.Emitter.IsAssignment; var oldAssigmentType = this.Emitter.AssignmentType; string variable = null; bool needReturnValue = !(assignmentExpression.Parent is ExpressionStatement); if (needReturnValue && assignmentExpression.Parent is LambdaExpression) { var lambdarr = this.Emitter.Resolver.ResolveNode(assignmentExpression.Parent, this.Emitter) as LambdaResolveResult; if (lambdarr != null && lambdarr.ReturnType.Kind == TypeKind.Void) { needReturnValue = false; } } var delegateAssigment = false; bool isEvent = false; var initCount = this.Emitter.Writers.Count; var asyncExpressionHandling = this.Emitter.AsyncExpressionHandling; this.WriteAwaiters(assignmentExpression.Left); this.WriteAwaiters(assignmentExpression.Right); var leftResolverResult = this.Emitter.Resolver.ResolveNode(assignmentExpression.Left, this.Emitter); var rightResolverResult = this.Emitter.Resolver.ResolveNode(assignmentExpression.Right, this.Emitter); var rr = this.Emitter.Resolver.ResolveNode(assignmentExpression, this.Emitter); var orr = rr as OperatorResolveResult; bool isDecimal = Helpers.IsDecimalType(rr.Type, this.Emitter.Resolver); var expectedType = this.Emitter.Resolver.Resolver.GetExpectedType(assignmentExpression); bool isDecimalExpected = Helpers.IsDecimalType(expectedType, this.Emitter.Resolver); bool isUserOperator = this.IsUserOperator(orr); var charToString = -1; if (orr != null && orr.Type.IsKnownType(KnownTypeCode.String)) { for (int i = 0; i < orr.Operands.Count; i++) { var crr = orr.Operands[i] as ConversionResolveResult; if (crr != null && crr.Input.Type.IsKnownType(KnownTypeCode.Char)) { charToString = i; } } } if (needReturnValue) { variable = this.GetTempVarName(); this.Write("(" + variable + " = "); var oldValue1 = this.Emitter.ReplaceAwaiterByVar; this.Emitter.ReplaceAwaiterByVar = true; assignmentExpression.Right.AcceptVisitor(this.Emitter); this.Emitter.ReplaceAwaiterByVar = oldValue1; this.Write(", "); } if (assignmentExpression.Operator == AssignmentOperatorType.Divide && ( (Helpers.IsIntegerType(leftResolverResult.Type, this.Emitter.Resolver) && Helpers.IsIntegerType(rightResolverResult.Type, this.Emitter.Resolver)) || (Helpers.IsIntegerType(this.Emitter.Resolver.Resolver.GetExpectedType(assignmentExpression.Left), this.Emitter.Resolver) && Helpers.IsIntegerType(this.Emitter.Resolver.Resolver.GetExpectedType(assignmentExpression.Right), this.Emitter.Resolver)) )) { this.Emitter.IsAssignment = true; this.Emitter.AssignmentType = AssignmentOperatorType.Assign; var oldValue1 = this.Emitter.ReplaceAwaiterByVar; this.Emitter.ReplaceAwaiterByVar = true; assignmentExpression.Left.AcceptVisitor(this.Emitter); if (this.Emitter.Writers.Count == initCount) { this.Write(" = "); } this.Emitter.ReplaceAwaiterByVar = oldValue1; this.Emitter.AssignmentType = oldAssigmentType; this.Emitter.IsAssignment = oldAssigment; this.Write("Bridge.Int.div("); assignmentExpression.Left.AcceptVisitor(this.Emitter); this.Write(", "); oldValue1 = this.Emitter.ReplaceAwaiterByVar; this.Emitter.ReplaceAwaiterByVar = true; if (needReturnValue) { this.Write(variable); } else { assignmentExpression.Right.AcceptVisitor(this.Emitter); } this.Write(")"); this.Emitter.ReplaceAwaiterByVar = oldValue1; this.Emitter.AsyncExpressionHandling = asyncExpressionHandling; if (this.Emitter.Writers.Count > initCount) { this.PopWriter(); } return; } if (assignmentExpression.Operator == AssignmentOperatorType.Add || assignmentExpression.Operator == AssignmentOperatorType.Subtract) { var add = assignmentExpression.Operator == AssignmentOperatorType.Add; if (this.Emitter.Validator.IsDelegateOrLambda(leftResolverResult)) { delegateAssigment = true; var leftMemberResolveResult = leftResolverResult as MemberResolveResult; if (leftMemberResolveResult != null) { isEvent = leftMemberResolveResult.Member is DefaultResolvedEvent; } if (!isEvent) { this.Emitter.IsAssignment = true; this.Emitter.AssignmentType = AssignmentOperatorType.Assign; assignmentExpression.Left.AcceptVisitor(this.Emitter); this.Emitter.IsAssignment = false; if (this.Emitter.Writers.Count == initCount) { this.Write(" = "); } this.Write(Bridge.Translator.Emitter.ROOT + "." + (add ? Bridge.Translator.Emitter.DELEGATE_COMBINE : Bridge.Translator.Emitter.DELEGATE_REMOVE)); this.WriteOpenParentheses(); } } } bool nullable = orr != null && orr.IsLiftedOperator; string root = Bridge.Translator.Emitter.ROOT + ".Nullable."; bool special = nullable; this.Emitter.IsAssignment = true; this.Emitter.AssignmentType = assignmentExpression.Operator; var oldValue = this.Emitter.ReplaceAwaiterByVar; this.Emitter.ReplaceAwaiterByVar = true; bool thisAssignment = leftResolverResult is ThisResolveResult; if (!thisAssignment) { if (special || (isDecimal && isDecimalExpected) || isUserOperator) { this.Emitter.AssignmentType = AssignmentOperatorType.Assign; } if (delegateAssigment && !isEvent) { this.Emitter.IsAssignment = false; } assignmentExpression.Left.AcceptVisitor(this.Emitter); if (delegateAssigment) { this.Emitter.IsAssignment = true; } } else { this.Write("("); } this.Emitter.ReplaceAwaiterByVar = oldValue; this.Emitter.AssignmentType = oldAssigmentType; this.Emitter.IsAssignment = oldAssigment; if (this.Emitter.Writers.Count == 0 && !delegateAssigment && !thisAssignment) { this.WriteSpace(); } if (isDecimal && isDecimalExpected) { if (this.Emitter.Writers.Count == initCount) { this.Write(" = "); } this.HandleDecimal(rr, variable); if (this.Emitter.Writers.Count > initCount) { this.PopWriter(); } if (needReturnValue) { this.Write(", " + variable + ")"); } return; } if (this.ResolveOperator(assignmentExpression, orr, initCount)) { return; } if (!delegateAssigment) { if (!special) { switch (assignmentExpression.Operator) { case AssignmentOperatorType.Assign: break; case AssignmentOperatorType.Add: this.Write("+"); break; case AssignmentOperatorType.BitwiseAnd: this.Write("&"); break; case AssignmentOperatorType.BitwiseOr: this.Write("|"); break; case AssignmentOperatorType.Divide: this.Write("/"); break; case AssignmentOperatorType.ExclusiveOr: this.Write("^"); break; case AssignmentOperatorType.Modulus: this.Write("%"); break; case AssignmentOperatorType.Multiply: this.Write("*"); break; case AssignmentOperatorType.ShiftLeft: this.Write("<<"); break; case AssignmentOperatorType.ShiftRight: this.Write(">>"); break; case AssignmentOperatorType.Subtract: this.Write("-"); break; default: throw new EmitterException(assignmentExpression, "Unsupported assignment operator: " + assignmentExpression.Operator.ToString()); } } if (special) { if (this.Emitter.Writers.Count == initCount) { this.Write(" = "); } this.Write(root); switch (assignmentExpression.Operator) { case AssignmentOperatorType.Assign: break; case AssignmentOperatorType.Add: this.Write("add"); break; case AssignmentOperatorType.BitwiseAnd: this.Write("band"); break; case AssignmentOperatorType.BitwiseOr: this.Write("bor"); break; case AssignmentOperatorType.Divide: this.Write("div"); break; case AssignmentOperatorType.ExclusiveOr: this.Write("xor"); break; case AssignmentOperatorType.Modulus: this.Write("mod"); break; case AssignmentOperatorType.Multiply: this.Write("mul"); break; case AssignmentOperatorType.ShiftLeft: this.Write("sl"); break; case AssignmentOperatorType.ShiftRight: this.Write("sr"); break; case AssignmentOperatorType.Subtract: this.Write("sub"); break; default: throw new EmitterException(assignmentExpression, "Unsupported assignment operator: " + assignmentExpression.Operator.ToString()); } this.WriteOpenParentheses(); assignmentExpression.Left.AcceptVisitor(this.Emitter); this.Write(", "); } int count = this.Emitter.Writers.Count; if (count == 0 && !thisAssignment && !special) { this.Write("= "); } } else if (!isEvent) { this.WriteComma(); } oldValue = this.Emitter.ReplaceAwaiterByVar; this.Emitter.ReplaceAwaiterByVar = true; if (charToString == 1) { this.Write("String.fromCharCode("); } if (needReturnValue) { this.Write(variable); } else { assignmentExpression.Right.AcceptVisitor(this.Emitter); } if (charToString == 1) { this.Write(")"); } if (special) { this.WriteCloseParentheses(); } if (thisAssignment) { this.Write(").$clone(this)"); } this.Emitter.ReplaceAwaiterByVar = oldValue; this.Emitter.AsyncExpressionHandling = asyncExpressionHandling; if (this.Emitter.Writers.Count > initCount) { var writerCount = this.Emitter.Writers.Count; for (int i = initCount; i < writerCount; i++) { this.PopWriter(); } } if (delegateAssigment) { this.WriteCloseParentheses(); } if (needReturnValue) { this.Write(", " + variable + ")"); } }
public override void VisitAssignmentExpression(AssignmentExpression assignmentExpression) { base.VisitAssignmentExpression(assignmentExpression); // Only check the right side; The left side always has the type of // the variable, which is not what we want to check var rightResolveResult = context.Resolve(assignmentExpression.Right) as LocalResolveResult; if (rightResolveResult != null) { CheckForCriterion(assignmentExpression.Right, rightResolveResult.Variable); } }
public AssignmentBlock(IEmitter emitter, AssignmentExpression assignmentExpression) : base(emitter, assignmentExpression) { this.Emitter = emitter; this.AssignmentExpression = assignmentExpression; }