16 #define GETTEXT_DOMAIN "wesnoth-lib" 30 #include "addon/manager.hpp" 40 #include <SDL2/SDL_image.h> 41 #include <SDL2/SDL_mixer.h> 43 #include <boost/algorithm/string.hpp> 44 #include <boost/predef.h> 45 #include <boost/version.hpp> 48 #include <openssl/crypto.h> 49 #include <openssl/opensslv.h> 52 #include <pango/pangocairo.h> 57 #include <CoreFoundation/CoreFoundation.h> 65 struct version_table_manager
70 version_table_manager();
73 const version_table_manager versions;
76 std::string format_version(
unsigned a,
unsigned b,
unsigned c)
78 return formatter() << a <<
'.' << b <<
'.' <<
c;
82 std::string format_version(
const SDL_version& v)
84 return formatter() <<
static_cast<unsigned>(v.major) <<
'.' 85 << static_cast<unsigned>(v.minor) <<
'.' 86 <<
static_cast<unsigned>(v.patch);
91 std::string format_openssl_patch_level(uint8_t
p)
94 ? std::string(1,
'a' + static_cast<char>(p) - 1)
95 :
"patch" +
std::to_string(p);
98 std::string format_openssl_version(
long v)
100 int major, minor, fix, patch, status;
101 std::ostringstream fmt;
111 minor = v & 0x0F00L >> 8;
112 fix = v & 0x00F0L >> 4;
115 fmt <<
"0." << minor <<
'.' << fix;
117 fmt << format_openssl_patch_level(patch);
126 major = (v & 0xF0000000L) >> 28;
127 minor = (v & 0x0FF00000L) >> 20;
128 fix = (v & 0x000FF000L) >> 12;
129 patch = (v & 0x00000FF0L) >> 4;
130 status = (v & 0x0000000FL);
132 if(v < 0x00905100L) {
144 const uint8_t is_final = (v & 0xF00L) >> 8;
145 status = is_final ? 0xF : 0;
147 }
else if(v < 0x00906000L) {
160 fmt << major <<
'.' << minor <<
'.' << fix;
163 fmt << format_openssl_patch_level(patch);
168 }
else if(status < 0xF) {
169 fmt <<
"-beta" << status;
179 version_table_manager::version_table_manager()
185 SDL_version sdl_version;
192 SDL_VERSION(&sdl_version);
195 SDL_GetVersion(&sdl_version);
204 SDL_IMAGE_VERSION(&sdl_version);
207 const SDL_version* sdl_rt_version = IMG_Linked_Version();
218 SDL_MIXER_VERSION(&sdl_version);
221 sdl_rt_version = Mix_Linked_Version();
240 compiled[
LIB_LUA] = LUA_VERSION_MAJOR
"." LUA_VERSION_MINOR
"." LUA_VERSION_RELEASE;
273 features.emplace_back(
N_(
"feature^Lua console completion"));
280 features.emplace_back(
N_(
"feature^D-Bus notifications back end"));
289 features.emplace_back(
N_(
"feature^Win32 notifications back end"));
295 features.emplace_back(
N_(
"feature^Cocoa notifications back end"));
300 const std::string empty_version =
"";
306 #if BOOST_ARCH_X86_64 308 #elif BOOST_ARCH_X86_32 310 #elif BOOST_ARCH_ARM && (defined(__arm64) || defined(_M_ARM64)) 314 #elif BOOST_ARCH_IA64 318 #elif BOOST_ARCH_ALPHA 320 #elif BOOST_ARCH_MIPS 322 #elif BOOST_ARCH_SPARC 333 return _(
"cpu_architecture^<unknown>");
339 std::vector<optional_feature> res = versions.features;
341 for(std::size_t k = 0; k < res.size(); ++k) {
343 res[k].name =
_(res[k].name.c_str());
347 const auto caret_pos = res[k].name.find(
'^');
348 if(caret_pos != std::string::npos) {
349 res[k].name.erase(0, caret_pos + 1);
359 return empty_version;
362 return versions.compiled[lib];
368 return empty_version;
371 return versions.linked[lib];
377 return empty_version;
380 return versions.names[lib];
387 if(infofile.is_open()) {
388 std::getline(infofile, info);
408 using list_entry = std::pair<std::string, std::string>;
409 using contents_list = std::vector<list_entry>;
411 list_formatter(
const std::string& heading,
const contents_list& contents = {},
const std::string& empty_placeholder =
"")
418 void insert(
const std::string&
label,
const std::string& value)
423 void set_placeholder(
const std::string& placeholder)
428 void stream_put(std::ostream& os)
const;
443 void list_formatter::stream_put(std::ostream& os)
const 452 auto label_length_comparator = [](
const list_entry&
a,
const list_entry&
b)
457 const auto longest_entry_label = std::max_element(
contents_.begin(),
contents_.end(), label_length_comparator);
458 const std::size_t min_length = longest_entry_label !=
contents_.end()
463 const std::size_t prev_width = os.width();
464 const std::ostream::fmtflags prev_flags = os.flags();
469 os << std::setw(min_length) << entry.first +
label_delimiter << entry.second <<
'\n';
472 os.width(prev_width);
473 os.flags(prev_flags);
479 std::ostream&
operator<<(std::ostream& os,
const list_formatter& fmt)
485 list_formatter library_versions_report_internal(
const std::string& heading =
"")
487 list_formatter fmt{heading};
491 if(versions.names[
n].empty()) {
495 std::string text = versions.compiled[
n];
496 if(!versions.linked[
n].empty()) {
497 text +=
" (runtime " + versions.linked[
n] +
")";
500 fmt.insert(versions.names[
n], text);
506 list_formatter optional_features_report_internal(
const std::string& heading =
"")
508 list_formatter fmt{heading};
512 for(
const auto& feature : features) {
513 fmt.insert(feature.name, feature.enabled ?
"yes" :
"no");
519 inline std::string geometry_to_string(
point p)
521 return std::to_string(p.x) +
'x' + std::to_string(p.y);
524 template<
typename coordinateType>
525 inline std::string geometry_to_string(coordinateType horizontal, coordinateType vertical)
528 return formatter() << std::fixed << std::setprecision(2) << horizontal <<
'x' << vertical;
531 std::string format_sdl_driver_list(std::vector<std::string> drivers,
const std::string&
current_driver)
533 bool found_current_driver =
false;
535 for(
auto& drvname : drivers) {
536 if(current_driver == drvname) {
537 found_current_driver =
true;
538 drvname =
"[" + current_driver +
"]";
542 if(drivers.empty() || !found_current_driver) {
544 drivers.emplace_back(
"[" + current_driver +
"]");
550 list_formatter video_settings_report_internal(
const std::string& heading =
"")
552 list_formatter fmt{heading};
554 std::string placeholder;
557 placeholder =
"Running in non-interactive mode.";
561 placeholder =
"Video not initialized yet.";
564 if(!placeholder.empty()) {
565 fmt.set_placeholder(placeholder);
573 std::string dpi_report;
575 dpi_report = dpi.first == 0.0f || dpi.second == 0.0f ?
577 geometry_to_string(dpi.first, dpi.second);
579 fmt.insert(
"SDL video drivers", format_sdl_driver_list(drivers, current_driver));
584 fmt.insert(
"Screen dpi", dpi_report);
589 fmt.insert(
info.first,
info.second);
595 list_formatter sound_settings_report_internal(
const std::string& heading =
"")
597 list_formatter fmt{heading};
601 if(!driver_status.initialized) {
602 fmt.set_placeholder(
"Audio not initialized.");
609 static std::map<uint16_t, std::string> audio_format_names = {
611 { AUDIO_U8,
"unsigned 8 bit" },
612 { AUDIO_S8,
"signed 8 bit" },
614 { AUDIO_U16LSB,
"unsigned 16 bit little-endian" },
615 { AUDIO_U16MSB,
"unsigned 16 bit big-endian" },
616 { AUDIO_S16LSB,
"signed 16 bit little-endian" },
617 { AUDIO_S16MSB,
"signed 16 bit big-endian" },
619 { AUDIO_S32LSB,
"signed 32 bit little-endian" },
620 { AUDIO_S32MSB,
"signed 32 bit big-endian" },
621 { AUDIO_F32LSB,
"signed 32 bit floating point little-endian" },
622 { AUDIO_F32MSB,
"signed 32 bit floating point big-endian" },
625 auto fmt_names_it = audio_format_names.find(driver_status.format);
627 const std::string fmt_name = fmt_names_it != audio_format_names.end()
628 ? fmt_names_it->second
629 :
formatter() <<
"0x" << std::setfill(
'0') << std::setw(2*
sizeof(driver_status.format)) << std::hex << std::uppercase << driver_status.format;
631 fmt.insert(
"SDL audio drivers", format_sdl_driver_list(drivers, current_driver));
632 fmt.insert(
"Number of channels", std::to_string(driver_status.channels));
633 fmt.insert(
"Output rate", std::to_string(driver_status.frequency) +
" Hz");
634 fmt.insert(
"Sample format", fmt_name);
635 fmt.insert(
"Sample size", std::to_string(driver_status.chunk_size) +
" bytes");
644 return formatter{} << library_versions_report_internal();
649 return formatter{} << optional_features_report_internal();
654 list_formatter::contents_list paths{
665 for(
auto& entry : paths) {
669 list_formatter::contents_list addons;
675 std::ostringstream o;
681 << list_formatter{
"Game paths", paths}
682 << library_versions_report_internal(
"Libraries")
683 << optional_features_report_internal(
"Features")
684 << video_settings_report_internal(
"Current video settings")
685 << sound_settings_report_internal(
"Current audio settings")
686 << list_formatter(
"Installed add-ons", addons,
"No add-ons installed.");
static const char heading_delimiter
std::string library_versions_report()
Produce a plain-text report of library versions suitable for stdout/stderr.
Interfaces for manipulating version numbers of engine, add-ons, etc.
std::string current_driver()
std::string current_driver()
The current video driver in use, or else "<not initialized>".
std::string join(const T &v, const std::string &s=",")
Generates a new string joining container items in a list.
static const std::string label_delimiter
std::string optional_features_report()
Produce a plain-text report of features suitable for stdout/stderr.
int current_refresh_rate()
The refresh rate of the screen.
std::string get_logs_dir()
std::vector< std::pair< std::string, std::string > > renderer_report()
Provides diagnostic information about the current renderer for the build_info API.
const std::string & library_build_version(LIBRARY_ID lib)
Retrieve the build-time version number of the given library.
std::vector< optional_feature > optional_features_table(bool localize)
Retrieve the features table.
static std::string _(const char *str)
std::string get_saves_dir()
std::vector< std::string > enumerate_drivers()
A list of available video drivers.
point current_resolution()
The current window size in desktop coordinates.
std::size_t size(const std::string &str)
Length in characters of a UTF-8 string.
const std::string & library_name(LIBRARY_ID lib)
Retrieve the user-visible name for the given library.
point output_size()
Returns the size of the final render target.
std::string label
What to show in the filter's drop-down list.
std::vector< optional_feature > features
std::string get_user_data_dir()
std::string dist_channel_id()
Return the distribution channel identifier, or "Default" if missing.
bool headless()
The game is running headless.
std::string build_arch()
Obtain the processor architecture for this build.
std::string sanitize_path(const std::string &path)
Sanitizes a path to remove references to the user's name.
std::ostream & operator<<(std::ostream &s, const ai::attack_result &r)
Platform identification and version information functions.
std::pair< float, float > get_dpi()
Retrieves the current game screen DPI for the build_info API.
std::string get_cache_dir()
std::vector< std::string > linked
const std::string revision
Game configuration data as global variables.
std::string os_version()
Returns a string with the running OS name and version information.
std::vector< std::string > names
point game_canvas_size()
The size of the game canvas, in drawing coordinates / game pixels.
const std::string & library_runtime_version(LIBRARY_ID lib)
Retrieve the runtime version number of the given library.
std::string & insert(std::string &str, const std::size_t pos, const std::string &insert)
Insert a UTF-8 string at the specified position.
Declarations for File-IO.
bool has_window()
Whether the game has set up a window to render into.
std::string get_user_config_dir()
std::string get_addons_dir()
void trim(std::string_view &s)
static driver_status query()
std::vector< std::string > enumerate_drivers()
static map_location::DIRECTION n
std::vector< std::string > compiled
std::string full_build_report()
Produce a bug report-style info dump.
std::map< std::string, std::string > installed_addons_and_versions()
Retrieves the ids and versions of all installed add-ons.