js2c.cc

#include <algorithm>
#include <cassert>
#include <cctype>
#include <cinttypes>
#include <cstdarg>
#include <cstdio>
#include <functional>
#include <iostream>
#include <map>
#include <set>
#include <string>
#include <string_view>
#include <vector>
#include "embedded_data.h"
#include "executable_wrapper.h"
#include "simdutf.h"
#include "uv.h"

#if defined(_WIN32)
#include <io.h>  // _S_IREAD _S_IWRITE
#ifndef S_IRUSR
#define S_IRUSR _S_IREAD
#endif  // S_IRUSR
#ifndef S_IWUSR
#define S_IWUSR _S_IWRITE
#endif  // S_IWUSR
#endif
namespace node {
namespace js2c {
int Main(int argc, char* argv[]);

static bool is_verbose = false;

void Debug(const char* format, ...) {
  va_list arguments;
  va_start(arguments, format);
  if (is_verbose) {
    vfprintf(stderr, format, arguments);
  }
  va_end(arguments);
}

void PrintUvError(const char* syscall, const char* filename, int error) {
  fprintf(stderr, "[%s] %s: %s\n", syscall, filename, uv_strerror(error));
}

int GetStats(const char* path, std::function<void(const uv_stat_t*)> func) {
  uv_fs_t req;
  int r = uv_fs_stat(nullptr, &req, path, nullptr);
  if (r == 0) {
    func(static_cast<const uv_stat_t*>(req.ptr));
  }
  uv_fs_req_cleanup(&req);
  return r;
}

bool IsDirectory(const std::string& filename, int* error) {
  bool result = false;
  *error = GetStats(filename.c_str(), [&](const uv_stat_t* stats) {
    result = !!(stats->st_mode & S_IFDIR);
  });
  if (*error != 0) {
    PrintUvError("stat", filename.c_str(), *error);
  }
  return result;
}

size_t GetFileSize(const std::string& filename, int* error) {
  size_t result = 0;
  *error = GetStats(filename.c_str(),
                    [&](const uv_stat_t* stats) { result = stats->st_size; });
  return result;
}

bool EndsWith(const std::string& str, std::string_view suffix) {
  size_t suffix_len = suffix.length();
  size_t str_len = str.length();
  if (str_len < suffix_len) {
    return false;
  }
  return str.compare(str_len - suffix_len, suffix_len, suffix) == 0;
}

bool StartsWith(const std::string& str, std::string_view prefix) {
  size_t prefix_len = prefix.length();
  size_t str_len = str.length();
  if (str_len < prefix_len) {
    return false;
  }
  return str.compare(0, prefix_len, prefix) == 0;
}

bool FilenameIsConfigGypi(const std::string& path) {
  return path == "config.gypi" || EndsWith(path, "/config.gypi");
}

typedef std::vector<std::string> FileList;
typedef std::map<std::string, FileList> FileMap;

bool SearchFiles(const std::string& dir,
                 FileMap* file_map,
                 const std::string& extension) {
  uv_fs_t scan_req;
  int result = uv_fs_scandir(nullptr, &scan_req, dir.c_str(), 0, nullptr);
  bool errored = false;
  if (result < 0) {
    PrintUvError("scandir", dir.c_str(), result);
    errored = true;
  } else {
    auto it = file_map->insert({extension, FileList()}).first;
    FileList& files = it->second;
    files.reserve(files.size() + result);
    uv_dirent_t dent;
    while (true) {
      result = uv_fs_scandir_next(&scan_req, &dent);
      if (result == UV_EOF) {
        break;
      }

      if (result != 0) {
        PrintUvError("scandir_next", dir.c_str(), result);
        errored = true;
        break;
      }

      std::string path = dir + '/' + dent.name;
      if (EndsWith(path, extension)) {
        files.emplace_back(path);
        continue;
      }
      if (!IsDirectory(path, &result)) {
        if (result == 0) {  // It's a file, no need to search further.
          continue;
        } else {
          errored = true;
          break;
        }
      }

      if (!SearchFiles(path, file_map, extension)) {
        errored = true;
        break;
      }
    }
  }

  uv_fs_req_cleanup(&scan_req);
  return !errored;
}

constexpr std::string_view kMjsSuffix = ".mjs";
constexpr std::string_view kJsSuffix = ".js";
constexpr std::string_view kGypiSuffix = ".gypi";
constexpr std::string_view depsPrefix = "deps/";
constexpr std::string_view libPrefix = "lib/";
std::set<std::string_view> kAllowedExtensions{
    kGypiSuffix, kJsSuffix, kMjsSuffix};

std::string_view HasAllowedExtensions(const std::string& filename) {
  for (const auto& ext : kAllowedExtensions) {
    if (EndsWith(filename, ext)) {
      return ext;
    }
  }
  return {};
}

using Fragment = std::vector<char>;
using Fragments = std::vector<std::vector<char>>;

std::vector<char> Join(const Fragments& fragments,
                       const std::string& separator) {
  size_t length = separator.size() * (fragments.size() - 1);
  for (size_t i = 0; i < fragments.size(); ++i) {
    length += fragments[i].size();
  }
  std::vector<char> buf(length, 0);
  size_t cursor = 0;
  for (size_t i = 0; i < fragments.size(); ++i) {
    const Fragment& fragment = fragments[i];
    // Avoid using snprintf on large chunks of data because it's much slower.
    // It's fine to use it on small amount of data though.
    if (i != 0) {
      memcpy(buf.data() + cursor, separator.c_str(), separator.size());
      cursor += separator.size();
    }
    memcpy(buf.data() + cursor, fragment.data(), fragment.size());
    cursor += fragment.size();
  }
  buf.resize(cursor);
  return buf;
}

const char* kTemplate = R"(
#include "env-inl.h"
#include "node_builtins.h"
#include "node_external_reference.h"
#include "node_internals.h"

namespace node {

namespace builtins {

%.*s
namespace {
const ThreadsafeCopyOnWrite<BuiltinSourceMap> global_source_map {
  BuiltinSourceMap {
%.*s
  }  // BuiltinSourceMap
};  // ThreadsafeCopyOnWrite
}  // anonymous namespace

void BuiltinLoader::LoadJavaScriptSource() {
  source_ = global_source_map;
}

void RegisterExternalReferencesForInternalizedBuiltinCode(
  ExternalReferenceRegistry* registry) {
%.*s
}

UnionBytes BuiltinLoader::GetConfig() {
  return UnionBytes(&config_resource);
}

}  // namespace builtins

}  // namespace node
)";

Fragment Format(const Fragments& definitions,
                const Fragments& initializers,
                const Fragments& registrations) {
  std::vector<char> def_buf = Join(definitions, "\n");
  size_t def_size = def_buf.size();
  std::vector<char> init_buf = Join(initializers, "\n");
  size_t init_size = init_buf.size();
  std::vector<char> reg_buf = Join(registrations, "\n");
  size_t reg_size = reg_buf.size();

  size_t result_size =
      def_size + init_size + reg_size + strlen(kTemplate) + 100;
  std::vector<char> result(result_size, 0);
  int r = snprintf(result.data(),
                   result_size,
                   kTemplate,
                   static_cast<int>(def_buf.size()),
                   def_buf.data(),
                   static_cast<int>(init_buf.size()),
                   init_buf.data(),
                   static_cast<int>(reg_buf.size()),
                   reg_buf.data());
  result.resize(r);
  return result;
}

std::vector<char> ReadFileSync(const char* path, size_t size, int* error) {
  uv_fs_t req;
  Debug("ReadFileSync %s with size %zu\n", path, size);

  uv_file file = uv_fs_open(nullptr, &req, path, O_RDONLY, 0, nullptr);
  if (req.result < 0) {
    uv_fs_req_cleanup(&req);
    *error = req.result;
    return std::vector<char>();
  }
  uv_fs_req_cleanup(&req);

  std::vector<char> contents(size);
  size_t offset = 0;

  while (offset < size) {
    uv_buf_t buf = uv_buf_init(contents.data() + offset, size - offset);
    int bytes_read = uv_fs_read(nullptr, &req, file, &buf, 1, offset, nullptr);
    offset += bytes_read;
    *error = req.result;
    uv_fs_req_cleanup(&req);
    if (*error < 0) {
      uv_fs_close(nullptr, &req, file, nullptr);
      // We can't do anything if uv_fs_close returns error, so just return.
      return std::vector<char>();
    }
    if (bytes_read <= 0) {
      break;
    }
  }
  assert(offset == size);

  *error = uv_fs_close(nullptr, &req, file, nullptr);
  return contents;
}

int WriteFileSync(const std::vector<char>& out, const char* path) {
  Debug("WriteFileSync %zu bytes to %s\n", out.size(), path);
  uv_fs_t req;
  uv_file file = uv_fs_open(nullptr,
                            &req,
                            path,
                            UV_FS_O_CREAT | UV_FS_O_WRONLY | UV_FS_O_TRUNC,
                            S_IWUSR | S_IRUSR,
                            nullptr);
  int err = req.result;
  uv_fs_req_cleanup(&req);
  if (err < 0) {
    return err;
  }

  uv_buf_t buf = uv_buf_init(const_cast<char*>(out.data()), out.size());
  err = uv_fs_write(nullptr, &req, file, &buf, 1, 0, nullptr);
  uv_fs_req_cleanup(&req);

  int r = uv_fs_close(nullptr, &req, file, nullptr);
  uv_fs_req_cleanup(&req);
  if (err < 0) {
    // We can't do anything if uv_fs_close returns error, so just return.
    return err;
  }
  return r;
}

int WriteIfChanged(const Fragment& out, const std::string& dest) {
  Debug("output size %zu\n", out.size());

  int error = 0;
  size_t size = GetFileSize(dest, &error);
  if (error != 0 && error != UV_ENOENT) {
    return error;
  }
  Debug("existing size %zu\n", size);

  bool changed = true;
  // If it's not the same size, the file is definitely changed so we'll
  // just proceed to update. Otherwise check the content before deciding
  // whether we want to write it.
  if (error != UV_ENOENT && size == out.size()) {
    std::vector<char> content = ReadFileSync(dest.c_str(), size, &error);
    if (error == 0) {  // In case of error, always write the file.
      changed = (memcmp(content.data(), out.data(), size) != 0);
    }
  }
  if (!changed) {
    Debug("No change, return\n");
    return 0;
  }
  return WriteFileSync(out, dest.c_str());
}

std::string GetFileId(const std::string& filename) {
  size_t end = filename.size();
  size_t start = 0;
  std::string prefix;
  // Strip .mjs and .js suffix
  if (EndsWith(filename, kMjsSuffix)) {
    end -= kMjsSuffix.size();
  } else if (EndsWith(filename, kJsSuffix)) {
    end -= kJsSuffix.size();
  }

  // deps/acorn/acorn/dist/acorn.js -> internal/deps/acorn/acorn/dist/acorn
  if (StartsWith(filename, depsPrefix)) {
    start = depsPrefix.size();
    prefix = "internal/deps/";
  } else if (StartsWith(filename, libPrefix)) {
    // lib/internal/url.js -> internal/url
    start = libPrefix.size();
    prefix = "";
  }

  return prefix + std::string(filename.begin() + start, filename.begin() + end);
}

std::string GetVariableName(const std::string& id) {
  std::string result = id;
  size_t length = result.size();

  for (size_t i = 0; i < length; ++i) {
    if (result[i] == '.' || result[i] == '-' || result[i] == '/') {
      result[i] = '_';
    }
  }
  return result;
}

std::vector<std::string> GetCodeTable() {
  size_t size = 1 << 16;
  std::vector<std::string> code_table(size);
  for (size_t i = 0; i < size; ++i) {
    code_table[i] = std::to_string(i) + ',';
  }
  return code_table;
}

const std::string& GetCode(uint16_t index) {
  static std::vector<std::string> table = GetCodeTable();
  return table[index];
}

#ifdef NODE_JS2C_USE_STRING_LITERALS
const char* string_literal_def_template = "static const %s *%s_raw = ";
constexpr std::string_view latin1_string_literal_start =
    "reinterpret_cast<const uint8_t*>(\"";
constexpr std::string_view ascii_string_literal_start =
    "reinterpret_cast<const uint8_t*>(R\"JS2C1b732aee(";
constexpr std::string_view utf16_string_literal_start =
    "reinterpret_cast<const uint16_t*>(uR\"JS2C1b732aee(";
constexpr std::string_view latin1_string_literal_end = "\");";
constexpr std::string_view utf_string_literal_end = ")JS2C1b732aee\");";
#else
const char* array_literal_def_template = "static const %s %s_raw[] = ";
constexpr std::string_view array_literal_start = "{\n";
constexpr std::string_view array_literal_end = "\n};\n\n";
#endif

// Definitions:
// static const uint8_t fs_raw[] = {
//  ....
// };
//
// static StaticExternalOneByteResource fs_resource(fs_raw, 1234, nullptr);
//
// static const uint16_t internal_cli_table_raw[] = {
//  ....
// };
//
// static StaticExternalTwoByteResource
// internal_cli_table_resource(internal_cli_table_raw, 1234, nullptr);
//
// If NODE_JS2C_USE_STRING_LITERALS is defined, the data is output as C++
// raw strings (i.e. R"JS2C1b732aee(...)JS2C1b732aee") rather than as an
// array. This speeds up compilation for gcc/clang.
enum class CodeType {
  kAscii,   // Code points are all within 0-127
  kLatin1,  // Code points are all within 0-255
  kTwoByte,
};
template <typename T>
Fragment GetDefinitionImpl(const std::vector<char>& code,
                           const std::string& var,
                           CodeType type) {
  constexpr bool is_two_byte = std::is_same_v<T, uint16_t>;
  static_assert(is_two_byte || std::is_same_v<T, char>);

  size_t count = is_two_byte
                     ? simdutf::utf16_length_from_utf8(code.data(), code.size())
                     : code.size();
  constexpr const char* arr_type = is_two_byte ? "uint16_t" : "uint8_t";
  constexpr const char* resource_type = is_two_byte
                                            ? "StaticExternalTwoByteResource"
                                            : "StaticExternalOneByteResource";

#ifdef NODE_JS2C_USE_STRING_LITERALS
  const char* literal_def_template = string_literal_def_template;
  // For code that contains Latin-1 characters, be conservative and assume
  // they all need escaping: one "\" and three digits.
  size_t unit = type == CodeType::kLatin1 ? 4 : 1;
  size_t def_size = 512 + code.size() * unit;
#else
  const char* literal_def_template = array_literal_def_template;
  constexpr size_t unit =
      (is_two_byte ? 5 : 3) + 1;  // 0-65536 or 0-255 and a ","
  size_t def_size = 512 + count * unit;
#endif

  Fragment result(def_size, 0);

  int cur = snprintf(
      result.data(), def_size, literal_def_template, arr_type, var.c_str());

  assert(cur != 0);

#ifdef NODE_JS2C_USE_STRING_LITERALS
  std::string_view start_string_view;
  switch (type) {
    case CodeType::kAscii:
      start_string_view = ascii_string_literal_start;
      break;
    case CodeType::kLatin1:
      start_string_view = latin1_string_literal_start;
      break;
    case CodeType::kTwoByte:
      start_string_view = utf16_string_literal_start;
      break;
  }

  memcpy(
      result.data() + cur, start_string_view.data(), start_string_view.size());
  cur += start_string_view.size();

  if (type != CodeType::kLatin1) {
    memcpy(result.data() + cur, code.data(), code.size());
    cur += code.size();
  } else {
    const uint8_t* ptr = reinterpret_cast<const uint8_t*>(code.data());
    for (size_t i = 0; i < count; ++i) {
      // Avoid using snprintf on large chunks of data because it's much slower.
      // It's fine to use it on small amount of data though.
      uint8_t ch = ptr[i];
      if (ch > 127) {
        Debug("In %s, found non-ASCII Latin-1 character at %zu: %d\n",
              var.c_str(),
              i,
              ch);
      }
      const std::string& str = GetOctalCode(ch);
      memcpy(result.data() + cur, str.c_str(), str.size());
      cur += str.size();
    }
  }

  std::string_view string_literal_end;
  switch (type) {
    case CodeType::kAscii:
      string_literal_end = utf_string_literal_end;
      break;
    case CodeType::kLatin1:
      string_literal_end = latin1_string_literal_end;
      break;
    case CodeType::kTwoByte:
      string_literal_end = utf_string_literal_end;
      break;
  }
  memcpy(result.data() + cur,
         string_literal_end.data(),
         string_literal_end.size());
  cur += string_literal_end.size();
#else
  memcpy(result.data() + cur,
         array_literal_start.data(),
         array_literal_start.size());
  cur += array_literal_start.size();

  // Avoid using snprintf on large chunks of data because it's much slower.
  // It's fine to use it on small amount of data though.
  if constexpr (is_two_byte) {
    std::vector<uint16_t> utf16_codepoints;
    utf16_codepoints.resize(count);
    size_t utf16_count = simdutf::convert_utf8_to_utf16(
        code.data(),
        code.size(),
        reinterpret_cast<char16_t*>(utf16_codepoints.data()));
    assert(utf16_count != 0);
    utf16_codepoints.resize(utf16_count);
    Debug("static size %zu\n", utf16_count);
    for (size_t i = 0; i < utf16_count; ++i) {
      const std::string& str = GetCode(utf16_codepoints[i]);
      memcpy(result.data() + cur, str.c_str(), str.size());
      cur += str.size();
    }
  } else {
    const uint8_t* ptr = reinterpret_cast<const uint8_t*>(code.data());
    for (size_t i = 0; i < count; ++i) {
      uint16_t ch = static_cast<uint16_t>(ptr[i]);
      if (ch > 127) {
        Debug("In %s, found non-ASCII Latin-1 character at %zu: %d\n",
              var.c_str(),
              i,
              ch);
      }
      const std::string& str = GetCode(ch);
      memcpy(result.data() + cur, str.c_str(), str.size());
      cur += str.size();
    }
  }

  memcpy(
      result.data() + cur, array_literal_end.data(), array_literal_end.size());
  cur += array_literal_end.size();
#endif

  int end_size = snprintf(result.data() + cur,
                          result.size() - cur,
                          "static %s %s_resource(%s_raw, %zu, nullptr);\n",
                          resource_type,
                          var.c_str(),
                          var.c_str(),
                          count);
  cur += end_size;
  result.resize(cur);
  return result;
}

bool Simplify(const std::vector<char>& code,
              const std::string& var,
              std::vector<char>* simplified) {
  // Allowlist files to avoid false positives.
  // TODO(joyeecheung): this could be removed if undici updates itself
  // to replace "’" with "'" though we could still keep this skeleton in
  // place for future hot fixes that are verified by humans.
  if (var != "internal_deps_undici_undici") {
    return false;
  }

  size_t code_size = code.size();
  simplified->reserve(code_size);
  const uint8_t* ptr = reinterpret_cast<const uint8_t*>(code.data());
  size_t simplified_count = 0;
  for (size_t i = 0; i < code_size; ++i) {
    switch (ptr[i]) {
      case 226: {  // ’ [ 226, 128, 153 ] -> '
        if (i + 2 < code_size && ptr[i + 1] == 128 && ptr[i + 2] == 153) {
          simplified->push_back('\'');
          i += 2;
          simplified_count++;
          break;
        }
        [[fallthrough]];
      }
      default: {
        simplified->push_back(code[i]);
        break;
      }
    }
  }

  if (simplified_count > 0) {
    Debug("Simplified %lu characters, ", simplified_count);
    Debug("old size %lu, new size %lu\n", code_size, simplified->size());
    return true;
  }
  return false;
}

Fragment GetDefinition(const std::string& var, const std::vector<char>& code) {
  Debug("GetDefinition %s, code size %zu\n", var.c_str(), code.size());
  bool is_ascii = simdutf::validate_ascii(code.data(), code.size());

  if (is_ascii) {
    Debug("ASCII-only, static size %zu\n", code.size());
    return GetDefinitionImpl<char>(code, var, CodeType::kAscii);
  }

  std::vector<char> latin1(code.size());
  auto result = simdutf::convert_utf8_to_latin1_with_errors(
      code.data(), code.size(), latin1.data());
  if (!result.error) {
    latin1.resize(result.count);
    Debug("Latin-1-only, old size %zu, new size %zu\n",
          code.size(),
          latin1.size());
    return GetDefinitionImpl<char>(latin1, var, CodeType::kLatin1);
  }

  // Since V8 only supports Latin-1 and UTF16 as underlying representation
  // we have to encode all files containing two-byte characters as UTF16.
  // While some files do need two-byte characters, some just
  // unintentionally have them. Replace certain characters that are known
  // to have sane one-byte equivalent to save space.
  std::vector<char> simplified;
  if (Simplify(code, var, &simplified)) {  // Changed.
    Debug("%s is simplified, re-generate definition\n", var.c_str());
    return GetDefinition(var, simplified);
  }

  // Simplification did not turn the code into 1-byte string. Just
  // use the original.
  return GetDefinitionImpl<uint16_t>(code, var, CodeType::kTwoByte);
}

int AddModule(const std::string& filename,
              Fragments* definitions,
              Fragments* initializers,
              Fragments* registrations) {
  Debug("AddModule %s start\n", filename.c_str());

  int error = 0;
  size_t file_size = GetFileSize(filename, &error);
  if (error != 0) {
    return error;
  }
  std::vector<char> code = ReadFileSync(filename.c_str(), file_size, &error);
  if (error != 0) {
    return error;
  }
  std::string file_id = GetFileId(filename);
  std::string var = GetVariableName(file_id);

  definitions->emplace_back(GetDefinition(var, code));

  // Initializers of the BuiltinSourceMap:
  // {"fs", UnionBytes{&fs_resource}},
  Fragment& init_buf = initializers->emplace_back(Fragment(256, 0));
  int init_size = snprintf(init_buf.data(),
                           init_buf.size(),
                           "    {\"%s\", UnionBytes(&%s_resource) },",
                           file_id.c_str(),
                           var.c_str());
  init_buf.resize(init_size);

  // Registrations:
  // registry->Register(&fs_resource);
  Fragment& reg_buf = registrations->emplace_back(Fragment(256, 0));
  int reg_size = snprintf(reg_buf.data(),
                          reg_buf.size(),
                          "  registry->Register(&%s_resource);",
                          var.c_str());
  reg_buf.resize(reg_size);
  return 0;
}

std::vector<char> ReplaceAll(const std::vector<char>& data,
                             const std::string& search,
                             const std::string& replacement) {
  auto cur = data.begin();
  auto last = data.begin();
  std::vector<char> result;
  result.reserve(data.size());
  while ((cur = std::search(last, data.end(), search.begin(), search.end())) !=
         data.end()) {
    result.insert(result.end(), last, cur);
    result.insert(result.end(),
                  replacement.c_str(),
                  replacement.c_str() + replacement.size());
    last = cur + search.size();
  }
  result.insert(result.end(), last, data.end());
  return result;
}

std::vector<char> StripComments(const std::vector<char>& input) {
  std::vector<char> result;
  result.reserve(input.size());

  auto last_hash = input.cbegin();
  auto line_begin = input.cbegin();
  auto end = input.cend();
  while ((last_hash = std::find(line_begin, end, '#')) != end) {
    result.insert(result.end(), line_begin, last_hash);
    line_begin = std::find(last_hash, end, '\n');
    if (line_begin != end) {
      line_begin += 1;
    }
  }
  result.insert(result.end(), line_begin, end);
  return result;
}

// This is technically unused for our config.gypi, but just porting it here to
// mimic js2c.py.
std::vector<char> JoinMultilineString(const std::vector<char>& input) {
  std::vector<char> result;
  result.reserve(input.size());

  auto closing_quote = input.cbegin();
  auto last_inserted = input.cbegin();
  auto end = input.cend();
  std::string search = "'\n";
  while ((closing_quote = std::search(
              last_inserted, end, search.begin(), search.end())) != end) {
    if (closing_quote != last_inserted) {
      result.insert(result.end(), last_inserted, closing_quote - 1);
      last_inserted = closing_quote - 1;
    }
    auto opening_quote = closing_quote + 2;
    while (opening_quote != end && isspace(*opening_quote)) {
      opening_quote++;
    }
    if (opening_quote == end) {
      break;
    }
    if (*opening_quote == '\'') {
      last_inserted = opening_quote + 1;
    } else {
      result.insert(result.end(), last_inserted, opening_quote);
      last_inserted = opening_quote;
    }
  }
  result.insert(result.end(), last_inserted, end);
  return result;
}

std::vector<char> JSONify(const std::vector<char>& code) {
  // 1. Remove string comments
  std::vector<char> stripped = StripComments(code);

  // 2. join multiline strings
  std::vector<char> joined = JoinMultilineString(stripped);

  // 3. normalize string literals from ' into "
  for (size_t i = 0; i < joined.size(); ++i) {
    if (joined[i] == '\'') {
      joined[i] = '"';
    }
  }

  // 4. turn pseudo-booleans strings into Booleans
  std::vector<char> result3 = ReplaceAll(joined, R"("true")", "true");
  std::vector<char> result4 = ReplaceAll(result3, R"("false")", "false");

  return result4;
}

int AddGypi(const std::string& var,
            const std::string& filename,
            Fragments* definitions) {
  Debug("AddGypi %s start\n", filename.c_str());

  int error = 0;
  size_t file_size = GetFileSize(filename, &error);
  if (error != 0) {
    return error;
  }
  std::vector<char> code = ReadFileSync(filename.c_str(), file_size, &error);
  if (error != 0) {
    return error;
  }
  assert(var == "config");

  std::vector<char> transformed = JSONify(code);
  definitions->emplace_back(GetDefinition(var, transformed));
  return 0;
}

int JS2C(const FileList& js_files,
         const FileList& mjs_files,
         const std::string& config,
         const std::string& dest) {
  Fragments definitions;
  definitions.reserve(js_files.size() + mjs_files.size() + 1);
  Fragments initializers;
  initializers.reserve(js_files.size() + mjs_files.size());
  Fragments registrations;
  registrations.reserve(js_files.size() + mjs_files.size() + 1);

  for (const auto& filename : js_files) {
    int r = AddModule(filename, &definitions, &initializers, &registrations);
    if (r != 0) {
      return r;
    }
  }
  for (const auto& filename : mjs_files) {
    int r = AddModule(filename, &definitions, &initializers, &registrations);
    if (r != 0) {
      return r;
    }
  }

  assert(FilenameIsConfigGypi(config));
  // "config.gypi" -> config_raw.
  int r = AddGypi("config", config, &definitions);
  if (r != 0) {
    return r;
  }
  Fragment out = Format(definitions, initializers, registrations);
  return WriteIfChanged(out, dest);
}

int PrintUsage(const char* argv0) {
  fprintf(stderr,
          "Usage: %s [--verbose] [--root /path/to/project/root] "
          "path/to/output.cc path/to/directory "
          "[extra-files ...]\n",
          argv0);
  return 1;
}

int Main(int argc, char* argv[]) {
  if (argc < 3) {
    return PrintUsage(argv[0]);
  }

  std::vector<std::string> args;
  args.reserve(argc);
  std::string root_dir;
  for (int i = 1; i < argc; ++i) {
    std::string arg(argv[i]);
    if (arg == "--verbose") {
      is_verbose = true;
    } else if (arg == "--root") {
      if (i == argc - 1) {
        fprintf(stderr, "--root must be followed by a path\n");
        return 1;
      }
      root_dir = argv[++i];
    } else {
      args.emplace_back(argv[i]);
    }
  }

  if (args.size() < 2) {
    return PrintUsage(argv[0]);
  }

  if (!root_dir.empty()) {
    int r = uv_chdir(root_dir.c_str());
    if (r != 0) {
      fprintf(stderr, "Cannot switch to the directory specified by --root\n");
      PrintUvError("chdir", root_dir.c_str(), r);
      return 1;
    }
  }
  std::string output = args[0];

  FileMap file_map;
  for (size_t i = 1; i < args.size(); ++i) {
    int error = 0;
    const std::string& file = args[i];
    if (IsDirectory(file, &error)) {
      if (!SearchFiles(file, &file_map, std::string(kJsSuffix)) ||
          !SearchFiles(file, &file_map, std::string(kMjsSuffix))) {
        return 1;
      }
    } else if (error != 0) {
      return 1;
    } else {  // It's a file.
      std::string_view extension = HasAllowedExtensions(file);
      if (extension.size() != 0) {
        auto it = file_map.insert({std::string(extension), FileList()}).first;
        it->second.push_back(file);
      } else {
        fprintf(stderr, "Unsupported file: %s\n", file.c_str());
        return 1;
      }
    }
  }

  // Should have exactly 3 types: `.js`, `.mjs` and `.gypi`.
  assert(file_map.size() == 3);
  auto gypi_it = file_map.find(".gypi");
  // Currently config.gypi is the only `.gypi` file allowed
  if (gypi_it == file_map.end() || gypi_it->second.size() != 1 ||
      !FilenameIsConfigGypi(gypi_it->second[0])) {
    fprintf(
        stderr,
        "Arguments should contain one and only one .gypi file: config.gypi\n");
    return 1;
  }
  auto js_it = file_map.find(".js");
  auto mjs_it = file_map.find(".mjs");
  assert(js_it != file_map.end() && mjs_it != file_map.end());

  auto it = std::find(mjs_it->second.begin(),
                      mjs_it->second.end(),
                      "lib/eslint.config_partial.mjs");
  if (it != mjs_it->second.end()) {
    mjs_it->second.erase(it);
  }

  std::sort(js_it->second.begin(), js_it->second.end());
  std::sort(mjs_it->second.begin(), mjs_it->second.end());

  return JS2C(js_it->second, mjs_it->second, gypi_it->second[0], output);
}
}  // namespace js2c
}  // namespace node

NODE_MAIN(int argc, node::argv_type raw_argv[]) {
  char** argv;
  node::FixupMain(argc, raw_argv, &argv);
  return node::js2c::Main(argc, argv);
}