private void addImplicitEnumParamTypes(IType owningType, List<IRType> paramTypes) {
// Enums have name and ordinal arguments implicitly added to their constructors
if (owningType.isEnum()) {
paramTypes.add(IRTypeConstants.STRING());
paramTypes.add(IRTypeConstants.pINT());
}
}
protected IRExpression compile_impl() {
IRExpression lhs =
IRArgConverter.castOrConvertIfNecessary(
IRTypeConstants.pBOOLEAN(), ExpressionTransformer.compile(_expr().getLHS(), _cc()));
IRExpression rhs =
IRArgConverter.castOrConvertIfNecessary(
IRTypeConstants.pBOOLEAN(), ExpressionTransformer.compile(_expr().getRHS(), _cc()));
return new IRConditionalOrExpression(lhs, rhs);
}
private void addDefaultConstructor(IRClass irClass) {
_context.initBodyContext(false);
_context.pushScope(true);
List<IRStatement> statements = new ArrayList<IRStatement>();
IRMethod irMethod =
IRMethodFactory.createConstructorIRMethod(_cc().getSuperType(), new IRType[0]);
statements.add(
new IRMethodCallStatement(
callSpecialMethod(
getDescriptor(_cc().getSuperType()),
irMethod,
pushThis(),
Collections.<IRExpression>emptyList())));
statements.add(new IRReturnStatement());
IRMethodStatement methodStatement =
new IRMethodStatement(
new IRStatementList(true, statements),
"<init>",
Opcodes.ACC_PUBLIC,
IRTypeConstants.pVOID(),
Collections.<IRSymbol>emptyList());
irClass.addMethod(methodStatement);
}
private void addEvaluateRootMethod(IRClass irClass) {
// Only bother adding in the method if the fragment's root is an IMemberAccessExpression;
// otherwise the method
// is already implemented to return null on FragmentInstance
IExpression expr = maybeUnwrap(_fragment.getExpression());
if (expr instanceof IMemberAccessExpression) {
// public abstract Object evaluateRootExpression(IExternalSymbolMap symbols);
IRSymbol symbolsParam =
new IRSymbol(SYMBOLS_PARAM_NAME, getDescriptor(IExternalSymbolMap.class), false);
_context.initBodyContext(false);
_context.pushScope(true);
_context.putSymbol(symbolsParam);
List<IRStatement> statements = new ArrayList<IRStatement>();
IRExpression returnValue =
ExpressionTransformer.compile(
((IMemberAccessExpression) expr).getRootExpression(), _context);
if (returnValue.getType().isPrimitive()) {
returnValue = boxValue(returnValue.getType(), returnValue);
}
statements.add(new IRReturnStatement(null, returnValue));
IRMethodStatement methodStatement =
new IRMethodStatement(
new IRStatementList(true, statements),
"evaluateRootExpression",
Opcodes.ACC_PUBLIC,
IRTypeConstants.OBJECT(),
Collections.singletonList(symbolsParam));
irClass.addMethod(methodStatement);
}
}
private void addEvaluateMethod(IRClass irClass) {
// public abstract Object evaluate(IExternalSymbolMap symbols);
IRSymbol symbolsParam =
new IRSymbol(SYMBOLS_PARAM_NAME, getDescriptor(IExternalSymbolMap.class), false);
_context.initBodyContext(false);
_context.pushScope(true);
_context.putSymbol(symbolsParam);
List<IRStatement> statements = new ArrayList<IRStatement>();
IExpression expression = _fragment.getExpression();
if (expression instanceof IProgram) {
Statement mainStatement = (Statement) ((IProgram) expression).getMainStatement();
statements.add(StatementTransformer.compile(_context, mainStatement));
// If the program doesn't terminate, then add in an explicit return null at the end.
// This is likely in the case of a program that doesn't actually return a value
boolean[] bAbsolute = {false};
ITerminalStatement terminalStmt =
mainStatement.getLeastSignificantTerminalStatement(bAbsolute);
if (!bAbsolute[0]
|| !(terminalStmt instanceof ReturnStatement)
&& !(terminalStmt instanceof ThrowStatement)) {
statements.add(new IRReturnStatement(null, nullLiteral()));
}
} else if (expression.getType().equals(JavaTypes.pVOID())) {
// If the expression has a void type, such as if it's a method call with no return value, then
// compile
// it as a synthetic statement and explicitly insert a return null
statements.add(new IRSyntheticStatement(ExpressionTransformer.compile(expression, _context)));
statements.add(new IRReturnStatement(null, nullLiteral()));
} else {
// If the expression has a value, just return that (after boxing it, if necessary)
IRExpression returnValue = ExpressionTransformer.compile(expression, _context);
if (returnValue.getType().isPrimitive()) {
returnValue = boxValue(returnValue.getType(), returnValue);
}
statements.add(new IRReturnStatement(null, returnValue));
}
IRMethodStatement methodStatement =
new IRMethodStatement(
new IRStatementList(true, statements),
"evaluate",
Opcodes.ACC_PUBLIC,
IRTypeConstants.OBJECT(),
Collections.singletonList(symbolsParam));
irClass.addMethod(methodStatement);
}
@Override
public IRType getType() {
return IRTypeConstants.pBOOLEAN();
}
@Override
public IRType getReturnType() {
return IRTypeConstants.pVOID();
}