@Override
protected String declareConversionFunction(
final ILocation loc, final CPrimitive oldType, final CPrimitive newType) {
final String functionName = "convert" + oldType.toString() + "To" + newType.toString();
final String prefixedFunctionName = "~" + functionName;
if (!mFunctionDeclarations.getDeclaredFunctions().containsKey(prefixedFunctionName)) {
final Attribute[] attributes;
final ASTType paramASTType = mTypeHandler.ctype2asttype(loc, oldType);
if (newType.isFloatingType()) {
attributes =
generateAttributes(loc, mOverapproximateFloatingPointOperations, "to_real", null);
} else if (newType.isIntegerType()) {
attributes =
generateAttributes(loc, mOverapproximateFloatingPointOperations, "to_int", null);
} else {
throw new AssertionError("unhandled case");
}
final ASTType[] params = new ASTType[] {paramASTType};
final ASTType resultASTType = mTypeHandler.ctype2asttype(loc, newType);
mFunctionDeclarations.declareFunction(
loc, prefixedFunctionName, attributes, resultASTType, params);
}
return prefixedFunctionName;
}
@Override
public Expression constructArithmeticFloatingPointExpression(
final ILocation loc,
final int nodeOperator,
final Expression exp1,
final CPrimitive type1,
final Expression exp2,
final CPrimitive type2) {
if (mOverapproximateFloatingPointOperations) {
final String functionName = "someBinaryArithmetic" + type1.toString() + "operation";
final String prefixedFunctionName = "~" + functionName;
if (!mFunctionDeclarations.getDeclaredFunctions().containsKey(prefixedFunctionName)) {
final Attribute attribute =
new NamedAttribute(
loc,
FunctionDeclarations.s_OVERAPPROX_IDENTIFIER,
new Expression[] {new StringLiteral(loc, functionName)});
final Attribute[] attributes = new Attribute[] {attribute};
final ASTType astType = mTypeHandler.ctype2asttype(loc, type1);
mFunctionDeclarations.declareFunction(
loc, prefixedFunctionName, attributes, astType, astType, astType);
}
return new FunctionApplication(loc, prefixedFunctionName, new Expression[] {exp1, exp2});
} else {
return constructArithmeticExpression(loc, nodeOperator, exp1, exp2);
}
}
@Override
public Expression constructBinaryComparisonFloatingPointExpression(
final ILocation loc,
final int nodeOperator,
final Expression exp1,
final CPrimitive type1,
final Expression exp2,
final CPrimitive type2) {
if (mOverapproximateFloatingPointOperations) {
final String functionName = "someBinary" + type1.toString() + "ComparisonOperation";
final String prefixedFunctionName = "~" + functionName;
if (!mFunctionDeclarations.getDeclaredFunctions().containsKey(prefixedFunctionName)) {
final Attribute attribute =
new NamedAttribute(
loc,
FunctionDeclarations.s_OVERAPPROX_IDENTIFIER,
new Expression[] {new StringLiteral(loc, functionName)});
final Attribute[] attributes = new Attribute[] {attribute};
final ASTType paramAstType = mTypeHandler.ctype2asttype(loc, type1);
final ASTType resultAstType = new PrimitiveType(loc, SFO.BOOL);
mFunctionDeclarations.declareFunction(
loc, prefixedFunctionName, attributes, resultAstType, paramAstType, paramAstType);
}
return new FunctionApplication(loc, prefixedFunctionName, new Expression[] {exp1, exp2});
} else {
BinaryExpression.Operator op;
switch (nodeOperator) {
case IASTBinaryExpression.op_equals:
op = BinaryExpression.Operator.COMPEQ;
break;
case IASTBinaryExpression.op_greaterEqual:
op = BinaryExpression.Operator.COMPGEQ;
break;
case IASTBinaryExpression.op_greaterThan:
op = BinaryExpression.Operator.COMPGT;
break;
case IASTBinaryExpression.op_lessEqual:
op = BinaryExpression.Operator.COMPLEQ;
break;
case IASTBinaryExpression.op_lessThan:
op = BinaryExpression.Operator.COMPLT;
break;
case IASTBinaryExpression.op_notequals:
op = BinaryExpression.Operator.COMPNEQ;
break;
default:
throw new AssertionError("Unknown BinaryExpression operator " + nodeOperator);
}
return ExpressionFactory.newBinaryExpression(loc, op, exp1, exp2);
}
}