private static Op subst(Op subOp, Var find, Var replace) { Op op = Substitute.substitute(subOp, find, replace); return OpAssign.assign(op, find, new ExprVar(replace)); } }
/** * rewrites the subop of assign. */ @Override public void visit(final OpAssign opAssign) { if (LOG.isDebugEnabled()) { LOG.debug("Starting visiting OpAssign"); } addOp(OpAssign.assign(rewriteOp1(opAssign), opAssign.getVarExprList())); }
private static Op subst(Op subOp, Var find, Var replace) { Op op = Substitute.substitute(subOp, find, replace); return OpAssign.assign(op, find, new ExprVar(replace)); } }
private static Op subst(Op subOp, Var var, NodeValue nv) { Op op = Substitute.substitute(subOp, var, nv.asNode()); return OpAssign.assign(op, var, nv); }
@Override public Op transform(OpAssign opAssign, Op subOp) { VarExprList varExprList2 = transformVarExprList(opAssign.getVarExprList()); if ( varExprList2.isEmpty() ) return subOp; return OpAssign.assign(subOp, varExprList2); }
@Override public Op transform(OpAssign opAssign, Op subOp) { VarExprList varExprList = opAssign.getVarExprList(); VarExprList varExprList2 = NodeTransformLib.transformVars(transform, varExprList); if ( varExprList == varExprList2 ) return super.transform(opAssign, subOp); return OpAssign.assign(subOp, varExprList2); }
@Override public Op transform(OpAssign opAssign, Op subOp) { if (subOp instanceof OpAssign) { // If a variable is assigned twice, don't do anything. // (assign (?x 2) (assign (?x 1) op)) => leave alone. // This is the safest option in a rare case. // It would be OK if addAll does a replacement without checking // but having it check and complain about duplicates adds robustness. // In OpExtend, it's actually illegal. OpAssign x = (OpAssign)subOp ; VarExprList outerVarExprList = opAssign.getVarExprList() ; VarExprList innerVarExprList = new VarExprList(x.getVarExprList()) ; // Copy Op r = OpAssign.assign(x.getSubOp(), innerVarExprList) ; // This contains an "if already (assign)" test. r = OpAssign.assign(r, outerVarExprList) ; return r ; } return super.transform(opAssign, subOp); }
@Override public Op transform(OpAssign opAssign, Op subOp) { VarExprList assignments = processAssignments(opAssign); if (assignments == null) return super.transform(opAssign, subOp); // Rewrite appropriately if (this.topmostOnly) { // If topmost only ignore any transformations lower down the tree // hence call getSubOp() rather than using the provided subOp if (assignments.size() > 0) { return OpAssign.assign(opAssign.getSubOp(), assignments); } else { return opAssign.getSubOp(); } } else { // Otherwise preserve any transformations from lower down the tree if (assignments.size() > 0) { return OpAssign.assign(subOp, assignments); } else { return subOp; } } }
@Override public void visit(OpAssign opAssign) { opAssign.getSubOp().visit(this); push(OpAssign.assign(pop(), rewrite(opAssign.getVarExprList()))); }
@Override public void visit(OpAssign opAssign) { opAssign.getSubOp().visit(this); push(OpAssign.assign(pop(), rewrite(opAssign.getVarExprList()))); }
op = OpAssign.assign(op, Var.alloc(actualName), new ExprVar(rewriteName)) ;
op = OpAssign.assign(op, Var.alloc(actualName), new ExprVar(rewriteName)) ;
return OpAssign.assign(current, assign.getVar(), assign.getExpr()) ;