settingsgen.cpp

Go to the documentation of this file.

/*
 * This file is part of OpenTTD.
 * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
 * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <https://www.gnu.org/licenses/old-licenses/gpl-2.0>.
 */

 
#include "../stdafx.h"
#include "../core/string_consumer.hpp"
#include "../string_func.h"
#include "../strings_type.h"
#include "../misc/getoptdata.h"
#include "../ini_type.h"
#include "../error_func.h"
 
#include <filesystem>
#include <fstream>
 
#include "../safeguards.h"
 
/* Doxygen in error_func.h */
[[noreturn]] void FatalErrorI(const std::string &str)
{
  fmt::print(stderr, "settingsgen: FATAL: {}\n", str);
  exit(1);
}
 
static const size_t OUTPUT_BLOCK_SIZE = 16000; 

class OutputBuffer {
public:
  void Clear()
  {
    this->size = 0;
  }

  size_t Add(std::string_view text)
  {
    size_t store_size = text.copy(this->data + this->size, OUTPUT_BLOCK_SIZE - this->size);
    this->size += store_size;
    return store_size;
  }

  void Write(FILE *out_fp) const
  {
    if (fwrite(this->data, 1, this->size, out_fp) != this->size) {
      FatalError("Cannot write output");
    }
  }

  bool HasRoom() const
  {
    return this->size < OUTPUT_BLOCK_SIZE;
  }
 
  size_t size;                  
  char data[OUTPUT_BLOCK_SIZE]; 
};

class OutputStore {
public:
  OutputStore()
  {
    this->Clear();
  }

  void Clear()
  {
    this->output_buffer.clear();
  }

  void Add(std::string_view text)
  {
    if (!text.empty() && this->BufferHasRoom()) {
      size_t stored_size = this->output_buffer[this->output_buffer.size() - 1].Add(text);
      text.remove_prefix(stored_size);
    }
    while (!text.empty()) {
      OutputBuffer &block = this->output_buffer.emplace_back();
      block.Clear(); // Initialize the new block.
      size_t stored_size = block.Add(text);
      text.remove_prefix(stored_size);
    }
  }

  void Write(FILE *out_fp) const
  {
    for (const OutputBuffer &out_data : output_buffer) {
      out_data.Write(out_fp);
    }
  }
 
private:
  bool BufferHasRoom() const
  {
    size_t num_blocks = this->output_buffer.size();
    return num_blocks > 0 && this->output_buffer[num_blocks - 1].HasRoom();
  }
 
  typedef std::vector<OutputBuffer> OutputBufferVector; 
  OutputBufferVector output_buffer; 
};
 

struct SettingsIniFile : IniLoadFile {
  SettingsIniFile(const IniGroupNameList &list_group_names = {}, const IniGroupNameList &seq_group_names = {}) :
      IniLoadFile(list_group_names, seq_group_names)
  {
  }
 
  std::optional<FileHandle> OpenFile(std::string_view filename, Subdirectory, size_t *size) override
  {
    /* Open the text file in binary mode to prevent end-of-line translations
     * done by ftell() and friends, as defined by K&R. */
    auto in = FileHandle::Open(filename, "rb");
    if (!in.has_value()) return in;
 
    fseek(*in, 0L, SEEK_END);
    *size = ftell(*in);
    fseek(*in, 0L, SEEK_SET); // Seek back to the start of the file.
 
    return in;
  }
 
  void ReportFileError(std::string_view message) override
  {
    FatalError("{}", message);
  }
};
 
OutputStore _stored_output; 
OutputStore _post_amble_output; 
 
static const std::string_view PREAMBLE_GROUP_NAME  = "pre-amble"; 
static const std::string_view POSTAMBLE_GROUP_NAME = "post-amble"; 
static const std::string_view TEMPLATES_GROUP_NAME = "templates"; 
static const std::string_view VALIDATION_GROUP_NAME = "validation"; 
static const std::string_view DEFAULTS_GROUP_NAME  = "defaults"; 

static void DumpGroup(const IniLoadFile &ifile, std::string_view group_name)
{
  const IniGroup *grp = ifile.GetGroup(group_name);
  if (grp != nullptr && grp->type == IGT_SEQUENCE) {
    for (const IniItem &item : grp->items) {
      if (!item.name.empty()) {
        _stored_output.Add(item.name);
        _stored_output.Add("\n");
      }
    }
  }
}

static std::optional<std::string_view> FindItemValue(std::string_view name, const IniGroup *grp, const IniGroup *defaults)
{
  const IniItem *item = grp->GetItem(name);
  if (item == nullptr && defaults != nullptr) item = defaults->GetItem(name);
  if (item == nullptr) return std::nullopt;
  return item->value;
}

static void DumpLine(const IniItem *item, const IniGroup *grp, const IniGroup *default_grp, OutputStore &output)
{
  /* Prefix with #if/#ifdef/#ifndef */
  static const auto pp_lines = {"if", "ifdef", "ifndef"};
  int count = 0;
  for (const auto &name : pp_lines) {
    auto condition = FindItemValue(name, grp, default_grp);
    if (condition.has_value()) {
      output.Add("#");
      output.Add(name);
      output.Add(" ");
      output.Add(*condition);
      output.Add("\n");
      count++;
    }
  }
 
  /* Output text of the template, except template variables of the form '$[_a-z0-9]+' which get replaced by their value. */
  static const std::string_view variable_name_characters = "_abcdefghijklmnopqrstuvwxyz0123456789";
  StringConsumer consumer{*item->value};
  while (consumer.AnyBytesLeft()) {
    char c = consumer.ReadChar();
    if (c != '$' || consumer.ReadIf("$")) {
      /* No $ or $$ (literal $). */
      output.Add(std::string_view{&c, 1});
      continue;
    }
 
    std::string_view variable = consumer.ReadUntilCharNotIn(variable_name_characters);
    if (!variable.empty()) {
      /* Find the text to output. */
      auto valitem = FindItemValue(variable, grp, default_grp);
      if (valitem.has_value()) output.Add(*valitem);
    } else {
      output.Add("$");
    }
  }
  output.Add("\n"); // \n after the expanded template.
  while (count > 0) {
    output.Add("#endif\n");
    count--;
  }
}

static void DumpSections(const IniLoadFile &ifile)
{
  static const auto special_group_names = {PREAMBLE_GROUP_NAME, POSTAMBLE_GROUP_NAME, DEFAULTS_GROUP_NAME, TEMPLATES_GROUP_NAME, VALIDATION_GROUP_NAME};
 
  const IniGroup *default_grp = ifile.GetGroup(DEFAULTS_GROUP_NAME);
  const IniGroup *templates_grp = ifile.GetGroup(TEMPLATES_GROUP_NAME);
  const IniGroup *validation_grp = ifile.GetGroup(VALIDATION_GROUP_NAME);
  if (templates_grp == nullptr) return;
 
  /* Output every group, using its name as template name. */
  for (const IniGroup &grp : ifile.groups) {
    /* Exclude special group names. */
    if (std::ranges::find(special_group_names, grp.name) != std::end(special_group_names)) continue;
 
    const IniItem *template_item = templates_grp->GetItem(grp.name); // Find template value.
    if (template_item == nullptr || !template_item->value.has_value()) {
      FatalError("Cannot find template {}", grp.name);
    }
    DumpLine(template_item, &grp, default_grp, _stored_output);
 
    if (validation_grp != nullptr) {
      const IniItem *validation_item = validation_grp->GetItem(grp.name); // Find template value.
      if (validation_item != nullptr && validation_item->value.has_value()) {
        DumpLine(validation_item, &grp, default_grp, _post_amble_output);
      }
    }
  }
}

static void AppendFile(std::optional<std::string_view> fname, FILE *out_fp)
{
  if (!fname.has_value()) return;
 
  auto in_fp = FileHandle::Open(*fname, "r");
  if (!in_fp.has_value()) {
    FatalError("Cannot open file {} for copying", *fname);
  }
 
  char buffer[4096];
  size_t length;
  do {
    length = fread(buffer, 1, lengthof(buffer), *in_fp);
    if (fwrite(buffer, 1, length, out_fp) != length) {
      FatalError("Cannot copy file");
    }
  } while (length == lengthof(buffer));
}

static bool CompareFiles(std::filesystem::path path1, std::filesystem::path path2)
{
  /* Check for equal size, but ignore the error code for cases when a file does not exist. */
  std::error_code error_code;
  if (std::filesystem::file_size(path1, error_code) != std::filesystem::file_size(path2, error_code)) return false;
 
  std::ifstream stream1(path1, std::ifstream::binary);
  std::ifstream stream2(path2, std::ifstream::binary);
 
  return std::equal(std::istreambuf_iterator<char>(stream1.rdbuf()),
      std::istreambuf_iterator<char>(),
      std::istreambuf_iterator<char>(stream2.rdbuf()));
}

static const OptionData _opts[] = {
  { .type = ODF_NO_VALUE, .id = 'h', .shortname = 'h', .longname = "--help" },
  { .type = ODF_NO_VALUE, .id = 'h', .shortname = '?' },
  { .type = ODF_HAS_VALUE, .id = 'o', .shortname = 'o', .longname = "--output" },
  { .type = ODF_HAS_VALUE, .id = 'b', .shortname = 'b', .longname = "--before" },
  { .type = ODF_HAS_VALUE, .id = 'a', .shortname = 'a', .longname = "--after" },
};

static void ProcessIniFile(std::string_view fname)
{
  static const IniLoadFile::IniGroupNameList seq_groups = {PREAMBLE_GROUP_NAME, POSTAMBLE_GROUP_NAME};
 
  SettingsIniFile ini{{}, seq_groups};
  ini.LoadFromDisk(fname, NO_DIRECTORY);
 
  DumpGroup(ini, PREAMBLE_GROUP_NAME);
  DumpSections(ini);
  DumpGroup(ini, POSTAMBLE_GROUP_NAME);
}

int CDECL main(int argc, char *argv[])
{
  std::optional<std::string_view> output_file;
  std::optional<std::string_view> before_file;
  std::optional<std::string_view> after_file;
 
  std::vector<std::string_view> params;
  for (int i = 1; i < argc; ++i) params.emplace_back(argv[i]);
  GetOptData mgo(params, _opts);
  for (;;) {
    int i = mgo.GetOpt();
    if (i == -1) break;
 
    switch (i) {
      case 'h':
        fmt::print("settingsgen\n"
            "Usage: settingsgen [options] ini-file...\n"
            "with options:\n"
            "   -h, -?, --help          Print this help message and exit\n"
            "   -b FILE, --before FILE  Copy FILE before all settings\n"
            "   -a FILE, --after FILE   Copy FILE after all settings\n"
            "   -o FILE, --output FILE  Write output to FILE\n");
        return 0;
 
      case 'o':
        output_file = mgo.opt;
        break;
 
      case 'a':
        after_file = mgo.opt;
        break;
 
      case 'b':
        before_file = mgo.opt;
        break;
 
      case -2:
        fmt::print(stderr, "Invalid arguments\n");
        return 1;
    }
  }
 
  _stored_output.Clear();
  _post_amble_output.Clear();
 
  for (auto &argument : mgo.arguments) ProcessIniFile(argument);
 
  /* Write output. */
  if (!output_file.has_value()) {
    AppendFile(before_file, stdout);
    _stored_output.Write(stdout);
    _post_amble_output.Write(stdout);
    AppendFile(after_file, stdout);
  } else {
    static const std::string_view tmp_output = "tmp2.xxx";
 
    auto fp = FileHandle::Open(tmp_output, "w");
    if (!fp.has_value()) {
      FatalError("Cannot open file {}", tmp_output);
    }
    AppendFile(before_file, *fp);
    _stored_output.Write(*fp);
    _post_amble_output.Write(*fp);
    AppendFile(after_file, *fp);
    fp.reset();
 
    std::error_code error_code;
    if (CompareFiles(tmp_output, *output_file)) {
      /* Files are equal. tmp2.xxx is not needed. */
      std::filesystem::remove(tmp_output, error_code);
    } else {
      /* Rename tmp2.xxx to output file. */
      std::filesystem::rename(tmp_output, *output_file, error_code);
      if (error_code) FatalError("rename({}, {}) failed: {}", tmp_output, *output_file, error_code.message());
    }
  }
  return 0;
}
 
std::optional<FileHandle> FileHandle::Open(const std::string &filename, std::string_view mode)
{
  auto f = fopen(filename.c_str(), std::string{mode}.c_str());
  if (f == nullptr) return std::nullopt;
  return FileHandle(f);
}