From 2af848d7c4e9a39f7ddedf3d62046eabc9fe65a5 Mon Sep 17 00:00:00 2001 From: Michael Williamson Date: Tue, 12 Jan 2016 09:14:22 +0000 Subject: Add hacktastic switch statement reading --- .../frontends/java/JavaStatementReader.java | 110 ++++++++++++++++++++- .../org/zwobble/couscous/frontends/java/Scope.java | 9 ++ 2 files changed, 115 insertions(+), 4 deletions(-) (limited to 'src/main') diff --git a/src/main/java/org/zwobble/couscous/frontends/java/JavaStatementReader.java b/src/main/java/org/zwobble/couscous/frontends/java/JavaStatementReader.java index 41809b7..1b6d62a 100644 --- a/src/main/java/org/zwobble/couscous/frontends/java/JavaStatementReader.java +++ b/src/main/java/org/zwobble/couscous/frontends/java/JavaStatementReader.java @@ -3,16 +3,23 @@ package org.zwobble.couscous.frontends.java; import org.eclipse.jdt.core.dom.*; import org.zwobble.couscous.ast.*; import org.zwobble.couscous.values.BooleanValue; +import org.zwobble.couscous.values.ObjectValues; -import java.util.List; -import java.util.Optional; +import java.util.*; +import java.util.function.Predicate; import java.util.stream.Collectors; -import static java.util.Arrays.asList; +import static com.google.common.collect.Iterables.*; +import static com.google.common.collect.Maps.immutableEntry; import static org.zwobble.couscous.ast.ExpressionStatementNode.expressionStatement; +import static org.zwobble.couscous.ast.IfStatementNode.ifStatement; +import static org.zwobble.couscous.ast.MethodCallNode.methodCall; +import static org.zwobble.couscous.ast.VariableReferenceNode.reference; import static org.zwobble.couscous.ast.WhileNode.whileLoop; +import static org.zwobble.couscous.frontends.java.JavaExpressionReader.coerceExpression; import static org.zwobble.couscous.frontends.java.JavaTypes.typeOf; import static org.zwobble.couscous.util.ExtraLists.*; +import static org.zwobble.couscous.util.ExtraLists.concat; class JavaStatementReader { private final Scope scope; @@ -52,6 +59,9 @@ class JavaStatementReader { case ASTNode.VARIABLE_DECLARATION_STATEMENT: return readVariableDeclarationStatement((VariableDeclarationStatement)statement); + case ASTNode.SWITCH_STATEMENT: + return readSwitchStatement((SwitchStatement)statement); + default: throw new RuntimeException("Unsupported statement: " + statement.getClass()); } @@ -74,12 +84,104 @@ class JavaStatementReader { } private StatementNode readIfStatement(IfStatement statement) { - return IfStatementNode.ifStatement( + return ifStatement( readExpression(BooleanValue.REF, statement.getExpression()), readStatement(statement.getThenStatement()), readStatement(statement.getElseStatement())); } + private List readSwitchStatement(SwitchStatement switchStatement) { + ExpressionNode switchValue = readExpressionWithoutBoxing(switchStatement.getExpression()); + LocalVariableDeclarationNode switchValueAssignment = scope.localVariable( + "_couscous_tmp_0", + switchValue.getType(), + switchValue); + + List statements = switchStatement.statements(); + List, List>> cases = new ArrayList<>(); + + for (int statementIndex = 0; statementIndex < statements.size(); statementIndex++) { + Statement statement = statements.get(statementIndex); + if (statement.getNodeType() == ASTNode.SWITCH_CASE) { + cases.add(readSwitchCase(statements, statementIndex)); + } + } + + List handle = tryFind(cases, currentCase -> !currentCase.getKey().isPresent()) + .transform(currentCase -> currentCase.getValue()) + .or(list()); + + for (int caseIndex = cases.size(); caseIndex --> 0;) { + Map.Entry, List> currentCase = cases.get(caseIndex); + if (currentCase.getKey().isPresent()) { + handle = list(ifStatement( + methodCall( + reference(switchValueAssignment), + "equals", + list(coerceExpression(ObjectValues.OBJECT, currentCase.getKey().get())), + BooleanValue.REF), + currentCase.getValue(), handle)); + } + } + + return cons( + switchValueAssignment, + handle); + } + + private Map.Entry,List> readSwitchCase(List statements, int statementIndex) { + SwitchCase caseStatement = (SwitchCase)statements.get(statementIndex); + + Iterable statementsForCase = upTo( + filter( + skip(statements, statementIndex), + statement -> statement.getNodeType() != ASTNode.SWITCH_CASE), + JavaStatementReader::isEndOfCase); + return immutableEntry( + Optional.ofNullable(caseStatement.getExpression()).map(this::readExpressionWithoutBoxing), + readStatements(statementsForCase)); + } + + private static Iterable upTo(Iterable iterable, Predicate predicate) { + return () -> new UpToIterator<>(iterable.iterator(), predicate); + } + + private static class UpToIterator implements Iterator { + private final Iterator iterator; + private final Predicate predicate; + private boolean finished; + + public UpToIterator(Iterator iterator, Predicate predicate) { + this.iterator = iterator; + this.predicate = predicate; + } + + @Override + public boolean hasNext() { + return !finished && iterator.hasNext(); + } + + @Override + public T next() { + if (hasNext()) { + T value = iterator.next(); + finished = predicate.test(value); + return value; + } else { + throw new NoSuchElementException(); + } + } + } + + private static boolean isEndOfCase(Statement statement) { + // TODO: do this on transformed nodes instead? + return statement.getNodeType() == ASTNode.RETURN_STATEMENT; + } + + private List readStatements(Iterable statements) { + return eagerFlatMap(statements, this::readStatement); + } + private WhileNode readWhileStatement(WhileStatement statement) { return whileLoop( readExpression(BooleanValue.REF, statement.getExpression()), diff --git a/src/main/java/org/zwobble/couscous/frontends/java/Scope.java b/src/main/java/org/zwobble/couscous/frontends/java/Scope.java index caf0a96..28cd6b6 100644 --- a/src/main/java/org/zwobble/couscous/frontends/java/Scope.java +++ b/src/main/java/org/zwobble/couscous/frontends/java/Scope.java @@ -56,6 +56,15 @@ public class Scope { return LocalVariableDeclarationNode.localVariableDeclaration(declaration, initialValue); } + public LocalVariableDeclarationNode localVariable( + String name, + TypeName type, + ExpressionNode initialValue + ) { + VariableDeclaration declaration = generateVariable(name, type); + return LocalVariableDeclarationNode.localVariableDeclaration(declaration, initialValue); + } + public ExpressionNode reference(String key) { VariableDeclaration variable = variablesByKey.get(key); if (variable == null) { -- cgit v1.2.3