349 lines
13 KiB
JavaScript
349 lines
13 KiB
JavaScript
/*
|
||
Overrides for generic Python code generation.
|
||
*/
|
||
import * as Blockly from 'blockly/core';
|
||
import { Names } from '@mixly/python';
|
||
|
||
/**
|
||
* Python code generator.
|
||
* @type {!Blockly.Generator}
|
||
*/
|
||
export const Python = new Blockly.Generator('Python');
|
||
Python.INDENT = " ";
|
||
|
||
/**
|
||
* List of illegal variable names.
|
||
* This is not intended to be a security feature. Blockly is 100% client-side,
|
||
* so bypassing this list is trivial. This is intended to prevent users from
|
||
* accidentally clobbering a built-in object or function.
|
||
* @private
|
||
*/
|
||
Python.addReservedWords(
|
||
// import keyword
|
||
// print(','.join(sorted(keyword.kwlist)))
|
||
// https://docs.python.org/3/reference/lexical_analysis.html#keywords
|
||
// https://docs.python.org/2/reference/lexical_analysis.html#keywords
|
||
'False,None,True,and,as,assert,break,class,continue,def,del,elif,else,' +
|
||
'except,exec,finally,for,from,global,if,import,in,is,lambda,nonlocal,not,' +
|
||
'or,pass,print,raise,return,try,while,with,yield,' +
|
||
// https://docs.python.org/3/library/constants.html
|
||
// https://docs.python.org/2/library/constants.html
|
||
'NotImplemented,Ellipsis,__debug__,quit,exit,copyright,license,credits,' +
|
||
// >>> print(','.join(sorted(dir(__builtins__))))
|
||
// https://docs.python.org/3/library/functions.html
|
||
// https://docs.python.org/2/library/functions.html
|
||
'ArithmeticError,AssertionError,AttributeError,BaseException,' +
|
||
'BlockingIOError,BrokenPipeError,BufferError,BytesWarning,' +
|
||
'ChildProcessError,ConnectionAbortedError,ConnectionError,' +
|
||
'ConnectionRefusedError,ConnectionResetError,DeprecationWarning,EOFError,' +
|
||
'Ellipsis,EnvironmentError,Exception,FileExistsError,FileNotFoundError,' +
|
||
'FloatingPointError,FutureWarning,GeneratorExit,IOError,ImportError,' +
|
||
'ImportWarning,IndentationError,IndexError,InterruptedError,' +
|
||
'IsADirectoryError,KeyError,KeyboardInterrupt,LookupError,MemoryError,' +
|
||
'ModuleNotFoundError,NameError,NotADirectoryError,NotImplemented,' +
|
||
'NotImplementedError,OSError,OverflowError,PendingDeprecationWarning,' +
|
||
'PermissionError,ProcessLookupError,RecursionError,ReferenceError,' +
|
||
'ResourceWarning,RuntimeError,RuntimeWarning,StandardError,' +
|
||
'StopAsyncIteration,StopIteration,SyntaxError,SyntaxWarning,SystemError,' +
|
||
'SystemExit,TabError,TimeoutError,TypeError,UnboundLocalError,' +
|
||
'UnicodeDecodeError,UnicodeEncodeError,UnicodeError,' +
|
||
'UnicodeTranslateError,UnicodeWarning,UserWarning,ValueError,Warning,' +
|
||
'ZeroDivisionError,_,__build_class__,__debug__,__doc__,__import__,' +
|
||
'__loader__,__name__,__package__,__spec__,abs,all,any,apply,ascii,' +
|
||
'basestring,bin,bool,buffer,bytearray,bytes,callable,chr,classmethod,cmp,' +
|
||
'coerce,compile,complex,copyright,credits,delattr,dict,dir,divmod,' +
|
||
'enumerate,eval,exec,execfile,exit,file,filter,float,format,frozenset,' +
|
||
'getattr,globals,hasattr,hash,help,hex,id,input,int,intern,isinstance,' +
|
||
'issubclass,iter,len,license,list,locals,long,map,max,memoryview,min,' +
|
||
'next,object,oct,open,ord,pow,print,property,quit,range,raw_input,reduce,' +
|
||
'reload,repr,reversed,round,set,setattr,slice,sorted,staticmethod,str,' +
|
||
'sum,super,tuple,type,unichr,unicode,vars,xrange,zip'
|
||
);
|
||
|
||
/**
|
||
* Order of operation ENUMs.
|
||
* http://docs.python.org/reference/expressions.html#summary
|
||
*/
|
||
Python.ORDER_ATOMIC = 0; // 0 "" ...
|
||
Python.ORDER_COLLECTION = 1; // tuples, lists, dictionaries
|
||
Python.ORDER_STRING_CONVERSION = 1; // `expression...`
|
||
Python.ORDER_UNARY_POSTFIX = 1; // expr++ expr-- () [] .
|
||
Python.ORDER_UNARY_PREFIX = 2; // -expr !expr ~expr ++expr --expr
|
||
Python.ORDER_MEMBER = 2.1; // . []
|
||
Python.ORDER_FUNCTION_CALL = 2.2; // ()
|
||
Python.ORDER_EXPONENTIATION = 3; // **
|
||
Python.ORDER_UNARY_SIGN = 4; // + -
|
||
Python.ORDER_BITWISE_NOT = 4; // ~
|
||
Python.ORDER_MULTIPLICATIVE = 5; // * / // %
|
||
Python.ORDER_ADDITIVE = 6; // + -
|
||
Python.ORDER_BITWISE_SHIFT = 7; // << >>
|
||
Python.ORDER_BITWISE_AND = 8; // &
|
||
Python.ORDER_BITWISE_XOR = 9; // ^
|
||
Python.ORDER_BITWISE_OR = 10; // |
|
||
Python.ORDER_RELATIONAL = 11; // in, not in, is, is not,
|
||
// <, <=, >, >=, <>, !=, ==
|
||
Python.ORDER_EQUALITY = 11; // == != === !==
|
||
Python.ORDER_LOGICAL_NOT = 12; // not
|
||
Python.ORDER_LOGICAL_AND = 13; // and
|
||
Python.ORDER_LOGICAL_OR = 14; // or
|
||
Python.ORDER_ASSIGNMENT = 14; // = *= /= ~/= %= += -= <<= >>= &= ^= |=
|
||
Python.ORDER_CONDITIONAL = 15; // if else
|
||
Python.ORDER_LAMBDA = 16; // lambda
|
||
Python.ORDER_NONE = 99; // (...)
|
||
|
||
/**
|
||
* List of outer-inner pairings that do NOT require parentheses.
|
||
* @type {!Array.<!Array.<number>>}
|
||
*/
|
||
Python.ORDER_OVERRIDES = [
|
||
// (foo()).bar -> foo().bar
|
||
// (foo())[0] -> foo()[0]
|
||
[Python.ORDER_FUNCTION_CALL, Python.ORDER_MEMBER],
|
||
// (foo())() -> foo()()
|
||
[Python.ORDER_FUNCTION_CALL, Python.ORDER_FUNCTION_CALL],
|
||
// (foo.bar).baz -> foo.bar.baz
|
||
// (foo.bar)[0] -> foo.bar[0]
|
||
// (foo[0]).bar -> foo[0].bar
|
||
// (foo[0])[1] -> foo[0][1]
|
||
[Python.ORDER_MEMBER, Python.ORDER_MEMBER],
|
||
// (foo.bar)() -> foo.bar()
|
||
// (foo[0])() -> foo[0]()
|
||
[Python.ORDER_MEMBER, Python.ORDER_FUNCTION_CALL],
|
||
|
||
// not (not foo) -> not not foo
|
||
// [Python.ORDER_LOGICAL_NOT, Python.ORDER_LOGICAL_NOT],
|
||
// a and (b and c) -> a and b and c
|
||
// [Python.ORDER_LOGICAL_AND, Python.ORDER_LOGICAL_AND],
|
||
// a or (b or c) -> a or b or c
|
||
// [Python.ORDER_LOGICAL_OR, Python.ORDER_LOGICAL_OR]
|
||
];
|
||
|
||
Python.init = function () {
|
||
/**
|
||
* Empty loops or conditionals are not allowed in Python.
|
||
*/
|
||
Python.PASS = this.INDENT + 'pass\n';
|
||
// Create a dictionary of definitions to be printed before the code.
|
||
Python.definitions_ = Object.create(null);
|
||
// Create a dictionary mapping desired function names in definitions_
|
||
// to actual function names (to avoid collisions with user functions).
|
||
Python.functionNames_ = Object.create(null);
|
||
Python.setups_ = Object.create(null);
|
||
Python.loops_ = Object.create(null);
|
||
Python.codeEnd_ = Object.create(null);
|
||
|
||
if (!Python.variableDB_) {
|
||
Python.variableDB_ = new Names(Python.RESERVED_WORDS_);
|
||
} else {
|
||
Python.variableDB_.reset();
|
||
}
|
||
}
|
||
|
||
function optimizeShowCalls(code) {
|
||
// 正则说明：
|
||
// - 使用 /s 修饰符让 . 可以匹配换行符
|
||
// - 匹配所有 show() 调用（包括后面的换行符）
|
||
// - 但需要确保后续代码中还有 pixel 操作（说明不是最后一个 show()）
|
||
const regex = /onboard_tft\.show\(\)\s*\n(?=.*?onboard_tft\.[hline|vline|line|rect|fill_rect|ellipse|pixel])/gs;
|
||
|
||
// 替换所有中间 show() 调用为空字符串
|
||
return code.replace(regex, '');
|
||
}
|
||
|
||
|
||
Python.finish = function (code) {
|
||
// Convert the definitions dictionary into a list.
|
||
if (code !== "") {
|
||
code = code.replace(/\n/g, '\n');
|
||
code = code.replace(/\n\s+$/, '\n');
|
||
}
|
||
var imports = [];
|
||
var definitions_var = []; //变量定义
|
||
var definitions_fun = []; //函数定义
|
||
for (var name in this.definitions_) {
|
||
var def = this.definitions_[name];
|
||
if (name.indexOf('import') === 0) {
|
||
imports.push(def);
|
||
} else if (name.indexOf('var_declare') === 0) {
|
||
definitions_var.push(def);
|
||
} else {
|
||
definitions_fun.push(def);
|
||
}
|
||
}
|
||
if (imports.length) {
|
||
imports.push('\n\n');
|
||
}
|
||
if (definitions_var.length) {
|
||
definitions_var.push('\n\n');
|
||
}
|
||
if (definitions_fun.length) {
|
||
definitions_fun.push('\n\n');
|
||
}
|
||
var functions = [];
|
||
for (var name in Python.functions_) {
|
||
functions.push(Python.functions_[name]);
|
||
}
|
||
if (functions.length) {
|
||
functions.push('\n\n');
|
||
}
|
||
var setups = [];
|
||
for (var name in Python.setups_) {
|
||
setups.push(Python.setups_[name]);
|
||
}
|
||
if (setups.length) {
|
||
setups.push('\n\n');
|
||
}
|
||
var loops = [];
|
||
for (var name in Python.loops_) {
|
||
loops.push(Python.loops_[name]);
|
||
}
|
||
var codeEnd = [];
|
||
for (var name in Python.codeEnd_) {
|
||
codeEnd.push(Python.codeEnd_[name]);
|
||
}
|
||
if (codeEnd.length !== 0) {
|
||
codeEnd.push('\n');
|
||
}
|
||
let text = '';
|
||
if (loops.length > 0) {
|
||
text = imports.join('\n') + definitions_var.join('\n') + definitions_fun.join('\n')
|
||
+ functions.join('\n') + setups.join('') + code + 'while True:\n' + loops.join('') + codeEnd.join('\n');
|
||
} else {
|
||
text = imports.join('\n') + definitions_var.join('\n') + definitions_fun.join('\n')
|
||
+ functions.join('\n') + setups.join('') + code + codeEnd.join('\n');
|
||
}
|
||
try {
|
||
text = optimizeShowCalls(text);
|
||
} catch (error) {
|
||
console.log(error);
|
||
}
|
||
return text;
|
||
}
|
||
|
||
|
||
/**
|
||
* Naked values are top-level blocks with outputs that aren't plugged into
|
||
* anything.
|
||
* @param {string} line Line of generated code.
|
||
* @return {string} Legal line of code.
|
||
*/
|
||
Python.scrubNakedValue = function (line) {
|
||
return line + '\n';
|
||
}
|
||
|
||
/**
|
||
* Encode a string as a properly escaped Python string, complete with quotes.
|
||
* @param {string} string Text to encode.
|
||
* @return {string} Python string.
|
||
* @private
|
||
*/
|
||
Python.quote_ = function (string) {
|
||
// Can't use goog.string.quote since % must also be escaped.
|
||
string = string.replace(/\\/g, '\\\\')
|
||
.replace(/\n/g, '\\\n');
|
||
|
||
// Follow the CPython behaviour of repr() for a non-byte string.
|
||
var quote = '\'';
|
||
if (string.indexOf('\'') !== -1) {
|
||
if (string.indexOf('"') === -1) {
|
||
quote = '"';
|
||
} else {
|
||
string = string.replace(/'/g, '\\\'');
|
||
}
|
||
}
|
||
return quote + string + quote;
|
||
}
|
||
|
||
/**
|
||
* Encode a string as a properly escaped multiline Python string, complete
|
||
* with quotes.
|
||
* @param {string} string Text to encode.
|
||
* @return {string} Python string.
|
||
* @private
|
||
*/
|
||
Python.multiline_quote_ = function (string) {
|
||
// Can't use goog.string.quote since % must also be escaped.
|
||
string = string.replace(/'''/g, '\\\'\\\'\\\'');
|
||
return '\'\'\'' + string + '\'\'\'';
|
||
}
|
||
|
||
/**
|
||
* Common tasks for generating Python from blocks.
|
||
* Handles comments for the specified block and any connected value blocks.
|
||
* Calls any statements following this block.
|
||
* @param {!Blockly.Block} block The current block.
|
||
* @param {string} code The Python code created for this block.
|
||
* @param {boolean=} opt_thisOnly True to generate code for only this statement.
|
||
* @return {string} Python code with comments and subsequent blocks added.
|
||
* @private
|
||
*/
|
||
Python.scrub_ = function (block, code, opt_thisOnly) {
|
||
var commentCode = '';
|
||
// Only collect comments for blocks that aren't inline.
|
||
if (!block.outputConnection || !block.outputConnection.targetConnection) {
|
||
// Collect comment for this block.
|
||
var comment = block.getCommentText();
|
||
if (comment) {
|
||
comment = Blockly.utils.string.wrap(comment,
|
||
Python.COMMENT_WRAP - 3);
|
||
commentCode += Python.prefixLines(comment + '\n', '# ');
|
||
}
|
||
// Collect comments for all value arguments.
|
||
// Don't collect comments for nested statements.
|
||
for (var i = 0; i < block.inputList.length; i++) {
|
||
if (block.inputList[i].type == Blockly.INPUT_VALUE) {
|
||
var childBlock = block.inputList[i].connection.targetBlock();
|
||
if (childBlock) {
|
||
var comment = Python.allNestedComments(childBlock);
|
||
if (comment) {
|
||
commentCode += Python.prefixLines(comment, '# ');
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
var nextBlock = block.nextConnection && block.nextConnection.targetBlock();
|
||
var nextCode = opt_thisOnly ? '' : Python.blockToCode(nextBlock);
|
||
return commentCode + code + nextCode;
|
||
}
|
||
|
||
/**
|
||
* Gets a property and adjusts the value, taking into account indexing, and
|
||
* casts to an integer.
|
||
* @param {!Blockly.Block} block The block.
|
||
* @param {string} atId The property ID of the element to get.
|
||
* @param {number=} opt_delta Value to add.
|
||
* @param {boolean=} opt_negate Whether to negate the value.
|
||
* @return {string|number}
|
||
*/
|
||
Python.getAdjustedInt = function (block, atId, opt_delta, opt_negate) {
|
||
var delta = opt_delta || 0;
|
||
if (block.workspace.options.oneBasedIndex) {
|
||
delta--;
|
||
}
|
||
var defaultAtIndex = block.workspace.options.oneBasedIndex ? '1' : '0';
|
||
var atOrder = delta ? Python.ORDER_ADDITIVE :
|
||
Python.ORDER_NONE;
|
||
var at = Python.valueToCode(block, atId, atOrder) || defaultAtIndex;
|
||
|
||
if (Blockly.isNumber(at)) {
|
||
// If the index is a naked number, adjust it right now.
|
||
at = parseInt(at, 10) + delta;
|
||
if (opt_negate) {
|
||
at = -at;
|
||
}
|
||
} else {
|
||
// If the index is dynamic, adjust it in code.
|
||
if (delta > 0) {
|
||
at = 'int(' + at + ' + ' + delta + ')';
|
||
} else if (delta < 0) {
|
||
at = 'int(' + at + ' - ' + -delta + ')';
|
||
} else {
|
||
at = 'int(' + at + ')';
|
||
}
|
||
if (opt_negate) {
|
||
at = '-' + at;
|
||
}
|
||
}
|
||
return at;
|
||
} |