protected override IExpression DoConvertExpression(IExpression expr) { if (lhs != null) { // expr must be a sub-expression of lhs Containers containers = new Containers(context); Containers exprContainers; IExpression newExpr = analysis.GetNewExpression(expr, containers, out exprContainers); if (newExpr != null) { // replace the assignment // expr[indices] = rhs; // with // newExpr[indices] = rhs; // expr[indices] = newExpr[indices]; IExpression replacedLhs = Builder.ReplaceExpression(lhs, expr, newExpr); IExpression ae = Builder.AssignExpr(lhs, replacedLhs); IStatement st = Builder.ExprStatement(ae); containers = Containers.RemoveUnusedLoops(containers, context, lhs); int ancIndex = containers.GetMatchingAncestorIndex(context); Containers missing = containers.GetContainersNotInContext(context, ancIndex); st = Containers.WrapWithContainers(st, missing.inputs); context.AddStatementAfterAncestorIndex(ancIndex, st); // attach the original rhs as an attribute on the new assignment IAssignExpression iae = context.FindAncestor <IAssignExpression>(); MarginalPrototype mp = new MarginalPrototype(null); mp.prototypeExpression = iae.Expression; context.OutputAttributes.Set(ae, mp); return(newExpr); } } return(base.DoConvertExpression(expr)); }
/// <summary> /// Remove assignments to variables which are copies of other variables. /// </summary> /// <param name="iae"></param> /// <returns></returns> protected override IExpression ConvertAssign(IAssignExpression iae) { IExpression copyExpr = GetCopyExpr(iae.Target); if (iae.Target is IVariableDeclarationExpression ivde) { ConvertExpression(ivde); } if (iae.Expression.Equals(copyExpr)) { return(iae); // was 'null' } // convert only right hand side IExpression expr = ConvertExpression(iae.Expression); if (ReferenceEquals(expr, iae.Expression)) { return(iae); } IAssignExpression ae = Builder.AssignExpr(); ae.Expression = expr; ae.Target = iae.Target; context.InputAttributes.CopyObjectAttributesTo(iae, context.OutputAttributes, ae); return(ae); }
protected override IExpression ConvertAssign(IAssignExpression iae) { // for(i) array[i] = rhs // becomes: // temp = CopyStorage(array) // for(i) temp[i] = rhs // for(i) array[i] = SetTo(temp[i]) IVariableDeclaration ivd = Recognizer.GetVariableDeclaration(iae.Target); string name = VariableInformation.GenerateName(context, ivd.Name + "_new"); IVariableDeclaration clone = Builder.VarDecl(name, ivd.VariableType); var cloneDeclExpr = Builder.VarDeclExpr(clone); var newTarget = Builder.ReplaceExpression(iae.Target, Builder.VarRefExpr(ivd), Builder.VarRefExpr(clone)); IExpression copyStorage = Builder.StaticGenericMethod( new Func <PlaceHolder, PlaceHolder>(ArrayHelper.CopyStorage), new[] { ivd.VariableType }, Builder.VarRefExpr(ivd)); var cloneDeclStmt = Builder.AssignStmt(cloneDeclExpr, copyStorage); context.OutputAttributes.Set(cloneDeclStmt, new Initializer()); cloneDecls.Add(cloneDeclStmt); IExpression setTo = Builder.StaticGenericMethod( new Func <PlaceHolder, PlaceHolder, PlaceHolder>(ArrayHelper.SetTo), new[] { iae.GetExpressionType() }, iae.Target, newTarget); IStatement setToStmt = Builder.AssignStmt(iae.Target, setTo); setToStmt = Containers.WrapWithContainers(setToStmt, containers); cloneUpdates.Add(setToStmt); return(Builder.AssignExpr(newTarget, iae.Expression)); }
private static bool IsNullDeclaration(IStatement state) { IExpressionStatement state_exp = state as IExpressionStatement; if (state_exp == null) { return(false); } IVariableDeclarationExpression exp_var; IAssignExpression exp_assign = state_exp.Expression as IAssignExpression; if (exp_assign != null) { // T value=nullptr; の場合 ILiteralExpression exp_lit = exp_assign.Expression as ILiteralExpression; if (exp_lit == null || exp_lit.Value != null) { return(false); } exp_var = exp_assign.Target as IVariableDeclarationExpression; } else { // T value; の場合 exp_var = state_exp.Expression as IVariableDeclarationExpression; } return(exp_var != null); }
protected override IExpression ConvertAssign(IAssignExpression iae) { if (iterationVar != null) { bool isOperatorStmt = false; foreach (var ist in context.FindAncestors <IStatement>()) { if (context.InputAttributes.Has <OperatorStatement>(ist)) { isOperatorStmt = true; break; } } if (isOperatorStmt) { // do not trace assignments to loop variables var target = Recognizer.GetTarget(iae.Target); var ivd = Recognizer.GetVariableDeclaration(target); bool isLoopVar = (ivd != null && Recognizer.GetLoopForVariable(context, ivd) != null); if (!isLoopVar) { RegisterVariable(target); } } } return(base.ConvertAssign(iae)); }
protected override IExpression ConvertAssign(IAssignExpression iae) { IExpression oldLhs = lhs; lhs = null; IExpression expr = ConvertExpression(iae.Expression); // do not replace the lhs if this is just an array create statement if (!(expr is IArrayCreateExpression)) { lhs = iae.Target; } IExpression target = ConvertExpression(iae.Target); lhs = oldLhs; if (ReferenceEquals(expr, iae.Expression) && ReferenceEquals(target, iae.Target)) { return(iae); } IAssignExpression ae = Builder.AssignExpr(); ae.Expression = expr; ae.Target = target; context.InputAttributes.CopyObjectAttributesTo(iae, context.OutputAttributes, ae); return(ae); }
protected override IExpression ConvertAssign(IAssignExpression iae) { IExpression targ = Recognizer.StripIndexers(iae.Target); if (targ is IArgumentReferenceExpression) { IArgumentReferenceExpression iare = (IArgumentReferenceExpression)targ; if (!(iae.Expression is IMethodInvokeExpression)) { Error("Cannot redefine the value of parameter '" + iare.Parameter.Name + "'."); } } IAssignExpression ae; if (iae.Expression is IArrayCreateExpression) { // We need to process the target first, rather than last, as normal ae = Builder.AssignExpr(); ae.Target = ConvertExpression(iae.Target); ae.Expression = ConvertExpression(iae.Expression); context.InputAttributes.CopyObjectAttributesTo(iae, context.OutputAttributes, ae); } else { ae = (IAssignExpression)base.ConvertAssign(iae); } if (ae.Target == null) { return(null); } return(ae); }
protected override IExpression ConvertAssign(IAssignExpression iae) { object targetDecl = Recognizer.GetArrayDeclaration(iae.Target); IStatement increment; if (this.isOperatorStatement && targetDecl is IVariableDeclaration) { IVariableDeclaration ivd = (IVariableDeclaration)targetDecl; if (analysis.onUpdate.TryGetValue(targetDecl, out increment)) { IExpression incrExpr = ((IExpressionStatement)increment).Expression; Containers containers = new Containers(context); containers.AddContainersNeededForExpression(context, incrExpr); containers = Containers.RemoveUnusedLoops(containers, context, incrExpr); containers = Containers.RemoveStochasticConditionals(containers, context); List <Containers> list; if (!containersOfUpdate.TryGetValue(targetDecl, out list)) { list = new List <Containers>(); containersOfUpdate[targetDecl] = list; } // have we already performed this update in these containers? bool alreadyDone = false; foreach (Containers prevContainers in list) { if (containers.Contains(prevContainers)) { // prevContainers is more general, i.e. has fewer containers than 'containers' alreadyDone = true; break; } } if (!alreadyDone) { list.Add(containers); // must set this attribute before the statement is wrapped context.OutputAttributes.Set(increment, new OperatorStatement()); int ancIndex = containers.GetMatchingAncestorIndex(context); Containers missing = containers.GetContainersNotInContext(context, ancIndex); increment = Containers.WrapWithContainers(increment, missing.outputs); context.AddStatementAfterAncestorIndex(ancIndex, increment); } } if (analysis.suppressUpdate.ContainsKey(ivd)) { foreach (IStatement ist in context.FindAncestors <IStatement>()) { if (context.InputAttributes.Has <OperatorStatement>(ist)) { var attr = analysis.suppressUpdate[ivd]; context.OutputAttributes.Set(ist, new HasIncrement(attr)); break; } } } } return(base.ConvertAssign(iae)); }
protected override IStatement ConvertExpressionStatement(IExpressionStatement ies) { if (parent == null) { return(ies); } bool keepIfStatement = false; // Only keep the surrounding if statement when a factor or constraint is being added. IExpression expr = ies.Expression; if (expr is IMethodInvokeExpression) { keepIfStatement = true; if (CodeRecognizer.IsInfer(expr)) { keepIfStatement = false; } } else if (expr is IAssignExpression) { keepIfStatement = false; IAssignExpression iae = (IAssignExpression)expr; IMethodInvokeExpression imie = iae.Expression as IMethodInvokeExpression; if (imie != null) { keepIfStatement = true; if (imie.Arguments.Count > 0) { // Statements that copy evidence variables should not send evidence messages. IVariableDeclaration ivd = Recognizer.GetVariableDeclaration(iae.Target); IVariableDeclaration ivdArg = Recognizer.GetVariableDeclaration(imie.Arguments[0]); if (ivd != null && context.InputAttributes.Has <DoNotSendEvidence>(ivd) && ivdArg != null && context.InputAttributes.Has <DoNotSendEvidence>(ivdArg)) { keepIfStatement = false; } } } else { expr = iae.Target; } } if (expr is IVariableDeclarationExpression) { IVariableDeclarationExpression ivde = (IVariableDeclarationExpression)expr; IVariableDeclaration ivd = ivde.Variable; keepIfStatement = CodeRecognizer.IsStochastic(context, ivd) && !context.InputAttributes.Has <DoNotSendEvidence>(ivd); } if (!keepIfStatement) { return(ies); } IConditionStatement cs = Builder.CondStmt(parent.Condition, Builder.BlockStmt()); cs.Then.Statements.Add(ies); return(cs); }
protected override IExpression ConvertAssign(IAssignExpression iae) { // if all args to a deterministic method are non-stoch or ForwardPointMass, the output is ForwardPointMass IVariableDeclaration targetVar = Recognizer.GetVariableDeclaration(iae.Target); if (targetVar == null || variablesDefinedNonPointMass.Contains(targetVar)) { return(base.ConvertAssign(iae)); } ProcessDefinition(iae.Expression, targetVar, isLhs: true); return(base.ConvertAssign(iae)); }
protected override IExpression ConvertAssign(IAssignExpression iae) { iae = (IAssignExpression)base.ConvertAssign(iae); // array allocation should not be treated as defining the variable bool shouldDelete = false; if (!(iae.Expression is IArrayCreateExpression)) { AddReplicateStatement(iae.Target, iae.Expression, ref shouldDelete); } return(shouldDelete ? null : iae); }
private void ForEachAttributeOfCodeElementAndContents(object codeElement, Action <ICompilerAttribute> action) { if ((attributes == null) || (codeElement == null)) { return; } foreach (var attr in attributes.GetAll <ICompilerAttribute>(codeElement)) { action(attr); } if (codeElement is IStatement) { if (codeElement is IExpressionStatement) { IExpressionStatement ies = (IExpressionStatement)codeElement; ForEachAttributeOfCodeElement(ies.Expression, action); if (ies.Expression is IVariableDeclarationExpression) { ForEachAttributeOfCodeElement(((IVariableDeclarationExpression)ies.Expression).Variable, action); } else if (ies.Expression is IAssignExpression) { IAssignExpression iae = (IAssignExpression)ies.Expression; if (iae.Target is IVariableDeclarationExpression) { ForEachAttributeOfCodeElement(((IVariableDeclarationExpression)iae.Target).Variable, action); } if (iae.Expression is IMethodInvokeExpression) { ForEachAttributeOfCodeElement(iae.Expression, action); } } } else if (codeElement is IForStatement) { IForStatement ifs = (IForStatement)codeElement; ForEachAttributeOfCodeElementAndContents(ifs.Initializer, action); IBinaryExpression ibe = (IBinaryExpression)ifs.Condition; ForEachAttributeOfCodeElementAndContents(ibe.Right, action); } } if (codeElement is IMethodDeclaration) { IMethodDeclaration imd = (IMethodDeclaration)codeElement; foreach (IParameterDeclaration ipd in imd.Parameters) { ForEachAttributeOfCodeElement(ipd, action); } } }
/// <summary> /// When array creations are assigned to stochastic arrays, this creates corresponding arrays for the marginal and uses channels. /// </summary> /// <param name="iace"></param> /// <returns></returns> protected override IExpression ConvertArrayCreate(IArrayCreateExpression iace) { IAssignExpression iae = context.FindAncestor <IAssignExpression>(); if (iae == null) { return(iace); } if (iae.Expression != iace) { return(iace); } IVariableDeclaration ivd = Recognizer.GetVariableDeclaration(iae.Target); VariableToChannelInformation vtci = context.InputAttributes.Get <VariableToChannelInformation>(ivd); if (vtci == null) { return(iace); // not a stochastic variable } // Check if this is the last level of indexing bool lastLevel = (!(iace.Type is IArrayType)); if ((lastLevel) && (vtci.usesEqualDefsStatements != null)) { if (vtci.IsUsesEqualDefsStatementInserted) { //Error("Duplicate array allocation."); } else { // Insert the UsesEqualDef statement after the array is fully allocated. // Note the array elements will not have been defined yet. LoopContext lc = context.InputAttributes.Get <LoopContext>(ivd); RefLoopContext rlc = lc.GetReferenceLoopContext(context); // IMPORTANT TODO: add this statement at the right level! IStatement ist = context.FindAncestor <IStatement>(); if (rlc.loops.Count > 0) { ist = rlc.loops[0]; } int ancIndex = context.GetAncestorIndex(ist); Containers containers = context.InputAttributes.Get <Containers>(ivd); Containers containersNeeded = containers.GetContainersNotInContext(context, ancIndex); vtci.usesEqualDefsStatements = Containers.WrapWithContainers(vtci.usesEqualDefsStatements, containersNeeded.outputs); context.AddStatementsAfter(ist, vtci.usesEqualDefsStatements); vtci.IsUsesEqualDefsStatementInserted = true; } } return(iace); }
/// <summary> /// Convert random assignments to derived variables /// </summary> /// <param name="iae"></param> /// <returns></returns> protected override IExpression ConvertAssign(IAssignExpression iae) { iae = (IAssignExpression)base.ConvertAssign(iae); IStatement ist = context.FindAncestor <IStatement>(); if (!context.InputAttributes.Has <Models.Constraint>(ist) && (iae.Expression is IMethodInvokeExpression)) { IMethodInvokeExpression imie = (IMethodInvokeExpression)iae.Expression; IVariableDeclaration ivd = Recognizer.GetVariableDeclaration(iae.Target); if (ivd != null) { bool isDerived = context.InputAttributes.Has <DerivedVariable>(ivd); if (isDerived) { FactorManager.FactorInfo info = CodeRecognizer.GetFactorInfo(context, imie); if (!info.IsDeterministicFactor) { // The variable is derived, but this definition is not derived. // Thus we must convert // y = sample() // into // y_random = sample() // y = Copy(y_random) // where y_random is not derived. VariableInformation varInfo = VariableInformation.GetVariableInformation(context, ivd); IList <IStatement> stmts = Builder.StmtCollection(); string name = ivd.Name + "_random" + (Count++); List <IList <IExpression> > indices = Recognizer.GetIndices(iae.Target); IVariableDeclaration cloneVar = varInfo.DeriveIndexedVariable(stmts, context, name, indices, copyInitializer: true); context.OutputAttributes.Remove <DerivedVariable>(cloneVar); stmts.Add(Builder.AssignStmt(Builder.VarRefExpr(cloneVar), iae.Expression)); int ancIndex = context.FindAncestorIndex <IStatement>(); context.AddStatementsBeforeAncestorIndex(ancIndex, stmts); Type tp = iae.Target.GetExpressionType(); if (tp == null) { Error("Could not determine type of expression: " + iae.Target); return(iae); } IExpression copy = Builder.StaticGenericMethod(new Func <PlaceHolder, PlaceHolder>(Clone.Copy), new Type[] { tp }, Builder.VarRefExpr(cloneVar)); iae = Builder.AssignExpr(iae.Target, copy); } } } } return(iae); }
protected override IExpression ConvertAssign(IAssignExpression iae) { var oldTargets = targetsOfCurrentAssignment; targetsOfCurrentAssignment = new Set <IExpression>(ReferenceEqualityComparer <IExpression> .Instance); iae = (IAssignExpression)base.ConvertAssign(iae); targetsOfCurrentAssignment.Add(iae.Target); IExpression rhs = iae.Expression; bool shouldDelete = false; foreach (IExpression target in targetsOfCurrentAssignment) { ProcessAssign(target, rhs, ref shouldDelete); } targetsOfCurrentAssignment = oldTargets; return(shouldDelete ? null : iae); }
protected override IExpression ConvertAssign(IAssignExpression iae) { // set index variables on the converted target, using the unconverted lhs indices // this code is copied from ModelAnalysisTransform IAssignExpression ae = (IAssignExpression)base.ConvertAssign(iae); IParameterDeclaration ipd = null; IVariableDeclaration ivd = Recognizer.GetVariableDeclaration(ae.Target); if (ivd == null) { ipd = Recognizer.GetParameterDeclaration(ae.Target); if (ipd == null) { return(ae); } } if (iae.Target is IArrayIndexerExpression) { // Gather index variables from the left-hand side of the assignment object decl = (ipd == null) ? (object)ivd : ipd; VariableInformation vi = VariableInformation.GetVariableInformation(context, decl); try { List <IVariableDeclaration[]> indVars = new List <IVariableDeclaration[]>(); Recognizer.AddIndexers(context, indVars, iae.Target); // Sets the size of this variable at this array depth int depth = Recognizer.GetIndexingDepth(iae.Target); // if this statement is actually a constraint, then we don't need to enforce matching of index variables bool isConstraint = context.InputAttributes.Has <Models.Constraint>(context.FindAncestor <IStatement>()); for (int i = 0; i < depth; i++) { vi.SetIndexVariablesAtDepth(i, indVars[i], allowMismatch: isConstraint); } } catch (Exception ex) { Error(ex.Message, ex); } if (!context.InputAttributes.Has <VariableInformation>(decl)) { context.InputAttributes.Set(decl, vi); } } return(ae); }
public override bool Equals(object obj) { if (this == obj) { return(true); } IAssignExpression expression = obj as IAssignExpression; if (expression == null) { return(false); } return (this.Expression.Equals(expression.Expression) && this.Target.Equals(expression.Target)); }
internal static ConditionBinding GetInitializerBinding(IForStatement ifs) { IStatement ist = ifs.Initializer; if (ist is IBlockStatement) { if (((IBlockStatement)ist).Statements.Count != 1) { throw new Exception("Unhandled loop initializer: " + ist); } ist = ((IBlockStatement)ist).Statements[0]; } IExpressionStatement init = (IExpressionStatement)ist; IAssignExpression iae = (IAssignExpression)init.Expression; IVariableDeclaration ivd = Recognizer.GetVariableDeclaration(iae.Target); return(new ConditionBinding(Builder.VarRefExpr(ivd), iae.Expression)); }
//CodeTransformer ct = new CodeTransformer(); protected Node AddNode(GraphWriter g, IStatement ist, Stage stage) { if (ist is ICommentStatement) { return(null); } Node nd = GetNodeForStatement(ist, stage); if (nd != null) { nd.Label = Count + "," + nd.Label; Count++; return(nd); } DependencyInformation di = context.InputAttributes.Get <DependencyInformation>(ist); if ((di != null) && (di.IsOutput)) { return(null); } string s = Count + ". " + StatementLabel(ist); nd = g.AddNode("node" + Count); nd.UserData = Count++; SetNodeForStatement(ist, stage, nd); //if (di.IsOutput) nd.Fillcolor = Color.LightBlue; nd.Label = s; if (stage == Stage.Initialisation) { nd.FillColor = Color.LightGray; } if (ist is IExpressionStatement) { IExpressionStatement ies = (IExpressionStatement)ist; IAssignExpression iae = ies.Expression as IAssignExpression; if ((iae != null) && (iae.Target is IVariableDeclarationExpression)) { nd.BorderWidth = 2; } } nd.Shape = ShapeStyle.Box; nd.FontSize = 9; return(nd); }
protected override IExpression ConvertAssign(IAssignExpression iae) { iae = (IAssignExpression)base.ConvertAssign(iae); if (iae.Target is IArrayIndexerExpression target && iae.Expression is IObjectCreateExpression ioce) { IExpression parent = target.Target; Type type = Builder.ToType(ioce.Type); if (MessageTransform.IsFileArray(type) && MessageTransform.IsFileArray(parent.GetExpressionType()) && ioce.Arguments.Count == 2) { // change new FileArray(name, dimensions) into FileArray(parent, index, dimensions) IList <IExpression> args = Builder.ExprCollection(); args.Add(target.Target); args.AddRange(target.Indices); args.Add(ioce.Arguments[1]); return(Builder.AssignExpr(target, Builder.NewObject(type, args))); } } return(iae); }
protected override IExpression ConvertAssign(IAssignExpression iae) { if (loggingAction != null) { if (iae.Expression is IArrayCreateExpression || iae.Expression is IObjectCreateExpression) { string name = iae.Target.ToString(); if (!name.Contains("_local") && !(iae.Target is IArrayIndexerExpression)) { var message = Builder.LiteralExpr("Allocating " + name); var invoke = Builder.DelegateInvokeExpr(); invoke.Target = loggingAction; invoke.Arguments.Add(message); context.AddStatementAfterCurrent(Builder.ExprStatement(invoke)); } } } return(base.ConvertAssign(iae)); }
private NodeInfo GetNodeInfo(IExpression factor) { IExpression target = null; IMethodInvokeExpression imie; if (factor is IAssignExpression) { IAssignExpression iae = (IAssignExpression)factor; target = iae.Target; if (target is IVariableDeclarationExpression) { IVariableDeclaration ivd = Recognizer.GetVariableDeclaration(target); target = Builder.VarRefExpr(ivd); } imie = (IMethodInvokeExpression)iae.Expression; } else { imie = (IMethodInvokeExpression)factor; } NodeInfo info = new NodeInfo(imie); info.info = CodeRecognizer.GetFactorInfo(context, imie); if (target != null) { info.isReturnOrOut.Add(true); info.arguments.Add(target); } if (!info.info.Method.IsStatic) { info.isReturnOrOut.Add(false); info.arguments.Add(imie.Method.Target); } foreach (IExpression arg in imie.Arguments) { bool isOut = (arg is IAddressOutExpression); info.isReturnOrOut.Add(isOut); info.arguments.Add(isOut ? ((IAddressOutExpression)arg).Expression : arg); } return(info); }
protected override IStatement ConvertExpressionStatement(IExpressionStatement ies) { if (ies.Expression is IAssignExpression) { IAssignExpression iae = (IAssignExpression)ies.Expression; if (iae.Expression is IMethodInvokeExpression) { factorExprs.Add(ies.Expression); } } else if (ies.Expression is IMethodInvokeExpression) { IMethodInvokeExpression imie = (IMethodInvokeExpression)ies.Expression; if (CodeRecognizer.IsInfer(imie)) { return(ies); } factorExprs.Add(ies.Expression); } return(ies); }
/// <summary> /// Attach DerivedVariable attributes to newly created variables /// </summary> /// <param name="iae"></param> /// <returns></returns> protected override IExpression ConvertAssign(IAssignExpression iae) { iae = (IAssignExpression)base.ConvertAssign(iae); if (iae.Expression is IMethodInvokeExpression imie) { IVariableDeclaration ivd = Recognizer.GetVariableDeclaration(iae.Target); if (ivd != null) { bool isDerived = context.InputAttributes.Has <DerivedVariable>(ivd); if (!isDerived) { FactorManager.FactorInfo info = CodeRecognizer.GetFactorInfo(context, imie); if (info.IsDeterministicFactor) { context.InputAttributes.Set(ivd, new DerivedVariable()); } } } } return(iae); }
//=========================================================== // 構文合致: function-try-statement // 判定が難しい為之は延期 // ・catch 等から抜ける全てのパスで throw しているか確認しなければならない //=========================================================== public static bool IsFunctionTry(IStatementCollection states) { if (states == null || states.Count == 0) { return(false); } // 前に連なっても OK なのは T var=nullptr のみ (この場合には最初の使用時に T も一緒に表示させなければならない...) int last = states.Count - 1; for (int i = 0; i < last; i++) { IExpressionStatement state_exp = states[i] as IExpressionStatement; if (state_exp == null) { return(false); } IAssignExpression exp_assign = state_exp.Expression as IAssignExpression; if (exp_assign == null) { return(false); } IVariableDeclaration decl = exp_assign.Target as IVariableDeclaration; if (decl == null) { return(false); } ILiteralExpression exp_lit = exp_assign.Expression as ILiteralExpression; if (exp_lit == null || exp_lit.Value != null) { return(false); } } return(false); }
//=========================================================== // 細かい関数 //=========================================================== private static void RemoveNullDeclaration(string name, Gen::List <IStatement> yields) { for (int i = 0, iM = yields.Count; i < iM; i++) { IExpressionStatement state_exp = yields[i] as IExpressionStatement; if (state_exp == null) { continue; } IVariableDeclarationExpression exp_var; IAssignExpression exp_assign = state_exp.Expression as IAssignExpression; if (exp_assign != null) { // T value=nullptr; の場合 ILiteralExpression exp_lit = exp_assign.Expression as ILiteralExpression; if (exp_lit == null || exp_lit.Value != null) { continue; } exp_var = exp_assign.Target as IVariableDeclarationExpression; } else { // T value; の場合 exp_var = state_exp.Expression as IVariableDeclarationExpression; } if (exp_var == null || exp_var.Variable.Name != name) { continue; } yields.RemoveAt(i); break; } }
protected override IExpression ConvertAssign(IAssignExpression iae) { IParameterDeclaration ipd = null; IVariableDeclaration ivd = Recognizer.GetVariableDeclaration(iae.Target); if (ivd == null) { ipd = Recognizer.GetParameterDeclaration(iae.Target); if (ipd == null) { return(base.ConvertAssign(iae)); } } IAssignExpression ae = (IAssignExpression)base.ConvertAssign(iae); if (ipd == null && !context.InputAttributes.Has <IsInferred>(ivd)) { // assignment to a local variable if (ae.Expression is ILiteralExpression) { bool isLoopInitializer = (Recognizer.GetAncestorIndexOfLoopBeingInitialized(context) != -1); if (!isLoopInitializer) { Type valueType = ae.Expression.GetExpressionType(); if (Quoter.ShouldInlineType(valueType)) { // inline all future occurrences of this variable with the rhs expression conditionContext.Add(new ConditionBinding(ae.Target, ae.Expression)); } } } } else { // assignment to a method parameter } return(ae); }
protected override IExpression ConvertAssign(IAssignExpression iae) { int index = assignmentIndex; assignmentIndex++; var ae = (IAssignExpression)base.ConvertAssign(iae); if (ae != null) { var lhsLiveness = liveness[index]; if (lhsLiveness == LivenessAnalysisTransform.Liveness.Unused) { return(null); } else if (lhsLiveness == LivenessAnalysisTransform.Liveness.Dead) { //Trace.WriteLine($"dead assign: {iae}"); if (ae.Target is IVariableDeclarationExpression) { if (ae.Expression is IDefaultExpression) { return(ae); } else { return(Builder.AssignExpr(ae.Target, Builder.DefaultExpr(ae.Target.GetExpressionType()))); } } else { return(null); } } } return(ae); }
/// <summary> /// Assignments to non-stochastic non-loop integer variables are added to the conditionContext /// </summary> /// <param name="iae"></param> /// <returns></returns> protected override IExpression ConvertAssign(IAssignExpression iae) { IExpression expr = ConvertExpression(iae.Expression); IExpression target = ConvertExpression(iae.Target); IVariableDeclaration ivd = Recognizer.GetVariableDeclaration(target); if (ivd != null) { var varInfo = VariableInformation.GetVariableInformation(context, ivd); if (!varInfo.IsStochastic && varInfo.varType.Equals(typeof(int)) && Recognizer.GetLoopForVariable(context, ivd) == null) { // add the assignment as a binding if (target is IVariableDeclarationExpression ivde) { target = Builder.VarRefExpr(ivde.Variable); } ConditionBinding binding = new ConditionBinding(target, expr); conditionContext.Add(binding); // when current lexical scope ends, remove this binding? // no, because locals aren't correctly scoped yet } } return(iae); }
public virtual IExpression TransformAssignExpression(IAssignExpression value) { value.Target = this.TransformExpression(value.Target); value.Expression = this.TransformExpression(value.Expression); return value; }
protected override IExpression ConvertAssign(IAssignExpression iae) { foreach (IStatement stmt in context.FindAncestors <IStatement>()) { // an initializer statement may perform a copy, but it is not valid to replace the lhs // in that case. if (context.InputAttributes.Has <Initializer>(stmt)) { return(iae); } } // Look for assignments where the right hand side is a SetTo call if (iae.Expression is IMethodInvokeExpression imie) { bool isCopy = Recognizer.IsStaticGenericMethod(imie, new Func <PlaceHolder, PlaceHolder>(Clone.Copy)); bool isSetTo = Recognizer.IsStaticGenericMethod(imie, typeof(ArrayHelper), "SetTo"); bool isSetAllElementsTo = Recognizer.IsStaticGenericMethod(imie, typeof(ArrayHelper), "SetAllElementsTo"); bool isGetItemsPoint = Recognizer.IsStaticGenericMethod(imie, typeof(GetItemsPointOp <>), "ItemsAverageConditional"); bool isGetJaggedItemsPoint = Recognizer.IsStaticGenericMethod(imie, typeof(GetJaggedItemsPointOp <>), "ItemsAverageConditional"); bool isGetDeepJaggedItemsPoint = Recognizer.IsStaticGenericMethod(imie, typeof(GetDeepJaggedItemsPointOp <>), "ItemsAverageConditional"); bool isGetItemsFromJaggedPoint = Recognizer.IsStaticGenericMethod(imie, typeof(GetItemsFromJaggedPointOp <>), "ItemsAverageConditional"); bool isGetItemsFromDeepJaggedPoint = Recognizer.IsStaticGenericMethod(imie, typeof(GetItemsFromDeepJaggedPointOp <>), "ItemsAverageConditional"); bool isGetJaggedItemsFromJaggedPoint = Recognizer.IsStaticGenericMethod(imie, typeof(GetJaggedItemsFromJaggedPointOp <>), "ItemsAverageConditional"); if (isCopy || isSetTo || isSetAllElementsTo || isGetItemsPoint || isGetJaggedItemsPoint || isGetDeepJaggedItemsPoint || isGetJaggedItemsFromJaggedPoint || isGetItemsFromJaggedPoint || isGetItemsFromDeepJaggedPoint) { IVariableDeclaration ivd = Recognizer.GetVariableDeclaration(iae.Target); // Find the condition context var ifs = context.FindAncestors <IConditionStatement>(); var condContext = new List <IConditionStatement>(); foreach (var ifSt in ifs) { if (!CodeRecognizer.IsStochastic(context, ifSt.Condition)) { condContext.Add(ifSt); } } var copyAttr = context.InputAttributes.GetOrCreate <CopyOfAttribute>(ivd, () => new CopyOfAttribute()); IExpression rhs; if (isSetTo || isSetAllElementsTo) { // Mark as copy of the second argument rhs = imie.Arguments[1]; } else { // Mark as copy of the first argument rhs = imie.Arguments[0]; } InitialiseTo init = context.InputAttributes.Get <InitialiseTo>(ivd); if (init != null) { IVariableDeclaration ivdRhs = Recognizer.GetVariableDeclaration(rhs); InitialiseTo initRhs = (ivdRhs == null) ? null : context.InputAttributes.Get <InitialiseTo>(ivdRhs); if (initRhs == null || !initRhs.initialMessagesExpression.Equals(init.initialMessagesExpression)) { // Do not replace a variable with a unique initialiser return(iae); } } var initBack = context.InputAttributes.Get <InitialiseBackwardTo>(ivd); if (initBack != null && !(initBack.initialMessagesExpression is IArrayCreateExpression)) { IVariableDeclaration ivdRhs = Recognizer.GetVariableDeclaration(rhs); InitialiseBackwardTo initRhs = (ivdRhs == null) ? null : context.InputAttributes.Get <InitialiseBackwardTo>(ivdRhs); if (initRhs == null || !initRhs.initialMessagesExpression.Equals(init.initialMessagesExpression)) { // Do not replace a variable with a unique initialiser return(iae); } } if (isCopy || isSetTo) { RemoveMatchingSuffixes(iae.Target, rhs, condContext, out IExpression lhsPrefix, out IExpression rhsPrefix); copyAttr.copyMap[lhsPrefix] = new CopyOfAttribute.CopyContext { Expression = rhsPrefix, ConditionContext = condContext }; } else if (isSetAllElementsTo) { copyAttr.copiedInEveryElementMap[iae.Target] = new CopyOfAttribute.CopyContext { Expression = rhs, ConditionContext = condContext }; } else if (isGetItemsPoint || isGetJaggedItemsPoint || isGetDeepJaggedItemsPoint || isGetItemsFromJaggedPoint || isGetItemsFromDeepJaggedPoint || isGetJaggedItemsFromJaggedPoint) { var target = ((IArrayIndexerExpression)iae.Target).Target; int inputDepth = imie.Arguments.Count - 3; List <IExpression> indexExprs = new List <IExpression>(); for (int i = 0; i < inputDepth; i++) { indexExprs.Add(imie.Arguments[1 + i]); } int outputDepth; if (isGetDeepJaggedItemsPoint) { outputDepth = 3; } else if (isGetJaggedItemsPoint || isGetJaggedItemsFromJaggedPoint) { outputDepth = 2; } else { outputDepth = 1; } copyAttr.copyAtIndexMap[target] = new CopyOfAttribute.CopyContext2 { Depth = outputDepth, ConditionContext = condContext, ExpressionAtIndex = (lhsIndices) => { return(Builder.JaggedArrayIndex(rhs, indexExprs.ListSelect(indexExpr => new[] { Builder.JaggedArrayIndex(indexExpr, lhsIndices) }))); } }; } else { throw new NotImplementedException(); } } } return(iae); }
private void WriteAssignExpression(IAssignExpression value, IFormatter formatter) { IBinaryExpression binaryExpression = value.Expression as IBinaryExpression; if (binaryExpression != null) { if (value.Target.Equals(binaryExpression.Left)) { string operatorText = string.Empty; switch (binaryExpression.Operator) { case BinaryOperator.Add: operatorText = "inc"; break; case BinaryOperator.Subtract: operatorText = "dec"; break; } if (operatorText.Length != 0) { // Op(a,b) formatter.Write(operatorText); formatter.Write("("); this.WriteExpression(value.Target, formatter); formatter.Write(","); formatter.Write(" "); this.WriteExpression(binaryExpression.Right, formatter); formatter.Write(")"); return; } } } IPropertyReferenceExpression propExpression = value.Target as IPropertyReferenceExpression; if (propExpression != null) { if (propExpression.Target != null) { this.WriteTargetExpression(propExpression.Target, formatter); formatter.Write("."); } var s = propExpression.Property.Resolve().SetMethod; WriteMethodReference(s, formatter); formatter.Write("("); this.WriteExpression(value.Expression, formatter); formatter.Write(")"); } else { // x := y + z this.WriteExpression(value.Target, formatter); formatter.Write(" = "); this.WriteExpression(value.Expression, formatter); } }
public virtual void VisitAssignExpression(IAssignExpression value) { this.VisitExpression(value.Target); this.VisitExpression(value.Expression); }