| /* |
| * Copyright (c) 2015, 2016, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| package jdk.test.lib.jittester.visitors; |
| |
| import java.util.List; |
| import java.util.Locale; |
| import java.util.Objects; |
| import java.util.stream.Collectors; |
| import jdk.test.lib.jittester.BinaryOperator; |
| import jdk.test.lib.jittester.Block; |
| import jdk.test.lib.jittester.Break; |
| import jdk.test.lib.jittester.CastOperator; |
| import jdk.test.lib.jittester.CatchBlock; |
| import jdk.test.lib.jittester.Continue; |
| import jdk.test.lib.jittester.Declaration; |
| import jdk.test.lib.jittester.IRNode; |
| import jdk.test.lib.jittester.If; |
| import jdk.test.lib.jittester.Initialization; |
| import jdk.test.lib.jittester.Literal; |
| import jdk.test.lib.jittester.LocalVariable; |
| import jdk.test.lib.jittester.NonStaticMemberVariable; |
| import jdk.test.lib.jittester.Nothing; |
| import jdk.test.lib.jittester.Operator; |
| import jdk.test.lib.jittester.OperatorKind; |
| import jdk.test.lib.jittester.PrintVariables; |
| import jdk.test.lib.jittester.ProductionParams; |
| import jdk.test.lib.jittester.Statement; |
| import jdk.test.lib.jittester.StaticMemberVariable; |
| import jdk.test.lib.jittester.Switch; |
| import jdk.test.lib.jittester.Symbol; |
| import jdk.test.lib.jittester.TernaryOperator; |
| import jdk.test.lib.jittester.Throw; |
| import jdk.test.lib.jittester.TryCatchBlock; |
| import jdk.test.lib.jittester.Type; |
| import jdk.test.lib.jittester.TypeList; |
| import jdk.test.lib.jittester.UnaryOperator; |
| import jdk.test.lib.jittester.VariableBase; |
| import jdk.test.lib.jittester.VariableDeclaration; |
| import jdk.test.lib.jittester.VariableDeclarationBlock; |
| import jdk.test.lib.jittester.VariableInfo; |
| import jdk.test.lib.jittester.arrays.ArrayCreation; |
| import jdk.test.lib.jittester.arrays.ArrayElement; |
| import jdk.test.lib.jittester.arrays.ArrayExtraction; |
| import jdk.test.lib.jittester.classes.ClassDefinitionBlock; |
| import jdk.test.lib.jittester.classes.Interface; |
| import jdk.test.lib.jittester.classes.Klass; |
| import jdk.test.lib.jittester.classes.MainKlass; |
| import jdk.test.lib.jittester.functions.ArgumentDeclaration; |
| import jdk.test.lib.jittester.functions.ConstructorDefinition; |
| import jdk.test.lib.jittester.functions.ConstructorDefinitionBlock; |
| import jdk.test.lib.jittester.functions.Function; |
| import jdk.test.lib.jittester.functions.FunctionDeclaration; |
| import jdk.test.lib.jittester.functions.FunctionDeclarationBlock; |
| import jdk.test.lib.jittester.functions.FunctionDefinition; |
| import jdk.test.lib.jittester.functions.FunctionDefinitionBlock; |
| import jdk.test.lib.jittester.functions.FunctionInfo; |
| import jdk.test.lib.jittester.functions.FunctionRedefinition; |
| import jdk.test.lib.jittester.functions.FunctionRedefinitionBlock; |
| import jdk.test.lib.jittester.functions.Return; |
| import jdk.test.lib.jittester.functions.StaticConstructorDefinition; |
| import jdk.test.lib.jittester.loops.CounterInitializer; |
| import jdk.test.lib.jittester.loops.CounterManipulator; |
| import jdk.test.lib.jittester.loops.DoWhile; |
| import jdk.test.lib.jittester.loops.For; |
| import jdk.test.lib.jittester.loops.Loop; |
| import jdk.test.lib.jittester.loops.LoopingCondition; |
| import jdk.test.lib.jittester.loops.While; |
| import jdk.test.lib.jittester.types.TypeArray; |
| import jdk.test.lib.jittester.types.TypeKlass; |
| import jdk.test.lib.jittester.utils.FixedTrees; |
| import jdk.test.lib.jittester.utils.PrintingUtils; |
| |
| public class JavaCodeVisitor implements Visitor<String> { |
| |
| public static String funcAttributes(FunctionInfo fi) { |
| String attrs = attributes(fi); |
| if (fi.isSynchronized()) { |
| attrs += "synchronized "; |
| } |
| return attrs; |
| } |
| |
| public static String attributes(Symbol s) { |
| String attrs = ""; |
| if (s.isPrivate()) { |
| attrs += "private "; |
| } |
| if (s.isProtected()) { |
| attrs += "protected "; |
| } |
| if (s.isPublic()) { |
| attrs += "public "; |
| } |
| if (s.isFinal()) { |
| attrs += "final "; |
| } |
| if (s.isStatic()) { |
| attrs += "static "; |
| } |
| return attrs; |
| } |
| |
| private String operatorToJaveCode(OperatorKind operationKind) { |
| switch (operationKind) { |
| case COMPOUND_ADD: |
| return "+="; |
| case COMPOUND_SUB: |
| return "-="; |
| case COMPOUND_MUL: |
| return "*="; |
| case COMPOUND_DIV: |
| return "/="; |
| case COMPOUND_MOD: |
| return "%="; |
| case COMPOUND_AND: |
| return "&="; |
| case COMPOUND_OR: |
| return "|="; |
| case COMPOUND_XOR: |
| return "^="; |
| case COMPOUND_SHR: |
| return ">>="; |
| case COMPOUND_SHL: |
| return "<<="; |
| case COMPOUND_SAR: |
| return ">>>="; |
| case ASSIGN: |
| return "="; |
| case OR: |
| return "||"; |
| case BIT_OR: |
| return "|"; |
| case BIT_XOR: |
| return "^"; |
| case AND: |
| return "&&"; |
| case BIT_AND: |
| return "&"; |
| case EQ: |
| return "=="; |
| case NE: |
| return "!="; |
| case GT: |
| return ">"; |
| case LT: |
| return "<"; |
| case GE: |
| return ">="; |
| case LE: |
| return "<="; |
| case SHR: |
| return ">>"; |
| case SHL: |
| return "<<"; |
| case SAR: |
| return ">>>"; |
| case ADD: |
| case STRADD: |
| return "+"; |
| case SUB: |
| return "-"; |
| case MUL: |
| return "*"; |
| case DIV: |
| return "/"; |
| case MOD: |
| return "%"; |
| case NOT: |
| return "!"; |
| case BIT_NOT: |
| return "~"; |
| case UNARY_PLUS: |
| return "+"; |
| case UNARY_MINUS: |
| return "-"; |
| case PRE_DEC: |
| case POST_DEC: |
| return "--"; |
| case PRE_INC: |
| case POST_INC: |
| return "++"; |
| default: |
| throw new IllegalArgumentException("Unkown operator kind " + operationKind); |
| } |
| } |
| |
| private String expressionToJavaCode(Operator t, IRNode p, Operator.Order o) { |
| String result; |
| try { |
| if ((o == Operator.Order.LEFT && ((Operator) p).getPriority() < t.getPriority()) |
| || (o == Operator.Order.RIGHT && ((Operator) p).getPriority() <= t.getPriority())) { |
| result = "(" + p.accept(this)+ ")"; |
| } else { |
| result = p.accept(this); |
| } |
| } catch (Exception e) { |
| result = p.accept(this); |
| } |
| return result; |
| } |
| |
| @Override |
| public String visit(ArgumentDeclaration node) { |
| VariableInfo vi = node.variableInfo; |
| return attributes(vi) + vi.type.accept(this) + " " + vi.name; |
| } |
| |
| @Override |
| public String visit(ArrayCreation node) { |
| Type arrayElemType = node.getArrayType().type; |
| String type = arrayElemType.accept(this); |
| String name = node.getVariable().getName(); |
| StringBuilder code = new StringBuilder() |
| .append(node.getVariable().accept(this)) |
| .append(";\n") |
| .append(PrintingUtils.align(node.getParent().getLevel())) |
| .append(name) |
| .append(" = new ") |
| .append(type); |
| code.append(node.getChildren().stream() |
| .map(p -> p.accept(this)) |
| .collect(Collectors.joining("][", "[", "]"))); |
| code.append(";\n"); |
| if (!TypeList.isBuiltIn(arrayElemType)) { |
| code.append(PrintingUtils.align(node.getParent().getLevel())) |
| .append("java.util.Arrays.fill(") |
| .append(name) |
| .append(", new ") |
| .append(type) |
| .append("());\n"); |
| } |
| return code.toString(); |
| } |
| |
| @Override |
| public String visit(ArrayElement node) { |
| IRNode array = node.getChild(0); |
| StringBuilder code = new StringBuilder(); |
| if (array instanceof VariableBase || array instanceof Function) { |
| code.append(array.accept(this)); |
| } else { |
| code.append("(") |
| .append(array.accept(this)) |
| .append(")"); |
| } |
| code.append(node.getChildren().stream() |
| .skip(1) |
| .map(c -> c.accept(this)) |
| .collect(Collectors.joining("][", "[", "]"))); |
| return code.toString(); |
| } |
| |
| @Override |
| public String visit(ArrayExtraction node) { |
| IRNode array = node.getChild(0); |
| StringBuilder code = new StringBuilder(); |
| if (array instanceof VariableBase || array instanceof Function) { |
| code.append(array.accept(this)); |
| } else { |
| code.append("(") |
| .append(array.accept(this)) |
| .append(")"); |
| } |
| code.append(node.getChildren().stream() |
| .skip(1) |
| .map(c -> c.accept(this)) |
| .collect(Collectors.joining("][", "[", "]"))); |
| return code.toString(); |
| } |
| |
| @Override |
| public String visit(BinaryOperator node) { |
| IRNode left = node.getChild(Operator.Order.LEFT.ordinal()); |
| IRNode right = node.getChild(Operator.Order.RIGHT.ordinal()); |
| if (left == null || right == null) { |
| return "null"; |
| } |
| return expressionToJavaCode(node, left, Operator.Order.LEFT) |
| + " " + operatorToJaveCode(node.getOperationKind()) + " " |
| + expressionToJavaCode(node, right, Operator.Order.RIGHT); |
| } |
| |
| @Override |
| public String visit(Block node) { |
| StringBuilder code = new StringBuilder(); |
| for (IRNode i : node.getChildren()) { |
| String s = i.accept(this); |
| if (!s.isEmpty()) { |
| int level = node.getLevel(); |
| if (i instanceof Block) { |
| code.append(PrintingUtils.align(level + 1)) |
| .append("{\n") |
| .append(s) |
| .append(PrintingUtils.align(level + 1)) |
| .append("}"); |
| } else { |
| code.append(PrintingUtils.align(level + 1)) |
| .append(s); |
| } |
| code.append(addComplexityInfo(i)); |
| code.append("\n"); |
| } |
| } |
| return code.toString(); |
| } |
| |
| private String addComplexityInfo(IRNode node) { |
| if (ProductionParams.printComplexity.value()) { |
| return " /* " + node.complexity() + " */"; |
| } |
| return ""; |
| } |
| |
| @Override |
| public String visit(Break node) { |
| return "break;"; |
| } |
| |
| @Override |
| public String visit(CastOperator node) { |
| return "(" + node.getResultType().accept(this)+ ")" |
| + expressionToJavaCode(node, node.getChild(0), Operator.Order.LEFT); |
| } |
| |
| @Override |
| public String visit(ClassDefinitionBlock node) { |
| StringBuilder code = new StringBuilder(); |
| for (IRNode i : node.getChildren()) { |
| code.append("\n") |
| .append(PrintingUtils.align(node.getLevel())) |
| .append(i.accept(this)) |
| .append("\n"); |
| } |
| |
| return code.toString(); |
| } |
| |
| @Override |
| public String visit(ConstructorDefinition node) { |
| String args = node.getChildren().stream() |
| .skip(1) |
| .map(c -> c.accept(this)) |
| .collect(Collectors.joining(", ")); |
| IRNode body = node.getChild(0); |
| StringBuilder code = new StringBuilder(); |
| code.append(funcAttributes(node.getFunctionInfo())) |
| .append(node.getFunctionInfo().name) |
| .append("(") |
| .append(args) |
| .append(")\n") |
| .append(PrintingUtils.align(node.getLevel() + 1)) |
| .append("{\n") |
| .append(body != null ? body.accept(this) : "") |
| .append(PrintingUtils.align(node.getLevel() + 1)) |
| .append("}"); |
| return code.toString(); |
| } |
| |
| @Override |
| public String visit(ConstructorDefinitionBlock node) { |
| StringBuilder code = new StringBuilder(); |
| for (IRNode i : node.getChildren()) { |
| code.append("\n") |
| .append(PrintingUtils.align(node.getLevel())) |
| .append(i.accept(this)) |
| .append(addComplexityInfo(i)) |
| .append("\n"); |
| } |
| return code.toString(); |
| } |
| |
| @Override |
| public String visit(Continue node) { |
| return "continue;"; |
| } |
| |
| @Override |
| public String visit(CounterInitializer node) { |
| VariableInfo vi = node.getVariableInfo(); |
| return vi.type.accept(this) + " " + vi.name + " = " + node.getChild(0).accept(this)+ ";"; |
| } |
| |
| @Override |
| public String visit(CounterManipulator node) { |
| return node.getChild(0).accept(this); |
| } |
| |
| @Override |
| public String visit(Declaration node) { |
| return node.getChild(0).accept(this)+ ";"; |
| } |
| |
| @Override |
| public String visit(DoWhile node) { |
| IRNode header = node.getChild(DoWhile.DoWhilePart.HEADER.ordinal()); |
| IRNode body1 = node.getChild(DoWhile.DoWhilePart.BODY1.ordinal()); |
| IRNode body2 = node.getChild(DoWhile.DoWhilePart.BODY2.ordinal()); |
| StringBuilder code = new StringBuilder(); |
| Loop loop = node.getLoop(); |
| int level = node.getLevel(); |
| code.append(loop.initialization.accept(this)) |
| .append("\n") |
| .append(header.accept(this)) |
| .append(PrintingUtils.align(level)) |
| .append("do\n") |
| .append(PrintingUtils.align(level)) |
| .append("{\n") |
| .append(body1.accept(this)) |
| .append(PrintingUtils.align(level + 1)) |
| .append(loop.manipulator.accept(this)) |
| .append(";\n") |
| .append(body2.accept(this)) |
| .append(PrintingUtils.align(level)) |
| .append("} while (") |
| .append(loop.condition.accept(this)) |
| .append(");"); |
| return code.toString(); |
| } |
| |
| @Override |
| public String visit(For node) { |
| IRNode header = node.getChild(For.ForPart.HEADER.ordinal()); |
| IRNode statement1 = node.getChild(For.ForPart.STATEMENT1.ordinal()); |
| IRNode statement2 = node.getChild(For.ForPart.STATEMENT2.ordinal()); |
| IRNode body1 = node.getChild(For.ForPart.BODY1.ordinal()); |
| IRNode body2 = node.getChild(For.ForPart.BODY2.ordinal()); |
| IRNode body3 = node.getChild(For.ForPart.BODY3.ordinal()); |
| Loop loop = node.getLoop(); |
| StringBuilder code = new StringBuilder(); |
| int level = node.getLevel(); |
| code.append(loop.initialization.accept(this)) |
| .append("\n") |
| .append(header.accept(this)) |
| .append(PrintingUtils.align(level)) |
| .append("for (") |
| .append(statement1.accept(this)) |
| .append("; ") |
| .append(loop.condition.accept(this)) |
| .append("; ") |
| .append(statement2.accept(this)) |
| .append(")\n") |
| .append(PrintingUtils.align(level)) |
| .append("{\n") |
| .append(body1.accept(this)) |
| .append(PrintingUtils.align(level + 1)) |
| .append(loop.manipulator.accept(this)) |
| .append(";\n") |
| .append(body2.accept(this)) |
| .append(body3.accept(this)) |
| .append(PrintingUtils.align(level)) |
| .append("}"); |
| return code.toString(); |
| } |
| |
| @Override |
| public String visit(Function node) { |
| FunctionInfo value = node.getValue(); |
| String nameAndArgs = value.name + "(" |
| + node.getChildren().stream() |
| .skip(value.isStatic() || value.isConstructor() ? 0 : 1) |
| .map(c -> c.accept(this)) |
| .collect(Collectors.joining(", ")) |
| + ")"; |
| String prefix = ""; |
| if (value.isStatic()) { |
| if(!node.getOwner().equals(value.owner)) { |
| prefix = value.owner.getName() + "."; |
| } |
| } else if (value.isConstructor()) { |
| prefix = "new "; |
| } else { |
| IRNode object = node.getChild(0); |
| String objectString = object.accept(this); |
| if (!objectString.equals("this")) { |
| if (object instanceof VariableBase || object instanceof Function |
| || object instanceof Literal) { |
| prefix = objectString + "."; |
| } else { |
| prefix = "(" + objectString + ")" + "."; |
| } |
| } |
| } |
| return prefix + nameAndArgs; |
| } |
| |
| @Override |
| public String visit(FunctionDeclaration node) { |
| String args = node.getChildren().stream() |
| .map(c -> c.accept(this)) |
| .collect(Collectors.joining(", ")); |
| |
| FunctionInfo functionInfo = node.getFunctionInfo(); |
| return (functionInfo.owner.isInterface() ? "" : "abstract ") |
| + funcAttributes(functionInfo) + functionInfo.type.accept(this)+ " " |
| + functionInfo.name + "(" + args + ");"; |
| } |
| |
| @Override |
| public String visit(FunctionDeclarationBlock node) { |
| StringBuilder code = new StringBuilder(); |
| for (IRNode i : node.getChildren()) { |
| code.append(PrintingUtils.align(node.getLevel())) |
| .append(i.accept(this)) |
| .append(addComplexityInfo(i)) |
| .append("\n"); |
| } |
| return code.toString(); |
| } |
| |
| @Override |
| public String visit(FunctionDefinition node) { |
| String args = node.getChildren().stream() |
| .skip(2) |
| .map(c -> c.accept(this)) |
| .collect(Collectors.joining(", ")); |
| IRNode body = node.getChild(0); |
| IRNode ret = node.getChild(1); |
| FunctionInfo functionInfo = node.getFunctionInfo(); |
| return funcAttributes(functionInfo) + functionInfo.type.accept(this) + " " + functionInfo.name + "(" + args + ")" + "\n" |
| + PrintingUtils.align(node.getLevel() + 1) + "{\n" |
| + body.accept(this) |
| + (ret != null ? PrintingUtils.align(node.getLevel() + 2) + ret.accept(this) + "\n" : "") |
| + PrintingUtils.align(node.getLevel() + 1) + "}\n"; |
| } |
| |
| @Override |
| public String visit(FunctionDefinitionBlock node) { |
| StringBuilder code = new StringBuilder(); |
| for (IRNode i : node.getChildren()) { |
| code.append("\n") |
| .append(PrintingUtils.align(node.getLevel())) |
| .append(i.accept(this)) |
| .append(addComplexityInfo(i)) |
| .append("\n"); |
| } |
| return code.toString(); |
| } |
| |
| @Override |
| public String visit(FunctionRedefinition node) { |
| String args = node.getChildren().stream() |
| .skip(2) |
| .map(c -> c.accept(this)) |
| .collect(Collectors.joining(", ")); |
| |
| IRNode body = node.getChild(0); |
| IRNode ret = node.getChild(1); |
| int level = node.getLevel(); |
| FunctionInfo functionInfo = node.getFunctionInfo(); |
| return funcAttributes(functionInfo) + functionInfo.type.accept(this) + " " + functionInfo.name + "(" + args + ")" + "\n" |
| + PrintingUtils.align(level + 1) + "{\n" |
| + body.accept(this) |
| + (ret != null ? PrintingUtils.align(level + 2) + ret.accept(this) + "\n" : "") |
| + PrintingUtils.align(level + 1) + "}"; |
| } |
| |
| @Override |
| public String visit(FunctionRedefinitionBlock node) { |
| StringBuilder code = new StringBuilder(); |
| for (IRNode i : node.getChildren()) { |
| code.append("\n") |
| .append(PrintingUtils.align(node.getLevel())) |
| .append(i.accept(this)) |
| .append(addComplexityInfo(i)) |
| .append("\n"); |
| } |
| return code.toString(); |
| } |
| |
| @Override |
| public String visit(If node) { |
| int level = node.getLevel(); |
| String thenBlockString = PrintingUtils.align(level) + "{\n" |
| + node.getChild(If.IfPart.THEN.ordinal()).accept(this) |
| + PrintingUtils.align(level) + "}"; |
| |
| String elseBlockString = null; |
| if (node.getChild(If.IfPart.ELSE.ordinal()) != null) { |
| elseBlockString = PrintingUtils.align(level) + "{\n" |
| + node.getChild(If.IfPart.ELSE.ordinal()).accept(this) |
| + PrintingUtils.align(level) + "}"; |
| } |
| |
| return "if (" + node.getChild(If.IfPart.CONDITION.ordinal()).accept(this)+ ")\n" |
| + thenBlockString + (elseBlockString != null ? "\n" |
| + PrintingUtils.align(level) + "else\n" + elseBlockString : ""); |
| } |
| |
| @Override |
| public String visit(Initialization node) { |
| VariableInfo vi = node.getVariableInfo(); |
| return attributes(vi) + vi.type.accept(this)+ " " + vi.name + " = " |
| + node.getChild(0).accept(this); |
| } |
| |
| @Override |
| public String visit(Interface node) { |
| return "interface " + node.getName() + (node.getParentKlass() != null ? " extends " |
| + node.getParentKlass().getName() : "") + " {\n" |
| + (node.getChildren().size() > 0 ? node.getChild(0).accept(this) : "") |
| + "}\n"; |
| } |
| |
| @Override |
| public String visit(Klass node) { |
| TypeKlass thisKlass = node.getThisKlass(); |
| String r = (ProductionParams.enableStrictFP.value() ? "strictfp " : "") |
| + (thisKlass.isFinal() ? "final " : "") |
| + (thisKlass.isAbstract() ? "abstract " : "") |
| + "class " + node.getName() |
| + (node.getParentKlass() != null && !node.getParentKlass().equals(TypeList.OBJECT) |
| ? " extends " + node.getParentKlass().getName() : ""); |
| List<TypeKlass> interfaces = node.getInterfaces(); |
| r += interfaces.stream() |
| .map(Type::getName) |
| .collect(Collectors.joining(", ", (interfaces.isEmpty() ? "" : " implements "), "")); |
| IRNode dataMembers = node.getChild(Klass.KlassPart.DATA_MEMBERS.ordinal()); |
| IRNode constructors = node.getChild(Klass.KlassPart.CONSTRUCTORS.ordinal()); |
| IRNode redefinedFunctions = node.getChild(Klass.KlassPart.REDEFINED_FUNCTIONS.ordinal()); |
| IRNode overridenFunctions = node.getChild(Klass.KlassPart.OVERRIDEN_FUNCTIONS.ordinal()); |
| IRNode memberFunctions = node.getChild(Klass.KlassPart.MEMBER_FUNCTIONS.ordinal()); |
| IRNode memberFunctionDecls = node.getChild(Klass.KlassPart.MEMBER_FUNCTIONS_DECLARATIONS.ordinal()); |
| IRNode printVariables = node.getChild(Klass.KlassPart.PRINT_VARIABLES.ordinal()); |
| r += " {\n" |
| + (dataMembers != null ? (dataMembers.accept(this)+ "\n") : "") |
| + (constructors != null ? (constructors.accept(this)+ "\n") : "") |
| + (redefinedFunctions != null ? (redefinedFunctions.accept(this)+ "\n") : "") |
| + (overridenFunctions != null ? (overridenFunctions.accept(this)+ "\n") : "") |
| + (memberFunctionDecls != null ? (memberFunctionDecls.accept(this)+ "\n") : "") |
| + (memberFunctions != null ? (memberFunctions.accept(this)+ "\n") : "") |
| + printVariables.accept(this) |
| + "}\n"; |
| return r; |
| } |
| |
| @Override |
| public String visit(Literal node) { |
| Type resultType = node.getResultType(); |
| Object value = node.getValue(); |
| if (resultType.equals(TypeList.LONG)) { |
| return value.toString() + "L"; |
| } |
| if (resultType.equals(TypeList.FLOAT)) { |
| return String.format((Locale) null, |
| "%EF", |
| Double.parseDouble(value.toString())); |
| } |
| if (resultType.equals(TypeList.DOUBLE)) { |
| return String.format((Locale) null, |
| "%E", |
| Double.parseDouble(value.toString())); |
| } |
| if (resultType.equals(TypeList.CHAR)) { |
| if ((Character) value == '\\') { |
| return "\'" + "\\\\" + "\'"; |
| } else { |
| return "\'" + value.toString() + "\'"; |
| } |
| } |
| if (resultType.equals(TypeList.SHORT)) { |
| return "(short) " + value.toString(); |
| } |
| if (resultType.equals(TypeList.BYTE)) { |
| return "(byte) " + value.toString(); |
| } |
| if (resultType.equals(TypeList.STRING)) { |
| // TOOD handle other non-printable |
| return "\"" + value.toString().replace("\n", "\\n") + "\""; |
| } |
| return value.toString(); |
| } |
| |
| @Override |
| public String visit(LocalVariable node) { |
| return node.getVariableInfo().name; |
| } |
| |
| @Override |
| public String visit(LoopingCondition node) { |
| return node.getCondition().accept(this); |
| } |
| |
| @Override |
| public String visit(MainKlass node) { |
| String name = node.getName(); |
| IRNode dataMembers = node.getChild(MainKlass.MainKlassPart.DATA_MEMBERS.ordinal()); |
| IRNode memberFunctions = node.getChild(MainKlass.MainKlassPart.MEMBER_FUNCTIONS.ordinal()); |
| IRNode testFunction = node.getChild(MainKlass.MainKlassPart.TEST_FUNCTION.ordinal()); |
| IRNode printVariables = node.getChild(MainKlass.MainKlassPart.PRINT_VARIABLES.ordinal()); |
| |
| return (ProductionParams.enableStrictFP.value() ? "strictfp " : "") |
| + "public class " + name + " {\n" |
| + dataMembers.accept(this)+ "\n" |
| + (memberFunctions != null ? memberFunctions.accept(this): "") + "\n" |
| + " private void test()\n" |
| + " {\n" |
| + testFunction.accept(this) |
| + " }" + addComplexityInfo(testFunction) + "\n" |
| + printVariables.accept(this) |
| + "}\n\n"; |
| } |
| |
| @Override |
| public String visit(NonStaticMemberVariable node) { |
| IRNode object = node.getChild(0); |
| String objectString = object.accept(this); |
| VariableInfo value = node.getVariableInfo(); |
| if (objectString.equals("this")) { |
| return value.name; |
| } else { |
| if (object instanceof VariableBase || object instanceof Function || object instanceof Literal) { |
| return objectString + "." + value.name; |
| } else { |
| return "(" + objectString + ")" + "." + value.name; |
| } |
| } |
| } |
| |
| @Override |
| public String visit(Nothing node) { |
| return ""; |
| } |
| |
| @Override |
| public String visit(PrintVariables node) { |
| return FixedTrees.printVariablesAsFunction(node).accept(this); |
| } |
| |
| @Override |
| public String visit(Return node) { |
| return "return " + node.getExpression().accept(this) + ";"; |
| } |
| |
| @Override |
| public String visit(Throw node) { |
| return "throw " + node.getThowable().accept(this) + ";"; |
| } |
| |
| @Override |
| public String visit(Statement node) { |
| return node.getChild(0).accept(this)+ (node.isSemicolonNeeded() ? ";" : ""); |
| } |
| |
| @Override |
| public String visit(StaticConstructorDefinition node) { |
| IRNode body = node.getChild(0); |
| return "static {\n" |
| + (body != null ? body.accept(this): "") |
| + PrintingUtils.align(node.getLevel()) + "}"; |
| } |
| |
| @Override |
| public String visit(StaticMemberVariable node) { |
| IRNode owner = node.getOwner(); |
| VariableInfo info = node.getVariableInfo(); |
| if (owner.equals(info.owner)) { |
| return info.name; |
| } else { |
| return info.owner.getName() + "." + info.name; |
| } |
| } |
| |
| @Override |
| public String visit(Switch node) { |
| int level = node.getLevel(); |
| int caseBlockIdx = node.getCaseBlockIndex(); |
| String cases = ""; |
| for (int i = 0; i < caseBlockIdx - 1; ++i) { |
| cases += PrintingUtils.align(level + 1); |
| if (node.getChild(i + 1) instanceof Nothing) { |
| cases += "default:\n"; |
| } else { |
| cases += "case " + node.getChild(i + 1).accept(this)+ ":\n"; |
| } |
| |
| cases += node.getChild(i + caseBlockIdx).accept(this)+ "\n"; |
| } |
| return "switch (" + node.getChild(0).accept(this)+ ")\n" |
| + PrintingUtils.align(level) + "{\n" |
| + cases |
| + PrintingUtils.align(level) + "}"; |
| } |
| |
| @Override |
| public String visit(TernaryOperator node) { |
| IRNode conditionalExp = node.getChild(TernaryOperator.TernaryPart.CONDITION.ordinal()); |
| IRNode leftExp = node.getChild(TernaryOperator.TernaryPart.TRUE.ordinal()); |
| IRNode rightExp = node.getChild(TernaryOperator.TernaryPart.FALSE.ordinal()); |
| if (Objects.isNull(conditionalExp) || Objects.isNull(leftExp) || Objects.isNull(rightExp)) { |
| return "null"; |
| } |
| return expressionToJavaCode(node, conditionalExp, Operator.Order.RIGHT) + " ? " |
| + expressionToJavaCode(node, leftExp, Operator.Order.RIGHT) + " : " |
| + expressionToJavaCode(node, rightExp, Operator.Order.RIGHT); |
| } |
| |
| @Override |
| public String visit(Type node) { |
| return node.getName(); |
| } |
| |
| @Override |
| public String visit(TypeArray node) { |
| String r = node.getType().accept(this); |
| for (int i = 0; i < node.getDimensions(); i++) { |
| r += "[]"; |
| } |
| return r; |
| } |
| |
| @Override |
| public String visit(UnaryOperator node) { |
| IRNode exp = node.getChild(0); |
| if (node.isPrefix()) { |
| return operatorToJaveCode(node.getOperationKind()) |
| + (exp instanceof Operator ? " " : "") |
| + expressionToJavaCode(node, exp, Operator.Order.LEFT); |
| } else { |
| return expressionToJavaCode(node, exp, Operator.Order.RIGHT) |
| + (exp instanceof Operator ? " " : "") |
| + operatorToJaveCode(node.getOperationKind()); |
| } |
| } |
| |
| @Override |
| public String visit(VariableDeclaration node) { |
| VariableInfo vi = node.getVariableInfo(); |
| return attributes(vi) + vi.type.accept(this)+ " " + vi.name; |
| } |
| |
| @Override |
| public String visit(VariableDeclarationBlock node) { |
| StringBuilder code = new StringBuilder(); |
| for (IRNode i : node.getChildren()) { |
| code.append(PrintingUtils.align(node.getLevel())) |
| .append(i.accept(this)) |
| .append(addComplexityInfo(i)) |
| .append("\n"); |
| } |
| return code.toString(); |
| } |
| |
| @Override |
| public String visit(While node) { |
| IRNode header = node.getChild(While.WhilePart.HEADER.ordinal()); |
| IRNode body1 = node.getChild(While.WhilePart.BODY1.ordinal()); |
| IRNode body2 = node.getChild(While.WhilePart.BODY2.ordinal()); |
| IRNode body3 = node.getChild(While.WhilePart.BODY3.ordinal()); |
| int level = node.getLevel(); |
| Loop loop = node.getLoop(); |
| return loop.initialization.accept(this)+ "\n" |
| + header.accept(this) |
| + PrintingUtils.align(level) + "while (" + loop.condition.accept(this)+ ")\n" |
| + PrintingUtils.align(level) + "{\n" |
| + body1.accept(this) |
| + PrintingUtils.align(level + 1) + loop.manipulator.accept(this)+ ";\n" |
| + body2.accept(this) |
| + body3.accept(this) |
| + PrintingUtils.align(level) + "}"; |
| } |
| |
| @Override |
| public String visit(CatchBlock node) { |
| StringBuilder result = new StringBuilder(); |
| int level = node.getLevel(); |
| result.append(PrintingUtils.align(level)).append("catch("); |
| result.append(node.throwables.get(0).accept(this)); |
| for (int i = 1; i < node.throwables.size(); i++) { |
| result.append(" | ").append(node.throwables.get(i).accept(this)); |
| } |
| result.append(" ex) {\n"); |
| result.append(node.getChild(0).accept(this)); |
| result.append(PrintingUtils.align(level)).append("}\n"); |
| return result.toString(); |
| } |
| |
| @Override |
| public String visit(TryCatchBlock node) { |
| StringBuilder result = new StringBuilder(); |
| List<? extends IRNode> childs = node.getChildren(); |
| IRNode body = childs.get(0); |
| IRNode finallyBody = childs.get(1); |
| int level = node.getLevel(); |
| result.append("try {\n") |
| .append(body.accept(this)).append("\n") |
| .append(PrintingUtils.align(level)) |
| .append("}\n"); |
| for (int i = 2; i < childs.size(); i++) { |
| result.append(childs.get(i).accept(this)); |
| } |
| if (finallyBody != null) { |
| String finallyContent = finallyBody.accept(this); |
| if (!finallyContent.isEmpty()) { |
| result.append(PrintingUtils.align(level)).append("finally {\n") |
| .append(finallyContent).append("\n") |
| .append(PrintingUtils.align(level)).append("}\n"); |
| } |
| } |
| return result.toString(); |
| } |
| } |
