nodeskini 1.0.1 → 1.0.3

package/blocklySkini/blockly/generators/lua/lists.js

@@ -0,0 +1,368 @@
+/**
+ * @license
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Generating Lua for list blocks.
+ * @author rodrigoq@google.com (Rodrigo Queiro)
+ */
+'use strict';
+
+goog.provide('Blockly.Lua.lists');
+
+goog.require('Blockly.Lua');
+
+
+Blockly.Lua['lists_create_empty'] = function(block) {
+  // Create an empty list.
+  return ['{}', Blockly.Lua.ORDER_HIGH];
+};
+
+Blockly.Lua['lists_create_with'] = function(block) {
+  // Create a list with any number of elements of any type.
+  var elements = new Array(block.itemCount_);
+  for (var i = 0; i < block.itemCount_; i++) {
+    elements[i] = Blockly.Lua.valueToCode(block, 'ADD' + i,
+        Blockly.Lua.ORDER_NONE) || 'None';
+  }
+  var code = '{' + elements.join(', ') + '}';
+  return [code, Blockly.Lua.ORDER_HIGH];
+};
+
+Blockly.Lua['lists_repeat'] = function(block) {
+  // Create a list with one element repeated.
+  var functionName = Blockly.Lua.provideFunction_(
+      'create_list_repeated',
+      ['function ' + Blockly.Lua.FUNCTION_NAME_PLACEHOLDER_ + '(item, count)',
+       '  local t = {}',
+       '  for i = 1, count do',
+       '    table.insert(t, item)',
+       '  end',
+       '  return t',
+       'end']);
+  var element = Blockly.Lua.valueToCode(block, 'ITEM',
+      Blockly.Lua.ORDER_NONE) || 'None';
+  var repeatCount = Blockly.Lua.valueToCode(block, 'NUM',
+      Blockly.Lua.ORDER_NONE) || '0';
+  var code = functionName + '(' + element + ', ' + repeatCount + ')';
+  return [code, Blockly.Lua.ORDER_HIGH];
+};
+
+Blockly.Lua['lists_length'] = function(block) {
+  // String or array length.
+  var list = Blockly.Lua.valueToCode(block, 'VALUE',
+      Blockly.Lua.ORDER_UNARY) || '{}';
+  return ['#' + list, Blockly.Lua.ORDER_UNARY];
+};
+
+Blockly.Lua['lists_isEmpty'] = function(block) {
+  // Is the string null or array empty?
+  var list = Blockly.Lua.valueToCode(block, 'VALUE',
+      Blockly.Lua.ORDER_UNARY) || '{}';
+  var code = '#' + list + ' == 0';
+  return [code, Blockly.Lua.ORDER_RELATIONAL];
+};
+
+Blockly.Lua['lists_indexOf'] = function(block) {
+  // Find an item in the list.
+  var item = Blockly.Lua.valueToCode(block, 'FIND',
+      Blockly.Lua.ORDER_NONE) || '\'\'';
+  var list = Blockly.Lua.valueToCode(block, 'VALUE',
+      Blockly.Lua.ORDER_NONE) || '{}';
+  if (block.getFieldValue('END') == 'FIRST') {
+    var functionName = Blockly.Lua.provideFunction_(
+        'first_index',
+        ['function ' + Blockly.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 {
+    var functionName = Blockly.Lua.provideFunction_(
+        'last_index',
+        ['function ' + Blockly.Lua.FUNCTION_NAME_PLACEHOLDER_ + '(t, elem)',
+         '  for i = #t, 1, -1 do',
+         '    if t[i] == elem then',
+         '      return i',
+         '    end',
+         '  end',
+         '  return 0',
+         'end']);
+  }
+  var code = functionName + '(' + list + ', ' + item + ')';
+  return [code, Blockly.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.
+ * @private
+ */
+Blockly.Lua.lists.getIndex_ = 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;
+  }
+};
+
+Blockly.Lua['lists_getIndex'] = function(block) {
+  // Get element at index.
+  // Note: Until January 2013 this block did not have MODE or WHERE inputs.
+  var mode = block.getFieldValue('MODE') || 'GET';
+  var where = block.getFieldValue('WHERE') || 'FROM_START';
+  var list = Blockly.Lua.valueToCode(block, 'VALUE', Blockly.Lua.ORDER_HIGH) ||
+      '({})';
+  var getIndex_ = Blockly.Lua.lists.getIndex_;
+
+  // 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.
+      var atOrder = (where == 'FROM_END') ? Blockly.Lua.ORDER_ADDITIVE :
+          Blockly.Lua.ORDER_NONE;
+      var at = Blockly.Lua.valueToCode(block, 'AT', atOrder) || '1';
+      var listVar = Blockly.Lua.variableDB_.getDistinctName(
+          'tmp_list', Blockly.VARIABLE_CATEGORY_NAME);
+      at = getIndex_(listVar, where, at);
+      var code = listVar + ' = ' + list + '\n' +
+          'table.remove(' + listVar + ', ' + at + ')\n';
+      return code;
+    } else {
+      // We need to create a procedure to avoid reevaluating values.
+      var at = Blockly.Lua.valueToCode(block, 'AT', Blockly.Lua.ORDER_NONE) ||
+          '1';
+      if (mode == 'GET') {
+        var functionName = Blockly.Lua.provideFunction_(
+            'list_get_' + where.toLowerCase(),
+            ['function ' + Blockly.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[' + getIndex_('t', where, 'at') + ']',
+             'end']);
+      } else {  //  mode == 'GET_REMOVE'
+        var functionName = Blockly.Lua.provideFunction_(
+            'list_remove_' + where.toLowerCase(),
+            ['function ' + Blockly.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, ' + getIndex_('t', where, 'at') + ')',
+             'end']);
+      }
+      var 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, Blockly.Lua.ORDER_HIGH];
+    }
+  } else {
+    // Either `list` is a simple variable, or we only need to refer to `list`
+    // once.
+    var atOrder = (mode == 'GET' && where == 'FROM_END') ?
+        Blockly.Lua.ORDER_ADDITIVE : Blockly.Lua.ORDER_NONE;
+    var at = Blockly.Lua.valueToCode(block, 'AT', atOrder) || '1';
+    at = getIndex_(list, where, at);
+    if (mode == 'GET') {
+      var code = list + '[' + at + ']';
+      return [code, Blockly.Lua.ORDER_HIGH];
+    } else {
+      var code = 'table.remove(' + list + ', ' + at + ')';
+      if (mode == 'GET_REMOVE') {
+        return [code, Blockly.Lua.ORDER_HIGH];
+      } else {  // `mode` == 'REMOVE'
+        return code + '\n';
+      }
+    }
+  }
+};
+
+Blockly.Lua['lists_setIndex'] = function(block) {
+  // Set element at index.
+  // Note: Until February 2013 this block did not have MODE or WHERE inputs.
+  var list = Blockly.Lua.valueToCode(block, 'LIST',
+      Blockly.Lua.ORDER_HIGH) || '{}';
+  var mode = block.getFieldValue('MODE') || 'SET';
+  var where = block.getFieldValue('WHERE') || 'FROM_START';
+  var at = Blockly.Lua.valueToCode(block, 'AT',
+      Blockly.Lua.ORDER_ADDITIVE) || '1';
+  var value = Blockly.Lua.valueToCode(block, 'TO',
+      Blockly.Lua.ORDER_NONE) || 'None';
+  var getIndex_ = Blockly.Lua.lists.getIndex_;
+
+  var 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.
+    var listVar = Blockly.Lua.variableDB_.getDistinctName(
+        'tmp_list', Blockly.VARIABLE_CATEGORY_NAME);
+    code = listVar + ' = ' + list + '\n';
+    list = listVar;
+  }
+  if (mode == 'SET') {
+    code += list + '[' + getIndex_(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 + ', ' +
+        (getIndex_(list, where, at) + (where == 'LAST' ? ' + 1' : '')) +
+        ', ' + value + ')';
+  }
+  return code + '\n';
+};
+
+Blockly.Lua['lists_getSublist'] = function(block) {
+  // Get sublist.
+  var list = Blockly.Lua.valueToCode(block, 'LIST',
+      Blockly.Lua.ORDER_NONE) || '{}';
+  var where1 = block.getFieldValue('WHERE1');
+  var where2 = block.getFieldValue('WHERE2');
+  var at1 = Blockly.Lua.valueToCode(block, 'AT1',
+      Blockly.Lua.ORDER_NONE) || '1';
+  var at2 = Blockly.Lua.valueToCode(block, 'AT2',
+      Blockly.Lua.ORDER_NONE) || '1';
+  var getIndex_ = Blockly.Lua.lists.getIndex_;
+
+  var functionName = Blockly.Lua.provideFunction_(
+      'list_sublist_' + where1.toLowerCase() + '_' + where2.toLowerCase(),
+      ['function ' + Blockly.Lua.FUNCTION_NAME_PLACEHOLDER_ + '(source' +
+          // The value for 'FROM_END' and'FROM_START' depends on `at` so
+          // we add it as a parameter.
+          ((where1 == 'FROM_END' || where1 == 'FROM_START') ? ', at1' : '') +
+          ((where2 == 'FROM_END' || where2 == 'FROM_START') ? ', at2' : '') +
+          ')',
+       '  local t = {}',
+       '  local start = ' + getIndex_('source', where1, 'at1'),
+       '  local finish = ' + getIndex_('source', where2, 'at2'),
+       '  for i = start, finish do',
+       '    table.insert(t, source[i])',
+       '  end',
+       '  return t',
+       'end']);
+  var 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, Blockly.Lua.ORDER_HIGH];
+};
+
+Blockly.Lua['lists_sort'] = function(block) {
+  // Block for sorting a list.
+  var list = Blockly.Lua.valueToCode(
+      block, 'LIST', Blockly.Lua.ORDER_NONE) || '{}';
+  var direction = block.getFieldValue('DIRECTION') === '1' ? 1 : -1;
+  var type = block.getFieldValue('TYPE');
+
+  var functionName = Blockly.Lua.provideFunction_(
+      'list_sort',
+      ['function ' + Blockly.Lua.FUNCTION_NAME_PLACEHOLDER_ +
+          '(list, typev, direction)',
+       '  local t = {}',
+       '  for n,v in pairs(list) do table.insert(t, v) end', // Shallow-copy.
+       '  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']);
+
+  var code = functionName +
+      '(' + list + ',"' + type + '", ' + direction + ')';
+  return [code, Blockly.Lua.ORDER_HIGH];
+};
+
+Blockly.Lua['lists_split'] = function(block) {
+  // Block for splitting text into a list, or joining a list into text.
+  var input = Blockly.Lua.valueToCode(block, 'INPUT',
+      Blockly.Lua.ORDER_NONE);
+  var delimiter = Blockly.Lua.valueToCode(block, 'DELIM',
+      Blockly.Lua.ORDER_NONE) || '\'\'';
+  var mode = block.getFieldValue('MODE');
+  var functionName;
+  if (mode == 'SPLIT') {
+    if (!input) {
+      input = '\'\'';
+    }
+    functionName = Blockly.Lua.provideFunction_(
+        'list_string_split',
+        ['function ' + Blockly.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);
+  }
+  var code = functionName + '(' + input + ', ' + delimiter + ')';
+  return [code, Blockly.Lua.ORDER_HIGH];
+};
+
+Blockly.Lua['lists_reverse'] = function(block) {
+  // Block for reversing a list.
+  var list = Blockly.Lua.valueToCode(block, 'LIST',
+      Blockly.Lua.ORDER_NONE) || '{}';
+  var functionName = Blockly.Lua.provideFunction_(
+      'list_reverse',
+      ['function ' + Blockly.Lua.FUNCTION_NAME_PLACEHOLDER_ + '(input)',
+       '  local reversed = {}',
+       '  for i = #input, 1, -1 do',
+       '    table.insert(reversed, input[i])',
+       '  end',
+       '  return reversed',
+       'end']);
+  var code = functionName + '(' + list + ')';
+  return [code, Blockly.Lua.ORDER_HIGH];
+};

package/blocklySkini/blockly/generators/lua/logic.js

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

package/blocklySkini/blockly/generators/lua/loops.js

@@ -0,0 +1,173 @@
+/**
+ * @license
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Generating Lua for loop blocks.
+ * @author rodrigoq@google.com (Rodrigo Queiro)
+ */
+'use strict';
+
+goog.provide('Blockly.Lua.loops');
+
+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}
+ */
+Blockly.Lua.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
+ * @private
+ */
+Blockly.Lua.addContinueLabel_ = function(branch) {
+  if (branch.indexOf(Blockly.Lua.CONTINUE_STATEMENT) != -1) {
+    // False positives are possible (e.g. a string literal), but are harmless.
+    return branch + Blockly.Lua.INDENT + '::continue::\n';
+  } else {
+    return branch;
+  }
+};
+
+Blockly.Lua['controls_repeat_ext'] = function(block) {
+  // Repeat n times.
+  if (block.getField('TIMES')) {
+    // Internal number.
+    var repeats = String(Number(block.getFieldValue('TIMES')));
+  } else {
+    // External number.
+    var repeats = Blockly.Lua.valueToCode(block, 'TIMES',
+        Blockly.Lua.ORDER_NONE) || '0';
+  }
+  if (Blockly.isNumber(repeats)) {
+    repeats = parseInt(repeats, 10);
+  } else {
+    repeats = 'math.floor(' + repeats + ')';
+  }
+  var branch = Blockly.Lua.statementToCode(block, 'DO');
+  branch = Blockly.Lua.addLoopTrap(branch, block);
+  branch = Blockly.Lua.addContinueLabel_(branch);
+  var loopVar = Blockly.Lua.variableDB_.getDistinctName(
+      'count', Blockly.VARIABLE_CATEGORY_NAME);
+  var code = 'for ' + loopVar + ' = 1, ' + repeats + ' do\n' +
+      branch + 'end\n';
+  return code;
+};
+
+Blockly.Lua['controls_repeat'] = Blockly.Lua['controls_repeat_ext'];
+
+Blockly.Lua['controls_whileUntil'] = function(block) {
+  // Do while/until loop.
+  var until = block.getFieldValue('MODE') == 'UNTIL';
+  var argument0 = Blockly.Lua.valueToCode(block, 'BOOL',
+      until ? Blockly.Lua.ORDER_UNARY :
+      Blockly.Lua.ORDER_NONE) || 'false';
+  var branch = Blockly.Lua.statementToCode(block, 'DO');
+  branch = Blockly.Lua.addLoopTrap(branch, block);
+  branch = Blockly.Lua.addContinueLabel_(branch);
+  if (until) {
+    argument0 = 'not ' + argument0;
+  }
+  return 'while ' + argument0 + ' do\n' + branch + 'end\n';
+};
+
+Blockly.Lua['controls_for'] = function(block) {
+  // For loop.
+  var variable0 = Blockly.Lua.variableDB_.getName(
+      block.getFieldValue('VAR'), Blockly.VARIABLE_CATEGORY_NAME);
+  var startVar = Blockly.Lua.valueToCode(block, 'FROM',
+      Blockly.Lua.ORDER_NONE) || '0';
+  var endVar = Blockly.Lua.valueToCode(block, 'TO',
+      Blockly.Lua.ORDER_NONE) || '0';
+  var increment = Blockly.Lua.valueToCode(block, 'BY',
+      Blockly.Lua.ORDER_NONE) || '1';
+  var branch = Blockly.Lua.statementToCode(block, 'DO');
+  branch = Blockly.Lua.addLoopTrap(branch, block);
+  branch = Blockly.Lua.addContinueLabel_(branch);
+  var code = '';
+  var incValue;
+  if (Blockly.isNumber(startVar) && Blockly.isNumber(endVar) &&
+      Blockly.isNumber(increment)) {
+    // All arguments are simple numbers.
+    var up = Number(startVar) <= Number(endVar);
+    var 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 = Blockly.Lua.variableDB_.getDistinctName(
+        variable0 + '_inc', Blockly.VARIABLE_CATEGORY_NAME);
+    code += incValue + ' = ';
+    if (Blockly.isNumber(increment)) {
+      code += Math.abs(increment) + '\n';
+    } else {
+      code += 'math.abs(' + increment + ')\n';
+    }
+    code += 'if (' + startVar + ') > (' + endVar + ') then\n';
+    code += Blockly.Lua.INDENT + incValue + ' = -' + incValue + '\n';
+    code += 'end\n';
+  }
+  code += 'for ' + variable0 + ' = ' + startVar + ', ' + endVar +
+      ', ' + incValue;
+  code += ' do\n' + branch + 'end\n';
+  return code;
+};
+
+Blockly.Lua['controls_forEach'] = function(block) {
+  // For each loop.
+  var variable0 = Blockly.Lua.variableDB_.getName(
+      block.getFieldValue('VAR'), Blockly.VARIABLE_CATEGORY_NAME);
+  var argument0 = Blockly.Lua.valueToCode(block, 'LIST',
+      Blockly.Lua.ORDER_NONE) || '{}';
+  var branch = Blockly.Lua.statementToCode(block, 'DO');
+  branch = Blockly.Lua.addLoopTrap(branch, block);
+  branch = Blockly.Lua.addContinueLabel_(branch);
+  var code = 'for _, ' + variable0 + ' in ipairs(' + argument0 + ') do \n' +
+      branch + 'end\n';
+  return code;
+};
+
+Blockly.Lua['controls_flow_statements'] = function(block) {
+  // Flow statements: continue, break.
+  var xfix = '';
+  if (Blockly.Lua.STATEMENT_PREFIX) {
+    // Automatic prefix insertion is switched off for this block.  Add manually.
+    xfix += Blockly.Lua.injectId(Blockly.Lua.STATEMENT_PREFIX, block);
+  }
+  if (Blockly.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 += Blockly.Lua.injectId(Blockly.Lua.STATEMENT_SUFFIX, block);
+  }
+  if (Blockly.Lua.STATEMENT_PREFIX) {
+    var loop = Blockly.Constants.Loops
+        .CONTROL_FLOW_IN_LOOP_CHECK_MIXIN.getSurroundLoop(block);
+    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 += Blockly.Lua.injectId(Blockly.Lua.STATEMENT_PREFIX, loop);
+    }
+  }
+  switch (block.getFieldValue('FLOW')) {
+    case 'BREAK':
+      return xfix + 'break\n';
+    case 'CONTINUE':
+      return xfix + Blockly.Lua.CONTINUE_STATEMENT;
+  }
+  throw Error('Unknown flow statement.');
+};