d6/dd4/saveload_8h_source.html

/*

 * 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 SAVELOAD_H

#define SAVELOAD_H


#include "saveload_error.hpp"

#include "../fileio_type.h"

#include "../fios.h"


enum SaveLoadVersion : uint16_t {

  SL_MIN_VERSION,


  SLV_1,

  SLV_2,

  SLV_3,

  SLV_4,

  SLV_5,

  SLV_6,

  SLV_7,

  SLV_8,

  SLV_9,


  SLV_10,

  SLV_11,

  SLV_12,

  SLV_13,

  SLV_14,


  SLV_15,

  SLV_16,

  SLV_17,

  SLV_18,

  SLV_19,


  SLV_20,

  SLV_21,

  SLV_22,

  SLV_23,

  SLV_24,


  SLV_25,

  SLV_26,

  SLV_27,

  SLV_28,

  SLV_29,


  SLV_30,

  SLV_31,

  SLV_32,

  SLV_33,

  SLV_34,


  SLV_35,

  SLV_36,

  SLV_37,

  SLV_38,

  SLV_39,


  SLV_40,

  SLV_41,

  SLV_42,

  SLV_43,

  SLV_44,


  SLV_45,

  SLV_46,

  SLV_47,

  SLV_48,

  SLV_49,


  SLV_50,

  SLV_51,

  SLV_52,

  SLV_53,

  SLV_54,


  SLV_55,

  SLV_56,

  SLV_57,

  SLV_58,

  SLV_59,


  SLV_60,

  SLV_61,

  SLV_62,

  SLV_63,

  SLV_64,


  SLV_65,

  SLV_66,

  SLV_67,

  SLV_68,

  SLV_69,


  SLV_70,

  SLV_71,

  SLV_72,

  SLV_73,

  SLV_74,


  SLV_75,

  SLV_76,

  SLV_77,

  SLV_78,

  SLV_79,


  SLV_80,

  SLV_81,

  SLV_82,

  SLV_83,

  SLV_84,


  SLV_85,

  SLV_86,

  SLV_87,

  SLV_88,

  SLV_89,


  SLV_90,

  SLV_91,

  SLV_92,

  SLV_93,

  SLV_94,


  SLV_95,

  SLV_96,

  SLV_97,

  SLV_98,

  SLV_99,


  SLV_100,

  SLV_101,

  SLV_102,

  SLV_103,

  SLV_104,


  SLV_105,

  SLV_106,

  SLV_107,

  SLV_108,

  SLV_109,


  SLV_110,

  SLV_111,

  SLV_112,

  SLV_113,

  SLV_114,


  SLV_115,

  SLV_116,

  SLV_117,

  SLV_118,

  SLV_119,


  SLV_120,

  SLV_121,

  SLV_122,

  SLV_123,

  SLV_124,


  SLV_125,

  SLV_126,

  SLV_127,

  SLV_128,

  SLV_129,


  SLV_130,

  SLV_131,

  SLV_132,

  SLV_133,

  SLV_134,


  SLV_135,

  SLV_136,

  SLV_137,

  SLV_138,

  SLV_139,


  SLV_140,

  SLV_141,

  SLV_142,

  SLV_143,

  SLV_144,


  SLV_145,

  SLV_146,

  SLV_147,

  SLV_148,

  SLV_149,


  SLV_150,

  SLV_151,

  SLV_152,

  SLV_153,

  SLV_154,


  SLV_155,

  SLV_156,

  SLV_157,

  SLV_158,

  SLV_159,


  SLV_160,

  SLV_161,

  SLV_162,

  SLV_163,

  SLV_164,


  SLV_165,

  SLV_166,

  SLV_167,

  SLV_168,

  SLV_169,


  SLV_170,

  SLV_171,

  SLV_172,

  SLV_173,

  SLV_174,


  SLV_175,

  SLV_176,

  SLV_177,

  SLV_178,

  SLV_179,


  SLV_180,

  SLV_181,

  SLV_182,

  SLV_183,

  SLV_184,


  SLV_185,

  SLV_186,

  SLV_187,

  SLV_188,

  SLV_189,


  SLV_190,

  SLV_191,

  SLV_192,

  SLV_193,

  SLV_194,


  SLV_195,

  SLV_196,

  SLV_197,

  SLV_198,

  SLV_EXTEND_CARGOTYPES,


  SLV_EXTEND_RAILTYPES,

  SLV_EXTEND_PERSISTENT_STORAGE,

  SLV_EXTEND_INDUSTRY_CARGO_SLOTS,

  SLV_SHIP_PATH_CACHE,

  SLV_SHIP_ROTATION,


  SLV_GROUP_LIVERIES,

  SLV_SHIPS_STOP_IN_LOCKS,

  SLV_FIX_CARGO_MONITOR,

  SLV_TOWN_CARGOGEN,

  SLV_SHIP_CURVE_PENALTY,


  SLV_SERVE_NEUTRAL_INDUSTRIES,

  SLV_ROADVEH_PATH_CACHE,

  SLV_REMOVE_OPF,

  SLV_TREES_WATER_CLASS,

  SLV_ROAD_TYPES,


  SLV_SCRIPT_MEMLIMIT,

  SLV_MULTITILE_DOCKS,

  SLV_TRADING_AGE,

  SLV_ENDING_YEAR,

  SLV_REMOVE_TOWN_CARGO_CACHE,


  /* Patchpacks for a while considered it a good idea to jump a few versions

   * above our version for their savegames. But as time continued, this gap

   * has been closing, up to the point we would start to reuse versions from

   * their patchpacks. This is not a problem from our perspective: the

   * savegame will simply fail to load because they all contain chunks we

   * cannot digest. But, this gives for ugly errors. As we have plenty of

   * versions anyway, we simply skip the versions we know belong to

   * patchpacks. This way we can present the user with a clean error

   * indicate they are loading a savegame from a patchpack.

   * For future patchpack creators: please follow a system like JGRPP, where

   * the version is masked with 0x8000, and the true version is stored in

   * its own chunk with feature toggles.

   */

  SLV_START_PATCHPACKS,

  SLV_END_PATCHPACKS = 286,


  SLV_GS_INDUSTRY_CONTROL,

  SLV_VEH_MOTION_COUNTER,

  SLV_INDUSTRY_TEXT,


  SLV_MAPGEN_SETTINGS_REVAMP,

  SLV_GROUP_REPLACE_WAGON_REMOVAL,

  SLV_CUSTOM_SUBSIDY_DURATION,

  SLV_SAVELOAD_LIST_LENGTH,

  SLV_RIFF_TO_ARRAY,


  SLV_TABLE_CHUNKS,

  SLV_SCRIPT_INT64,

  SLV_LINKGRAPH_TRAVEL_TIME,

  SLV_DOCK_DOCKINGTILES,

  SLV_REPAIR_OBJECT_DOCKING_TILES,


  SLV_U64_TICK_COUNTER,

  SLV_LAST_LOADING_TICK,

  SLV_MULTITRACK_LEVEL_CROSSINGS,

  SLV_NEWGRF_ROAD_STOPS,

  SLV_LINKGRAPH_EDGES,


  SLV_VELOCITY_NAUTICAL,

  SLV_CONSISTENT_PARTIAL_Z,

  SLV_MORE_CARGO_AGE,

  SLV_LINKGRAPH_SECONDS,

  SLV_AI_START_DATE,


  SLV_EXTEND_VEHICLE_RANDOM,

  SLV_EXTEND_ENTITY_MAPPING,

  SLV_DISASTER_VEH_STATE,

  SLV_SAVEGAME_ID,

  SLV_STRING_GAMELOG,


  SLV_INDUSTRY_CARGO_REORGANISE,

  SLV_PERIODS_IN_TRANSIT_RENAME,

  SLV_NEWGRF_LAST_SERVICE,

  SLV_REMOVE_LOADED_AT_XY,

  SLV_CARGO_TRAVELLED,


  SLV_STATION_RATING_CHEAT,

  SLV_TIMETABLE_START_TICKS,

  SLV_TIMETABLE_START_TICKS_FIX,

  SLV_TIMETABLE_TICKS_TYPE,

  SLV_WATER_REGIONS,


  SLV_WATER_REGION_EVAL_SIMPLIFIED,

  SLV_ECONOMY_DATE,

  SLV_ECONOMY_MODE_TIMEKEEPING_UNITS,

  SLV_CALENDAR_SUB_DATE_FRACT,

  SLV_SHIP_ACCELERATION,


  SLV_MAX_LOAN_FOR_COMPANY,

  SLV_DEPOT_UNBUNCHING,

  SLV_AI_LOCAL_CONFIG,

  SLV_SCRIPT_RANDOMIZER,

  SLV_VEHICLE_ECONOMY_AGE,


  SLV_COMPANY_ALLOW_LIST,

  SLV_GROUP_NUMBERS,

  SLV_INCREASE_STATION_TYPE_FIELD_SIZE,

  SLV_ROAD_WAYPOINTS,

  SLV_COMPANY_INAUGURATED_PERIOD,


  SLV_ROAD_STOP_TILE_DATA,

  SLV_COMPANY_ALLOW_LIST_V2,


  SL_MAX_VERSION,

};


enum SaveOrLoadResult {

  SL_OK     = 0,

  SL_ERROR  = 1,

  SL_REINIT = 2,

};


struct FileToSaveLoad {

  SaveLoadOperation file_op;

  DetailedFileType detail_ftype;

  AbstractFileType abstract_ftype;

  std::string name;

  std::string title;


  void SetMode(FiosType ft);

  void SetMode(SaveLoadOperation fop, AbstractFileType aft, DetailedFileType dft);

  void Set(const FiosItem &item);

};


enum SavegameType {

  SGT_TTD,

  SGT_TTDP1,

  SGT_TTDP2,

  SGT_OTTD,

  SGT_TTO,

  SGT_INVALID = 0xFF,

};


extern FileToSaveLoad _file_to_saveload;


std::string GenerateDefaultSaveName();

void SetSaveLoadError(StringID str);

StringID GetSaveLoadErrorType();

StringID GetSaveLoadErrorMessage();

SaveOrLoadResult SaveOrLoad(const std::string &filename, SaveLoadOperation fop, DetailedFileType dft, Subdirectory sb, bool threaded = true);

void WaitTillSaved();

void ProcessAsyncSaveFinish();

void DoExitSave();


void DoAutoOrNetsave(FiosNumberedSaveName &counter);


SaveOrLoadResult SaveWithFilter(std::shared_ptr<struct SaveFilter> writer, bool threaded);

SaveOrLoadResult LoadWithFilter(std::shared_ptr<struct LoadFilter> reader);


typedef void AutolengthProc(int);


enum ChunkType {

  CH_RIFF = 0,

  CH_ARRAY = 1,

  CH_SPARSE_ARRAY = 2,

  CH_TABLE = 3,

  CH_SPARSE_TABLE = 4,


  CH_TYPE_MASK = 0xf,

  CH_READONLY,

};


struct ChunkHandler {

  uint32_t id;

  ChunkType type;


  ChunkHandler(uint32_t id, ChunkType type) : id(id), type(type) {}


  virtual ~ChunkHandler() = default;


  virtual void Save() const { NOT_REACHED(); }


  virtual void Load() const = 0;


  virtual void FixPointers() const {}


  virtual void LoadCheck(size_t len = 0) const;


  std::string GetName() const

  {

    return std::string()

      + static_cast<char>(this->id >> 24)

      + static_cast<char>(this->id >> 16)

      + static_cast<char>(this->id >> 8)

      + static_cast<char>(this->id);

  }

};


using ChunkHandlerRef = std::reference_wrapper<const ChunkHandler>;


using ChunkHandlerTable = std::span<const ChunkHandlerRef>;


using SaveLoadTable = std::span<const struct SaveLoad>;


using SaveLoadCompatTable = std::span<const struct SaveLoadCompat>;


class SaveLoadHandler {

public:

  std::optional<std::vector<SaveLoad>> load_description;


  virtual ~SaveLoadHandler() = default;


  virtual void Save([[maybe_unused]] void *object) const {}


  virtual void Load([[maybe_unused]] void *object) const {}


  virtual void LoadCheck([[maybe_unused]] void *object) const {}


  virtual void FixPointers([[maybe_unused]] void *object) const {}


  virtual SaveLoadTable GetDescription() const = 0;


  virtual SaveLoadCompatTable GetCompatDescription() const = 0;


  SaveLoadTable GetLoadDescription() const;

};


template <class TImpl, class TObject>

class DefaultSaveLoadHandler : public SaveLoadHandler {

public:

  SaveLoadTable GetDescription() const override { return static_cast<const TImpl *>(this)->description; }

  SaveLoadCompatTable GetCompatDescription() const override { return static_cast<const TImpl *>(this)->compat_description; }


  virtual void Save([[maybe_unused]] TObject *object) const {}

  void Save(void *object) const override { this->Save(static_cast<TObject *>(object)); }


  virtual void Load([[maybe_unused]] TObject *object) const {}

  void Load(void *object) const override { this->Load(static_cast<TObject *>(object)); }


  virtual void LoadCheck([[maybe_unused]] TObject *object) const {}

  void LoadCheck(void *object) const override { this->LoadCheck(static_cast<TObject *>(object)); }


  virtual void FixPointers([[maybe_unused]] TObject *object) const {}

  void FixPointers(void *object) const override { this->FixPointers(static_cast<TObject *>(object)); }

};


enum SLRefType {

  REF_ORDER          =  0,

  REF_VEHICLE        =  1,

  REF_STATION        =  2,

  REF_TOWN           =  3,

  REF_VEHICLE_OLD    =  4,

  REF_ROADSTOPS      =  5,

  REF_ENGINE_RENEWS  =  6,

  REF_CARGO_PACKET   =  7,

  REF_ORDERLIST      =  8,

  REF_STORAGE        =  9,

  REF_LINK_GRAPH     = 10,

  REF_LINK_GRAPH_JOB = 11,

};


enum VarTypes {

  /* 4 bits allocated a maximum of 16 types for NumberType.

   * NOTE: the SLE_FILE_NNN values are stored in the savegame! */

  SLE_FILE_END      =  0,

  SLE_FILE_I8       =  1,

  SLE_FILE_U8       =  2,

  SLE_FILE_I16      =  3,

  SLE_FILE_U16      =  4,

  SLE_FILE_I32      =  5,

  SLE_FILE_U32      =  6,

  SLE_FILE_I64      =  7,

  SLE_FILE_U64      =  8,

  SLE_FILE_STRINGID =  9,

  SLE_FILE_STRING   = 10,

  SLE_FILE_STRUCT   = 11,

  /* 4 more possible file-primitives */


  SLE_FILE_TYPE_MASK = 0xf,

  SLE_FILE_HAS_LENGTH_FIELD = 1 << 4,


  /* 4 bits allocated a maximum of 16 types for NumberType */

  SLE_VAR_BL    =  0 << 4,

  SLE_VAR_I8    =  1 << 4,

  SLE_VAR_U8    =  2 << 4,

  SLE_VAR_I16   =  3 << 4,

  SLE_VAR_U16   =  4 << 4,

  SLE_VAR_I32   =  5 << 4,

  SLE_VAR_U32   =  6 << 4,

  SLE_VAR_I64   =  7 << 4,

  SLE_VAR_U64   =  8 << 4,

  SLE_VAR_NULL  =  9 << 4,

  SLE_VAR_STR   = 12 << 4,

  SLE_VAR_STRQ  = 13 << 4,

  SLE_VAR_NAME  = 14 << 4,

  /* 1 more possible memory-primitives */


  /* Shortcut values */

  SLE_VAR_CHAR = SLE_VAR_I8,


  /* Default combinations of variables. As savegames change, so can variables

   * and thus it is possible that the saved value and internal size do not

   * match and you need to specify custom combo. The defaults are listed here */

  SLE_BOOL         = SLE_FILE_I8  | SLE_VAR_BL,

  SLE_INT8         = SLE_FILE_I8  | SLE_VAR_I8,

  SLE_UINT8        = SLE_FILE_U8  | SLE_VAR_U8,

  SLE_INT16        = SLE_FILE_I16 | SLE_VAR_I16,

  SLE_UINT16       = SLE_FILE_U16 | SLE_VAR_U16,

  SLE_INT32        = SLE_FILE_I32 | SLE_VAR_I32,

  SLE_UINT32       = SLE_FILE_U32 | SLE_VAR_U32,

  SLE_INT64        = SLE_FILE_I64 | SLE_VAR_I64,

  SLE_UINT64       = SLE_FILE_U64 | SLE_VAR_U64,

  SLE_CHAR         = SLE_FILE_I8  | SLE_VAR_CHAR,

  SLE_STRINGID     = SLE_FILE_STRINGID | SLE_VAR_U32,

  SLE_STRING       = SLE_FILE_STRING   | SLE_VAR_STR,

  SLE_STRINGQUOTE  = SLE_FILE_STRING   | SLE_VAR_STRQ,

  SLE_NAME         = SLE_FILE_STRINGID | SLE_VAR_NAME,


  /* Shortcut values */

  SLE_UINT  = SLE_UINT32,

  SLE_INT   = SLE_INT32,

  SLE_STR   = SLE_STRING,

  SLE_STRQ  = SLE_STRINGQUOTE,


  /* 8 bits allocated for a maximum of 8 flags

   * Flags directing saving/loading of a variable */

  SLF_ALLOW_CONTROL   = 1 << 8,

  SLF_ALLOW_NEWLINE   = 1 << 9,

};


typedef uint32_t VarType;


enum SaveLoadType : uint8_t {

  SL_VAR         =  0,

  SL_REF         =  1,

  SL_STRUCT      =  2,


  SL_STDSTR      =  4,


  SL_ARR         =  5,

  SL_DEQUE       =  6,

  SL_VECTOR      =  7,

  SL_REFLIST     =  8,

  SL_STRUCTLIST  =  9,


  SL_SAVEBYTE    = 10,

  SL_NULL        = 11,

};


typedef void *SaveLoadAddrProc(void *base, size_t extra);


struct SaveLoad {

  std::string name;

  SaveLoadType cmd;

  VarType conv;

  uint16_t length;

  SaveLoadVersion version_from;

  SaveLoadVersion version_to;

  SaveLoadAddrProc *address_proc;

  size_t extra_data;

  std::shared_ptr<SaveLoadHandler> handler;

};


struct SaveLoadCompat {

  std::string name;

  VarTypes null_type;

  uint16_t null_length;

  SaveLoadVersion version_from;

  SaveLoadVersion version_to;

};


inline constexpr VarType GetVarMemType(VarType type)

{

  return GB(type, 4, 4) << 4;

}


inline constexpr VarType GetVarFileType(VarType type)

{

  return GB(type, 0, 4);

}


inline constexpr bool IsNumericType(VarType conv)

{

  return GetVarMemType(conv) <= SLE_VAR_U64;

}


inline constexpr size_t SlVarSize(VarType type)

{

  switch (GetVarMemType(type)) {

    case SLE_VAR_BL: return sizeof(bool);

    case SLE_VAR_I8: return sizeof(int8_t);

    case SLE_VAR_U8: return sizeof(uint8_t);

    case SLE_VAR_I16: return sizeof(int16_t);

    case SLE_VAR_U16: return sizeof(uint16_t);

    case SLE_VAR_I32: return sizeof(int32_t);

    case SLE_VAR_U32: return sizeof(uint32_t);

    case SLE_VAR_I64: return sizeof(int64_t);

    case SLE_VAR_U64: return sizeof(uint64_t);

    case SLE_VAR_NULL: return sizeof(void *);

    case SLE_VAR_STR: return sizeof(std::string);

    case SLE_VAR_STRQ: return sizeof(std::string);

    case SLE_VAR_NAME: return sizeof(std::string);

    default: NOT_REACHED();

  }

}


inline constexpr bool SlCheckVarSize(SaveLoadType cmd, VarType type, size_t length, size_t size)

{

  switch (cmd) {

    case SL_VAR: return SlVarSize(type) == size;

    case SL_REF: return sizeof(void *) == size;

    case SL_STDSTR: return SlVarSize(type) == size;

    case SL_ARR: return SlVarSize(type) * length <= size; // Partial load of array is permitted.

    case SL_DEQUE: return sizeof(std::deque<void *>) == size;

    case SL_VECTOR: return sizeof(std::vector<void *>) == size;

    case SL_REFLIST: return sizeof(std::list<void *>) == size;

    case SL_SAVEBYTE: return true;

    default: NOT_REACHED();

  }

}


#define SLE_GENERAL_NAME(cmd, name, base, variable, type, length, from, to, extra) \

  SaveLoad {name, cmd, type, length, from, to, [] (void *b, size_t) -> void * { \

    static_assert(SlCheckVarSize(cmd, type, length, sizeof(static_cast<base *>(b)->variable))); \

    assert(b != nullptr); \

    return const_cast<void *>(static_cast<const void *>(std::addressof(static_cast<base *>(b)->variable))); \

  }, extra, nullptr}


#define SLE_GENERAL(cmd, base, variable, type, length, from, to, extra) SLE_GENERAL_NAME(cmd, #variable, base, variable, type, length, from, to, extra)


#define SLE_CONDVAR(base, variable, type, from, to) SLE_GENERAL(SL_VAR, base, variable, type, 0, from, to, 0)


#define SLE_CONDVARNAME(base, variable, name, type, from, to) SLE_GENERAL_NAME(SL_VAR, name, base, variable, type, 0, from, to, 0)


#define SLE_CONDREF(base, variable, type, from, to) SLE_GENERAL(SL_REF, base, variable, type, 0, from, to, 0)


#define SLE_CONDARR(base, variable, type, length, from, to) SLE_GENERAL(SL_ARR, base, variable, type, length, from, to, 0)


#define SLE_CONDARRNAME(base, variable, name, type, length, from, to) SLE_GENERAL_NAME(SL_ARR, name, base, variable, type, length, from, to, 0)


#define SLE_CONDSTR(base, variable, type, length, from, to) SLE_GENERAL(SL_STR, base, variable, type, length, from, to, 0)


#define SLE_CONDSSTR(base, variable, type, from, to) SLE_GENERAL(SL_STDSTR, base, variable, type, 0, from, to, 0)


#define SLE_CONDSSTRNAME(base, variable, name, type, from, to) SLE_GENERAL_NAME(SL_STDSTR, name, base, variable, type, 0, from, to, 0)


#define SLE_CONDREFLIST(base, variable, type, from, to) SLE_GENERAL(SL_REFLIST, base, variable, type, 0, from, to, 0)


#define SLE_CONDDEQUE(base, variable, type, from, to) SLE_GENERAL(SL_DEQUE, base, variable, type, 0, from, to, 0)


#define SLE_CONDVECTOR(base, variable, type, from, to) SLE_GENERAL(SL_VECTOR, base, variable, type, 0, from, to, 0)


#define SLE_VAR(base, variable, type) SLE_CONDVAR(base, variable, type, SL_MIN_VERSION, SL_MAX_VERSION)


#define SLE_VARNAME(base, variable, name, type) SLE_CONDVARNAME(base, variable, name, type, SL_MIN_VERSION, SL_MAX_VERSION)


#define SLE_REF(base, variable, type) SLE_CONDREF(base, variable, type, SL_MIN_VERSION, SL_MAX_VERSION)


#define SLE_ARR(base, variable, type, length) SLE_CONDARR(base, variable, type, length, SL_MIN_VERSION, SL_MAX_VERSION)


#define SLE_ARRNAME(base, variable, name, type, length) SLE_CONDARRNAME(base, variable, name, type, length, SL_MIN_VERSION, SL_MAX_VERSION)


#define SLE_SSTR(base, variable, type) SLE_CONDSSTR(base, variable, type, SL_MIN_VERSION, SL_MAX_VERSION)


#define SLE_SSTRNAME(base, variable, name, type) SLE_CONDSSTRNAME(base, variable, name, type, SL_MIN_VERSION, SL_MAX_VERSION)


#define SLE_REFLIST(base, variable, type) SLE_CONDREFLIST(base, variable, type, SL_MIN_VERSION, SL_MAX_VERSION)


#define SLE_SAVEBYTE(base, variable) SLE_GENERAL(SL_SAVEBYTE, base, variable, 0, 0, SL_MIN_VERSION, SL_MAX_VERSION, 0)


#define SLEG_GENERAL(name, cmd, variable, type, length, from, to, extra) \

  SaveLoad {name, cmd, type, length, from, to, [] (void *, size_t) -> void * { \

    static_assert(SlCheckVarSize(cmd, type, length, sizeof(variable))); \

    return static_cast<void *>(std::addressof(variable)); }, extra, nullptr}


#define SLEG_CONDVAR(name, variable, type, from, to) SLEG_GENERAL(name, SL_VAR, variable, type, 0, from, to, 0)


#define SLEG_CONDREF(name, variable, type, from, to) SLEG_GENERAL(name, SL_REF, variable, type, 0, from, to, 0)


#define SLEG_CONDARR(name, variable, type, length, from, to) SLEG_GENERAL(name, SL_ARR, variable, type, length, from, to, 0)


#define SLEG_CONDSSTR(name, variable, type, from, to) SLEG_GENERAL(name, SL_STDSTR, variable, type, 0, from, to, 0)


#define SLEG_CONDSTRUCT(name, handler, from, to) SaveLoad {name, SL_STRUCT, 0, 0, from, to, nullptr, 0, std::make_shared<handler>()}


#define SLEG_CONDREFLIST(name, variable, type, from, to) SLEG_GENERAL(name, SL_REFLIST, variable, type, 0, from, to, 0)


#define SLEG_CONDVECTOR(name, variable, type, from, to) SLEG_GENERAL(name, SL_VECTOR, variable, type, 0, from, to, 0)


#define SLEG_CONDSTRUCTLIST(name, handler, from, to) SaveLoad {name, SL_STRUCTLIST, 0, 0, from, to, nullptr, 0, std::make_shared<handler>()}


#define SLEG_VAR(name, variable, type) SLEG_CONDVAR(name, variable, type, SL_MIN_VERSION, SL_MAX_VERSION)


#define SLEG_REF(name, variable, type) SLEG_CONDREF(name, variable, type, SL_MIN_VERSION, SL_MAX_VERSION)


#define SLEG_ARR(name, variable, type) SLEG_CONDARR(name, variable, type, lengthof(variable), SL_MIN_VERSION, SL_MAX_VERSION)


#define SLEG_SSTR(name, variable, type) SLEG_CONDSSTR(name, variable, type, SL_MIN_VERSION, SL_MAX_VERSION)


#define SLEG_STRUCT(name, handler) SLEG_CONDSTRUCT(name, handler, SL_MIN_VERSION, SL_MAX_VERSION)


#define SLEG_REFLIST(name, variable, type) SLEG_CONDREFLIST(name, variable, type, SL_MIN_VERSION, SL_MAX_VERSION)


#define SLEG_VECTOR(name, variable, type) SLEG_CONDVECTOR(name, variable, type, SL_MIN_VERSION, SL_MAX_VERSION)


#define SLEG_STRUCTLIST(name, handler) SLEG_CONDSTRUCTLIST(name, handler, SL_MIN_VERSION, SL_MAX_VERSION)


#define SLC_VAR(name) {name, SLE_FILE_U8, 0, SL_MIN_VERSION, SL_MAX_VERSION}


#define SLC_NULL(length, from, to) {{}, SLE_FILE_U8, length, from, to}


#define SLC_NULL_STR(length, from, to) {{}, SLE_FILE_STRING, length, from, to}


#define SLC_END() {{}, 0, 0, SL_MIN_VERSION, SL_MIN_VERSION}


inline bool IsSavegameVersionBefore(SaveLoadVersion major, uint8_t minor = 0)

{

  extern SaveLoadVersion _sl_version;

  extern uint8_t            _sl_minor_version;

  return _sl_version < major || (minor > 0 && _sl_version == major && _sl_minor_version < minor);

}


inline bool IsSavegameVersionBeforeOrAt(SaveLoadVersion major)

{

  extern SaveLoadVersion _sl_version;

  return _sl_version <= major;

}


inline bool SlIsObjectCurrentlyValid(SaveLoadVersion version_from, SaveLoadVersion version_to)

{

  extern const SaveLoadVersion SAVEGAME_VERSION;

  return version_from <= SAVEGAME_VERSION && SAVEGAME_VERSION < version_to;

}


inline void *GetVariableAddress(const void *object, const SaveLoad &sld)

{

  /* Entry is a null-variable, mostly used to read old savegames etc. */

  if (GetVarMemType(sld.conv) == SLE_VAR_NULL) {

    assert(sld.address_proc == nullptr);

    return nullptr;

  }


  /* Everything else should be a non-null pointer. */

  assert(sld.address_proc != nullptr);

  return sld.address_proc(const_cast<void *>(object), sld.extra_data);

}


int64_t ReadValue(const void *ptr, VarType conv);

void WriteValue(void *ptr, VarType conv, int64_t val);


void SlSetArrayIndex(uint index);

int SlIterateArray();


void SlSetStructListLength(size_t length);

size_t SlGetStructListLength(size_t limit);


void SlAutolength(AutolengthProc *proc, int arg);

size_t SlGetFieldLength();

void SlSetLength(size_t length);

size_t SlCalcObjMemberLength(const void *object, const SaveLoad &sld);

size_t SlCalcObjLength(const void *object, const SaveLoadTable &slt);


uint8_t SlReadByte();

void SlWriteByte(uint8_t b);


void SlGlobList(const SaveLoadTable &slt);

void SlCopy(void *object, size_t length, VarType conv);

std::vector<SaveLoad> SlTableHeader(const SaveLoadTable &slt);

std::vector<SaveLoad> SlCompatTableHeader(const SaveLoadTable &slt, const SaveLoadCompatTable &slct);

void SlObject(void *object, const SaveLoadTable &slt);


bool SaveloadCrashWithMissingNewGRFs();


inline void SlSkipBytes(size_t length)

{

  for (; length != 0; length--) SlReadByte();

}


extern std::string _savegame_format;

extern bool _do_autosave;


#endif /* SAVELOAD_H */