16 #define GETTEXT_DOMAIN "wesnoth-lib"
29 #include "addon/manager.hpp"
38 #include <SDL2/SDL_image.h>
39 #include <SDL2/SDL_mixer.h>
41 #include <boost/algorithm/string.hpp>
42 #include <boost/version.hpp>
45 #include <openssl/crypto.h>
46 #include <openssl/opensslv.h>
49 #include <curl/curl.h>
51 #include <pango/pangocairo.h>
56 #include <CoreFoundation/CoreFoundation.h>
64 struct version_table_manager
69 version_table_manager();
72 const version_table_manager versions;
74 std::string format_version(
unsigned a,
unsigned b,
unsigned c)
79 std::string format_version(
const SDL_version& v)
81 return formatter() <<
static_cast<unsigned>(v.major) <<
'.'
82 <<
static_cast<unsigned>(v.minor) <<
'.'
83 <<
static_cast<unsigned>(v.patch);
88 std::string format_openssl_patch_level(uint8_t
p)
91 ? std::string(1,
'a' +
static_cast<char>(
p) - 1)
92 :
"patch" + std::to_string(
p);
95 std::string format_openssl_version(
long v)
97 int major, minor, fix, patch, status;
98 std::ostringstream fmt;
108 minor = v & 0x0F00L >> 8;
109 fix = v & 0x00F0L >> 4;
112 fmt <<
"0." << minor <<
'.' << fix;
114 fmt << format_openssl_patch_level(patch);
123 major = (v & 0xF0000000L) >> 28;
124 minor = (v & 0x0FF00000L) >> 20;
125 fix = (v & 0x000FF000L) >> 12;
126 patch = (v & 0x00000FF0L) >> 4;
127 status = (v & 0x0000000FL);
129 if(v < 0x00905100L) {
141 const uint8_t is_final = (v & 0xF00L) >> 8;
142 status = is_final ? 0xF : 0;
144 }
else if(v < 0x00906000L) {
157 fmt << major <<
'.' << minor <<
'.' << fix;
160 fmt << format_openssl_patch_level(patch);
165 }
else if(status < 0xF) {
166 fmt <<
"-beta" << status;
175 version_table_manager::version_table_manager()
181 SDL_version sdl_version;
187 SDL_VERSION(&sdl_version);
190 SDL_GetVersion(&sdl_version);
199 SDL_IMAGE_VERSION(&sdl_version);
202 const SDL_version* sdl_rt_version = IMG_Linked_Version();
213 SDL_MIXER_VERSION(&sdl_version);
216 sdl_rt_version = Mix_Linked_Version();
235 compiled[
LIB_LUA] = LUA_VERSION_MAJOR
"." LUA_VERSION_MINOR
"." LUA_VERSION_RELEASE;
253 (LIBCURL_VERSION_NUM & 0xFF0000) >> 16,
254 (LIBCURL_VERSION_NUM & 0x00FF00) >> 8,
255 LIBCURL_VERSION_NUM & 0x0000FF);
256 curl_version_info_data *curl_ver = curl_version_info(CURLVERSION_NOW);
257 if(curl_ver && curl_ver->version) {
284 features.emplace_back(
N_(
"feature^Lua console completion"));
291 features.emplace_back(
N_(
"feature^D-Bus notifications back end"));
300 features.emplace_back(
N_(
"feature^Win32 notifications back end"));
306 features.emplace_back(
N_(
"feature^Cocoa notifications back end"));
311 const std::string empty_version =
"";
317 #if BOOST_ARCH_X86_64
319 #elif BOOST_ARCH_X86_32
321 #elif BOOST_ARCH_ARM && (defined(__arm64) || defined(_M_ARM64))
325 #elif BOOST_ARCH_IA64
329 #elif BOOST_ARCH_ALPHA
331 #elif BOOST_ARCH_MIPS
333 #elif BOOST_ARCH_SPARC
344 return _(
"cpu_architecture^<unknown>");
350 std::vector<optional_feature> res = versions.features;
352 for(std::size_t k = 0; k < res.size(); ++k) {
354 res[k].name =
_(res[k].name.c_str());
358 const auto caret_pos = res[k].name.find(
'^');
359 if(caret_pos != std::string::npos) {
360 res[k].name.erase(0, caret_pos + 1);
370 return empty_version;
373 return versions.compiled[lib];
379 return empty_version;
382 return versions.linked[lib];
388 return empty_version;
391 return versions.names[lib];
398 if(infofile.is_open()) {
399 std::getline(infofile,
info);
419 using list_entry = std::pair<std::string, std::string>;
420 using contents_list = std::vector<list_entry>;
422 list_formatter(
const std::string& heading,
const contents_list& contents = {},
const std::string& empty_placeholder =
"")
429 void insert(
const std::string&
label,
const std::string& value)
434 void set_placeholder(
const std::string& placeholder)
439 void stream_put(std::ostream& os)
const;
454 void list_formatter::stream_put(std::ostream& os)
const
463 auto label_length_comparator = [](
const list_entry&
a,
const list_entry&
b)
468 const auto longest_entry_label = std::max_element(
contents_.begin(),
contents_.end(), label_length_comparator);
469 const std::size_t min_length = longest_entry_label !=
contents_.end()
474 const std::size_t prev_width = os.width();
475 const std::ostream::fmtflags prev_flags = os.flags();
480 os << std::setw(min_length) << entry.first +
label_delimiter << entry.second <<
'\n';
483 os.width(prev_width);
484 os.flags(prev_flags);
490 std::ostream&
operator<<(std::ostream& os,
const list_formatter& fmt)
496 list_formatter library_versions_report_internal(
const std::string& heading =
"")
498 list_formatter fmt{heading};
502 if(versions.names[
n].empty()) {
506 std::string text = versions.compiled[
n];
507 if(!versions.linked[
n].empty()) {
508 text +=
" (runtime " + versions.linked[
n] +
")";
511 fmt.insert(versions.names[
n], text);
517 list_formatter optional_features_report_internal(
const std::string& heading =
"")
519 list_formatter fmt{heading};
523 for(
const auto& feature :
features) {
524 fmt.insert(feature.name, feature.enabled ?
"yes" :
"no");
530 inline std::string geometry_to_string(
point p)
532 return std::to_string(
p.x) +
'x' + std::to_string(
p.y);
535 template<
typename coordinateType>
536 inline std::string geometry_to_string(coordinateType horizontal, coordinateType vertical)
539 return formatter() << std::fixed << std::setprecision(2) << horizontal <<
'x' << vertical;
542 std::string format_sdl_driver_list(std::vector<std::string> drivers,
const std::string&
current_driver)
544 bool found_current_driver =
false;
546 for(
auto& drvname : drivers) {
548 found_current_driver =
true;
553 if(drivers.empty() || !found_current_driver) {
561 list_formatter video_settings_report_internal(
const std::string& heading =
"")
563 list_formatter fmt{heading};
565 std::string placeholder;
568 placeholder =
"Running in non-interactive mode.";
572 placeholder =
"Video not initialized yet.";
575 if(!placeholder.empty()) {
576 fmt.set_placeholder(placeholder);
584 std::string dpi_report;
586 dpi_report = dpi.first == 0.0f || dpi.second == 0.0f ?
588 geometry_to_string(dpi.first, dpi.second);
590 fmt.insert(
"SDL video drivers", format_sdl_driver_list(drivers,
current_driver));
595 fmt.insert(
"Screen dpi", dpi_report);
600 fmt.insert(
info.first,
info.second);
606 list_formatter sound_settings_report_internal(
const std::string& heading =
"")
608 list_formatter fmt{heading};
612 if(!driver_status.initialized) {
613 fmt.set_placeholder(
"Audio not initialized.");
620 static std::map<uint16_t, std::string> audio_format_names = {
622 { AUDIO_U8,
"unsigned 8 bit" },
623 { AUDIO_S8,
"signed 8 bit" },
625 { AUDIO_U16LSB,
"unsigned 16 bit little-endian" },
626 { AUDIO_U16MSB,
"unsigned 16 bit big-endian" },
627 { AUDIO_S16LSB,
"signed 16 bit little-endian" },
628 { AUDIO_S16MSB,
"signed 16 bit big-endian" },
630 { AUDIO_S32LSB,
"signed 32 bit little-endian" },
631 { AUDIO_S32MSB,
"signed 32 bit big-endian" },
632 { AUDIO_F32LSB,
"signed 32 bit floating point little-endian" },
633 { AUDIO_F32MSB,
"signed 32 bit floating point big-endian" },
636 auto fmt_names_it = audio_format_names.find(driver_status.format);
638 const std::string fmt_name = fmt_names_it != audio_format_names.end()
639 ? fmt_names_it->second
640 :
formatter() <<
"0x" << std::setfill(
'0') << std::setw(2*
sizeof(driver_status.format)) << std::hex << std::uppercase << driver_status.format;
642 fmt.insert(
"SDL audio drivers", format_sdl_driver_list(drivers,
current_driver));
643 fmt.insert(
"Number of channels", std::to_string(driver_status.channels));
644 fmt.insert(
"Output rate", std::to_string(driver_status.frequency) +
" Hz");
645 fmt.insert(
"Sample format", fmt_name);
646 fmt.insert(
"Sample size", std::to_string(driver_status.chunk_size) +
" bytes");
655 return formatter{} << library_versions_report_internal();
660 return formatter{} << optional_features_report_internal();
665 list_formatter::contents_list paths{
676 for(
auto& entry : paths) {
680 list_formatter::contents_list addons;
686 std::ostringstream o;
692 << list_formatter{
"Game paths", paths}
693 << library_versions_report_internal(
"Libraries")
694 << optional_features_report_internal(
"Features")
695 << video_settings_report_internal(
"Current video settings")
696 << sound_settings_report_internal(
"Current audio settings")
697 << list_formatter(
"Installed add-ons", addons,
"No add-ons installed.");
std::ostream & operator<<(std::ostream &s, const ai::attack_result &r)
std::map< std::string, std::string > installed_addons_and_versions()
Retrieves the ids and versions of all installed add-ons.
static const char heading_delimiter
std::vector< optional_feature > features
std::vector< std::string > compiled
std::vector< std::string > linked
std::vector< std::string > names
static const std::string label_delimiter
Platform identification and version information functions.
Declarations for File-IO.
Interfaces for manipulating version numbers of engine, add-ons, etc.
static std::string _(const char *str)
std::string label
What to show in the filter's drop-down list.
T end(const std::pair< T, T > &p)
T begin(const std::pair< T, T > &p)
std::string os_version()
Returns a string with the running OS name and version information.
std::string get_cache_dir()
std::string get_user_config_dir()
std::string get_user_data_dir()
std::string get_saves_dir()
std::string get_logs_dir()
std::string get_addons_dir()
std::string sanitize_path(const std::string &path)
Sanitizes a path to remove references to the user's name.
Game configuration data as global variables.
const std::string & library_name(LIBRARY_ID lib)
Retrieve the user-visible name for the given library.
std::string full_build_report()
Produce a bug report-style info dump.
std::string library_versions_report()
Produce a plain-text report of library versions suitable for stdout/stderr.
std::vector< optional_feature > optional_features_table(bool localize)
Retrieve the features table.
const std::string & library_runtime_version(LIBRARY_ID lib)
Retrieve the runtime version number of the given library.
const std::string & library_build_version(LIBRARY_ID lib)
Retrieve the build-time version number of the given library.
std::string build_arch()
Obtain the processor architecture for this build.
std::string optional_features_report()
Produce a plain-text report of features suitable for stdout/stderr.
const std::string revision
std::string dist_channel_id()
Return the distribution channel identifier, or "Default" if missing.
std::vector< std::string > enumerate_drivers()
std::string current_driver()
std::string & insert(std::string &str, const std::size_t pos, const std::string &insert)
Insert a UTF-8 string at the specified position.
std::size_t size(const std::string &str)
Length in characters of a UTF-8 string.
void trim(std::string_view &s)
std::string join(const T &v, const std::string &s=",")
Generates a new string joining container items in a list.
bool headless()
The game is running headless.
std::vector< std::pair< std::string, std::string > > renderer_report()
Provides diagnostic information about the current renderer for the build_info API.
point output_size()
Returns the size of the final render target.
point game_canvas_size()
The size of the game canvas, in drawing coordinates / game pixels.
bool has_window()
Whether the game has set up a window to render into.
std::vector< std::string > enumerate_drivers()
A list of available video drivers.
std::pair< float, float > get_dpi()
Retrieves the current game screen DPI for the build_info API.
point current_resolution()
The current window size in desktop coordinates.
int current_refresh_rate()
The refresh rate of the screen.
std::string current_driver()
The current video driver in use, or else "<not initialized>".
static driver_status query()
static map_location::DIRECTION n