saveload.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 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,                   
 
  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);
const char *GetSaveLoadErrorString();
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(void *arg);
 
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 : byte {
  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;     
  size_t size;                    
  SaveLoadAddrProc *address_proc; 
  size_t extra_data;              
  std::shared_ptr<SaveLoadHandler> handler; 
};
 
struct SaveLoadCompat {
  std::string name;             
  uint16_t 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, cpp_sizeof(base, variable), [] (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_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, sizeof(variable), [] (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, 0, 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, 0, 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, 0, SL_MIN_VERSION, SL_MAX_VERSION}
 
#define SLC_NULL(length, from, to) {{}, length, from, to}
 
#define SLC_END() {{}, 0, SL_MIN_VERSION, SL_MIN_VERSION}
 
inline bool IsSavegameVersionBefore(SaveLoadVersion major, byte minor = 0)
{
  extern SaveLoadVersion _sl_version;
  extern byte            _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, void *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);
 
byte SlReadByte();
void SlWriteByte(byte 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 */