diff options
5 files changed, 139 insertions, 16 deletions
diff --git a/src/main/java/org/zwobble/couscous/backends/python/PrimitiveMethods.java b/src/main/java/org/zwobble/couscous/backends/python/PrimitiveMethods.java index 02db3b2..1da18f9 100644 --- a/src/main/java/org/zwobble/couscous/backends/python/PrimitiveMethods.java +++ b/src/main/java/org/zwobble/couscous/backends/python/PrimitiveMethods.java @@ -6,11 +6,14 @@ import java.util.Optional; import org.zwobble.couscous.ast.TypeName; import org.zwobble.couscous.backends.python.ast.PythonExpressionNode; +import org.zwobble.couscous.values.IntegerValue; import org.zwobble.couscous.values.StringValue; import com.google.common.collect.ImmutableMap; +import com.google.common.collect.ImmutableMap.Builder; import static java.util.Arrays.asList; +import static org.zwobble.couscous.backends.python.ast.PythonAttributeAccessNode.pythonAttributeAccess; import static org.zwobble.couscous.backends.python.ast.PythonCallNode.pythonCall; import static org.zwobble.couscous.backends.python.ast.PythonGetSliceNode.pythonGetSlice; import static org.zwobble.couscous.backends.python.ast.PythonVariableReferenceNode.pythonVariableReference; @@ -29,15 +32,45 @@ public class PrimitiveMethods { .build(); + private static final Map<String, PrimitiveMethodGenerator> INT_METHODS; + + static { + ImmutableMap.Builder<String, PrimitiveMethodGenerator> methods = ImmutableMap.builder(); + + addMethod(methods, "add", "__add__"); + addMethod(methods, "subtract", "__sub__"); + addMethod(methods, "multiply", "__mul__"); + addMethod(methods, "divide", "__floordiv__"); + addMethod(methods, "mod", "__mod__"); + + addMethod(methods, "greaterThan", "__gt__"); + addMethod(methods, "greaterThanOrEqual", "__ge__"); + addMethod(methods, "lessThan", "__lt__"); + addMethod(methods, "lessThanOrEqual", "__le__"); + + INT_METHODS = methods.build(); + } + + private static void addMethod( + Builder<String, PrimitiveMethodGenerator> methods, + String methodName, + String pythonMethodName) { + methods.put(methodName, (receiver, arguments) -> + pythonCall( + pythonAttributeAccess(receiver, pythonMethodName), + arguments)); + } + private static final Map<TypeName, Map<String, PrimitiveMethodGenerator>> METHODS = ImmutableMap.<TypeName, Map<String, PrimitiveMethodGenerator>>builder() .put(StringValue.REF, STRING_METHODS) + .put(IntegerValue.REF, INT_METHODS) .build(); public static boolean isPrimitive(TypeName type) { return METHODS.containsKey(type); } - + public static Optional<PrimitiveMethodGenerator> getPrimitiveMethod(TypeName type, String methodName) { return Optional.ofNullable(METHODS.get(type)) .flatMap(methodsForType -> Optional.ofNullable(methodsForType.get(methodName))); diff --git a/src/main/java/org/zwobble/couscous/backends/python/PythonCodeGenerator.java b/src/main/java/org/zwobble/couscous/backends/python/PythonCodeGenerator.java index 85858ad..a10c54d 100644 --- a/src/main/java/org/zwobble/couscous/backends/python/PythonCodeGenerator.java +++ b/src/main/java/org/zwobble/couscous/backends/python/PythonCodeGenerator.java @@ -28,6 +28,7 @@ import org.zwobble.couscous.ast.visitors.ExpressionNodeMapper; import org.zwobble.couscous.ast.visitors.NodeVisitorWithEmptyDefaults; import org.zwobble.couscous.ast.visitors.NodeVisitors; import org.zwobble.couscous.ast.visitors.StatementNodeMapper; +import org.zwobble.couscous.backends.python.PrimitiveMethods.PrimitiveMethodGenerator; import org.zwobble.couscous.backends.python.ast.PythonBlock; import org.zwobble.couscous.backends.python.ast.PythonClassNode; import org.zwobble.couscous.backends.python.ast.PythonExpressionNode; @@ -65,8 +66,6 @@ import static org.zwobble.couscous.backends.python.ast.PythonStringLiteralNode.p import static org.zwobble.couscous.backends.python.ast.PythonVariableReferenceNode.pythonVariableReference; public class PythonCodeGenerator { - - public static PythonModuleNode generateCode(ClassNode classNode) { Iterator<org.zwobble.couscous.backends.python.ast.PythonImportNode> imports = generateImports(classNode).iterator(); PythonFunctionDefinitionNode constructor = generateConstructor(classNode.getConstructor()); @@ -155,8 +154,6 @@ public class PythonCodeGenerator { } private static class StatementGenerator implements StatementNodeMapper<PythonStatementNode> { - - @Override public PythonStatementNode visit(ReturnNode returnNode) { return pythonReturn(generateExpression(returnNode.getValue())); @@ -188,8 +185,6 @@ public class PythonCodeGenerator { private static final ExpressionGenerator EXPRESSION_GENERATOR = new ExpressionGenerator(); private static class ExpressionGenerator implements ExpressionNodeMapper<PythonExpressionNode> { - - @Override public PythonExpressionNode visit(LiteralNode literal) { return generateCode(literal.getValue()); @@ -217,10 +212,10 @@ public class PythonCodeGenerator { @Override public PythonExpressionNode visit(MethodCallNode methodCall) { - final org.zwobble.couscous.backends.python.ast.PythonExpressionNode receiver = generateExpression(methodCall.getReceiver()); - final java.util.List<org.zwobble.couscous.backends.python.ast.PythonExpressionNode> arguments = generateExpressions(methodCall.getArguments()); + PythonExpressionNode receiver = generateExpression(methodCall.getReceiver()); + List<PythonExpressionNode> arguments = generateExpressions(methodCall.getArguments()); if (isPrimitive(methodCall.getReceiver())) { - final org.zwobble.couscous.backends.python.PrimitiveMethods.PrimitiveMethodGenerator primitiveMethodGenerator = PrimitiveMethods.getPrimitiveMethod(methodCall.getReceiver().getType(), methodCall.getMethodName()).get(); + PrimitiveMethodGenerator primitiveMethodGenerator = PrimitiveMethods.getPrimitiveMethod(methodCall.getReceiver().getType(), methodCall.getMethodName()).get(); return primitiveMethodGenerator.generate(receiver, arguments); } else { return pythonCall(pythonAttributeAccess(receiver, methodCall.getMethodName()), arguments); diff --git a/src/main/java/org/zwobble/couscous/interpreter/values/IntegerInterpreterValue.java b/src/main/java/org/zwobble/couscous/interpreter/values/IntegerInterpreterValue.java index bd214cb..823e873 100644 --- a/src/main/java/org/zwobble/couscous/interpreter/values/IntegerInterpreterValue.java +++ b/src/main/java/org/zwobble/couscous/interpreter/values/IntegerInterpreterValue.java @@ -1,6 +1,9 @@ package org.zwobble.couscous.interpreter.values; import java.util.Optional; +import java.util.function.BiFunction; + +import org.zwobble.couscous.interpreter.Environment; import org.zwobble.couscous.interpreter.NoSuchField; import org.zwobble.couscous.values.IntegerValue; import org.zwobble.couscous.values.PrimitiveValue; @@ -9,10 +12,57 @@ import org.zwobble.couscous.values.StringValue; import static java.util.Arrays.asList; public final class IntegerInterpreterValue implements InterpreterValue { - public static final ConcreteType TYPE = ConcreteType.builder(IntegerInterpreterValue.class, IntegerValue.REF).staticMethod("parseInt", asList(StringValue.REF), (environment, arguments) -> { - StringInterpreterValue value = (StringInterpreterValue)arguments.get(0); - return new IntegerInterpreterValue(Integer.parseInt(value.getValue())); - }).build(); + public static final ConcreteType TYPE = ConcreteType.builder(IntegerInterpreterValue.class, IntegerValue.REF) + .staticMethod("parseInt", asList(StringValue.REF), (environment, arguments) -> { + StringInterpreterValue value = (StringInterpreterValue)arguments.get(0); + return new IntegerInterpreterValue(Integer.parseInt(value.getValue())); + }) + .method("add", asList(IntegerValue.REF), + infixReturningInteger((left, right) -> left + right)) + .method("subtract", asList(IntegerValue.REF), + infixReturningInteger((left, right) -> left - right)) + .method("multiply", asList(IntegerValue.REF), + infixReturningInteger((left, right) -> left * right)) + .method("divide", asList(IntegerValue.REF), + infixReturningInteger((left, right) -> left / right)) + .method("mod", asList(IntegerValue.REF), + infixReturningInteger((left, right) -> left % right)) + .method("greaterThan", asList(IntegerValue.REF), + infixReturningBoolean((left, right) -> left > right)) + .method("greaterThanOrEqual", asList(IntegerValue.REF), + infixReturningBoolean((left, right) -> left >= right)) + .method("lessThan", asList(IntegerValue.REF), + infixReturningBoolean((left, right) -> left < right)) + .method("lessThanOrEqual", asList(IntegerValue.REF), + infixReturningBoolean((left, right) -> left <= right)) + .build(); + + private static + BiFunction<Environment, MethodCallArguments<IntegerInterpreterValue>, InterpreterValue> + infixReturningInteger(BiFunction<Integer, Integer, Integer> func) { + return infix((left, right) -> { + return new IntegerInterpreterValue(func.apply(left, right)); + }); + } + + private static + BiFunction<Environment, MethodCallArguments<IntegerInterpreterValue>, InterpreterValue> + infixReturningBoolean(BiFunction<Integer, Integer, Boolean> func) { + return infix((left, right) -> { + return new BooleanInterpreterValue(func.apply(left, right)); + }); + } + + private static + BiFunction<Environment, MethodCallArguments<IntegerInterpreterValue>, InterpreterValue> + infix(BiFunction<Integer, Integer, InterpreterValue> func) { + return (environment, arguments) -> { + IntegerInterpreterValue left = arguments.getReceiver(); + IntegerInterpreterValue right = (IntegerInterpreterValue) arguments.get(0); + return func.apply(left.getValue(), right.getValue()); + }; + } + private final int value; @Override diff --git a/src/test/java/org/zwobble/couscous/tests/BackendEvalTests.java b/src/test/java/org/zwobble/couscous/tests/BackendEvalTests.java index 20d1881..eaf97dd 100644 --- a/src/test/java/org/zwobble/couscous/tests/BackendEvalTests.java +++ b/src/test/java/org/zwobble/couscous/tests/BackendEvalTests.java @@ -6,6 +6,8 @@ import org.junit.Test; import org.zwobble.couscous.ast.ClassNode; import org.zwobble.couscous.ast.ExpressionNode; import org.zwobble.couscous.ast.FormalArgumentNode; +import org.zwobble.couscous.ast.MethodCallNode; +import org.zwobble.couscous.values.BooleanValue; import org.zwobble.couscous.values.IntegerValue; import org.zwobble.couscous.values.PrimitiveValue; import org.zwobble.couscous.values.StringValue; @@ -38,6 +40,50 @@ public abstract class BackendEvalTests { } @Test + public void canEvaluateOperationsOnIntegers() { + assertEquals( + value(3), + evalExpression(methodCall(literal(1), "add", asList(literal(2)), IntegerValue.REF))); + assertEquals( + value(-1), + evalExpression(methodCall(literal(1), "subtract", asList(literal(2)), IntegerValue.REF))); + assertEquals( + value(2), + evalExpression(methodCall(literal(1), "multiply", asList(literal(2)), IntegerValue.REF))); + + assertEquals(value(0), evalExpression(divideIntegers(1, 2))); + assertEquals(value(1), evalExpression(divideIntegers(10, 6))); + // TODO: +// assertEquals(value(-1), evalExpression(divideIntegers(-10, 6))); +// assertEquals(value(-1), evalExpression(divideIntegers(10, -6))); +// assertEquals(value(1), evalExpression(divideIntegers(-10, -6))); + + assertEquals(value(1), evalExpression(modIntegers(1, 2))); + assertEquals(value(4), evalExpression(modIntegers(10, 6))); + + assertEquals( + value(false), + evalExpression(methodCall(literal(1), "greaterThan", asList(literal(2)), BooleanValue.REF))); + assertEquals( + value(false), + evalExpression(methodCall(literal(1), "greaterThanOrEqual", asList(literal(2)), BooleanValue.REF))); + assertEquals( + value(true), + evalExpression(methodCall(literal(1), "lessThan", asList(literal(2)), BooleanValue.REF))); + assertEquals( + value(true), + evalExpression(methodCall(literal(1), "lessThanOrEqual", asList(literal(2)), BooleanValue.REF))); + } + + private MethodCallNode divideIntegers(int left, int right) { + return methodCall(literal(left), "divide", asList(literal(right)), IntegerValue.REF); + } + + private MethodCallNode modIntegers(int left, int right) { + return methodCall(literal(left), "mod", asList(literal(right)), IntegerValue.REF); + } + + @Test public void whenConditionIsTrueThenValueOfConditionalTernaryIsTrueBranch() { PrimitiveValue result = evalExpression(ternaryConditional(literal(true), literal("T"), literal("F"))); assertEquals(value("T"), result); diff --git a/src/test/java/org/zwobble/couscous/tests/JavaToPythonTests.java b/src/test/java/org/zwobble/couscous/tests/JavaToPythonTests.java index b1101ec..2568e55 100644 --- a/src/test/java/org/zwobble/couscous/tests/JavaToPythonTests.java +++ b/src/test/java/org/zwobble/couscous/tests/JavaToPythonTests.java @@ -3,13 +3,13 @@ package org.zwobble.couscous.tests; import java.nio.file.Files; import java.util.List; -import org.junit.Ignore; import org.junit.Test; import org.zwobble.couscous.ast.ClassNode; import org.zwobble.couscous.ast.TypeName; import org.zwobble.couscous.frontends.java.JavaFrontend; import org.zwobble.couscous.tests.backends.python.PythonMethodRunner; import org.zwobble.couscous.values.PrimitiveValue; + import static java.util.Arrays.asList; import static org.junit.Assert.assertEquals; import static org.zwobble.couscous.tests.util.ExtraFiles.deleteRecursively; @@ -23,7 +23,6 @@ public class JavaToPythonTests { } @Test - @Ignore("WIP") public void canUseOperatorsOnPrimitives() { assertEquals(value(3), evalExpression("1 + 2")); assertEquals(value(false), evalExpression("1 > 2")); |