CodingPirates/blockly
1
0
Fork 0
mirror of https://github.com/google/blockly.git synced 2026-01-07 17:10:11 +01:00
Code Issues Packages Projects Releases Wiki Activity

refactor(generators): Introduce JavascriptGenerator class, Order enum (#7153)

Browse Source 
* refactor(generators): Introduce class JavascriptGenerator

  Also fix an import ordering error.

* refactor(generators): Use Order.* instead of .ORDER_*

* refactor(generators): Don't rename javascriptGenerator
This commit is contained in:
Christopher Allen
2023-06-13 21:30:37 +01:00
committed by GitHub
parent 3e9d892934
commit 306eb80216
10 changed files with 770 additions and 713 deletions
Download Patch File Download Diff File Expand all files Collapse all files

560
generators/javascript.js
View File

@@ -16,305 +16,319 @@ import * as Variables from '../core/variables.js';
import * as stringUtils from '../core/utils/string.js'; import * as stringUtils from '../core/utils/string.js';
// import type {Block} from '../core/block.js'; // import type {Block} from '../core/block.js';
import {CodeGenerator} from '../core/generator.js'; import {CodeGenerator} from '../core/generator.js';
import {inputTypes} from '../core/inputs/input_types.js';
import {Names, NameType} from '../core/names.js'; import {Names, NameType} from '../core/names.js';
// import type {Workspace} from '../core/workspace.js'; // import type {Workspace} from '../core/workspace.js';
import {inputTypes} from '../core/inputs/input_types.js';
/**
* JavaScript code generator.
* @type {!CodeGenerator}
*/
const JavaScript = new CodeGenerator('JavaScript');
/**
* 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.
*/
JavaScript.addReservedWords(
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Lexical_grammar#Keywords
'break,case,catch,class,const,continue,debugger,default,delete,do,else,export,extends,finally,for,function,if,import,in,instanceof,new,return,super,switch,this,throw,try,typeof,var,void,while,with,yield,' +
'enum,' +
'implements,interface,let,package,private,protected,public,static,' +
'await,' +
'null,true,false,' +
// Magic variable.
'arguments,' +
// Everything in the current environment (835 items in Chrome, 104 in Node).
Object.getOwnPropertyNames(globalThis).join(','));
/** /**
* Order of operation ENUMs. * Order of operation ENUMs.
* https://developer.mozilla.org/en/JavaScript/Reference/Operators/Operator_Precedence * https://developer.mozilla.org/en/JavaScript/Reference/Operators/Operator_Precedence
* @enum {number}
*/ */
JavaScript.ORDER_ATOMIC = 0; // 0 "" ... export const Order = {
JavaScript.ORDER_NEW = 1.1; // new ATOMIC: 0, // 0 "" ...
JavaScript.ORDER_MEMBER = 1.2; // . [] NEW: 1.1, // new
JavaScript.ORDER_FUNCTION_CALL = 2; // () MEMBER: 1.2, // . []
JavaScript.ORDER_INCREMENT = 3; // ++ FUNCTION_CALL: 2, // ()
JavaScript.ORDER_DECREMENT = 3; // -- INCREMENT: 3, // ++
JavaScript.ORDER_BITWISE_NOT = 4.1; // ~ DECREMENT: 3, // --
JavaScript.ORDER_UNARY_PLUS = 4.2; // + BITWISE_NOT: 4.1, // ~
JavaScript.ORDER_UNARY_NEGATION = 4.3; // - UNARY_PLUS: 4.2, // +
JavaScript.ORDER_LOGICAL_NOT = 4.4; // ! UNARY_NEGATION: 4.3, // -
JavaScript.ORDER_TYPEOF = 4.5; // typeof LOGICAL_NOT: 4.4, // !
JavaScript.ORDER_VOID = 4.6; // void TYPEOF: 4.5, // typeof
JavaScript.ORDER_DELETE = 4.7; // delete VOID: 4.6, // void
JavaScript.ORDER_AWAIT = 4.8; // await DELETE: 4.7, // delete
JavaScript.ORDER_EXPONENTIATION = 5.0; // ** AWAIT: 4.8, // await
JavaScript.ORDER_MULTIPLICATION = 5.1; // * EXPONENTIATION: 5.0, // **
JavaScript.ORDER_DIVISION = 5.2; // / MULTIPLICATION: 5.1, // *
JavaScript.ORDER_MODULUS = 5.3; // % DIVISION: 5.2, // /
JavaScript.ORDER_SUBTRACTION = 6.1; // - MODULUS: 5.3, // %
JavaScript.ORDER_ADDITION = 6.2; // + SUBTRACTION: 6.1, // -
JavaScript.ORDER_BITWISE_SHIFT = 7; // << >> >>> ADDITION: 6.2, // +
JavaScript.ORDER_RELATIONAL = 8; // < <= > >= BITWISE_SHIFT: 7, // << >> >>>
JavaScript.ORDER_IN = 8; // in RELATIONAL: 8, // < <= > >=
JavaScript.ORDER_INSTANCEOF = 8; // instanceof IN: 8, // in
JavaScript.ORDER_EQUALITY = 9; // == != === !== INSTANCEOF: 8, // instanceof
JavaScript.ORDER_BITWISE_AND = 10; // & EQUALITY: 9, // == != === !==
JavaScript.ORDER_BITWISE_XOR = 11; // ^ BITWISE_AND: 10, // &
JavaScript.ORDER_BITWISE_OR = 12; // | BITWISE_XOR: 11, // ^
JavaScript.ORDER_LOGICAL_AND = 13; // && BITWISE_OR: 12, // |
JavaScript.ORDER_LOGICAL_OR = 14; // || LOGICAL_AND: 13, // &&
JavaScript.ORDER_CONDITIONAL = 15; // ?: LOGICAL_OR: 14, // ||
JavaScript.ORDER_ASSIGNMENT = 16; // = += -= **= *= /= %= <<= >>= ... CONDITIONAL: 15, // ?:
JavaScript.ORDER_YIELD = 17; // yield ASSIGNMENT: 16, //: += -= **= *= /= %= <<= >>= ...
JavaScript.ORDER_COMMA = 18; // , YIELD: 17, // yield
JavaScript.ORDER_NONE = 99; // (...) COMMA: 18, // ,
NONE: 99, // (...)
/**
* List of outer-inner pairings that do NOT require parentheses.
* @type {!Array<!Array<number>>}
*/
JavaScript.ORDER_OVERRIDES = [
// (foo()).bar -> foo().bar
// (foo())[0] -> foo()[0]
[JavaScript.ORDER_FUNCTION_CALL, JavaScript.ORDER_MEMBER],
// (foo())() -> foo()()
[JavaScript.ORDER_FUNCTION_CALL, JavaScript.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]
[JavaScript.ORDER_MEMBER, JavaScript.ORDER_MEMBER],
// (foo.bar)() -> foo.bar()
// (foo[0])() -> foo[0]()
[JavaScript.ORDER_MEMBER, JavaScript.ORDER_FUNCTION_CALL],
// !(!foo) -> !!foo
[JavaScript.ORDER_LOGICAL_NOT, JavaScript.ORDER_LOGICAL_NOT],
// a * (b * c) -> a * b * c
[JavaScript.ORDER_MULTIPLICATION, JavaScript.ORDER_MULTIPLICATION],
// a + (b + c) -> a + b + c
[JavaScript.ORDER_ADDITION, JavaScript.ORDER_ADDITION],
// a && (b && c) -> a && b && c
[JavaScript.ORDER_LOGICAL_AND, JavaScript.ORDER_LOGICAL_AND],
// a || (b || c) -> a || b || c
[JavaScript.ORDER_LOGICAL_OR, JavaScript.ORDER_LOGICAL_OR]
];
/**
* Whether the init method has been called.
* @type {?boolean}
*/
JavaScript.isInitialized = false;
/**
* Initialise the database of variable names.
* @param {!Workspace} workspace Workspace to generate code from.
*/
JavaScript.init = function(workspace) {
// Call Blockly.CodeGenerator's init.
Object.getPrototypeOf(this).init.call(this);
if (!this.nameDB_) {
this.nameDB_ = new Names(this.RESERVED_WORDS_);
} else {
this.nameDB_.reset();
}
this.nameDB_.setVariableMap(workspace.getVariableMap());
this.nameDB_.populateVariables(workspace);
this.nameDB_.populateProcedures(workspace);
const defvars = [];
// Add developer variables (not created or named by the user).
const devVarList = Variables.allDeveloperVariables(workspace);
for (let i = 0; i < devVarList.length; i++) {
defvars.push(
this.nameDB_.getName(devVarList[i], NameType.DEVELOPER_VARIABLE));
}
// Add user variables, but only ones that are being used.
const variables = Variables.allUsedVarModels(workspace);
for (let i = 0; i < variables.length; i++) {
defvars.push(this.nameDB_.getName(variables[i].getId(), NameType.VARIABLE));
}
// Declare all of the variables.
if (defvars.length) {
this.definitions_['variables'] = 'var ' + defvars.join(', ') + ';';
}
this.isInitialized = true;
}; };
/** /**
* Prepend the generated code with the variable definitions. * JavaScript code generator class.
* @param {string} code Generated code.
* @return {string} Completed code.
*/ */
JavaScript.finish = function(code) { export class JavascriptGenerator extends CodeGenerator {
// Convert the definitions dictionary into a list. /**
const definitions = Object.values(this.definitions_); * List of outer-inner pairings that do NOT require parentheses.
// Call Blockly.CodeGenerator's finish. * @type {!Array<!Array<number>>}
code = Object.getPrototypeOf(this).finish.call(this, code); */
this.isInitialized = false; ORDER_OVERRIDES = [
// (foo()).bar -> foo().bar
// (foo())[0] -> foo()[0]
[Order.FUNCTION_CALL, Order.MEMBER],
// (foo())() -> foo()()
[Order.FUNCTION_CALL, 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]
[Order.MEMBER, Order.MEMBER],
// (foo.bar)() -> foo.bar()
// (foo[0])() -> foo[0]()
[Order.MEMBER, Order.FUNCTION_CALL],
this.nameDB_.reset(); // !(!foo) -> !!foo
return definitions.join('\n\n') + '\n\n\n' + code; [Order.LOGICAL_NOT, Order.LOGICAL_NOT],
}; // a * (b * c) -> a * b * c
[Order.MULTIPLICATION, Order.MULTIPLICATION],
// a + (b + c) -> a + b + c
[Order.ADDITION, Order.ADDITION],
// a && (b && c) -> a && b && c
[Order.LOGICAL_AND, Order.LOGICAL_AND],
// a || (b || c) -> a || b || c
[Order.LOGICAL_OR, Order.LOGICAL_OR]
];
/** constructor(name) {
* Naked values are top-level blocks with outputs that aren't plugged into super(name ?? 'JavaScript');
* anything. A trailing semicolon is needed to make this legal. this.isInitialized = false;
* @param {string} line Line of generated code.
* @return {string} Legal line of code.
*/
JavaScript.scrubNakedValue = function(line) {
return line + ';\n';
};
/** // Copy Order values onto instance for backwards compatibility
* Encode a string as a properly escaped JavaScript string, complete with // while ensuring they are not part of the publically- -advertised
* quotes. // API.
* @param {string} string Text to encode. for (const key in Order) {
* @return {string} JavaScript string. this['ORDER_' + key] = Order[key];
* @protected
*/
JavaScript.quote_ = function(string) {
// Can't use goog.string.quote since Google's style guide recommends
// JS string literals use single quotes.
string = string.replace(/\\/g, '\\\\')
.replace(/\n/g, '\\\n')
.replace(/'/g, '\\\'');
return '\'' + string + '\'';
};
/**
* Encode a string as a properly escaped multiline JavaScript string, complete
* with quotes.
* @param {string} string Text to encode.
* @return {string} JavaScript string.
* @protected
*/
JavaScript.multiline_quote_ = function(string) {
// Can't use goog.string.quote since Google's style guide recommends
// JS string literals use single quotes.
const lines = string.split(/\n/g).map(this.quote_);
return lines.join(' + \'\\n\' +\n');
};
/**
* Common tasks for generating JavaScript from blocks.
* Handles comments for the specified block and any connected value blocks.
* Calls any statements following this block.
* @param {!Block} block The current block.
* @param {string} code The JavaScript code created for this block.
* @param {boolean=} opt_thisOnly True to generate code for only this statement.
* @return {string} JavaScript code with comments and subsequent blocks added.
* @protected
*/
JavaScript.scrub_ = function(block, code, opt_thisOnly) {
let commentCode = '';
// Only collect comments for blocks that aren't inline.
if (!block.outputConnection || !block.outputConnection.targetConnection) {
// Collect comment for this block.
let comment = block.getCommentText();
if (comment) {
comment = stringUtils.wrap(comment, this.COMMENT_WRAP - 3);
commentCode += this.prefixLines(comment + '\n', '// ');
} }
// Collect comments for all value arguments.
// Don't collect comments for nested statements. // List of illegal variable names. This is not intended to be a
for (let i = 0; i < block.inputList.length; i++) { // security feature. Blockly is 100% client-side, so bypassing
if (block.inputList[i].type === inputTypes.VALUE) { // this list is trivial. This is intended to prevent users from
const childBlock = block.inputList[i].connection.targetBlock(); // accidentally clobbering a built-in object or function.
if (childBlock) { this.addReservedWords(
comment = this.allNestedComments(childBlock); // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Lexical_grammar#Keywords
if (comment) { 'break,case,catch,class,const,continue,debugger,default,delete,do,' +
commentCode += this.prefixLines(comment, '// '); 'else,export,extends,finally,for,function,if,import,in,instanceof,' +
'new,return,super,switch,this,throw,try,typeof,var,void,' +
'while,with,yield,' +
'enum,' +
'implements,interface,let,package,private,protected,public,static,' +
'await,' +
'null,true,false,' +
// Magic variable.
'arguments,' +
// Everything in the current environment (835 items in Chrome,
// 104 in Node).
Object.getOwnPropertyNames(globalThis).join(',')
);
}
/**
* Initialise the database of variable names.
* @param {!Workspace} workspace Workspace to generate code from.
*/
init(workspace) {
super.init(workspace);
if (!this.nameDB_) {
this.nameDB_ = new Names(this.RESERVED_WORDS_);
} else {
this.nameDB_.reset();
}
this.nameDB_.setVariableMap(workspace.getVariableMap());
this.nameDB_.populateVariables(workspace);
this.nameDB_.populateProcedures(workspace);
const defvars = [];
// Add developer variables (not created or named by the user).
const devVarList = Variables.allDeveloperVariables(workspace);
for (let i = 0; i < devVarList.length; i++) {
defvars.push(
this.nameDB_.getName(devVarList[i], NameType.DEVELOPER_VARIABLE));
}
// Add user variables, but only ones that are being used.
const variables = Variables.allUsedVarModels(workspace);
for (let i = 0; i < variables.length; i++) {
defvars.push(this.nameDB_.getName(variables[i].getId(), NameType.VARIABLE));
}
// Declare all of the variables.
if (defvars.length) {
this.definitions_['variables'] = 'var ' + defvars.join(', ') + ';';
}
this.isInitialized = true;
}
/**
* Prepend the generated code with the variable definitions.
* @param {string} code Generated code.
* @return {string} Completed code.
*/
finish(code) {
// Convert the definitions dictionary into a list.
const definitions = Object.values(this.definitions_);
// Call Blockly.CodeGenerator's finish.
super.finish(code);
this.isInitialized = false;
this.nameDB_.reset();
return definitions.join('\n\n') + '\n\n\n' + code;
}
/**
* Naked values are top-level blocks with outputs that aren't plugged into
* anything. A trailing semicolon is needed to make this legal.
* @param {string} line Line of generated code.
* @return {string} Legal line of code.
*/
scrubNakedValue(line) {
return line + ';\n';
}
/**
* Encode a string as a properly escaped JavaScript string, complete with
* quotes.
* @param {string} string Text to encode.
* @return {string} JavaScript string.
* @protected
*/
quote_(string) {
// Can't use goog.string.quote since Google's style guide recommends
// JS string literals use single quotes.
string = string.replace(/\\/g, '\\\\')
.replace(/\n/g, '\\\n')
.replace(/'/g, '\\\'');
return '\'' + string + '\'';
}
/**
* Encode a string as a properly escaped multiline JavaScript string, complete
* with quotes.
* @param {string} string Text to encode.
* @return {string} JavaScript string.
* @protected
*/
multiline_quote_(string) {
// Can't use goog.string.quote since Google's style guide recommends
// JS string literals use single quotes.
const lines = string.split(/\n/g).map(this.quote_);
return lines.join(' + \'\\n\' +\n');
}
/**
* Common tasks for generating JavaScript from blocks.
* Handles comments for the specified block and any connected value blocks.
* Calls any statements following this block.
* @param {!Block} block The current block.
* @param {string} code The JavaScript code created for this block.
* @param {boolean=} opt_thisOnly True to generate code for only this statement.
* @return {string} JavaScript code with comments and subsequent blocks added.
* @protected
*/
scrub_(block, code, opt_thisOnly) {
let commentCode = '';
// Only collect comments for blocks that aren't inline.
if (!block.outputConnection || !block.outputConnection.targetConnection) {
// Collect comment for this block.
let comment = block.getCommentText();
if (comment) {
comment = stringUtils.wrap(comment, this.COMMENT_WRAP - 3);
commentCode += this.prefixLines(comment + '\n', '// ');
}
// Collect comments for all value arguments.
// Don't collect comments for nested statements.
for (let i = 0; i < block.inputList.length; i++) {
if (block.inputList[i].type === inputTypes.VALUE) {
const childBlock = block.inputList[i].connection.targetBlock();
if (childBlock) {
comment = this.allNestedComments(childBlock);
if (comment) {
commentCode += this.prefixLines(comment, '// ');
}
} }
} }
} }
} }
} const nextBlock = block.nextConnection && block.nextConnection.targetBlock();
const nextBlock = block.nextConnection && block.nextConnection.targetBlock(); const nextCode = opt_thisOnly ? '' : this.blockToCode(nextBlock);
const nextCode = opt_thisOnly ? '' : this.blockToCode(nextBlock); return commentCode + code + nextCode;
return commentCode + code + nextCode;
};
/**
* Gets a property and adjusts the value while taking into account indexing.
* @param {!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.
* @param {number=} opt_order The highest order acting on this value.
* @return {string|number}
*/
JavaScript.getAdjusted = function(
block, atId, opt_delta, opt_negate, opt_order) {
let delta = opt_delta || 0;
let order = opt_order || this.ORDER_NONE;
if (block.workspace.options.oneBasedIndex) {
delta--;
}
const defaultAtIndex = block.workspace.options.oneBasedIndex ? '1' : '0';
let innerOrder;
let outerOrder = order;
if (delta > 0) {
outerOrder = this.ORDER_ADDITION;
innerOrder = this.ORDER_ADDITION;
} else if (delta < 0) {
outerOrder = this.ORDER_SUBTRACTION;
innerOrder = this.ORDER_SUBTRACTION;
} else if (opt_negate) {
outerOrder = this.ORDER_UNARY_NEGATION;
innerOrder = this.ORDER_UNARY_NEGATION;
} }
let at = this.valueToCode(block, atId, outerOrder) || defaultAtIndex; /**
* Gets a property and adjusts the value while taking into account indexing.
if (stringUtils.isNumber(at)) { * @param {!Block} block The block.
// If the index is a naked number, adjust it right now. * @param {string} atId The property ID of the element to get.
at = Number(at) + delta; * @param {number=} opt_delta Value to add.
if (opt_negate) { * @param {boolean=} opt_negate Whether to negate the value.
at = -at; * @param {number=} opt_order The highest order acting on this value.
* @return {string|number}
*/
getAdjusted(block, atId, opt_delta, opt_negate, opt_order) {
let delta = opt_delta || 0;
let order = opt_order || this.ORDER_NONE;
if (block.workspace.options.oneBasedIndex) {
delta--;
} }
} else { const defaultAtIndex = block.workspace.options.oneBasedIndex ? '1' : '0';
// If the index is dynamic, adjust it in code.
let innerOrder;
let outerOrder = order;
if (delta > 0) { if (delta > 0) {
at = at + ' + ' + delta; outerOrder = this.ORDER_ADDITION;
innerOrder = this.ORDER_ADDITION;
} else if (delta < 0) { } else if (delta < 0) {
at = at + ' - ' + -delta; outerOrder = this.ORDER_SUBTRACTION;
innerOrder = this.ORDER_SUBTRACTION;
} else if (opt_negate) {
outerOrder = this.ORDER_UNARY_NEGATION;
innerOrder = this.ORDER_UNARY_NEGATION;
} }
if (opt_negate) {
if (delta) { let at = this.valueToCode(block, atId, outerOrder) || defaultAtIndex;
at = '-(' + at + ')';
} else { if (stringUtils.isNumber(at)) {
at = '-' + at; // If the index is a naked number, adjust it right now.
at = Number(at) + delta;
if (opt_negate) {
at = -at;
}
} else {
// If the index is dynamic, adjust it in code.
if (delta > 0) {
at = at + ' + ' + delta;
} else if (delta < 0) {
at = at + ' - ' + -delta;
}
if (opt_negate) {
if (delta) {
at = '-(' + at + ')';
} else {
at = '-' + at;
}
}
innerOrder = Math.floor(innerOrder);
order = Math.floor(order);
if (innerOrder && order >= innerOrder) {
at = '(' + at + ')';
} }
} }
innerOrder = Math.floor(innerOrder); return at;
order = Math.floor(order);
if (innerOrder && order >= innerOrder) {
at = '(' + at + ')';
}
} }
return at; }
};
export {JavaScript as javascriptGenerator}; /**
* JavaScript code generator instance.
* @type {!JavascriptGenerator}
*/
export const javascriptGenerator = new JavascriptGenerator();

44
generators/javascript/colour.js
View File

@@ -11,36 +11,36 @@
import * as goog from '../../closure/goog/goog.js'; import * as goog from '../../closure/goog/goog.js';
goog.declareModuleId('Blockly.JavaScript.colour'); goog.declareModuleId('Blockly.JavaScript.colour');
import {javascriptGenerator as JavaScript} from '../javascript.js'; import {Order, javascriptGenerator} from '../javascript.js';
JavaScript.forBlock['colour_picker'] = function(block) { javascriptGenerator.forBlock['colour_picker'] = function(block) {
// Colour picker. // Colour picker.
const code = JavaScript.quote_(block.getFieldValue('COLOUR')); const code = javascriptGenerator.quote_(block.getFieldValue('COLOUR'));
return [code, JavaScript.ORDER_ATOMIC]; return [code, Order.ATOMIC];
}; };
JavaScript.forBlock['colour_random'] = function(block) { javascriptGenerator.forBlock['colour_random'] = function(block) {
// Generate a random colour. // Generate a random colour.
const functionName = JavaScript.provideFunction_('colourRandom', ` const functionName = javascriptGenerator.provideFunction_('colourRandom', `
function ${JavaScript.FUNCTION_NAME_PLACEHOLDER_}() { function ${javascriptGenerator.FUNCTION_NAME_PLACEHOLDER_}() {
var num = Math.floor(Math.random() * Math.pow(2, 24)); var num = Math.floor(Math.random() * Math.pow(2, 24));
return '#' + ('00000' + num.toString(16)).substr(-6); return '#' + ('00000' + num.toString(16)).substr(-6);
} }
`); `);
const code = functionName + '()'; const code = functionName + '()';
return [code, JavaScript.ORDER_FUNCTION_CALL]; return [code, Order.FUNCTION_CALL];
}; };
JavaScript.forBlock['colour_rgb'] = function(block) { javascriptGenerator.forBlock['colour_rgb'] = function(block) {
// Compose a colour from RGB components expressed as percentages. // Compose a colour from RGB components expressed as percentages.
const red = JavaScript.valueToCode(block, 'RED', JavaScript.ORDER_NONE) || 0; const red = javascriptGenerator.valueToCode(block, 'RED', Order.NONE) || 0;
const green = const green =
JavaScript.valueToCode(block, 'GREEN', JavaScript.ORDER_NONE) || 0; javascriptGenerator.valueToCode(block, 'GREEN', Order.NONE) || 0;
const blue = const blue =
JavaScript.valueToCode(block, 'BLUE', JavaScript.ORDER_NONE) || 0; javascriptGenerator.valueToCode(block, 'BLUE', Order.NONE) || 0;
const functionName = JavaScript.provideFunction_('colourRgb', ` const functionName = javascriptGenerator.provideFunction_('colourRgb', `
function ${JavaScript.FUNCTION_NAME_PLACEHOLDER_}(r, g, b) { function ${javascriptGenerator.FUNCTION_NAME_PLACEHOLDER_}(r, g, b) {
r = Math.max(Math.min(Number(r), 100), 0) * 2.55; r = Math.max(Math.min(Number(r), 100), 0) * 2.55;
g = Math.max(Math.min(Number(g), 100), 0) * 2.55; g = Math.max(Math.min(Number(g), 100), 0) * 2.55;
b = Math.max(Math.min(Number(b), 100), 0) * 2.55; b = Math.max(Math.min(Number(b), 100), 0) * 2.55;
@@ -51,19 +51,19 @@ function ${JavaScript.FUNCTION_NAME_PLACEHOLDER_}(r, g, b) {
} }
`); `);
const code = functionName + '(' + red + ', ' + green + ', ' + blue + ')'; const code = functionName + '(' + red + ', ' + green + ', ' + blue + ')';
return [code, JavaScript.ORDER_FUNCTION_CALL]; return [code, Order.FUNCTION_CALL];
}; };
JavaScript.forBlock['colour_blend'] = function(block) { javascriptGenerator.forBlock['colour_blend'] = function(block) {
// Blend two colours together. // Blend two colours together.
const c1 = JavaScript.valueToCode(block, 'COLOUR1', JavaScript.ORDER_NONE) || const c1 = javascriptGenerator.valueToCode(block, 'COLOUR1', Order.NONE) ||
"'#000000'"; "'#000000'";
const c2 = JavaScript.valueToCode(block, 'COLOUR2', JavaScript.ORDER_NONE) || const c2 = javascriptGenerator.valueToCode(block, 'COLOUR2', Order.NONE) ||
"'#000000'"; "'#000000'";
const ratio = const ratio =
JavaScript.valueToCode(block, 'RATIO', JavaScript.ORDER_NONE) || 0.5; javascriptGenerator.valueToCode(block, 'RATIO', Order.NONE) || 0.5;
const functionName = JavaScript.provideFunction_('colourBlend', ` const functionName = javascriptGenerator.provideFunction_('colourBlend', `
function ${JavaScript.FUNCTION_NAME_PLACEHOLDER_}(c1, c2, ratio) { function ${javascriptGenerator.FUNCTION_NAME_PLACEHOLDER_}(c1, c2, ratio) {
ratio = Math.max(Math.min(Number(ratio), 1), 0); ratio = Math.max(Math.min(Number(ratio), 1), 0);
var r1 = parseInt(c1.substring(1, 3), 16); var r1 = parseInt(c1.substring(1, 3), 16);
var g1 = parseInt(c1.substring(3, 5), 16); var g1 = parseInt(c1.substring(3, 5), 16);
@@ -81,5 +81,5 @@ function ${JavaScript.FUNCTION_NAME_PLACEHOLDER_}(c1, c2, ratio) {
} }
`); `);
const code = functionName + '(' + c1 + ', ' + c2 + ', ' + ratio + ')'; const code = functionName + '(' + c1 + ', ' + c2 + ', ' + ratio + ')';
return [code, JavaScript.ORDER_FUNCTION_CALL]; return [code, Order.FUNCTION_CALL];
}; };

148
generators/javascript/lists.js
View File

@@ -13,30 +13,30 @@ import * as goog from '../../closure/goog/goog.js';
goog.declareModuleId('Blockly.JavaScript.lists'); goog.declareModuleId('Blockly.JavaScript.lists');
import {NameType} from '../../core/names.js'; import {NameType} from '../../core/names.js';
import {javascriptGenerator as JavaScript} from '../javascript.js'; import {Order, javascriptGenerator} from '../javascript.js';
JavaScript.forBlock['lists_create_empty'] = function(block) { javascriptGenerator.forBlock['lists_create_empty'] = function(block) {
// Create an empty list. // Create an empty list.
return ['[]', JavaScript.ORDER_ATOMIC]; return ['[]', Order.ATOMIC];
}; };
JavaScript.forBlock['lists_create_with'] = function(block) { javascriptGenerator.forBlock['lists_create_with'] = function(block) {
// Create a list with any number of elements of any type. // Create a list with any number of elements of any type.
const elements = new Array(block.itemCount_); const elements = new Array(block.itemCount_);
for (let i = 0; i < block.itemCount_; i++) { for (let i = 0; i < block.itemCount_; i++) {
elements[i] = elements[i] =
JavaScript.valueToCode(block, 'ADD' + i, JavaScript.ORDER_NONE) || javascriptGenerator.valueToCode(block, 'ADD' + i, Order.NONE) ||
'null'; 'null';
} }
const code = '[' + elements.join(', ') + ']'; const code = '[' + elements.join(', ') + ']';
return [code, JavaScript.ORDER_ATOMIC]; return [code, Order.ATOMIC];
}; };
JavaScript.forBlock['lists_repeat'] = function(block) { javascriptGenerator.forBlock['lists_repeat'] = function(block) {
// Create a list with one element repeated. // Create a list with one element repeated.
const functionName = JavaScript.provideFunction_('listsRepeat', ` const functionName = javascriptGenerator.provideFunction_('listsRepeat', `
function ${JavaScript.FUNCTION_NAME_PLACEHOLDER_}(value, n) { function ${javascriptGenerator.FUNCTION_NAME_PLACEHOLDER_}(value, n) {
var array = []; var array = [];
for (var i = 0; i < n; i++) { for (var i = 0; i < n; i++) {
array[i] = value; array[i] = value;
@@ -45,59 +45,60 @@ function ${JavaScript.FUNCTION_NAME_PLACEHOLDER_}(value, n) {
} }
`); `);
const element = const element =
JavaScript.valueToCode(block, 'ITEM', JavaScript.ORDER_NONE) || 'null'; javascriptGenerator.valueToCode(block, 'ITEM', Order.NONE) || 'null';
const repeatCount = const repeatCount =
JavaScript.valueToCode(block, 'NUM', JavaScript.ORDER_NONE) || '0'; javascriptGenerator.valueToCode(block, 'NUM', Order.NONE) || '0';
const code = functionName + '(' + element + ', ' + repeatCount + ')'; const code = functionName + '(' + element + ', ' + repeatCount + ')';
return [code, JavaScript.ORDER_FUNCTION_CALL]; return [code, Order.FUNCTION_CALL];
}; };
JavaScript.forBlock['lists_length'] = function(block) { javascriptGenerator.forBlock['lists_length'] = function(block) {
// String or array length. // String or array length.
const list = const list =
JavaScript.valueToCode(block, 'VALUE', JavaScript.ORDER_MEMBER) || '[]'; javascriptGenerator.valueToCode(block, 'VALUE', Order.MEMBER) || '[]';
return [list + '.length', JavaScript.ORDER_MEMBER]; return [list + '.length', Order.MEMBER];
}; };
JavaScript.forBlock['lists_isEmpty'] = function(block) { javascriptGenerator.forBlock['lists_isEmpty'] = function(block) {
// Is the string null or array empty? // Is the string null or array empty?
const list = const list =
JavaScript.valueToCode(block, 'VALUE', JavaScript.ORDER_MEMBER) || '[]'; javascriptGenerator.valueToCode(block, 'VALUE', Order.MEMBER) || '[]';
return ['!' + list + '.length', JavaScript.ORDER_LOGICAL_NOT]; return ['!' + list + '.length', Order.LOGICAL_NOT];
}; };
JavaScript.forBlock['lists_indexOf'] = function(block) { javascriptGenerator.forBlock['lists_indexOf'] = function(block) {
// Find an item in the list. // Find an item in the list.
const operator = const operator =
block.getFieldValue('END') === 'FIRST' ? 'indexOf' : 'lastIndexOf'; block.getFieldValue('END') === 'FIRST' ? 'indexOf' : 'lastIndexOf';
const item = const item =
JavaScript.valueToCode(block, 'FIND', JavaScript.ORDER_NONE) || "''"; javascriptGenerator.valueToCode(block, 'FIND', Order.NONE) || "''";
const list = const list =
JavaScript.valueToCode(block, 'VALUE', JavaScript.ORDER_MEMBER) || '[]'; javascriptGenerator.valueToCode(block, 'VALUE', Order.MEMBER) || '[]';
const code = list + '.' + operator + '(' + item + ')'; const code = list + '.' + operator + '(' + item + ')';
if (block.workspace.options.oneBasedIndex) { if (block.workspace.options.oneBasedIndex) {
return [code + ' + 1', JavaScript.ORDER_ADDITION]; return [code + ' + 1', Order.ADDITION];
} }
return [code, JavaScript.ORDER_FUNCTION_CALL]; return [code, Order.FUNCTION_CALL];
}; };
JavaScript.forBlock['lists_getIndex'] = function(block) { javascriptGenerator.forBlock['lists_getIndex'] = function(block) {
// Get element at index. // Get element at index.
// Note: Until January 2013 this block did not have MODE or WHERE inputs. // Note: Until January 2013 this block did not have MODE or WHERE inputs.
const mode = block.getFieldValue('MODE') || 'GET'; const mode = block.getFieldValue('MODE') || 'GET';
const where = block.getFieldValue('WHERE') || 'FROM_START'; const where = block.getFieldValue('WHERE') || 'FROM_START';
const listOrder = const listOrder =
(where === 'RANDOM') ? JavaScript.ORDER_NONE : JavaScript.ORDER_MEMBER; (where === 'RANDOM') ? Order.NONE : Order.MEMBER;
const list = JavaScript.valueToCode(block, 'VALUE', listOrder) || '[]'; const list =
javascriptGenerator.valueToCode(block, 'VALUE', listOrder) || '[]';
switch (where) { switch (where) {
case ('FIRST'): case ('FIRST'):
if (mode === 'GET') { if (mode === 'GET') {
const code = list + '[0]'; const code = list + '[0]';
return [code, JavaScript.ORDER_MEMBER]; return [code, Order.MEMBER];
} else if (mode === 'GET_REMOVE') { } else if (mode === 'GET_REMOVE') {
const code = list + '.shift()'; const code = list + '.shift()';
return [code, JavaScript.ORDER_MEMBER]; return [code, Order.MEMBER];
} else if (mode === 'REMOVE') { } else if (mode === 'REMOVE') {
return list + '.shift();\n'; return list + '.shift();\n';
} }
@@ -105,43 +106,44 @@ JavaScript.forBlock['lists_getIndex'] = function(block) {
case ('LAST'): case ('LAST'):
if (mode === 'GET') { if (mode === 'GET') {
const code = list + '.slice(-1)[0]'; const code = list + '.slice(-1)[0]';
return [code, JavaScript.ORDER_MEMBER]; return [code, Order.MEMBER];
} else if (mode === 'GET_REMOVE') { } else if (mode === 'GET_REMOVE') {
const code = list + '.pop()'; const code = list + '.pop()';
return [code, JavaScript.ORDER_MEMBER]; return [code, Order.MEMBER];
} else if (mode === 'REMOVE') { } else if (mode === 'REMOVE') {
return list + '.pop();\n'; return list + '.pop();\n';
} }
break; break;
case ('FROM_START'): { case ('FROM_START'): {
const at = JavaScript.getAdjusted(block, 'AT'); const at = javascriptGenerator.getAdjusted(block, 'AT');
if (mode === 'GET') { if (mode === 'GET') {
const code = list + '[' + at + ']'; const code = list + '[' + at + ']';
return [code, JavaScript.ORDER_MEMBER]; return [code, Order.MEMBER];
} else if (mode === 'GET_REMOVE') { } else if (mode === 'GET_REMOVE') {
const code = list + '.splice(' + at + ', 1)[0]'; const code = list + '.splice(' + at + ', 1)[0]';
return [code, JavaScript.ORDER_FUNCTION_CALL]; return [code, Order.FUNCTION_CALL];
} else if (mode === 'REMOVE') { } else if (mode === 'REMOVE') {
return list + '.splice(' + at + ', 1);\n'; return list + '.splice(' + at + ', 1);\n';
} }
break; break;
} }
case ('FROM_END'): { case ('FROM_END'): {
const at = JavaScript.getAdjusted(block, 'AT', 1, true); const at = javascriptGenerator.getAdjusted(block, 'AT', 1, true);
if (mode === 'GET') { if (mode === 'GET') {
const code = list + '.slice(' + at + ')[0]'; const code = list + '.slice(' + at + ')[0]';
return [code, JavaScript.ORDER_FUNCTION_CALL]; return [code, Order.FUNCTION_CALL];
} else if (mode === 'GET_REMOVE') { } else if (mode === 'GET_REMOVE') {
const code = list + '.splice(' + at + ', 1)[0]'; const code = list + '.splice(' + at + ', 1)[0]';
return [code, JavaScript.ORDER_FUNCTION_CALL]; return [code, Order.FUNCTION_CALL];
} else if (mode === 'REMOVE') { } else if (mode === 'REMOVE') {
return list + '.splice(' + at + ', 1);'; return list + '.splice(' + at + ', 1);';
} }
break; break;
} }
case ('RANDOM'): { case ('RANDOM'): {
const functionName = JavaScript.provideFunction_('listsGetRandomItem', ` const functionName =
function ${JavaScript.FUNCTION_NAME_PLACEHOLDER_}(list, remove) { javascriptGenerator.provideFunction_('listsGetRandomItem', `
function ${javascriptGenerator.FUNCTION_NAME_PLACEHOLDER_}(list, remove) {
var x = Math.floor(Math.random() * list.length); var x = Math.floor(Math.random() * list.length);
if (remove) { if (remove) {
return list.splice(x, 1)[0]; return list.splice(x, 1)[0];
@@ -152,7 +154,7 @@ function ${JavaScript.FUNCTION_NAME_PLACEHOLDER_}(list, remove) {
`); `);
const code = functionName + '(' + list + ', ' + (mode !== 'GET') + ')'; const code = functionName + '(' + list + ', ' + (mode !== 'GET') + ')';
if (mode === 'GET' || mode === 'GET_REMOVE') { if (mode === 'GET' || mode === 'GET_REMOVE') {
return [code, JavaScript.ORDER_FUNCTION_CALL]; return [code, Order.FUNCTION_CALL];
} else if (mode === 'REMOVE') { } else if (mode === 'REMOVE') {
return code + ';\n'; return code + ';\n';
} }
@@ -162,15 +164,15 @@ function ${JavaScript.FUNCTION_NAME_PLACEHOLDER_}(list, remove) {
throw Error('Unhandled combination (lists_getIndex).'); throw Error('Unhandled combination (lists_getIndex).');
}; };
JavaScript.forBlock['lists_setIndex'] = function(block) { javascriptGenerator.forBlock['lists_setIndex'] = function(block) {
// Set element at index. // Set element at index.
// Note: Until February 2013 this block did not have MODE or WHERE inputs. // Note: Until February 2013 this block did not have MODE or WHERE inputs.
let list = let list =
JavaScript.valueToCode(block, 'LIST', JavaScript.ORDER_MEMBER) || '[]'; javascriptGenerator.valueToCode(block, 'LIST', Order.MEMBER) || '[]';
const mode = block.getFieldValue('MODE') || 'GET'; const mode = block.getFieldValue('MODE') || 'GET';
const where = block.getFieldValue('WHERE') || 'FROM_START'; const where = block.getFieldValue('WHERE') || 'FROM_START';
const value = const value =
JavaScript.valueToCode(block, 'TO', JavaScript.ORDER_ASSIGNMENT) || javascriptGenerator.valueToCode(block, 'TO', Order.ASSIGNMENT) ||
'null'; 'null';
// Cache non-trivial values to variables to prevent repeated look-ups. // Cache non-trivial values to variables to prevent repeated look-ups.
// Closure, which accesses and modifies 'list'. // Closure, which accesses and modifies 'list'.
@@ -179,7 +181,8 @@ JavaScript.forBlock['lists_setIndex'] = function(block) {
return ''; return '';
} }
const listVar = const listVar =
JavaScript.nameDB_.getDistinctName('tmpList', NameType.VARIABLE); javascriptGenerator.nameDB_.getDistinctName(
'tmpList', NameType.VARIABLE);
const code = 'var ' + listVar + ' = ' + list + ';\n'; const code = 'var ' + listVar + ' = ' + list + ';\n';
list = listVar; list = listVar;
return code; return code;
@@ -202,7 +205,7 @@ JavaScript.forBlock['lists_setIndex'] = function(block) {
} }
break; break;
case ('FROM_START'): { case ('FROM_START'): {
const at = JavaScript.getAdjusted(block, 'AT'); const at = javascriptGenerator.getAdjusted(block, 'AT');
if (mode === 'SET') { if (mode === 'SET') {
return list + '[' + at + '] = ' + value + ';\n'; return list + '[' + at + '] = ' + value + ';\n';
} else if (mode === 'INSERT') { } else if (mode === 'INSERT') {
@@ -211,8 +214,8 @@ JavaScript.forBlock['lists_setIndex'] = function(block) {
break; break;
} }
case ('FROM_END'): { case ('FROM_END'): {
const at = JavaScript.getAdjusted( const at = javascriptGenerator.getAdjusted(
block, 'AT', 1, false, JavaScript.ORDER_SUBTRACTION); block, 'AT', 1, false, Order.SUBTRACTION);
let code = cacheList(); let code = cacheList();
if (mode === 'SET') { if (mode === 'SET') {
code += list + '[' + list + '.length - ' + at + '] = ' + value + ';\n'; code += list + '[' + list + '.length - ' + at + '] = ' + value + ';\n';
@@ -227,7 +230,8 @@ JavaScript.forBlock['lists_setIndex'] = function(block) {
case ('RANDOM'): { case ('RANDOM'): {
let code = cacheList(); let code = cacheList();
const xVar = const xVar =
JavaScript.nameDB_.getDistinctName('tmpX', NameType.VARIABLE); javascriptGenerator.nameDB_.getDistinctName(
'tmpX', NameType.VARIABLE);
code += 'var ' + xVar + ' = Math.floor(Math.random() * ' + list + code += 'var ' + xVar + ' = Math.floor(Math.random() * ' + list +
'.length);\n'; '.length);\n';
if (mode === 'SET') { if (mode === 'SET') {
@@ -262,10 +266,10 @@ const getSubstringIndex = function(listName, where, opt_at) {
} }
}; };
JavaScript.forBlock['lists_getSublist'] = function(block) { javascriptGenerator.forBlock['lists_getSublist'] = function(block) {
// Get sublist. // Get sublist.
const list = const list =
JavaScript.valueToCode(block, 'LIST', JavaScript.ORDER_MEMBER) || '[]'; javascriptGenerator.valueToCode(block, 'LIST', Order.MEMBER) || '[]';
const where1 = block.getFieldValue('WHERE1'); const where1 = block.getFieldValue('WHERE1');
const where2 = block.getFieldValue('WHERE2'); const where2 = block.getFieldValue('WHERE2');
let code; let code;
@@ -279,11 +283,11 @@ JavaScript.forBlock['lists_getSublist'] = function(block) {
let at1; let at1;
switch (where1) { switch (where1) {
case 'FROM_START': case 'FROM_START':
at1 = JavaScript.getAdjusted(block, 'AT1'); at1 = javascriptGenerator.getAdjusted(block, 'AT1');
break; break;
case 'FROM_END': case 'FROM_END':
at1 = JavaScript.getAdjusted( at1 = javascriptGenerator.getAdjusted(
block, 'AT1', 1, false, JavaScript.ORDER_SUBTRACTION); block, 'AT1', 1, false, Order.SUBTRACTION);
at1 = list + '.length - ' + at1; at1 = list + '.length - ' + at1;
break; break;
case 'FIRST': case 'FIRST':
@@ -295,11 +299,11 @@ JavaScript.forBlock['lists_getSublist'] = function(block) {
let at2; let at2;
switch (where2) { switch (where2) {
case 'FROM_START': case 'FROM_START':
at2 = JavaScript.getAdjusted(block, 'AT2', 1); at2 = javascriptGenerator.getAdjusted(block, 'AT2', 1);
break; break;
case 'FROM_END': case 'FROM_END':
at2 = JavaScript.getAdjusted( at2 = javascriptGenerator.getAdjusted(
block, 'AT2', 0, false, JavaScript.ORDER_SUBTRACTION); block, 'AT2', 0, false, Order.SUBTRACTION);
at2 = list + '.length - ' + at2; at2 = list + '.length - ' + at2;
break; break;
case 'LAST': case 'LAST':
@@ -310,8 +314,8 @@ JavaScript.forBlock['lists_getSublist'] = function(block) {
} }
code = list + '.slice(' + at1 + ', ' + at2 + ')'; code = list + '.slice(' + at1 + ', ' + at2 + ')';
} else { } else {
const at1 = JavaScript.getAdjusted(block, 'AT1'); const at1 = javascriptGenerator.getAdjusted(block, 'AT1');
const at2 = JavaScript.getAdjusted(block, 'AT2'); const at2 = javascriptGenerator.getAdjusted(block, 'AT2');
const wherePascalCase = { const wherePascalCase = {
'FIRST': 'First', 'FIRST': 'First',
'LAST': 'Last', 'LAST': 'Last',
@@ -324,9 +328,9 @@ JavaScript.forBlock['lists_getSublist'] = function(block) {
(where1 === 'FROM_END' || where1 === 'FROM_START') ? ', at1' : ''; (where1 === 'FROM_END' || where1 === 'FROM_START') ? ', at1' : '';
const at2Param = const at2Param =
(where2 === 'FROM_END' || where2 === 'FROM_START') ? ', at2' : ''; (where2 === 'FROM_END' || where2 === 'FROM_START') ? ', at2' : '';
const functionName = JavaScript.provideFunction_( const functionName = javascriptGenerator.provideFunction_(
'subsequence' + wherePascalCase[where1] + wherePascalCase[where2], ` 'subsequence' + wherePascalCase[where1] + wherePascalCase[where2], `
function ${JavaScript.FUNCTION_NAME_PLACEHOLDER_}(sequence${at1Param}${at2Param}) { function ${javascriptGenerator.FUNCTION_NAME_PLACEHOLDER_}(sequence${at1Param}${at2Param}) {
var start = ${getSubstringIndex('sequence', where1, 'at1')}; var start = ${getSubstringIndex('sequence', where1, 'at1')};
var end = ${getSubstringIndex('sequence', where2, 'at2')} + 1; var end = ${getSubstringIndex('sequence', where2, 'at2')} + 1;
return sequence.slice(start, end); return sequence.slice(start, end);
@@ -339,19 +343,19 @@ function ${JavaScript.FUNCTION_NAME_PLACEHOLDER_}(sequence${at1Param}${at2Param}
((where2 === 'FROM_END' || where2 === 'FROM_START') ? ', ' + at2 : '') + ((where2 === 'FROM_END' || where2 === 'FROM_START') ? ', ' + at2 : '') +
')'; ')';
} }
return [code, JavaScript.ORDER_FUNCTION_CALL]; return [code, Order.FUNCTION_CALL];
}; };
JavaScript.forBlock['lists_sort'] = function(block) { javascriptGenerator.forBlock['lists_sort'] = function(block) {
// Block for sorting a list. // Block for sorting a list.
const list = const list =
JavaScript.valueToCode(block, 'LIST', JavaScript.ORDER_FUNCTION_CALL) || javascriptGenerator.valueToCode(block, 'LIST', Order.FUNCTION_CALL) ||
'[]'; '[]';
const direction = block.getFieldValue('DIRECTION') === '1' ? 1 : -1; const direction = block.getFieldValue('DIRECTION') === '1' ? 1 : -1;
const type = block.getFieldValue('TYPE'); const type = block.getFieldValue('TYPE');
const getCompareFunctionName = const getCompareFunctionName =
JavaScript.provideFunction_('listsGetSortCompare', ` javascriptGenerator.provideFunction_('listsGetSortCompare', `
function ${JavaScript.FUNCTION_NAME_PLACEHOLDER_}(type, direction) { function ${javascriptGenerator.FUNCTION_NAME_PLACEHOLDER_}(type, direction) {
var compareFuncs = { var compareFuncs = {
'NUMERIC': function(a, b) { 'NUMERIC': function(a, b) {
return Number(a) - Number(b); }, return Number(a) - Number(b); },
@@ -367,15 +371,15 @@ function ${JavaScript.FUNCTION_NAME_PLACEHOLDER_}(type, direction) {
return [ return [
list + '.slice().sort(' + getCompareFunctionName + '("' + type + '", ' + list + '.slice().sort(' + getCompareFunctionName + '("' + type + '", ' +
direction + '))', direction + '))',
JavaScript.ORDER_FUNCTION_CALL Order.FUNCTION_CALL
]; ];
}; };
JavaScript.forBlock['lists_split'] = function(block) { javascriptGenerator.forBlock['lists_split'] = function(block) {
// Block for splitting text into a list, or joining a list into text. // Block for splitting text into a list, or joining a list into text.
let input = JavaScript.valueToCode(block, 'INPUT', JavaScript.ORDER_MEMBER); let input = javascriptGenerator.valueToCode(block, 'INPUT', Order.MEMBER);
const delimiter = const delimiter =
JavaScript.valueToCode(block, 'DELIM', JavaScript.ORDER_NONE) || "''"; javascriptGenerator.valueToCode(block, 'DELIM', Order.NONE) || "''";
const mode = block.getFieldValue('MODE'); const mode = block.getFieldValue('MODE');
let functionName; let functionName;
if (mode === 'SPLIT') { if (mode === 'SPLIT') {
@@ -392,14 +396,14 @@ JavaScript.forBlock['lists_split'] = function(block) {
throw Error('Unknown mode: ' + mode); throw Error('Unknown mode: ' + mode);
} }
const code = input + '.' + functionName + '(' + delimiter + ')'; const code = input + '.' + functionName + '(' + delimiter + ')';
return [code, JavaScript.ORDER_FUNCTION_CALL]; return [code, Order.FUNCTION_CALL];
}; };
JavaScript.forBlock['lists_reverse'] = function(block) { javascriptGenerator.forBlock['lists_reverse'] = function(block) {
// Block for reversing a list. // Block for reversing a list.
const list = const list =
JavaScript.valueToCode(block, 'LIST', JavaScript.ORDER_FUNCTION_CALL) || javascriptGenerator.valueToCode(block, 'LIST', Order.FUNCTION_CALL) ||
'[]'; '[]';
const code = list + '.slice().reverse()'; const code = list + '.slice().reverse()';
return [code, JavaScript.ORDER_FUNCTION_CALL]; return [code, Order.FUNCTION_CALL];
}; };

83
generators/javascript/logic.js
View File

@@ -11,26 +11,28 @@
import * as goog from '../../closure/goog/goog.js'; import * as goog from '../../closure/goog/goog.js';
goog.declareModuleId('Blockly.JavaScript.logic'); goog.declareModuleId('Blockly.JavaScript.logic');
import {javascriptGenerator as JavaScript} from '../javascript.js'; import {Order, javascriptGenerator} from '../javascript.js';
JavaScript.forBlock['controls_if'] = function(block) { javascriptGenerator.forBlock['controls_if'] = function(block) {
// If/elseif/else condition. // If/elseif/else condition.
let n = 0; let n = 0;
let code = ''; let code = '';
if (JavaScript.STATEMENT_PREFIX) { if (javascriptGenerator.STATEMENT_PREFIX) {
// Automatic prefix insertion is switched off for this block. Add manually. // Automatic prefix insertion is switched off for this block. Add manually.
code += JavaScript.injectId(JavaScript.STATEMENT_PREFIX, block); code += javascriptGenerator.injectId(
javascriptGenerator.STATEMENT_PREFIX, block);
} }
do { do {
const conditionCode = const conditionCode =
JavaScript.valueToCode(block, 'IF' + n, JavaScript.ORDER_NONE) || javascriptGenerator.valueToCode(block, 'IF' + n, Order.NONE) ||
'false'; 'false';
let branchCode = JavaScript.statementToCode(block, 'DO' + n); let branchCode = javascriptGenerator.statementToCode(block, 'DO' + n);
if (JavaScript.STATEMENT_SUFFIX) { if (javascriptGenerator.STATEMENT_SUFFIX) {
branchCode = JavaScript.prefixLines( branchCode = javascriptGenerator.prefixLines(
JavaScript.injectId(JavaScript.STATEMENT_SUFFIX, block), javascriptGenerator.injectId(
JavaScript.INDENT) + javascriptGenerator.STATEMENT_SUFFIX, block),
javascriptGenerator.INDENT) +
branchCode; branchCode;
} }
code += (n > 0 ? ' else ' : '') + 'if (' + conditionCode + ') {\n' + code += (n > 0 ? ' else ' : '') + 'if (' + conditionCode + ') {\n' +
@@ -38,12 +40,13 @@ JavaScript.forBlock['controls_if'] = function(block) {
n++; n++;
} while (block.getInput('IF' + n)); } while (block.getInput('IF' + n));
if (block.getInput('ELSE') || JavaScript.STATEMENT_SUFFIX) { if (block.getInput('ELSE') || javascriptGenerator.STATEMENT_SUFFIX) {
let branchCode = JavaScript.statementToCode(block, 'ELSE'); let branchCode = javascriptGenerator.statementToCode(block, 'ELSE');
if (JavaScript.STATEMENT_SUFFIX) { if (javascriptGenerator.STATEMENT_SUFFIX) {
branchCode = JavaScript.prefixLines( branchCode = javascriptGenerator.prefixLines(
JavaScript.injectId(JavaScript.STATEMENT_SUFFIX, block), javascriptGenerator.injectId(
JavaScript.INDENT) + javascriptGenerator.STATEMENT_SUFFIX, block),
javascriptGenerator.INDENT) +
branchCode; branchCode;
} }
code += ' else {\n' + branchCode + '}'; code += ' else {\n' + branchCode + '}';
@@ -51,29 +54,30 @@ JavaScript.forBlock['controls_if'] = function(block) {
return code + '\n'; return code + '\n';
}; };
JavaScript.forBlock['controls_ifelse'] = JavaScript.forBlock['controls_if']; javascriptGenerator.forBlock['controls_ifelse'] =
javascriptGenerator.forBlock['controls_if'];
JavaScript.forBlock['logic_compare'] = function(block) { javascriptGenerator.forBlock['logic_compare'] = function(block) {
// Comparison operator. // Comparison operator.
const OPERATORS = const OPERATORS =
{'EQ': '==', 'NEQ': '!=', 'LT': '<', 'LTE': '<=', 'GT': '>', 'GTE': '>='}; {'EQ': '==', 'NEQ': '!=', 'LT': '<', 'LTE': '<=', 'GT': '>', 'GTE': '>='};
const operator = OPERATORS[block.getFieldValue('OP')]; const operator = OPERATORS[block.getFieldValue('OP')];
const order = (operator === '==' || operator === '!=') ? const order = (operator === '==' || operator === '!=') ?
JavaScript.ORDER_EQUALITY : Order.EQUALITY :
JavaScript.ORDER_RELATIONAL; Order.RELATIONAL;
const argument0 = JavaScript.valueToCode(block, 'A', order) || '0'; const argument0 = javascriptGenerator.valueToCode(block, 'A', order) || '0';
const argument1 = JavaScript.valueToCode(block, 'B', order) || '0'; const argument1 = javascriptGenerator.valueToCode(block, 'B', order) || '0';
const code = argument0 + ' ' + operator + ' ' + argument1; const code = argument0 + ' ' + operator + ' ' + argument1;
return [code, order]; return [code, order];
}; };
JavaScript.forBlock['logic_operation'] = function(block) { javascriptGenerator.forBlock['logic_operation'] = function(block) {
// Operations 'and', 'or'. // Operations 'and', 'or'.
const operator = (block.getFieldValue('OP') === 'AND') ? '&&' : '||'; const operator = (block.getFieldValue('OP') === 'AND') ? '&&' : '||';
const order = (operator === '&&') ? JavaScript.ORDER_LOGICAL_AND : const order = (operator === '&&') ? Order.LOGICAL_AND :
JavaScript.ORDER_LOGICAL_OR; Order.LOGICAL_OR;
let argument0 = JavaScript.valueToCode(block, 'A', order); let argument0 = javascriptGenerator.valueToCode(block, 'A', order);
let argument1 = JavaScript.valueToCode(block, 'B', order); let argument1 = javascriptGenerator.valueToCode(block, 'B', order);
if (!argument0 && !argument1) { if (!argument0 && !argument1) {
// If there are no arguments, then the return value is false. // If there are no arguments, then the return value is false.
argument0 = 'false'; argument0 = 'false';
@@ -92,36 +96,37 @@ JavaScript.forBlock['logic_operation'] = function(block) {
return [code, order]; return [code, order];
}; };
JavaScript.forBlock['logic_negate'] = function(block) { javascriptGenerator.forBlock['logic_negate'] = function(block) {
// Negation. // Negation.
const order = JavaScript.ORDER_LOGICAL_NOT; const order = Order.LOGICAL_NOT;
const argument0 = JavaScript.valueToCode(block, 'BOOL', order) || 'true'; const argument0 =
javascriptGenerator.valueToCode(block, 'BOOL', order) || 'true';
const code = '!' + argument0; const code = '!' + argument0;
return [code, order]; return [code, order];
}; };
JavaScript.forBlock['logic_boolean'] = function(block) { javascriptGenerator.forBlock['logic_boolean'] = function(block) {
// Boolean values true and false. // Boolean values true and false.
const code = (block.getFieldValue('BOOL') === 'TRUE') ? 'true' : 'false'; const code = (block.getFieldValue('BOOL') === 'TRUE') ? 'true' : 'false';
return [code, JavaScript.ORDER_ATOMIC]; return [code, Order.ATOMIC];
}; };
JavaScript.forBlock['logic_null'] = function(block) { javascriptGenerator.forBlock['logic_null'] = function(block) {
// Null data type. // Null data type.
return ['null', JavaScript.ORDER_ATOMIC]; return ['null', Order.ATOMIC];
}; };
JavaScript.forBlock['logic_ternary'] = function(block) { javascriptGenerator.forBlock['logic_ternary'] = function(block) {
// Ternary operator. // Ternary operator.
const value_if = const value_if =
JavaScript.valueToCode(block, 'IF', JavaScript.ORDER_CONDITIONAL) || javascriptGenerator.valueToCode(block, 'IF', Order.CONDITIONAL) ||
'false'; 'false';
const value_then = const value_then =
JavaScript.valueToCode(block, 'THEN', JavaScript.ORDER_CONDITIONAL) || javascriptGenerator.valueToCode(block, 'THEN', Order.CONDITIONAL) ||
'null'; 'null';
const value_else = const value_else =
JavaScript.valueToCode(block, 'ELSE', JavaScript.ORDER_CONDITIONAL) || javascriptGenerator.valueToCode(block, 'ELSE', Order.CONDITIONAL) ||
'null'; 'null';
const code = value_if + ' ? ' + value_then + ' : ' + value_else; const code = value_if + ' ? ' + value_then + ' : ' + value_else;
return [code, JavaScript.ORDER_CONDITIONAL]; return [code, Order.CONDITIONAL];
}; };

87
generators/javascript/loops.js
View File

@@ -13,10 +13,10 @@ goog.declareModuleId('Blockly.JavaScript.loops');
import * as stringUtils from '../../core/utils/string.js'; import * as stringUtils from '../../core/utils/string.js';
import {NameType} from '../../core/names.js'; import {NameType} from '../../core/names.js';
import {javascriptGenerator as JavaScript} from '../javascript.js'; import {Order, javascriptGenerator} from '../javascript.js';
JavaScript.forBlock['controls_repeat_ext'] = function(block) { javascriptGenerator.forBlock['controls_repeat_ext'] = function(block) {
// Repeat n times. // Repeat n times.
let repeats; let repeats;
if (block.getField('TIMES')) { if (block.getField('TIMES')) {
@@ -25,18 +25,19 @@ JavaScript.forBlock['controls_repeat_ext'] = function(block) {
} else { } else {
// External number. // External number.
repeats = repeats =
JavaScript.valueToCode(block, 'TIMES', JavaScript.ORDER_ASSIGNMENT) || javascriptGenerator.valueToCode(block, 'TIMES', Order.ASSIGNMENT) ||
'0'; '0';
} }
let branch = JavaScript.statementToCode(block, 'DO'); let branch = javascriptGenerator.statementToCode(block, 'DO');
branch = JavaScript.addLoopTrap(branch, block); branch = javascriptGenerator.addLoopTrap(branch, block);
let code = ''; let code = '';
const loopVar = const loopVar =
JavaScript.nameDB_.getDistinctName('count', NameType.VARIABLE); javascriptGenerator.nameDB_.getDistinctName('count', NameType.VARIABLE);
let endVar = repeats; let endVar = repeats;
if (!repeats.match(/^\w+$/) && !stringUtils.isNumber(repeats)) { if (!repeats.match(/^\w+$/) && !stringUtils.isNumber(repeats)) {
endVar = endVar =
JavaScript.nameDB_.getDistinctName('repeat_end', NameType.VARIABLE); javascriptGenerator.nameDB_.getDistinctName(
'repeat_end', NameType.VARIABLE);
code += 'var ' + endVar + ' = ' + repeats + ';\n'; code += 'var ' + endVar + ' = ' + repeats + ';\n';
} }
code += 'for (var ' + loopVar + ' = 0; ' + loopVar + ' < ' + endVar + '; ' + code += 'for (var ' + loopVar + ' = 0; ' + loopVar + ' < ' + endVar + '; ' +
@@ -44,36 +45,38 @@ JavaScript.forBlock['controls_repeat_ext'] = function(block) {
return code; return code;
}; };
JavaScript.forBlock['controls_repeat'] = JavaScript.forBlock['controls_repeat_ext']; javascriptGenerator.forBlock['controls_repeat'] =
javascriptGenerator.forBlock['controls_repeat_ext'];
JavaScript.forBlock['controls_whileUntil'] = function(block) { javascriptGenerator.forBlock['controls_whileUntil'] = function(block) {
// Do while/until loop. // Do while/until loop.
const until = block.getFieldValue('MODE') === 'UNTIL'; const until = block.getFieldValue('MODE') === 'UNTIL';
let argument0 = let argument0 =
JavaScript.valueToCode( javascriptGenerator.valueToCode(
block, 'BOOL', block, 'BOOL',
until ? JavaScript.ORDER_LOGICAL_NOT : JavaScript.ORDER_NONE) || until ? Order.LOGICAL_NOT : Order.NONE) ||
'false'; 'false';
let branch = JavaScript.statementToCode(block, 'DO'); let branch = javascriptGenerator.statementToCode(block, 'DO');
branch = JavaScript.addLoopTrap(branch, block); branch = javascriptGenerator.addLoopTrap(branch, block);
if (until) { if (until) {
argument0 = '!' + argument0; argument0 = '!' + argument0;
} }
return 'while (' + argument0 + ') {\n' + branch + '}\n'; return 'while (' + argument0 + ') {\n' + branch + '}\n';
}; };
JavaScript.forBlock['controls_for'] = function(block) { javascriptGenerator.forBlock['controls_for'] = function(block) {
// For loop. // For loop.
const variable0 = const variable0 =
JavaScript.nameDB_.getName(block.getFieldValue('VAR'), NameType.VARIABLE); javascriptGenerator.nameDB_.getName(
block.getFieldValue('VAR'), NameType.VARIABLE);
const argument0 = const argument0 =
JavaScript.valueToCode(block, 'FROM', JavaScript.ORDER_ASSIGNMENT) || '0'; javascriptGenerator.valueToCode(block, 'FROM', Order.ASSIGNMENT) || '0';
const argument1 = const argument1 =
JavaScript.valueToCode(block, 'TO', JavaScript.ORDER_ASSIGNMENT) || '0'; javascriptGenerator.valueToCode(block, 'TO', Order.ASSIGNMENT) || '0';
const increment = const increment =
JavaScript.valueToCode(block, 'BY', JavaScript.ORDER_ASSIGNMENT) || '1'; javascriptGenerator.valueToCode(block, 'BY', Order.ASSIGNMENT) || '1';
let branch = JavaScript.statementToCode(block, 'DO'); let branch = javascriptGenerator.statementToCode(block, 'DO');
branch = JavaScript.addLoopTrap(branch, block); branch = javascriptGenerator.addLoopTrap(branch, block);
let code; let code;
if (stringUtils.isNumber(argument0) && stringUtils.isNumber(argument1) && if (stringUtils.isNumber(argument0) && stringUtils.isNumber(argument1) &&
stringUtils.isNumber(increment)) { stringUtils.isNumber(increment)) {
@@ -93,19 +96,19 @@ JavaScript.forBlock['controls_for'] = function(block) {
// Cache non-trivial values to variables to prevent repeated look-ups. // Cache non-trivial values to variables to prevent repeated look-ups.
let startVar = argument0; let startVar = argument0;
if (!argument0.match(/^\w+$/) && !stringUtils.isNumber(argument0)) { if (!argument0.match(/^\w+$/) && !stringUtils.isNumber(argument0)) {
startVar = JavaScript.nameDB_.getDistinctName( startVar = javascriptGenerator.nameDB_.getDistinctName(
variable0 + '_start', NameType.VARIABLE); variable0 + '_start', NameType.VARIABLE);
code += 'var ' + startVar + ' = ' + argument0 + ';\n'; code += 'var ' + startVar + ' = ' + argument0 + ';\n';
} }
let endVar = argument1; let endVar = argument1;
if (!argument1.match(/^\w+$/) && !stringUtils.isNumber(argument1)) { if (!argument1.match(/^\w+$/) && !stringUtils.isNumber(argument1)) {
endVar = JavaScript.nameDB_.getDistinctName( endVar = javascriptGenerator.nameDB_.getDistinctName(
variable0 + '_end', NameType.VARIABLE); variable0 + '_end', NameType.VARIABLE);
code += 'var ' + endVar + ' = ' + argument1 + ';\n'; code += 'var ' + endVar + ' = ' + argument1 + ';\n';
} }
// Determine loop direction at start, in case one of the bounds // Determine loop direction at start, in case one of the bounds
// changes during loop execution. // changes during loop execution.
const incVar = JavaScript.nameDB_.getDistinctName( const incVar = javascriptGenerator.nameDB_.getDistinctName(
variable0 + '_inc', NameType.VARIABLE); variable0 + '_inc', NameType.VARIABLE);
code += 'var ' + incVar + ' = '; code += 'var ' + incVar + ' = ';
if (stringUtils.isNumber(increment)) { if (stringUtils.isNumber(increment)) {
@@ -114,7 +117,7 @@ JavaScript.forBlock['controls_for'] = function(block) {
code += 'Math.abs(' + increment + ');\n'; code += 'Math.abs(' + increment + ');\n';
} }
code += 'if (' + startVar + ' > ' + endVar + ') {\n'; code += 'if (' + startVar + ' > ' + endVar + ') {\n';
code += JavaScript.INDENT + incVar + ' = -' + incVar + ';\n'; code += javascriptGenerator.INDENT + incVar + ' = -' + incVar + ';\n';
code += '}\n'; code += '}\n';
code += 'for (' + variable0 + ' = ' + startVar + '; ' + incVar + code += 'for (' + variable0 + ' = ' + startVar + '; ' + incVar +
' >= 0 ? ' + variable0 + ' <= ' + endVar + ' : ' + variable0 + ' >= 0 ? ' + variable0 + ' <= ' + endVar + ' : ' + variable0 +
@@ -124,50 +127,54 @@ JavaScript.forBlock['controls_for'] = function(block) {
return code; return code;
}; };
JavaScript.forBlock['controls_forEach'] = function(block) { javascriptGenerator.forBlock['controls_forEach'] = function(block) {
// For each loop. // For each loop.
const variable0 = const variable0 =
JavaScript.nameDB_.getName(block.getFieldValue('VAR'), NameType.VARIABLE); javascriptGenerator.nameDB_.getName(
block.getFieldValue('VAR'), NameType.VARIABLE);
const argument0 = const argument0 =
JavaScript.valueToCode(block, 'LIST', JavaScript.ORDER_ASSIGNMENT) || javascriptGenerator.valueToCode(block, 'LIST', Order.ASSIGNMENT) ||
'[]'; '[]';
let branch = JavaScript.statementToCode(block, 'DO'); let branch = javascriptGenerator.statementToCode(block, 'DO');
branch = JavaScript.addLoopTrap(branch, block); branch = javascriptGenerator.addLoopTrap(branch, block);
let code = ''; let code = '';
// Cache non-trivial values to variables to prevent repeated look-ups. // Cache non-trivial values to variables to prevent repeated look-ups.
let listVar = argument0; let listVar = argument0;
if (!argument0.match(/^\w+$/)) { if (!argument0.match(/^\w+$/)) {
listVar = JavaScript.nameDB_.getDistinctName( listVar = javascriptGenerator.nameDB_.getDistinctName(
variable0 + '_list', NameType.VARIABLE); variable0 + '_list', NameType.VARIABLE);
code += 'var ' + listVar + ' = ' + argument0 + ';\n'; code += 'var ' + listVar + ' = ' + argument0 + ';\n';
} }
const indexVar = JavaScript.nameDB_.getDistinctName( const indexVar = javascriptGenerator.nameDB_.getDistinctName(
variable0 + '_index', NameType.VARIABLE); variable0 + '_index', NameType.VARIABLE);
branch = JavaScript.INDENT + variable0 + ' = ' + listVar + '[' + indexVar + branch = javascriptGenerator.INDENT + variable0 + ' = ' + listVar +
'];\n' + branch; '[' + indexVar + '];\n' + branch;
code += 'for (var ' + indexVar + ' in ' + listVar + ') {\n' + branch + '}\n'; code += 'for (var ' + indexVar + ' in ' + listVar + ') {\n' + branch + '}\n';
return code; return code;
}; };
JavaScript.forBlock['controls_flow_statements'] = function(block) { javascriptGenerator.forBlock['controls_flow_statements'] = function(block) {
// Flow statements: continue, break. // Flow statements: continue, break.
let xfix = ''; let xfix = '';
if (JavaScript.STATEMENT_PREFIX) { if (javascriptGenerator.STATEMENT_PREFIX) {
// Automatic prefix insertion is switched off for this block. Add manually. // Automatic prefix insertion is switched off for this block. Add manually.
xfix += JavaScript.injectId(JavaScript.STATEMENT_PREFIX, block); xfix += javascriptGenerator.injectId(
javascriptGenerator.STATEMENT_PREFIX, block);
} }
if (JavaScript.STATEMENT_SUFFIX) { if (javascriptGenerator.STATEMENT_SUFFIX) {
// Inject any statement suffix here since the regular one at the end // Inject any statement suffix here since the regular one at the end
// will not get executed if the break/continue is triggered. // will not get executed if the break/continue is triggered.
xfix += JavaScript.injectId(JavaScript.STATEMENT_SUFFIX, block); xfix += javascriptGenerator.injectId(
javascriptGenerator.STATEMENT_SUFFIX, block);
} }
if (JavaScript.STATEMENT_PREFIX) { if (javascriptGenerator.STATEMENT_PREFIX) {
const loop = block.getSurroundLoop(); const loop = block.getSurroundLoop();
if (loop && !loop.suppressPrefixSuffix) { if (loop && !loop.suppressPrefixSuffix) {
// Inject loop's statement prefix here since the regular one at the end // Inject loop's statement prefix here since the regular one at the end
// of the loop will not get executed if 'continue' is triggered. // of the loop will not get executed if 'continue' is triggered.
// In the case of 'break', a prefix is needed due to the loop's suffix. // In the case of 'break', a prefix is needed due to the loop's suffix.
xfix += JavaScript.injectId(JavaScript.STATEMENT_PREFIX, loop); xfix += javascriptGenerator.injectId(
javascriptGenerator.STATEMENT_PREFIX, loop);
} }
} }
switch (block.getFieldValue('FLOW')) { switch (block.getFieldValue('FLOW')) {

227
generators/javascript/math.js
View File

@@ -13,63 +13,63 @@ import * as goog from '../../closure/goog/goog.js';
goog.declareModuleId('Blockly.JavaScript.math'); goog.declareModuleId('Blockly.JavaScript.math');
import {NameType} from '../../core/names.js'; import {NameType} from '../../core/names.js';
import {javascriptGenerator as JavaScript} from '../javascript.js'; import {Order, javascriptGenerator} from '../javascript.js';
JavaScript.forBlock['math_number'] = function(block) { javascriptGenerator.forBlock['math_number'] = function(block) {
// Numeric value. // Numeric value.
const code = Number(block.getFieldValue('NUM')); const code = Number(block.getFieldValue('NUM'));
const order = code >= 0 ? JavaScript.ORDER_ATOMIC : const order = code >= 0 ? Order.ATOMIC :
JavaScript.ORDER_UNARY_NEGATION; Order.UNARY_NEGATION;
return [code, order]; return [code, order];
}; };
JavaScript.forBlock['math_arithmetic'] = function(block) { javascriptGenerator.forBlock['math_arithmetic'] = function(block) {
// Basic arithmetic operators, and power. // Basic arithmetic operators, and power.
const OPERATORS = { const OPERATORS = {
'ADD': [' + ', JavaScript.ORDER_ADDITION], 'ADD': [' + ', Order.ADDITION],
'MINUS': [' - ', JavaScript.ORDER_SUBTRACTION], 'MINUS': [' - ', Order.SUBTRACTION],
'MULTIPLY': [' * ', JavaScript.ORDER_MULTIPLICATION], 'MULTIPLY': [' * ', Order.MULTIPLICATION],
'DIVIDE': [' / ', JavaScript.ORDER_DIVISION], 'DIVIDE': [' / ', Order.DIVISION],
'POWER': [null, JavaScript.ORDER_NONE], // Handle power separately. 'POWER': [null, Order.NONE], // Handle power separately.
}; };
const tuple = OPERATORS[block.getFieldValue('OP')]; const tuple = OPERATORS[block.getFieldValue('OP')];
const operator = tuple[0]; const operator = tuple[0];
const order = tuple[1]; const order = tuple[1];
const argument0 = JavaScript.valueToCode(block, 'A', order) || '0'; const argument0 = javascriptGenerator.valueToCode(block, 'A', order) || '0';
const argument1 = JavaScript.valueToCode(block, 'B', order) || '0'; const argument1 = javascriptGenerator.valueToCode(block, 'B', order) || '0';
let code; let code;
// Power in JavaScript requires a special case since it has no operator. // Power in JavaScript requires a special case since it has no operator.
if (!operator) { if (!operator) {
code = 'Math.pow(' + argument0 + ', ' + argument1 + ')'; code = 'Math.pow(' + argument0 + ', ' + argument1 + ')';
return [code, JavaScript.ORDER_FUNCTION_CALL]; return [code, Order.FUNCTION_CALL];
} }
code = argument0 + operator + argument1; code = argument0 + operator + argument1;
return [code, order]; return [code, order];
}; };
JavaScript.forBlock['math_single'] = function(block) { javascriptGenerator.forBlock['math_single'] = function(block) {
// Math operators with single operand. // Math operators with single operand.
const operator = block.getFieldValue('OP'); const operator = block.getFieldValue('OP');
let code; let code;
let arg; let arg;
if (operator === 'NEG') { if (operator === 'NEG') {
// Negation is a special case given its different operator precedence. // Negation is a special case given its different operator precedence.
arg = JavaScript.valueToCode(block, 'NUM', arg = javascriptGenerator.valueToCode(block, 'NUM',
JavaScript.ORDER_UNARY_NEGATION) || '0'; Order.UNARY_NEGATION) || '0';
if (arg[0] === '-') { if (arg[0] === '-') {
// --3 is not legal in JS. // --3 is not legal in JS.
arg = ' ' + arg; arg = ' ' + arg;
} }
code = '-' + arg; code = '-' + arg;
return [code, JavaScript.ORDER_UNARY_NEGATION]; return [code, Order.UNARY_NEGATION];
} }
if (operator === 'SIN' || operator === 'COS' || operator === 'TAN') { if (operator === 'SIN' || operator === 'COS' || operator === 'TAN') {
arg = JavaScript.valueToCode(block, 'NUM', arg = javascriptGenerator.valueToCode(block, 'NUM',
JavaScript.ORDER_DIVISION) || '0'; Order.DIVISION) || '0';
} else { } else {
arg = JavaScript.valueToCode(block, 'NUM', arg = javascriptGenerator.valueToCode(block, 'NUM',
JavaScript.ORDER_NONE) || '0'; Order.NONE) || '0';
} }
// First, handle cases which generate values that don't need parentheses // First, handle cases which generate values that don't need parentheses
// wrapping the code. // wrapping the code.
@@ -109,7 +109,7 @@ JavaScript.forBlock['math_single'] = function(block) {
break; break;
} }
if (code) { if (code) {
return [code, JavaScript.ORDER_FUNCTION_CALL]; return [code, Order.FUNCTION_CALL];
} }
// Second, handle cases which generate values that may need parentheses // Second, handle cases which generate values that may need parentheses
// wrapping the code. // wrapping the code.
@@ -129,46 +129,47 @@ JavaScript.forBlock['math_single'] = function(block) {
default: default:
throw Error('Unknown math operator: ' + operator); throw Error('Unknown math operator: ' + operator);
} }
return [code, JavaScript.ORDER_DIVISION]; return [code, Order.DIVISION];
}; };
JavaScript.forBlock['math_constant'] = function(block) { javascriptGenerator.forBlock['math_constant'] = function(block) {
// Constants: PI, E, the Golden Ratio, sqrt(2), 1/sqrt(2), INFINITY. // Constants: PI, E, the Golden Ratio, sqrt(2), 1/sqrt(2), INFINITY.
const CONSTANTS = { const CONSTANTS = {
'PI': ['Math.PI', JavaScript.ORDER_MEMBER], 'PI': ['Math.PI', Order.MEMBER],
'E': ['Math.E', JavaScript.ORDER_MEMBER], 'E': ['Math.E', Order.MEMBER],
'GOLDEN_RATIO': ['(1 + Math.sqrt(5)) / 2', JavaScript.ORDER_DIVISION], 'GOLDEN_RATIO': ['(1 + Math.sqrt(5)) / 2', Order.DIVISION],
'SQRT2': ['Math.SQRT2', JavaScript.ORDER_MEMBER], 'SQRT2': ['Math.SQRT2', Order.MEMBER],
'SQRT1_2': ['Math.SQRT1_2', JavaScript.ORDER_MEMBER], 'SQRT1_2': ['Math.SQRT1_2', Order.MEMBER],
'INFINITY': ['Infinity', JavaScript.ORDER_ATOMIC], 'INFINITY': ['Infinity', Order.ATOMIC],
}; };
return CONSTANTS[block.getFieldValue('CONSTANT')]; return CONSTANTS[block.getFieldValue('CONSTANT')];
}; };
JavaScript.forBlock['math_number_property'] = function(block) { javascriptGenerator.forBlock['math_number_property'] = function(block) {
// Check if a number is even, odd, prime, whole, positive, or negative // Check if a number is even, odd, prime, whole, positive, or negative
// or if it is divisible by certain number. Returns true or false. // or if it is divisible by certain number. Returns true or false.
const PROPERTIES = { const PROPERTIES = {
'EVEN': [' % 2 === 0', JavaScript.ORDER_MODULUS, JavaScript.ORDER_EQUALITY], 'EVEN': [' % 2 === 0', Order.MODULUS, Order.EQUALITY],
'ODD': [' % 2 === 1', JavaScript.ORDER_MODULUS, JavaScript.ORDER_EQUALITY], 'ODD': [' % 2 === 1', Order.MODULUS, Order.EQUALITY],
'WHOLE': [' % 1 === 0', JavaScript.ORDER_MODULUS, 'WHOLE': [' % 1 === 0', Order.MODULUS,
JavaScript.ORDER_EQUALITY], Order.EQUALITY],
'POSITIVE': [' > 0', JavaScript.ORDER_RELATIONAL, 'POSITIVE': [' > 0', Order.RELATIONAL,
JavaScript.ORDER_RELATIONAL], Order.RELATIONAL],
'NEGATIVE': [' < 0', JavaScript.ORDER_RELATIONAL, 'NEGATIVE': [' < 0', Order.RELATIONAL,
JavaScript.ORDER_RELATIONAL], Order.RELATIONAL],
'DIVISIBLE_BY': [null, JavaScript.ORDER_MODULUS, JavaScript.ORDER_EQUALITY], 'DIVISIBLE_BY': [null, Order.MODULUS, Order.EQUALITY],
'PRIME': [null, JavaScript.ORDER_NONE, JavaScript.ORDER_FUNCTION_CALL], 'PRIME': [null, Order.NONE, Order.FUNCTION_CALL],
}; };
const dropdownProperty = block.getFieldValue('PROPERTY'); const dropdownProperty = block.getFieldValue('PROPERTY');
const [suffix, inputOrder, outputOrder] = PROPERTIES[dropdownProperty]; const [suffix, inputOrder, outputOrder] = PROPERTIES[dropdownProperty];
const numberToCheck = JavaScript.valueToCode(block, 'NUMBER_TO_CHECK', const numberToCheck =
inputOrder) || '0'; javascriptGenerator.valueToCode(block, 'NUMBER_TO_CHECK', inputOrder) ||
'0';
let code; let code;
if (dropdownProperty === 'PRIME') { if (dropdownProperty === 'PRIME') {
// Prime is a special case as it is not a one-liner test. // Prime is a special case as it is not a one-liner test.
const functionName = JavaScript.provideFunction_('mathIsPrime', ` const functionName = javascriptGenerator.provideFunction_('mathIsPrime', `
function ${JavaScript.FUNCTION_NAME_PLACEHOLDER_}(n) { function ${javascriptGenerator.FUNCTION_NAME_PLACEHOLDER_}(n) {
// https://en.wikipedia.org/wiki/Primality_test#Naive_methods // https://en.wikipedia.org/wiki/Primality_test#Naive_methods
if (n == 2 || n == 3) { if (n == 2 || n == 3) {
return true; return true;
@@ -189,8 +190,8 @@ function ${JavaScript.FUNCTION_NAME_PLACEHOLDER_}(n) {
`); `);
code = functionName + '(' + numberToCheck + ')'; code = functionName + '(' + numberToCheck + ')';
} else if (dropdownProperty === 'DIVISIBLE_BY') { } else if (dropdownProperty === 'DIVISIBLE_BY') {
const divisor = JavaScript.valueToCode(block, 'DIVISOR', const divisor = javascriptGenerator.valueToCode(block, 'DIVISOR',
JavaScript.ORDER_MODULUS) || '0'; Order.MODULUS) || '0';
code = numberToCheck + ' % ' + divisor + ' === 0'; code = numberToCheck + ' % ' + divisor + ' === 0';
} else { } else {
code = numberToCheck + suffix; code = numberToCheck + suffix;
@@ -198,58 +199,60 @@ function ${JavaScript.FUNCTION_NAME_PLACEHOLDER_}(n) {
return [code, outputOrder]; return [code, outputOrder];
}; };
JavaScript.forBlock['math_change'] = function(block) { javascriptGenerator.forBlock['math_change'] = function(block) {
// Add to a variable in place. // Add to a variable in place.
const argument0 = JavaScript.valueToCode(block, 'DELTA', const argument0 = javascriptGenerator.valueToCode(block, 'DELTA',
JavaScript.ORDER_ADDITION) || '0'; Order.ADDITION) || '0';
const varName = JavaScript.nameDB_.getName( const varName = javascriptGenerator.nameDB_.getName(
block.getFieldValue('VAR'), NameType.VARIABLE); block.getFieldValue('VAR'), NameType.VARIABLE);
return varName + ' = (typeof ' + varName + ' === \'number\' ? ' + varName + return varName + ' = (typeof ' + varName + ' === \'number\' ? ' + varName +
' : 0) + ' + argument0 + ';\n'; ' : 0) + ' + argument0 + ';\n';
}; };
// Rounding functions have a single operand. // Rounding functions have a single operand.
JavaScript.forBlock['math_round'] = JavaScript.forBlock['math_single']; javascriptGenerator.forBlock['math_round'] =
javascriptGenerator.forBlock['math_single'];
// Trigonometry functions have a single operand. // Trigonometry functions have a single operand.
JavaScript.forBlock['math_trig'] = JavaScript.forBlock['math_single']; javascriptGenerator.forBlock['math_trig'] =
javascriptGenerator.forBlock['math_single'];
JavaScript.forBlock['math_on_list'] = function(block) { javascriptGenerator.forBlock['math_on_list'] = function(block) {
// Math functions for lists. // Math functions for lists.
const func = block.getFieldValue('OP'); const func = block.getFieldValue('OP');
let list; let list;
let code; let code;
switch (func) { switch (func) {
case 'SUM': case 'SUM':
list = JavaScript.valueToCode(block, 'LIST', list = javascriptGenerator.valueToCode(block, 'LIST',
JavaScript.ORDER_MEMBER) || '[]'; Order.MEMBER) || '[]';
code = list + '.reduce(function(x, y) {return x + y;}, 0)'; code = list + '.reduce(function(x, y) {return x + y;}, 0)';
break; break;
case 'MIN': case 'MIN':
list = JavaScript.valueToCode(block, 'LIST', list = javascriptGenerator.valueToCode(block, 'LIST',
JavaScript.ORDER_NONE) || '[]'; Order.NONE) || '[]';
code = 'Math.min.apply(null, ' + list + ')'; code = 'Math.min.apply(null, ' + list + ')';
break; break;
case 'MAX': case 'MAX':
list = JavaScript.valueToCode(block, 'LIST', list = javascriptGenerator.valueToCode(block, 'LIST',
JavaScript.ORDER_NONE) || '[]'; Order.NONE) || '[]';
code = 'Math.max.apply(null, ' + list + ')'; code = 'Math.max.apply(null, ' + list + ')';
break; break;
case 'AVERAGE': { case 'AVERAGE': {
// mathMean([null,null,1,3]) === 2.0. // mathMean([null,null,1,3]) === 2.0.
const functionName = JavaScript.provideFunction_('mathMean', ` const functionName = javascriptGenerator.provideFunction_('mathMean', `
function ${JavaScript.FUNCTION_NAME_PLACEHOLDER_}(myList) { function ${javascriptGenerator.FUNCTION_NAME_PLACEHOLDER_}(myList) {
return myList.reduce(function(x, y) {return x + y;}, 0) / myList.length; return myList.reduce(function(x, y) {return x + y;}, 0) / myList.length;
} }
`); `);
list = JavaScript.valueToCode(block, 'LIST', list = javascriptGenerator.valueToCode(block, 'LIST',
JavaScript.ORDER_NONE) || '[]'; Order.NONE) || '[]';
code = functionName + '(' + list + ')'; code = functionName + '(' + list + ')';
break; break;
} }
case 'MEDIAN': { case 'MEDIAN': {
// mathMedian([null,null,1,3]) === 2.0. // mathMedian([null,null,1,3]) === 2.0.
const functionName = JavaScript.provideFunction_('mathMedian', ` const functionName = javascriptGenerator.provideFunction_('mathMedian', `
function ${JavaScript.FUNCTION_NAME_PLACEHOLDER_}(myList) { function ${javascriptGenerator.FUNCTION_NAME_PLACEHOLDER_}(myList) {
var localList = myList.filter(function (x) {return typeof x === 'number';}); var localList = myList.filter(function (x) {return typeof x === 'number';});
if (!localList.length) return null; if (!localList.length) return null;
localList.sort(function(a, b) {return b - a;}); localList.sort(function(a, b) {return b - a;});
@@ -260,8 +263,8 @@ function ${JavaScript.FUNCTION_NAME_PLACEHOLDER_}(myList) {
} }
} }
`); `);
list = JavaScript.valueToCode(block, 'LIST', list = javascriptGenerator.valueToCode(block, 'LIST',
JavaScript.ORDER_NONE) || '[]'; Order.NONE) || '[]';
code = functionName + '(' + list + ')'; code = functionName + '(' + list + ')';
break; break;
} }
@@ -269,8 +272,8 @@ function ${JavaScript.FUNCTION_NAME_PLACEHOLDER_}(myList) {
// As a list of numbers can contain more than one mode, // As a list of numbers can contain more than one mode,
// the returned result is provided as an array. // the returned result is provided as an array.
// Mode of [3, 'x', 'x', 1, 1, 2, '3'] -> ['x', 1]. // Mode of [3, 'x', 'x', 1, 1, 2, '3'] -> ['x', 1].
const functionName = JavaScript.provideFunction_('mathModes', ` const functionName = javascriptGenerator.provideFunction_('mathModes', `
function ${JavaScript.FUNCTION_NAME_PLACEHOLDER_}(values) { function ${javascriptGenerator.FUNCTION_NAME_PLACEHOLDER_}(values) {
var modes = []; var modes = [];
var counts = []; var counts = [];
var maxCount = 0; var maxCount = 0;
@@ -299,14 +302,15 @@ function ${JavaScript.FUNCTION_NAME_PLACEHOLDER_}(values) {
return modes; return modes;
} }
`); `);
list = JavaScript.valueToCode(block, 'LIST', list = javascriptGenerator.valueToCode(block, 'LIST',
JavaScript.ORDER_NONE) || '[]'; Order.NONE) || '[]';
code = functionName + '(' + list + ')'; code = functionName + '(' + list + ')';
break; break;
} }
case 'STD_DEV': { case 'STD_DEV': {
const functionName = JavaScript.provideFunction_('mathStandardDeviation', ` const functionName =
function ${JavaScript.FUNCTION_NAME_PLACEHOLDER_}(numbers) { javascriptGenerator.provideFunction_('mathStandardDeviation', `
function ${javascriptGenerator.FUNCTION_NAME_PLACEHOLDER_}(numbers) {
var n = numbers.length; var n = numbers.length;
if (!n) return null; if (!n) return null;
var mean = numbers.reduce(function(x, y) {return x + y;}) / n; var mean = numbers.reduce(function(x, y) {return x + y;}) / n;
@@ -318,60 +322,61 @@ function ${JavaScript.FUNCTION_NAME_PLACEHOLDER_}(numbers) {
return Math.sqrt(variance); return Math.sqrt(variance);
} }
`); `);
list = JavaScript.valueToCode(block, 'LIST', list = javascriptGenerator.valueToCode(block, 'LIST',
JavaScript.ORDER_NONE) || '[]'; Order.NONE) || '[]';
code = functionName + '(' + list + ')'; code = functionName + '(' + list + ')';
break; break;
} }
case 'RANDOM': { case 'RANDOM': {
const functionName = JavaScript.provideFunction_('mathRandomList', ` const functionName =
function ${JavaScript.FUNCTION_NAME_PLACEHOLDER_}(list) { javascriptGenerator.provideFunction_('mathRandomList', `
function ${javascriptGenerator.FUNCTION_NAME_PLACEHOLDER_}(list) {
var x = Math.floor(Math.random() * list.length); var x = Math.floor(Math.random() * list.length);
return list[x]; return list[x];
} }
`); `);
list = JavaScript.valueToCode(block, 'LIST', list = javascriptGenerator.valueToCode(block, 'LIST',
JavaScript.ORDER_NONE) || '[]'; Order.NONE) || '[]';
code = functionName + '(' + list + ')'; code = functionName + '(' + list + ')';
break; break;
} }
default: default:
throw Error('Unknown operator: ' + func); throw Error('Unknown operator: ' + func);
} }
return [code, JavaScript.ORDER_FUNCTION_CALL]; return [code, Order.FUNCTION_CALL];
}; };
JavaScript.forBlock['math_modulo'] = function(block) { javascriptGenerator.forBlock['math_modulo'] = function(block) {
// Remainder computation. // Remainder computation.
const argument0 = JavaScript.valueToCode(block, 'DIVIDEND', const argument0 = javascriptGenerator.valueToCode(block, 'DIVIDEND',
JavaScript.ORDER_MODULUS) || '0'; Order.MODULUS) || '0';
const argument1 = JavaScript.valueToCode(block, 'DIVISOR', const argument1 = javascriptGenerator.valueToCode(block, 'DIVISOR',
JavaScript.ORDER_MODULUS) || '0'; Order.MODULUS) || '0';
const code = argument0 + ' % ' + argument1; const code = argument0 + ' % ' + argument1;
return [code, JavaScript.ORDER_MODULUS]; return [code, Order.MODULUS];
}; };
JavaScript.forBlock['math_constrain'] = function(block) { javascriptGenerator.forBlock['math_constrain'] = function(block) {
// Constrain a number between two limits. // Constrain a number between two limits.
const argument0 = JavaScript.valueToCode(block, 'VALUE', const argument0 = javascriptGenerator.valueToCode(block, 'VALUE',
JavaScript.ORDER_NONE) || '0'; Order.NONE) || '0';
const argument1 = JavaScript.valueToCode(block, 'LOW', const argument1 = javascriptGenerator.valueToCode(block, 'LOW',
JavaScript.ORDER_NONE) || '0'; Order.NONE) || '0';
const argument2 = JavaScript.valueToCode(block, 'HIGH', const argument2 = javascriptGenerator.valueToCode(block, 'HIGH',
JavaScript.ORDER_NONE) || 'Infinity'; Order.NONE) || 'Infinity';
const code = 'Math.min(Math.max(' + argument0 + ', ' + argument1 + '), ' + const code = 'Math.min(Math.max(' + argument0 + ', ' + argument1 + '), ' +
argument2 + ')'; argument2 + ')';
return [code, JavaScript.ORDER_FUNCTION_CALL]; return [code, Order.FUNCTION_CALL];
}; };
JavaScript.forBlock['math_random_int'] = function(block) { javascriptGenerator.forBlock['math_random_int'] = function(block) {
// Random integer between [X] and [Y]. // Random integer between [X] and [Y].
const argument0 = JavaScript.valueToCode(block, 'FROM', const argument0 = javascriptGenerator.valueToCode(block, 'FROM',
JavaScript.ORDER_NONE) || '0'; Order.NONE) || '0';
const argument1 = JavaScript.valueToCode(block, 'TO', const argument1 = javascriptGenerator.valueToCode(block, 'TO',
JavaScript.ORDER_NONE) || '0'; Order.NONE) || '0';
const functionName = JavaScript.provideFunction_('mathRandomInt', ` const functionName = javascriptGenerator.provideFunction_('mathRandomInt', `
function ${JavaScript.FUNCTION_NAME_PLACEHOLDER_}(a, b) { function ${javascriptGenerator.FUNCTION_NAME_PLACEHOLDER_}(a, b) {
if (a > b) { if (a > b) {
// Swap a and b to ensure a is smaller. // Swap a and b to ensure a is smaller.
var c = a; var c = a;
@@ -382,20 +387,20 @@ function ${JavaScript.FUNCTION_NAME_PLACEHOLDER_}(a, b) {
} }
`); `);
const code = functionName + '(' + argument0 + ', ' + argument1 + ')'; const code = functionName + '(' + argument0 + ', ' + argument1 + ')';
return [code, JavaScript.ORDER_FUNCTION_CALL]; return [code, Order.FUNCTION_CALL];
}; };
JavaScript.forBlock['math_random_float'] = function(block) { javascriptGenerator.forBlock['math_random_float'] = function(block) {
// Random fraction between 0 and 1. // Random fraction between 0 and 1.
return ['Math.random()', JavaScript.ORDER_FUNCTION_CALL]; return ['Math.random()', Order.FUNCTION_CALL];
}; };
JavaScript.forBlock['math_atan2'] = function(block) { javascriptGenerator.forBlock['math_atan2'] = function(block) {
// Arctangent of point (X, Y) in degrees from -180 to 180. // Arctangent of point (X, Y) in degrees from -180 to 180.
const argument0 = JavaScript.valueToCode(block, 'X', const argument0 = javascriptGenerator.valueToCode(block, 'X',
JavaScript.ORDER_NONE) || '0'; Order.NONE) || '0';
const argument1 = JavaScript.valueToCode(block, 'Y', const argument1 = javascriptGenerator.valueToCode(block, 'Y',
JavaScript.ORDER_NONE) || '0'; Order.NONE) || '0';
return ['Math.atan2(' + argument1 + ', ' + argument0 + ') / Math.PI * 180', return ['Math.atan2(' + argument1 + ', ' + argument0 + ') / Math.PI * 180',
JavaScript.ORDER_DIVISION]; Order.DIVISION];
}; };

82
generators/javascript/procedures.js
View File

@@ -12,98 +12,112 @@ import * as goog from '../../closure/goog/goog.js';
goog.declareModuleId('Blockly.JavaScript.procedures'); goog.declareModuleId('Blockly.JavaScript.procedures');
import {NameType} from '../../core/names.js'; import {NameType} from '../../core/names.js';
import {javascriptGenerator as JavaScript} from '../javascript.js'; import {Order, javascriptGenerator} from '../javascript.js';
JavaScript.forBlock['procedures_defreturn'] = function(block) { javascriptGenerator.forBlock['procedures_defreturn'] = function(block) {
// Define a procedure with a return value. // Define a procedure with a return value.
const funcName = JavaScript.nameDB_.getName( const funcName = javascriptGenerator.nameDB_.getName(
block.getFieldValue('NAME'), NameType.PROCEDURE); block.getFieldValue('NAME'), NameType.PROCEDURE);
let xfix1 = ''; let xfix1 = '';
if (JavaScript.STATEMENT_PREFIX) { if (javascriptGenerator.STATEMENT_PREFIX) {
xfix1 += JavaScript.injectId(JavaScript.STATEMENT_PREFIX, block); xfix1 += javascriptGenerator.injectId(
javascriptGenerator.STATEMENT_PREFIX, block);
} }
if (JavaScript.STATEMENT_SUFFIX) { if (javascriptGenerator.STATEMENT_SUFFIX) {
xfix1 += JavaScript.injectId(JavaScript.STATEMENT_SUFFIX, block); xfix1 += javascriptGenerator.injectId(
javascriptGenerator.STATEMENT_SUFFIX, block);
} }
if (xfix1) { if (xfix1) {
xfix1 = JavaScript.prefixLines(xfix1, JavaScript.INDENT); xfix1 = javascriptGenerator.prefixLines(xfix1, javascriptGenerator.INDENT);
} }
let loopTrap = ''; let loopTrap = '';
if (JavaScript.INFINITE_LOOP_TRAP) { if (javascriptGenerator.INFINITE_LOOP_TRAP) {
loopTrap = JavaScript.prefixLines( loopTrap = javascriptGenerator.prefixLines(
JavaScript.injectId(JavaScript.INFINITE_LOOP_TRAP, block), javascriptGenerator.injectId(
JavaScript.INDENT); javascriptGenerator.INFINITE_LOOP_TRAP, block),
javascriptGenerator.INDENT);
} }
const branch = JavaScript.statementToCode(block, 'STACK'); const branch = javascriptGenerator.statementToCode(block, 'STACK');
let returnValue = let returnValue =
JavaScript.valueToCode(block, 'RETURN', JavaScript.ORDER_NONE) || ''; javascriptGenerator.valueToCode(block, 'RETURN', Order.NONE) || '';
let xfix2 = ''; let xfix2 = '';
if (branch && returnValue) { if (branch && returnValue) {
// After executing the function body, revisit this block for the return. // After executing the function body, revisit this block for the return.
xfix2 = xfix1; xfix2 = xfix1;
} }
if (returnValue) { if (returnValue) {
returnValue = JavaScript.INDENT + 'return ' + returnValue + ';\n'; returnValue = javascriptGenerator.INDENT + 'return ' + returnValue + ';\n';
} }
const args = []; const args = [];
const variables = block.getVars(); const variables = block.getVars();
for (let i = 0; i < variables.length; i++) { for (let i = 0; i < variables.length; i++) {
args[i] = JavaScript.nameDB_.getName(variables[i], NameType.VARIABLE); args[i] =
javascriptGenerator.nameDB_.getName(variables[i], NameType.VARIABLE);
} }
let code = 'function ' + funcName + '(' + args.join(', ') + ') {\n' + xfix1 + let code = 'function ' + funcName + '(' + args.join(', ') + ') {\n' + xfix1 +
loopTrap + branch + xfix2 + returnValue + '}'; loopTrap + branch + xfix2 + returnValue + '}';
code = JavaScript.scrub_(block, code); code = javascriptGenerator.scrub_(block, code);
// Add % so as not to collide with helper functions in definitions list. // Add % so as not to collide with helper functions in definitions list.
JavaScript.definitions_['%' + funcName] = code; javascriptGenerator.definitions_['%' + funcName] = code;
return null; return null;
}; };
// Defining a procedure without a return value uses the same generator as // Defining a procedure without a return value uses the same generator as
// a procedure with a return value. // a procedure with a return value.
JavaScript.forBlock['procedures_defnoreturn'] = JavaScript.forBlock['procedures_defreturn']; javascriptGenerator.forBlock['procedures_defnoreturn'] =
javascriptGenerator.forBlock['procedures_defreturn'];
JavaScript.forBlock['procedures_callreturn'] = function(block) { javascriptGenerator.forBlock['procedures_callreturn'] = function(block) {
// Call a procedure with a return value. // Call a procedure with a return value.
const funcName = JavaScript.nameDB_.getName( const funcName = javascriptGenerator.nameDB_.getName(
block.getFieldValue('NAME'), NameType.PROCEDURE); block.getFieldValue('NAME'), NameType.PROCEDURE);
const args = []; const args = [];
const variables = block.getVars(); const variables = block.getVars();
for (let i = 0; i < variables.length; i++) { for (let i = 0; i < variables.length; i++) {
args[i] = JavaScript.valueToCode(block, 'ARG' + i, JavaScript.ORDER_NONE) || args[i] = javascriptGenerator.valueToCode(block, 'ARG' + i, Order.NONE) ||
'null'; 'null';
} }
const code = funcName + '(' + args.join(', ') + ')'; const code = funcName + '(' + args.join(', ') + ')';
return [code, JavaScript.ORDER_FUNCTION_CALL]; return [code, Order.FUNCTION_CALL];
}; };
JavaScript.forBlock['procedures_callnoreturn'] = function(block) { javascriptGenerator.forBlock['procedures_callnoreturn'] = function(block) {
// Call a procedure with no return value. // Call a procedure with no return value.
// Generated code is for a function call as a statement is the same as a // Generated code is for a function call as a statement is the same as a
// function call as a value, with the addition of line ending. // function call as a value, with the addition of line ending.
const tuple = JavaScript.forBlock['procedures_callreturn'](block); const tuple = javascriptGenerator.forBlock['procedures_callreturn'](block);
return tuple[0] + ';\n'; return tuple[0] + ';\n';
}; };
JavaScript.forBlock['procedures_ifreturn'] = function(block) { javascriptGenerator.forBlock['procedures_callnoreturn'] = function(block) {
// Call a procedure with no return value.
// Generated code is for a function call as a statement is the same as a
// function call as a value, with the addition of line ending.
const tuple = javascriptGenerator.forBlock['procedures_callreturn'](block);
return tuple[0] + ';\n';
};
javascriptGenerator.forBlock['procedures_ifreturn'] = function(block) {
// Conditionally return value from a procedure. // Conditionally return value from a procedure.
const condition = const condition =
JavaScript.valueToCode(block, 'CONDITION', JavaScript.ORDER_NONE) || javascriptGenerator.valueToCode(block, 'CONDITION', Order.NONE) ||
'false'; 'false';
let code = 'if (' + condition + ') {\n'; let code = 'if (' + condition + ') {\n';
if (JavaScript.STATEMENT_SUFFIX) { if (javascriptGenerator.STATEMENT_SUFFIX) {
// Inject any statement suffix here since the regular one at the end // Inject any statement suffix here since the regular one at the end
// will not get executed if the return is triggered. // will not get executed if the return is triggered.
code += JavaScript.prefixLines( code += javascriptGenerator.prefixLines(
JavaScript.injectId(JavaScript.STATEMENT_SUFFIX, block), javascriptGenerator.injectId(
JavaScript.INDENT); javascriptGenerator.STATEMENT_SUFFIX, block),
javascriptGenerator.INDENT);
} }
if (block.hasReturnValue_) { if (block.hasReturnValue_) {
const value = const value =
JavaScript.valueToCode(block, 'VALUE', JavaScript.ORDER_NONE) || 'null'; javascriptGenerator.valueToCode(block, 'VALUE', Order.NONE) || 'null';
code += JavaScript.INDENT + 'return ' + value + ';\n'; code += javascriptGenerator.INDENT + 'return ' + value + ';\n';
} else { } else {
code += JavaScript.INDENT + 'return;\n'; code += javascriptGenerator.INDENT + 'return;\n';
} }
code += '}\n'; code += '}\n';
return code; return code;

227
generators/javascript/text.js
View File

@@ -12,7 +12,7 @@ import * as goog from '../../closure/goog/goog.js';
goog.declareModuleId('Blockly.JavaScript.texts'); goog.declareModuleId('Blockly.JavaScript.texts');
import {NameType} from '../../core/names.js'; import {NameType} from '../../core/names.js';
import {javascriptGenerator as JavaScript} from '../javascript.js'; import {Order, javascriptGenerator} from '../javascript.js';
/** /**
@@ -29,9 +29,9 @@ const strRegExp = /^\s*'([^']|\\')*'\s*$/;
*/ */
const forceString = function(value) { const forceString = function(value) {
if (strRegExp.test(value)) { if (strRegExp.test(value)) {
return [value, JavaScript.ORDER_ATOMIC]; return [value, Order.ATOMIC];
} }
return ['String(' + value + ')', JavaScript.ORDER_FUNCTION_CALL]; return ['String(' + value + ')', Order.FUNCTION_CALL];
}; };
/** /**
@@ -53,158 +53,162 @@ const getSubstringIndex = function(stringName, where, opt_at) {
} }
}; };
JavaScript.forBlock['text'] = function(block) { javascriptGenerator.forBlock['text'] = function(block) {
// Text value. // Text value.
const code = JavaScript.quote_(block.getFieldValue('TEXT')); const code = javascriptGenerator.quote_(block.getFieldValue('TEXT'));
return [code, JavaScript.ORDER_ATOMIC]; return [code, Order.ATOMIC];
}; };
JavaScript.forBlock['text_multiline'] = function(block) { javascriptGenerator.forBlock['text_multiline'] = function(block) {
// Text value. // Text value.
const code = JavaScript.multiline_quote_(block.getFieldValue('TEXT')); const code =
const order = code.indexOf('+') !== -1 ? JavaScript.ORDER_ADDITION : javascriptGenerator.multiline_quote_(block.getFieldValue('TEXT'));
JavaScript.ORDER_ATOMIC; const order = code.indexOf('+') !== -1 ? Order.ADDITION :
Order.ATOMIC;
return [code, order]; return [code, order];
}; };
JavaScript.forBlock['text_join'] = function(block) { javascriptGenerator.forBlock['text_join'] = function(block) {
// Create a string made up of any number of elements of any type. // Create a string made up of any number of elements of any type.
switch (block.itemCount_) { switch (block.itemCount_) {
case 0: case 0:
return ["''", JavaScript.ORDER_ATOMIC]; return ["''", Order.ATOMIC];
case 1: { case 1: {
const element = JavaScript.valueToCode(block, 'ADD0', const element = javascriptGenerator.valueToCode(block, 'ADD0',
JavaScript.ORDER_NONE) || "''"; Order.NONE) || "''";
const codeAndOrder = forceString(element); const codeAndOrder = forceString(element);
return codeAndOrder; return codeAndOrder;
} }
case 2: { case 2: {
const element0 = JavaScript.valueToCode(block, 'ADD0', const element0 = javascriptGenerator.valueToCode(block, 'ADD0',
JavaScript.ORDER_NONE) || "''"; Order.NONE) || "''";
const element1 = JavaScript.valueToCode(block, 'ADD1', const element1 = javascriptGenerator.valueToCode(block, 'ADD1',
JavaScript.ORDER_NONE) || "''"; Order.NONE) || "''";
const code = forceString(element0)[0] + const code = forceString(element0)[0] +
' + ' + forceString(element1)[0]; ' + ' + forceString(element1)[0];
return [code, JavaScript.ORDER_ADDITION]; return [code, Order.ADDITION];
} }
default: { default: {
const elements = new Array(block.itemCount_); const elements = new Array(block.itemCount_);
for (let i = 0; i < block.itemCount_; i++) { for (let i = 0; i < block.itemCount_; i++) {
elements[i] = JavaScript.valueToCode(block, 'ADD' + i, elements[i] = javascriptGenerator.valueToCode(block, 'ADD' + i,
JavaScript.ORDER_NONE) || "''"; Order.NONE) || "''";
} }
const code = '[' + elements.join(',') + '].join(\'\')'; const code = '[' + elements.join(',') + '].join(\'\')';
return [code, JavaScript.ORDER_FUNCTION_CALL]; return [code, Order.FUNCTION_CALL];
} }
} }
}; };
JavaScript.forBlock['text_append'] = function(block) { javascriptGenerator.forBlock['text_append'] = function(block) {
// Append to a variable in place. // Append to a variable in place.
const varName = JavaScript.nameDB_.getName( const varName = javascriptGenerator.nameDB_.getName(
block.getFieldValue('VAR'), NameType.VARIABLE); block.getFieldValue('VAR'), NameType.VARIABLE);
const value = JavaScript.valueToCode(block, 'TEXT', const value = javascriptGenerator.valueToCode(block, 'TEXT',
JavaScript.ORDER_NONE) || "''"; Order.NONE) || "''";
const code = varName + ' += ' + const code = varName + ' += ' +
forceString(value)[0] + ';\n'; forceString(value)[0] + ';\n';
return code; return code;
}; };
JavaScript.forBlock['text_length'] = function(block) { javascriptGenerator.forBlock['text_length'] = function(block) {
// String or array length. // String or array length.
const text = JavaScript.valueToCode(block, 'VALUE', const text = javascriptGenerator.valueToCode(block, 'VALUE',
JavaScript.ORDER_MEMBER) || "''"; Order.MEMBER) || "''";
return [text + '.length', JavaScript.ORDER_MEMBER]; return [text + '.length', Order.MEMBER];
}; };
JavaScript.forBlock['text_isEmpty'] = function(block) { javascriptGenerator.forBlock['text_isEmpty'] = function(block) {
// Is the string null or array empty? // Is the string null or array empty?
const text = JavaScript.valueToCode(block, 'VALUE', const text = javascriptGenerator.valueToCode(block, 'VALUE',
JavaScript.ORDER_MEMBER) || "''"; Order.MEMBER) || "''";
return ['!' + text + '.length', JavaScript.ORDER_LOGICAL_NOT]; return ['!' + text + '.length', Order.LOGICAL_NOT];
}; };
JavaScript.forBlock['text_indexOf'] = function(block) { javascriptGenerator.forBlock['text_indexOf'] = function(block) {
// Search the text for a substring. // Search the text for a substring.
const operator = block.getFieldValue('END') === 'FIRST' ? const operator = block.getFieldValue('END') === 'FIRST' ?
'indexOf' : 'lastIndexOf'; 'indexOf' : 'lastIndexOf';
const substring = JavaScript.valueToCode(block, 'FIND', const substring = javascriptGenerator.valueToCode(block, 'FIND',
JavaScript.ORDER_NONE) || "''"; Order.NONE) || "''";
const text = JavaScript.valueToCode(block, 'VALUE', const text = javascriptGenerator.valueToCode(block, 'VALUE',
JavaScript.ORDER_MEMBER) || "''"; Order.MEMBER) || "''";
const code = text + '.' + operator + '(' + substring + ')'; const code = text + '.' + operator + '(' + substring + ')';
// Adjust index if using one-based indices. // Adjust index if using one-based indices.
if (block.workspace.options.oneBasedIndex) { if (block.workspace.options.oneBasedIndex) {
return [code + ' + 1', JavaScript.ORDER_ADDITION]; return [code + ' + 1', Order.ADDITION];
} }
return [code, JavaScript.ORDER_FUNCTION_CALL]; return [code, Order.FUNCTION_CALL];
}; };
JavaScript.forBlock['text_charAt'] = function(block) { javascriptGenerator.forBlock['text_charAt'] = function(block) {
// Get letter at index. // Get letter at index.
// Note: Until January 2013 this block did not have the WHERE input. // Note: Until January 2013 this block did not have the WHERE input.
const where = block.getFieldValue('WHERE') || 'FROM_START'; const where = block.getFieldValue('WHERE') || 'FROM_START';
const textOrder = (where === 'RANDOM') ? JavaScript.ORDER_NONE : const textOrder = (where === 'RANDOM') ? Order.NONE :
JavaScript.ORDER_MEMBER; Order.MEMBER;
const text = JavaScript.valueToCode(block, 'VALUE', textOrder) || "''"; const text =
javascriptGenerator.valueToCode(block, 'VALUE', textOrder) || "''";
switch (where) { switch (where) {
case 'FIRST': { case 'FIRST': {
const code = text + '.charAt(0)'; const code = text + '.charAt(0)';
return [code, JavaScript.ORDER_FUNCTION_CALL]; return [code, Order.FUNCTION_CALL];
} }
case 'LAST': { case 'LAST': {
const code = text + '.slice(-1)'; const code = text + '.slice(-1)';
return [code, JavaScript.ORDER_FUNCTION_CALL]; return [code, Order.FUNCTION_CALL];
} }
case 'FROM_START': { case 'FROM_START': {
const at = JavaScript.getAdjusted(block, 'AT'); const at = javascriptGenerator.getAdjusted(block, 'AT');
// Adjust index if using one-based indices. // Adjust index if using one-based indices.
const code = text + '.charAt(' + at + ')'; const code = text + '.charAt(' + at + ')';
return [code, JavaScript.ORDER_FUNCTION_CALL]; return [code, Order.FUNCTION_CALL];
} }
case 'FROM_END': { case 'FROM_END': {
const at = JavaScript.getAdjusted(block, 'AT', 1, true); const at = javascriptGenerator.getAdjusted(block, 'AT', 1, true);
const code = text + '.slice(' + at + ').charAt(0)'; const code = text + '.slice(' + at + ').charAt(0)';
return [code, JavaScript.ORDER_FUNCTION_CALL]; return [code, Order.FUNCTION_CALL];
} }
case 'RANDOM': { case 'RANDOM': {
const functionName = JavaScript.provideFunction_('textRandomLetter', ` const functionName =
function ${JavaScript.FUNCTION_NAME_PLACEHOLDER_}(text) { javascriptGenerator.provideFunction_('textRandomLetter', `
function ${javascriptGenerator.FUNCTION_NAME_PLACEHOLDER_}(text) {
var x = Math.floor(Math.random() * text.length); var x = Math.floor(Math.random() * text.length);
return text[x]; return text[x];
} }
`); `);
const code = functionName + '(' + text + ')'; const code = functionName + '(' + text + ')';
return [code, JavaScript.ORDER_FUNCTION_CALL]; return [code, Order.FUNCTION_CALL];
} }
} }
throw Error('Unhandled option (text_charAt).'); throw Error('Unhandled option (text_charAt).');
}; };
JavaScript.forBlock['text_getSubstring'] = function(block) { javascriptGenerator.forBlock['text_getSubstring'] = function(block) {
// Get substring. // Get substring.
const where1 = block.getFieldValue('WHERE1'); const where1 = block.getFieldValue('WHERE1');
const where2 = block.getFieldValue('WHERE2'); const where2 = block.getFieldValue('WHERE2');
const requiresLengthCall = (where1 !== 'FROM_END' && where1 !== 'LAST' && const requiresLengthCall = (where1 !== 'FROM_END' && where1 !== 'LAST' &&
where2 !== 'FROM_END' && where2 !== 'LAST'); where2 !== 'FROM_END' && where2 !== 'LAST');
const textOrder = requiresLengthCall ? JavaScript.ORDER_MEMBER : const textOrder = requiresLengthCall ? Order.MEMBER :
JavaScript.ORDER_NONE; Order.NONE;
const text = JavaScript.valueToCode(block, 'STRING', textOrder) || "''"; const text =
javascriptGenerator.valueToCode(block, 'STRING', textOrder) || "''";
let code; let code;
if (where1 === 'FIRST' && where2 === 'LAST') { if (where1 === 'FIRST' && where2 === 'LAST') {
code = text; code = text;
return [code, JavaScript.ORDER_NONE]; return [code, Order.NONE];
} else if (text.match(/^'?\w+'?$/) || requiresLengthCall) { } else if (text.match(/^'?\w+'?$/) || requiresLengthCall) {
// If the text is a variable or literal or doesn't require a call for // If the text is a variable or literal or doesn't require a call for
// length, don't generate a helper function. // length, don't generate a helper function.
let at1; let at1;
switch (where1) { switch (where1) {
case 'FROM_START': case 'FROM_START':
at1 = JavaScript.getAdjusted(block, 'AT1'); at1 = javascriptGenerator.getAdjusted(block, 'AT1');
break; break;
case 'FROM_END': case 'FROM_END':
at1 = JavaScript.getAdjusted(block, 'AT1', 1, false, at1 = javascriptGenerator.getAdjusted(block, 'AT1', 1, false,
JavaScript.ORDER_SUBTRACTION); Order.SUBTRACTION);
at1 = text + '.length - ' + at1; at1 = text + '.length - ' + at1;
break; break;
case 'FIRST': case 'FIRST':
@@ -216,11 +220,11 @@ JavaScript.forBlock['text_getSubstring'] = function(block) {
let at2; let at2;
switch (where2) { switch (where2) {
case 'FROM_START': case 'FROM_START':
at2 = JavaScript.getAdjusted(block, 'AT2', 1); at2 = javascriptGenerator.getAdjusted(block, 'AT2', 1);
break; break;
case 'FROM_END': case 'FROM_END':
at2 = JavaScript.getAdjusted(block, 'AT2', 0, false, at2 = javascriptGenerator.getAdjusted(block, 'AT2', 0, false,
JavaScript.ORDER_SUBTRACTION); Order.SUBTRACTION);
at2 = text + '.length - ' + at2; at2 = text + '.length - ' + at2;
break; break;
case 'LAST': case 'LAST':
@@ -231,8 +235,8 @@ JavaScript.forBlock['text_getSubstring'] = function(block) {
} }
code = text + '.slice(' + at1 + ', ' + at2 + ')'; code = text + '.slice(' + at1 + ', ' + at2 + ')';
} else { } else {
const at1 = JavaScript.getAdjusted(block, 'AT1'); const at1 = javascriptGenerator.getAdjusted(block, 'AT1');
const at2 = JavaScript.getAdjusted(block, 'AT2'); const at2 = javascriptGenerator.getAdjusted(block, 'AT2');
const wherePascalCase = {'FIRST': 'First', 'LAST': 'Last', const wherePascalCase = {'FIRST': 'First', 'LAST': 'Last',
'FROM_START': 'FromStart', 'FROM_END': 'FromEnd'}; 'FROM_START': 'FromStart', 'FROM_END': 'FromEnd'};
// The value for 'FROM_END' and'FROM_START' depends on `at` so // The value for 'FROM_END' and'FROM_START' depends on `at` so
@@ -241,9 +245,9 @@ JavaScript.forBlock['text_getSubstring'] = function(block) {
(where1 === 'FROM_END' || where1 === 'FROM_START') ? ', at1' : ''; (where1 === 'FROM_END' || where1 === 'FROM_START') ? ', at1' : '';
const at2Param = const at2Param =
(where2 === 'FROM_END' || where2 === 'FROM_START') ? ', at2' : ''; (where2 === 'FROM_END' || where2 === 'FROM_START') ? ', at2' : '';
const functionName = JavaScript.provideFunction_( const functionName = javascriptGenerator.provideFunction_(
'subsequence' + wherePascalCase[where1] + wherePascalCase[where2], ` 'subsequence' + wherePascalCase[where1] + wherePascalCase[where2], `
function ${JavaScript.FUNCTION_NAME_PLACEHOLDER_}(sequence${at1Param}${at2Param}) { function ${javascriptGenerator.FUNCTION_NAME_PLACEHOLDER_}(sequence${at1Param}${at2Param}) {
var start = ${getSubstringIndex('sequence', where1, 'at1')}; var start = ${getSubstringIndex('sequence', where1, 'at1')};
var end = ${getSubstringIndex('sequence', where2, 'at2')} + 1; var end = ${getSubstringIndex('sequence', where2, 'at2')} + 1;
return sequence.slice(start, end); return sequence.slice(start, end);
@@ -256,10 +260,10 @@ function ${JavaScript.FUNCTION_NAME_PLACEHOLDER_}(sequence${at1Param}${at2Param}
((where2 === 'FROM_END' || where2 === 'FROM_START') ? ', ' + at2 : '') + ((where2 === 'FROM_END' || where2 === 'FROM_START') ? ', ' + at2 : '') +
')'; ')';
} }
return [code, JavaScript.ORDER_FUNCTION_CALL]; return [code, Order.FUNCTION_CALL];
}; };
JavaScript.forBlock['text_changeCase'] = function(block) { javascriptGenerator.forBlock['text_changeCase'] = function(block) {
// Change capitalization. // Change capitalization.
const OPERATORS = { const OPERATORS = {
'UPPERCASE': '.toUpperCase()', 'UPPERCASE': '.toUpperCase()',
@@ -267,26 +271,28 @@ JavaScript.forBlock['text_changeCase'] = function(block) {
'TITLECASE': null, 'TITLECASE': null,
}; };
const operator = OPERATORS[block.getFieldValue('CASE')]; const operator = OPERATORS[block.getFieldValue('CASE')];
const textOrder = operator ? JavaScript.ORDER_MEMBER : JavaScript.ORDER_NONE; const textOrder = operator ? Order.MEMBER : Order.NONE;
const text = JavaScript.valueToCode(block, 'TEXT', textOrder) || "''"; const text =
javascriptGenerator.valueToCode(block, 'TEXT', textOrder) || "''";
let code; let code;
if (operator) { if (operator) {
// Upper and lower case are functions built into JavaScript. // Upper and lower case are functions built into javascriptGenerator.
code = text + operator; code = text + operator;
} else { } else {
// Title case is not a native JavaScript function. Define one. // Title case is not a native JavaScript function. Define one.
const functionName = JavaScript.provideFunction_('textToTitleCase', ` const functionName =
function ${JavaScript.FUNCTION_NAME_PLACEHOLDER_}(str) { javascriptGenerator.provideFunction_('textToTitleCase', `
function ${javascriptGenerator.FUNCTION_NAME_PLACEHOLDER_}(str) {
return str.replace(/\\S+/g, return str.replace(/\\S+/g,
function(txt) {return txt[0].toUpperCase() + txt.substring(1).toLowerCase();}); function(txt) {return txt[0].toUpperCase() + txt.substring(1).toLowerCase();});
} }
`); `);
code = functionName + '(' + text + ')'; code = functionName + '(' + text + ')';
} }
return [code, JavaScript.ORDER_FUNCTION_CALL]; return [code, Order.FUNCTION_CALL];
}; };
JavaScript.forBlock['text_trim'] = function(block) { javascriptGenerator.forBlock['text_trim'] = function(block) {
// Trim spaces. // Trim spaces.
const OPERATORS = { const OPERATORS = {
'LEFT': ".replace(/^[\\s\\xa0]+/, '')", 'LEFT': ".replace(/^[\\s\\xa0]+/, '')",
@@ -294,45 +300,46 @@ JavaScript.forBlock['text_trim'] = function(block) {
'BOTH': '.trim()', 'BOTH': '.trim()',
}; };
const operator = OPERATORS[block.getFieldValue('MODE')]; const operator = OPERATORS[block.getFieldValue('MODE')];
const text = JavaScript.valueToCode(block, 'TEXT', const text = javascriptGenerator.valueToCode(block, 'TEXT',
JavaScript.ORDER_MEMBER) || "''"; Order.MEMBER) || "''";
return [text + operator, JavaScript.ORDER_FUNCTION_CALL]; return [text + operator, Order.FUNCTION_CALL];
}; };
JavaScript.forBlock['text_print'] = function(block) { javascriptGenerator.forBlock['text_print'] = function(block) {
// Print statement. // Print statement.
const msg = JavaScript.valueToCode(block, 'TEXT', const msg = javascriptGenerator.valueToCode(block, 'TEXT',
JavaScript.ORDER_NONE) || "''"; Order.NONE) || "''";
return 'window.alert(' + msg + ');\n'; return 'window.alert(' + msg + ');\n';
}; };
JavaScript.forBlock['text_prompt_ext'] = function(block) { javascriptGenerator.forBlock['text_prompt_ext'] = function(block) {
// Prompt function. // Prompt function.
let msg; let msg;
if (block.getField('TEXT')) { if (block.getField('TEXT')) {
// Internal message. // Internal message.
msg = JavaScript.quote_(block.getFieldValue('TEXT')); msg = javascriptGenerator.quote_(block.getFieldValue('TEXT'));
} else { } else {
// External message. // External message.
msg = JavaScript.valueToCode(block, 'TEXT', JavaScript.ORDER_NONE) || "''"; msg = javascriptGenerator.valueToCode(block, 'TEXT', Order.NONE) || "''";
} }
let code = 'window.prompt(' + msg + ')'; let code = 'window.prompt(' + msg + ')';
const toNumber = block.getFieldValue('TYPE') === 'NUMBER'; const toNumber = block.getFieldValue('TYPE') === 'NUMBER';
if (toNumber) { if (toNumber) {
code = 'Number(' + code + ')'; code = 'Number(' + code + ')';
} }
return [code, JavaScript.ORDER_FUNCTION_CALL]; return [code, Order.FUNCTION_CALL];
}; };
JavaScript.forBlock['text_prompt'] = JavaScript.forBlock['text_prompt_ext']; javascriptGenerator.forBlock['text_prompt'] =
javascriptGenerator.forBlock['text_prompt_ext'];
JavaScript.forBlock['text_count'] = function(block) { javascriptGenerator.forBlock['text_count'] = function(block) {
const text = JavaScript.valueToCode(block, 'TEXT', const text = javascriptGenerator.valueToCode(block, 'TEXT',
JavaScript.ORDER_NONE) || "''"; Order.NONE) || "''";
const sub = JavaScript.valueToCode(block, 'SUB', const sub = javascriptGenerator.valueToCode(block, 'SUB',
JavaScript.ORDER_NONE) || "''"; Order.NONE) || "''";
const functionName = JavaScript.provideFunction_('textCount', ` const functionName = javascriptGenerator.provideFunction_('textCount', `
function ${JavaScript.FUNCTION_NAME_PLACEHOLDER_}(haystack, needle) { function ${javascriptGenerator.FUNCTION_NAME_PLACEHOLDER_}(haystack, needle) {
if (needle.length === 0) { if (needle.length === 0) {
return haystack.length + 1; return haystack.length + 1;
} else { } else {
@@ -341,31 +348,31 @@ function ${JavaScript.FUNCTION_NAME_PLACEHOLDER_}(haystack, needle) {
} }
`); `);
const code = functionName + '(' + text + ', ' + sub + ')'; const code = functionName + '(' + text + ', ' + sub + ')';
return [code, JavaScript.ORDER_FUNCTION_CALL]; return [code, Order.FUNCTION_CALL];
}; };
JavaScript.forBlock['text_replace'] = function(block) { javascriptGenerator.forBlock['text_replace'] = function(block) {
const text = JavaScript.valueToCode(block, 'TEXT', const text = javascriptGenerator.valueToCode(block, 'TEXT',
JavaScript.ORDER_NONE) || "''"; Order.NONE) || "''";
const from = JavaScript.valueToCode(block, 'FROM', const from = javascriptGenerator.valueToCode(block, 'FROM',
JavaScript.ORDER_NONE) || "''"; Order.NONE) || "''";
const to = JavaScript.valueToCode(block, 'TO', JavaScript.ORDER_NONE) || "''"; const to = javascriptGenerator.valueToCode(block, 'TO', Order.NONE) || "''";
// The regex escaping code below is taken from the implementation of // The regex escaping code below is taken from the implementation of
// goog.string.regExpEscape. // goog.string.regExpEscape.
const functionName = JavaScript.provideFunction_('textReplace', ` const functionName = javascriptGenerator.provideFunction_('textReplace', `
function ${JavaScript.FUNCTION_NAME_PLACEHOLDER_}(haystack, needle, replacement) { function ${javascriptGenerator.FUNCTION_NAME_PLACEHOLDER_}(haystack, needle, replacement) {
needle = needle.replace(/([-()\\[\\]{}+?*.$\\^|,:#<!\\\\])/g, '\\\\$1') needle = needle.replace(/([-()\\[\\]{}+?*.$\\^|,:#<!\\\\])/g, '\\\\$1')
.replace(/\\x08/g, '\\\\x08'); .replace(/\\x08/g, '\\\\x08');
return haystack.replace(new RegExp(needle, 'g'), replacement); return haystack.replace(new RegExp(needle, 'g'), replacement);
} }
`); `);
const code = functionName + '(' + text + ', ' + from + ', ' + to + ')'; const code = functionName + '(' + text + ', ' + from + ', ' + to + ')';
return [code, JavaScript.ORDER_FUNCTION_CALL]; return [code, Order.FUNCTION_CALL];
}; };
JavaScript.forBlock['text_reverse'] = function(block) { javascriptGenerator.forBlock['text_reverse'] = function(block) {
const text = JavaScript.valueToCode(block, 'TEXT', const text = javascriptGenerator.valueToCode(block, 'TEXT',
JavaScript.ORDER_MEMBER) || "''"; Order.MEMBER) || "''";
const code = text + ".split('').reverse().join('')"; const code = text + ".split('').reverse().join('')";
return [code, JavaScript.ORDER_FUNCTION_CALL]; return [code, Order.FUNCTION_CALL];
}; };

16
generators/javascript/variables.js
View File

@@ -12,21 +12,21 @@ import * as goog from '../../closure/goog/goog.js';
goog.declareModuleId('Blockly.JavaScript.variables'); goog.declareModuleId('Blockly.JavaScript.variables');
import {NameType} from '../../core/names.js'; import {NameType} from '../../core/names.js';
import {javascriptGenerator as JavaScript} from '../javascript.js'; import {Order, javascriptGenerator} from '../javascript.js';
JavaScript.forBlock['variables_get'] = function(block) { javascriptGenerator.forBlock['variables_get'] = function(block) {
// Variable getter. // Variable getter.
const code = JavaScript.nameDB_.getName(block.getFieldValue('VAR'), const code = javascriptGenerator.nameDB_.getName(block.getFieldValue('VAR'),
NameType.VARIABLE); NameType.VARIABLE);
return [code, JavaScript.ORDER_ATOMIC]; return [code, Order.ATOMIC];
}; };
JavaScript.forBlock['variables_set'] = function(block) { javascriptGenerator.forBlock['variables_set'] = function(block) {
// Variable setter. // Variable setter.
const argument0 = JavaScript.valueToCode( const argument0 = javascriptGenerator.valueToCode(
block, 'VALUE', JavaScript.ORDER_ASSIGNMENT) || '0'; block, 'VALUE', Order.ASSIGNMENT) || '0';
const varName = JavaScript.nameDB_.getName( const varName = javascriptGenerator.nameDB_.getName(
block.getFieldValue('VAR'), NameType.VARIABLE); block.getFieldValue('VAR'), NameType.VARIABLE);
return varName + ' = ' + argument0 + ';\n'; return varName + ' = ' + argument0 + ';\n';
}; };

9
generators/javascript/variables_dynamic.js
View File

@@ -11,10 +11,11 @@
import * as goog from '../../closure/goog/goog.js'; import * as goog from '../../closure/goog/goog.js';
goog.declareModuleId('Blockly.JavaScript.variablesDynamic'); goog.declareModuleId('Blockly.JavaScript.variablesDynamic');
import {javascriptGenerator as JavaScript} from '../javascript.js'; import {javascriptGenerator} from '../javascript.js';
import './variables.js'; import './variables.js';
// JavaScript is dynamically typed. // JavaScript is dynamically typed.
JavaScript.forBlock['variables_get_dynamic'] = JavaScript.forBlock['variables_get']; javascriptGenerator.forBlock['variables_get_dynamic'] =
JavaScript.forBlock['variables_set_dynamic'] = JavaScript.forBlock['variables_set']; javascriptGenerator.forBlock['variables_get'];
javascriptGenerator.forBlock['variables_set_dynamic'] =
javascriptGenerator.forBlock['variables_set'];