blockly 9.0.0-beta.0 → 9.0.0-beta.2

package/generators/lua/lists.js

@@ -1,348 +0,0 @@
-/**
- * @license
- * Copyright 2016 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * @fileoverview Generating Lua for list blocks.
- */
-'use strict';
-
-goog.module('Blockly.Lua.lists');
-
-const {NameType} = goog.require('Blockly.Names');
-const {luaGenerator: Lua} = goog.require('Blockly.Lua');
-
-
-Lua['lists_create_empty'] = function(block) {
-  // Create an empty list.
-  return ['{}', Lua.ORDER_HIGH];
-};
-
-Lua['lists_create_with'] = function(block) {
-  // 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++) {
-    elements[i] = Lua.valueToCode(block, 'ADD' + i, Lua.ORDER_NONE) || 'None';
-  }
-  const code = '{' + elements.join(', ') + '}';
-  return [code, Lua.ORDER_HIGH];
-};
-
-Lua['lists_repeat'] = function(block) {
-  // Create a list with one element repeated.
-  const functionName = Lua.provideFunction_('create_list_repeated', `
-function ${Lua.FUNCTION_NAME_PLACEHOLDER_}(item, count)
-  local t = {}
-  for i = 1, count do
-    table.insert(t, item)
-  end
-  return t
-end
-  `);
-  const element = Lua.valueToCode(block, 'ITEM', Lua.ORDER_NONE) || 'None';
-  const repeatCount = Lua.valueToCode(block, 'NUM', Lua.ORDER_NONE) || '0';
-  const code = functionName + '(' + element + ', ' + repeatCount + ')';
-  return [code, Lua.ORDER_HIGH];
-};
-
-Lua['lists_length'] = function(block) {
-  // String or array length.
-  const list = Lua.valueToCode(block, 'VALUE', Lua.ORDER_UNARY) || '{}';
-  return ['#' + list, Lua.ORDER_UNARY];
-};
-
-Lua['lists_isEmpty'] = function(block) {
-  // Is the string null or array empty?
-  const list = Lua.valueToCode(block, 'VALUE', Lua.ORDER_UNARY) || '{}';
-  const code = '#' + list + ' == 0';
-  return [code, Lua.ORDER_RELATIONAL];
-};
-
-Lua['lists_indexOf'] = function(block) {
-  // Find an item in the list.
-  const item = Lua.valueToCode(block, 'FIND', Lua.ORDER_NONE) || "''";
-  const list = Lua.valueToCode(block, 'VALUE', Lua.ORDER_NONE) || '{}';
-  let functionName;
-  if (block.getFieldValue('END') === 'FIRST') {
-    functionName = Lua.provideFunction_('first_index', `
-function ${Lua.FUNCTION_NAME_PLACEHOLDER_}(t, elem)
-  for k, v in ipairs(t) do
-    if v == elem then
-      return k
-    end
-  end
-  return 0
-end
-`);
-  } else {
-    functionName = Lua.provideFunction_('last_index', `
-function ${Lua.FUNCTION_NAME_PLACEHOLDER_}(t, elem)
-  for i = #t, 1, -1 do
-    if t[i] == elem then
-      return i
-    end
-  end
-  return 0
-end
-`);
-  }
-  const code = functionName + '(' + list + ', ' + item + ')';
-  return [code, Lua.ORDER_HIGH];
-};
-
-/**
- * Returns an expression calculating the index into a list.
- * @param {string} listName Name of the list, used to calculate length.
- * @param {string} where The method of indexing, selected by dropdown in Blockly
- * @param {string=} opt_at The optional offset when indexing from start/end.
- * @return {string|undefined} Index expression.
- */
-const getListIndex = function(listName, where, opt_at) {
-  if (where === 'FIRST') {
-    return '1';
-  } else if (where === 'FROM_END') {
-    return '#' + listName + ' + 1 - ' + opt_at;
-  } else if (where === 'LAST') {
-    return '#' + listName;
-  } else if (where === 'RANDOM') {
-    return 'math.random(#' + listName + ')';
-  } else {
-    return opt_at;
-  }
-};
-
-Lua['lists_getIndex'] = function(block) {
-  // Get element at index.
-  // Note: Until January 2013 this block did not have MODE or WHERE inputs.
-  const mode = block.getFieldValue('MODE') || 'GET';
-  const where = block.getFieldValue('WHERE') || 'FROM_START';
-  const list = Lua.valueToCode(block, 'VALUE', Lua.ORDER_HIGH) || '({})';
-
-  // If `list` would be evaluated more than once (which is the case for LAST,
-  // FROM_END, and RANDOM) and is non-trivial, make sure to access it only once.
-  if ((where === 'LAST' || where === 'FROM_END' || where === 'RANDOM') &&
-      !list.match(/^\w+$/)) {
-    // `list` is an expression, so we may not evaluate it more than once.
-    if (mode === 'REMOVE') {
-      // We can use multiple statements.
-      const atOrder =
-          (where === 'FROM_END') ? Lua.ORDER_ADDITIVE : Lua.ORDER_NONE;
-      let at = Lua.valueToCode(block, 'AT', atOrder) || '1';
-      const listVar =
-          Lua.nameDB_.getDistinctName('tmp_list', NameType.VARIABLE);
-      at = getListIndex(listVar, where, at);
-      const code = listVar + ' = ' + list + '\n' +
-          'table.remove(' + listVar + ', ' + at + ')\n';
-      return code;
-    } else {
-      // We need to create a procedure to avoid reevaluating values.
-      const at = Lua.valueToCode(block, 'AT', Lua.ORDER_NONE) || '1';
-      let functionName;
-      if (mode === 'GET') {
-        functionName = Lua.provideFunction_('list_get_' + where.toLowerCase(), [
-          'function ' + Lua.FUNCTION_NAME_PLACEHOLDER_ + '(t' +
-              // The value for 'FROM_END' and'FROM_START' depends on `at` so
-              // we add it as a parameter.
-              ((where === 'FROM_END' || where === 'FROM_START') ? ', at)' :
-                                                                  ')'),
-          '  return t[' + getListIndex('t', where, 'at') + ']', 'end'
-        ]);
-      } else {  // `mode` === 'GET_REMOVE'
-        functionName =
-            Lua.provideFunction_('list_remove_' + where.toLowerCase(), [
-              'function ' + Lua.FUNCTION_NAME_PLACEHOLDER_ + '(t' +
-                  // The value for 'FROM_END' and'FROM_START' depends on `at` so
-                  // we add it as a parameter.
-                  ((where === 'FROM_END' || where === 'FROM_START') ? ', at)' :
-                                                                      ')'),
-              '  return table.remove(t, ' + getListIndex('t', where, 'at') +
-                  ')',
-              'end'
-            ]);
-      }
-      const code = functionName + '(' + list +
-          // The value for 'FROM_END' and 'FROM_START' depends on `at` so we
-          // pass it.
-          ((where === 'FROM_END' || where === 'FROM_START') ? ', ' + at : '') +
-          ')';
-      return [code, Lua.ORDER_HIGH];
-    }
-  } else {
-    // Either `list` is a simple variable, or we only need to refer to `list`
-    // once.
-    const atOrder = (mode === 'GET' && where === 'FROM_END') ?
-        Lua.ORDER_ADDITIVE :
-        Lua.ORDER_NONE;
-    let at = Lua.valueToCode(block, 'AT', atOrder) || '1';
-    at = getListIndex(list, where, at);
-    if (mode === 'GET') {
-      const code = list + '[' + at + ']';
-      return [code, Lua.ORDER_HIGH];
-    } else {
-      const code = 'table.remove(' + list + ', ' + at + ')';
-      if (mode === 'GET_REMOVE') {
-        return [code, Lua.ORDER_HIGH];
-      } else {  // `mode` === 'REMOVE'
-        return code + '\n';
-      }
-    }
-  }
-};
-
-Lua['lists_setIndex'] = function(block) {
-  // Set element at index.
-  // Note: Until February 2013 this block did not have MODE or WHERE inputs.
-  let list = Lua.valueToCode(block, 'LIST', Lua.ORDER_HIGH) || '{}';
-  const mode = block.getFieldValue('MODE') || 'SET';
-  const where = block.getFieldValue('WHERE') || 'FROM_START';
-  const at = Lua.valueToCode(block, 'AT', Lua.ORDER_ADDITIVE) || '1';
-  const value = Lua.valueToCode(block, 'TO', Lua.ORDER_NONE) || 'None';
-
-  let code = '';
-  // If `list` would be evaluated more than once (which is the case for LAST,
-  // FROM_END, and RANDOM) and is non-trivial, make sure to access it only once.
-  if ((where === 'LAST' || where === 'FROM_END' || where === 'RANDOM') &&
-      !list.match(/^\w+$/)) {
-    // `list` is an expression, so we may not evaluate it more than once.
-    // We can use multiple statements.
-    const listVar = Lua.nameDB_.getDistinctName('tmp_list', NameType.VARIABLE);
-    code = listVar + ' = ' + list + '\n';
-    list = listVar;
-  }
-  if (mode === 'SET') {
-    code += list + '[' + getListIndex(list, where, at) + '] = ' + value;
-  } else {  // `mode` === 'INSERT'
-    // LAST is a special case, because we want to insert
-    // *after* not *before*, the existing last element.
-    code += 'table.insert(' + list + ', ' +
-        (getListIndex(list, where, at) + (where === 'LAST' ? ' + 1' : '')) +
-        ', ' + value + ')';
-  }
-  return code + '\n';
-};
-
-Lua['lists_getSublist'] = function(block) {
-  // Get sublist.
-  const list = Lua.valueToCode(block, 'LIST', Lua.ORDER_NONE) || '{}';
-  const where1 = block.getFieldValue('WHERE1');
-  const where2 = block.getFieldValue('WHERE2');
-  const at1 = Lua.valueToCode(block, 'AT1', Lua.ORDER_NONE) || '1';
-  const at2 = Lua.valueToCode(block, 'AT2', Lua.ORDER_NONE) || '1';
-
-  // The value for 'FROM_END' and'FROM_START' depends on `at` so
-  // we add it as a parameter.
-  const at1Param =
-      (where1 === 'FROM_END' || where1 === 'FROM_START') ? ', at1' : '';
-  const at2Param =
-      (where2 === 'FROM_END' || where2 === 'FROM_START') ? ', at2' : '';
-  const functionName = Lua.provideFunction_(
-      'list_sublist_' + where1.toLowerCase() + '_' + where2.toLowerCase(), `
-function ${Lua.FUNCTION_NAME_PLACEHOLDER_}(source${at1Param}${at2Param})
-  local t = {}
-  local start = ${getListIndex('source', where1, 'at1')}
-  local finish = ${getListIndex('source', where2, 'at2')}
-  for i = start, finish do
-    table.insert(t, source[i])
-  end
-  return t
-end
-`);
-  const code = functionName + '(' + list +
-      // The value for 'FROM_END' and 'FROM_START' depends on `at` so we
-      // pass it.
-      ((where1 === 'FROM_END' || where1 === 'FROM_START') ? ', ' + at1 : '') +
-      ((where2 === 'FROM_END' || where2 === 'FROM_START') ? ', ' + at2 : '') +
-      ')';
-  return [code, Lua.ORDER_HIGH];
-};
-
-Lua['lists_sort'] = function(block) {
-  // Block for sorting a list.
-  const list = Lua.valueToCode(block, 'LIST', Lua.ORDER_NONE) || '{}';
-  const direction = block.getFieldValue('DIRECTION') === '1' ? 1 : -1;
-  const type = block.getFieldValue('TYPE');
-
-  const functionName = Lua.provideFunction_('list_sort', `
-function ${Lua.FUNCTION_NAME_PLACEHOLDER_}(list, typev, direction)
-  local t = {}
-  for n,v in pairs(list) do table.insert(t, v) end
-  local compareFuncs = {
-    NUMERIC = function(a, b)
-      return (tonumber(tostring(a)) or 0)
-          < (tonumber(tostring(b)) or 0) end,
-    TEXT = function(a, b)
-      return tostring(a) < tostring(b) end,
-    IGNORE_CASE = function(a, b)
-      return string.lower(tostring(a)) < string.lower(tostring(b)) end
-  }
-  local compareTemp = compareFuncs[typev]
-  local compare = compareTemp
-  if direction == -1
-  then compare = function(a, b) return compareTemp(b, a) end
-  end
-  table.sort(t, compare)
-  return t
-end
-`);
-
-  const code =
-      functionName + '(' + list + ',"' + type + '", ' + direction + ')';
-  return [code, Lua.ORDER_HIGH];
-};
-
-Lua['lists_split'] = function(block) {
-  // Block for splitting text into a list, or joining a list into text.
-  let input = Lua.valueToCode(block, 'INPUT', Lua.ORDER_NONE);
-  const delimiter = Lua.valueToCode(block, 'DELIM', Lua.ORDER_NONE) || "''";
-  const mode = block.getFieldValue('MODE');
-  let functionName;
-  if (mode === 'SPLIT') {
-    if (!input) {
-      input = "''";
-    }
-    functionName = Lua.provideFunction_('list_string_split', `
-function ${Lua.FUNCTION_NAME_PLACEHOLDER_}(input, delim)
-  local t = {}
-  local pos = 1
-  while true do
-    next_delim = string.find(input, delim, pos)
-    if next_delim == nil then
-      table.insert(t, string.sub(input, pos))
-      break
-    else
-      table.insert(t, string.sub(input, pos, next_delim-1))
-      pos = next_delim + #delim
-    end
-  end
-  return t
-end
-`);
-  } else if (mode === 'JOIN') {
-    if (!input) {
-      input = '{}';
-    }
-    functionName = 'table.concat';
-  } else {
-    throw Error('Unknown mode: ' + mode);
-  }
-  const code = functionName + '(' + input + ', ' + delimiter + ')';
-  return [code, Lua.ORDER_HIGH];
-};
-
-Lua['lists_reverse'] = function(block) {
-  // Block for reversing a list.
-  const list = Lua.valueToCode(block, 'LIST', Lua.ORDER_NONE) || '{}';
-  const functionName = Lua.provideFunction_('list_reverse', `
-function ${Lua.FUNCTION_NAME_PLACEHOLDER_}(input)
-  local reversed = {}
-  for i = #input, 1, -1 do
-    table.insert(reversed, input[i])
-  end
-  return reversed
-end
-`);
-  const code = functionName + '(' + list + ')';
-  return [code, Lua.ORDER_HIGH];
-};

package/generators/lua/logic.js

@@ -1,112 +0,0 @@
-/**
- * @license
- * Copyright 2016 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * @fileoverview Generating Lua for logic blocks.
- */
-'use strict';
-
-goog.module('Blockly.Lua.logic');
-
-const {luaGenerator: Lua} = goog.require('Blockly.Lua');
-
-
-Lua['controls_if'] = function(block) {
-  // If/elseif/else condition.
-  let n = 0;
-  let code = '';
-  if (Lua.STATEMENT_PREFIX) {
-    // Automatic prefix insertion is switched off for this block.  Add manually.
-    code += Lua.injectId(Lua.STATEMENT_PREFIX, block);
-  }
-  do {
-    const conditionCode =
-        Lua.valueToCode(block, 'IF' + n, Lua.ORDER_NONE) || 'false';
-    let branchCode = Lua.statementToCode(block, 'DO' + n);
-    if (Lua.STATEMENT_SUFFIX) {
-      branchCode = Lua.prefixLines(
-          Lua.injectId(Lua.STATEMENT_SUFFIX, block), Lua.INDENT) + branchCode;
-    }
-    code +=
-        (n > 0 ? 'else' : '') + 'if ' + conditionCode + ' then\n' + branchCode;
-    n++;
-  } while (block.getInput('IF' + n));
-
-  if (block.getInput('ELSE') || Lua.STATEMENT_SUFFIX) {
-    let branchCode = Lua.statementToCode(block, 'ELSE');
-    if (Lua.STATEMENT_SUFFIX) {
-      branchCode = Lua.prefixLines(
-                       Lua.injectId(Lua.STATEMENT_SUFFIX, block), Lua.INDENT) +
-          branchCode;
-    }
-    code += 'else\n' + branchCode;
-  }
-  return code + 'end\n';
-};
-
-Lua['controls_ifelse'] = Lua['controls_if'];
-
-Lua['logic_compare'] = function(block) {
-  // Comparison operator.
-  const OPERATORS =
-      {'EQ': '==', 'NEQ': '~=', 'LT': '<', 'LTE': '<=', 'GT': '>', 'GTE': '>='};
-  const operator = OPERATORS[block.getFieldValue('OP')];
-  const argument0 = Lua.valueToCode(block, 'A', Lua.ORDER_RELATIONAL) || '0';
-  const argument1 = Lua.valueToCode(block, 'B', Lua.ORDER_RELATIONAL) || '0';
-  const code = argument0 + ' ' + operator + ' ' + argument1;
-  return [code, Lua.ORDER_RELATIONAL];
-};
-
-Lua['logic_operation'] = function(block) {
-  // Operations 'and', 'or'.
-  const operator = (block.getFieldValue('OP') === 'AND') ? 'and' : 'or';
-  const order = (operator === 'and') ? Lua.ORDER_AND : Lua.ORDER_OR;
-  let argument0 = Lua.valueToCode(block, 'A', order);
-  let argument1 = Lua.valueToCode(block, 'B', order);
-  if (!argument0 && !argument1) {
-    // If there are no arguments, then the return value is false.
-    argument0 = 'false';
-    argument1 = 'false';
-  } else {
-    // Single missing arguments have no effect on the return value.
-    const defaultArgument = (operator === 'and') ? 'true' : 'false';
-    if (!argument0) {
-      argument0 = defaultArgument;
-    }
-    if (!argument1) {
-      argument1 = defaultArgument;
-    }
-  }
-  const code = argument0 + ' ' + operator + ' ' + argument1;
-  return [code, order];
-};
-
-Lua['logic_negate'] = function(block) {
-  // Negation.
-  const argument0 = Lua.valueToCode(block, 'BOOL', Lua.ORDER_UNARY) || 'true';
-  const code = 'not ' + argument0;
-  return [code, Lua.ORDER_UNARY];
-};
-
-Lua['logic_boolean'] = function(block) {
-  // Boolean values true and false.
-  const code = (block.getFieldValue('BOOL') === 'TRUE') ? 'true' : 'false';
-  return [code, Lua.ORDER_ATOMIC];
-};
-
-Lua['logic_null'] = function(block) {
-  // Null data type.
-  return ['nil', Lua.ORDER_ATOMIC];
-};
-
-Lua['logic_ternary'] = function(block) {
-  // Ternary operator.
-  const value_if = Lua.valueToCode(block, 'IF', Lua.ORDER_AND) || 'false';
-  const value_then = Lua.valueToCode(block, 'THEN', Lua.ORDER_AND) || 'nil';
-  const value_else = Lua.valueToCode(block, 'ELSE', Lua.ORDER_OR) || 'nil';
-  const code = value_if + ' and ' + value_then + ' or ' + value_else;
-  return [code, Lua.ORDER_OR];
-};

package/generators/lua/loops.js

@@ -1,168 +0,0 @@
-/**
- * @license
- * Copyright 2016 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * @fileoverview Generating Lua for loop blocks.
- */
-'use strict';
-
-goog.module('Blockly.Lua.loops');
-
-const stringUtils = goog.require('Blockly.utils.string');
-const {NameType} = goog.require('Blockly.Names');
-const {luaGenerator: Lua} = goog.require('Blockly.Lua');
-
-
-/**
- * This is the text used to implement a <pre>continue</pre>.
- * It is also used to recognise <pre>continue</pre>s in generated code so that
- * the appropriate label can be put at the end of the loop body.
- * @const {string}
- */
-const CONTINUE_STATEMENT = 'goto continue\n';
-
-/**
- * If the loop body contains a "goto continue" statement, add a continue label
- * to the loop body. Slightly inefficient, as continue labels will be generated
- * in all outer loops, but this is safer than duplicating the logic of
- * blockToCode.
- *
- * @param {string} branch Generated code of the loop body
- * @return {string} Generated label or '' if unnecessary
- */
-const addContinueLabel = function(branch) {
-  if (branch.indexOf(CONTINUE_STATEMENT) !== -1) {
-    // False positives are possible (e.g. a string literal), but are harmless.
-    return branch + Lua.INDENT + '::continue::\n';
-  } else {
-    return branch;
-  }
-};
-
-Lua['controls_repeat_ext'] = function(block) {
-  // Repeat n times.
-  let repeats;
-  if (block.getField('TIMES')) {
-    // Internal number.
-    repeats = String(Number(block.getFieldValue('TIMES')));
-  } else {
-    // External number.
-    repeats = Lua.valueToCode(block, 'TIMES', Lua.ORDER_NONE) || '0';
-  }
-  if (stringUtils.isNumber(repeats)) {
-    repeats = parseInt(repeats, 10);
-  } else {
-    repeats = 'math.floor(' + repeats + ')';
-  }
-  let branch = Lua.statementToCode(block, 'DO');
-  branch = Lua.addLoopTrap(branch, block);
-  branch = addContinueLabel(branch);
-  const loopVar = Lua.nameDB_.getDistinctName('count', NameType.VARIABLE);
-  const code =
-      'for ' + loopVar + ' = 1, ' + repeats + ' do\n' + branch + 'end\n';
-  return code;
-};
-
-Lua['controls_repeat'] = Lua['controls_repeat_ext'];
-
-Lua['controls_whileUntil'] = function(block) {
-  // Do while/until loop.
-  const until = block.getFieldValue('MODE') === 'UNTIL';
-  let argument0 =
-      Lua.valueToCode(
-          block, 'BOOL', until ? Lua.ORDER_UNARY : Lua.ORDER_NONE) ||
-      'false';
-  let branch = Lua.statementToCode(block, 'DO');
-  branch = Lua.addLoopTrap(branch, block);
-  branch = addContinueLabel(branch);
-  if (until) {
-    argument0 = 'not ' + argument0;
-  }
-  return 'while ' + argument0 + ' do\n' + branch + 'end\n';
-};
-
-Lua['controls_for'] = function(block) {
-  // For loop.
-  const variable0 =
-      Lua.nameDB_.getName(block.getFieldValue('VAR'), NameType.VARIABLE);
-  const startVar = Lua.valueToCode(block, 'FROM', Lua.ORDER_NONE) || '0';
-  const endVar = Lua.valueToCode(block, 'TO', Lua.ORDER_NONE) || '0';
-  const increment = Lua.valueToCode(block, 'BY', Lua.ORDER_NONE) || '1';
-  let branch = Lua.statementToCode(block, 'DO');
-  branch = Lua.addLoopTrap(branch, block);
-  branch = addContinueLabel(branch);
-  let code = '';
-  let incValue;
-  if (stringUtils.isNumber(startVar) && stringUtils.isNumber(endVar) &&
-      stringUtils.isNumber(increment)) {
-    // All arguments are simple numbers.
-    const up = Number(startVar) <= Number(endVar);
-    const step = Math.abs(Number(increment));
-    incValue = (up ? '' : '-') + step;
-  } else {
-    code = '';
-    // Determine loop direction at start, in case one of the bounds
-    // changes during loop execution.
-    incValue =
-        Lua.nameDB_.getDistinctName(variable0 + '_inc', NameType.VARIABLE);
-    code += incValue + ' = ';
-    if (stringUtils.isNumber(increment)) {
-      code += Math.abs(increment) + '\n';
-    } else {
-      code += 'math.abs(' + increment + ')\n';
-    }
-    code += 'if (' + startVar + ') > (' + endVar + ') then\n';
-    code += Lua.INDENT + incValue + ' = -' + incValue + '\n';
-    code += 'end\n';
-  }
-  code +=
-      'for ' + variable0 + ' = ' + startVar + ', ' + endVar + ', ' + incValue;
-  code += ' do\n' + branch + 'end\n';
-  return code;
-};
-
-Lua['controls_forEach'] = function(block) {
-  // For each loop.
-  const variable0 =
-      Lua.nameDB_.getName(block.getFieldValue('VAR'), NameType.VARIABLE);
-  const argument0 = Lua.valueToCode(block, 'LIST', Lua.ORDER_NONE) || '{}';
-  let branch = Lua.statementToCode(block, 'DO');
-  branch = Lua.addLoopTrap(branch, block);
-  branch = addContinueLabel(branch);
-  const code = 'for _, ' + variable0 + ' in ipairs(' + argument0 + ') do \n' +
-      branch + 'end\n';
-  return code;
-};
-
-Lua['controls_flow_statements'] = function(block) {
-  // Flow statements: continue, break.
-  let xfix = '';
-  if (Lua.STATEMENT_PREFIX) {
-    // Automatic prefix insertion is switched off for this block.  Add manually.
-    xfix += Lua.injectId(Lua.STATEMENT_PREFIX, block);
-  }
-  if (Lua.STATEMENT_SUFFIX) {
-    // Inject any statement suffix here since the regular one at the end
-    // will not get executed if the break/continue is triggered.
-    xfix += Lua.injectId(Lua.STATEMENT_SUFFIX, block);
-  }
-  if (Lua.STATEMENT_PREFIX) {
-    const loop = block.getSurroundLoop();
-    if (loop && !loop.suppressPrefixSuffix) {
-      // Inject loop's statement prefix here since the regular one at the end
-      // 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.
-      xfix += Lua.injectId(Lua.STATEMENT_PREFIX, loop);
-    }
-  }
-  switch (block.getFieldValue('FLOW')) {
-    case 'BREAK':
-      return xfix + 'break\n';
-    case 'CONTINUE':
-      return xfix + CONTINUE_STATEMENT;
-  }
-  throw Error('Unknown flow statement.');
-};