281 lines
11 KiB
JavaScript
281 lines
11 KiB
JavaScript
import * as Blockly from 'blockly/core';
|
|
|
|
export const controls_main = function (a, generator) {
|
|
var d = generator.statementToCode(a, "DO"),
|
|
d = generator.addLoopTrap(d, a.id) || generator.PASS;
|
|
return "if __name__ == '__main__':\n" + d;
|
|
}
|
|
|
|
export const base_setup = function (_, generator) {
|
|
var branch = generator.statementToCode(this, 'DO');
|
|
branch = branch.replace(/(^\s*)|(\s*$)/g, "").replace(/\n {4}/g, '\n');//去除两端空格
|
|
if (branch.endsWith('\n')) {
|
|
generator.setups_['setup_setup'] = branch;
|
|
}
|
|
else {
|
|
generator.setups_['setup_setup'] = branch + '\n';
|
|
}
|
|
return '';
|
|
}
|
|
|
|
// ok
|
|
export const controls_if = function (a, generator) {
|
|
var b = 0,
|
|
c = "",
|
|
d,
|
|
e;
|
|
do
|
|
e = generator.valueToCode(a, "IF" + b, generator.ORDER_NONE) || "False", d = generator.statementToCode(a, "DO" + b) || generator.PASS, c += (0 == b ? "if " : "elif ") + e + ":\n" + d, ++b;
|
|
while (a.getInput("IF" + b));
|
|
a.getInput("ELSE") && (d = generator.statementToCode(a, "ELSE") || generator.PASS, c += "else:\n" + d);
|
|
return c
|
|
}
|
|
|
|
export const controls_try_finally = function (_, generator) {
|
|
var n = 0;
|
|
var argument = generator.valueToCode(this, 'IF' + n,
|
|
generator.ORDER_NONE) || 'null';
|
|
var branch = '';
|
|
var t = generator.statementToCode(this, 'try') || ' pass\n';
|
|
var code = 'try:\n' + t;
|
|
for (n = 1; n <= this.elseifCount_; n++) {
|
|
argument = generator.valueToCode(this, 'IF' + n,
|
|
generator.ORDER_NONE) || '';
|
|
if (argument !== '')
|
|
argument = ' ' + argument
|
|
branch = generator.statementToCode(this, 'DO' + n) || ' pass\n';
|
|
code += 'except' + argument + ': \n' + branch;
|
|
}
|
|
if (this.elseCount_) {
|
|
branch = generator.statementToCode(this, 'ELSE') || ' pass\n';
|
|
code += 'finally:\n' + branch;
|
|
}
|
|
// code += '}';
|
|
return code;
|
|
}
|
|
|
|
// ok
|
|
export const controls_for = function (a, generator) {
|
|
var b = generator.variableDB_.getName(a.getFieldValue("VAR"), Blockly.Variables.NAME_TYPE),
|
|
//var b = generator.valueToCode(a, "VAR", generator.ORDER_MEMBER) || "''",
|
|
c = generator.valueToCode(a, "FROM", generator.ORDER_NONE) || "0",
|
|
d = generator.valueToCode(a, "TO", generator.ORDER_NONE) || "0",
|
|
e = generator.valueToCode(a, "STEP", generator.ORDER_NONE) || "1",
|
|
f = generator.statementToCode(a, "DO"),
|
|
f = generator.addLoopTrap(f, a.id) || generator.PASS,
|
|
g = "",
|
|
h = function (_, generator) {
|
|
return generator.provideFunction_("upRange",
|
|
["def " + generator.FUNCTION_NAME_PLACEHOLDER_ + "(start, stop, step):", " while start <= stop:", " yield start", " start += abs(step)"])
|
|
},
|
|
k = function (_, generator) {
|
|
return generator.provideFunction_("downRange", ["def " + generator.FUNCTION_NAME_PLACEHOLDER_ + "(start, stop, step):", " while start >= stop:", " yield start", " start -= abs(step)"])
|
|
}
|
|
a = function (a, b, c) {
|
|
return "(" + a + " <= " + b + ") and " + h() + "(" + a + ", " + b + ", " + c + ") or " + k() + "(" + a + ", " + b + ", " + c + ")"
|
|
}
|
|
if (Blockly.isNumber(c) && Blockly.isNumber(d) &&
|
|
Blockly.isNumber(e))
|
|
c = parseFloat(c), d = parseFloat(d), e = Math.abs(parseFloat(e)), 0 === c % 1 && 0 === d % 1 && 0 === e % 1 ? (c <= d ? (d++, a = 0 == c && 1 == e ? d : c + ", " + d, 1 != e && (a += ", " + e)) : (d--, a = c + ", " + d + ", -" + e), a = "range(" + a + ")") : (a = c < d ? h() : k(), a += "(" + c + ", " + d + ", " + e + ")");
|
|
else {
|
|
var l = function (a, c) {
|
|
if (Blockly.isNumber(a))
|
|
a = parseFloat(a);
|
|
else {
|
|
var d = generator.variableDB_.getDistinctName(b + c, Blockly.Variables.NAME_TYPE);
|
|
g += d + " = " + a + "\n";
|
|
a = d
|
|
}
|
|
return a
|
|
},
|
|
c = l(c, "_start"),
|
|
d = l(d, "_end");
|
|
l(e, "_inc");
|
|
a = "number" == typeof c && "number" == typeof d ? c < d ? h(c, d, e) : k(c, d, e) : a(c, d, e)
|
|
}
|
|
return g += "for " + b + " in " + a + ":\n" + f
|
|
}
|
|
|
|
export const controls_for_range = function (block, generator) {
|
|
var iter = generator.variableDB_.getName(block.getFieldValue("VAR"), Blockly.Variables.NAME_TYPE),
|
|
from = generator.valueToCode(block, "FROM", generator.ORDER_NONE) || "0",
|
|
end = generator.valueToCode(block, "TO", generator.ORDER_NONE) || "0",
|
|
step = generator.valueToCode(block, "STEP", generator.ORDER_NONE) || "1",
|
|
dostatement = generator.statementToCode(block, "DO"),
|
|
pass = generator.addLoopTrap(dostatement, block.id) || generator.PASS;
|
|
generator.setups_["mixly_range"] = "def mixly_range(start, stop, step):\n" +
|
|
" for i in range(start, stop + 1, step):\n" +
|
|
" yield i\n\n";
|
|
return "for " + iter + " in mixly_range(" + from + ", " + end + ", " + step + "):\n" + pass;
|
|
}
|
|
|
|
export const controls_whileUntil = function (a, generator) {
|
|
var b = "UNTIL" == a.getFieldValue("MODE"),
|
|
c = generator.valueToCode(a, "BOOL", generator.ORDER_NONE) || "False",
|
|
d = generator.statementToCode(a, "DO"),
|
|
d = generator.addLoopTrap(d, a.id) || generator.PASS;
|
|
b && (c = "not " + c);
|
|
return "while " + c + ":\n" + d
|
|
}
|
|
|
|
// export const controls_flow_statements = function (_, generator) {
|
|
// // Flow statements: continue, break.
|
|
// switch (this.getFieldValue('FLOW')) {
|
|
// case 'BREAK':
|
|
// return 'break;\n';
|
|
// case 'CONTINUE':
|
|
// return 'continue;\n';
|
|
// }
|
|
// throw 'Unknown flow statement.';
|
|
// }
|
|
|
|
//ok
|
|
export const controls_flow_statements = function (a) {
|
|
switch (a.getFieldValue("FLOW")) {
|
|
case "BREAK":
|
|
return "break\n";
|
|
case "CONTINUE":
|
|
return "continue\n"
|
|
}
|
|
throw "Unknown flow statement.";
|
|
}
|
|
|
|
// ok
|
|
export const controls_delay = function (_, generator) {
|
|
var delay_time = generator.valueToCode(this, 'DELAY_TIME', generator.ORDER_ATOMIC) || '1000'
|
|
var code = 'sleep(' + delay_time + ')\n';
|
|
return code;
|
|
}
|
|
|
|
// ok
|
|
export const Panic_with_status_code = function (_, generator) {
|
|
var status_code = generator.valueToCode(this, 'STATUS_CODE', generator.ORDER_ATOMIC) || '1000'
|
|
var code = 'panic(' + status_code + ')\n';
|
|
return code;
|
|
}
|
|
|
|
// ok
|
|
export const controls_millis = function (_, generator) {
|
|
generator.definitions_.import_time = "import time";
|
|
var code = 'time.time()';
|
|
return [code, generator.ORDER_ATOMIC];
|
|
}
|
|
|
|
// ok
|
|
export const reset = function (_, generator) {
|
|
generator.definitions_['import_microbit'] = 'from microbit import *'
|
|
return 'reset()\n';
|
|
}
|
|
export const controls_interrupts = function () {
|
|
return 'interrupts();\n';
|
|
}
|
|
|
|
export const controls_nointerrupts = function () {
|
|
return 'noInterrupts();\n';
|
|
}
|
|
|
|
|
|
export const controls_forEach = function (block, generator) {
|
|
// For each loop.
|
|
var variable0 = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC) || '\'\'';
|
|
var argument0 = generator.valueToCode(block, 'LIST',
|
|
generator.ORDER_RELATIONAL) || '[]';
|
|
var branch = generator.statementToCode(block, 'DO');
|
|
branch = generator.addLoopTrap(branch, block.id) ||
|
|
generator.PASS;
|
|
var code = 'for ' + variable0 + ' in ' + argument0 + ':\n' + branch;
|
|
return code;
|
|
}
|
|
|
|
export const controls_range = function (_, generator) {
|
|
var from = generator.valueToCode(this, "FROM", generator.ORDER_NONE) || "0";
|
|
var end = generator.valueToCode(this, "TO", generator.ORDER_NONE) || "0";
|
|
var step = generator.valueToCode(this, "STEP", generator.ORDER_NONE) || "1";
|
|
var code = "range(" + from + ", " + end + ", " + step + ")";
|
|
return [code, generator.ORDER_ATOMIC];
|
|
}
|
|
|
|
export const controls_lambda = function (a, generator) {
|
|
var c = generator.valueToCode(a, "BOOL", generator.ORDER_NONE) || "None",
|
|
d = generator.statementToCode(a, "DO") || "pass";
|
|
var code = "lambda " + c + ": " + d;
|
|
code = code.replace('\n', '').replace(' ', '')
|
|
return [code, generator.ORDER_ATOMIC];
|
|
}
|
|
|
|
export const time_sleep = function (_, generator) {
|
|
generator.definitions_['import_time'] = 'import time';
|
|
var delay_time = generator.valueToCode(this, 'DELAY_TIME', generator.ORDER_ATOMIC) || '1000'
|
|
var code = 'time.sleep(' + delay_time + ')\n';
|
|
return code;
|
|
}
|
|
|
|
export const controls_pass = function () {
|
|
return 'pass\n';
|
|
}
|
|
|
|
export const controls_thread = function (_, generator) {
|
|
generator.definitions_['import__thread'] = 'import _thread';
|
|
var v = generator.valueToCode(this, "VAR", generator.ORDER_NONE) || "None";
|
|
var callback = generator.variableDB_.getName(
|
|
generator.valueToCode(this, "callback", generator.ORDER_NONE) || "None",
|
|
Blockly.Procedures.NAME_TYPE
|
|
);
|
|
var code = "_thread.start_new_thread(" + callback + ", " + v + ")\n";
|
|
return code;
|
|
}
|
|
|
|
// do-while循环
|
|
export const do_while = function (_, generator) {
|
|
var value_select_data = generator.valueToCode(this, 'select_data', generator.ORDER_NONE) || "False";
|
|
var statements_input_data = generator.statementToCode(this, 'input_data')
|
|
var dropdown_type = this.getFieldValue('type');
|
|
if (dropdown_type == 'true') {
|
|
statements_input_data = statements_input_data + ' if (' + value_select_data + '):\n' + ' break\n';
|
|
}
|
|
else {
|
|
statements_input_data = statements_input_data + ' if not (' + value_select_data + '):\n' + ' break\n';
|
|
}
|
|
statements_input_data = generator.addLoopTrap(statements_input_data, this.id) || generator.PASS;
|
|
//var dropdown_type = this.getFieldValue('type');
|
|
var code = 'while True:\n' + statements_input_data;
|
|
return code;
|
|
}
|
|
|
|
// export const base_type = controls_type;
|
|
// export const controls_TypeLists = controls_typeLists;
|
|
|
|
export const controls_repeat_ext = function (a, generator) {
|
|
var times = generator.valueToCode(this, 'TIMES', generator.ORDER_ATOMIC);
|
|
var d = generator.statementToCode(a, "DO"),
|
|
d = generator.addLoopTrap(d, a.id) || generator.PASS;
|
|
return 'for _my_variable in range(' + times + '):\n' + d;
|
|
}
|
|
|
|
|
|
export const garbage_collection = function (_, generator) {
|
|
generator.definitions_['import_gc'] = 'import gc';
|
|
var code = 'gc.collect()\n'
|
|
return code;
|
|
}
|
|
|
|
export const get_mem_alloc = function (_, generator) {
|
|
generator.definitions_['import_gc'] = 'import gc';
|
|
var code = 'gc.mem_alloc()\n';
|
|
return [code, generator.ORDER_ATOMIC];
|
|
}
|
|
|
|
export const get_mem_free = function (_, generator) {
|
|
generator.definitions_['import_gc'] = 'import gc';
|
|
var code = 'gc.mem_free()\n';
|
|
return [code, generator.ORDER_ATOMIC]
|
|
}
|
|
|
|
export const get_unique_identifier = function (_, generator) {
|
|
generator.definitions_['import_machine'] = 'import machine';
|
|
var code = 'machine.unique_id()';
|
|
return [code, generator.ORDER_ATOMIC];
|
|
}
|
|
|
|
// ok
|
|
export const controls_repeat = controls_repeat_ext; |