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

refactor(generators): Restructure generator modules to contain side effects (#7173)

Browse Source 
* refactor(generators): Move lang.js -> lang/lang_gernator.js

  Move the LangGenerator definitions into their respective
  subdirectories and add a _generator suffix to their filenames,
  i.e. generators/javascript.js  becomes
  generators/javascript/javascript_generator.js.

  This is to keep related code together and allow the `lang/all.js`
  entrypoints to be moved to the top level generators/ directory.

  No goog module IDs were changed, so playground and test code
  that accesses this modules by filename does not need to be modified.

* refactor(generators) Move lang/all.js -> lang.js

  - Move the entrypoints in generators/*/all.js to correspondingly-named
    files in generators/ instead—i.e., generators/javascript/all.js
    becomes generators/javascript.js.

  - Update build_tasks.js accordingly.

* fix(generators): Add missing exports for LuaGenerator, PhpGenerator

  These were inadvertently omitted from #7161 and #7162, respectively.

* refactor(generators): Make block generator modules side-effect free

  - Move declaration of <lang>Generator instance from
    generators/<lang>/<lang>_generator.js to generators/<lang>.js.
  - Move .addReservedWords() calls from generators/<lang>/*.js to
    generators/<lang>.js
  - Modify generators/<lang>/*.js to export block generator functions
    individually, rather than installing on <lang>Generator instance.
  - Modify generators/<lang>.js to import and install block generator
    functions on <lang>Generator instance.

* fix(tests): Fix tests broken by restructuring of generators

  Where these tests needed block generator functions preinstalled
  they should have been importing the Blockly.<Lang>.all module.

  Where they do not need the provided block generator functions
  they can now create their own empty <Lang>Generator instances.

* chore: Update renamings file

  - Fix a malformation in previous entries that was not detected by
    the renaming file validator test.
  - Add entries describing the work done in this and related recent
    PRs.

* fix: Correct minor errors in PR #7173

  - Fix a search-and-replace error in renamings.json5
  - Fix an incorrect-but-usable import in generator_test.js
This commit is contained in:
Christopher Allen
2023-06-20 23:22:44 +01:00
committed by GitHub
parent 021a560ef0
commit 130989763c
64 changed files with 2120 additions and 2046 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
generators/javascript/all.js
View File

@@ -1,26 +0,0 @@
/**
* @license
* Copyright 2021 Google LLC
* SPDX-License-Identifier: Apache-2.0
*/
/**
* @fileoverview Complete helper functions for generating JavaScript for
* blocks. This is the entrypoint for javascript_compressed.js.
* @suppress {extraRequire}
*/
import * as goog from '../../closure/goog/goog.js';
goog.declareModuleId('Blockly.JavaScript.all');
import './colour.js';
import './lists.js';
import './logic.js';
import './loops.js';
import './math.js';
import './procedures.js';
import './text.js';
import './variables.js';
import './variables_dynamic.js';
export * from '../javascript.js';

10
generators/javascript/colour.js
View File

@@ -11,16 +11,16 @@
import * as goog from '../../closure/goog/goog.js';
goog.declareModuleId('Blockly.JavaScript.colour');
import {Order, javascriptGenerator} from '../javascript.js';
import {Order} from './javascript_generator.js';
javascriptGenerator.forBlock['colour_picker'] = function(block, generator) {
export function colour_picker(block, generator) {
// Colour picker.
const code = generator.quote_(block.getFieldValue('COLOUR'));
return [code, Order.ATOMIC];
};
javascriptGenerator.forBlock['colour_random'] = function(block, generator) {
export function colour_random(block, generator) {
// Generate a random colour.
const functionName = generator.provideFunction_('colourRandom', `
function ${generator.FUNCTION_NAME_PLACEHOLDER_}() {
@@ -32,7 +32,7 @@ function ${generator.FUNCTION_NAME_PLACEHOLDER_}() {
return [code, Order.FUNCTION_CALL];
};
javascriptGenerator.forBlock['colour_rgb'] = function(block, generator) {
export function colour_rgb(block, generator) {
// Compose a colour from RGB components expressed as percentages.
const red = generator.valueToCode(block, 'RED', Order.NONE) || 0;
const green =
@@ -54,7 +54,7 @@ function ${generator.FUNCTION_NAME_PLACEHOLDER_}(r, g, b) {
return [code, Order.FUNCTION_CALL];
};
javascriptGenerator.forBlock['colour_blend'] = function(block, generator) {
export function colour_blend(block, generator) {
// Blend two colours together.
const c1 = generator.valueToCode(block, 'COLOUR1', Order.NONE) ||
"'#000000'";

335
generators/javascript/javascript_generator.js Normal file
View File

@@ -0,0 +1,335 @@
/**
* @license
* Copyright 2012 Google LLC
* SPDX-License-Identifier: Apache-2.0
*/
/**
* @fileoverview Helper functions for generating JavaScript for blocks.
* @suppress {checkTypes|globalThis}
*/
import * as goog from '../../closure/goog/goog.js';
goog.declareModuleId('Blockly.JavaScript');
import * as Variables from '../../core/variables.js';
import * as stringUtils from '../../core/utils/string.js';
// import type {Block} from '../../core/block.js';
import {CodeGenerator} from '../../core/generator.js';
import {Names, NameType} from '../../core/names.js';
// import type {Workspace} from '../../core/workspace.js';
import {inputTypes} from '../../core/inputs/input_types.js';
/**
* Order of operation ENUMs.
* https://developer.mozilla.org/en/JavaScript/Reference/Operators/Operator_Precedence
* @enum {number}
*/
export const Order = {
ATOMIC: 0, // 0 "" ...
NEW: 1.1, // new
MEMBER: 1.2, // . []
FUNCTION_CALL: 2, // ()
INCREMENT: 3, // ++
DECREMENT: 3, // --
BITWISE_NOT: 4.1, // ~
UNARY_PLUS: 4.2, // +
UNARY_NEGATION: 4.3, // -
LOGICAL_NOT: 4.4, // !
TYPEOF: 4.5, // typeof
VOID: 4.6, // void
DELETE: 4.7, // delete
AWAIT: 4.8, // await
EXPONENTIATION: 5.0, // **
MULTIPLICATION: 5.1, // *
DIVISION: 5.2, // /
MODULUS: 5.3, // %
SUBTRACTION: 6.1, // -
ADDITION: 6.2, // +
BITWISE_SHIFT: 7, // << >> >>>
RELATIONAL: 8, // < <= > >=
IN: 8, // in
INSTANCEOF: 8, // instanceof
EQUALITY: 9, // == != === !==
BITWISE_AND: 10, // &
BITWISE_XOR: 11, // ^
BITWISE_OR: 12, // |
LOGICAL_AND: 13, // &&
LOGICAL_OR: 14, // ||
CONDITIONAL: 15, // ?:
ASSIGNMENT: 16, //: += -= **= *= /= %= <<= >>= ...
YIELD: 17, // yield
COMMA: 18, // ,
NONE: 99, // (...)
};
/**
* JavaScript code generator class.
*/
export class JavascriptGenerator extends CodeGenerator {
/**
* List of outer-inner pairings that do NOT require parentheses.
* @type {!Array<!Array<number>>}
*/
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],
// !(!foo) -> !!foo
[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) {
super(name ?? 'JavaScript');
this.isInitialized = false;
// Copy Order values onto instance for backwards compatibility
// while ensuring they are not part of the publically-advertised
// API.
//
// TODO(#7085): deprecate these in due course. (Could initially
// replace data properties with get accessors that call
// deprecate.warn().)
for (const key in Order) {
this['ORDER_' + key] = Order[key];
}
// 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.
this.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(',')
);
}
/**
* 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 nextCode = opt_thisOnly ? '' : this.blockToCode(nextBlock);
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}
*/
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--;
}
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;
if (stringUtils.isNumber(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 + ')';
}
}
return at;
}
}

26
generators/javascript/lists.js
View File

@@ -13,15 +13,15 @@ import * as goog from '../../closure/goog/goog.js';
goog.declareModuleId('Blockly.JavaScript.lists');
import {NameType} from '../../core/names.js';
import {Order, javascriptGenerator} from '../javascript.js';
import {Order} from './javascript_generator.js';
javascriptGenerator.forBlock['lists_create_empty'] = function(block, generator) {
export function lists_create_empty(block, generator) {
// Create an empty list.
return ['[]', Order.ATOMIC];
};
javascriptGenerator.forBlock['lists_create_with'] = function(block, generator) {
export function lists_create_with(block, generator) {
// Create a list with any number of elements of any type.
const elements = new Array(block.itemCount_);
for (let i = 0; i < block.itemCount_; i++) {
@@ -33,7 +33,7 @@ javascriptGenerator.forBlock['lists_create_with'] = function(block, generator) {
return [code, Order.ATOMIC];
};
javascriptGenerator.forBlock['lists_repeat'] = function(block, generator) {
export function lists_repeat(block, generator) {
// Create a list with one element repeated.
const functionName = generator.provideFunction_('listsRepeat', `
function ${generator.FUNCTION_NAME_PLACEHOLDER_}(value, n) {
@@ -52,21 +52,21 @@ function ${generator.FUNCTION_NAME_PLACEHOLDER_}(value, n) {
return [code, Order.FUNCTION_CALL];
};
javascriptGenerator.forBlock['lists_length'] = function(block, generator) {
export function lists_length(block, generator) {
// String or array length.
const list =
generator.valueToCode(block, 'VALUE', Order.MEMBER) || '[]';
return [list + '.length', Order.MEMBER];
};
javascriptGenerator.forBlock['lists_isEmpty'] = function(block, generator) {
export function lists_isEmpty(block, generator) {
// Is the string null or array empty?
const list =
generator.valueToCode(block, 'VALUE', Order.MEMBER) || '[]';
return ['!' + list + '.length', Order.LOGICAL_NOT];
};
javascriptGenerator.forBlock['lists_indexOf'] = function(block, generator) {
export function lists_indexOf(block, generator) {
// Find an item in the list.
const operator =
block.getFieldValue('END') === 'FIRST' ? 'indexOf' : 'lastIndexOf';
@@ -81,7 +81,7 @@ javascriptGenerator.forBlock['lists_indexOf'] = function(block, generator) {
return [code, Order.FUNCTION_CALL];
};
javascriptGenerator.forBlock['lists_getIndex'] = function(block, generator) {
export function lists_getIndex(block, generator) {
// Get element at index.
// Note: Until January 2013 this block did not have MODE or WHERE inputs.
const mode = block.getFieldValue('MODE') || 'GET';
@@ -164,7 +164,7 @@ function ${generator.FUNCTION_NAME_PLACEHOLDER_}(list, remove) {
throw Error('Unhandled combination (lists_getIndex).');
};
javascriptGenerator.forBlock['lists_setIndex'] = function(block, generator) {
export function lists_setIndex(block, generator) {
// Set element at index.
// Note: Until February 2013 this block did not have MODE or WHERE inputs.
let list =
@@ -266,7 +266,7 @@ const getSubstringIndex = function(listName, where, opt_at) {
}
};
javascriptGenerator.forBlock['lists_getSublist'] = function(block, generator) {
export function lists_getSublist(block, generator) {
// Get sublist.
const list =
generator.valueToCode(block, 'LIST', Order.MEMBER) || '[]';
@@ -346,7 +346,7 @@ function ${generator.FUNCTION_NAME_PLACEHOLDER_}(sequence${at1Param}${at2Param})
return [code, Order.FUNCTION_CALL];
};
javascriptGenerator.forBlock['lists_sort'] = function(block, generator) {
export function lists_sort(block, generator) {
// Block for sorting a list.
const list =
generator.valueToCode(block, 'LIST', Order.FUNCTION_CALL) ||
@@ -375,7 +375,7 @@ function ${generator.FUNCTION_NAME_PLACEHOLDER_}(type, direction) {
];
};
javascriptGenerator.forBlock['lists_split'] = function(block, generator) {
export function lists_split(block, generator) {
// Block for splitting text into a list, or joining a list into text.
let input = generator.valueToCode(block, 'INPUT', Order.MEMBER);
const delimiter =
@@ -399,7 +399,7 @@ javascriptGenerator.forBlock['lists_split'] = function(block, generator) {
return [code, Order.FUNCTION_CALL];
};
javascriptGenerator.forBlock['lists_reverse'] = function(block, generator) {
export function lists_reverse(block, generator) {
// Block for reversing a list.
const list =
generator.valueToCode(block, 'LIST', Order.FUNCTION_CALL) ||

19
generators/javascript/logic.js
View File

@@ -11,10 +11,10 @@
import * as goog from '../../closure/goog/goog.js';
goog.declareModuleId('Blockly.JavaScript.logic');
import {Order, javascriptGenerator} from '../javascript.js';
import {Order} from './javascript_generator.js';
javascriptGenerator.forBlock['controls_if'] = function(block, generator) {
export function controls_if(block, generator) {
// If/elseif/else condition.
let n = 0;
let code = '';
@@ -54,10 +54,9 @@ javascriptGenerator.forBlock['controls_if'] = function(block, generator) {
return code + '\n';
};
javascriptGenerator.forBlock['controls_ifelse'] =
javascriptGenerator.forBlock['controls_if'];
export const controls_ifelse = controls_if;
javascriptGenerator.forBlock['logic_compare'] = function(block, generator) {
export function logic_compare(block, generator) {
// Comparison operator.
const OPERATORS =
{'EQ': '==', 'NEQ': '!=', 'LT': '<', 'LTE': '<=', 'GT': '>', 'GTE': '>='};
@@ -71,7 +70,7 @@ javascriptGenerator.forBlock['logic_compare'] = function(block, generator) {
return [code, order];
};
javascriptGenerator.forBlock['logic_operation'] = function(block, generator) {
export function logic_operation(block, generator) {
// Operations 'and', 'or'.
const operator = (block.getFieldValue('OP') === 'AND') ? '&&' : '||';
const order = (operator === '&&') ? Order.LOGICAL_AND :
@@ -96,7 +95,7 @@ javascriptGenerator.forBlock['logic_operation'] = function(block, generator) {
return [code, order];
};
javascriptGenerator.forBlock['logic_negate'] = function(block, generator) {
export function logic_negate(block, generator) {
// Negation.
const order = Order.LOGICAL_NOT;
const argument0 =
@@ -105,18 +104,18 @@ javascriptGenerator.forBlock['logic_negate'] = function(block, generator) {
return [code, order];
};
javascriptGenerator.forBlock['logic_boolean'] = function(block, generator) {
export function logic_boolean(block, generator) {
// Boolean values true and false.
const code = (block.getFieldValue('BOOL') === 'TRUE') ? 'true' : 'false';
return [code, Order.ATOMIC];
};
javascriptGenerator.forBlock['logic_null'] = function(block, generator) {
export function logic_null(block, generator) {
// Null data type.
return ['null', Order.ATOMIC];
};
javascriptGenerator.forBlock['logic_ternary'] = function(block, generator) {
export function logic_ternary(block, generator) {
// Ternary operator.
const value_if =
generator.valueToCode(block, 'IF', Order.CONDITIONAL) ||

15
generators/javascript/loops.js
View File

@@ -13,10 +13,10 @@ goog.declareModuleId('Blockly.JavaScript.loops');
import * as stringUtils from '../../core/utils/string.js';
import {NameType} from '../../core/names.js';
import {Order, javascriptGenerator} from '../javascript.js';
import {Order} from './javascript_generator.js';
javascriptGenerator.forBlock['controls_repeat_ext'] = function(block, generator) {
export function controls_repeat_ext(block, generator) {
// Repeat n times.
let repeats;
if (block.getField('TIMES')) {
@@ -45,10 +45,9 @@ javascriptGenerator.forBlock['controls_repeat_ext'] = function(block, generator)
return code;
};
javascriptGenerator.forBlock['controls_repeat'] =
javascriptGenerator.forBlock['controls_repeat_ext'];
export const controls_repeat = controls_repeat_ext;
javascriptGenerator.forBlock['controls_whileUntil'] = function(block, generator) {
export function controls_whileUntil(block, generator) {
// Do while/until loop.
const until = block.getFieldValue('MODE') === 'UNTIL';
let argument0 =
@@ -64,7 +63,7 @@ javascriptGenerator.forBlock['controls_whileUntil'] = function(block, generator)
return 'while (' + argument0 + ') {\n' + branch + '}\n';
};
javascriptGenerator.forBlock['controls_for'] = function(block, generator) {
export function controls_for(block, generator) {
// For loop.
const variable0 =
generator.nameDB_.getName(
@@ -127,7 +126,7 @@ javascriptGenerator.forBlock['controls_for'] = function(block, generator) {
return code;
};
javascriptGenerator.forBlock['controls_forEach'] = function(block, generator) {
export function controls_forEach(block, generator) {
// For each loop.
const variable0 =
generator.nameDB_.getName(
@@ -153,7 +152,7 @@ javascriptGenerator.forBlock['controls_forEach'] = function(block, generator) {
return code;
};
javascriptGenerator.forBlock['controls_flow_statements'] = function(block, generator) {
export function controls_flow_statements(block, generator) {
// Flow statements: continue, break.
let xfix = '';
if (generator.STATEMENT_PREFIX) {

32
generators/javascript/math.js
View File

@@ -13,10 +13,10 @@ import * as goog from '../../closure/goog/goog.js';
goog.declareModuleId('Blockly.JavaScript.math');
import {NameType} from '../../core/names.js';
import {Order, javascriptGenerator} from '../javascript.js';
import {Order} from './javascript_generator.js';
javascriptGenerator.forBlock['math_number'] = function(block, generator) {
export function math_number(block, generator) {
// Numeric value.
const code = Number(block.getFieldValue('NUM'));
const order = code >= 0 ? Order.ATOMIC :
@@ -24,7 +24,7 @@ javascriptGenerator.forBlock['math_number'] = function(block, generator) {
return [code, order];
};
javascriptGenerator.forBlock['math_arithmetic'] = function(block, generator) {
export function math_arithmetic(block, generator) {
// Basic arithmetic operators, and power.
const OPERATORS = {
'ADD': [' + ', Order.ADDITION],
@@ -48,7 +48,7 @@ javascriptGenerator.forBlock['math_arithmetic'] = function(block, generator) {
return [code, order];
};
javascriptGenerator.forBlock['math_single'] = function(block, generator) {
export function math_single(block, generator) {
// Math operators with single operand.
const operator = block.getFieldValue('OP');
let code;
@@ -132,7 +132,7 @@ javascriptGenerator.forBlock['math_single'] = function(block, generator) {
return [code, Order.DIVISION];
};
javascriptGenerator.forBlock['math_constant'] = function(block, generator) {
export function math_constant(block, generator) {
// Constants: PI, E, the Golden Ratio, sqrt(2), 1/sqrt(2), INFINITY.
const CONSTANTS = {
'PI': ['Math.PI', Order.MEMBER],
@@ -145,7 +145,7 @@ javascriptGenerator.forBlock['math_constant'] = function(block, generator) {
return CONSTANTS[block.getFieldValue('CONSTANT')];
};
javascriptGenerator.forBlock['math_number_property'] = function(block, generator) {
export function math_number_property(block, generator) {
// Check if a number is even, odd, prime, whole, positive, or negative
// or if it is divisible by certain number. Returns true or false.
const PROPERTIES = {
@@ -199,7 +199,7 @@ function ${generator.FUNCTION_NAME_PLACEHOLDER_}(n) {
return [code, outputOrder];
};
javascriptGenerator.forBlock['math_change'] = function(block, generator) {
export function math_change(block, generator) {
// Add to a variable in place.
const argument0 = generator.valueToCode(block, 'DELTA',
Order.ADDITION) || '0';
@@ -210,13 +210,11 @@ javascriptGenerator.forBlock['math_change'] = function(block, generator) {
};
// Rounding functions have a single operand.
javascriptGenerator.forBlock['math_round'] =
javascriptGenerator.forBlock['math_single'];
export const math_round = math_single;
// Trigonometry functions have a single operand.
javascriptGenerator.forBlock['math_trig'] =
javascriptGenerator.forBlock['math_single'];
export const math_trig = math_single;
javascriptGenerator.forBlock['math_on_list'] = function(block, generator) {
export function math_on_list(block, generator) {
// Math functions for lists.
const func = block.getFieldValue('OP');
let list;
@@ -346,7 +344,7 @@ function ${generator.FUNCTION_NAME_PLACEHOLDER_}(list) {
return [code, Order.FUNCTION_CALL];
};
javascriptGenerator.forBlock['math_modulo'] = function(block, generator) {
export function math_modulo(block, generator) {
// Remainder computation.
const argument0 = generator.valueToCode(block, 'DIVIDEND',
Order.MODULUS) || '0';
@@ -356,7 +354,7 @@ javascriptGenerator.forBlock['math_modulo'] = function(block, generator) {
return [code, Order.MODULUS];
};
javascriptGenerator.forBlock['math_constrain'] = function(block, generator) {
export function math_constrain(block, generator) {
// Constrain a number between two limits.
const argument0 = generator.valueToCode(block, 'VALUE',
Order.NONE) || '0';
@@ -369,7 +367,7 @@ javascriptGenerator.forBlock['math_constrain'] = function(block, generator) {
return [code, Order.FUNCTION_CALL];
};
javascriptGenerator.forBlock['math_random_int'] = function(block, generator) {
export function math_random_int(block, generator) {
// Random integer between [X] and [Y].
const argument0 = generator.valueToCode(block, 'FROM',
Order.NONE) || '0';
@@ -390,12 +388,12 @@ function ${generator.FUNCTION_NAME_PLACEHOLDER_}(a, b) {
return [code, Order.FUNCTION_CALL];
};
javascriptGenerator.forBlock['math_random_float'] = function(block, generator) {
export function math_random_float(block, generator) {
// Random fraction between 0 and 1.
return ['Math.random()', Order.FUNCTION_CALL];
};
javascriptGenerator.forBlock['math_atan2'] = function(block, generator) {
export function math_atan2(block, generator) {
// Arctangent of point (X, Y) in degrees from -180 to 180.
const argument0 = generator.valueToCode(block, 'X',
Order.NONE) || '0';

13
generators/javascript/procedures.js
View File

@@ -12,10 +12,10 @@ import * as goog from '../../closure/goog/goog.js';
goog.declareModuleId('Blockly.JavaScript.procedures');
import {NameType} from '../../core/names.js';
import {Order, javascriptGenerator} from '../javascript.js';
import {Order} from './javascript_generator.js';
javascriptGenerator.forBlock['procedures_defreturn'] = function(block, generator) {
export function procedures_defreturn(block, generator) {
// Define a procedure with a return value.
const funcName = generator.nameDB_.getName(
block.getFieldValue('NAME'), NameType.PROCEDURE);
@@ -65,10 +65,9 @@ javascriptGenerator.forBlock['procedures_defreturn'] = function(block, generator
// Defining a procedure without a return value uses the same generator as
// a procedure with a return value.
javascriptGenerator.forBlock['procedures_defnoreturn'] =
javascriptGenerator.forBlock['procedures_defreturn'];
export const procedures_defnoreturn = procedures_defreturn;
javascriptGenerator.forBlock['procedures_callreturn'] = function(block, generator) {
export function procedures_callreturn(block, generator) {
// Call a procedure with a return value.
const funcName = generator.nameDB_.getName(
block.getFieldValue('NAME'), NameType.PROCEDURE);
@@ -82,7 +81,7 @@ javascriptGenerator.forBlock['procedures_callreturn'] = function(block, generato
return [code, Order.FUNCTION_CALL];
};
javascriptGenerator.forBlock['procedures_callnoreturn'] = function(block, generator) {
export function procedures_callnoreturn(block, generator) {
// 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.
@@ -90,7 +89,7 @@ javascriptGenerator.forBlock['procedures_callnoreturn'] = function(block, genera
return tuple[0] + ';\n';
};
javascriptGenerator.forBlock['procedures_ifreturn'] = function(block, generator) {
export function procedures_ifreturn(block, generator) {
// Conditionally return value from a procedure.
const condition =
generator.valueToCode(block, 'CONDITION', Order.NONE) ||

37
generators/javascript/text.js
View File

@@ -12,7 +12,7 @@ import * as goog from '../../closure/goog/goog.js';
goog.declareModuleId('Blockly.JavaScript.texts');
import {NameType} from '../../core/names.js';
import {Order, javascriptGenerator} from '../javascript.js';
import {Order} from './javascript_generator.js';
/**
@@ -53,13 +53,13 @@ const getSubstringIndex = function(stringName, where, opt_at) {
}
};
javascriptGenerator.forBlock['text'] = function(block, generator) {
export function text(block, generator) {
// Text value.
const code = generator.quote_(block.getFieldValue('TEXT'));
return [code, Order.ATOMIC];
};
javascriptGenerator.forBlock['text_multiline'] = function(block, generator) {
export function text_multiline(block, generator) {
// Text value.
const code =
generator.multiline_quote_(block.getFieldValue('TEXT'));
@@ -68,7 +68,7 @@ javascriptGenerator.forBlock['text_multiline'] = function(block, generator) {
return [code, order];
};
javascriptGenerator.forBlock['text_join'] = function(block, generator) {
export function text_join(block, generator) {
// Create a string made up of any number of elements of any type.
switch (block.itemCount_) {
case 0:
@@ -100,7 +100,7 @@ javascriptGenerator.forBlock['text_join'] = function(block, generator) {
}
};
javascriptGenerator.forBlock['text_append'] = function(block, generator) {
export function text_append(block, generator) {
// Append to a variable in place.
const varName = generator.nameDB_.getName(
block.getFieldValue('VAR'), NameType.VARIABLE);
@@ -111,21 +111,21 @@ javascriptGenerator.forBlock['text_append'] = function(block, generator) {
return code;
};
javascriptGenerator.forBlock['text_length'] = function(block, generator) {
export function text_length(block, generator) {
// String or array length.
const text = generator.valueToCode(block, 'VALUE',
Order.MEMBER) || "''";
return [text + '.length', Order.MEMBER];
};
javascriptGenerator.forBlock['text_isEmpty'] = function(block, generator) {
export function text_isEmpty(block, generator) {
// Is the string null or array empty?
const text = generator.valueToCode(block, 'VALUE',
Order.MEMBER) || "''";
return ['!' + text + '.length', Order.LOGICAL_NOT];
};
javascriptGenerator.forBlock['text_indexOf'] = function(block, generator) {
export function text_indexOf(block, generator) {
// Search the text for a substring.
const operator = block.getFieldValue('END') === 'FIRST' ?
'indexOf' : 'lastIndexOf';
@@ -141,7 +141,7 @@ javascriptGenerator.forBlock['text_indexOf'] = function(block, generator) {
return [code, Order.FUNCTION_CALL];
};
javascriptGenerator.forBlock['text_charAt'] = function(block, generator) {
export function text_charAt(block, generator) {
// Get letter at index.
// Note: Until January 2013 this block did not have the WHERE input.
const where = block.getFieldValue('WHERE') || 'FROM_START';
@@ -184,7 +184,7 @@ function ${generator.FUNCTION_NAME_PLACEHOLDER_}(text) {
throw Error('Unhandled option (text_charAt).');
};
javascriptGenerator.forBlock['text_getSubstring'] = function(block, generator) {
export function text_getSubstring(block, generator) {
// Get substring.
const where1 = block.getFieldValue('WHERE1');
const where2 = block.getFieldValue('WHERE2');
@@ -263,7 +263,7 @@ function ${generator.FUNCTION_NAME_PLACEHOLDER_}(sequence${at1Param}${at2Param})
return [code, Order.FUNCTION_CALL];
};
javascriptGenerator.forBlock['text_changeCase'] = function(block, generator) {
export function text_changeCase(block, generator) {
// Change capitalization.
const OPERATORS = {
'UPPERCASE': '.toUpperCase()',
@@ -292,7 +292,7 @@ function ${generator.FUNCTION_NAME_PLACEHOLDER_}(str) {
return [code, Order.FUNCTION_CALL];
};
javascriptGenerator.forBlock['text_trim'] = function(block, generator) {
export function text_trim(block, generator) {
// Trim spaces.
const OPERATORS = {
'LEFT': ".replace(/^[\\s\\xa0]+/, '')",
@@ -305,14 +305,14 @@ javascriptGenerator.forBlock['text_trim'] = function(block, generator) {
return [text + operator, Order.FUNCTION_CALL];
};
javascriptGenerator.forBlock['text_print'] = function(block, generator) {
export function text_print(block, generator) {
// Print statement.
const msg = generator.valueToCode(block, 'TEXT',
Order.NONE) || "''";
return 'window.alert(' + msg + ');\n';
};
javascriptGenerator.forBlock['text_prompt_ext'] = function(block, generator) {
export function text_prompt_ext(block, generator) {
// Prompt function.
let msg;
if (block.getField('TEXT')) {
@@ -330,10 +330,9 @@ javascriptGenerator.forBlock['text_prompt_ext'] = function(block, generator) {
return [code, Order.FUNCTION_CALL];
};
javascriptGenerator.forBlock['text_prompt'] =
javascriptGenerator.forBlock['text_prompt_ext'];
export const text_prompt = text_prompt_ext;
javascriptGenerator.forBlock['text_count'] = function(block, generator) {
export function text_count(block, generator) {
const text = generator.valueToCode(block, 'TEXT',
Order.NONE) || "''";
const sub = generator.valueToCode(block, 'SUB',
@@ -351,7 +350,7 @@ function ${generator.FUNCTION_NAME_PLACEHOLDER_}(haystack, needle) {
return [code, Order.FUNCTION_CALL];
};
javascriptGenerator.forBlock['text_replace'] = function(block, generator) {
export function text_replace(block, generator) {
const text = generator.valueToCode(block, 'TEXT',
Order.NONE) || "''";
const from = generator.valueToCode(block, 'FROM',
@@ -370,7 +369,7 @@ function ${generator.FUNCTION_NAME_PLACEHOLDER_}(haystack, needle, replacement)
return [code, Order.FUNCTION_CALL];
};
javascriptGenerator.forBlock['text_reverse'] = function(block, generator) {
export function text_reverse(block, generator) {
const text = generator.valueToCode(block, 'TEXT',
Order.MEMBER) || "''";
const code = text + ".split('').reverse().join('')";

6
generators/javascript/variables.js
View File

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

10
generators/javascript/variables_dynamic.js
View File

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