strgen.h

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>.
 */

 
#ifndef STRGEN_H
#define STRGEN_H
 
#include "../core/string_consumer.hpp"
#include "../language.h"
#include "../string_type.h"
#include "../3rdparty/fmt/format.h"
 
#include <unordered_map>
#include <array>

struct Case {
  uint8_t caseidx;       
  std::string string; 
 
  Case(uint8_t caseidx, std::string_view string);
};

struct LangString {
  std::string name;       
  std::string english;    
  std::string translated; 
  size_t index;           
  size_t line;            
  std::vector<Case> translated_cases; 
 
  LangString(std::string_view name, std::string_view english, size_t index, size_t line);
  void FreeTranslation();
};

struct StringData {
  std::vector<std::shared_ptr<LangString>> strings; 
  std::unordered_map<std::string, std::shared_ptr<LangString>, StringHash, std::equal_to<>> name_to_string; 
  size_t tabs;          
  size_t max_strings;   
  size_t next_string_id;
 
  StringData(size_t tabs);
  void FreeTranslation();
  void Add(std::shared_ptr<LangString> ls);
  LangString *Find(std::string_view s);
  uint32_t Version() const;
  size_t CountInUse(size_t tab) const;
};

struct StringReader {
  StringData &data; 
  const std::string file; 
  bool master;      
  bool translation; 
 
  StringReader(StringData &data, const std::string &file, bool master, bool translation);
  virtual ~StringReader() = default;
  void HandleString(std::string_view str);

  virtual std::optional<std::string> ReadLine() = 0;

  virtual void HandlePragma(std::string_view str, LanguagePackHeader &lang);

  virtual void ParseFile();
};

struct HeaderWriter {
  virtual void WriteStringID(const std::string &name, size_t stringid) = 0;

  virtual void Finalise(const StringData &data) = 0;

  virtual ~HeaderWriter() = default;
 
  void WriteHeader(const StringData &data);
};

struct LanguageWriter {
  virtual void WriteHeader(const LanguagePackHeader *header) = 0;

  virtual void Write(std::string_view buffer) = 0;

  virtual void Finalise() = 0;

  virtual ~LanguageWriter() = default;
 
  virtual void WriteLength(size_t length);
  virtual void WriteLang(const StringData &data);
};
 
struct CmdStruct;
 
struct CmdPair {
  const CmdStruct *cmd;
  std::string param;
 
  auto operator<=>(const CmdPair &other) const = default;
};
 
struct ParsedCommandStruct {
  std::vector<CmdPair> non_consuming_commands;
  std::array<const CmdStruct*, 32> consuming_commands{ nullptr }; 
};
 
const CmdStruct *TranslateCmdForCompare(const CmdStruct *a);
ParsedCommandStruct ExtractCommandString(std::string_view s, bool warnings);
 
void StrgenWarningI(const std::string &msg);
void StrgenErrorI(const std::string &msg);
[[noreturn]] void StrgenFatalI(const std::string &msg);
#define StrgenWarning(format_string, ...) StrgenWarningI(fmt::format(FMT_STRING(format_string) __VA_OPT__(,) __VA_ARGS__))
#define StrgenError(format_string, ...) StrgenErrorI(fmt::format(FMT_STRING(format_string) __VA_OPT__(,) __VA_ARGS__))
#define StrgenFatal(format_string, ...) StrgenFatalI(fmt::format(FMT_STRING(format_string) __VA_OPT__(,) __VA_ARGS__))
std::optional<std::string_view> ParseWord(StringConsumer &consumer);

struct StrgenState {
  std::string file = "(unknown file)"; 
  size_t cur_line = 0; 
  size_t errors = 0;
  size_t warnings = 0;
  bool show_warnings = false;
  bool annotate_todos = false;
  bool translation = false; 
  LanguagePackHeader lang; 
};
extern StrgenState _strgen;
 
#endif /* STRGEN_H */