@Override public void visitUnaryExpr(UnaryExpr unaryExpr) { switch (unaryExpr.getOp()) { case PRE_INC: case PRE_DEC: case BNEG: case LNOT: out.append(unaryExpr.getOp().getText() + " "); break; case POST_DEC: break; default: assert false : "Unknown unary operator " + unaryExpr.getOp(); visit(unaryExpr.getExpr()); switch (unaryExpr.getOp()) { case POST_DEC: case POST_INC: out.append(" " + unaryExpr.getOp().getText()); break; case PRE_INC: break; default: assert false : "Unknown unary operator " + unaryExpr.getOp();
@Override public Expr generateExpr(IRandom generator, Expr... args) { assert args.length == getNumArguments(); return new ParenExpr(new UnaryExpr(args[0], op)); }
@Override public void visitUnaryExpr(UnaryExpr unaryExpr) { super.visitUnaryExpr(unaryExpr); // TODO: need to check, but as a first approximation a unary always returns the same type as // its argument Type argType = types.get(unaryExpr.getExpr()); if (argType != null) { types.put(unaryExpr, argType); } }
@Override public void visitUnaryExpr(UnaryExpr unaryExpr) { if (isSideEffectingUnOp(unaryExpr.getOp())) { insideLValueCount++; } super.visitUnaryExpr(unaryExpr); if (isSideEffectingUnOp(unaryExpr.getOp())) { assert insideLValueCount > 0; insideLValueCount--; } if (!isSideEffectingUnOp(unaryExpr.getOp())) { identifyMutationPoints(unaryExpr); } }
@Override public void visitUnaryExpr(UnaryExpr unaryExpr) { visitChildFromParent(unaryExpr.getExpr(), unaryExpr); }
private Optional<Integer> getAsConstant(Expr expr) { if (expr instanceof ParenExpr) { return getAsConstant(((ParenExpr)expr).getExpr()); } if (expr instanceof IntConstantExpr) { return Optional.of(Integer.valueOf(((IntConstantExpr) expr).getValue())); } if (expr instanceof UnaryExpr) { final UnaryExpr unaryExpr = (UnaryExpr) expr; switch (unaryExpr.getOp()) { case MINUS: return getAsConstant(unaryExpr.getExpr()).map(item -> -item); case PLUS: return getAsConstant(unaryExpr.getExpr()); default: return Optional.empty(); } } return Optional.empty(); }
@Override public UnaryExpr clone() { return new UnaryExpr(expr.clone(), op); }
private static void replaceLoopCounterInIncrement(Expr increment, String newLoopCounter) { ((VariableIdentifierExpr) ((UnaryExpr) increment).getExpr()).setName(newLoopCounter); }
@Override public void visitUnaryExpr(UnaryExpr unaryExpr) { if (unaryExpr.getOp().isSideEffecting()) { predicateHolds(); } super.visitUnaryExpr(unaryExpr); }
private void handleLoop(LoopStmt loopStmt) { if (containsReturn(loopStmt)) { loopStmt.setCondition( new BinaryExpr( new ParenExpr(new UnaryExpr(makeHasReturned(), UnOp.LNOT)), loopStmt.getCondition(), BinOp.LAND)); } }
@Override public boolean preconditionHolds() { if (!enclosingBlock.getStmts().contains(secondLoop)) { return false; } if (!(firstLoop.getIncrement() instanceof UnaryExpr)) { return false; } if (!(((UnaryExpr) firstLoop.getIncrement()).getExpr() instanceof VariableIdentifierExpr)) { return false; } return true; }
/** * Determines whether the given statement came from a live code injection. * * @param stmt A statement to be analysed * @return Whether the statement is injected live code or not */ public static boolean isSimpleLiveCodeInjection(Stmt stmt) { if (!(stmt instanceof ExprStmt)) { return false; } final Expr expr = ((ExprStmt) stmt).getExpr(); if (expr instanceof BinaryExpr) { if (!((BinaryExpr) expr).getOp().isSideEffecting()) { return false; } return isLiveInjectionVariableReference(((BinaryExpr) expr).getLhs()); } if (expr instanceof UnaryExpr) { if (!((UnaryExpr) expr).getOp().isSideEffecting()) { return false; } return isLiveInjectionVariableReference(((UnaryExpr) expr).getExpr()); } if (expr instanceof FunctionCallExpr) { return ((FunctionCallExpr) expr).getCallee().startsWith(Constants.LIVE_PREFIX); } return false; }
private List<Stmt> regionStackToStmts(List<List<Stmt>> regionStack) { if (regionStack.size() == 1) { return regionStack.get(0); } final List<Stmt> result = new ArrayList<>(); result.addAll(regionStack.get(0)); // Check that the remainder actually contains some statements if (regionStack.subList(1, regionStack.size()).stream().anyMatch(item -> !item.isEmpty())) { result.add(new IfStmt( new UnaryExpr(makeHasReturned(), UnOp.LNOT), new BlockStmt(regionStackToStmts( regionStack.subList(1, regionStack.size())), true), null)); } return result; }
private void findFoldZeroSubSomethingOpportunities(IAstNode parent, Expr child, Expr lhs, Expr rhs) { if (isZeroFloat(lhs)) { addReplaceWithExpr(parent, child, new ParenExpr(new UnaryExpr(rhs, UnOp.MINUS))); } final Type childType = typer.lookupType(child); final Type rhsType = typer.lookupType(rhs); if (childType != null && rhsType != null && childType.getWithoutQualifiers().equals(rhsType.getWithoutQualifiers())) { if (isZeroFloatVecOrSquareMat(lhs)) { addReplaceWithExpr(parent, child, new ParenExpr(new UnaryExpr(rhs, UnOp.MINUS))); } } }
@Override public Expr visitUnary_expression(Unary_expressionContext ctx) { if (ctx.postfix_expression() != null) { return visitPostfix_expression(ctx.postfix_expression()); } if (ctx.INC_OP() != null) { return new UnaryExpr(visitUnary_expression(ctx.unary_expression()), UnOp.PRE_INC); } if (ctx.DEC_OP() != null) { return new UnaryExpr(visitUnary_expression(ctx.unary_expression()), UnOp.PRE_DEC); } assert ctx.unary_operator() != null; return new UnaryExpr(visitUnary_expression(ctx.unary_expression()), processUnaryOperator(ctx.unary_operator())); }
new BlockStmt(Arrays.asList(BreakStmt.INSTANCE), true), null), new ExprStmt(new UnaryExpr( new VariableIdentifierExpr(limiterName), UnOp.POST_INC)));