Add GN split_list function

tools/gn/functions.cc

 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "tools/gn/functions.h"
 
 #include <stddef.h>
 #include <iostream>
 #include <utility>
 
 #include "base/environment.h"
 #include "base/strings/string_util.h"
 #include "tools/gn/config.h"
 #include "tools/gn/config_values_generator.h"
 #include "tools/gn/err.h"
 #include "tools/gn/input_file.h"
+#include "tools/gn/parse_node_value_adapter.h"
 #include "tools/gn/parse_tree.h"
 #include "tools/gn/pool.h"
 #include "tools/gn/scheduler.h"
 #include "tools/gn/scope.h"
 #include "tools/gn/settings.h"
 #include "tools/gn/template.h"
 #include "tools/gn/token.h"
 #include "tools/gn/value.h"
 #include "tools/gn/value_extractors.h"
 #include "tools/gn/variables.h"
@@ skipping 777 matching lines @@
   const BuildSettings::PrintCallback& cb =
       scope->settings()->build_settings()->print_callback();
   if (cb.is_null())
     printf("%s", output.c_str());
   else
     cb.Run(output);
 
   return Value();
 }
 
+// split_list ------------------------------------------------------------------
+
+const char kSplitList[] = "split_list";
+const char kSplitList_HelpShort[] =
+    "split_list: Splits a list into N different sub-lists.";
+const char kSplitList_Help[] =
+    "split_list: Splits a list into N different sub-lists.\n"
+    "\n"
+    "  result = split_list(input, n)\n"
+    "\n"
+    "  Given a list and a number N, splits the list into N sub-lists of\n"
+    "  approximately equal size. The return value is a list of the sub-lists.\n"
+    "  The result will always be a list of size N. If N is greater than the\n"
+    "  number of elements in the input, it will be padded with empty lists.\n"
+    "\n"
+    "  The expected use is to divide source files into smaller uniform\n"
+    "  chunks.\n"
+    "\n"
+    "Example\n"
+    "\n"
+    "  The code:\n"
+    "    mylist = [1, 2, 3, 4, 5, 6]\n"
+    "    print(split_list(mylist, 3))\n"
+    "\n"
+    "  Will print:\n"
+    "    [[1, 2], [3, 4], [5, 6]\n";
+Value RunSplitList(Scope* scope,
+                   const FunctionCallNode* function,
+                   const ListNode* args_list,
+                   Err* err) {
+  const auto& args_vector = args_list->contents();
+  if (args_vector.size() != 2) {
+    *err = Err(function, "Wrong number of arguments to split_list().",
+               "Expecting exactly two.");
+    return Value();
+  }
+
+  ParseNodeValueAdapter list_adapter;
+  if (!list_adapter.InitForType(scope, args_vector[0].get(), Value::LIST, err))
+    return Value();
+  const std::vector<Value>& input = list_adapter.get().list_value();
+
+  ParseNodeValueAdapter count_adapter;
+  if (!count_adapter.InitForType(scope, args_vector[1].get(), Value::INTEGER,
+                                 err))
+    return Value();
+  int64_t count = count_adapter.get().int_value();
+  if (count <= 0) {
+    *err = Err(function, "Negative result size.");

[scottmg, 2016/06/27 22:06:01]

<= isn't quite negative, maybe "Should be greater than zero." or something.

+    return Value();
+  }
+
+  Value result(function, Value::LIST);
+  result.list_value().resize(count);
+
+  int64_t items_per_result =
+      static_cast<int64_t>(input.size() + count - 1) / count;
+  for (int64_t i = 0; i < count; i++) {
+    result.list_value()[i] = Value(function, Value::LIST);
+
+    // Assign all remainders to the last one in the bucket.
+    auto begin_add = input.begin() + i * items_per_result;
+    auto end_add = (i == count - 1) ? input.end()
+                                    : begin_add + items_per_result;

[scottmg, 2016/06/27 22:06:01]

This doesn't seem quite right. e.g. if there's 6 items into 4 lists, I think
you'll end up with

  [[1, 2], [3, 4], [5, 6], []]

rather than

  [[1, 2], [3, 4], [5], [6]]

.

+    result.list_value()[i].list_value().assign(begin_add, end_add);
+  }
+
+  return result;
+}
+
 // -----------------------------------------------------------------------------
 
 FunctionInfo::FunctionInfo()
     : self_evaluating_args_runner(nullptr),
       generic_block_runner(nullptr),
       executed_block_runner(nullptr),
       no_block_runner(nullptr),
       help_short(nullptr),
       help(nullptr),
       is_target(false) {
@@ skipping 92 matching lines @@
     INSERT_FUNCTION(GetTargetOutputs, false)
     INSERT_FUNCTION(Import, false)
     INSERT_FUNCTION(Pool, false)
     INSERT_FUNCTION(Print, false)
     INSERT_FUNCTION(ProcessFileTemplate, false)
     INSERT_FUNCTION(ReadFile, false)
     INSERT_FUNCTION(RebasePath, false)
     INSERT_FUNCTION(SetDefaults, false)
     INSERT_FUNCTION(SetDefaultToolchain, false)
     INSERT_FUNCTION(SetSourcesAssignmentFilter, false)
+    INSERT_FUNCTION(SplitList, false)
     INSERT_FUNCTION(Template, false)
     INSERT_FUNCTION(Tool, false)
     INSERT_FUNCTION(Toolchain, false)
     INSERT_FUNCTION(ToolchainArgs, false)
     INSERT_FUNCTION(WriteFile, false)
 
     #undef INSERT_FUNCTION
   }
 };
 const FunctionInfoInitializer function_info;
@@ skipping 75 matching lines @@
   }
 
   // Otherwise it's a no-block function.
   if (!VerifyNoBlockForFunctionCall(function, block, err))
     return Value();
   return found_function->second.no_block_runner(scope, function,
                                                 args.list_value(), err);
 }
 
 }  // namespace functions