389 lines
12 KiB
JavaScript
389 lines
12 KiB
JavaScript
'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; |