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 <http://www.gnu.org/licenses/>.
 */
 
#ifndef STRGEN_H
#define STRGEN_H
 
#include "../language.h"
#include "../3rdparty/fmt/format.h"
 
#include <unordered_map>
#include <array>
 
struct Case {
  int caseidx;        
  std::string string; 
 
  Case(int caseidx, const std::string &string);
};
 
struct LangString {
  std::string name;       
  std::string english;    
  std::string translated; 
  size_t index;           
  int line;               
  std::vector<Case> translated_cases; 
 
  LangString(const std::string &name, const std::string &english, size_t index, int line);
  void FreeTranslation();
};
 
struct StringData {
  std::vector<std::unique_ptr<LangString>> strings; 
  std::unordered_map<std::string_view, LangString *> name_to_string; 
  size_t tabs;          
  size_t max_strings;   
  size_t next_string_id;
 
  StringData(size_t tabs);
  void FreeTranslation();
  void Add(std::unique_ptr<LangString> ls);
  LangString *Find(const std::string_view s);
  uint VersionHashStr(uint hash, const char *s) const;
  uint Version() const;
  uint CountInUse(uint 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() {}
  void HandleString(char *str);
 
  virtual std::optional<std::string> ReadLine() = 0;
 
  virtual void HandlePragma(char *str);
 
  virtual void ParseFile();
};
 
struct HeaderWriter {
  virtual void WriteStringID(const std::string &name, int 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(const uint8_t *buffer, size_t length) = 0;
 
  virtual void Finalise() = 0;
 
  virtual ~LanguageWriter() = default;
 
  virtual void WriteLength(uint length);
  virtual void WriteLang(const StringData &data);
};
 
struct CmdStruct;
 
struct CmdPair {
  const CmdStruct *cmd;
  std::string param;
};
 
struct ParsedCommandStruct {
  std::vector<CmdPair> non_consuming_commands;
  std::array<const CmdStruct*, 32> consuming_commands{ nullptr }; // ordered by param #
};
 
const CmdStruct *TranslateCmdForCompare(const CmdStruct *a);
ParsedCommandStruct ExtractCommandString(const char *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__))
char *ParseWord(char **buf);
 
extern const char *_file;
extern int _cur_line;
extern int _errors, _warnings, _show_todo;
extern LanguagePackHeader _lang;
 
#endif /* STRGEN_H */