codecompiler.java

tinyos最新版

            exceptionTest(exc, else_end, node, 1);
            handler_end.setPosition();

            //do else clause
            suite(node.orelse);
            else_end.setPosition();
        }

        code.freeFinallyLocal(exc);
        code.addExceptionHandler(start, end, handler_start,
                                 code.pool.Class("java/lang/Throwable"));
        return null;
    }

    public Object visitSuite(Suite node) throws Exception {
        return suite(node.body);
    }

    public Object suite(stmtType[] stmts) throws Exception {
        int n = stmts.length;
        for(int i = 0; i < n; i++) {
            Object exit = visit(stmts[i]);
            //System.out.println("exit: "+exit+", "+n+", "+(exit != null));
            if (exit != null)
                return Exit;
        }
        return null;
    }

    public Object visitBoolOp(BoolOp node) throws Exception {
        Label end = code.getLabel();
        visit(node.values[0]);
        for (int i = 1; i < node.values.length; i++) {
            code.dup();
            if (mrefs.nonzero == 0) {
                mrefs.nonzero = code.pool.Methodref("org/python/core/PyObject",
                                                    "__nonzero__", "()Z");
            }
            code.invokevirtual(mrefs.nonzero);
            switch (node.op) {
            case BoolOp.Or : 
                code.ifne(end);
                break;
            case BoolOp.And : 
                code.ifeq(end);
                break;
            }
            code.pop();
            visit(node.values[i]);
        }
        end.setPosition();
        return null;
    }


    public Object visitCompare(Compare node) throws Exception {
        int tmp1 = code.getLocal("org/python/core/PyObject");
        int tmp2 = code.getLocal("org/python/core/PyObject");
        int op;

        if (mrefs.nonzero == 0) {
            mrefs.nonzero = code.pool.Methodref("org/python/core/PyObject",
                                                "__nonzero__", "()Z");
        }

        Label end = code.getLabel();

        visit(node.left);

        int n = node.ops.length;
        for(int i = 0; i < n - 1; i++) {
            visit(node.comparators[i]);
            code.dup();
            code.astore(tmp1);
            code.invokevirtual(make_cmpop(node.ops[i]));
            code.dup();
            code.astore(tmp2);
            code.invokevirtual(mrefs.nonzero);
            code.ifeq(end);
            code.aload(tmp1);
        }

        visit(node.comparators[n-1]);
        code.invokevirtual(make_cmpop(node.ops[n-1]));

        if (n > 1) {
            code.astore(tmp2);
            end.setPosition();
            code.aload(tmp2);
        }
        code.freeLocal(tmp1);
        code.freeLocal(tmp2);
        return null;
    }

    int[] compare_ops = new int[11];
    public int make_cmpop(int op) throws Exception {
        if (compare_ops[op] == 0) {
            String name = null;
            switch (op) {
            case Compare.Eq:    name = "_eq"; break;
            case Compare.NotEq: name = "_ne"; break;
            case Compare.Lt:    name = "_lt"; break;
            case Compare.LtE:   name = "_le"; break;
            case Compare.Gt:    name = "_gt"; break;
            case Compare.GtE:   name = "_ge"; break;
            case Compare.Is:    name = "_is"; break;
            case Compare.IsNot: name = "_isnot"; break;
            case Compare.In:    name = "_in"; break;
            case Compare.NotIn: name = "_notin"; break;
            }
            compare_ops[op] = code.pool.Methodref(
                "org/python/core/PyObject", name,
                "(" + $pyObj + ")" + $pyObj);
        }
        return compare_ops[op];
    }

    static String[] bin_methods = new String[] {
        null,
        "_add",
        "_sub",
        "_mul",
        "_div",
        "_mod",
        "_pow",
        "_lshift",
        "_rshift",
        "_or",
        "_xor",
        "_and",
        "_floordiv",
    };

    int[] bin_ops = new int[13];
    public int make_binop(int op) throws Exception {
        if (bin_ops[op] == 0) {
            String name = bin_methods[op];
            if (op == BinOp.Div && module.getFutures().areDivisionOn()) {
                name = "_truediv";
            }
            bin_ops[op] = code.pool.Methodref(
                "org/python/core/PyObject", name,
                "(" + $pyObj + ")" + $pyObj);
        }
        return bin_ops[op];
    }

    public Object visitBinOp(BinOp node) throws Exception {
        visit(node.left);
        visit(node.right);
        code.invokevirtual(make_binop(node.op));
        return null;
    }

    
    static String[] unary_methods = new String[] {
        null,
        "__invert__",
        "__not__",
        "__pos__",
        "__neg__",
    };

    int[] unary_ops = new int[unary_methods.length];
    public int make_unaryop(int op) throws Exception {
        if (unary_ops[op] == 0) {
            String name = unary_methods[op];
            unary_ops[op] = code.pool.Methodref(
                "org/python/core/PyObject", name, "()" + $pyObj);
        }
        return unary_ops[op];
    }

    public Object visitUnaryOp(UnaryOp node) throws Exception {
        visit(node.operand);
        code.invokevirtual(make_unaryop(node.op));
        return null;
    }


    static String[] aug_methods = new String[] {
        null,
        "__iadd__",
        "__isub__",
        "__imul__",
        "__idiv__",
        "__imod__",
        "__ipow__",
        "__ilshift__",
        "__irshift__",
        "__ior__",
        "__ixor__",
        "__iand__",
        "__ifloordiv__",
    };

    int[] augbin_ops = new int[aug_methods.length];
    public int make_augbinop(int op) throws Exception {
        if (augbin_ops[op] == 0) {
            String name = aug_methods[op];
            if (op == BinOp.Div && module.getFutures().areDivisionOn()) {
                name = "__itruediv__";
            }
            augbin_ops[op] = code.pool.Methodref(
                "org/python/core/PyObject", name,
                "(" + $pyObj + ")" + $pyObj);
        }
        return augbin_ops[op];
    }

    public Object visitAugAssign(AugAssign node) throws Exception {
        visit(node.value);
        int tmp = storeTop();

        augmode = expr_contextType.Load;
        visit(node.target);

        code.aload(tmp);
        code.invokevirtual(make_augbinop(node.op));
        code.freeLocal(tmp);

        temporary = storeTop();
        augmode = expr_contextType.Store;
        visit(node.target);
        code.freeLocal(temporary);

        return null;
    }


    public static void makeStrings(Code c, String[] names, int n)
        throws IOException
    {
        c.iconst(n);
        c.anewarray(c.pool.Class("java/lang/String"));
        int strings = c.getLocal("[java/lang/String");
        c.astore(strings);
        for (int i=0; i<n; i++) {
            c.aload(strings);
            c.iconst(i);
            c.ldc(names[i]);
            c.aastore();
        }
        c.aload(strings);
        c.freeLocal(strings);
    }

    public int invokea0, invokea1, invokea2;
    public int invoke2;
    public Object Invoke(Attribute node, SimpleNode[] values)
        throws Exception
    {
        String name = getName(node.attr);
        visit(node.value);
        code.ldc(name);

        //System.out.println("invoke: "+name+": "+values.length);

        switch (values.length) {
        case 0:
            if (mrefs.invokea0 == 0) {
                mrefs.invokea0 = code.pool.Methodref(
                    "org/python/core/PyObject", "invoke",
                    "(" + $str + ")" + $pyObj);
            }
            code.invokevirtual(mrefs.invokea0);
            break;
        case 1:
            if (mrefs.invokea1 == 0) {
                mrefs.invokea1 = code.pool.Methodref(
                    "org/python/core/PyObject", "invoke",
                    "(" + $str + $pyObj + ")" + $pyObj);
            }
            visit(values[0]);
            code.invokevirtual(mrefs.invokea1);
            break;
        case 2:
            if (mrefs.invokea2 == 0) {
                mrefs.invokea2 = code.pool.Methodref(
                    "org/python/core/PyObject", "invoke",
                    "(" + $str + $pyObj + $pyObj + ")" + $pyObj);
            }
            visit(values[0]);
            visit(values[1]);
            code.invokevirtual(mrefs.invokea2);
            break;
        default:
            makeArray(values);
            if (mrefs.invoke2 == 0) {
                mrefs.invoke2 = code.pool.Methodref(
                    "org/python/core/PyObject", "invoke",
                    "(" + $str + $pyObjArr + ")" + $pyObj);
            }
            code.invokevirtual(mrefs.invoke2);
            break;
        }

        return null;
    }


    public int callextra;
    public int call1, call2;
    public int calla0, calla1, calla2, calla3, calla4;
    public Object visitCall(Call node) throws Exception {
        String[] keys = new String[node.keywords.length];
        exprType[] values = new exprType[node.args.length + keys.length];
        for (int i = 0; i < node.args.length; i++) {
            values[i] = node.args[i];
        }
        for (int i = 0; i < node.keywords.length; i++) {
            keys[i] = node.keywords[i].arg;
            values[node.args.length + i] = node.keywords[i].value;
        }

        // Detect a method invocation with no keywords
        if (node.keywords == null && node.starargs == null &&
            node.kwargs == null && node.func instanceof Attribute)
        {
            return Invoke((Attribute) node.func, values);
        }

        visit(node.func);

        if (node.starargs != null || node.kwargs != null) {
            makeArray(values);
            makeStrings(code, keys, keys.length);
            if (node.starargs == null)
                code.aconst_null();
            else
                visit(node.starargs);
            if (node.kwargs == null)
                code.aconst_null();
            else
                visit(node.kwargs);

            if (mrefs.callextra == 0) {
                mrefs.callextra = code.pool.Methodref(
                    "org/python/core/PyObject", "_callextra",
                    "(" + $pyObjArr + $strArr + $pyObj + $pyObj + ")" +
                    $pyObj);
            }
            code.invokevirtual(mrefs.callextra);
        } else if (keys.length > 0) {
            makeArray(values);
            makeStrings(code, keys, keys.length);

            if (mrefs.call1 == 0) {
                mrefs.call1 = code.pool.Methodref(
                    "org/python/core/PyObject", "__call__",
                    "(" + $pyObjArr + $strArr + ")" + $pyObj);
            }
            code.invokevirtual(mrefs.call1);
        } else {
            switch (values.length) {
            case 0:
                if (mrefs.calla0 == 0) {
                    mrefs.calla0 = code.pool.Methodref(
                        "org/python/core/PyObject", "__call__",
                        "()" + $pyObj);
                }
                code.invokevirtual(mrefs.calla0);
                break;
            case 1:
                if (mrefs.calla1 == 0) {
                    mrefs.calla1 = code.pool.Methodref(
                        "org/python/core/PyObject", "__call__",
                        "(" + $pyObj + ")" + $pyObj);
                }
                visit(values[0]);
                code.invokevirtual(mrefs.calla1);
                break;
            case 2:
                if (mrefs.calla2 == 0) {
                    mrefs.calla2 = code.pool.Methodref(
                        "org/python/core/PyObject", "__call__",
                        "(" + $pyObj + $pyObj + ")" + $pyObj);
                }
                visit(values[0]);
                visit(values[1]);
                code.invokevirtual(mrefs.calla2);
                break;
            case 3:
                if (mrefs.calla3 == 0) {
                    mrefs.calla3 = code.pool.Methodref(
                        "org/python/core/PyObject", "__call__",
                        "(" + $pyObj + $pyObj + $pyObj + ")" + $pyObj);
                }
                visit(values[0]);
                visit(values[1]);
                visit(values[2]);
                code.invokevirtual(mrefs.calla3);
                break;
            case 4:
                if (mrefs.calla4 == 0) {
                    mrefs.calla4 = code.pool.Methodref(
                        "org/python/core/PyObject", "__call__",
                        "(" + $pyObj + $pyObj + $pyObj + $pyObj + ")" +
                            $pyObj);
                }
                visit(values[0]);
                visit(values[1]);
                visit(values[2]);
                visit(values[3]);
                code.invokevirtual(mrefs.calla4);
                break;
            default:
                makeArray(values);
                if (mrefs.call2 == 0) {
                    mrefs.call2 = code.pool.Methodref(
                        "org/python/core/PyObject", "__call__",
                        "(" + $pyObjArr + ")" + $pyObj);
                }
                code.invokevirtual(mrefs.call2);
                break;