初始化提交

boards/default_src/python/converters/control.js

@@ -0,0 +1,98 @@
+'use strict';
+
+pbc.globalFunctionD['type'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
+    if (args.length != 1) {
+        throw new Error("Incorrect number of arguments");
+    }
+    return block("controls_type", func.lineno, {}, {
+            'DATA': py2block.convert(args[0]),
+        }, {
+            "inline": "false"
+        });
+}
+
+
+function typeName() {
+    function converter(py2block, node, id, ctx, nodeName) {
+        return block("controls_typeLists", node.lineno, {'type': nodeName}, {}, {
+            "inline": "true"
+        });
+    }
+
+    return converter;
+}
+
+pbc.reservedNameD['int'] = typeName();
+pbc.reservedNameD['float'] = typeName();
+pbc.reservedNameD['str'] = typeName();
+pbc.reservedNameD['list'] = typeName();
+pbc.reservedNameD['tuple'] = typeName();
+pbc.reservedNameD['dict'] = typeName();
+pbc.reservedNameD['set'] = typeName();
+pbc.reservedNameD['NoneType'] = typeName();
+
+pbc.globalFunctionD['range'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
+    var args_len = args.length;
+    if (args_len > 3 || args_len < 1) {
+        throw new Error("Incorrect number of arguments");
+    }
+    var arg1block, arg2block, arg3block;
+    if (args_len == 1) {
+        arg2block = py2block.convert(args[0]);
+        var args0 = {
+            _astname: "Num",
+            n: {
+                'v': 0
+            }
+
+        };
+        arg1block = py2block.convert(args0);
+        var args2 = {
+            _astname: "Num",
+            n: {
+                'v': 1
+            }
+        };
+        arg3block = py2block.convert(args2);
+    }else if (args_len == 2) {
+        var args2 = {
+            _astname: "Num",
+            n: {
+                'v': 1
+            }
+        };
+        arg1block = py2block.convert(args[0]);
+        arg2block = py2block.convert(args[1]);
+        arg3block = py2block.convert(args2);
+    }else {
+        arg1block = py2block.convert(args[0]);
+        arg2block = py2block.convert(args[1]);
+        arg3block = py2block.convert(args[2]);
+    }
+
+    return block("controls_range", func.lineno, {
+    }, {
+        'FROM': arg1block,
+        'TO': arg2block,
+        'STEP': arg3block
+    }, {
+        "inline": "true"
+    });
+};
+
+pbc.moduleFunctionD.get('_thread')['start_new_thread'] = function(py2block, func, args, keywords, starargs, kwargs, node){
+    if (args.length !== 2) {
+        throw new Error("Incorrect number of arguments");
+    }
+    pbc.pinType = "pins_callback";
+    var callback = py2block.convert(args[0]);
+    pbc.pinType=null;
+    var tupblock = py2block.convert(args[1]);
+    return [block("controls_thread", func.lineno, {},{
+    "callback":callback,
+    "VAR":tupblock
+    },{
+        "inline": "true"
+    })];
+};
+//for i in ...在python_to_blockly.js中实现

boards/default_src/python/converters/dicts.js

@@ -0,0 +1,153 @@
+'use strict';
+
+pbc.assignD.get('Dict')['check_assign'] = function (py2block, node, targets, value) {
+    if (value._astname === "Dict")
+        return true;
+    return false;
+}
+
+pbc.assignD.get('Dict')['create_block'] = function (py2block, node, targets, value) {
+    var keys = value.keys;
+    var values = value.values;
+
+    var keyList = [];
+    var valueList = [];
+    for (var i = 0; i < keys.length; i+= 1) {
+        var sourceCode = py2block.getSourceCode(node).split('\n')[keys[i].lineno - 1];
+        var s = keys[i].col_offset;
+        var e = sourceCode.indexOf(":", keys[i].col_offset);
+        keyList["KEY"+i] = sourceCode.substring(s, e).trim();
+        valueList["ADD"+i] = py2block.convert(values[i]);
+    }
+    keyList['VAR'] = py2block.Name_str(targets[0]);
+
+    return block("dicts_create_with", node.lineno, keyList, valueList, {
+        "inline": "false"
+    }, {
+        "@items": keys.length
+    });
+}
+
+pbc.objectFunctionD.get('keys')['Dict'] = function(py2block, func, args, keywords, starargs, kwargs, node){
+    if (args.length !== 0) {
+        throw new Error("Incorrect number of arguments");
+    }
+    var objblock = py2block.convert(func.value);
+    return block("dicts_keys", func.lineno, {}, {
+        "DICT": objblock,
+    }, {
+        "inline": "true"
+    });
+};
+
+pbc.objectFunctionD.get('get')['Dict'] = function(py2block, func, args, keywords, starargs, kwargs, node){
+    if (args.length !== 1 && args.length !== 2) {
+        throw new Error("Incorrect number of arguments");
+    }
+    var objblock = py2block.convert(func.value);
+    if (args.length == 2){
+    var args0 = py2block.convert(args[0]);
+    var args1 = py2block.convert(args[1]);
+    return block("dicts_get_default", func.lineno, {}, {
+        "DICT": objblock,
+        "KEY": args0,
+        "VAR": args1,
+    }, {
+        "inline": "true"
+    });
+    }
+    else{
+
+        var args1block = {
+            _astname: "Name",
+            id: {
+                'v': 'None'
+            }
+        };    
+    var args0 = py2block.convert(args[0]);
+    var args1 = py2block.convert(args1block);
+    return block("dicts_get_default", func.lineno, {}, {
+        "DICT": objblock,
+        "KEY": args0,
+        "VAR": args1,
+    }, {
+        "inline": "true"
+    });    
+    }
+};
+
+//d['key']在python_to_blockly.js中实现
+
+//d['key'] = 11;在python_to_blockly.js中实现
+
+//del d['key'];在python_to_blockly.js中实现
+
+//d.clear()在lists.js中实现
+
+//d.pop('key')在set.js中实现
+
+
+pbc.objectFunctionD.get('setdefault')['Dict'] = function(py2block, func, args, keywords, starargs, kwargs, node){
+    if (args.length !== 2) {
+        throw new Error("Incorrect number of arguments");
+    }
+    var objblock = py2block.convert(func.value);
+    var args0 = py2block.convert(args[0]);
+    var args1 = py2block.convert(args[1]);
+    return [block("dicts_setdefault", func.lineno, {}, {
+        "DICT": objblock,
+        "KEY": args0,
+        "VAR": args1,
+    }, {
+        "inline": "true"
+    })];
+};
+
+
+pbc.objectFunctionD.get('items')['Dict'] = function(py2block, func, args, keywords, starargs, kwargs, node){
+    if (args.length !== 0) {
+        throw new Error("Incorrect number of arguments");
+    }
+    var objblock = py2block.convert(func.value);
+    return block("dicts_items", func.lineno, {}, {
+        "DICT": objblock,
+    }, {
+        "inline": "true"
+    });
+};
+
+
+pbc.objectFunctionD.get('values')['Dict'] = function(py2block, func, args, keywords, starargs, kwargs, node){
+    if (args.length !== 0) {
+        throw new Error("Incorrect number of arguments");
+    }
+    var objblock = py2block.convert(func.value);
+    return block("dicts_values", func.lineno, {}, {
+        "DICT": objblock,
+    }, {
+        "inline": "true"
+    });
+};
+
+
+pbc.globalFunctionD['dict'] = function(py2block, func, args, keywords, starargs, kwargs, node){
+    if (args.length > 1) {
+        throw new Error("Incorrect number of arguments");
+    }
+    if (args.length ==0){
+        return block("dicts_create_with_noreturn", node.lineno, {},{}
+            , {
+                "inline": "true",
+            }, {
+                "@items": 0
+            });
+    }
+    if (args.length ==1){
+        var numblock = py2block.convert(args[0]);
+    return block("dicts_todict", func.lineno, {}, {
+            'VAR': numblock,
+        }, {
+            "inline": "false"
+        });
+    }
+}

boards/default_src/python/converters/lists.js

@@ -0,0 +1,243 @@
+'use strict';
+
+pbc.assignD.get('List')['check_assign'] = function (py2block, node, targets, value) {
+    if (value._astname === "List")
+        return true;
+    return false;
+}
+
+pbc.assignD.get('List')['create_block'] = function (py2block, node, targets, value) {
+    return block("lists_create_with", node.lineno, {
+            'VAR': py2block.Name_str(targets[0])
+        },
+        py2block.convertElements("ADD", value.elts), {
+            "inline": elts.length < 4 ? "false" : "true",
+        }, {
+            "@items": value.elts.length
+        });
+}
+
+
+//mylist[0]在python_to_blockly.js中实现
+//mylist[0:2]在python_to_blockly.js中实现
+
+
+function listTrig(mode){
+    function converter(py2block, func, args, keywords, starargs, kwargs, node){
+        if (args.length !== 1) {
+            throw new Error("Incorrect number of arguments");
+        }
+        var argblock = py2block.convert(args[0]);
+        return block("list_trig", func.lineno, {
+            'OP':mode
+        }, {
+            "data": argblock,
+        }, {
+            "inline": "true"
+        });
+    };
+    return converter;
+}
+
+pbc.globalFunctionD['sum'] = listTrig('SUM');
+pbc.globalFunctionD['math_mean'] = listTrig('AVERAGE');
+pbc.globalFunctionD['math_median'] = listTrig('MEDIAN');
+pbc.globalFunctionD['math_modes'] = listTrig('MODE');
+pbc.globalFunctionD['math_standard_deviation'] = listTrig('STD_DEV');
+
+
+//mylist[0] = 0在python_to_blockly.js中实现
+
+
+pbc.objectFunctionD.get('insert')['List'] = function(py2block, func, args, keywords, starargs, kwargs, node){
+    if (args.length !== 2) {
+        throw new Error("Incorrect number of arguments");
+    }
+    var objblock = py2block.convert(func.value);
+    var atblock = py2block.convert(args[0]);
+    var valblock = py2block.convert(args[1]);
+    return [block("lists_insert_value", func.lineno, {}, {
+        "LIST": objblock,
+        "AT": atblock,
+        "VALUE": valblock,
+    }, {
+        "inline": "true"
+    })];
+};
+
+function listAppendExtend(mode){
+    function converter(py2block, func, args, keywords, starargs, kwargs, node){
+        if (args.length !== 1) {
+            throw new Error("Incorrect number of arguments");
+        }
+        var objblock = py2block.convert(func.value);
+        var argblock = py2block.convert(args[0]);
+        return [block("lists_append_extend", func.lineno, {
+            "OP":mode
+        }, {
+            "LIST": objblock,
+            "DATA": argblock
+        }, {
+            "inline": "true"
+        })];
+    };
+    return converter;
+}
+pbc.objectFunctionD.get('append')['List'] = listAppendExtend('append');
+pbc.objectFunctionD.get('extend')['List'] = listAppendExtend('extend');
+
+
+//del mylist[0]在python_to_blockly.js中实现
+
+pbc.objectFunctionD.get('remove')['List'] = function(py2block, func, args, keywords, starargs, kwargs, node){
+    if (args.length !== 1) {
+        throw new Error("Incorrect number of arguments");
+    }
+    var objblock = py2block.convert(func.value);
+    var argblock = py2block.convert(args[0]);
+    return [block("lists_remove_at", func.lineno, {
+        "OP":"remove"
+    }, {
+        "LIST": objblock,
+        "DATA": argblock
+    }, {
+        "inline": "true"
+    })];
+};
+
+
+//mylist.pop(0)在set.js中实现
+//random.choice(mylist)在text.js中实现
+
+function listFindCount(mode){
+    function converter(py2block, func, args, keywords, starargs, kwargs, node){
+        if (args.length !== 1) {
+            throw new Error("Incorrect number of arguments");
+        }
+        var objblock = py2block.convert(func.value);
+        var argblock = py2block.convert(args[0]);
+        return block("lists_find", func.lineno, {
+            'OP':mode
+        }, {
+            "VAR": objblock,
+            "data": argblock
+        }, {
+            "inline": "true"
+        });
+    };
+    return converter;
+}
+pbc.objectFunctionD.get('index')['List'] = listFindCount('INDEX');
+pbc.objectFunctionD.get('count')['List'] = listFindCount('COUNT');
+
+
+pbc.globalFunctionD['lists_sort'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
+    if (args.length !== 3 && args[1]._astname === "Str"
+        && args[2]._astname === "Name") {
+        throw new Error("Incorrect number of arguments");
+    }
+    var argblock = py2block.convert(args[0]);
+    var type = py2block.Str_value(args[1]);
+    var reverse = py2block.Name_str(args[2]);
+    if(reverse == "True"){
+        reverse = '-1';
+    }else if(reverse == "False"){
+        reverse = '1';
+    }else{
+        throw new Error("not implement");
+    }
+    return block("lists_sort", func.lineno, {
+        'TYPE': type,
+        'DIRECTION':reverse
+    }, {
+        'LIST': argblock
+    }, {
+        "inline": "true"
+    });
+}
+
+
+pbc.objectFunctionD.get('reverse')['List'] = function(py2block, func, args, keywords, starargs, kwargs, node){
+    if (args.length !== 0) {
+        throw new Error("Incorrect number of arguments");
+    }
+    var objblock = py2block.convert(func.value);
+    return [block("lists_reverse", func.lineno, {}, {
+        "VAR": objblock,
+    }, {
+        "inline": "true"
+    })];
+};
+
+
+pbc.objectFunctionD.get('clear')['List'] = function(py2block, func, args, keywords, starargs, kwargs, node){
+    if (args.length !== 0) {
+        throw new Error("Incorrect number of arguments");
+    }
+    var objblock = py2block.convert(func.value);
+    return [block("lists_clear", func.lineno, {}, {
+        "VAR": objblock,
+    }, {
+        "inline": "true"
+    })];
+};
+
+pbc.globalFunctionD['list'] = function(py2block, func, args, keywords, starargs, kwargs, node){
+    if (args.length > 1) {
+        throw new Error("Incorrect number of arguments");
+    }
+    if (args.length ==0){
+        return block("lists_create_with_noreturn", node.lineno, {},{}
+            , {
+                "inline": "true",
+            }, {
+                "@items": 0
+            });
+    }
+    if (args.length ==1){
+        var numblock = py2block.convert(args[0]);
+    return block("list_tolist", func.lineno, {}, {
+            'VAR': numblock,
+        }, {
+            "inline": "false"
+        })
+    }
+}
+
+pbc.globalFunctionD['zip'] = function(py2block, func, args, keywords, starargs, kwargs, node){    
+    
+        var d = py2block.convertElements("ADD", args);
+        
+        return block("lists_zip", node.lineno, {
+        }, d, {
+            "inline": "true",
+        }, {
+            "@items":args.length
+        });
+    }
+
+pbc.moduleFunctionD.get('random')['sample'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
+    if (args.length !== 2) {
+        throw new Error("Incorrect number of arguments");
+    }
+    var listname = py2block.convert(args[0]);
+    var varblock = py2block.convert(args[1]);
+    return block("lists_get_random_sublist", func.lineno, {}, {
+        'LIST':listname,
+        'VAR': varblock
+    }, {
+        "inline": "true"
+    });
+}
+
+pbc.objectFunctionD.get('tolist')['List'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
+        if (args.length !== 0) {
+            throw new Error("Incorrect number of arguments");
+        }
+        var objblock = py2block.convert(func.value);
+        return block("list_tolist2", func.lineno, {}, {
+            "VAR": objblock
+        }, {
+            "inline": "true"
+        });
+    }

boards/default_src/python/converters/logic.js

@@ -0,0 +1,15 @@
+'use strict';
+
+
+//目前块都在python_to_blockly.js中实现
+pbc.globalFunctionD['bool'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
+    if (args.length != 1) {
+        throw new Error("Incorrect number of arguments");
+    }
+    var numblock = py2block.convert(args[0]);
+    return block("logic_tobool", func.lineno, {}, {
+            'VAR': numblock,
+        }, {
+            "inline": "false"
+        });
+}

boards/default_src/python/converters/math.js

@@ -0,0 +1,389 @@
+'use strict';
+
+//加减乘除 在python_to_blockly.js中实现
+//位操作 在python_to_blockly.js中实现
+function mathDecchange(mode) {
+    function converter(py2block, func, args, keywords, starargs, kwargs, node) {
+        if (args.length != 1) {
+            throw new Error("Incorrect number of arguments");
+        }
+        
+            return block("math_dec", func.lineno, {
+                'OP': mode
+            }, {
+                'NUM': py2block.convert(args[0])
+            }, {
+                "inline": "true"
+            });
+        
+    }
+
+    return converter;
+}
+
+pbc.globalFunctionD['bin'] = mathDecchange('bin');
+pbc.globalFunctionD['oct'] = mathDecchange('oct');
+pbc.globalFunctionD['hex'] = mathDecchange('hex');
+
+function mathTrigonometric(mode) {
+    function converter(py2block, func, args, keywords, starargs, kwargs, node) {
+        if (args.length != 1) {
+            throw new Error("Incorrect number of arguments");
+        }
+        // if (args[0]._astname == "Call"
+        //     && args[0].func._astname == "Attribute"
+        //     && args[0].func.value._astname == "Name"
+        //     && py2block.Name_str(args[0].func.value) == "math"
+        //     && py2block.identifier(args[0].func.attr) == "radians"
+        //     && args[0].args.length == 1) {
+            return block("math_trig", func.lineno, {
+                'OP': mode
+            }, {
+                'NUM': py2block.convert(args[0])
+            }, {
+                "inline": "true"
+            });
+        // } else {
+        //     throw new Error("not implement math." + mode);
+        // }
+
+
+    }
+
+    return converter;
+}
+
+pbc.moduleFunctionD.get('math')['sin'] = mathTrigonometric('SIN');
+pbc.moduleFunctionD.get('math')['cos'] = mathTrigonometric('COS');
+pbc.moduleFunctionD.get('math')['tan'] = mathTrigonometric('TAN');
+
+function mathAntiTrigonometric() {
+    function converter(py2block, func, args, keywords, starargs, kwargs, node) {
+        if (args.length != 1) {
+            throw new Error("Incorrect number of arguments");
+        }
+        if (args[0]._astname == "Call"
+            && args[0].func._astname == "Attribute"
+            && args[0].func.value._astname == "Name"
+            && py2block.Name_str(args[0].func.value) == "math"
+            && (py2block.identifier(args[0].func.attr) == "asin"
+                || py2block.identifier(args[0].func.attr) == "acos"
+                || py2block.identifier(args[0].func.attr) == "atan")
+            && args[0].args.length == 1) {
+            return block("math_trig", func.lineno, {
+                'OP': py2block.identifier(args[0].func.attr).toUpperCase()
+            }, {
+                'NUM': py2block.convert(args[0].args[0])
+            }, {
+                "inline": "true"
+            });
+        } else {
+            throw new Error("not implement math.degrees");
+        }
+    }
+
+    return converter;
+}
+
+pbc.moduleFunctionD.get('math')['degrees'] = mathAntiTrigonometric();
+
+function mathLogOrExp(mode) {
+    function converter(py2block, func, args, keywords, starargs, kwargs, node) {
+        if (mode != "POW10") {
+            if (args.length != 1) {
+                throw new Error("Incorrect number of arguments");
+            }
+            return block("math_trig", func.lineno, {
+                'OP': mode
+            }, {
+                'NUM': py2block.convert(args[0])
+            }, {
+                "inline": "true"
+            });
+        } else {
+            if (args.length != 2) {
+                throw new Error("Incorrect number of arguments");
+            }
+            return block("math_trig", func.lineno, {
+                'OP': mode
+            }, {
+                'NUM': py2block.convert(args[1])
+            }, {
+                "inline": "true"
+            });
+        }
+    }
+
+    return converter;
+}
+
+pbc.moduleFunctionD.get('math')['log'] = mathLogOrExp('LN');
+pbc.moduleFunctionD.get('math')['log10'] = mathLogOrExp('LOG10');
+pbc.moduleFunctionD.get('math')['exp'] = mathLogOrExp('EXP');
+pbc.moduleFunctionD.get('math')['pow'] = mathLogOrExp('POW10');
+
+
+function mathIntFunc(mode) {
+    function converter(py2block, func, args, keywords, starargs, kwargs, node) {
+        if (args.length != 1) {
+            throw new Error("Incorrect number of arguments");
+        }
+        var varblock = py2block.convert(args[0]);
+        return block("math_to_int", func.lineno, {
+            'OP': mode
+        }, {
+            'A': varblock
+        }, {
+            "inline": "true"
+        });
+    }
+
+    return converter;
+}
+
+pbc.globalFunctionD['round'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
+    if (args.length !== 1 && args.length !== 2) {
+        throw new Error("Incorrect number of arguments");
+    }
+    if (args.length == 1){
+    var varblock = py2block.convert(args[0]);
+    return block("math_to_int", func.lineno, {
+        'OP': "round"
+    }, {
+        'A': varblock
+    }, {
+        "inline": "true"
+    });
+    }
+    if (args.length == 2){
+    var varblock = py2block.convert(args[0]);
+    var varblock1 = py2block.convert(args[1]);
+    return block("math_round", func.lineno, {}, {
+        'VALUE': varblock,
+        'VAR': varblock1
+    }, {
+        "inline": "true"
+    });
+    }
+
+}
+
+
+pbc.moduleFunctionD.get('math')['sqrt'] = mathIntFunc('sqrt');
+pbc.moduleFunctionD.get('math')['ceil'] = mathIntFunc('ceil');
+pbc.moduleFunctionD.get('math')['floor'] = mathIntFunc('floor');
+pbc.moduleFunctionD.get('math')['fabs'] = mathIntFunc('fabs');
+
+
+function mathMaxMin(mode) {
+    function converter(py2block, func, args, keywords, starargs, kwargs, node) {
+        if (args.length === 2) {
+            if (args[0]._astname == "Call"
+                && args[0].func._astname == "Name"
+                && py2block.Name_str(args[0].func) == "max"
+                && py2block.Name_str(func) == "min") {
+                return block("math_constrain", func.lineno, {}, {
+                    'VALUE': py2block.convert(args[0].args[0]),
+                    'LOW': py2block.convert(args[0].args[1]),
+                    'HIGH': py2block.convert(args[1])
+                }, {
+                    "inline": "true"
+                });
+            } else {
+                var ablock = py2block.convert(args[0]);
+                var bblock = py2block.convert(args[1]);
+                return block("math_max_min", func.lineno, {
+                    'OP': mode
+                }, {
+                    'A': ablock,
+                    'B': bblock
+                }, {
+                    "inline": "true"
+                });
+            }
+        } else if (args.length === 1) {
+            var argblock = py2block.convert(args[0]);
+            return block("list_trig", func.lineno, {
+                'OP': mode.toUpperCase()
+            }, {
+                'data': argblock
+            }, {
+                "inline": "true"
+            });
+        } else {
+            throw new Error("Incorrect number of arguments");
+        }
+    }
+    return converter;
+}
+
+pbc.globalFunctionD['max'] = mathMaxMin('max');
+pbc.globalFunctionD['min'] = mathMaxMin('min');
+
+
+function mathRandom(mode) {
+    function converter(py2block, func, args, keywords, starargs, kwargs, node) {
+        if (args.length != 2) {
+            throw new Error("Incorrect number of arguments");
+        }
+        var fromblock = py2block.convert(args[0]);
+        var toblock = py2block.convert(args[1]);
+        return block("math_random", func.lineno, {
+            'TYPE': mode
+        }, {
+            'FROM': fromblock,
+            'TO': toblock
+        }, {
+            "inline": "true"
+        });
+    }
+
+    return converter;
+}
+
+pbc.moduleFunctionD.get('random')['randint'] = mathRandom('int');
+pbc.moduleFunctionD.get('random')['uniform'] = mathRandom('float');
+
+pbc.moduleFunctionD.get('random')['seed'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
+    if (args.length !== 1) {
+        throw new Error("Incorrect number of arguments");
+    }
+    var varblock = py2block.convert(args[0]);
+    return [block("math_random_seed", func.lineno, {}, {
+        'NUM': varblock
+    }, {
+        "inline": "true"
+    })];
+}
+
+function radixToEng(num) {
+    if (num == 2) {
+        return 'two';
+    } else if (num == 8) {
+        return 'eight';
+    } else if (num == 10) {
+        return 'ten';
+    } else if (num == 16) {
+        return 'sixteen';
+    } else {
+        return "unknown";
+    }
+}
+
+pbc.globalFunctionD['int'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
+    if (args.length == 1) {
+        var paramblock = py2block.convert(args[0]);
+        if (args[0]._astname == "Call" && args[0].func._astname == "Name" && py2block.Name_str(args[0].func) == "str") {
+            paramblock = py2block.convert(args[0].args[0]);
+        }else if(args[0]._astname == "Call" && args[0].func._astname == "Name" && py2block.Name_str(args[0].func) == "input"){
+            if(pbc.board == pbc.MIXPY) {
+                paramblock = py2block.convert(args[0].args[0]);
+                return block("inout_type_input", func.lineno, {
+                    "DIR": "int"
+                }, {
+                    'VAR': paramblock
+                }, {
+                    "inline": "true"
+                });
+            }
+        }else if(args[0]._astname == "Call" && args[0].func._astname == "Attribute" && args[0].func.attr.v == "input"){
+            if(pbc.board == pbc.MIXPY) {
+                paramblock = py2block.convert(args[0].args[0]);
+                return block("inout_type_input", func.lineno, {
+                    "DIR": "int"
+                }, {
+                    'VAR': paramblock
+                }, {
+                    "inline": "true"
+                });
+            }
+        }
+        return block("text_to_number", func.lineno, {
+            'TOWHAT': "int"
+        }, {
+            'VAR': paramblock,
+        }, {
+            "inline": "true"
+        });
+    } else if (args.length == 2) {
+        if (args[0]._astname == "Call" && args[0].func._astname == "Name" && py2block.Name_str(args[0].func) == "str"
+            && args[1]._astname == "Num") {
+            var paramblock = py2block.convert(args[0].args[0]);
+            return block("math_number_base_conversion", func.lineno, {
+                'OP': radixToEng(args[1].n.v),
+                'OP2': 'ten'
+            }, {
+                'NUM': paramblock,
+            }, {
+                "inline": "true"
+            });
+        }
+    }
+    throw new Error("Incorrect number of arguments");
+}
+
+
+/*function radix(mode){
+    function converter(py2block, func, args, keywords, starargs, kwargs, node) {
+        if (args.length != 1) {
+            throw new Error("Incorrect number of arguments");
+        }
+        if (args[0]._astname == "Call"
+            && args[0].func._astname == "Name" && py2block.Name_str(args[0].func) == "int"
+            && args[0].args[0]._astname == "Call" && args[0].args[0].func._astname == "Name" && py2block.Name_str(args[0].args[0].func) == "str") {
+            var paramblock = py2block.convert(args[0].args[0].args[0]);
+            return block("math_number_base_conversion", func.lineno, {
+                'OP': radixToEng(args[0].args[1].n.v),
+                'OP2': mode
+            }, {
+                'NUM': paramblock,
+            }, {
+                "inline": "true"
+            });
+        }
+    }
+    return converter;
+}
+
+pbc.globalFunctionD['hex'] = radix('sixteen');
+pbc.globalFunctionD['oct'] = radix('eight');
+pbc.globalFunctionD['bin'] = radix('two');*/
+
+
+pbc.globalFunctionD['math_map'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
+    if (args.length !== 5) {
+        throw new Error("Incorrect number of arguments");
+    }
+    return block("math_map", func.lineno, {}, {
+        'NUM': py2block.convert(args[0]),
+        'fromLow': py2block.convert(args[1]),
+        'fromHigh': py2block.convert(args[2]),
+        'toLow': py2block.convert(args[3]),
+        'toHigh': py2block.convert(args[4])
+    }, {
+        "inline": "true"
+    });
+}
+
+pbc.globalFunctionD['abs'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
+    if (args.length != 1) {
+        throw new Error("Incorrect number of arguments");
+    }
+    var argblock = py2block.convert(args[0]);
+    return [block("math_to_int", func.lineno, {
+        "OP":'fabs'
+    }, {
+        'A': argblock
+    }, {
+            "inline": "true"
+        })];
+}
+
+function mathConstant(py2block, node, value, attr) {
+    return block('math_constant', node.lineno, {
+        'CONSTANT': value
+    }, {});
+}
+
+pbc.moduleAttrD.get('math')['pi'] = mathConstant;
+pbc.moduleAttrD.get('math')['e'] = mathConstant;

boards/default_src/python/converters/set.js

@@ -0,0 +1,180 @@
+'use strict';
+
+pbc.assignD.get('Set')['check_assign'] = function (py2block, node, targets, value) {
+    if (value._astname === "Set")
+        return true;
+    return false;
+}
+
+pbc.assignD.get('Set')['create_block'] = function (py2block, node, targets, value) {
+    return block("set_create_with", node.lineno, {
+            'VAR': py2block.Name_str(targets[0])
+        },
+        py2block.convertElements("ADD", value.elts), {
+            "inline": "false",
+        }, {
+            "@items": value.elts.length
+        });
+}
+
+//len在text里实现
+
+pbc.objectFunctionD.get('pop')['Set'] = function(py2block, func, args, keywords, starargs, kwargs, node){
+    if (args.length === 0) {
+        var popblock = py2block.convert(func.value);
+        return block("set_pop", func.lineno, {}, {
+            "SET":popblock
+        }, {
+            "inline": "true"
+        });
+    }else if(args.length === 1){
+        var objblock = py2block.convert(func.value);
+        var argblock = py2block.convert(args[0]);
+        return block("lists_pop", func.lineno, {}, {
+            "LIST":objblock,
+            "VALUE":argblock
+        }, {
+            "inline": "true"
+        });
+    }else{
+        throw new Error("Incorrect number of arguments");
+    }
+
+}
+
+
+//tuple(mytuple), set(mytup)在lists.js中实现
+
+function setOperate(mode){
+    function converter(py2block, func, args, keywords, starargs, kwargs, node) {
+        if (args.length !== 1) {
+            throw new Error("Incorrect number of arguments");
+        }
+        var objblock = py2block.convert(func.value);
+        var argblock = py2block.convert(args[0]);
+        return block("set_operate", func.lineno, {
+            'OPERATE': mode,
+        }, {
+            "SET1": objblock,
+            "SET2": argblock
+        }, {
+            "inline": "true"
+        });
+    }
+    return converter;
+}
+
+pbc.objectFunctionD.get('union')['Set'] = setOperate('union');
+pbc.objectFunctionD.get('intersection')['Set'] = setOperate('intersection');
+pbc.objectFunctionD.get('difference')['Set'] =  setOperate('difference');
+
+
+pbc.objectFunctionD.get('update')['Set'] = function(py2block, func, args, keywords, starargs, kwargs, node){
+    if (args.length !== 1) {
+        throw new Error("Incorrect number of arguments");
+    }
+    var objblock = py2block.convert(func.value);
+    var argblock = py2block.convert(args[0]);
+    return [block("set_update", func.lineno, {}, {
+        "SET": objblock,
+        "VAR": argblock
+    }, {
+        "inline": "true"
+    })];
+};
+
+
+function setOperateUpdate(mode){
+    function converter(py2block, func, args, keywords, starargs, kwargs, node) {
+        if (args.length !== 1) {
+            throw new Error("Incorrect number of arguments");
+        }
+        var objblock = py2block.convert(func.value);
+        var argblock = py2block.convert(args[0]);
+        return [block("set_operate_update", func.lineno, {
+            'OPERATE': mode,
+        }, {
+            "SET1": objblock,
+            "SET2": argblock
+        }, {
+            "inline": "true"
+        })];
+    }
+    return converter;
+}
+
+
+
+pbc.objectFunctionD.get('difference_update')['Set'] = setOperateUpdate('difference_update');
+pbc.objectFunctionD.get('intersection_update')['Set'] = setOperateUpdate('intersection_update');
+
+
+function setAddDiscard(mode){
+    function converter(py2block, func, args, keywords, starargs, kwargs, node) {
+        if (args.length !== 1) {
+            throw new Error("Incorrect number of arguments");
+        }
+        var objblock = py2block.convert(func.value);
+        var argblock = py2block.convert(args[0]);
+        return [block("set_add_discard", func.lineno, {
+            'OPERATE':mode,
+        }, {
+            "SET":objblock,
+            "data":argblock
+        }, {
+            "inline": "true"
+        })];
+    }
+    return converter;
+}
+
+pbc.objectFunctionD.get('add')['Set'] = setAddDiscard('add');
+pbc.objectFunctionD.get('discard')['Set'] = setAddDiscard('discard');
+
+
+function setSub(mode){
+    function converter(py2block, func, args, keywords, starargs, kwargs, node) {
+        if (args.length !== 1) {
+            throw new Error("Incorrect number of arguments");
+        }
+        var objblock = py2block.convert(func.value);
+        var argblock = py2block.convert(args[0]);
+        return block("set_sub", func.lineno, {
+            'OPERATE':mode,
+        }, {
+            "SET1":objblock,
+            "SET2":argblock
+        }, {
+            "inline": "true"
+        });
+    }
+    return converter;
+}
+
+pbc.globalFunctionD['set'] = function(py2block, func, args, keywords, starargs, kwargs, node){
+    if (args.length > 1) {
+        throw new Error("Incorrect number of arguments");
+    }
+    if (args.length ==0){
+        return block("set_create_with_noreturn", node.lineno, {},{}
+            , {
+                "inline": "true",
+            }, {
+                "@items": 0
+            });
+    }
+    if (args.length ==1){
+        var numblock = py2block.convert(args[0]);
+    return block("set_toset", func.lineno, {}, {
+            'VAR': numblock,
+        }, {
+            "inline": "false"
+        });
+    }
+}
+
+
+
+pbc.objectFunctionD.get('issubset')['Set'] = setSub('issubset');
+pbc.objectFunctionD.get('issuperset')['Set'] = setSub('issuperset');
+

boards/default_src/python/converters/storage.js

@@ -0,0 +1,359 @@
+'use strict';
+
+var fileClass = 'open';
+
+
+
+
+pbc.globalFunctionD['open'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
+    if (args.length !== 2) {
+        throw new Error("Incorrect number of arguments");
+    }    
+    if (keywords.length == 0) {
+    var varblock = py2block.convert(args[0]);
+    var mode = py2block.Str_value(args[1]);
+   return block("storage_fileopen_new", node.lineno, {
+        "MODE":mode
+    }, {
+        "FILENAME":varblock
+    });
+    }
+    if (keywords.length == 1) {
+    var varblock = py2block.convert(args[0]);
+    var mode = py2block.Str_value(args[1]);
+    var code = py2block.Str_value(keywords[0].value);
+   return block("storage_fileopen_new_encoding", node.lineno, {
+        "MODE":mode,
+        "CODE":code
+    }, {
+        "FILENAME":varblock
+    });
+    }
+
+}
+
+pbc.objectFunctionD.get('write')[fileClass] = function(py2block, func, args, keywords, starargs, kwargs, node){
+    if (args.length !== 1) {
+        throw new Error("Incorrect number of arguments");
+    }
+    var fileblock = py2block.convert(func.value);
+    var argblock = py2block.convert(args[0]);
+    return [block("storage_file_write", func.lineno, {}, {
+        "FILE" : fileblock,
+        "data" :argblock
+    }, {
+        "inline": "true"
+    })];
+}
+
+
+pbc.objectFunctionD.get('read')[fileClass] = function(py2block, func, args, keywords, starargs, kwargs, node){
+    if (args.length == 1) {
+    var fileblock = py2block.convert(func.value);
+    var argblock = py2block.convert(args[0]);
+    return block("storage_get_contents", func.lineno, {
+        "MODE":"read"
+    }, {
+         "FILE" : fileblock,
+         "SIZE" : argblock
+    }, {
+        "inline": "true"
+    });
+    }
+    if (args.length == 0) {
+    var fileblock = py2block.convert(func.value);
+    return block("storage_get_contents_without_para", func.lineno, {
+        "MODE":"read"
+    }, {
+         "FILE" : fileblock
+    }, {
+        "inline": "true"
+    });
+    }
+    else{
+        throw new Error("Incorrect number of arguments");
+    }
+}
+
+
+pbc.objectFunctionD.get('readline')[fileClass] = function(py2block, func, args, keywords, starargs, kwargs, node){
+    if (args.length == 1) {
+    var fileblock = py2block.convert(func.value);
+    var argblock = py2block.convert(args[0]);
+    return block("storage_get_contents", func.lineno, {
+        "MODE":"readline"
+    }, {
+         "FILE" : fileblock,
+         "SIZE" : argblock
+    }, {
+        "inline": "true"
+    });
+    }
+    if (args.length == 0) {
+    var fileblock = py2block.convert(func.value);
+    return block("storage_get_contents_without_para", func.lineno, {
+        "MODE":"readline"
+    }, {
+         "FILE" : fileblock
+    }, {
+        "inline": "true"
+    });
+    }
+    else{
+        throw new Error("Incorrect number of arguments");
+    }
+}
+
+pbc.objectFunctionD.get('readlines')[fileClass] = function(py2block, func, args, keywords, starargs, kwargs, node){
+    if (args.length == 1) {
+    var fileblock = py2block.convert(func.value);
+    var argblock = py2block.convert(args[0]);
+    return block("storage_get_contents", func.lineno, {
+        "MODE":"readlines"
+    }, {
+         "FILE" : fileblock,
+         "SIZE" : argblock
+    }, {
+        "inline": "true"
+    });
+    }
+    if (args.length == 0) {
+    var fileblock = py2block.convert(func.value);
+    return block("storage_get_contents_without_para", func.lineno, {
+        "MODE":"readlines"
+    }, {
+         "FILE" : fileblock
+    }, {
+        "inline": "true"
+    });
+    }
+    else{
+        throw new Error("Incorrect number of arguments");
+    }
+}
+
+
+pbc.objectFunctionD.get('writable')[fileClass] = function(py2block, func, args, keywords, starargs, kwargs, node){
+    if (args.length !== 0) {
+        throw new Error("Incorrect number of arguments");
+    }
+    var fileblock = py2block.convert(func.value);
+    return block("storage_can_write_ornot", func.lineno, {}, {
+        "FILE" : fileblock,
+    }, {
+        "inline": "true"
+    });
+}
+
+
+pbc.objectFunctionD.get('name')[fileClass] = function(py2block, func, args, keywords, starargs, kwargs, node){
+    if (args.length !== 0) {
+        throw new Error("Incorrect number of arguments");
+    }
+    var fileblock = py2block.convert(func.value);
+    return block("storage_get_filename", func.lineno, {}, {
+         "FILE" : fileblock
+    }, {
+        "inline": "true"
+    });
+}
+
+
+pbc.objectFunctionD.get('close')[fileClass] = function(py2block, func, args, keywords, starargs, kwargs, node){
+    if (args.length !== 0) {
+        throw new Error("Incorrect number of arguments");
+    }
+    var fileblock = py2block.convert(func.value);
+    return [block("storage_close_file", func.lineno, {}, {
+        "FILE" : fileblock
+    }, {
+        "inline": "true"
+    })];
+}
+
+
+pbc.moduleFunctionD.get('os')['listdir'] = function(py2block, func, args, keywords, starargs, kwargs, node){
+    if (args.length !== 0) {
+        throw new Error("Incorrect number of arguments");
+    }
+    return block("storage_list_all_files", func.lineno, {}, {
+    }, {
+        "inline": "true"
+    });
+}
+
+
+pbc.moduleFunctionD.get('os')['remove'] = function(py2block, func, args, keywords, starargs, kwargs, node){
+    if (args.length !== 1) {
+        throw new Error("Incorrect number of arguments");
+    }
+    var argblock = py2block.convert(args[0]);
+    return [block("storage_delete_file", func.lineno, {"MODE":"remove"}, {
+         "FILE" : argblock
+    }, {
+        "inline": "true"
+    })];
+}
+
+pbc.moduleFunctionD.get('os')['removedirs'] = function(py2block, func, args, keywords, starargs, kwargs, node){
+    if (args.length !== 1) {
+        throw new Error("Incorrect number of arguments");
+    }
+    var argblock = py2block.convert(args[0]);
+    return [block("storage_delete_file", func.lineno, {"MODE":"removedirs"}, {
+         "FILE" : argblock
+    }, {
+        "inline": "true"
+    })];
+}
+pbc.moduleFunctionD.get('os')['size'] = function(py2block, func, args, keywords, starargs, kwargs, node){
+    if (args.length !== 1) {
+        throw new Error("Incorrect number of arguments");
+    }
+    var argblock = py2block.convert(args[0]);
+    return block("storage_get_file_size", func.lineno, {}, {
+         "FILE" : argblock
+    }, {
+        "inline": "true"
+    });
+}
+
+pbc.objectFunctionD.get('seek')[fileClass] = function(py2block, func, args, keywords, starargs, kwargs, node){
+    if (args.length !== 2) {
+        throw new Error("Incorrect number of arguments");
+    }
+    var fileblock = py2block.convert(func.value);
+    var argblock = py2block.convert(args[0]);
+    if(args[1].n.v=="0"){
+        var mode = "start";
+    }
+    else if(args[1].n.v=="1"){
+        var mode = "current";
+    }
+    else{
+        var mode = "end";
+    }
+    return [block("storage_file_seek", func.lineno, {
+        "MODE": mode
+    }, {
+         "FILE" : fileblock,
+         "SIZE" : argblock
+    }, {
+        "inline": "true"
+    })];
+}
+
+pbc.objectFunctionD.get('tell')[fileClass] = function(py2block, func, args, keywords, starargs, kwargs, node){
+    if (args.length !== 0) {
+        throw new Error("Incorrect number of arguments");
+    }
+    var fileblock = py2block.convert(func.value);
+    return block("storage_file_tell", func.lineno, {
+    }, {
+         "FILE" : fileblock,
+    }, {
+        "inline": "true"
+    });
+}
+
+pbc.moduleFunctionD.get('os')['chdir'] = function(py2block, func, args, keywords, starargs, kwargs, node){
+    if (args.length !== 1) {
+        throw new Error("Incorrect number of arguments");
+    }
+    var argblock = py2block.convert(args[0]);
+    return [block("storage_change_dir", func.lineno, {}, {
+         "FILE" : argblock
+    }, {
+        "inline": "true"
+    })];
+}
+
+pbc.moduleFunctionD.get('os')['getcwd'] = function(py2block, func, args, keywords, starargs, kwargs, node){
+    if (args.length !== 0) {
+        throw new Error("Incorrect number of arguments");
+    }
+    return block("storage_get_current_dir", func.lineno, {}, {
+    }, {
+        "inline": "true"
+    });
+}
+
+pbc.moduleFunctionD.get('os')['mkdir'] = function(py2block, func, args, keywords, starargs, kwargs, node){
+    if (args.length !== 1) {
+        throw new Error("Incorrect number of arguments");
+    }
+    var fun = func.attr.v;
+    var argblock = py2block.convert(args[0]);
+    return [block("storage_make_dir", func.lineno, {"MODE":fun}, {
+         "PATH" : argblock
+    }, {
+        "inline": "true"
+    })];
+}
+
+pbc.moduleFunctionD.get('os')['makedirs'] = function(py2block, func, args, keywords, starargs, kwargs, node){
+    if (args.length !== 1) {
+        throw new Error("Incorrect number of arguments");
+    }
+    var fun = func.attr.v;
+    var argblock = py2block.convert(args[0]);
+    return [block("storage_make_dir", func.lineno, {"MODE":fun}, {
+         "PATH" : argblock
+    }, {
+        "inline": "true"
+    })];
+}
+
+pbc.moduleFunctionD.get('os')['rename'] = function(py2block, func, args, keywords, starargs, kwargs, node){
+    if (args.length !== 2) {
+        throw new Error("Incorrect number of arguments");
+    }
+    var argblock = py2block.convert(args[0]);
+    var arg1block = py2block.convert(args[1]);
+    return [block("storage_rename", func.lineno, {}, {
+         "FILE" : argblock,
+         "NEWFILE":arg1block
+    }, {
+        "inline": "true"
+    })];
+}
+
+pbc.moduleFunctionD.get('os')['isfile'] = function(py2block, func, args, keywords, starargs, kwargs, node){
+    if (args.length !== 1) {
+        throw new Error("Incorrect number of arguments");
+    }
+    var fun = func.attr.v;
+    var argblock = py2block.convert(args[0]);
+    return [block("storage_is_file", func.lineno, {"MODE":fun}, {
+         "FILE" : argblock
+    }, {
+        "inline": "true"
+    })];
+}
+
+pbc.moduleFunctionD.get('os')['startfile'] = function(py2block, func, args, keywords, starargs, kwargs, node){
+    if (args.length !== 1) {
+        throw new Error("Incorrect number of arguments");
+    }
+    var fun = func.attr.v;
+    var argblock = py2block.convert(args[0]);
+    return [block("storage_open_file_with_os", func.lineno, {"MODE":fun}, {
+         "fn" : argblock
+    }, {
+        "inline": "true"
+    })];
+}
+
+pbc.moduleFunctionD.get('os')['isdir'] = function(py2block, func, args, keywords, starargs, kwargs, node){
+    if (args.length !== 1) {
+        throw new Error("Incorrect number of arguments");
+    }
+    var fun = func.attr.v;
+    var argblock = py2block.convert(args[0]);
+    return [block("storage_is_file", func.lineno, {"MODE":fun}, {
+         "FILE" : argblock
+    }, {
+        "inline": "true"
+    })];
+}
+

boards/default_src/python/converters/text.js

@@ -0,0 +1,377 @@
+'use strict';
+
+//01."text" 在 python_to_blockly.js实现
+
+//02.str('Hello') + str('Mixly') 在 python_to_blockly.js实现
+
+//03.int(str('123'))这种形式的，在math.js实现
+function numConvert(mode) {
+    function converter(py2block, func, args, keywords, starargs, kwargs, node) {
+        if ((mode != 'b' && args.length != 1) || (mode == 'b' && args.length != 2)) {
+            throw new Error("Incorrect number of arguments");
+        }
+        var paramblock = py2block.convert(args[0]);
+        if (args[0]._astname == "Call" && args[0].func._astname == "Name" && py2block.Name_str(args[0].func) == "str") {
+            paramblock = py2block.convert(args[0].args[0]);
+        }else if(args[0]._astname == "Call" && args[0].func._astname == "Name" && py2block.Name_str(args[0].func) == "input"){
+            if(pbc.board == pbc.MIXPY) {
+                paramblock = py2block.convert(args[0].args[0]);
+                return block("inout_type_input", func.lineno, {
+                    "DIR": "float"
+                }, {
+                    'VAR': paramblock
+                }, {
+                    "inline": "true"
+                });
+            }
+        }else if(args[0]._astname == "Call" && args[0].func._astname == "Attribute" && args[0].func.attr.v == "input"){
+            if(pbc.board == pbc.MIXPY) {
+                paramblock = py2block.convert(args[0].args[0]);
+                return block("inout_type_input", func.lineno, {
+                    "DIR": "float"
+                }, {
+                    'VAR': paramblock
+                }, {
+                    "inline": "true"
+                });
+            }
+        }
+        return block("text_to_number", func.lineno, {
+            'TOWHAT': mode
+        }, {
+            'VAR': paramblock,
+        }, {
+            "inline": "false"
+        });
+    }
+    return converter;
+}
+
+pbc.globalFunctionD['float'] = numConvert('float');
+pbc.globalFunctionD['bytes'] = numConvert('b');
+
+
+pbc.globalFunctionD['chr'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
+    if (args.length != 1) {
+        throw new Error("Incorrect number of arguments");
+    }
+    var numblock = py2block.convert(args[0]);
+    return block("ascii_to_char", func.lineno, {}, {
+            'VAR': numblock,
+        }, {
+            "inline": "false"
+        });
+}
+
+
+pbc.globalFunctionD['ord'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
+    if (args.length != 1) {
+        throw new Error("Incorrect number of arguments");
+    }
+    var numblock = py2block.convert(args[0]);
+    return block("char_to_ascii", func.lineno, {}, {
+            'VAR': numblock,
+        }, {
+            "inline": "false"
+        });
+}
+
+
+pbc.globalFunctionD['str'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
+    if (args.length != 1) {
+        throw new Error("Incorrect number of arguments");
+    }
+    var numblock = py2block.convert(args[0]);
+    return block("number_to_text", func.lineno, {}, {
+            'VAR': numblock,
+        }, {
+            "inline": "false"
+        });
+}
+
+pbc.globalFunctionD['len'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
+    if (args.length != 1) {
+        throw new Error("Incorrect number of arguments");
+    }
+    var numblock = py2block.convert(args[0]);
+    return block("text_length", func.lineno, {}, {
+            'VAR': numblock,
+        }, {
+            "inline": "false"
+        });
+}
+
+
+// 'mixly'[0]这种形式的，在python_to_blockly.js中实现
+
+
+pbc.moduleFunctionD.get('random')['choice'] = function (py2block, func, args, keywords, starargs, kwargs, node){
+    if (args.length !== 1) {
+        throw new Error("Incorrect number of arguments");
+    }
+    var argblock = py2block.convert(args[0]);
+    var argAstname = args[0]._astname;
+    if(args[0]._astname == "Call" && args[0].func._astname == "Name" && py2block.Name_str(args[0].func) == "str"){
+        argblock = py2block.convert(args[0].args[0]);
+        argAstname = "Str";
+    }
+    if(argAstname == "Str"){
+        return block('text_random_char', func.lineno, {}, {
+            'VAR':argblock
+        }, {
+            "inline": "true"
+        });
+    }else{
+        return block('lists_get_random_item', func.lineno, {}, {
+            'LIST':argblock
+        }, {
+            "inline": "true"
+        });
+    }
+}
+
+
+//str('123') == str('234')这种形式的，在python_to_blockly.js中实现
+
+function startEndWithStr(mode){
+    function converter(py2block, func, args, keywords, starargs, kwargs, node){
+        if (args.length !== 1) {
+            throw new Error("Incorrect number of arguments");
+        }
+        var objblock = py2block.convert(func.value);
+        if(func.value._astname == "Call" && func.value.func._astname == "Name" && py2block.Name_str(func.value.func) == "str"){
+            objblock = py2block.convert(func.value.args[0]);
+        }
+        var argblock = py2block.convert(args[0]);
+        if(args[0]._astname == "Call" && args[0].func._astname == "Name" && py2block.Name_str(args[0].func) == "str"){
+            argblock = py2block.convert(args[0].args[0]);
+        }
+        return block('text_equals_starts_ends', func.lineno, {
+            'DOWHAT':mode
+        }, {
+            'STR1':objblock,
+            'STR2':argblock
+        }, {
+            "inline": "true"
+        });
+    }
+    return converter;
+}
+
+pbc.objectFunctionD.get('startswith')['Str'] = startEndWithStr('startswith');
+pbc.objectFunctionD.get('endswith')['Str'] = startEndWithStr('endswith');
+
+
+// 'mixly'[0:8]这种形式的，在python_to_blockly.js中实现
+function strTitle(mode){
+    function converter(py2block, func, args, keywords, starargs, kwargs, node) {
+        if (args.length !== 0) {
+            throw new Error("Incorrect number of arguments");
+        }
+        var textblock = py2block.convert(func.value);
+        return block("text_capital", func.lineno, {
+            'CAPITAL': mode,
+        }, {
+            "VAR": textblock,
+        }, {
+            "inline": "true"
+        });
+    }
+    return converter;
+}
+
+pbc.objectFunctionD.get('upper')['Str'] = strTitle('upper');
+pbc.objectFunctionD.get('title')['Str'] = strTitle('title');
+pbc.objectFunctionD.get('lower')['Str'] = strTitle('lower');
+pbc.objectFunctionD.get('swapcase')['Str'] = strTitle('swapcase');
+pbc.objectFunctionD.get('capitalize')['Str'] = strTitle('capitalize');
+
+function strencode(mode){
+    function converter(py2block, func, args, keywords, starargs, kwargs, node) {
+        if (args.length !== 1) {
+            throw new Error("Incorrect number of arguments");
+        }
+        var textblock = py2block.convert(func.value);
+        return block("text_to_number", func.lineno, {
+            'TOWHAT': mode,
+        }, {
+            "VAR": textblock,
+        }, {
+            "inline": "true"
+        });
+    }
+    return converter;
+}
+pbc.objectFunctionD.get('encode')['Str'] = strencode('b');
+
+
+function textStrip(mode){
+    function converter(py2block, func, args, keywords, starargs, kwargs, node) {
+        if (args.length !== 0) {
+            throw new Error("Incorrect number of arguments");
+        }
+        var objblock = py2block.convert(func.value);        
+        return block("text_strip", func.lineno, {
+            'TOWHAT': mode,
+        }, {
+            "VAR": objblock,            
+        }, {
+            "inline": "true"
+        });
+    }
+    return converter;
+}
+
+pbc.objectFunctionD.get('strip')['Str'] = textStrip('strip');
+pbc.objectFunctionD.get('lstrip')['Str'] = textStrip('lstrip');
+pbc.objectFunctionD.get('rstrip')['Str'] =  textStrip('rstrip');
+
+
+
+function textAlign(mode){
+    function converter(py2block, func, args, keywords, starargs, kwargs, node) {
+        if (args.length !== 2) {
+            throw new Error("Incorrect number of arguments");
+        }
+        var objblock = py2block.convert(func.value);
+        var argblock1 = py2block.convert(args[0]);
+        var argblock2 = py2block.convert(args[1]);
+        return block("text_center", func.lineno, {
+            'CENTER': mode,
+        }, {
+            "VAR": objblock, 
+            "WID": argblock1,
+            "Symbol": argblock2
+        }, {
+            "inline": "true"
+        });
+    }
+    return converter;
+}
+
+pbc.objectFunctionD.get('ljust')['Str'] = textAlign('ljust');
+pbc.objectFunctionD.get('center')['Str'] = textAlign('center');
+pbc.objectFunctionD.get('rjust')['Str'] =  textAlign('rjust');
+
+
+pbc.objectFunctionD.get('split')['Str'] = function converter(py2block, func, args, keywords, starargs, kwargs, node) {
+        if (args.length !== 1) {
+            throw new Error("Incorrect number of arguments");
+        }
+        var objblock = py2block.convert(func.value);       
+        var argblock = py2block.convert(args[0]); 
+        return block("text_split", func.lineno, {           
+        }, {
+            "VAR": objblock,  
+            "VAL": argblock          
+        }, {
+            "inline": "true"
+        });
+    }
+
+pbc.objectFunctionD.get('replace')['Str'] = function converter(py2block, func, args, keywords, starargs, kwargs, node) {
+        if (args.length !== 2) {
+            throw new Error("Incorrect number of arguments");
+        }
+        var objblock = py2block.convert(func.value);       
+        var argblock1 = py2block.convert(args[0]); 
+        var argblock2 = py2block.convert(args[1]);
+        return block("text_replace", func.lineno, {           
+        }, {
+            "VAR": objblock,  
+            "STR1": argblock1,
+            "STR2": argblock2          
+        }, {
+            "inline": "true"
+        });
+    }
+
+pbc.objectFunctionD.get('find')['Str'] = function converter(py2block, func, args, keywords, starargs, kwargs, node) {
+        if (args.length !== 1) {
+            throw new Error("Incorrect number of arguments");
+        }
+        var objblock = py2block.convert(func.value);       
+        var argblock = py2block.convert(args[0]); 
+        return block("text_find", func.lineno, {           
+        }, {
+            "VAR": objblock,  
+            "STR": argblock          
+        }, {
+            "inline": "true"
+        });
+    }
+
+pbc.objectFunctionD.get('join')['Str'] = function converter(py2block, func, args, keywords, starargs, kwargs, node) {
+        if (args.length !== 1) {
+            throw new Error("Incorrect number of arguments");
+        }
+        var objblock = py2block.convert(func.value);       
+        var argblock = py2block.convert(args[0]); 
+        return block("text_join_seq", func.lineno, {           
+        }, {
+            "VAR": objblock,  
+            "LIST": argblock          
+        }, {
+            "inline": "true"
+        });
+    }    
+
+pbc.objectFunctionD.get('format')['Str'] = function converter(py2block, func, args, keywords, starargs, kwargs, node) {
+        var objblock = py2block.convert(func.value);
+        var d = py2block.convertElements("ADD", args);
+        d['VAR'] = objblock;
+        return block("text_format_noreturn", node.lineno, {
+        }, d, {
+            "inline": "true",
+        }, {
+            "@items":args.length
+        });
+    }
+
+
+
+function strEncodeDecode(mode){
+    function converter(py2block, func, args, keywords, starargs, kwargs, node) {
+        if (args.length !== 1) {
+            throw new Error("Incorrect number of arguments");
+        }
+        var objblock = py2block.convert(func.value);       
+        
+        return block("text_encode", func.lineno, {  
+            'DIR': mode,
+            'CODE':args[0].s.v         
+        }, {
+            "VAR": objblock,                       
+        }, {
+            "inline": "true"
+        });
+    }
+    return converter;
+}
+
+pbc.objectFunctionD.get('encode')['Str'] = strEncodeDecode('encode');
+pbc.objectFunctionD.get('decode')['Str'] = strEncodeDecode('decode');
+
+pbc.globalFunctionD['eval'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
+    if (args.length != 1) {
+        throw new Error("Incorrect number of arguments");
+    }
+    var argblock = py2block.convert(args[0]);
+    return block("text_eval", func.lineno, {}, {
+        "VAR":argblock
+    }, {
+            "inline": "true"
+        });
+}
+
+pbc.moduleFunctionD.get('os')['system'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
+    if (args.length !== 1) {
+        throw new Error("Incorrect number of arguments");
+    }
+    var varblock = py2block.convert(args[0]);
+    return [block("os_system", func.lineno, {}, {
+        'VAR': varblock
+    }, {
+        "inline": "true"
+    })];
+}

boards/default_src/python/converters/tuple.js

@@ -0,0 +1,47 @@
+'use strict';
+
+pbc.assignD.get('Tuple')['check_assign'] = function (py2block, node, targets, value) {
+    if (value._astname === "Tuple")
+        return true;
+    return false;
+}
+
+pbc.assignD.get('Tuple')['create_block'] = function (py2block, node, targets, value) {
+    return block("tuple_create_with", node.lineno, {
+            'VAR': py2block.Name_str(targets[0])
+        },
+        py2block.convertElements("ADD", value.elts), {
+            "inline": elts.length < 4 ? "false" : "true",
+        }, {
+            "@items": value.elts.length
+        });
+}
+
+//mytup[0]在python_to_blockly.py中实现
+//len在text里实现
+
+//max/min在math里已实现
+
+//list(mytuple), set(mytup)在lists.js中实现
+
+pbc.globalFunctionD['tuple'] = function(py2block, func, args, keywords, starargs, kwargs, node){
+    if (args.length > 1) {
+        throw new Error("Incorrect number of arguments");
+    }
+    if (args.length ==0){
+        return block("tuple_create_with_noreturn", node.lineno, {},{}
+            , {
+                "inline": "true",
+            }, {
+                "@items": 0
+            });
+    }
+    if (args.length ==1){
+        var numblock = py2block.convert(args[0]);
+    return block("tuple_totuple", func.lineno, {}, {
+            'VAR': numblock,
+        }, {
+            "inline": "false"
+        });
+    }
+}

boards/default_src/python/converters/variables.js

@@ -0,0 +1,39 @@
+'use strict';
+
+pbc.globalFunctionD['dict'] = function converter(py2block, func, args, keywords, starargs, kwargs, node) {
+    var paramblock = py2block.convert(args[0]);
+    return block("variables_change", func.lineno, {
+        'OP': 'dict'
+    }, {
+        'MYVALUE': paramblock,
+    }, {
+        "inline": "false"
+    });
+}
+
+function TypeConvert(mode) {
+    function converter(py2block, func, args, keywords, starargs, kwargs, node) {
+        if (args.length !== 1) {
+            throw new Error("Incorrect number of arguments");
+        }
+        var argblock = py2block.convert(args[0]);
+        return block("variables_change", func.lineno, {
+            "OP":mode
+        }, {
+            'MYVALUE': argblock
+        }, {
+            "inline": "true"
+        });
+    }
+    return converter;
+}
+
+pbc.globalFunctionD['int'] = TypeConvert('int');
+pbc.globalFunctionD['float'] = TypeConvert('float');
+pbc.globalFunctionD['bool'] = TypeConvert('bool');
+// pbc.globalFunctionD['complex'] = TypeConvert('complex');
+pbc.globalFunctionD['str'] = TypeConvert('str');
+pbc.globalFunctionD['list'] = TypeConvert('list');
+pbc.globalFunctionD['tuple'] = TypeConvert('tuple');
+pbc.globalFunctionD['set'] = TypeConvert('set');
+pbc.globalFunctionD['dict'] = TypeConvert('dict');