Java FunctionNode.FUNCTION_EXPRESSION属性代码示例

private void visitFunction(OptFunctionNode ofn, int functionType)
{
    int fnIndex = codegen.getIndex(ofn.fnode);
    cfw.add(ByteCode.NEW, codegen.mainClassName);
    // Call function constructor
    cfw.add(ByteCode.DUP);
    cfw.addALoad(variableObjectLocal);
    cfw.addALoad(contextLocal);           // load 'cx'
    cfw.addPush(fnIndex);
    cfw.addInvoke(ByteCode.INVOKESPECIAL, codegen.mainClassName,
                  "<init>", Codegen.FUNCTION_CONSTRUCTOR_SIGNATURE);

    if (functionType == FunctionNode.ARROW_FUNCTION) {
        cfw.addALoad(contextLocal);           // load 'cx'
        cfw.addALoad(variableObjectLocal);
        cfw.addALoad(thisObjLocal);
        addOptRuntimeInvoke("bindThis",
                            "(Lorg/mozilla/javascript/NativeFunction;"
                            +"Lorg/mozilla/javascript/Context;"
                            +"Lorg/mozilla/javascript/Scriptable;"
                            +"Lorg/mozilla/javascript/Scriptable;"
                            +")Lorg/mozilla/javascript/Function;");
    }

    if (functionType == FunctionNode.FUNCTION_EXPRESSION ||
        functionType == FunctionNode.ARROW_FUNCTION) {
        // Leave closure object on stack and do not pass it to
        // initFunction which suppose to connect statements to scope
        return;
    }
    cfw.addPush(functionType);
    cfw.addALoad(variableObjectLocal);
    cfw.addALoad(contextLocal);           // load 'cx'
    addOptRuntimeInvoke("initFunction",
                        "(Lorg/mozilla/javascript/NativeFunction;"
                        +"I"
                        +"Lorg/mozilla/javascript/Scriptable;"
                        +"Lorg/mozilla/javascript/Context;"
                        +")V");
}
 

private void visitFunction(OptFunctionNode ofn, int functionType)
{
    int fnIndex = codegen.getIndex(ofn.fnode);
    cfw.add(ByteCode.NEW, codegen.mainClassName);
    // Call function constructor
    cfw.add(ByteCode.DUP);
    cfw.addALoad(variableObjectLocal);
    cfw.addALoad(contextLocal);           // load 'cx'
    cfw.addPush(fnIndex);
    cfw.addInvoke(ByteCode.INVOKESPECIAL, codegen.mainClassName,
                  "<init>", Codegen.FUNCTION_CONSTRUCTOR_SIGNATURE);

    if (functionType == FunctionNode.FUNCTION_EXPRESSION) {
        // Leave closure object on stack and do not pass it to
        // initFunction which suppose to connect statements to scope
        return;
    }
    cfw.addPush(functionType);
    cfw.addALoad(variableObjectLocal);
    cfw.addALoad(contextLocal);           // load 'cx'
    addOptRuntimeInvoke("initFunction",
                        "(Lorg/mozilla/javascript/NativeFunction;"
                        +"I"
                        +"Lorg/mozilla/javascript/Scriptable;"
                        +"Lorg/mozilla/javascript/Context;"
                        +")V");
}
 

private Node transformFunction(FunctionNode fn) {
    int functionType = fn.getFunctionType();
    int start = decompiler.markFunctionStart(functionType);
    Node mexpr = decompileFunctionHeader(fn);
    int index = currentScriptOrFn.addFunction(fn);

    PerFunctionVariables savedVars = new PerFunctionVariables(fn);
    try {
        // If we start needing to record much more codegen metadata during
        // function parsing, we should lump it all into a helper class.
        Node destructuring = (Node)fn.getProp(Node.DESTRUCTURING_PARAMS);
        fn.removeProp(Node.DESTRUCTURING_PARAMS);

        int lineno = fn.getBody().getLineno();
        ++nestingOfFunction;  // only for body, not params
        Node body = transform(fn.getBody());

        if (!fn.isExpressionClosure()) {
            decompiler.addToken(Token.RC);
        }
        fn.setEncodedSourceBounds(start, decompiler.markFunctionEnd(start));

        if (functionType != FunctionNode.FUNCTION_EXPRESSION && !fn.isExpressionClosure()) {
            // Add EOL only if function is not part of expression
            // since it gets SEMI + EOL from Statement in that case
            decompiler.addToken(Token.EOL);
        }

        if (destructuring != null) {
            body.addChildToFront(new Node(Token.EXPR_VOID,
                                          destructuring, lineno));
        }

        int syntheticType = fn.getFunctionType();
        Node pn = initFunction(fn, index, body, syntheticType);
        if (mexpr != null) {
            pn = createAssignment(Token.ASSIGN, mexpr, pn);
            if (syntheticType != FunctionNode.FUNCTION_EXPRESSION) {
                pn = createExprStatementNoReturn(pn, fn.getLineno());
            }
        }
        return pn;

    } finally {
        --nestingOfFunction;
        savedVars.restore();
    }
}
 

private Node transformGenExpr(GeneratorExpression node) {
    Node pn;
    
    FunctionNode fn = new FunctionNode();
    fn.setSourceName(currentScriptOrFn.getNextTempName());
    fn.setIsGenerator();
    fn.setFunctionType(FunctionNode.FUNCTION_EXPRESSION);
    fn.setRequiresActivation();
  
    int functionType = fn.getFunctionType();
    int start = decompiler.markFunctionStart(functionType);
    Node mexpr = decompileFunctionHeader(fn);
    int index = currentScriptOrFn.addFunction(fn);

    PerFunctionVariables savedVars = new PerFunctionVariables(fn);
    try {
        // If we start needing to record much more codegen metadata during
        // function parsing, we should lump it all into a helper class.
        Node destructuring = (Node)fn.getProp(Node.DESTRUCTURING_PARAMS);
        fn.removeProp(Node.DESTRUCTURING_PARAMS);

        int lineno = node.lineno;
        ++nestingOfFunction;  // only for body, not params
        Node body = genExprTransformHelper(node);

        if (!fn.isExpressionClosure()) {
            decompiler.addToken(Token.RC);
        }
        fn.setEncodedSourceBounds(start, decompiler.markFunctionEnd(start));

        if (functionType != FunctionNode.FUNCTION_EXPRESSION && !fn.isExpressionClosure()) {
            // Add EOL only if function is not part of expression
            // since it gets SEMI + EOL from Statement in that case
            decompiler.addToken(Token.EOL);
        }

        if (destructuring != null) {
            body.addChildToFront(new Node(Token.EXPR_VOID,
                                          destructuring, lineno));
        }

        int syntheticType = fn.getFunctionType();
        pn = initFunction(fn, index, body, syntheticType);
        if (mexpr != null) {
            pn = createAssignment(Token.ASSIGN, mexpr, pn);
            if (syntheticType != FunctionNode.FUNCTION_EXPRESSION) {
                pn = createExprStatementNoReturn(pn, fn.getLineno());
            }
        }
    } finally {
        --nestingOfFunction;
        savedVars.restore();
    }
   
    Node call = createCallOrNew(Token.CALL, pn);
    call.setLineno(node.getLineno());
    decompiler.addToken(Token.LP);
    decompiler.addToken(Token.RP);
    return call;
}
 

private Node initFunction(FunctionNode fnNode, int functionIndex,
                          Node statements, int functionType) {
    fnNode.setFunctionType(functionType);
    fnNode.addChildToBack(statements);

    int functionCount = fnNode.getFunctionCount();
    if (functionCount != 0) {
        // Functions containing other functions require activation objects
        fnNode.setRequiresActivation();
    }

    if (functionType == FunctionNode.FUNCTION_EXPRESSION) {
        Name name = fnNode.getFunctionName();
        if (name != null && name.length() != 0
                && fnNode.getSymbol(name.getIdentifier()) == null) {
            // A function expression needs to have its name as a
            // variable (if it isn't already allocated as a variable).
            // See ECMA Ch. 13.  We add code to the beginning of the
            // function to initialize a local variable of the
            // function's name to the function value, but only if the
            // function doesn't already define a formal parameter, var,
            // or nested function with the same name.
            fnNode.putSymbol(new Symbol(Token.FUNCTION, name.getIdentifier()));
            Node setFn = new Node(Token.EXPR_VOID,
                             new Node(Token.SETNAME,
                                      Node.newString(Token.BINDNAME,
                                                     name.getIdentifier()),
                                 new Node(Token.THISFN)));
            statements.addChildrenToFront(setFn);
        }
    }

    // Add return to end if needed.
    Node lastStmt = statements.getLastChild();
    if (lastStmt == null || lastStmt.getType() != Token.RETURN) {
        statements.addChildToBack(new Node(Token.RETURN));
    }

    Node result = Node.newString(Token.FUNCTION, fnNode.getName());
    result.putIntProp(Node.FUNCTION_PROP, functionIndex);
    return result;
}
 

private void visitFunction(OptFunctionNode ofn, int functionType)
{
    int fnIndex = codegen.getIndex(ofn.fnode);
    cfw.add(ByteCode.NEW, codegen.mainClassName);
    // Call function constructor
    cfw.add(ByteCode.DUP);
    cfw.addALoad(variableObjectLocal);
    cfw.addALoad(contextLocal);           // load 'cx'
    cfw.addPush(fnIndex);
    cfw.addInvoke(ByteCode.INVOKESPECIAL, codegen.mainClassName,
                  "<init>", Codegen.FUNCTION_CONSTRUCTOR_SIGNATURE);

    // Init mainScript field;
    cfw.add(ByteCode.DUP);
    if (isTopLevel) {
        cfw.add(ByteCode.ALOAD_0);
    } else {
        cfw.add(ByteCode.ALOAD_0);
        cfw.add(ByteCode.GETFIELD,
                codegen.mainClassName,
                Codegen.DIRECT_CALL_PARENT_FIELD,
                codegen.mainClassSignature);
    }
    cfw.add(ByteCode.PUTFIELD,
            codegen.mainClassName,
            Codegen.DIRECT_CALL_PARENT_FIELD,
            codegen.mainClassSignature);

    int directTargetIndex = ofn.getDirectTargetIndex();
    if (directTargetIndex >= 0) {
        cfw.add(ByteCode.DUP);
        if (isTopLevel) {
            cfw.add(ByteCode.ALOAD_0);
        } else {
            cfw.add(ByteCode.ALOAD_0);
            cfw.add(ByteCode.GETFIELD,
                    codegen.mainClassName,
                    Codegen.DIRECT_CALL_PARENT_FIELD,
                    codegen.mainClassSignature);
        }
        cfw.add(ByteCode.SWAP);
        cfw.add(ByteCode.PUTFIELD,
                codegen.mainClassName,
                Codegen.getDirectTargetFieldName(directTargetIndex),
                codegen.mainClassSignature);
    }

    if (functionType == FunctionNode.FUNCTION_EXPRESSION) {
        // Leave closure object on stack and do not pass it to
        // initFunction which suppose to connect statements to scope
        return;
    }
    cfw.addPush(functionType);
    cfw.addALoad(variableObjectLocal);
    cfw.addALoad(contextLocal);           // load 'cx'
    addOptRuntimeInvoke("initFunction",
                        "(Lorg/mozilla/javascript/NativeFunction;"
                        +"I"
                        +"Lorg/mozilla/javascript/Scriptable;"
                        +"Lorg/mozilla/javascript/Context;"
                        +")V");
}