初始化提交
This commit is contained in:
王立帮
89
boards/default_src/python/generators/blynk.js
Normal file
89
boards/default_src/python/generators/blynk.js
Normal file
@@ -0,0 +1,89 @@
|
||||
import * as Blockly from 'blockly/core';
|
||||
|
||||
// 物联网-wifi信息
|
||||
export const blynk_server = function (_, generator) {
|
||||
var wifi_ssid = generator.valueToCode(this, 'wifi_ssid', generator.ORDER_ATOMIC);
|
||||
var wifi_pass = generator.valueToCode(this, 'wifi_pass', generator.ORDER_ATOMIC);
|
||||
generator.definitions_.import_time = "import network,time,BlynkLib";
|
||||
var code;
|
||||
code = "wlan = network.WLAN(network.STA_IF)\n";
|
||||
code += "wlan.active(True)\n";
|
||||
code += "if not wlan.isconnected():\n";
|
||||
code += " print('connecting to network...')\n";
|
||||
code += " wlan.connect(" + wifi_ssid + "," + wifi_pass + ")\n";
|
||||
code += " while not wlan.isconnected():\n";
|
||||
code += " pass\n";
|
||||
code += "print('network config:', wlan.ifconfig())\n";
|
||||
code += "BLYNK_AUTH='" + "auth_key" + "'\n";
|
||||
code += "blynk = BlynkLib.Blynk(BLYNK_AUTH)\n"
|
||||
code += "while True:\n"
|
||||
code += " blynk.run()\n"
|
||||
code += " pass\n"
|
||||
return code;
|
||||
}
|
||||
|
||||
// 物联网-wifi信息
|
||||
export const blynk_iot_get_data = function (_, generator) {
|
||||
var Vpin = this.getFieldValue('Vpin');
|
||||
var args = [];
|
||||
for (var x = 0; x < this.arguments_.length; x++) {
|
||||
args[x] = generator.valueToCode(this, 'ARG' + x, generator.ORDER_NONE) || 'null';
|
||||
}
|
||||
var code = '(a' + args.join(', ') + ');\n';
|
||||
var branch = generator.statementToCode(this, 'STACK');
|
||||
if (generator.INFINITE_LOOP_TRAP) {
|
||||
branch = generator.INFINITE_LOOP_TRAP.replace(/%1/g, '\'' + this.id + '\'') + branch;
|
||||
}
|
||||
var args = [];
|
||||
for (var x = 0; x < this.arguments_.length; x++) {
|
||||
args[x] = this.argumentstype_[x] + ' ' + generator.variableDB_.getName(this.arguments_[x], Blockly.Variables.NAME_TYPE);
|
||||
}
|
||||
var GetDataCode = "";
|
||||
if (this.arguments_.length == 1) {
|
||||
GetDataCode = generator.variableDB_.getName(this.arguments_[0], Blockly.Variables.NAME_TYPE);
|
||||
if (this.argumentstype_[0] == "int")
|
||||
GetDataCode += "= param.asInt();\n"
|
||||
else if (this.argumentstype_[0] == "String")
|
||||
GetDataCode += "= param.asStr();\n"
|
||||
else if (this.argumentstype_[0] == "long")
|
||||
GetDataCode += "= param.asDouble();\n"
|
||||
else if (this.argumentstype_[0] == "float")
|
||||
GetDataCode += "= param.asFloat();\n"
|
||||
else if (this.argumentstype_[0] == "boolean")
|
||||
GetDataCode += "= param.asInt();\n"
|
||||
else if (this.argumentstype_[0] == "byte")
|
||||
GetDataCode += "= param.asStr();\n"
|
||||
else if (this.argumentstype_[0] == "char")
|
||||
GetDataCode += "= param.asStr();\n"
|
||||
}
|
||||
else {
|
||||
for (var x = 0; x < this.arguments_.length; x++) {
|
||||
args[x] = this.argumentstype_[x] + ' ' + generator.variableDB_.getName(this.arguments_[x], Blockly.Variables.NAME_TYPE);
|
||||
|
||||
GetDataCode += generator.variableDB_.getName(this.arguments_[x], Blockly.Variables.NAME_TYPE);
|
||||
if (this.argumentstype_[x] == "int")
|
||||
GetDataCode += "= param[" + x + "].asInt();\n"
|
||||
else if (this.argumentstype_[x] == "String")
|
||||
GetDataCode += "= param[" + x + "].asStr();\n"
|
||||
else if (this.argumentstype_[x] == "long")
|
||||
GetDataCode += "= param[" + x + "].asDouble();\n"
|
||||
else if (this.argumentstype_[x] == "float")
|
||||
GetDataCode += "= param[" + x + "].asFloat();\n"
|
||||
else if (this.argumentstype_[x] == "boolean")
|
||||
GetDataCode += "= param[" + x + "].asInt();\n"
|
||||
else if (this.argumentstype_[x] == "byte")
|
||||
GetDataCode += "= param[" + x + "].asStr();\n"
|
||||
else if (this.argumentstype_[x] == "char")
|
||||
GetDataCode += "= param[" + x + "].asStr();\n"
|
||||
}
|
||||
}
|
||||
|
||||
if (this.arguments_.length > 0)
|
||||
generator.definitions_[args] = args.join(';\n') + ";";
|
||||
var code = ' BLYNK_WRITE(' + Vpin + ') {\n' + GetDataCode +
|
||||
branch + '}\n';
|
||||
// var code = 'BLYNK_WRITE(' + Vpin+ ') {\n'+variable+" = param.as"+datatype+"();\n"+branch+'}\n';
|
||||
code = generator.scrub_(this, code);
|
||||
generator.definitions_[Vpin] = code;
|
||||
return null;
|
||||
}
|
||||
147
boards/default_src/python/generators/class.js
Normal file
147
boards/default_src/python/generators/class.js
Normal file
@@ -0,0 +1,147 @@
|
||||
import * as Blockly from 'blockly/core';
|
||||
|
||||
export const class_make = function (_, generator) {
|
||||
var text_name = this.getFieldValue('VAR') || 'None';
|
||||
var statements_data = generator.statementToCode(this, 'data');
|
||||
var code = 'class ' + text_name + ':\n' + statements_data;
|
||||
return code;
|
||||
}
|
||||
|
||||
export const class_make_with_base = function (_, generator) {
|
||||
var text_name = this.getFieldValue('VAR') || 'None';
|
||||
var name = generator.valueToCode(this, 'NAME', generator.ORDER_ASSIGNMENT) || 'None';
|
||||
var statements_data = generator.statementToCode(this, 'data');
|
||||
var code = '';
|
||||
if (name == 'None')
|
||||
code = 'class ' + text_name + ':\n' + statements_data;
|
||||
else
|
||||
code = 'class ' + text_name + '(' + name + '):\n' + statements_data;
|
||||
return code;
|
||||
}
|
||||
|
||||
export const class_get = function (_, generator) {
|
||||
var code = this.getFieldValue('VAR') || 'None';
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const property_set = function (_, generator) {
|
||||
var argument0 = generator.valueToCode(this, 'VALUE', generator.ORDER_ASSIGNMENT) || 'None';
|
||||
var argument1 = generator.valueToCode(this, 'DATA', generator.ORDER_ASSIGNMENT) || 'None';
|
||||
var varName = this.getFieldValue('VAR') || 'None';
|
||||
return argument0 + '.' + varName + ' = ' + argument1 + '\n';
|
||||
}
|
||||
|
||||
export const property_get = function (_, generator) {
|
||||
var argument0 = generator.valueToCode(this, 'VALUE', generator.ORDER_ASSIGNMENT) || 'None';
|
||||
var code = this.getFieldValue('VAR') || 'None';
|
||||
return [argument0 + '.' + code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const object_set = function (_, generator) {
|
||||
var text_name = this.getFieldValue('VAR10') || 'None';
|
||||
var text_new_name = this.getFieldValue('VAR11') || 'None';
|
||||
var code = new Array(this.itemCount_);
|
||||
for (var n = 0; n < this.itemCount_; n++) {
|
||||
code[n] = generator.valueToCode(this, 'ADD' + n, generator.ORDER_NONE) || 'None';
|
||||
}
|
||||
var code = text_new_name + ' = ' + text_name + '(' + code.join(',') + ')\n';
|
||||
return code;
|
||||
}
|
||||
|
||||
export const object_get = function (_, generator) {
|
||||
var code = this.getFieldValue('VAR') || 'None';
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const method_procedures_defreturn = function (_, generator) {
|
||||
// Define a procedure with a return value.
|
||||
//var funcName = generator.variableDB_.getName(this.getFieldValue('NAME'),
|
||||
// Blockly.Class_Test.NAME_TYPE);
|
||||
var funcName = this.getFieldValue('NAME') || 'None';
|
||||
var branch = generator.statementToCode(this, 'STACK') || ' pass\n';
|
||||
if (generator.INFINITE_LOOP_TRAP) {
|
||||
branch = generator.INFINITE_LOOP_TRAP.replace(/%1/g,
|
||||
'\'' + this.id + '\'') + branch;
|
||||
}
|
||||
var returnValue = generator.valueToCode(this, 'RETURN',
|
||||
generator.ORDER_NONE) || '';
|
||||
//var type=this.getFieldValue('TYPE');
|
||||
if (returnValue) {
|
||||
returnValue = ' return ' + returnValue + '\n';
|
||||
}
|
||||
//var returnType = returnValue ? type : 'void';
|
||||
var args = [];
|
||||
for (var x = 0; x < this.arguments_.length; x++) {
|
||||
var varName = generator.variableDB_.getName(this.arguments_[x], Blockly.Variables.NAME_TYPE);
|
||||
args[x] = varName;
|
||||
}
|
||||
var code = '';
|
||||
//if(this.arguments_.length)
|
||||
code = 'def ' + funcName + '(' + args.join(', ') + '):\n' +
|
||||
branch + returnValue + '\n';
|
||||
//code = generator.scrub_(this, code);
|
||||
//generator.setups_[funcName] = code;
|
||||
return code;
|
||||
}
|
||||
|
||||
export const method_procedures_defnoreturn = method_procedures_defreturn;
|
||||
|
||||
export const method_procedures_callreturn = function (_, generator) {
|
||||
var argument1 = generator.valueToCode(this, 'DATA', generator.ORDER_ASSIGNMENT) || 'None';
|
||||
// Call a procedure with a return value.
|
||||
//var funcName = generator.variableDB_.getName(this.getFieldValue('NAME'),
|
||||
// Blockly.Class_Test.NAME_TYPE);
|
||||
var funcName = this.getFieldValue('NAME');
|
||||
var args = [];
|
||||
for (var x = 0; x < this.arguments_.length - 1; x++) {
|
||||
args[x] = generator.valueToCode(this, 'ARG' + (x + 1),
|
||||
generator.ORDER_NONE) || 'null';
|
||||
}
|
||||
var code = argument1 + '.' + funcName + '(' + args.join(', ') + ')';
|
||||
return [code, generator.ORDER_UNARY_POSTFIX];
|
||||
}
|
||||
|
||||
export const method_procedures_callnoreturn = function (_, generator) {
|
||||
var argument1 = generator.valueToCode(this, 'DATA', generator.ORDER_ASSIGNMENT) || 'None';
|
||||
// Call a procedure with no return value.
|
||||
//var funcName = generator.variableDB_.getName(this.getFieldValue('NAME'),
|
||||
// Blockly.Class_Test.NAME_TYPE);
|
||||
var funcName = this.getFieldValue('NAME');
|
||||
var args = [];
|
||||
for (var x = 0; x < this.arguments_.length - 1; x++) {
|
||||
args[x] = generator.valueToCode(this, 'ARG' + (x + 1),
|
||||
generator.ORDER_NONE) || 'null';
|
||||
}
|
||||
var code = argument1 + '.' + funcName + '(' + args.join(', ') + ')\n';
|
||||
return code;
|
||||
}
|
||||
|
||||
export const method_procedures_ifreturn = function (_, generator) {
|
||||
// Conditionally return value from a procedure.
|
||||
var condition = generator.valueToCode(this, 'CONDITION',
|
||||
generator.ORDER_NONE) || 'False';
|
||||
var code = 'if (' + condition + ') :\n';
|
||||
if (this.hasReturnValue_) {
|
||||
var value = generator.valueToCode(this, 'VALUE',
|
||||
generator.ORDER_NONE) || 'None';
|
||||
code += ' return ' + value;
|
||||
} else {
|
||||
code += ' return None';
|
||||
}
|
||||
code += '\n';
|
||||
return code;
|
||||
}
|
||||
|
||||
export const method_procedures_return = function (_, generator) {
|
||||
// Conditionally return value from a procedure.
|
||||
var code = ""
|
||||
if (this.hasReturnValue_) {
|
||||
var value = generator.valueToCode(this, 'VALUE',
|
||||
generator.ORDER_NONE) || 'None';
|
||||
code += 'return ' + value;
|
||||
} else {
|
||||
code += 'return None';
|
||||
}
|
||||
code += '\n';
|
||||
return code;
|
||||
}
|
||||
256
boards/default_src/python/generators/control.js
Normal file
256
boards/default_src/python/generators/control.js
Normal file
@@ -0,0 +1,256 @@
|
||||
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;
|
||||
}
|
||||
|
||||
// ok
|
||||
export const controls_repeat = controls_repeat_ext;
|
||||
207
boards/default_src/python/generators/dicts.js
Normal file
207
boards/default_src/python/generators/dicts.js
Normal file
@@ -0,0 +1,207 @@
|
||||
/**
|
||||
* @license
|
||||
* Visual Blocks Language
|
||||
*
|
||||
* Copyright 2012 Google Inc.
|
||||
* https://developers.google.com/blockly/
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
/**
|
||||
* @fileoverview Generating Python for dictionary blocks.
|
||||
* @author acbart@vt.edu (Austin Cory Bart)
|
||||
*/
|
||||
import * as Blockly from 'blockly/core';
|
||||
|
||||
export const dicts_create_with = function (_, generator) {
|
||||
// Create a list with any number of elements of any type.
|
||||
//var dropdown_type = this.getFieldValue('TYPE');
|
||||
var varName = generator.variableDB_.getName(this.getFieldValue('VAR'),
|
||||
Blockly.Variables.NAME_TYPE);
|
||||
//var size=window.parseFloat(this.getFieldValue('SIZE'));
|
||||
var code = new Array(this.itemCount_);
|
||||
var default_value = '0';
|
||||
for (var n = 0; n < this.itemCount_; n++) {
|
||||
var keyName = this.getFieldValue('KEY' + n);
|
||||
code[n] = keyName + ":" + (generator.valueToCode(this, 'ADD' + n, generator.ORDER_NONE) || default_value);
|
||||
}
|
||||
var code = varName + '= ' + '{' + code.join(', ') + '}\n';
|
||||
//var code =''+varName+'['+size+"]"+'='+ '{' + code.join(', ') + '}\n';
|
||||
//generator.setups_['setup_lists'+varName] = code;
|
||||
return code;
|
||||
}
|
||||
|
||||
export const dicts_keys = function (_, generator) {
|
||||
var varName = generator.valueToCode(this, 'DICT', generator.ORDER_ASSIGNMENT) || '0';
|
||||
var code = varName + '.keys()';
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const dicts_get = function (_, generator) {
|
||||
var varName = generator.valueToCode(this, 'DICT', generator.ORDER_ASSIGNMENT) || '0';
|
||||
//var size=window.parseFloat(this.getFieldValue('SIZE'));
|
||||
var text = generator.valueToCode(this, 'KEY', generator.ORDER_ASSIGNMENT);
|
||||
// var text=this.getFieldValue('KEY');
|
||||
var code = varName + "[" + text + "]";
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const dicts_get_default = function (_, generator) {
|
||||
var varName = generator.valueToCode(this, 'DICT', generator.ORDER_ASSIGNMENT) || '0';
|
||||
//var size=window.parseFloat(this.getFieldValue('SIZE'));
|
||||
var text = generator.valueToCode(this, 'KEY', generator.ORDER_ASSIGNMENT);
|
||||
var argument = generator.valueToCode(this, 'VAR', generator.ORDER_ASSIGNMENT) || '0';
|
||||
// var text=this.getFieldValue('KEY');
|
||||
var code = varName + ".get(" + text + ',' + argument + ")";
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const dicts_add_or_change = function (_, generator) {
|
||||
var varName = generator.valueToCode(this, 'DICT', generator.ORDER_ASSIGNMENT) || 'mydict';
|
||||
var text = generator.valueToCode(this, 'KEY', generator.ORDER_ASSIGNMENT);
|
||||
// var text=this.getFieldValue('KEY');
|
||||
var argument = generator.valueToCode(this, 'VAR', generator.ORDER_ASSIGNMENT) || '0';
|
||||
var code = varName + "[" + text + "] = " + argument + '\n';
|
||||
return code;
|
||||
}
|
||||
|
||||
export const dicts_delete = function (_, generator) {
|
||||
var varName = generator.valueToCode(this, 'DICT', generator.ORDER_ASSIGNMENT) || 'mydict';
|
||||
var text = generator.valueToCode(this, 'KEY', generator.ORDER_ASSIGNMENT);
|
||||
// var text=this.getFieldValue('KEY');
|
||||
var code = "del " + varName + "[" + text + "]\n";
|
||||
return code;
|
||||
}
|
||||
|
||||
export const dicts_update = function (_, generator) {
|
||||
var varName2 = generator.valueToCode(this, 'DICT2', generator.ORDER_ASSIGNMENT) || '0';
|
||||
var varName = generator.valueToCode(this, 'DICT', generator.ORDER_ASSIGNMENT) || '0';
|
||||
var code = varName + '.update(' + varName2 + ')\n';
|
||||
return code;
|
||||
}
|
||||
|
||||
export const dicts_clear = function (_, generator) {
|
||||
var varName = generator.valueToCode(this, 'DICT', generator.ORDER_ASSIGNMENT) || '0';
|
||||
var code = varName + '.clear()\n';
|
||||
return code;
|
||||
}
|
||||
|
||||
export const dicts_items = function (_, generator) {
|
||||
var varName = generator.valueToCode(this, 'DICT', generator.ORDER_ASSIGNMENT) || '0';
|
||||
var code = varName + '.items()';
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const dicts_values = function (_, generator) {
|
||||
var varName = generator.valueToCode(this, 'DICT', generator.ORDER_ASSIGNMENT) || '0';
|
||||
var code = varName + '.values()';
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const dicts_length = function (_, generator) {
|
||||
var varName = generator.valueToCode(this, 'DICT', generator.ORDER_ASSIGNMENT) || '0';
|
||||
var code = 'len(' + varName + ')';
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const dicts_deldict = function (_, generator) {
|
||||
var varName = generator.valueToCode(this, 'DICT', generator.ORDER_ASSIGNMENT) || '0';
|
||||
var code = 'del ' + varName + '\n';
|
||||
return code;
|
||||
}
|
||||
|
||||
export const dicts_add_change_del = function (block, generator) {
|
||||
var dict = generator.valueToCode(block, 'DICT',
|
||||
generator.ORDER_MEMBER) || '[]';
|
||||
var mode = block.getFieldValue('WHERE');
|
||||
var KEY = generator.valueToCode(this, 'KEY', generator.ORDER_ASSIGNMENT);
|
||||
// var text=this.getFieldValue('KEY');
|
||||
|
||||
switch (mode) {
|
||||
case 'INSERT':
|
||||
//var at2 = block.getFieldValue('AT2');
|
||||
var at2 = generator.valueToCode(this, 'AT2', generator.ORDER_ASSIGNMENT) || '0';
|
||||
var code = dict + "[" + KEY + "] = " + at2 + '\n'
|
||||
break;
|
||||
|
||||
case 'DELETE':
|
||||
var code = 'del ' + dict + "[" + KEY + "]\n"
|
||||
break;
|
||||
default:
|
||||
throw 'Unhandled option (lists_setIndex2)';
|
||||
}
|
||||
return code;
|
||||
}
|
||||
|
||||
export const dicts_pop = function (_, generator) {
|
||||
var varName = generator.valueToCode(this, 'DICT', generator.ORDER_ASSIGNMENT) || '0';
|
||||
var text = generator.valueToCode(this, 'KEY', generator.ORDER_ASSIGNMENT);
|
||||
// var text=this.getFieldValue('KEY');
|
||||
var code = varName + ".pop(" + text + ")";
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const dicts_setdefault = function (_, generator) {
|
||||
var varName = generator.valueToCode(this, 'DICT', generator.ORDER_ASSIGNMENT) || 'mydict';
|
||||
var text = generator.valueToCode(this, 'KEY', generator.ORDER_ASSIGNMENT);
|
||||
// var text=this.getFieldValue('KEY');
|
||||
var argument = generator.valueToCode(this, 'VAR', generator.ORDER_ASSIGNMENT) || '0';
|
||||
var code = varName + ".setdefault" + "(" + text + "," + argument + ")\n";
|
||||
return code;
|
||||
}
|
||||
|
||||
export const dicts_create_with_noreturn = function (_, generator) {
|
||||
// Create a list with any number of elements of any type.
|
||||
// var varName = generator.variableDB_.getName(this.getFieldValue('VAR'),
|
||||
// Blockly.Variables.NAME_TYPE);
|
||||
//var size=window.parseFloat(this.getFieldValue('SIZE'));
|
||||
var code = new Array(this.itemCount_);
|
||||
var default_value = '0';
|
||||
|
||||
for (var n = 0; n < this.itemCount_; n++) {
|
||||
var keyName = this.getFieldValue('KEY' + n);
|
||||
code[n] = keyName + ":" + (generator.valueToCode(this, 'ADD' + n, generator.ORDER_NONE) || default_value);
|
||||
}
|
||||
// if (this.itemCount_!=1){
|
||||
// generator.definitions_['var_declare'+varName] = varName+'= '+ '(' + code.join(', ') + ')\n';}
|
||||
// else {
|
||||
// generator.definitions_['var_declare'+varName] = varName+'= '+ '(' + code.join(', ') + ',)\n';}
|
||||
if (this.itemCount_ != 1) {
|
||||
var code = '{' + code.join(', ') + '}';
|
||||
}
|
||||
else {
|
||||
var code = '{' + code.join(', ') + ',}';
|
||||
}
|
||||
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const dicts_todict = function (_, generator) {
|
||||
var str = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC) || '0'
|
||||
return ['dict(' + str + ')', generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const dicts_to_json = function (_, generator) {
|
||||
generator.definitions_['import_json'] = 'import json';
|
||||
var varName = generator.valueToCode(this, 'DICT', generator.ORDER_ASSIGNMENT) || '0';
|
||||
var code = 'json.dumps(' + varName + ')';
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const json_to_dicts = function (_, generator) {
|
||||
generator.definitions_['import_json'] = 'import json';
|
||||
var varName = generator.valueToCode(this, 'VAR', generator.ORDER_ASSIGNMENT) || 'null';
|
||||
var code = 'json.loads(' + varName + ')';
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
70
boards/default_src/python/generators/html.js
Normal file
70
boards/default_src/python/generators/html.js
Normal file
@@ -0,0 +1,70 @@
|
||||
export const html_document = function (_, generator) {
|
||||
var head = generator.statementToCode(this, 'HEAD');
|
||||
var body = generator.statementToCode(this, 'BODY');
|
||||
var code = "'''<!DOCTYPE HTML>\n<html>\n<head>\n" + '\t<meta charset="utf-8">\n' + head + "</head>\n<body>\n" + body + "</body>\n</html>\n'''";
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const html_title = function (_, generator) {
|
||||
var t = generator.statementToCode(this, 'DO');
|
||||
var l = this.getFieldValue('LEVEL');
|
||||
var code = "<h" + l + ">\n" + t + "</h" + l + ">\n";
|
||||
return code;
|
||||
}
|
||||
|
||||
export const html_head_body = function (_, generator) {
|
||||
var t = generator.statementToCode(this, 'DO');
|
||||
var l = this.getFieldValue('LEVEL');
|
||||
if (l == 'head') {
|
||||
var code = "<" + l + '>\n\t<meta charset="utf-8">\n' + t + "</" + l + ">\n";
|
||||
}
|
||||
else {
|
||||
var code = "<" + l + ">\n" + t + "</" + l + ">\n";
|
||||
}
|
||||
return code;
|
||||
}
|
||||
|
||||
export const html_content = function (_, generator) {
|
||||
var t = generator.statementToCode(this, 'DO');
|
||||
// var s = generator.valueToCode(this, 'style');
|
||||
var l = this.getFieldValue('LEVEL');
|
||||
// var code = "<" + l + " " + s + " >\n" + t + "</" + l + ">\n";
|
||||
var code = "<" + l + ">\n" + t + "</" + l + ">\n";
|
||||
return code;
|
||||
}
|
||||
|
||||
export const html_content_more = function (_, generator) {
|
||||
var t = generator.statementToCode(this, 'DO');
|
||||
var s = generator.valueToCode(this, 'style');
|
||||
var l = this.getFieldValue('LEVEL');
|
||||
var code = "<" + l + " " + s + " >\n" + t + "</" + l + ">\n";
|
||||
return code;
|
||||
}
|
||||
|
||||
export const html_style = function (_, generator) {
|
||||
var style = generator.statementToCode(this, 'STYLE');
|
||||
var code = 'style="' + style + '"';
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const html_form = function (_, generator) {
|
||||
var tag = this.getFieldValue('LEVEL');
|
||||
var name = this.getFieldValue('NAME');
|
||||
var value = this.getFieldValue('VALUE');
|
||||
var s = generator.valueToCode(this, 'style') || "";
|
||||
var code = '<input type="' + tag + '" name="' + name + '" value="' + value + '" ' + s + ' />';
|
||||
return code;
|
||||
}
|
||||
|
||||
export const html_style_content = function () {
|
||||
var key = this.getFieldValue('KEY');
|
||||
var value = this.getFieldValue('VALUE');
|
||||
var code = key + ':' + value + ";";
|
||||
return code;
|
||||
}
|
||||
|
||||
export const html_text = function () {
|
||||
var text = this.getFieldValue('TEXT');
|
||||
var code = text + "\n";
|
||||
return code;
|
||||
}
|
||||
267
boards/default_src/python/generators/lists.js
Normal file
267
boards/default_src/python/generators/lists.js
Normal file
@@ -0,0 +1,267 @@
|
||||
import * as Blockly from 'blockly/core';
|
||||
|
||||
export const lists_get_sublist = function (_, generator) {
|
||||
// Get sublist.
|
||||
var list = generator.valueToCode(this, 'LIST', generator.ORDER_ADDITIVE) || 'mylist';
|
||||
var at1 = generator.valueToCode(this, 'AT1', generator.ORDER_ADDITIVE);
|
||||
var at2 = generator.valueToCode(this, 'AT2', generator.ORDER_ADDITIVE);
|
||||
var code = list + '[' + at1 + ' : ' + at2 + ']';
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const lists_2d_get_data_with_col_row = function (_, generator) {
|
||||
var value_LIST = generator.valueToCode(this, 'LIST', generator.ORDER_ATOMIC) || 'mylist';
|
||||
var value_row = generator.valueToCode(this, 'row', generator.ORDER_ATOMIC) || 0;
|
||||
var value_col = generator.valueToCode(this, 'col', generator.ORDER_ATOMIC) || 0;
|
||||
var code = value_LIST + '[' + value_row + ',' + value_col + ']';
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const lists_2d_get_col_row_data = function (_, generator) {
|
||||
var value_LIST = generator.valueToCode(this, 'LIST', generator.ORDER_ATOMIC) || 'mylist';
|
||||
var value_row_start = generator.valueToCode(this, 'row_start', generator.ORDER_ATOMIC) || 0;
|
||||
var value_row_end = generator.valueToCode(this, 'row_end', generator.ORDER_ATOMIC) || 1;
|
||||
var value_col_start = generator.valueToCode(this, 'col_start', generator.ORDER_ATOMIC) || 0;
|
||||
var value_col_end = generator.valueToCode(this, 'col_end', generator.ORDER_ATOMIC) || 1;
|
||||
var code = value_LIST + '[' + value_row_start + ' : ' + value_row_end + ',' + value_col_start + ' : ' + value_col_end + ']';
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const lists_create_with = function (_, generator) {
|
||||
// Create a list with any number of elements of any type.
|
||||
var varName = generator.variableDB_.getName(this.getFieldValue('VAR'),
|
||||
Blockly.Variables.NAME_TYPE);
|
||||
//var size=window.parseFloat(this.getFieldValue('SIZE'));
|
||||
var code = new Array(this.itemCount_);
|
||||
var default_value = '0';
|
||||
for (var n = 0; n < this.itemCount_; n++) {
|
||||
code[n] = generator.valueToCode(this, 'ADD' + n,
|
||||
generator.ORDER_NONE) || default_value;
|
||||
}
|
||||
//generator.setups_['var_declare'+varName] = varName+' = '+ '[' + code.join(', ') + ']\n';
|
||||
var code = varName + ' = ' + '[' + code.join(', ') + ']\n';
|
||||
return code;
|
||||
}
|
||||
|
||||
export const lists_create_with_text = function (_, generator) {
|
||||
var varName = generator.variableDB_.getName(this.getFieldValue('VAR'),
|
||||
Blockly.Variables.NAME_TYPE);
|
||||
//var size=window.parseFloat(this.getFieldValue('SIZE'));
|
||||
var text = this.getFieldValue('TEXT');
|
||||
// generator.setups_['var_declare'+varName] = varName+' = '+ '[' + text + ']\n';
|
||||
var code = varName + ' = ' + '[' + text + ']\n';
|
||||
return code;
|
||||
}
|
||||
|
||||
export const lists_get_index = function (_, generator) {
|
||||
// Indexing into a list is the same as indexing into a string.
|
||||
var list = generator.valueToCode(this, 'LIST', generator.ORDER_ADDITIVE) || 'mylist';
|
||||
var argument0 = generator.valueToCode(this, 'AT', generator.ORDER_ADDITIVE) || 0;
|
||||
var code = list + '[' + argument0 + ']';
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const lists_set_index = function (_, generator) {
|
||||
// Set element at index.
|
||||
var varName = generator.valueToCode(this, 'LIST', generator.ORDER_ADDITIVE) || 'mylist';
|
||||
var argument0 = generator.valueToCode(this, 'AT',
|
||||
generator.ORDER_ADDITIVE) || '0';
|
||||
var argument2 = generator.valueToCode(this, 'TO',
|
||||
generator.ORDER_ASSIGNMENT) || '0';
|
||||
// Blockly uses one-based indicies.
|
||||
return varName + '[' + argument0 + '] = ' + argument2 + '\n';
|
||||
}
|
||||
|
||||
export const lists_append_extend = function (_, generator) {
|
||||
var varName = generator.valueToCode(this, 'LIST', generator.ORDER_ASSIGNMENT) || '0';
|
||||
var argument = generator.valueToCode(this, 'DATA', generator.ORDER_ASSIGNMENT) || '0';
|
||||
var op = this.getFieldValue('OP');
|
||||
var code = varName + '.' + op + '(' + argument + ')\n';
|
||||
return code;
|
||||
}
|
||||
|
||||
export const lists_get_random_item = function (_, generator) {
|
||||
generator.definitions_['import_random'] = 'import random';
|
||||
var varName = generator.valueToCode(this, 'LIST', generator.ORDER_ADDITIVE) || 'mylist';
|
||||
var code = 'random.choice(' + varName + ')';
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const lists_get_random_sublist = function (_, generator) {
|
||||
generator.definitions_['import_random'] = 'import random';
|
||||
var varName = generator.valueToCode(this, 'LIST', generator.ORDER_ADDITIVE) || 'mylist';
|
||||
var VALUE = generator.valueToCode(this, 'VAR', generator.ORDER_ASSIGNMENT) || '0';
|
||||
var code = 'random.sample(' + varName + ',' + VALUE + ')';
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const lists_insert_value = function (_, generator) {
|
||||
var varName = generator.valueToCode(this, 'LIST', generator.ORDER_ASSIGNMENT) || '0';
|
||||
var at = generator.valueToCode(this, 'AT', generator.ORDER_ADDITIVE) || '0';
|
||||
var VALUE = generator.valueToCode(this, 'VALUE', generator.ORDER_ASSIGNMENT) || '0';
|
||||
var code = varName + '.insert(' + at + ', ' + VALUE + ')\n';
|
||||
return code;
|
||||
}
|
||||
|
||||
export const lists_reverse = function (_, generator) {
|
||||
var varName = generator.valueToCode(this, 'VAR', generator.ORDER_ASSIGNMENT) || '0';
|
||||
var code = varName + '.reverse()\n';
|
||||
return code;
|
||||
}
|
||||
export const lists_clear = function (_, generator) {
|
||||
var varName = generator.valueToCode(this, 'VAR', generator.ORDER_ASSIGNMENT) || '0';
|
||||
var code = varName + '.clear()\n';
|
||||
return code;
|
||||
}
|
||||
|
||||
export const lists_find = function (_, generator) {
|
||||
var op = this.getFieldValue('OP');
|
||||
var varName = generator.valueToCode(this, 'VAR', generator.ORDER_ASSIGNMENT) || '0';
|
||||
var argument = generator.valueToCode(this, 'data', generator.ORDER_ASSIGNMENT) || '0';
|
||||
if (op == 'INDEX')
|
||||
var code = varName + '.index(' + argument + ')';
|
||||
else if (op == 'COUNT')
|
||||
var code = varName + '.count(' + argument + ')';
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const lists_remove_at = function (_, generator) {
|
||||
var varName = generator.valueToCode(this, 'LIST', generator.ORDER_ASSIGNMENT) || '0';
|
||||
var argument = generator.valueToCode(this, 'DATA', generator.ORDER_ASSIGNMENT) || '0';
|
||||
var op = this.getFieldValue('OP');
|
||||
var code = "";
|
||||
if (op == "del") {
|
||||
code = 'del ' + varName + '[' + argument + ']\n';
|
||||
} else {
|
||||
code = varName + '.remove' + '(' + argument + ')\n';
|
||||
}
|
||||
return code;
|
||||
}
|
||||
|
||||
export const lists_pop = function (_, generator) {
|
||||
var varName = generator.valueToCode(this, 'LIST', generator.ORDER_ADDITIVE) || 'mylist';
|
||||
var argument = generator.valueToCode(this, 'VALUE', generator.ORDER_ASSIGNMENT) || '0';
|
||||
var code = varName + '.pop(' + argument + ')';
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const list_trig = function (a, generator) {
|
||||
var b = a.getFieldValue("OP"), c;
|
||||
generator.definitions_['import_math'] = "import math";
|
||||
a = generator.valueToCode(a, 'data', generator.ORDER_NONE)
|
||||
switch (b) {
|
||||
case "LEN":
|
||||
c = "len(" + a + ")";
|
||||
break;
|
||||
case "SUM":
|
||||
c = "sum(" + a + ")";
|
||||
break;
|
||||
case "MIN":
|
||||
c = "min(" + a + ")";
|
||||
break;
|
||||
case "MAX":
|
||||
c = "max(" + a + ")";
|
||||
break;
|
||||
case 'AVERAGE':
|
||||
generator.definitions_['import_mixpy_math_mean'] = "from mixpy import math_mean";
|
||||
c = 'math_mean(' + a + ')';
|
||||
break;
|
||||
case 'MEDIAN':
|
||||
generator.definitions_['import_mixpy_math_median'] = "from mixpy import math_median";
|
||||
c = 'math_median(' + a + ')';
|
||||
break;
|
||||
case 'MODE':
|
||||
generator.definitions_['import_mixpy_math_modes'] = "from mixpy import math_modes";
|
||||
c = 'math_modes(' + a + ')';
|
||||
break;
|
||||
case 'STD_DEV':
|
||||
generator.definitions_['import_mixpy_math_standard_deviation'] = "from mixpy import math_standard_deviation";
|
||||
c = 'math_standard_deviation(' + a + ')';
|
||||
break;
|
||||
default:
|
||||
throw 'Unknown operator: ' + b;
|
||||
}
|
||||
if (c)
|
||||
return [c, generator.ORDER_ATOMIC];
|
||||
|
||||
}
|
||||
|
||||
export const lists_sort = function (block, generator) {
|
||||
// Block for sorting a list.
|
||||
generator.definitions_['import_mixpy_lists_sort'] = "from mixpy import lists_sort";
|
||||
var list = (generator.valueToCode(block, 'LIST',
|
||||
generator.ORDER_NONE) || '[]');
|
||||
var type = block.getFieldValue('TYPE');
|
||||
var reverse = block.getFieldValue('DIRECTION') === '1' ? 'False' : 'True';
|
||||
var code = 'lists_sort(' + list + ', "' + type + '", ' + reverse + ')';
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const lists_change_to = function (_, generator) {
|
||||
var op = this.getFieldValue('OP');
|
||||
var varName = generator.valueToCode(this, 'VAR', generator.ORDER_ASSIGNMENT) || '0';
|
||||
var code = '';
|
||||
if (op == 'array') {
|
||||
generator.definitions_['import_numpy'] = 'import numpy';
|
||||
code = 'numpy.array(' + varName + ')';
|
||||
}
|
||||
else {
|
||||
code = op + '(' + varName + ')';
|
||||
}
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const list_many_input = function (_, generator) {
|
||||
var text = this.getFieldValue('CONTENT');
|
||||
var code = '[' + text + ']'
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const lists_create_with_noreturn = function (_, generator) {
|
||||
// Create a list with any number of elements of any type.
|
||||
var code = new Array(this.itemCount_);
|
||||
var default_value = '0';
|
||||
for (var n = 0; n < this.itemCount_; n++) {
|
||||
code[n] = generator.valueToCode(this, 'ADD' + n,
|
||||
generator.ORDER_NONE) || default_value;
|
||||
}
|
||||
var code = '[' + code.join(', ') + ']';
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const lists_change_to_general = lists_change_to;
|
||||
|
||||
export const lists_del_general = function (_, generator) {
|
||||
var varName = generator.valueToCode(this, 'TUP', generator.ORDER_ASSIGNMENT) || '0';
|
||||
var code = 'del ' + varName + '\n';
|
||||
return code;
|
||||
}
|
||||
|
||||
export const lists_create_with2 = lists_create_with
|
||||
export const lists_create_with_text2 = lists_create_with_text
|
||||
export const lists_getIndex3 = lists_get_index
|
||||
export const lists_getSublist3 = lists_get_sublist
|
||||
export const lists_setIndex3 = lists_set_index
|
||||
export const lists_insert_value2 = lists_insert_value
|
||||
export const lists_remove_at2 = lists_remove_at
|
||||
|
||||
export const lists_zip = function (_, generator) {
|
||||
var code = new Array(this.itemCount_);
|
||||
var default_value = '[]';
|
||||
for (var n = 0; n < this.itemCount_; n++) {
|
||||
code[n] = generator.valueToCode(this, 'ADD' + n,
|
||||
generator.ORDER_NONE) || default_value;
|
||||
}
|
||||
var code = 'zip(' + code.join(', ') + ')';
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const list_tolist = function (_, generator) {
|
||||
var str = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC) || '0'
|
||||
return ['list(' + str + ')', generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const list_tolist2 = function (_, generator) {
|
||||
var str = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC) || '0'
|
||||
return [str + '.tolist()', generator.ORDER_ATOMIC];
|
||||
}
|
||||
102
boards/default_src/python/generators/logic.js
Normal file
102
boards/default_src/python/generators/logic.js
Normal file
@@ -0,0 +1,102 @@
|
||||
export const logic_compare = function (_, generator) {
|
||||
// Comparison operator.
|
||||
var mode = this.getFieldValue('OP');
|
||||
var operator = logic_compare.OPERATORS[mode];
|
||||
var order = (operator == '==' || operator == '!=') ?
|
||||
generator.ORDER_EQUALITY : generator.ORDER_RELATIONAL;
|
||||
var argument0 = generator.valueToCode(this, 'A', order) || '0';
|
||||
var argument1 = generator.valueToCode(this, 'B', order) || '0';
|
||||
var code = argument0 + ' ' + operator + ' ' + argument1;
|
||||
return [code, order];
|
||||
}
|
||||
|
||||
export const logic_compare_continous = function (_, generator) {
|
||||
// Comparison operator.
|
||||
var mode1 = this.getFieldValue('OP1');
|
||||
var operator1 = logic_compare.OPERATORS[mode1];
|
||||
var mode2 = this.getFieldValue('OP2');
|
||||
var operator2 = logic_compare.OPERATORS[mode2];
|
||||
var argument0 = generator.valueToCode(this, 'A', generator.ORDER_RELATIONAL) || '0';
|
||||
var argument1 = generator.valueToCode(this, 'B', generator.ORDER_RELATIONAL) || '0';
|
||||
var argument2 = generator.valueToCode(this, 'C', generator.ORDER_RELATIONAL) || '0';
|
||||
var code = argument0 + ' ' + operator1 + ' ' + argument1 + ' ' + operator2 + ' ' + argument2;
|
||||
return [code, generator.ORDER_RELATIONAL];
|
||||
}
|
||||
|
||||
logic_compare.OPERATORS = {
|
||||
EQ: '==',
|
||||
NEQ: '!=',
|
||||
LT: '<',
|
||||
LTE: '<=',
|
||||
GT: '>',
|
||||
GTE: '>='
|
||||
};
|
||||
|
||||
export const logic_operation = function (_, generator) {
|
||||
// Operations 'and', 'or'.
|
||||
var operator = this.getFieldValue('OP');
|
||||
var order = (operator == '&&') ? generator.ORDER_LOGICAL_AND :
|
||||
generator.ORDER_LOGICAL_OR;
|
||||
var argument0 = generator.valueToCode(this, 'A', order) || 'False';
|
||||
var argument1 = generator.valueToCode(this, 'B', order) || 'False';
|
||||
if (operator == 'AND') {
|
||||
var code = argument0 + ' and ' + argument1;
|
||||
} else if (operator == 'OR') {
|
||||
var code = argument0 + ' or ' + argument1;
|
||||
} else if (operator == 'NOR') {
|
||||
// var code = '('+argument0+' and '+argument1+' ) or ((not '+argument0+') and (not '+argument1+'))';
|
||||
var code = 'not(' + argument0 + '^' + argument1 + ')';
|
||||
} else {
|
||||
// var code = '((not '+argument0+') and '+argument1+' ) or ( '+argument0+' and (not '+argument1+'))';
|
||||
var code = argument0 + '^' + argument1;
|
||||
}
|
||||
return [code, order];
|
||||
}
|
||||
|
||||
export const logic_negate = function (_, generator) {
|
||||
// Negation.
|
||||
var order = generator.ORDER_UNARY_PREFIX;
|
||||
var argument0 = generator.valueToCode(this, 'BOOL', order) || 'False';
|
||||
var code = 'not ' + argument0;
|
||||
return [code, order];
|
||||
}
|
||||
|
||||
export const logic_boolean = function (_, generator) {
|
||||
// Boolean values true and false.
|
||||
var code = (this.getFieldValue('BOOL') == 'TRUE') ? 'True' : 'False';
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const logic_null = function (_, generator) {
|
||||
var code = 'None';
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const logic_true_or_false = function (_, generator) {
|
||||
var a = generator.valueToCode(this, 'A', generator.ORDER_ATOMIC) || 'False';
|
||||
var b = generator.valueToCode(this, 'B', generator.ORDER_ATOMIC) || 'False';
|
||||
var c = generator.valueToCode(this, 'C', generator.ORDER_ATOMIC) || 'False';
|
||||
var code = '(' + b + ' if ' + a + ' else ' + c + ')';
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const logic_is_in = function (_, generator) {
|
||||
var a = generator.valueToCode(this, 'A', generator.ORDER_ATOMIC) || '\'\'';
|
||||
var b = generator.valueToCode(this, 'B', generator.ORDER_ATOMIC) || '\'\'';
|
||||
var bool = this.getFieldValue('BOOL');
|
||||
var code = a + ' ' + bool + ' ' + b;
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const logic_is = function (_, generator) {
|
||||
var a = generator.valueToCode(this, 'A', generator.ORDER_ATOMIC) || '\'\'';
|
||||
var b = generator.valueToCode(this, 'B', generator.ORDER_ATOMIC) || '\'\'';
|
||||
var bool = this.getFieldValue('BOOL');
|
||||
var code = a + ' ' + bool + ' ' + b;
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const logic_tobool = function (_, generator) {
|
||||
var str = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC) || '0'
|
||||
return ['bool(' + str + ')', generator.ORDER_ATOMIC];
|
||||
}
|
||||
303
boards/default_src/python/generators/math.js
Normal file
303
boards/default_src/python/generators/math.js
Normal file
@@ -0,0 +1,303 @@
|
||||
// export const math_number = function() {
|
||||
// // Numeric value.
|
||||
// var code = (this.getFieldValue('NUM'));
|
||||
// // -4.abs() returns -4 in Dart due to strange order of operation choices.
|
||||
// // -4 is actually an operator and a number. Reflect this in the order.
|
||||
// var order = code < 0 ?
|
||||
// generator.ORDER_UNARY_PREFIX : generator.ORDER_ATOMIC;
|
||||
// return [code, order];
|
||||
// }
|
||||
|
||||
// generator.math = {}
|
||||
// generator.addReservedWords("math,random,Number");
|
||||
|
||||
export const math_number = function (_, generator) {
|
||||
// a = parseFloat(a.getFieldValue("NUM"));
|
||||
// var b;
|
||||
// Infinity == a ? (a = 'float("inf")', b = generator.ORDER_FUNCTION_CALL) : -Infinity == a ? (a = '-float("inf")', b = generator.ORDER_UNARY_SIGN) : b = 0 > a ? generator.ORDER_UNARY_SIGN : generator.ORDER_ATOMIC;
|
||||
// return [a, b]
|
||||
|
||||
var code = this.getFieldValue('NUM');
|
||||
// -4.abs() returns -4 in Dart due to strange order of operation choices.
|
||||
// -4 is actually an operator and a number. Reflect this in the order.
|
||||
var order = code < 0 ?
|
||||
generator.ORDER_UNARY_PREFIX : generator.ORDER_ATOMIC;
|
||||
return [code, order];
|
||||
}
|
||||
|
||||
export const math_constant = function (_, generator) {
|
||||
generator.definitions_.import_math = "import math";
|
||||
var name = this.getFieldValue('CONSTANT');
|
||||
var code = 'math.' + name;
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const math_constant_mp = function (_, generator) {
|
||||
generator.definitions_.import_math = "import math";
|
||||
var name = this.getFieldValue('CONSTANT');
|
||||
var code = 'math.' + name;
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const math_bit = function (_, generator) {
|
||||
var operator = this.getFieldValue('OP');
|
||||
var order = generator.ORDER_ATOMIC;
|
||||
var argument0 = generator.valueToCode(this, 'A', order) || '0';
|
||||
var argument1 = generator.valueToCode(this, 'B', order) || '0';
|
||||
var code = '(' + argument0 + operator + argument1 + ')';
|
||||
return [code, order];
|
||||
}
|
||||
|
||||
export const math_arithmetic = function (a, generator) {
|
||||
var b = {
|
||||
ADD: [" + ", generator.ORDER_ADDITIVE],
|
||||
MINUS: [" - ", generator.ORDER_ADDITIVE],
|
||||
MULTIPLY: [" * ", generator.ORDER_MULTIPLICATIVE],
|
||||
DIVIDE: [" / ", generator.ORDER_MULTIPLICATIVE],
|
||||
QUYU: [' % ', generator.ORDER_MULTIPLICATIVE],//增加取余操作
|
||||
ZHENGCHU: [' // ', generator.ORDER_MULTIPLICATIVE],//增加整除操作
|
||||
POWER: [" ** ", generator.ORDER_EXPONENTIATION]
|
||||
}[a.getFieldValue("OP")],
|
||||
c = b[0],
|
||||
b = b[1],
|
||||
d = generator.valueToCode(a, "A", b) || "0";
|
||||
a = generator.valueToCode(a, "B", b) || "0";
|
||||
return [d + c + a, b]
|
||||
}
|
||||
|
||||
export const math_selfcalcu = function (_, generator) {
|
||||
var argument0 = generator.valueToCode(this, 'A', generator.ORDER_RELATIONAL) || '0';
|
||||
var argument1 = generator.valueToCode(this, 'B', generator.ORDER_RELATIONAL) || '0';
|
||||
var operator = this.getFieldValue('OP');
|
||||
switch (operator) {
|
||||
case 'ADD': var op = '+='; break;
|
||||
case 'MINUS': var op = '-='; break;
|
||||
case 'MULTIPLY': var op = '*='; break;
|
||||
case 'DIVIDE': var op = '/='; break;
|
||||
case 'QUYU': var op = '%='; break;
|
||||
case 'ZHENGCHU': var op = '//='; break;
|
||||
case 'POWER': var op = '**='; break;
|
||||
}
|
||||
var code = argument0 + ' ' + op + ' ' + argument1 + '\n';
|
||||
return code;
|
||||
}
|
||||
|
||||
export const math_single = function (a, generator) {
|
||||
var b = a.getFieldValue("OP"),
|
||||
c;
|
||||
if ("NEG" == b)
|
||||
return c = generator.valueToCode(a, "NUM", generator.ORDER_UNARY_SIGN) || "0", ["-" + c, generator.ORDER_UNARY_SIGN];
|
||||
generator.definitions_['import_math'] = "import math";
|
||||
a = "SIN" == b || "COS" == b || "TAN" == b ? generator.valueToCode(a, "NUM", generator.ORDER_MULTIPLICATIVE) || "0" : generator.valueToCode(a, "NUM", generator.ORDER_NONE) || "0";
|
||||
switch (b) {
|
||||
case "ABS":
|
||||
c = "math.fabs(" + a + ")";
|
||||
break;
|
||||
case "ROOT":
|
||||
c = "math.sqrt(" +
|
||||
a + ")";
|
||||
break;
|
||||
case "LN":
|
||||
c = "math.log(" + a + ")";
|
||||
break;
|
||||
case "LOG10":
|
||||
c = "math.log10(" + a + ")";
|
||||
break;
|
||||
case "EXP":
|
||||
c = "math.exp(" + a + ")";
|
||||
break;
|
||||
case "POW10":
|
||||
c = "math.pow(10," + a + ")";
|
||||
break;
|
||||
case "ROUND":
|
||||
c = "round(" + a + ")";
|
||||
break;
|
||||
case "ROUNDUP":
|
||||
c = "math.ceil(" + a + ")";
|
||||
break;
|
||||
case "ROUNDDOWN":
|
||||
c = "math.floor(" + a + ")";
|
||||
break;
|
||||
case "SIN":
|
||||
c = "math.sin(" + a + ")";
|
||||
break;
|
||||
case "COS":
|
||||
c = "math.cos(" + a + ")";
|
||||
break;
|
||||
case "TAN":
|
||||
c = "math.tan(" + a + ")";
|
||||
break;
|
||||
case "++":
|
||||
c = "++(" + a + ")";
|
||||
break;
|
||||
case "--":
|
||||
c = "--(" + a + ")";
|
||||
break;
|
||||
case "-":
|
||||
c = "-(" + a + ")";
|
||||
break;
|
||||
default:
|
||||
}
|
||||
if (c)
|
||||
return [c, generator.ORDER_EXPONENTIATION];
|
||||
switch (b) {
|
||||
case "ASIN":
|
||||
c = "math.degrees(math.asin(" + a + "))";
|
||||
break;
|
||||
case "ACOS":
|
||||
c = "math.degrees(math.acos(" + a + "))";
|
||||
break;
|
||||
case "ATAN":
|
||||
c = "math.degrees(math.atan(" + a + "))";
|
||||
break;
|
||||
}
|
||||
return [c, generator.ORDER_MULTIPLICATIVE]
|
||||
}
|
||||
|
||||
export const math_trig = math_single;
|
||||
|
||||
export const math_dec = function (_, generator) {
|
||||
var argument0 = generator.valueToCode(this, 'NUM', generator.ORDER_NONE) || '0';
|
||||
var operator = this.getFieldValue('OP');
|
||||
var code = operator + '(' + argument0 + ')';
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
|
||||
}
|
||||
|
||||
export const math_to_int = function (_, generator) {
|
||||
var argument0 = generator.valueToCode(this, 'A', generator.ORDER_NONE) || '0';
|
||||
var operator = this.getFieldValue('OP');
|
||||
var code = "";
|
||||
if (operator === "round") {
|
||||
code = operator + '(' + argument0 + ')';
|
||||
} else {
|
||||
code = "math." + operator + '(' + argument0 + ')';
|
||||
generator.definitions_.import_math = "import math";
|
||||
}
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const math_max_min = function (_, generator) {
|
||||
var a = generator.valueToCode(this, 'A', generator.ORDER_NONE) || '0';
|
||||
var b = generator.valueToCode(this, 'B', generator.ORDER_NONE) || '0';
|
||||
var operator = this.getFieldValue('OP');
|
||||
var code = operator + '(' + a + ', ' + b + ')';
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const math_random = function (_, generator) {
|
||||
generator.definitions_.import_random = "import random";
|
||||
// Random integer between [X] and [Y].
|
||||
var type = this.getFieldValue('TYPE');
|
||||
var argument0 = generator.valueToCode(this, 'FROM',
|
||||
generator.ORDER_NONE) || '0';
|
||||
var argument1 = generator.valueToCode(this, 'TO',
|
||||
generator.ORDER_NONE) || '0';
|
||||
if (type == 'int') {
|
||||
var code = 'random.randint(' + argument0 + ', ' + argument1 + ')';
|
||||
} else if (type == 'float') {
|
||||
var code = 'random.uniform(' + argument0 + ', ' + argument1 + ')';
|
||||
}
|
||||
return [code, generator.ORDER_UNARY_POSTFIX];
|
||||
}
|
||||
|
||||
export const math_map = function (_, generator) {
|
||||
var value_num = generator.valueToCode(this, 'NUM', generator.ORDER_NONE);
|
||||
var value_fl = generator.valueToCode(this, 'fromLow', generator.ORDER_ATOMIC);
|
||||
var value_fh = generator.valueToCode(this, 'fromHigh', generator.ORDER_ATOMIC);
|
||||
var value_tl = generator.valueToCode(this, 'toLow', generator.ORDER_ATOMIC);
|
||||
var value_th = generator.valueToCode(this, 'toHigh', generator.ORDER_ATOMIC);
|
||||
generator.definitions_['import_mixpy_math_map'] = "from mixpy import math_map";
|
||||
var code = 'math_map(' + value_num + ', ' + value_fl + ', ' + value_fh + ', ' + value_tl + ', ' + value_th + ')';
|
||||
return [code, generator.ORDER_NONE];
|
||||
}
|
||||
|
||||
export const math_constrain = function (_, generator) {
|
||||
// Constrain a number between two limits.
|
||||
var argument0 = generator.valueToCode(this, 'VALUE',
|
||||
generator.ORDER_NONE) || '0';
|
||||
var argument1 = generator.valueToCode(this, 'LOW',
|
||||
generator.ORDER_NONE) || '0';
|
||||
var argument2 = generator.valueToCode(this, 'HIGH',
|
||||
generator.ORDER_NONE) || '0';
|
||||
var code = 'min(max(' + argument0 + ', ' + argument1 + '), ' + argument2 + ')';
|
||||
return [code, generator.ORDER_UNARY_POSTFIX];
|
||||
}
|
||||
|
||||
export const math_number_base_conversion = function (a, generator) {
|
||||
var c1 = a.getFieldValue("OP");
|
||||
var d = generator.valueToCode(this, 'NUM', generator.ORDER_NONE) || '0';
|
||||
var c2 = a.getFieldValue("OP2");
|
||||
generator.definitions_['import_math'] = "import math";
|
||||
var param1 = "";
|
||||
var param2 = "10";
|
||||
if (c1 == "two") {
|
||||
param2 = '2';
|
||||
} else if (c1 == "eight") {
|
||||
param2 = '8'
|
||||
} else if (c1 == "ten") {
|
||||
param2 = '10'
|
||||
} else if (c1 == "sixteen") {
|
||||
param2 = '16'
|
||||
}
|
||||
|
||||
if (c2 == "two") {
|
||||
param1 = 'bin';
|
||||
} else if (c2 == "eight") {
|
||||
param1 = 'oct'
|
||||
} else if (c2 == "ten") {
|
||||
param1 = ''
|
||||
} else if (c2 == "sixteen") {
|
||||
param1 = 'hex'
|
||||
}
|
||||
if (param1 == "") {
|
||||
var code = "int(str(" + d + "), " + param2 + ")";
|
||||
} else {
|
||||
var code = param1 + "(int(str(" + d + "), " + param2 + "))";
|
||||
|
||||
}
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const math_random_seed = function (_, generator) {
|
||||
// Random integer between [X] and [Y].
|
||||
generator.definitions_.import_random = "import random";
|
||||
var a = generator.valueToCode(this, 'NUM', generator.ORDER_NONE) || '0';
|
||||
var code = 'random.seed(' + a + ');' + '\n';
|
||||
return code;
|
||||
}
|
||||
|
||||
export const math_indexer_number = function (_, generator) {
|
||||
var code = this.getFieldValue('NUM');
|
||||
// -4.abs() returns -4 in Dart due to strange order of operation choices.
|
||||
// -4 is actually an operator and a number. Reflect this in the order.
|
||||
var order = code < 0 ?
|
||||
generator.ORDER_UNARY_PREFIX : generator.ORDER_ATOMIC;
|
||||
return [code, order];
|
||||
}
|
||||
|
||||
export const math_round = function (_, generator) {
|
||||
var argument0 = generator.valueToCode(this, 'VALUE',
|
||||
generator.ORDER_NONE) || '0';
|
||||
var argument1 = generator.valueToCode(this, 'VAR',
|
||||
generator.ORDER_NONE) || '0';
|
||||
|
||||
var code = 'round(' + argument0 + ', ' + argument1 + ')';
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const text_to_number = function (_, generator) {
|
||||
var towhat = this.getFieldValue('TOWHAT');
|
||||
var str = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
|
||||
if (towhat == 'b') return ['' + str + '.encode("utf-8")', generator.ORDER_ATOMIC];
|
||||
return [towhat + "(" + str + ')', generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const text_to_number_skulpt = function (_, generator) {
|
||||
var towhat = this.getFieldValue('TOWHAT');
|
||||
var str = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
|
||||
if (towhat == 'b') return ['' + str + '.encode("utf-8")', generator.ORDER_ATOMIC];
|
||||
return [towhat + "(" + str + ')', generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const base_map = math_map;
|
||||
107
boards/default_src/python/generators/procedures.js
Normal file
107
boards/default_src/python/generators/procedures.js
Normal file
@@ -0,0 +1,107 @@
|
||||
import * as Blockly from 'blockly/core';
|
||||
|
||||
export const procedures_defreturn = function (_, generator) {
|
||||
// Define a procedure with a return value.
|
||||
var funcName = generator.variableDB_.getName(this.getFieldValue('NAME'),
|
||||
Blockly.Procedures.NAME_TYPE);
|
||||
var branch = generator.statementToCode(this, 'STACK') || ' pass\n';
|
||||
if (generator.INFINITE_LOOP_TRAP) {
|
||||
branch = generator.INFINITE_LOOP_TRAP.replace(/%1/g,
|
||||
'\'' + this.id + '\'') + branch;
|
||||
}
|
||||
var returnValue = generator.valueToCode(this, 'RETURN',
|
||||
generator.ORDER_NONE) || '';
|
||||
//var type=this.getFieldValue('TYPE');
|
||||
if (returnValue) {
|
||||
returnValue = ' return ' + returnValue + '\n';
|
||||
}
|
||||
//var returnType = returnValue ? type : 'void';
|
||||
var args = [];
|
||||
for (var x = 0; x < this.arguments_.length; x++) {
|
||||
var varName = generator.variableDB_.getName(this.arguments_[x], Blockly.Variables.NAME_TYPE);
|
||||
args[x] = varName;
|
||||
}
|
||||
var code = 'def ' + funcName + '(' + args.join(', ') + '):\n' +
|
||||
branch + returnValue + '\n';
|
||||
code = generator.scrub_(this, code);
|
||||
generator.setups_[funcName] = code;
|
||||
return null;
|
||||
}
|
||||
|
||||
export const procedures_defnoreturn = function (_, generator) {
|
||||
// Define a procedure with a return value.
|
||||
var funcName = generator.variableDB_.getName(this.getFieldValue('NAME'),
|
||||
Blockly.Procedures.NAME_TYPE);
|
||||
var branch = generator.statementToCode(this, 'STACK') || ' pass\n';
|
||||
if (generator.INFINITE_LOOP_TRAP) {
|
||||
branch = generator.INFINITE_LOOP_TRAP.replace(/%1/g,
|
||||
'\'' + this.id + '\'') + branch;
|
||||
}
|
||||
//var returnType = returnValue ? type : 'void';
|
||||
var args = [];
|
||||
for (var x = 0; x < this.arguments_.length; x++) {
|
||||
var varName = generator.variableDB_.getName(this.arguments_[x], Blockly.Variables.NAME_TYPE);
|
||||
args[x] = varName;
|
||||
}
|
||||
var code = 'def ' + funcName + '(' + args.join(', ') + '):\n' +
|
||||
branch + '\n';
|
||||
code = generator.scrub_(this, code);
|
||||
generator.setups_[funcName] = code;
|
||||
return null;
|
||||
}
|
||||
|
||||
export const procedures_callreturn = function (_, generator) {
|
||||
// Call a procedure with a return value.
|
||||
var funcName = generator.variableDB_.getName(this.getFieldValue('NAME'),
|
||||
Blockly.Procedures.NAME_TYPE);
|
||||
var args = [];
|
||||
for (var x = 0; x < this.arguments_.length; x++) {
|
||||
args[x] = generator.valueToCode(this, 'ARG' + x,
|
||||
generator.ORDER_NONE) || 'null';
|
||||
}
|
||||
var code = funcName + '(' + args.join(', ') + ')';
|
||||
return [code, generator.ORDER_UNARY_POSTFIX];
|
||||
}
|
||||
|
||||
export const procedures_callnoreturn = function (_, generator) {
|
||||
// Call a procedure with no return value.
|
||||
var funcName = generator.variableDB_.getName(this.getFieldValue('NAME'),
|
||||
Blockly.Procedures.NAME_TYPE);
|
||||
var args = [];
|
||||
for (var x = 0; x < this.arguments_.length; x++) {
|
||||
args[x] = generator.valueToCode(this, 'ARG' + x,
|
||||
generator.ORDER_NONE) || 'null';
|
||||
}
|
||||
var code = funcName + '(' + args.join(', ') + ')\n';
|
||||
return code;
|
||||
}
|
||||
|
||||
export const procedures_ifreturn = function (_, generator) {
|
||||
// Conditionally return value from a procedure.
|
||||
var condition = generator.valueToCode(this, 'CONDITION',
|
||||
generator.ORDER_NONE) || 'False';
|
||||
var code = 'if (' + condition + ') :\n';
|
||||
if (this.hasReturnValue_) {
|
||||
var value = generator.valueToCode(this, 'VALUE',
|
||||
generator.ORDER_NONE) || 'None';
|
||||
code += ' return ' + value;
|
||||
} else {
|
||||
code += ' return None';
|
||||
}
|
||||
code += '\n';
|
||||
return code;
|
||||
}
|
||||
|
||||
export const procedures_return = function (_, generator) {
|
||||
// Conditionally return value from a procedure.
|
||||
var code = ""
|
||||
if (this.hasReturnValue_) {
|
||||
var value = generator.valueToCode(this, 'VALUE',
|
||||
generator.ORDER_NONE) || 'None';
|
||||
code += 'return ' + value;
|
||||
} else {
|
||||
code += 'return None';
|
||||
}
|
||||
code += '\n';
|
||||
return code;
|
||||
}
|
||||
95
boards/default_src/python/generators/set.js
Normal file
95
boards/default_src/python/generators/set.js
Normal file
@@ -0,0 +1,95 @@
|
||||
import * as Blockly from 'blockly/core';
|
||||
|
||||
export const set_create_with = function (_, generator) {
|
||||
var varName = generator.variableDB_.getName(this.getFieldValue('VAR'),
|
||||
Blockly.Variables.NAME_TYPE);
|
||||
var code = new Array(this.itemCount_);
|
||||
var default_value = '0';
|
||||
for (var n = 0; n < this.itemCount_; n++) {
|
||||
code[n] = generator.valueToCode(this, 'ADD' + n,
|
||||
generator.ORDER_NONE) || default_value;
|
||||
}
|
||||
//generator.definitions_['var_declare'+varName] = varName+'= '+ '{' + code.join(', ') + '}\n';
|
||||
code = varName + '= ' + '{' + code.join(', ') + '}\n';
|
||||
if (this.itemCount_ == 0) { code = varName + ' = ' + 'set()\n' }
|
||||
return code;
|
||||
}
|
||||
|
||||
export const set_length = function (_, generator) {
|
||||
var varName = generator.valueToCode(this, 'SET', generator.ORDER_ASSIGNMENT) || '0';
|
||||
var code = 'len(' + varName + ')';
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const set_pop = function (_, generator) {
|
||||
var varName = generator.valueToCode(this, 'SET', generator.ORDER_ASSIGNMENT) || '0';
|
||||
var code = varName + '.pop()';
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const set_clear = function (_, generator) {
|
||||
var varName = generator.valueToCode(this, 'SET', generator.ORDER_ASSIGNMENT) || '0';
|
||||
var code = varName + '.clear()\n';
|
||||
return code;
|
||||
}
|
||||
|
||||
export const set_operate = function (_, generator) {
|
||||
var vars1 = generator.valueToCode(this, 'SET1', generator.ORDER_ASSIGNMENT) || '0';
|
||||
var vars2 = generator.valueToCode(this, 'SET2', generator.ORDER_ASSIGNMENT) || '0';
|
||||
var operate = this.getFieldValue('OPERATE');
|
||||
//var num = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
|
||||
var code = vars1 + "." + operate + "(" + vars2 + ')';
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const set_operate_update = function (_, generator) {
|
||||
var vars1 = generator.valueToCode(this, 'SET1', generator.ORDER_ASSIGNMENT) || '0';
|
||||
var vars2 = generator.valueToCode(this, 'SET2', generator.ORDER_ASSIGNMENT) || '0';
|
||||
var operate = this.getFieldValue('OPERATE');
|
||||
//var num = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
|
||||
var code = vars1 + "." + operate + "(" + vars2 + ')\n';
|
||||
return code;
|
||||
}
|
||||
|
||||
export const set_add_discard = function (_, generator) {
|
||||
var vars1 = generator.valueToCode(this, 'SET', generator.ORDER_ASSIGNMENT) || '0';
|
||||
var operate = this.getFieldValue('OPERATE');
|
||||
var argument = generator.valueToCode(this, 'data', generator.ORDER_ASSIGNMENT) || '0';
|
||||
var code = vars1 + "." + operate + "(" + argument + ')\n';
|
||||
return code;
|
||||
}
|
||||
|
||||
export const set_sub = function (_, generator) {
|
||||
var vars1 = generator.valueToCode(this, 'SET1', generator.ORDER_ASSIGNMENT) || '0';
|
||||
var vars2 = generator.valueToCode(this, 'SET2', generator.ORDER_ASSIGNMENT) || '0';
|
||||
var operate = this.getFieldValue('OPERATE');
|
||||
//var num = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
|
||||
var code = vars1 + "." + operate + "(" + vars2 + ')';
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const set_update = function (_, generator) {
|
||||
var varName = generator.valueToCode(this, 'SET', generator.ORDER_ASSIGNMENT) || '0';
|
||||
var color = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
|
||||
//var color = generator.valueToCode(this, 'data', generator.ORDER_ASSIGNMENT) || '0';
|
||||
var code = varName + "." + 'update' + '(' + color + ')\n';
|
||||
return code;
|
||||
}
|
||||
|
||||
// export const set_change_to = function(){
|
||||
// var op = this.getFieldValue('OP');
|
||||
// var varName = generator.valueToCode(this, 'VAR', generator.ORDER_ASSIGNMENT) || '0';
|
||||
// var code = op + '(' + varName + ')\n';
|
||||
// return [code, generator.ORDER_ATOMIC];
|
||||
// }
|
||||
|
||||
export const set_create_with_text_return = function (_, generator) {
|
||||
var text = this.getFieldValue('TEXT');
|
||||
var code = '{' + text + '}';
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const set_toset = function (_, generator) {
|
||||
var str = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC) || '0'
|
||||
return ['set(' + str + ')', generator.ORDER_ATOMIC];
|
||||
}
|
||||
175
boards/default_src/python/generators/storage.js
Normal file
175
boards/default_src/python/generators/storage.js
Normal file
@@ -0,0 +1,175 @@
|
||||
export const storage_open_file_with_os = function (_, generator) {
|
||||
generator.definitions_['import_os'] = 'import os';
|
||||
var fn = generator.valueToCode(this, 'fn', generator.ORDER_ATOMIC);
|
||||
return "os.startfile(" + fn + ")\n";
|
||||
}
|
||||
|
||||
export const storage_fileopen = function (_, generator) {
|
||||
// For each loop.
|
||||
var variable0 = generator.valueToCode(this, 'FILE', generator.ORDER_ATOMIC);
|
||||
var fn = generator.valueToCode(this, 'FILENAME', generator.ORDER_ATOMIC);
|
||||
var mode = this.getFieldValue('MODE');
|
||||
var code = variable0 + ' = open(' + fn + ', \'' + mode + '\')\n';
|
||||
return code;
|
||||
}
|
||||
|
||||
export const storage_fileopen_new = function (_, generator) { // For each loop.
|
||||
var fn = generator.valueToCode(this, 'FILENAME', generator.ORDER_ATOMIC);
|
||||
var mode = this.getFieldValue('MODE');
|
||||
var code = 'open(' + fn + ', \'' + mode + '\')';
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const storage_fileopen_new_encoding = function (_, generator) { // For each loop.
|
||||
var fn = generator.valueToCode(this, 'FILENAME', generator.ORDER_ATOMIC);
|
||||
var mode = this.getFieldValue('MODE');
|
||||
var encode = this.getFieldValue('CODE');
|
||||
var code = 'open(' + fn + ', \'' + mode + '\', encoding="' + encode + '")';
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const storage_file_write = function (_, generator) {
|
||||
var data = generator.valueToCode(this, 'data', generator.ORDER_ATOMIC);
|
||||
var file = generator.valueToCode(this, 'FILE', generator.ORDER_ATOMIC);
|
||||
return file + ".write(" + data + ")\n";
|
||||
}
|
||||
|
||||
export const storage_get_contents_without_para = function (_, generator) {
|
||||
var mode = this.getFieldValue('MODE');
|
||||
var file = generator.valueToCode(this, 'FILE', generator.ORDER_ATOMIC);
|
||||
var code = file + '.' + mode + '()';
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const storage_get_contents = function (_, generator) {
|
||||
var mode = this.getFieldValue('MODE');
|
||||
var file = generator.valueToCode(this, 'FILE', generator.ORDER_ATOMIC);
|
||||
var size = generator.valueToCode(this, 'SIZE', generator.ORDER_ATOMIC);
|
||||
var code = file + '.' + mode + '(' + size + ')';
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const storage_get_a_line = function (_, generator) {
|
||||
var file = generator.valueToCode(this, 'FILE', generator.ORDER_ATOMIC);
|
||||
var size = generator.valueToCode(this, 'SIZE', generator.ORDER_ATOMIC);
|
||||
var code = file + ".readline(" + size + ')';
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const storage_can_write_ornot = function (_, generator) {
|
||||
var file = generator.valueToCode(this, 'FILE', generator.ORDER_ATOMIC);
|
||||
var code = file + ".writable()";
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const storage_get_filename = function (_, generator) {
|
||||
var file = generator.valueToCode(this, 'FILE', generator.ORDER_ATOMIC);
|
||||
var code = file + ".name()";
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const storage_close_file = function (_, generator) {
|
||||
var file = generator.valueToCode(this, 'FILE', generator.ORDER_ATOMIC);
|
||||
var code = file + ".close()\n";
|
||||
return code;
|
||||
}
|
||||
|
||||
export const storage_list_all_files = function (_, generator) {
|
||||
generator.definitions_['import_os'] = 'import os';
|
||||
var code = 'os.listdir()';
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const storage_delete_file = function (_, generator) {
|
||||
generator.definitions_['import_os'] = 'import os';
|
||||
var mode = this.getFieldValue('MODE');
|
||||
var file = generator.valueToCode(this, 'FILE', generator.ORDER_ATOMIC);
|
||||
var code = "os." + mode + "(" + file + ")\n";
|
||||
return code;
|
||||
}
|
||||
|
||||
export const storage_get_file_size = function (_, generator) {
|
||||
generator.definitions_['import_os'] = 'import os';
|
||||
var file = generator.valueToCode(this, 'FILE', generator.ORDER_ATOMIC);
|
||||
var code = "os.path.getsize(" + file + ")";
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const storage_file_tell = function (_, generator) {
|
||||
var file = generator.valueToCode(this, 'FILE', generator.ORDER_ATOMIC);
|
||||
var code = file + ".tell()";
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const storage_file_seek = function (_, generator) {
|
||||
var mode = this.getFieldValue('MODE');
|
||||
var mode_num = 0;
|
||||
if (mode == 'start') {
|
||||
mode_num = 0;
|
||||
}
|
||||
else if (mode == 'current') {
|
||||
mode_num = 1;
|
||||
}
|
||||
else {
|
||||
mode_num = 2;
|
||||
}
|
||||
var file = generator.valueToCode(this, 'FILE', generator.ORDER_ATOMIC);
|
||||
var size = generator.valueToCode(this, 'SIZE', generator.ORDER_ATOMIC);
|
||||
var code = file + '.seek(' + size + ',' + mode_num + ')\n';
|
||||
return code;
|
||||
}
|
||||
|
||||
export const storage_change_dir = function (_, generator) {
|
||||
generator.definitions_['import_os'] = 'import os';
|
||||
var file = generator.valueToCode(this, 'FILE', generator.ORDER_ATOMIC);
|
||||
var code = "os.chdir(" + file + ")\n";
|
||||
return code;
|
||||
}
|
||||
|
||||
export const storage_get_current_dir = function (_, generator) {
|
||||
generator.definitions_['import_os'] = 'import os';
|
||||
var code = 'os.getcwd()';
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const storage_make_dir = function (_, generator) {
|
||||
generator.definitions_['import_os'] = 'import os';
|
||||
var mode = this.getFieldValue('MODE');
|
||||
var path = generator.valueToCode(this, 'PATH', generator.ORDER_ATOMIC);
|
||||
var code = 'os.' + mode + '(' + path + ')\n';
|
||||
return code;
|
||||
}
|
||||
|
||||
export const storage_rename = function (_, generator) {
|
||||
generator.definitions_['import_os'] = 'import os';
|
||||
var file = generator.valueToCode(this, 'FILE', generator.ORDER_ATOMIC);
|
||||
var file1 = generator.valueToCode(this, 'NEWFILE', generator.ORDER_ATOMIC);
|
||||
var code = "os.rename(" + file + "," + file1 + ")\n";
|
||||
return code;
|
||||
}
|
||||
|
||||
export const storage_is_file = function (_, generator) {
|
||||
generator.definitions_['import_os'] = 'import os';
|
||||
var file = generator.valueToCode(this, 'FILE', generator.ORDER_ATOMIC);
|
||||
var mode = this.getFieldValue('MODE');
|
||||
var code = "os." + mode + "(" + file + ")";
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const sdcard_use_spi_init = function (_, generator) {
|
||||
generator.definitions_['import_os'] = 'import os';
|
||||
generator.definitions_['import_sdcard'] = 'import sdcard';
|
||||
var v = generator.valueToCode(this, 'SUB', generator.ORDER_ATOMIC);
|
||||
var sv = generator.valueToCode(this, 'SPISUB', generator.ORDER_ATOMIC);
|
||||
var pv = generator.valueToCode(this, 'PINSUB', generator.ORDER_ATOMIC);
|
||||
var code = v + ' = sdcard.SDCard(' + sv + ',' + pv + ')\n';
|
||||
return code;
|
||||
}
|
||||
|
||||
export const sdcard_mount = function (_, generator) {
|
||||
generator.definitions_['import_os'] = 'import os';
|
||||
generator.definitions_['import_sdcard'] = 'import sdcard';
|
||||
var sd = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
|
||||
var dir = generator.valueToCode(this, 'DIR', generator.ORDER_ATOMIC);
|
||||
return "os.mount(" + sd + ',' + dir + ")\n";
|
||||
}
|
||||
245
boards/default_src/python/generators/text.js
Normal file
245
boards/default_src/python/generators/text.js
Normal file
@@ -0,0 +1,245 @@
|
||||
import * as Blockly from 'blockly/core';
|
||||
|
||||
export const text = function (_, generator) {
|
||||
// Text value.
|
||||
//var code = 'String('+generator.quote_(this.getFieldValue('TEXT'))+')';
|
||||
var code = generator.quote_(this.getFieldValue('TEXT'));
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const text_textarea = function (_, generator) {
|
||||
// Text value.
|
||||
//var code = 'String('+generator.quote_(this.getFieldValue('TEXT'))+')';
|
||||
var code = '"""' + (this.getFieldValue('VALUE')) + '"""';
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const text_char = function (_, generator) {
|
||||
var code = '\'' + this.getFieldValue('TEXT') + '\'';
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const text_join = function (_, generator) {
|
||||
// Text value.
|
||||
var a = generator.valueToCode(this, 'A', generator.ORDER_ATOMIC);
|
||||
var b = generator.valueToCode(this, 'B', generator.ORDER_ATOMIC);
|
||||
return [a + ' + ' + b, generator.ORDER_ADDITIVE];
|
||||
}
|
||||
|
||||
export const ascii_to_char = function (_, generator) {
|
||||
var asciivalue = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC) || '0'
|
||||
return ['chr(' + asciivalue + ')', generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const char_to_ascii = function (_, generator) {
|
||||
var charvalue = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC) || 'a';
|
||||
return ['ord(' + charvalue + ')', generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const number_to_text = function (_, generator) {
|
||||
var str = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC) || '0';
|
||||
return ['str(' + str + ')', generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const text_length = function (_, generator) {
|
||||
var str = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC) || '""';
|
||||
return ['len(' + str + ')', generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const text_char_at2 = function (a, generator) {
|
||||
var c = a.getFieldValue("WHERE") || "FROM_START",
|
||||
str = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC) || '""';
|
||||
switch (c) {
|
||||
case "FROM_START":
|
||||
a = generator.getAdjustedInt(a, "AT");
|
||||
return [str + "[" + a + "]", generator.ORDER_ATOMIC];
|
||||
case "FROM_END":
|
||||
a = generator.getAdjustedInt(a, "AT", 1, !0);
|
||||
return [str + "[" + a + "]", generator.ORDER_ATOMIC];
|
||||
case "RANDOM":
|
||||
generator.definitions_.import_random = "import random";
|
||||
return ["random.choice(" + str + ")", generator.ORDER_FUNCTION_CALL];
|
||||
}
|
||||
throw "Unhandled combination (lists_getIndex).";
|
||||
}
|
||||
|
||||
export const text_char_at = function (_, generator) {
|
||||
var str = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC) || '""';
|
||||
var at = generator.valueToCode(this, 'AT', generator.ORDER_ATOMIC) || 0;
|
||||
return [str + "[" + at + "]", generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const text_random_char = function (_, generator) {
|
||||
var str = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC) || '""';
|
||||
generator.definitions_.import_random = "import random";
|
||||
return ["random.choice(" + str + ")", generator.ORDER_FUNCTION_CALL];
|
||||
}
|
||||
|
||||
export const text_equals_starts_ends = function (_, generator) {
|
||||
var str1 = (generator.valueToCode(this, 'STR1', generator.ORDER_ATOMIC) || '""');
|
||||
var str2 = (generator.valueToCode(this, 'STR2', generator.ORDER_ATOMIC) || '""');
|
||||
var dowhat = this.getFieldValue('DOWHAT');
|
||||
if (dowhat === '===')
|
||||
return [str1 + ' == ' + str2, generator.ORDER_ATOMIC];
|
||||
return [str1 + '.' + dowhat + '(' + str2 + ')', generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const text_compare_to = function (_, generator) {
|
||||
var str1 = (generator.valueToCode(this, 'STR1', generator.ORDER_ATOMIC) || '""');
|
||||
var str2 = (generator.valueToCode(this, 'STR2', generator.ORDER_ATOMIC) || '""');
|
||||
return ['cmp(' + str1 + ',' + str2 + ')', generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const text_substring2 = function (block, generator) {
|
||||
// Get sublist.
|
||||
var str = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC) || '""';
|
||||
var where1 = block.getFieldValue('WHERE1');
|
||||
var where2 = block.getFieldValue('WHERE2');
|
||||
switch (where1) {
|
||||
case 'FROM_START':
|
||||
var at1 = generator.getAdjustedInt(block, 'AT1');
|
||||
if (at1 == '0') {
|
||||
at1 = '';
|
||||
}
|
||||
break;
|
||||
case 'FROM_END':
|
||||
var at1 = generator.getAdjustedInt(block, 'AT1', 0, true);
|
||||
break;
|
||||
case 'FIRST':
|
||||
var at1 = '0';
|
||||
break;
|
||||
default:
|
||||
throw 'Unhandled option (lists_getSublist)';
|
||||
}
|
||||
switch (where2) {
|
||||
case 'FROM_START':
|
||||
var at2 = generator.getAdjustedInt(block, 'AT2');
|
||||
break;
|
||||
case 'FROM_END':
|
||||
var at2 = generator.getAdjustedInt(block, 'AT2', 0, true);
|
||||
// Ensure that if the result calculated is 0 that sub-sequence will
|
||||
// include all elements as expected.
|
||||
if (!Blockly.isNumber(String(at2))) {
|
||||
generator.definitions_['import_sys'] = 'import sys';
|
||||
at2 += ' or sys.maxsize';
|
||||
} else if (at2 == '0') {
|
||||
at2 = '';
|
||||
}
|
||||
break;
|
||||
case 'LAST':
|
||||
var at2 = '-1';
|
||||
break;
|
||||
default:
|
||||
throw 'Unhandled option (lists_getSublist)';
|
||||
}
|
||||
var code = str + '[' + at1 + ' : ' + at2 + ']';
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const text_substring = function (_, generator) {
|
||||
// Get sublist.
|
||||
var str = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC) || '""';
|
||||
var at1 = generator.valueToCode(this, 'AT1', generator.ORDER_ATOMIC);
|
||||
var at2 = generator.valueToCode(this, 'AT2', generator.ORDER_ATOMIC);
|
||||
var code = str + '[' + at1 + ' : ' + at2 + ']';
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const text_capital = function (_, generator) {
|
||||
var capital = this.getFieldValue('CAPITAL');
|
||||
var str = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
|
||||
return ['' + str + '.' + capital + '()', generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const text_center = function (_, generator) {
|
||||
var center = this.getFieldValue('CENTER');
|
||||
var str = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
|
||||
var width = generator.valueToCode(this, 'WID', generator.ORDER_ATOMIC);
|
||||
var symbol = generator.valueToCode(this, 'Symbol', generator.ORDER_ATOMIC);
|
||||
return ['' + str + '.' + center + '(' + width + ',' + symbol + ')', generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const text_find = function (_, generator) {
|
||||
var sentence = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
|
||||
var str = generator.valueToCode(this, 'STR', generator.ORDER_ATOMIC);
|
||||
return ['' + sentence + '.find(' + str + ')', generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const text_join_seq = function (_, generator) {
|
||||
var sentence = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
|
||||
var varName = generator.valueToCode(this, 'LIST', generator.ORDER_ASSIGNMENT) || '0';
|
||||
return [sentence + '.join(' + varName + ')', generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const text_replace = function (_, generator) {
|
||||
var sentence = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
|
||||
var str1 = generator.valueToCode(this, 'STR1', generator.ORDER_ATOMIC);
|
||||
var str2 = generator.valueToCode(this, 'STR2', generator.ORDER_ATOMIC);
|
||||
return ['' + sentence + '.replace(' + str1 + ',' + str2 + ')', generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const text_split = function (_, generator) {
|
||||
var str = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC) || '""';
|
||||
var argument = generator.valueToCode(this, 'VAL', generator.ORDER_ATOMIC) || '""';
|
||||
var code = str + ".split(" + argument + ")";
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const text_strip = function (_, generator) {
|
||||
var towhat = this.getFieldValue('TOWHAT');
|
||||
var str = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
|
||||
var code = str + "." + towhat + "()";
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const text_format = function (_, generator) {
|
||||
// Create a list with any number of elements of any type.
|
||||
var s = this.getFieldValue('VAR');
|
||||
var code = new Array(this.itemCount_);
|
||||
var default_value = '0';
|
||||
for (var n = 0; n < this.itemCount_; n++) {
|
||||
|
||||
code[n] = generator.valueToCode(this, 'ADD' + n,
|
||||
generator.ORDER_NONE) || default_value;
|
||||
}
|
||||
var code = s + '.format(' + code.join(', ') + ')';
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const text_format_noreturn = function (_, generator) {
|
||||
// Create a list with any number of elements of any type.
|
||||
var s = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
|
||||
var code = new Array(this.itemCount_);
|
||||
var default_value = '0';
|
||||
for (var n = 0; n < this.itemCount_; n++) {
|
||||
|
||||
code[n] = generator.valueToCode(this, 'ADD' + n,
|
||||
generator.ORDER_NONE) || default_value;
|
||||
}
|
||||
var code = s + '.format(' + code.join(', ') + ')';
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const text_substring3 = text_substring
|
||||
export const text_compareTo = text_compare_to
|
||||
export const text_char_at3 = text_char_at
|
||||
|
||||
export const text_encode = function (_, generator) {
|
||||
var code = this.getFieldValue('DIR');
|
||||
var varName = this.getFieldValue('CODE')
|
||||
var str = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC) || '""';
|
||||
return [str + '.' + code + '("' + varName + '")', generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const text_eval = function (_, generator) {
|
||||
var codestr = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
|
||||
var code = "eval" + '(' + codestr + ')';
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const os_system = function (_, generator) {
|
||||
generator.definitions_['import_os'] = 'import os';
|
||||
var codestr = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC);
|
||||
var code = "os.system" + '(' + codestr + ')\n';
|
||||
return code;
|
||||
}
|
||||
292
boards/default_src/python/generators/tuple.js
Normal file
292
boards/default_src/python/generators/tuple.js
Normal file
@@ -0,0 +1,292 @@
|
||||
import * as Blockly from 'blockly/core';
|
||||
|
||||
export const tuple_create_with = function (_, generator) {
|
||||
// Create a list with any number of elements of any type.
|
||||
var varName = generator.variableDB_.getName(this.getFieldValue('VAR'),
|
||||
Blockly.Variables.NAME_TYPE);
|
||||
//var size=window.parseFloat(this.getFieldValue('SIZE'));
|
||||
var code = new Array(this.itemCount_);
|
||||
var default_value = '0';
|
||||
for (var n = 0; n < this.itemCount_; n++) {
|
||||
|
||||
code[n] = generator.valueToCode(this, 'ADD' + n,
|
||||
generator.ORDER_NONE) || default_value;
|
||||
}
|
||||
// if (this.itemCount_!=1){
|
||||
// generator.definitions_['var_declare'+varName] = varName+'= '+ '(' + code.join(', ') + ')\n';}
|
||||
// else {
|
||||
// generator.definitions_['var_declare'+varName] = varName+'= '+ '(' + code.join(', ') + ',)\n';}
|
||||
if (this.itemCount_ != 1) {
|
||||
var code = varName + '= ' + '(' + code.join(', ') + ')\n';
|
||||
}
|
||||
else {
|
||||
var code = varName + '= ' + '(' + code.join(', ') + ',)\n';
|
||||
}
|
||||
return code;
|
||||
}
|
||||
|
||||
export const tuple_create_with_text2 = function (_, generator) {
|
||||
var varName = generator.variableDB_.getName(this.getFieldValue('VAR'),
|
||||
Blockly.Variables.NAME_TYPE);
|
||||
//var size=window.parseFloat(this.getFieldValue('SIZE'));
|
||||
var text = this.getFieldValue('TEXT');
|
||||
//generator.definitions_['var_declare'+varName] = varName+'= '+ '(' + text + ')\n';
|
||||
var code = varName + '= ' + '(' + text + ')\n';
|
||||
return code;
|
||||
}
|
||||
|
||||
export const tuple_create_with_text_return = function (_, generator) {
|
||||
var text = this.getFieldValue('TEXT');
|
||||
var code = '(' + text + ')';
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const tuple_getIndex = function (_, generator) {
|
||||
// Indexing into a list is the same as indexing into a string.
|
||||
var varName = generator.valueToCode(this, 'TUP', generator.ORDER_ASSIGNMENT) || '0';
|
||||
var argument0 = generator.valueToCode(this, 'AT',
|
||||
generator.ORDER_ADDITIVE) || '1';
|
||||
if (argument0.match(/^\d+$/)) {
|
||||
// If the index is a naked number, decrement it right now.
|
||||
argument0 = parseInt(argument0, 10);
|
||||
}
|
||||
// else {
|
||||
// If the index is dynamic, decrement it in code.
|
||||
// argument0;
|
||||
// }
|
||||
var code = varName + '[' + argument0 + ']';
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const tuple_length = function (_, generator) {
|
||||
var varName = generator.valueToCode(this, 'TUP', generator.ORDER_ASSIGNMENT) || '0';
|
||||
var code = 'len(' + varName + ')';
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const tuple_del = function (_, generator) {
|
||||
var varName = generator.valueToCode(this, 'TUP', generator.ORDER_ASSIGNMENT) || '0';
|
||||
var code = 'del ' + varName + '\n';
|
||||
return code;
|
||||
}
|
||||
|
||||
export const tuple_join = function (_, generator) {
|
||||
var varName1 = generator.valueToCode(this, 'TUP1', generator.ORDER_ASSIGNMENT) || '0';
|
||||
var varName2 = generator.valueToCode(this, 'TUP2', generator.ORDER_ASSIGNMENT) || '0';
|
||||
var code = varName1 + " + " + varName2;
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const tuple_max = function (_, generator) {
|
||||
var varname = generator.valueToCode(this, 'TUP', generator.ORDER_ASSIGNMENT) || '0';
|
||||
var maxmin = this.getFieldValue('DIR');
|
||||
var code = maxmin + "(" + varname + ')';
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const tuple_change_to = function (_, generator) {
|
||||
var op = this.getFieldValue('OP');
|
||||
var varName = generator.valueToCode(this, 'VAR', generator.ORDER_ASSIGNMENT) || '0';
|
||||
var code = op + '(' + varName + ')\n';
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const tuple_find = function (_, generator) {
|
||||
var op = this.getFieldValue('OP');
|
||||
var varName = generator.valueToCode(this, 'VAR', generator.ORDER_ASSIGNMENT) || '0';
|
||||
var argument = generator.valueToCode(this, 'data', generator.ORDER_ASSIGNMENT) || '0';
|
||||
if (op == 'INDEX')
|
||||
var code = varName + '.index(' + argument + ')';
|
||||
else if (op == 'COUNT')
|
||||
var code = varName + '.count(' + argument + ')';
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const tuple_trig = function (a, generator) {
|
||||
var b = a.getFieldValue("OP"), c;
|
||||
generator.definitions_['import_math'] = "import math";
|
||||
a = generator.valueToCode(a, 'data', generator.ORDER_NONE)
|
||||
switch (b) {
|
||||
case "LEN":
|
||||
c = "len(" + a + ")";
|
||||
break;
|
||||
case "SUM":
|
||||
c = "sum(" + a + ")";
|
||||
break;
|
||||
case "MIN":
|
||||
c = "min(" + a + ")";
|
||||
break;
|
||||
case "MAX":
|
||||
c = "max(" + a + ")";
|
||||
break;
|
||||
case 'AVERAGE':
|
||||
// generator.definitions_['from_numbers_import_Number'] =
|
||||
// 'from numbers import Number';
|
||||
var functionName = generator.provideFunction_(
|
||||
'math_mean',
|
||||
// This operation excludes null and values that aren't int or float:',
|
||||
// math_mean([null, null, "aString", 1, 9]) == 5.0.',
|
||||
['def ' + generator.FUNCTION_NAME_PLACEHOLDER_ + '(myList):',
|
||||
' localList = [e for e in myList if type(e) == int or type(e) == float]',
|
||||
' if not localList: return',
|
||||
' return float(sum(localList)) / len(localList)']);
|
||||
c = functionName + '(' + a + ')';
|
||||
break;
|
||||
case 'MEDIAN':
|
||||
// generator.definitions_['from_numbers_import_Number'] =
|
||||
// 'from numbers import Numberd';
|
||||
var functionName = generator.provideFunction_(
|
||||
'math_median',
|
||||
// This operation excludes null values:
|
||||
// math_median([null, null, 1, 3]) == 2.0.
|
||||
['def ' + generator.FUNCTION_NAME_PLACEHOLDER_ + '(myList):',
|
||||
' localList = sorted([e for e in myList if type(e) == int or type(e) == float])',
|
||||
' if not localList: return',
|
||||
' if len(localList) % 2 == 0:',
|
||||
' return (localList[len(localList) // 2 - 1] + ' +
|
||||
'localList[len(localList) // 2]) / 2.0',
|
||||
' else:',
|
||||
' return localList[(len(localList) - 1) // 2]']);
|
||||
c = functionName + '(' + a + ')';
|
||||
break;
|
||||
case 'MODE':
|
||||
var functionName = generator.provideFunction_(
|
||||
'math_modes',
|
||||
// As a list of numbers can contain more than one mode,
|
||||
// the returned result is provided as an array.
|
||||
// Mode of [3, 'x', 'x', 1, 1, 2, '3'] -> ['x', 1].
|
||||
['def ' + generator.FUNCTION_NAME_PLACEHOLDER_ + '(some_list):',
|
||||
' modes = []',
|
||||
' # Using a lists of [item, count] to keep count rather than dict',
|
||||
' # to avoid "unhashable" errors when the counted item is ' +
|
||||
'itself a list or dict.',
|
||||
' counts = []',
|
||||
' maxCount = 1',
|
||||
' for item in some_list:',
|
||||
' found = False',
|
||||
' for count in counts:',
|
||||
' if count[0] == item:',
|
||||
' count[1] += 1',
|
||||
' maxCount = max(maxCount, count[1])',
|
||||
' found = True',
|
||||
' if not found:',
|
||||
' counts.append([item, 1])',
|
||||
' for counted_item, item_count in counts:',
|
||||
' if item_count == maxCount:',
|
||||
' modes.append(counted_item)',
|
||||
' return modes']);
|
||||
c = functionName + '(' + a + ')';
|
||||
break;
|
||||
case 'STD_DEV':
|
||||
generator.definitions_['import_math'] = 'import math';
|
||||
var functionName = generator.provideFunction_(
|
||||
'math_standard_deviation',
|
||||
['def ' + generator.FUNCTION_NAME_PLACEHOLDER_ + '(numbers):',
|
||||
' n = len(numbers)',
|
||||
' if n == 0: return',
|
||||
' mean = float(sum(numbers)) / n',
|
||||
' variance = sum((x - mean) ** 2 for x in numbers) / n',
|
||||
' return math.sqrt(variance)']);
|
||||
c = functionName + '(' + a + ')';
|
||||
break;
|
||||
default:
|
||||
throw 'Unknown operator: ' + b;
|
||||
}
|
||||
if (c)
|
||||
return [c, generator.ORDER_FUNCTION_CALL];
|
||||
|
||||
}
|
||||
|
||||
export const tuple_getSublist = function (block, generator) {
|
||||
// Get sublist.
|
||||
var list = generator.valueToCode(block, 'LIST',
|
||||
generator.ORDER_MEMBER) || '[]';
|
||||
var where1 = block.getFieldValue('WHERE1');
|
||||
var where2 = block.getFieldValue('WHERE2');
|
||||
switch (where1) {
|
||||
case 'FROM_START':
|
||||
var at1 = generator.getAdjustedInt(block, 'AT1');
|
||||
if (at1 == '0') {
|
||||
at1 = '';
|
||||
}
|
||||
break;
|
||||
case 'FROM_END':
|
||||
var at1 = generator.getAdjustedInt(block, 'AT1', 1, true);
|
||||
break;
|
||||
case 'FIRST':
|
||||
var at1 = '0';
|
||||
break;
|
||||
default:
|
||||
throw 'Unhandled option (lists_getSublist)';
|
||||
}
|
||||
switch (where2) {
|
||||
case 'FROM_START':
|
||||
var at2 = generator.getAdjustedInt(block, 'AT2', 1);
|
||||
at2 = at2 - 1;
|
||||
break;
|
||||
case 'FROM_END':
|
||||
var at2 = generator.getAdjustedInt(block, 'AT2', 1, true);
|
||||
// Ensure that if the result calculated is 0 that sub-sequence will
|
||||
// include all elements as expected.
|
||||
if (!Blockly.isNumber(String(at2))) {
|
||||
generator.definitions_['import_sys'] = 'import sys';
|
||||
at2 += ' or sys.maxsize';
|
||||
} else if (at2 == '0') {
|
||||
at2 = '';
|
||||
}
|
||||
break;
|
||||
case 'LAST':
|
||||
var at2 = '-1';
|
||||
break;
|
||||
default:
|
||||
throw 'Unhandled option (lists_getSublist)';
|
||||
}
|
||||
var code = list + '[' + at1 + ' : ' + at2 + ']';
|
||||
return [code, generator.ORDER_MEMBER];
|
||||
}
|
||||
|
||||
export const tuple_create_with_noreturn = function (_, generator) {
|
||||
// Create a list with any number of elements of any type.
|
||||
var code = new Array(this.itemCount_);
|
||||
var default_value = '0';
|
||||
|
||||
|
||||
for (var n = 0; n < this.itemCount_; n++) {
|
||||
|
||||
code[n] = generator.valueToCode(this, 'ADD' + n,
|
||||
generator.ORDER_NONE) || default_value;
|
||||
}
|
||||
// if (this.itemCount_!=1){
|
||||
// generator.definitions_['var_declare'+varName] = varName+'= '+ '(' + code.join(', ') + ')\n';}
|
||||
// else {
|
||||
// generator.definitions_['var_declare'+varName] = varName+'= '+ '(' + code.join(', ') + ',)\n';}
|
||||
if (this.itemCount_ != 1) {
|
||||
var code = '(' + code.join(', ') + ')';
|
||||
}
|
||||
else {
|
||||
var code = '(' + code.join(', ') + ',)';
|
||||
}
|
||||
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const tuple_get_sublist = function (_, generator) {
|
||||
// Get sublist.
|
||||
var list = generator.valueToCode(this, 'LIST', generator.ORDER_ADDITIVE) || '0';
|
||||
var at1 = generator.valueToCode(this, 'AT1', generator.ORDER_ADDITIVE) || '0';
|
||||
var at2 = generator.valueToCode(this, 'AT2', generator.ORDER_ADDITIVE) || '0';
|
||||
var code = list + '[' + at1 + ' : ' + at2 + ']';
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const tuple_get_random_item = function (_, generator) {
|
||||
generator.definitions_['import_random'] = 'import random';
|
||||
var varName = generator.valueToCode(this, 'TUP', generator.ORDER_ADDITIVE) || 'mytup';
|
||||
var code = 'random.choice(' + varName + ')';
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const tuple_totuple = function (_, generator) {
|
||||
var str = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC) || '0'
|
||||
return ['tuple(' + str + ')', generator.ORDER_ATOMIC];
|
||||
}
|
||||
78
boards/default_src/python/generators/utility.js
Normal file
78
boards/default_src/python/generators/utility.js
Normal file
@@ -0,0 +1,78 @@
|
||||
/**
|
||||
* @license
|
||||
* Visual Blocks Language
|
||||
*
|
||||
* Copyright 2012 Google Inc.
|
||||
* https://developers.google.com/blockly/
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
/**
|
||||
* @fileoverview Generating Python for utility blocks.
|
||||
* @author acbart@vt.edu (Austin Cory Bart)
|
||||
*/
|
||||
|
||||
export const raw_block = function (block) {
|
||||
var code = block.getFieldValue('TEXT') + "\n";
|
||||
return code;
|
||||
}
|
||||
|
||||
export const raw_expression = function (block, generator) {
|
||||
var code = block.getFieldValue('TEXT');
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const raw_empty = function (block, generator) {
|
||||
var code = generator.valueToCode(block, 'VALUE',
|
||||
generator.ORDER_ATOMIC) || '';
|
||||
return code + "\n";
|
||||
}
|
||||
|
||||
export const raw_table = function () {
|
||||
//var code = block.getFieldValue('TEXT')+"\n";
|
||||
return '';//code;
|
||||
}
|
||||
|
||||
export const type_check = function (block, generator) {
|
||||
var value = generator.valueToCode(block, 'VALUE',
|
||||
generator.ORDER_MEMBER) || '___';
|
||||
var code = 'type(' + value + ')';
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const function_call = function (block, generator) {
|
||||
var name = block.getFieldValue('NAME');
|
||||
var hasReturn = block.hasReturn_;
|
||||
var args = new Array(block.itemCount_);
|
||||
for (var n = 0; n < block.itemCount_; n++) {
|
||||
args[n] = generator.valueToCode(block, 'ARGUMENT' + n,
|
||||
generator.ORDER_NONE) || '___';
|
||||
}
|
||||
var code = name + '(' + args.join(', ') + ')';
|
||||
if (hasReturn) {
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
return code + '\n';
|
||||
}
|
||||
|
||||
export const attribute_access = function (block, generator) {
|
||||
var value_module = generator.valueToCode(block, 'MODULE', generator.ORDER_ATOMIC);
|
||||
var value_name = generator.valueToCode(block, 'NAME', generator.ORDER_ATOMIC);
|
||||
//去除掉两端的括号，如(val()) --> val()
|
||||
value_name = value_name.substring(1, value_name.length - 1);
|
||||
// TODO: Assemble JavaScript into code variable.
|
||||
var code = value_module + '.' + value_name;
|
||||
// TODO: Change ORDER_NONE to the correct strength.
|
||||
return [code, generator.ORDER_NONE];
|
||||
}
|
||||
72
boards/default_src/python/generators/variables.js
Normal file
72
boards/default_src/python/generators/variables.js
Normal file
@@ -0,0 +1,72 @@
|
||||
import * as Blockly from 'blockly/core';
|
||||
|
||||
export const variables_get = function (_, generator) {
|
||||
// Variable getter.
|
||||
var code = generator.variableDB_.getName(this.getFieldValue('VAR'),
|
||||
Blockly.Variables.NAME_TYPE);
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
// export const variables_declare = function() {
|
||||
// var dropdown_type = this.getFieldValue('TYPE');
|
||||
// var argument0;
|
||||
// //TODO: settype to variable
|
||||
// argument0 = generator.valueToCode(this, 'VALUE',generator.ORDER_ASSIGNMENT) || 'None';
|
||||
// var varName = generator.variableDB_.getName(this.getFieldValue('VAR'),
|
||||
// Blockly.Variables.NAME_TYPE);
|
||||
|
||||
// if (dropdown_type === 'number')
|
||||
// generator.definitions_['var_declare' + varName] = 'let ' + ' ' + varName + ' = 0;';
|
||||
// else if(dropdown_type === 'string')
|
||||
// generator.definitions_['var_declare' + varName] = 'let ' + ' ' + varName + ' = \'\';';
|
||||
// else if(dropdown_type === 'boolean')
|
||||
// generator.definitions_['var_declare' + varName] = 'let ' + ' ' + varName + ' = true;';
|
||||
// else if(dropdown_type.startsWith('Array'))
|
||||
// generator.definitions_['var_declare' + varName] = 'let ' + varName + ':' + dropdown_type + ' = [];';
|
||||
|
||||
// if(generator.setups_['var_declare' + varName] === undefined) {
|
||||
// generator.setups_['var_declare' + varName] = varName + ' = ' + argument0 + '\n';
|
||||
// }else {
|
||||
// }
|
||||
// return '';
|
||||
// }
|
||||
|
||||
export const variables_set = function (_, generator) {
|
||||
// Variable setter.
|
||||
if (this.getFieldValue('VAR') == "") {
|
||||
return " = None\n";
|
||||
}
|
||||
var argument0 = generator.valueToCode(this, 'VALUE',
|
||||
generator.ORDER_ASSIGNMENT) || 'None';
|
||||
var varName = generator.variableDB_.getName(this.getFieldValue('VAR'), Blockly.Variables.NAME_TYPE);
|
||||
return varName + ' = ' + argument0 + '\n';
|
||||
}
|
||||
|
||||
export const variables_change = function (_, generator) {
|
||||
// Variable setter.
|
||||
var operator = this.getFieldValue('OP');
|
||||
var varName = generator.valueToCode(this, 'MYVALUE', generator.ORDER_ATOMIC) || 'None';
|
||||
if (operator == 'bytes') { var code = operator + '(' + varName + ',"UTF-8")'; }
|
||||
else { var code = operator + '(' + varName + ')'; }
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const variables_global = function (_, generator) {
|
||||
var str = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC) || 'None';
|
||||
var code = "global " + str + '\n';
|
||||
return code;
|
||||
}
|
||||
|
||||
// ok
|
||||
export const controls_type = function (_, generator) {
|
||||
var data = generator.valueToCode(this, 'DATA', generator.ORDER_ATOMIC) || 'None'
|
||||
var code = 'type(' + data + ')';
|
||||
return [code, generator.ORDER_ATOMIC];
|
||||
}
|
||||
|
||||
export const controls_typeLists = function (_, generator) {
|
||||
//generator.definitions_['import_microbit_*'] = 'from microbit import *';
|
||||
var type = this.getFieldValue('type');
|
||||
// generator.definitions_['func_type' + type] = code;
|
||||
return [type, generator.ORDER_ATOMIC];
|
||||
}
|
||||
Reference in New Issue
Block a user