chore: import upstream snapshot with attribution

tensorflow/c/experimental/ops/gen/common/BUILD

@@ -0,0 +1,49 @@
+load("@rules_cc//cc:cc_library.bzl", "cc_library")
+load(
+    "//tensorflow:tensorflow.bzl",
+    "tf_cc_tests",
+)
+
+package(
+    # copybara:uncomment default_applicable_licenses = ["//tensorflow:license"],
+    default_visibility = ["//visibility:public"],
+    licenses = ["notice"],
+)
+
+cc_library(
+    name = "common",
+    srcs = glob(
+        ["*.cc"],
+        exclude = ["*_test.cc"],
+    ),
+    hdrs = glob(["*.h"]),
+    deps = [
+        "//tensorflow/c/experimental/ops/gen/model",
+        "//tensorflow/core:framework",
+        "//tensorflow/core:framework_internal",
+        "//tensorflow/core:lib",
+        "//tensorflow/core:lib_internal",
+        "//tensorflow/core:op_gen_lib",
+        "//tensorflow/core:protos_all_cc",
+        "//tensorflow/core/platform:str_util",
+        "@com_google_absl//absl/log",
+        "@com_google_absl//absl/log:check",
+        "@com_google_absl//absl/strings",
+    ],
+    alwayslink = 1,
+)
+
+tf_cc_tests(
+    name = "all_tests",
+    size = "small",
+    srcs = glob(["*_test.cc"]),
+    deps = [
+        ":common",
+        "//tensorflow/core:core_cpu",
+        "//tensorflow/core:framework",
+        "//tensorflow/core:test",
+        "//tensorflow/core:test_main",
+        "//tensorflow/core:testlib",
+        "//tensorflow/core/platform:types",
+    ],
+)

tensorflow/c/experimental/ops/gen/common/case_format.cc

@@ -0,0 +1,107 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#include "tensorflow/c/experimental/ops/gen/common/case_format.h"
+
+#include <string>
+
+#include "absl/strings/ascii.h"
+#include "tensorflow/core/platform/types.h"
+
+namespace tensorflow {
+namespace generator {
+
+namespace {
+
+enum CaseFormatType {
+  LOWER_CAMEL,
+  UPPER_CAMEL,
+  LOWER_SNAKE,
+  UPPER_SNAKE,
+};
+
+std::string FormatStringCase(const std::string& str, CaseFormatType to,
+                             const char delimiter = '_') {
+  const bool from_snake = (str == absl::AsciiStrToUpper(str)) ||
+                          (str == absl::AsciiStrToLower(str));
+  const bool toUpper = (to == UPPER_CAMEL || to == UPPER_SNAKE);
+  const bool toSnake = (to == LOWER_SNAKE || to == UPPER_SNAKE);
+
+  std::string result;
+
+  bool inputStart = true;
+  bool wordStart = true;
+  for (const char c : str) {
+    // Find a word start.
+    if (c == delimiter) {
+      // Repeated cases of wordStart means explicit delimiter usage.
+      if (wordStart) {
+        result.push_back(delimiter);
+      }
+      wordStart = true;
+      continue;
+    }
+    if (!from_snake && absl::ascii_isupper(c)) {
+      wordStart = true;
+    }
+
+    // add delimiter
+    if (wordStart && toSnake && !inputStart) {
+      result.push_back(delimiter);
+    }
+
+    // add the next letter from the input string (choosing upper/lower case)
+    const bool shouldCapIfSnake = toUpper;
+    const bool shouldCapIfCamel = wordStart && (toUpper || !inputStart);
+    if ((toSnake && shouldCapIfSnake) || (!toSnake && shouldCapIfCamel)) {
+      result += absl::ascii_toupper(c);
+    } else {
+      result += absl::ascii_tolower(c);
+    }
+
+    // at this point we are no longer at the start of a word:
+    wordStart = false;
+    // .. or the input:
+    inputStart = false;
+  }
+
+  if (wordStart) {
+    // This only happens with a trailing delimiter, which should remain.
+    result.push_back(delimiter);
+  }
+
+  return result;
+}
+
+}  // namespace
+
+//
+// Public interface
+//
+
+std::string toLowerCamel(const std::string& s, const char delimiter) {
+  return FormatStringCase(s, LOWER_CAMEL, delimiter);
+}
+std::string toLowerSnake(const std::string& s, const char delimiter) {
+  return FormatStringCase(s, LOWER_SNAKE, delimiter);
+}
+std::string toUpperCamel(const std::string& s, const char delimiter) {
+  return FormatStringCase(s, UPPER_CAMEL, delimiter);
+}
+std::string toUpperSnake(const std::string& s, const char delimiter) {
+  return FormatStringCase(s, UPPER_SNAKE, delimiter);
+}
+
+}  // namespace generator
+}  // namespace tensorflow

tensorflow/c/experimental/ops/gen/common/case_format.h

@@ -0,0 +1,46 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_C_EXPERIMENTAL_OPS_GEN_COMMON_CASE_FORMAT_H_
+#define TENSORFLOW_C_EXPERIMENTAL_OPS_GEN_COMMON_CASE_FORMAT_H_
+
+#include "tensorflow/core/platform/str_util.h"
+#include "tensorflow/core/platform/types.h"
+
+namespace tensorflow {
+namespace generator {
+
+// Conversion routines between upper/lower camel/snake case formats, e.g.:
+//   "lowerCamelCase"
+//   "lower_snake_case"
+//   "UpperCamelCase"
+//   "UPPER_SNAKE_CASE"
+//
+// The input format is automatically detected.
+// The delimiter must be specified if it is other than an underscore ('_')
+// for conversion either *to* or *from* snake case.
+//
+// Leading and trailing delimiters are supported, e.g.:
+//    "__OneTwo__" (in camel case)  <==>  "__ONE_TWO__" (in snake case)
+//
+// Note: performance not yet tested.
+std::string toLowerCamel(const std::string& s, const char delimiter = '_');
+std::string toLowerSnake(const std::string& s, const char delimiter = '_');
+std::string toUpperCamel(const std::string& s, const char delimiter = '_');
+std::string toUpperSnake(const std::string& s, const char delimiter = '_');
+
+}  // namespace generator
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_C_EXPERIMENTAL_OPS_GEN_COMMON_CASE_FORMAT_H_

tensorflow/c/experimental/ops/gen/common/case_format_test.cc

@@ -0,0 +1,128 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#include "tensorflow/c/experimental/ops/gen/common/case_format.h"
+
+#include <string>
+
+#include "tensorflow/core/platform/test.h"
+#include "tensorflow/core/platform/types.h"
+
+namespace tensorflow {
+namespace generator {
+
+namespace {
+
+// For each test case, we manually construct the 4 variations in string case and
+// test all 16 conversions: from and to each of the 4 string case variations.
+struct Variations {
+  std::string lower_camel;
+  std::string lower_snake;
+  std::string upper_camel;
+  std::string upper_snake;
+};
+
+void TestSingleVariation(const std::string& str, Variations expected,
+                         char delimiter = '_') {
+  EXPECT_EQ(expected.lower_camel, toLowerCamel(str, delimiter));
+  EXPECT_EQ(expected.lower_snake, toLowerSnake(str, delimiter));
+  EXPECT_EQ(expected.upper_camel, toUpperCamel(str, delimiter));
+  EXPECT_EQ(expected.upper_snake, toUpperSnake(str, delimiter));
+}
+
+void TestAllVariations(Variations variations, char delimiter = '_') {
+  TestSingleVariation(variations.lower_camel, variations, delimiter);
+  TestSingleVariation(variations.lower_snake, variations, delimiter);
+  TestSingleVariation(variations.upper_camel, variations, delimiter);
+  TestSingleVariation(variations.upper_snake, variations, delimiter);
+}
+
+TEST(CppOpGenCaseFormat, test_single_word) {
+  TestAllVariations(Variations{
+      "three",
+      "three",
+      "Three",
+      "THREE",
+  });
+}
+
+TEST(CppOpGenCaseFormat, test_complex_string) {
+  TestAllVariations(Variations{
+      "threeNTest33Words",
+      "three_n_test33_words",
+      "ThreeNTest33Words",
+      "THREE_N_TEST33_WORDS",
+  });
+}
+
+TEST(CppOpGenCaseFormat, test_hyphen_delimiter) {
+  TestAllVariations(
+      Variations{
+          "threeNTest33Words",
+          "three-n-test33-words",
+          "ThreeNTest33Words",
+          "THREE-N-TEST33-WORDS",
+      },
+      '-');
+}
+
+TEST(CppOpGenCaseFormat, test_trailing_underscore) {
+  TestAllVariations(Variations{
+      "threeNTest33Words_",
+      "three_n_test33_words_",
+      "ThreeNTest33Words_",
+      "THREE_N_TEST33_WORDS_",
+  });
+}
+
+TEST(CppOpGenCaseFormat, test_double_trailing_underscores) {
+  TestAllVariations(Variations{
+      "xxY__",
+      "xx_y__",
+      "XxY__",
+      "XX_Y__",
+  });
+}
+
+TEST(CppOpGenCaseFormat, test_leading_underscore) {
+  TestAllVariations(Variations{
+      "_threeNTest33Words",
+      "_three_n_test33_words",
+      "_ThreeNTest33Words",
+      "_THREE_N_TEST33_WORDS",
+  });
+}
+
+TEST(CppOpGenCaseFormat, test_double_leading_underscores) {
+  TestAllVariations(Variations{
+      "__threeNTest33Words",
+      "__three_n_test33_words",
+      "__ThreeNTest33Words",
+      "__THREE_N_TEST33_WORDS",
+  });
+}
+
+TEST(CppOpGenCaseFormat, test_leading_and_trailing_underscores) {
+  TestAllVariations(Variations{
+      "__threeNTest33Words____",
+      "__three_n_test33_words____",
+      "__ThreeNTest33Words____",
+      "__THREE_N_TEST33_WORDS____",
+  });
+}
+
+}  // namespace
+
+}  // namespace generator
+}  // namespace tensorflow

tensorflow/c/experimental/ops/gen/common/controller.cc

@@ -0,0 +1,94 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#include "tensorflow/c/experimental/ops/gen/common/controller.h"
+
+#include <string>
+#include <vector>
+
+#include "absl/log/check.h"
+#include "absl/strings/substitute.h"
+#include "tensorflow/c/experimental/ops/gen/common/path_config.h"
+#include "tensorflow/c/experimental/ops/gen/common/source_code.h"
+#include "tensorflow/c/experimental/ops/gen/model/op_spec.h"
+#include "xla/tsl/platform/status.h"
+#include "tensorflow/core/framework/api_def.pb.h"
+#include "tensorflow/core/framework/op.h"
+#include "tensorflow/core/framework/op_def.pb.h"
+#include "tensorflow/core/framework/op_gen_lib.h"
+#include "tensorflow/core/platform/env.h"
+#include "tensorflow/core/platform/logging.h"
+#include "tensorflow/core/platform/path.h"
+
+namespace tensorflow {
+namespace generator {
+
+Controller::Controller(PathConfig path_config, Env* env)
+    : env_(env), path_config_(path_config) {
+  // Load the Op and API definitions
+  InitializeOpApi();
+
+  // Convert the Op and API definitions to the internal data model
+  BuildModel();
+}
+Controller::~Controller() { delete api_def_map_; }
+
+const void Controller::WriteFile(const std::string& file_path,
+                                 const SourceCode& code) const {
+  TF_CHECK_OK(WriteStringToFile(env_, file_path, code.Render())) << file_path;
+}
+
+const std::vector<OpSpec>& Controller::GetModelOps() const {
+  return operators_;
+}
+
+void Controller::InitializeOpApi() {
+  OpRegistry::Global()->Export(false, &op_list_);
+
+  // Load matching API defs for each Op. Paths are visited in order, allowing
+  // python/api_def_Xyz.pbtxt to override base/api_def_Xyz.pbtxt, for example.
+  api_def_map_ = new ApiDefMap(op_list_);
+  for (const auto& op : op_list_.op()) {
+    for (const auto& dir : path_config_.api_dirs) {
+      const std::string file_name =
+          absl::Substitute("api_def_$0.pbtxt", op.name());
+      const std::string file_path = io::JoinPath(dir, file_name);
+      if (env_->FileExists(file_path).ok()) {
+        TF_CHECK_OK(api_def_map_->LoadFile(env_, file_path)) << file_path;
+      } else {
+        // API defs are currently used for only optional pieces.
+      }
+    }
+  }
+
+  // Doc strings (summary, description) typically come from the API def.
+  api_def_map_->UpdateDocs();
+}
+
+void Controller::BuildModel() {
+  // Build the internal data model for the requested ops
+  for (const auto& op_name : path_config_.op_names) {
+    const OpDef* op_def = nullptr;
+    TF_CHECK_OK(OpRegistry::Global()->LookUpOpDef(op_name, &op_def));
+    CHECK(op_def != nullptr);  // Crash OK
+
+    const ApiDef* api_def = api_def_map_->GetApiDef(op_name);
+    CHECK(api_def != nullptr);  // Crash OK
+
+    operators_.push_back(OpSpec::Create(*op_def, *api_def));
+  }
+}
+
+}  // namespace generator
+}  // namespace tensorflow

tensorflow/c/experimental/ops/gen/common/controller.h

@@ -0,0 +1,58 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_C_EXPERIMENTAL_OPS_GEN_COMMON_CONTROLLER_H_
+#define TENSORFLOW_C_EXPERIMENTAL_OPS_GEN_COMMON_CONTROLLER_H_
+
+#include <vector>
+
+#include "tensorflow/c/experimental/ops/gen/common/path_config.h"
+#include "tensorflow/c/experimental/ops/gen/common/source_code.h"
+#include "tensorflow/c/experimental/ops/gen/model/op_spec.h"
+#include "tensorflow/core/framework/op_def.pb.h"
+#include "tensorflow/core/framework/op_gen_lib.h"
+#include "tensorflow/core/platform/env.h"
+#include "tensorflow/core/platform/types.h"
+
+namespace tensorflow {
+namespace generator {
+
+class Controller {
+ public:
+  explicit Controller(PathConfig path_config, Env* env = Env::Default());
+  virtual ~Controller();
+  const void WriteFile(const std::string& file_path,
+                       const SourceCode& code) const;
+  const std::vector<OpSpec>& GetModelOps() const;
+
+ private:
+  void InitializeOpApi();
+  void BuildModel();
+
+  // Data model: Ops to generate
+  std::vector<OpSpec> operators_;
+
+  // Configuration
+  Env* env_;
+  PathConfig path_config_;
+
+  // Initialized TensorFlow Op/API definitions
+  OpList op_list_;
+  ApiDefMap* api_def_map_;
+};
+
+}  // namespace generator
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_C_EXPERIMENTAL_OPS_GEN_COMMON_CONTROLLER_H_

tensorflow/c/experimental/ops/gen/common/path_config.cc

@@ -0,0 +1,69 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#include "tensorflow/c/experimental/ops/gen/common/path_config.h"
+
+#include <algorithm>
+#include <string>
+#include <vector>
+
+#include "absl/strings/str_join.h"
+#include "tensorflow/core/lib/strings/str_util.h"
+#include "tensorflow/core/platform/types.h"
+
+namespace tensorflow {
+namespace generator {
+
+PathConfig::PathConfig(const std::string& output_dir,
+                       const std::string& source_dir,
+                       const std::string& api_dir_list,
+                       const std::vector<std::string> op_names)
+    : output_path(output_dir), op_names(op_names) {
+  api_dirs = str_util::Split(api_dir_list, ",", str_util::SkipEmpty());
+
+  // Decompose the directory components given the output/source directories.
+  //
+  // Be flexible; accept any path string with a "tensorflow" directory name.
+  // (It's hard to construct a location-agnostic include path string using the
+  // build system, so we accept an example, such as the source build target.)
+
+  tf_root_dir = "tensorflow";
+
+  // Prefix, e.g. "third_party" given root_dir "third_party/tensorflow/...."
+  std::vector<std::string> source_path_components =
+      tensorflow::str_util::Split(source_dir, "/");
+  auto source_tfroot_pos = std::find(source_path_components.begin(),
+                                     source_path_components.end(), tf_root_dir);
+  if (source_tfroot_pos != source_path_components.end()) {
+    tf_prefix_dir =
+        absl::StrJoin(source_path_components.begin(), source_tfroot_pos, "/");
+  } else {
+    tf_prefix_dir = source_dir;
+  }
+
+  // TF subdir, e.g. "c/ops" given output_dir "blah/blah/tensorflow/c/ops"
+  std::vector<std::string> output_path_components =
+      tensorflow::str_util::Split(output_dir, "/");
+  auto output_tfroot_pos = std::find(output_path_components.begin(),
+                                     output_path_components.end(), tf_root_dir);
+  if (output_tfroot_pos != output_path_components.end()) {
+    tf_output_dir =
+        absl::StrJoin(output_tfroot_pos + 1, output_path_components.end(), "/");
+  } else {
+    tf_output_dir = output_dir;
+  }
+}
+
+}  // namespace generator
+}  // namespace tensorflow

tensorflow/c/experimental/ops/gen/common/path_config.h

@@ -0,0 +1,43 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_C_EXPERIMENTAL_OPS_GEN_COMMON_PATH_CONFIG_H_
+#define TENSORFLOW_C_EXPERIMENTAL_OPS_GEN_COMMON_PATH_CONFIG_H_
+
+#include <vector>
+
+#include "tensorflow/core/platform/types.h"
+
+namespace tensorflow {
+namespace generator {
+
+struct PathConfig {
+  std::string output_path;
+  std::vector<std::string> op_names;
+  std::vector<std::string> api_dirs;
+  std::string tf_prefix_dir;
+  std::string tf_root_dir;
+  std::string tf_output_dir;
+
+  explicit PathConfig() = default;
+  explicit PathConfig(const std::string& output_dir,
+                      const std::string& source_dir,
+                      const std::string& api_dir_list,
+                      const std::vector<std::string> op_names);
+};
+
+}  // namespace generator
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_C_EXPERIMENTAL_OPS_GEN_COMMON_PATH_CONFIG_H_

tensorflow/c/experimental/ops/gen/common/source_code.cc

@@ -0,0 +1,68 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#include "tensorflow/c/experimental/ops/gen/common/source_code.h"
+
+#include <string>
+
+#include "absl/log/log.h"
+#include "absl/strings/ascii.h"
+#include "absl/strings/match.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
+#include "absl/strings/strip.h"
+#include "tensorflow/core/platform/logging.h"
+#include "tensorflow/core/platform/stringpiece.h"
+
+namespace tensorflow {
+namespace generator {
+
+std::string SourceCode::Render() const {
+  std::string code;
+  for (const Line& line : lines_) {
+    absl::StrAppend(&code, std::string(line.indent * spaces_per_indent_, ' '),
+                    line.text, "\n");
+  }
+  return code;
+}
+
+void SourceCode::AddLineWithIndent(const std::string& line) {
+  ValidateAndAddLine(current_indent_, line);
+}
+
+void SourceCode::AddLineWithoutIndent(const std::string& line) {
+  ValidateAndAddLine(0, line);
+}
+
+void SourceCode::AddBlankLine() { ValidateAndAddLine(0, ""); }
+
+void SourceCode::IncreaseIndent() { current_indent_++; }
+
+void SourceCode::DecreaseIndent() { current_indent_--; }
+
+void SourceCode::ValidateAndAddLine(int indent, const std::string& raw_line) {
+  absl::string_view line(raw_line);
+  bool had_trailing_newline = absl::ConsumeSuffix(&line, "\n");
+
+  if (absl::StrContains(line, '\n')) {
+    LOG(ERROR) << "Attempt to add multiple lines; bad formatting is likely.";
+  } else if (had_trailing_newline) {
+    LOG(WARNING) << "Superfluous trailing newline in '" << line << "'";
+  }
+  lines_.push_back(
+      {indent, std::string(absl::StripTrailingAsciiWhitespace(line))});
+}
+
+}  // namespace generator
+}  // namespace tensorflow

tensorflow/c/experimental/ops/gen/common/source_code.h

@@ -0,0 +1,54 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_C_EXPERIMENTAL_OPS_GEN_COMMON_SOURCE_CODE_H_
+#define TENSORFLOW_C_EXPERIMENTAL_OPS_GEN_COMMON_SOURCE_CODE_H_
+
+#include <vector>
+
+#include "tensorflow/core/platform/types.h"
+
+namespace tensorflow {
+namespace generator {
+
+class SourceCode {
+ public:
+  std::string Render() const;
+  void SetSpacesPerIndent(int spaces_per_indent) {
+    spaces_per_indent_ = spaces_per_indent;
+  }
+
+  void AddLineWithIndent(const std::string& line);
+  void AddLineWithoutIndent(const std::string& line);
+  void AddBlankLine();
+  void IncreaseIndent();
+  void DecreaseIndent();
+
+ private:
+  struct Line {
+    int indent;
+    std::string text;
+  };
+
+  void ValidateAndAddLine(int indent_level, const std::string& raw_line);
+
+  int spaces_per_indent_ = 2;
+  int current_indent_ = 0;
+  std::vector<Line> lines_;
+};
+
+}  // namespace generator
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_C_EXPERIMENTAL_OPS_GEN_COMMON_SOURCE_CODE_H_

tensorflow/c/experimental/ops/gen/common/view_util.cc

@@ -0,0 +1,43 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#include "tensorflow/c/experimental/ops/gen/common/view_util.h"
+
+#include <string>
+#include <vector>
+
+#include "absl/strings/str_join.h"
+#include "absl/strings/substitute.h"
+#include "tensorflow/core/platform/types.h"
+
+namespace tensorflow {
+namespace generator {
+
+std::string Call(const std::string& object, const std::string& method,
+                 std::vector<std::string> arguments, const char* oper) {
+  return absl::Substitute("$0$1$2($3)", object, oper, method,
+                          absl::StrJoin(arguments, ", "));
+}
+
+std::string Call(const std::string& function,
+                 std::vector<std::string> arguments) {
+  return absl::Substitute("$0($1)", function, absl::StrJoin(arguments, ", "));
+}
+
+std::string Quoted(const std::string& s) {
+  return absl::Substitute("\"$0\"", s);
+}
+
+}  // namespace generator
+}  // namespace tensorflow

tensorflow/c/experimental/ops/gen/common/view_util.h

@@ -0,0 +1,34 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_C_EXPERIMENTAL_OPS_GEN_COMMON_VIEW_UTIL_H_
+#define TENSORFLOW_C_EXPERIMENTAL_OPS_GEN_COMMON_VIEW_UTIL_H_
+
+#include <vector>
+
+#include "tensorflow/core/platform/types.h"
+
+namespace tensorflow {
+namespace generator {
+
+std::string Call(const std::string& function,
+                 std::vector<std::string> arguments);
+std::string Call(const std::string& object, const std::string& method,
+                 std::vector<std::string> arguments, const char* oper = "->");
+std::string Quoted(const std::string& s);
+
+}  // namespace generator
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_C_EXPERIMENTAL_OPS_GEN_COMMON_VIEW_UTIL_H_