Xinwen Deng / aem-src

/*
 * Decompiled with CFR 0_118.
 */
package com.adobe.forms.formcalc;

import com.adobe.forms.formcalc.ASTAccessor;
import com.adobe.forms.formcalc.ASTAdditive;
import com.adobe.forms.formcalc.ASTArgumentList;
import com.adobe.forms.formcalc.ASTAssignment;
import com.adobe.forms.formcalc.ASTBreak;
import com.adobe.forms.formcalc.ASTContinue;
import com.adobe.forms.formcalc.ASTDeclarationAssignment;
import com.adobe.forms.formcalc.ASTDeclarationOnly;
import com.adobe.forms.formcalc.ASTDownTo;
import com.adobe.forms.formcalc.ASTElseIfExpr;
import com.adobe.forms.formcalc.ASTEquality;
import com.adobe.forms.formcalc.ASTExpressionList;
import com.adobe.forms.formcalc.ASTForEachExpr;
import com.adobe.forms.formcalc.ASTForExpr;
import com.adobe.forms.formcalc.ASTForInit;
import com.adobe.forms.formcalc.ASTFunctionCall;
import com.adobe.forms.formcalc.ASTFunctionDeclaration;
import com.adobe.forms.formcalc.ASTFunctionIf;
import com.adobe.forms.formcalc.ASTIdentifier;
import com.adobe.forms.formcalc.ASTIfExpr;
import com.adobe.forms.formcalc.ASTLogicalAnd;
import com.adobe.forms.formcalc.ASTLogicalOr;
import com.adobe.forms.formcalc.ASTMultiplicative;
import com.adobe.forms.formcalc.ASTNULL;
import com.adobe.forms.formcalc.ASTNumber;
import com.adobe.forms.formcalc.ASTParameterList;
import com.adobe.forms.formcalc.ASTParenExpression;
import com.adobe.forms.formcalc.ASTRelational;
import com.adobe.forms.formcalc.ASTSimpleExpr;
import com.adobe.forms.formcalc.ASTStep;
import com.adobe.forms.formcalc.ASTString;
import com.adobe.forms.formcalc.ASTUnary;
import com.adobe.forms.formcalc.ASTUpTo;
import com.adobe.forms.formcalc.ASTWhile;
import com.adobe.forms.formcalc.CalcTransParserVisitor;
import com.adobe.forms.formcalc.Node;
import com.adobe.forms.formcalc.SimpleNode;
import com.adobe.forms.formcalc.api.FunctionNameMapping;
import com.adobe.forms.formcalc.support.Scopes;
import java.io.PrintWriter;

public class FormCalc2JSVisitor
implements CalcTransParserVisitor {
    private final PrintWriter output;
    private boolean lineWrap = true;
    private final FunctionNameMapping functionNameMapping;
    private final Scopes scopes = new Scopes();
    private int seed = 0;

    public FormCalc2JSVisitor(FunctionNameMapping functionNameMapping, PrintWriter output) {
        this.functionNameMapping = functionNameMapping;
        this.output = output;
    }

    @Override
    public Object visit(SimpleNode node, Object data) {
        return null;
    }

    @Override
    public Object visit(ASTArgumentList node, Object data) {
        this.print("(");
        int childrenNum = node.jjtGetNumChildren();
        for (int i = 0; i < childrenNum; ++i) {
            Node agument = node.jjtGetChild(i);
            if (i > 0) {
                this.print(",");
            }
            agument.jjtAccept(this, data);
        }
        this.print(")");
        return null;
    }

    @Override
    public Object visit(ASTLogicalOr node, Object data) {
        int childNum = node.jjtGetNumChildren();
        assert (childNum > 1);
        node.jjtGetChild(0).jjtAccept(this, data);
        for (int idx = 1; idx < childNum; ++idx) {
            this.printSpace();
            this.print("||");
            this.printSpace();
            node.jjtGetChild(idx).jjtAccept(this, data);
        }
        return null;
    }

    @Override
    public Object visit(ASTLogicalAnd node, Object data) {
        int childNum = node.jjtGetNumChildren();
        assert (childNum > 1);
        node.jjtGetChild(0).jjtAccept(this, data);
        for (int idx = 1; idx < childNum; ++idx) {
            this.printSpace();
            this.print("&&");
            this.printSpace();
            node.jjtGetChild(idx).jjtAccept(this, data);
        }
        return null;
    }

    @Override
    public Object visit(ASTEquality node, Object data) {
        int childNum = node.jjtGetNumChildren();
        assert (childNum > 1);
        node.jjtGetChild(0).jjtAccept(this, data);
        for (int idx = 1; idx < childNum; ++idx) {
            this.printSpace();
            if (node.isEquals(idx)) {
                this.print("==");
            } else {
                this.print("!=");
            }
            this.printSpace();
            node.jjtGetChild(idx).jjtAccept(this, data);
        }
        return null;
    }

    @Override
    public Object visit(ASTRelational node, Object data) {
        int childNum = node.jjtGetNumChildren();
        assert (childNum > 1);
        node.jjtGetChild(0).jjtAccept(this, data);
        for (int idx = 1; idx < childNum; ++idx) {
            this.printSpace();
            if (node.isGT(idx)) {
                this.print(">");
            } else if (node.isGE(idx)) {
                this.print(">=");
            } else if (node.isLT(idx)) {
                this.print("<");
            } else if (node.isLE(idx)) {
                this.print("<=");
            } else assert (false);
            this.printSpace();
            node.jjtGetChild(idx).jjtAccept(this, data);
        }
        return null;
    }

    @Override
    public Object visit(ASTAdditive node, Object data) {
        int childNum = node.jjtGetNumChildren();
        assert (childNum > 1);
        node.jjtGetChild(0).jjtAccept(this, data);
        for (int idx = 1; idx < childNum; ++idx) {
            this.printSpace();
            if (node.isAdd(idx)) {
                this.print("+");
            } else {
                this.print("-");
            }
            this.printSpace();
            node.jjtGetChild(idx).jjtAccept(this, data);
        }
        return null;
    }

    @Override
    public Object visit(ASTMultiplicative node, Object data) {
        int childNum = node.jjtGetNumChildren();
        assert (childNum > 1);
        node.jjtGetChild(0).jjtAccept(this, data);
        for (int idx = 1; idx < childNum; ++idx) {
            this.printSpace();
            if (node.isMultiple(idx)) {
                this.print("*");
            } else {
                this.print("/");
            }
            this.printSpace();
            node.jjtGetChild(idx).jjtAccept(this, data);
        }
        return null;
    }

    @Override
    public Object visit(ASTNumber node, Object data) {
        this.print(node.getLiteral());
        return null;
    }

    @Override
    public Object visit(ASTFunctionCall node, Object data) {
        Node iffun;
        if (node.jjtGetNumChildren() == 1 && (iffun = node.jjtGetChild(0)) instanceof ASTFunctionIf) {
            return iffun.jjtAccept(this, data);
        }
        String con = this.functionNameMapping.getFunctionToConst(node.getFunName());
        if (con != null) {
            this.print(con);
            this.printSpace();
        } else {
            this.print(this.functionNameMapping.getJSFunctionIfAny(node.getFunName()));
            int childNum = node.jjtGetNumChildren();
            if (childNum == 2) {
                Node agumentList = node.jjtGetChild(1);
                agumentList.jjtAccept(this, data);
            } else {
                this.print("(");
                this.print(")");
            }
        }
        return null;
    }

    @Override
    public Object visit(ASTFunctionIf node, Object data) {
        this.print(this.functionNameMapping.getJSFunctionIfAny("IF"));
        int childNum = node.jjtGetNumChildren();
        assert (childNum < 2);
        if (childNum == 1) {
            Node agumentList = node.jjtGetChild(0);
            agumentList.jjtAccept(this, data);
        } else {
            this.print("(");
            this.print(")");
        }
        return null;
    }

    @Override
    public Object visit(ASTAccessor node, Object data) {
        String nodeLiteral = node.getLiteral();
        if (nodeLiteral.contains("[")) {
            this.print("FormCalc._ArrayAccessor(" + nodeLiteral + ")");
        } else {
            this.print("FormCalc._Accessor(" + nodeLiteral + ")");
        }
        return null;
    }

    @Override
    public Object visit(ASTUnary node, Object data) {
        if (node.hasPLUSPrefix()) {
            this.print("+");
            this.printSpace();
        } else if (node.hasMINUSPrefix()) {
            this.print("-");
            this.printSpace();
        } else if (node.hasNOTPrefix()) {
            this.print("!");
            this.printSpace();
        }
        Node child = node.jjtGetChild(0);
        child.jjtAccept(this, data);
        return null;
    }

    @Override
    public Object visit(final ASTAssignment node, final Object data) {
        this.scopes.runInScope(Scopes.ASSIGNMENT_EXPRESSION, new Scopes.Action(){

            @Override
            public void call() {
                SimpleNode p = (SimpleNode)node.jjtGetChild(0);
                String temp = p.getLiteral();
                int startIndex = temp.indexOf("[");
                int indexOfDot = temp.lastIndexOf(".");
                if (startIndex != -1) {
                    String prop = "rawValue";
                    String object = temp.substring(1, temp.length() - 1);
                    if (indexOfDot > startIndex) {
                        prop = temp.substring(indexOfDot + 1, temp.length() - 1);
                        object = temp.substring(1, indexOfDot);
                    }
                    FormCalc2JSVisitor.this.print("var a = this.resolveNodes('" + object + "')");
                    FormCalc2JSVisitor.this.print("\nif (a.length > 0) {");
                    FormCalc2JSVisitor.this.print("\n    a.item(0)." + prop);
                    FormCalc2JSVisitor.this.print("=");
                    node.jjtGetChild(1).jjtAccept(FormCalc2JSVisitor.this, data);
                    FormCalc2JSVisitor.this.print("\n    for(var i=1;i<a.length;i++)");
                    FormCalc2JSVisitor.this.print("\n        a.item(i)." + prop + "=a.item(0)." + prop);
                    FormCalc2JSVisitor.this.print("\n}");
                } else {
                    FormCalc2JSVisitor.this.print(p.getLiteral());
                    FormCalc2JSVisitor.this.print("=");
                    node.jjtGetChild(1).jjtAccept(FormCalc2JSVisitor.this, data);
                }
            }
        });
        if (this.scopes.generateReturnStatement()) {
            this.print(String.format("\nreturn %1$s;", ((SimpleNode)node.jjtGetChild(0)).getLiteral()));
        }
        return null;
    }

    @Override
    public Object visit(ASTIdentifier node, Object data) {
        return null;
    }

    @Override
    public Object visit(ASTNULL node, Object data) {
        this.print("null");
        return null;
    }

    @Override
    public Object visit(ASTString node, Object data) {
        this.print(node.getImage());
        return null;
    }

    @Override
    public Object visit(ASTParenExpression node, Object data) {
        this.print("(");
        int childNum = node.jjtGetNumChildren();
        for (int i = 0; i < childNum; ++i) {
            node.jjtGetChild(i).jjtAccept(this, data);
        }
        this.print(")");
        return null;
    }

    @Override
    public Object visit(ASTExpressionList node, final Object data) {
        int childNum = node.jjtGetNumChildren();
        for (int i = 0; i < childNum; ++i) {
            final Node child = node.jjtGetChild(i);
            if (i == childNum - 1) {
                this.scopes.runInScope(Scopes.LAST_EXPRESSION_IN_BLOCK, new Scopes.Action(){

                    @Override
                    public void call() {
                        child.jjtAccept(FormCalc2JSVisitor.this, data);
                    }
                });
            } else {
                child.jjtAccept(this, data);
            }
            if (this.isSingleLineExpression(child)) {
                this.print(";");
            }
            this.println();
        }
        return null;
    }

    private boolean isSingleLineExpression(Node child) {
        if (child instanceof ASTSimpleExpr || child instanceof ASTAssignment || child instanceof ASTDeclarationAssignment || child instanceof ASTBreak || child instanceof ASTContinue) {
            return true;
        }
        return false;
    }

    @Override
    public Object visit(final ASTWhile node, final Object data) {
        int childNum = node.jjtGetNumChildren();
        assert (childNum == 2);
        this.print("while");
        this.printCondition(node.jjtGetChild(0), data);
        this.scopes.runInScope(node, new Scopes.Action(){

            @Override
            public void call() {
                FormCalc2JSVisitor.this.printBlock(node.jjtGetChild(1), data);
            }
        });
        return null;
    }

    @Override
    public Object visit(final ASTDeclarationAssignment node, final Object data) {
        assert (2 == node.jjtGetNumChildren());
        this.scopes.runInScope(Scopes.ASSIGNMENT_EXPRESSION, new Scopes.Action(){

            @Override
            public void call() {
                FormCalc2JSVisitor.this.print("var");
                FormCalc2JSVisitor.this.printSpace();
                ASTIdentifier identifier = (ASTIdentifier)node.jjtGetChild(0);
                FormCalc2JSVisitor.this.print(identifier.getName());
                FormCalc2JSVisitor.this.print("=");
                node.jjtGetChild(1).jjtAccept(FormCalc2JSVisitor.this, data);
            }
        });
        if (this.scopes.generateReturnStatement()) {
            this.print(String.format("\nreturn %1$s", ((ASTIdentifier)node.jjtGetChild(0)).getName()));
        }
        return null;
    }

    @Override
    public Object visit(ASTDeclarationOnly node, Object data) {
        assert (1 == node.jjtGetNumChildren());
        this.print("var");
        this.printSpace();
        ASTIdentifier identifier = (ASTIdentifier)node.jjtGetChild(0);
        this.print(identifier.getName());
        return null;
    }

    @Override
    public Object visit(ASTIfExpr node, final Object data) {
        this.print("if");
        this.printCondition(node.jjtGetChild(0), data);
        final Node exprList = node.jjtGetChild(1);
        this.scopes.runInScope(node, new Scopes.Action(){

            @Override
            public void call() {
                FormCalc2JSVisitor.this.printBlock(exprList, data);
            }
        });
        this.handle3rdChildOfIf(node, data);
        return null;
    }

    @Override
    public Object visit(final ASTElseIfExpr node, final Object data) {
        this.print("else if");
        this.printCondition(node.jjtGetChild(0), data);
        this.scopes.runInScope(node, new Scopes.Action(){

            @Override
            public void call() {
                FormCalc2JSVisitor.this.printBlock(node.jjtGetChild(1), data);
            }
        });
        this.handle3rdChildOfIf(node, data);
        return null;
    }

    public void handle3rdChildOfIf(Node node, final Object data) {
        int childNum = node.jjtGetNumChildren();
        if (childNum > 2) {
            assert (childNum == 3);
            final Node n3 = node.jjtGetChild(2);
            if (n3 instanceof ASTElseIfExpr) {
                n3.jjtAccept(this, data);
            } else {
                this.print("else");
                this.scopes.runInScope(node, new Scopes.Action(){

                    @Override
                    public void call() {
                        FormCalc2JSVisitor.this.printBlock(n3, data);
                    }
                });
            }
        }
    }

    @Override
    public Object visit(ASTBreak node, Object data) {
        this.print("break");
        return null;
    }

    @Override
    public Object visit(ASTContinue node, Object data) {
        this.print("continue");
        return null;
    }

    @Override
    public Object visit(ASTForInit node, Object data) {
        ASTIdentifier id = (ASTIdentifier)node.jjtGetChild(0);
        this.print(id.getName());
        this.print("=");
        node.jjtGetChild(1).jjtAccept(this, data);
        return null;
    }

    @Override
    public Object visit(ASTUpTo node, Object data) {
        node.jjtGetChild(0).jjtAccept(this, data);
        return null;
    }

    @Override
    public Object visit(ASTDownTo node, Object data) {
        node.jjtGetChild(0).jjtAccept(this, data);
        return null;
    }

    @Override
    public Object visit(ASTStep node, Object data) {
        node.jjtGetChild(0).jjtAccept(this, data);
        return null;
    }

    @Override
    public Object visit(final ASTForEachExpr node, final Object data) {
        Node arguLst = node.jjtGetChild(1);
        String wrapperArrayID = "temp" + this.generateID();
        this.print(String.format("var %1$s = new Array", wrapperArrayID));
        if (arguLst instanceof ASTArgumentList) {
            arguLst.jjtAccept(this, data);
        }
        this.print(";");
        this.println();
        String indexID = "index" + this.generateID();
        this.print(String.format("for(var %1$s =0; %1$s < %2$s.length; %1$s++)", indexID, wrapperArrayID));
        this.print("{");
        this.println();
        this.print(String.format("%1$s = %2$s[%3$s];", node.getLoopVariable(), wrapperArrayID, indexID));
        this.scopes.runInScope(node, new Scopes.Action(){

            @Override
            public void call() {
                node.jjtGetChild(node.jjtGetNumChildren() - 1).jjtAccept(FormCalc2JSVisitor.this, data);
            }
        });
        this.print("}");
        return null;
    }

    @Override
    public Object visit(ASTForExpr node, final Object data) {
        boolean upto;
        this.print("for");
        this.print("(");
        Node forInit = node.jjtGetChild(0);
        assert (forInit instanceof ASTForInit);
        forInit.jjtAccept(this, data);
        this.print(";");
        Node TO = node.jjtGetChild(1);
        if (TO instanceof ASTUpTo) {
            upto = true;
        } else {
            assert (TO instanceof ASTDownTo);
            upto = false;
        }
        this.print(node.getControl());
        this.printSpace();
        if (upto) {
            this.print("<=");
        } else {
            this.print(">=");
        }
        this.printSpace();
        TO.jjtAccept(this, data);
        this.print(";");
        Node loopBody = null;
        Node third = node.jjtGetChild(2);
        this.print(node.getControl());
        this.print("=");
        this.print(node.getControl());
        if (upto) {
            this.print("+");
        } else {
            this.print("-");
        }
        this.printSpace();
        if (third instanceof ASTStep) {
            third.jjtAccept(this, data);
            loopBody = node.jjtGetChild(3);
        } else {
            this.print("1");
            loopBody = third;
        }
        this.print(")");
        final Node finalLoopBody = loopBody;
        this.scopes.runInScope(node, new Scopes.Action(){

            @Override
            public void call() {
                FormCalc2JSVisitor.this.printBlock(finalLoopBody, data);
            }
        });
        return null;
    }

    @Override
    public Object visit(final ASTFunctionDeclaration node, final Object data) {
        this.println();
        this.print("function");
        this.printSpace();
        ASTIdentifier identifier = (ASTIdentifier)node.jjtGetChild(0);
        this.print(identifier.getName());
        Node parameters = node.jjtGetChild(1);
        assert (parameters instanceof ASTParameterList);
        parameters.jjtAccept(this, data);
        this.print("{");
        this.scopes.runInScope(Scopes.FUNCTION_DECLARATION, new Scopes.Action(){

            @Override
            public void call() {
                if (node.jjtGetNumChildren() == 3) {
                    node.jjtGetChild(2).jjtAccept(FormCalc2JSVisitor.this, data);
                }
            }
        });
        this.print("}");
        return null;
    }

    @Override
    public Object visit(ASTParameterList node, Object data) {
        this.print("(");
        int childrenNum = node.jjtGetNumChildren();
        for (int i = 0; i < childrenNum; ++i) {
            ASTIdentifier param = (ASTIdentifier)node.jjtGetChild(i);
            if (i > 0) {
                this.print(",");
            }
            this.print(param.getName());
        }
        this.print(")");
        return null;
    }

    @Override
    public Object visit(ASTSimpleExpr node, Object data) {
        if (this.scopes.generateReturnStatement()) {
            this.print("return");
            this.printSpace();
        }
        node.jjtGetChild(0).jjtAccept(this, data);
        return null;
    }

    private void printCondition(final Node condition, final Object data) {
        this.scopes.runInScope(Scopes.FRAGMENT, new Scopes.Action(){

            @Override
            public void call() {
                FormCalc2JSVisitor.this.print("(");
                condition.jjtAccept(FormCalc2JSVisitor.this, data);
                FormCalc2JSVisitor.this.print(")");
            }
        });
    }

    private void printBlock(Node node, Object data) {
        this.print("{");
        this.println();
        node.jjtAccept(this, data);
        this.println();
        this.print("}");
        this.println();
    }

    private void println() {
        if (this.lineWrap) {
            this.output.println();
        }
    }

    private void printSpace() {
        this.print(" ");
    }

    private void print(String s) {
        this.output.print(s);
    }

    private String generateID() {
        return String.valueOf(this.seed++);
    }

}