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 <http://www.gnu.org/licenses/>.
 */
 
#include "../stdafx.h"
#include "../string_func.h"
#include "../strings_type.h"
#include "../misc/getoptdata.h"
#include "../ini_type.h"
#include "../core/mem_func.hpp"
#include "../error_func.h"
 
#include <filesystem>
 
#include "../safeguards.h"
 
[[noreturn]] void FatalErrorI(const std::string &msg)
{
  fmt::print(stderr, "settingsgen: FATAL: {}\n", msg);
  exit(1);
}
 
static const size_t OUTPUT_BLOCK_SIZE = 16000; 
 
class OutputBuffer {
public:
  void Clear()
  {
    this->size = 0;
  }
 
  size_t Add(const char *text, size_t length)
  {
    size_t store_size = std::min(length, OUTPUT_BLOCK_SIZE - this->size);
    assert(store_size <= OUTPUT_BLOCK_SIZE);
    MemCpyT(this->data + this->size, text, store_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(const char *text, size_t length = 0)
  {
    if (length == 0) length = strlen(text);
 
    if (length > 0 && this->BufferHasRoom()) {
      size_t stored_size = this->output_buffer[this->output_buffer.size() - 1].Add(text, length);
      length -= stored_size;
      text += stored_size;
    }
    while (length > 0) {
      OutputBuffer &block = this->output_buffer.emplace_back();
      block.Clear(); // Initialize the new block.
      size_t stored_size = block.Add(text, length);
      length -= stored_size;
      text += 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(const std::string &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(const char * const pre, const char * const buffer, const char * const post) override
  {
    FatalError("{}{}{}", pre, buffer, post);
  }
};
 
OutputStore _stored_output; 
OutputStore _post_amble_output; 
 
static const char *PREAMBLE_GROUP_NAME  = "pre-amble"; 
static const char *POSTAMBLE_GROUP_NAME = "post-amble"; 
static const char *TEMPLATES_GROUP_NAME = "templates"; 
static const char *VALIDATION_GROUP_NAME = "validation"; 
static const char *DEFAULTS_GROUP_NAME  = "defaults"; 
 
static void DumpGroup(const IniLoadFile &ifile, const char * const 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.c_str());
        _stored_output.Add("\n", 1);
      }
    }
  }
}
 
static const char *FindItemValue(const char *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 || !item->value.has_value()) return nullptr;
  return item->value->c_str();
}
 
static void DumpLine(const IniItem *item, const IniGroup *grp, const IniGroup *default_grp, OutputStore &output)
{
  static const int MAX_VAR_LENGTH = 64;
 
  /* Prefix with #if/#ifdef/#ifndef */
  static const auto pp_lines = {"if", "ifdef", "ifndef"};
  int count = 0;
  for (const auto &name : pp_lines) {
    const char *condition = FindItemValue(name, grp, default_grp);
    if (condition != nullptr) {
      output.Add("#", 1);
      output.Add(name);
      output.Add(" ", 1);
      output.Add(condition);
      output.Add("\n", 1);
      count++;
    }
  }
 
  /* Output text of the template, except template variables of the form '$[_a-z0-9]+' which get replaced by their value. */
  const char *txt = item->value->c_str();
  while (*txt != '\0') {
    if (*txt != '$') {
      output.Add(txt, 1);
      txt++;
      continue;
    }
    txt++;
    if (*txt == '$') { // Literal $
      output.Add(txt, 1);
      txt++;
      continue;
    }
 
    /* Read variable. */
    char variable[MAX_VAR_LENGTH];
    int i = 0;
    while (i < MAX_VAR_LENGTH - 1) {
      if (!(txt[i] == '_' || (txt[i] >= 'a' && txt[i] <= 'z') || (txt[i] >= '0' && txt[i] <= '9'))) break;
      variable[i] = txt[i];
      i++;
    }
    variable[i] = '\0';
    txt += i;
 
    if (i > 0) {
      /* Find the text to output. */
      const char *valitem = FindItemValue(variable, grp, default_grp);
      if (valitem != nullptr) output.Add(valitem);
    } else {
      output.Add("$", 1);
    }
  }
  output.Add("\n", 1); // \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::find(std::begin(special_group_names), std::end(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(const char *fname, FILE *out_fp)
{
  if (fname == nullptr) 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(const char *n1, const char *n2)
{
  auto f2 = FileHandle::Open(n2, "rb");
  if (!f2.has_value()) return false;
 
  auto f1 = FileHandle::Open(n1, "rb");
  if (!f1.has_value()) {
    FatalError("can't open {}", n1);
  }
 
  size_t l1, l2;
  do {
    char b1[4096];
    char b2[4096];
    l1 = fread(b1, 1, sizeof(b1), *f1);
    l2 = fread(b2, 1, sizeof(b2), *f2);
 
    if (l1 != l2 || memcmp(b1, b2, l1) != 0) {
      return false;
    }
  } while (l1 != 0);
 
  return true;
}
 
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(const char *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[])
{
  const char *output_file = nullptr;
  const char *before_file = nullptr;
  const char *after_file = nullptr;
 
  GetOptData mgo(std::span(argv + 1, argc - 1), _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 == nullptr) {
    AppendFile(before_file, stdout);
    _stored_output.Write(stdout);
    _post_amble_output.Write(stdout);
    AppendFile(after_file, stdout);
  } else {
    static const char * const 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, const std::string &mode)
{
  auto f = fopen(filename.c_str(), mode.c_str());
  if (f == nullptr) return std::nullopt;
  return FileHandle(f);
}