evert/osb
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

resolved most of the compiler warnings/errors under gcc

Browse Source 
also update xxhash and tinyformat
This commit is contained in:
LDA 2023-06-26 11:48:27 -07:00
parent 4585c9cafa
commit c9e889723b
51 changed files with 2302 additions and 1300 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@ -1,5 +1,6 @@
build/ build/
dist/ dist/
.cache/
attic/ attic/
tiled/ tiled/
assets/user/ assets/user/

4
source/CMakeLists.txt
View File

@ -226,8 +226,8 @@ ENDIF ()
# Set C/C++ compiler flags based on build environment... # Set C/C++ compiler flags based on build environment...
IF (STAR_COMPILER_GNU) IF (STAR_COMPILER_GNU)
SET (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra -Wuninitialized -Wunreachable-code -Wformat -no-pie") SET (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra -Wno-unused -Wno-implicit-fallthrough -no-pie")
SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++17 -Wall -Wextra -Wuninitialized -Wunreachable-code -Wformat -no-pie") SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++17 -Wall -Wextra -Wno-unused -Wno-implicit-fallthrough -no-pie")
IF (STAR_SYSTEM_FAMILY_WINDOWS) IF (STAR_SYSTEM_FAMILY_WINDOWS)
SET (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mthreads") SET (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mthreads")

2
source/application/StarRenderer_opengl20.cpp
View File

@ -710,7 +710,7 @@ void OpenGl20Renderer::logGlErrorSummary(String prefix) {
} else { } else {
Logger::error("<UNRECOGNIZED GL ERROR>"); Logger::error("<UNRECOGNIZED GL ERROR>");
} }
} while (error = glGetError()); } while ((error = glGetError()));
} }
} }

6
source/base/StarAssets.cpp
View File

@ -242,7 +242,7 @@ ImageConstPtr Assets::image(AssetPath const& path) const {
void Assets::queueImages(StringList const& paths) const { void Assets::queueImages(StringList const& paths) const {
queueAssets(paths.transformed([](String const& path) { queueAssets(paths.transformed([](String const& path) {
auto components = AssetPath::split(path); const auto components = AssetPath::split(path);
validatePath(components, true, true); validatePath(components, true, true);
return AssetId{AssetType::Image, move(components)}; return AssetId{AssetType::Image, move(components)};
@ -275,7 +275,7 @@ AudioConstPtr Assets::audio(String const& path) const {
void Assets::queueAudios(StringList const& paths) const { void Assets::queueAudios(StringList const& paths) const {
queueAssets(paths.transformed([](String const& path) { queueAssets(paths.transformed([](String const& path) {
auto components = AssetPath::split(path); const auto components = AssetPath::split(path);
validatePath(components, false, false); validatePath(components, false, false);
return AssetId{AssetType::Audio, move(components)}; return AssetId{AssetType::Audio, move(components)};
@ -866,7 +866,7 @@ shared_ptr<Assets::AssetData> Assets::loadImage(AssetPath const& path) const {
auto newData = make_shared<ImageData>(); auto newData = make_shared<ImageData>();
Image newImage = *source->image; Image newImage = *source->image;
path.directives.forEach([&](auto const& entry, Directives const& directives) { path.directives.forEach([&](auto const& entry, Directives const& directives) {
if (auto error = entry.operation.ptr<ErrorImageOperation>()) if (auto error = entry.operation.template ptr<ErrorImageOperation>())
std::rethrow_exception(error->exception); std::rethrow_exception(error->exception);
else else
processImageOperation(entry.operation, newImage, [&](String const& ref) { return references.get(ref).get(); }); processImageOperation(entry.operation, newImage, [&](String const& ref) { return references.get(ref).get(); });

2
source/core/StarBTreeDatabase.cpp
View File

@ -199,7 +199,7 @@ void BTreeDatabase::forAll(function<void(ByteArray, ByteArray)> v) {
bool BTreeDatabase::insert(ByteArray const& k, ByteArray const& data) { bool BTreeDatabase::insert(ByteArray const& k, ByteArray const& data) {
WriteLocker writeLocker(m_lock); WriteLocker writeLocker(m_lock);
checkKeySize(k); checkKeySize(k);
return m_impl.insert(move(k), move(data)); return m_impl.insert(k, data);
} }
bool BTreeDatabase::remove(ByteArray const& k) { bool BTreeDatabase::remove(ByteArray const& k) {

2
source/core/StarColor.hpp
View File

@ -67,7 +67,7 @@ public:
static Color temperature(float temp); static Color temperature(float temp);
static Vec4B hueShiftVec4B(Vec4B color, float hue); static Vec4B hueShiftVec4B(Vec4B color, float hue);
static Vec4B Color::hexToVec4B(StringView s); static Vec4B hexToVec4B(StringView s);
// Black // Black
Color(); Color();

14
source/core/StarDirectives.cpp
View File

@ -154,11 +154,11 @@ size_t Directives::size() const {
return shared ? shared->entries.size() : 0; return shared ? shared->entries.size() : 0;
} }
inline bool Directives::empty() const { bool Directives::empty() const {
return !shared || shared->empty(); return !shared || shared->empty();
} }
inline Directives::operator bool() const { Directives::operator bool() const {
return !empty(); return !empty();
} }
@ -205,11 +205,11 @@ DirectivesGroup::DirectivesGroup(String&& directives) : m_count(0) {
} }
} }
inline bool DirectivesGroup::empty() const { bool DirectivesGroup::empty() const {
return m_count == 0; return m_count == 0;
} }
inline DirectivesGroup::operator bool() const { DirectivesGroup::operator bool() const {
return empty(); return empty();
} }
@ -238,7 +238,7 @@ DirectivesGroup& DirectivesGroup::operator+=(Directives const& other) {
return *this; return *this;
} }
inline String DirectivesGroup::toString() const { String DirectivesGroup::toString() const {
String string; String string;
addToString(string); addToString(string);
return string; return string;
@ -272,7 +272,7 @@ bool DirectivesGroup::forEachAbortable(AbortableDirectivesCallback callback) con
return true; return true;
} }
inline Image DirectivesGroup::applyNewImage(Image const& image) const { Image DirectivesGroup::applyNewImage(Image const& image) const {
Image result = image; Image result = image;
applyExistingImage(result); applyExistingImage(result);
return result; return result;
@ -288,7 +288,7 @@ void DirectivesGroup::applyExistingImage(Image& image) const {
}); });
} }
inline size_t DirectivesGroup::hash() const { size_t DirectivesGroup::hash() const {
XXHash3 hasher; XXHash3 hasher;
for (auto& directives : m_directives) { for (auto& directives : m_directives) {
size_t hash = directives.hash(); size_t hash = directives.hash();

2
source/core/StarDirectives.hpp
View File

@ -23,7 +23,7 @@ public:
size_t length; size_t length;
ImageOperation const& loadOperation(Shared const& parent) const; ImageOperation const& loadOperation(Shared const& parent) const;
inline StringView string(Shared const& parent) const; StringView string(Shared const& parent) const;
Entry(ImageOperation&& newOperation, size_t begin, size_t end); Entry(ImageOperation&& newOperation, size_t begin, size_t end);
Entry(ImageOperation const& newOperation, size_t begin, size_t end); Entry(ImageOperation const& newOperation, size_t begin, size_t end);
Entry(Entry const& other); Entry(Entry const& other);

4
source/core/StarEncode.cpp
View File

@ -186,7 +186,7 @@ String hexEncode(char const* data, size_t len) {
size_t encoded = hexEncode(data, len, &res[0], res.size()); size_t encoded = hexEncode(data, len, &res[0], res.size());
_unused(encoded); _unused(encoded);
starAssert(encoded == res.size()); starAssert(encoded == res.size());
return move(res); return res;
} }
String base64Encode(char const* data, size_t len) { String base64Encode(char const* data, size_t len) {
@ -195,7 +195,7 @@ String base64Encode(char const* data, size_t len) {
_unused(encoded); _unused(encoded);
starAssert(encoded <= res.size()); starAssert(encoded <= res.size());
res.resize(encoded); res.resize(encoded);
return move(res); return res;
} }
String hexEncode(ByteArray const& data) { String hexEncode(ByteArray const& data) {

5
source/core/StarImageProcessing.cpp
View File

@ -204,7 +204,8 @@ ImageOperation imageOperationFromString(StringView string) {
return move(operation); return move(operation);
if (which = !which) which = !which;
if (which)
operation.colorReplaceMap[*(Vec4B*)&a] = *(Vec4B*)&b; operation.colorReplaceMap[*(Vec4B*)&a] = *(Vec4B*)&b;
hexLen = 0; hexLen = 0;
@ -219,7 +220,7 @@ ImageOperation imageOperationFromString(StringView string) {
//if (time != 0.0) //if (time != 0.0)
// Logger::logf(LogLevel::Debug, "Parsed %u long directives to %u replace operations in %fs", view.size(), operation.colorReplaceMap.size(), Time::monotonicTime() - time); // Logger::logf(LogLevel::Debug, "Parsed %u long directives to %u replace operations in %fs", view.size(), operation.colorReplaceMap.size(), Time::monotonicTime() - time);
return move(operation); return operation;
} }
List<StringView> bits; List<StringView> bits;

2
source/core/StarJson.cpp
View File

@ -1025,7 +1025,7 @@ Json jsonMerge(Json const& base, Json const& merger) {
if (!res.second) if (!res.second)
res.first->second = jsonMerge(res.first->second, p.second); res.first->second = jsonMerge(res.first->second, p.second);
} }
return move(merged); return merged;
} else if (merger.type() == Json::Type::Null) { } else if (merger.type() == Json::Type::Null) {
return base; return base;

2
source/core/StarJsonRpc.cpp
View File

@ -13,7 +13,7 @@ JsonRpc::JsonRpc() {
void JsonRpc::registerHandler(String const& handler, JsonRpcRemoteFunction func) { void JsonRpc::registerHandler(String const& handler, JsonRpcRemoteFunction func) {
if (m_handlers.contains(handler)) if (m_handlers.contains(handler))
throw JsonRpcException(strf("Handler by that name already exists '%s'", handler)); throw JsonRpcException(strf("Handler by that name already exists '%s'", handler));
m_handlers.add(move(handler), move(func)); m_handlers.add(handler, move(func));
} }
void JsonRpc::registerHandlers(JsonRpcHandlers const& handlers) { void JsonRpc::registerHandlers(JsonRpcHandlers const& handlers) {

2
source/core/StarLockFile_unix.cpp
View File

@ -14,7 +14,7 @@ int64_t const LockFile::MaximumSleepMillis;
Maybe<LockFile> LockFile::acquireLock(String const& filename, int64_t lockTimeout) { Maybe<LockFile> LockFile::acquireLock(String const& filename, int64_t lockTimeout) {
LockFile lock(move(filename)); LockFile lock(move(filename));
if (lock.lock(lockTimeout)) if (lock.lock(lockTimeout))
return move(lock); return lock;
return {}; return {};
} }

2
source/core/StarLua.hpp
View File

@ -109,7 +109,7 @@ namespace LuaDetail {
LuaHandle& operator=(LuaHandle&& other); LuaHandle& operator=(LuaHandle&& other);
LuaEnginePtr engine; LuaEnginePtr engine;
int handleIndex; int handleIndex = 0;
}; };
// Not meant to be used directly, exposes a raw interface for wrapped C++ // Not meant to be used directly, exposes a raw interface for wrapped C++

2
source/core/StarLuaConverters.cpp
View File

@ -33,7 +33,7 @@ Maybe<Color> LuaConverter<Color>::to(LuaEngine& engine, LuaValue const& v) {
} else if (auto s = v.ptr<LuaString>()) { } else if (auto s = v.ptr<LuaString>()) {
try { try {
return Color(s->ptr()); return Color(s->ptr());
} catch (ColorException) {} } catch (ColorException const&) {}
} }
return {}; return {};

2
source/core/StarOptionParser.cpp
View File

@ -67,7 +67,7 @@ pair<OptionParser::Options, StringList> OptionParser::parseOptions(StringList co
} }
} else { } else {
result.arguments.append(move(arg)); result.arguments.append(arg);
} }
} }

2
source/core/StarParametricFunction.hpp
View File

@ -124,7 +124,7 @@ ParametricTable<IndexType, ValueType>::ParametricTable(PairContainer indexValueP
return std::get<0>(a) < std::get<0>(b); return std::get<0>(a) < std::get<0>(b);
}); });
for (auto const pair : indexValuePairs) { for (auto const& pair : indexValuePairs) {
m_indexes.push_back(move(std::get<0>(pair))); m_indexes.push_back(move(std::get<0>(pair)));
m_values.push_back(move(std::get<1>(pair))); m_values.push_back(move(std::get<1>(pair)));
} }

10
source/core/StarPythonic.hpp
View File

@ -303,7 +303,13 @@ namespace RangeHelper {
STAR_EXCEPTION(RangeException, StarException); STAR_EXCEPTION(RangeException, StarException);
template <typename Value, typename Diff = int> template <typename Value, typename Diff = int>
class RangeIterator : public std::iterator<std::random_access_iterator_tag, Value> { class RangeIterator {
using iterator_category = std::random_access_iterator_tag;
using value_type = Value;
using difference_type = Diff;
using pointer = Value*;
using reference = Value&;
public: public:
RangeIterator() : m_start(), m_end(), m_diff(1), m_current(), m_stop(true) {} RangeIterator() : m_start(), m_end(), m_diff(1), m_current(), m_stop(true) {}
@ -342,7 +348,7 @@ public:
return *this; return *this;
} }
RangeIterator operator-=(Diff steps) const { RangeIterator operator-=(Diff steps) {
m_stop = false; m_stop = false;
sanity(); sanity();

8
source/core/StarRect.hpp
View File

@ -52,6 +52,7 @@ public:
Box(); Box();
Box(Coord const& min, Coord const& max); Box(Coord const& min, Coord const& max);
Box(Box const& b); Box(Box const& b);
Box& operator=(Box const& b);
template <typename T2> template <typename T2>
explicit Box(Box<T2, N> const& b); explicit Box(Box<T2, N> const& b);
@ -328,6 +329,13 @@ template <typename T, size_t N>
Box<T, N>::Box(Box const& b) Box<T, N>::Box(Box const& b)
: m_min(b.min()), m_max(b.max()) {} : m_min(b.min()), m_max(b.max()) {}
template <typename T, size_t N>
Box<T, N>& Box<T, N>::operator=(Box<T, N> const& b) {
m_min = b.m_min;
m_max = b.m_max;
return *this;
}
template <typename T, size_t N> template <typename T, size_t N>
template <typename T2> template <typename T2>
Box<T, N>::Box(Box<T2, N> const& b) Box<T, N>::Box(Box<T2, N> const& b)

4
source/core/StarString.hpp
View File

@ -428,7 +428,7 @@ String String::lookupTags(Lookup&& lookup) const {
} }
} }
return move(finalString); return finalString;
} }
template <typename Lookup> template <typename Lookup>
@ -466,7 +466,7 @@ Maybe<String> String::maybeLookupTagsView(Lookup&& lookup) const {
for (auto& view : finalViews) for (auto& view : finalViews)
finalString += view; finalString += view;
return move(finalString); return String(finalString);
} }
template <typename Lookup> template <typename Lookup>

2
source/core/StarStringView.cpp
View File

@ -425,7 +425,7 @@ bool operator<(StringView s1, StringView s2) {
return s1.m_view < s2.m_view; return s1.m_view < s2.m_view;
} }
std::ostream& operator<<(std::ostream& os, StringView& s) { std::ostream& operator<<(std::ostream& os, StringView const& s) {
os << s.utf8(); os << s.utf8();
return os; return os;
} }

2
source/core/StarStringView.hpp
View File

@ -100,7 +100,7 @@ public:
friend bool operator!=(StringView s1, StringView s2); friend bool operator!=(StringView s1, StringView s2);
friend bool operator<(StringView s1, StringView s2); friend bool operator<(StringView s1, StringView s2);
friend std::ostream& operator<<(std::ostream& os, StringView& s); friend std::ostream& operator<<(std::ostream& os, StringView const& s);
private: private:
int compare(size_t selfOffset, int compare(size_t selfOffset,

5
source/core/StarTime.cpp
View File

@ -177,6 +177,11 @@ Timer::Timer() : Clock(false) {
Timer::Timer(Timer const& timer) Timer::Timer(Timer const& timer)
: Clock(timer) {} : Clock(timer) {}
Timer& Timer::operator=(Timer const& timer) {
Clock::operator=(timer);
return *this;
}
void Timer::restart(double timeLeft) { void Timer::restart(double timeLeft) {
Clock::setTime(-timeLeft); Clock::setTime(-timeLeft);
Clock::start(); Clock::start();

1
source/core/StarTime.hpp
View File

@ -85,6 +85,7 @@ public:
// Constructs a stopped timer whose time is up. // Constructs a stopped timer whose time is up.
Timer(); Timer();
Timer(Timer const& timer); Timer(Timer const& timer);
Timer& operator=(Timer const& timer);
// Start the timer with the given time left. // Start the timer with the given time left.
void restart(double timeLeft); void restart(double timeLeft);

1
source/extern/.gitattributes vendored Normal file
View File

@ -0,0 +1 @@
** linguist-vendored=true

406
source/extern/tinyformat.h vendored
View File

@ -33,6 +33,7 @@
// //
// * Type safety and extensibility for user defined types. // * Type safety and extensibility for user defined types.
// * C99 printf() compatibility, to the extent possible using std::ostream // * C99 printf() compatibility, to the extent possible using std::ostream
// * POSIX extension for positional arguments
// * Simplicity and minimalism. A single header file to include and distribute // * Simplicity and minimalism. A single header file to include and distribute
// with your projects. // with your projects.
// * Augment rather than replace the standard stream formatting mechanism // * Augment rather than replace the standard stream formatting mechanism
@ -42,7 +43,7 @@
// Main interface example usage // Main interface example usage
// ---------------------------- // ----------------------------
// //
// To print a date to std::cout: // To print a date to std::cout for American usage:
// //
// std::string weekday = "Wednesday"; // std::string weekday = "Wednesday";
// const char* month = "July"; // const char* month = "July";
@ -52,6 +53,14 @@
// //
// tfm::printf("%s, %s %d, %.2d:%.2d\n", weekday, month, day, hour, min); // tfm::printf("%s, %s %d, %.2d:%.2d\n", weekday, month, day, hour, min);
// //
// POSIX extension for positional arguments is available.
// The ability to rearrange formatting arguments is an important feature
// for localization because the word order may vary in different languages.
//
// Previous example for German usage. Arguments are reordered:
//
// tfm::printf("%1$s, %3$d. %2$s, %4$d:%5$.2d\n", weekday, month, day, hour, min);
//
// The strange types here emphasize the type safety of the interface; it is // The strange types here emphasize the type safety of the interface; it is
// possible to print a std::string using the "%s" conversion, and a // possible to print a std::string using the "%s" conversion, and a
// size_t using the "%d" conversion. A similar result could be achieved // size_t using the "%d" conversion. A similar result could be achieved
@ -133,11 +142,17 @@ namespace tfm = tinyformat;
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
// Implementation details. // Implementation details.
#include <algorithm> #include <algorithm>
#include <cassert>
#include <iostream> #include <iostream>
#include <sstream> #include <sstream>
#include <cmath>
#ifndef TINYFORMAT_ASSERT
# include <cassert>
# define TINYFORMAT_ASSERT(cond) assert(cond)
#endif
#ifndef TINYFORMAT_ERROR #ifndef TINYFORMAT_ERROR
# include <cassert>
# define TINYFORMAT_ERROR(reason) assert(0 && reason) # define TINYFORMAT_ERROR(reason) assert(0 && reason)
#endif #endif
@ -147,23 +162,14 @@ namespace tfm = tinyformat;
# endif # endif
#endif #endif
#ifdef TINYFORMAT_USE_VARIADIC_TEMPLATES
# include <array>
# if defined(_MSC_VER) && _MSC_VER <= 1800 // VS2013
# define TINYFORMAT_BRACED_INIT_WORKAROUND(x) (x)
# else
# define TINYFORMAT_BRACED_INIT_WORKAROUND(x) {x}
# endif
#endif
#if defined(__GLIBCXX__) && __GLIBCXX__ < 20080201 #if defined(__GLIBCXX__) && __GLIBCXX__ < 20080201
// std::showpos is broken on old libstdc++ as provided with OSX. See // std::showpos is broken on old libstdc++ as provided with macOS. See
// http://gcc.gnu.org/ml/libstdc++/2007-11/msg00075.html // http://gcc.gnu.org/ml/libstdc++/2007-11/msg00075.html
# define TINYFORMAT_OLD_LIBSTDCPLUSPLUS_WORKAROUND # define TINYFORMAT_OLD_LIBSTDCPLUSPLUS_WORKAROUND
#endif #endif
#ifdef __APPLE__ #ifdef __APPLE__
// Workaround OSX linker warning: xcode uses different default symbol // Workaround macOS linker warning: Xcode uses different default symbol
// visibilities for static libs vs executables (see issue #25) // visibilities for static libs vs executables (see issue #25)
# define TINYFORMAT_HIDDEN __attribute__((visibility("hidden"))) # define TINYFORMAT_HIDDEN __attribute__((visibility("hidden")))
#else #else
@ -219,7 +225,7 @@ template<int n> struct is_wchar<wchar_t[n]> {};
template<typename T, typename fmtT, bool convertible = is_convertible<T, fmtT>::value> template<typename T, typename fmtT, bool convertible = is_convertible<T, fmtT>::value>
struct formatValueAsType struct formatValueAsType
{ {
static void invoke(std::ostream& /*out*/, const T& /*value*/) { assert(0); } static void invoke(std::ostream& /*out*/, const T& /*value*/) { TINYFORMAT_ASSERT(0); }
}; };
// Specialized version for types that can actually be converted to fmtT, as // Specialized version for types that can actually be converted to fmtT, as
// indicated by the "convertible" template parameter. // indicated by the "convertible" template parameter.
@ -241,8 +247,7 @@ struct formatZeroIntegerWorkaround<T,true>
{ {
static bool invoke(std::ostream& out, const T& value) static bool invoke(std::ostream& out, const T& value)
{ {
if (static_cast<int>(value) == 0 && out.flags() & std::ios::showpos) if (static_cast<int>(value) == 0 && out.flags() & std::ios::showpos) {
{
out << "+0"; out << "+0";
return true; return true;
} }
@ -277,7 +282,7 @@ inline void formatTruncated(std::ostream& out, const T& value, int ntrunc)
std::ostringstream tmp; std::ostringstream tmp;
tmp << value; tmp << value;
std::string result = tmp.str(); std::string result = tmp.str();
out.write(result.c_str(), std::min(ntrunc, static_cast<int>(result.size()))); out.write(result.c_str(), (std::min)(ntrunc, static_cast<int>(result.size())));
} }
#define TINYFORMAT_DEFINE_FORMAT_TRUNCATED_CSTR(type) \ #define TINYFORMAT_DEFINE_FORMAT_TRUNCATED_CSTR(type) \
inline void formatTruncated(std::ostream& out, type* value, int ntrunc) \ inline void formatTruncated(std::ostream& out, type* value, int ntrunc) \
@ -293,6 +298,21 @@ TINYFORMAT_DEFINE_FORMAT_TRUNCATED_CSTR(const char)
TINYFORMAT_DEFINE_FORMAT_TRUNCATED_CSTR(char) TINYFORMAT_DEFINE_FORMAT_TRUNCATED_CSTR(char)
#undef TINYFORMAT_DEFINE_FORMAT_TRUNCATED_CSTR #undef TINYFORMAT_DEFINE_FORMAT_TRUNCATED_CSTR
template<typename T>
void spaceFillIfNotFinite(std::ostream& out, const T& value) { }
// TODO: type_traits would clearly be better here. Should consider moving all
// these workarounds into a big pre-C++11 section.
#define TINYFORMAT_SETFILL_NOT_FINITE_FLOATING(type) \
inline void spaceFillIfNotFinite(std::ostream& out, type value) \
{ \
if (out.fill() == '0' && !std::isfinite(value)) \
out.fill(' '); \
}
TINYFORMAT_SETFILL_NOT_FINITE_FLOATING(float)
TINYFORMAT_SETFILL_NOT_FINITE_FLOATING(double)
TINYFORMAT_SETFILL_NOT_FINITE_FLOATING(long double)
#undef TINYFORMAT_SETFILL_NOT_FINITE_FLOATING
} // namespace detail } // namespace detail
@ -327,8 +347,9 @@ inline void formatValue(std::ostream& out, const char* /*fmtBegin*/,
// void* respectively and format that instead of the value itself. For the // void* respectively and format that instead of the value itself. For the
// %p conversion it's important to avoid dereferencing the pointer, which // %p conversion it's important to avoid dereferencing the pointer, which
// could otherwise lead to a crash when printing a dangling (const char*). // could otherwise lead to a crash when printing a dangling (const char*).
bool canConvertToChar = detail::is_convertible<T,char>::value; const bool canConvertToChar = detail::is_convertible<T,char>::value;
bool canConvertToVoidPtr = detail::is_convertible<T, const void*>::value; const bool canConvertToVoidPtr = detail::is_convertible<T, const void*>::value;
detail::spaceFillIfNotFinite(out, value);
if (canConvertToChar && *(fmtEnd-1) == 'c') if (canConvertToChar && *(fmtEnd-1) == 'c')
detail::formatValueAsType<T, char>::invoke(out, value); detail::formatValueAsType<T, char>::invoke(out, value);
else if (canConvertToVoidPtr && *(fmtEnd-1) == 'p') else if (canConvertToVoidPtr && *(fmtEnd-1) == 'p')
@ -336,8 +357,7 @@ inline void formatValue(std::ostream& out, const char* /*fmtBegin*/,
#ifdef TINYFORMAT_OLD_LIBSTDCPLUSPLUS_WORKAROUND #ifdef TINYFORMAT_OLD_LIBSTDCPLUSPLUS_WORKAROUND
else if (detail::formatZeroIntegerWorkaround<T>::invoke(out, value)) /**/; else if (detail::formatZeroIntegerWorkaround<T>::invoke(out, value)) /**/;
#endif #endif
else if(ntrunc >= 0) else if (ntrunc >= 0) {
{
// Take care not to overread C strings in truncating conversions like // Take care not to overread C strings in truncating conversions like
// "%.4s" where at most 4 characters may be read. // "%.4s" where at most 4 characters may be read.
detail::formatTruncated(out, value, ntrunc); detail::formatTruncated(out, value, ntrunc);
@ -352,8 +372,7 @@ inline void formatValue(std::ostream& out, const char* /*fmtBegin*/,
inline void formatValue(std::ostream& out, const char* /*fmtBegin*/, \ inline void formatValue(std::ostream& out, const char* /*fmtBegin*/, \
const char* fmtEnd, int /**/, charType value) \ const char* fmtEnd, int /**/, charType value) \
{ \ { \
switch(*(fmtEnd-1)) \ switch (*(fmtEnd-1)) { \
{ \
case 'u': case 'd': case 'i': case 'o': case 'X': case 'x': \ case 'u': case 'd': case 'i': case 'o': case 'X': case 'x': \
out << static_cast<int>(value); break; \ out << static_cast<int>(value); break; \
default: \ default: \
@ -378,11 +397,11 @@ TINYFORMAT_DEFINE_FORMATVALUE_CHAR(unsigned char)
#define TINYFORMAT_PASSARGS_TAIL(n) TINYFORMAT_PASSARGS_TAIL_ ## n #define TINYFORMAT_PASSARGS_TAIL(n) TINYFORMAT_PASSARGS_TAIL_ ## n
// To keep it as transparent as possible, the macros below have been generated // To keep it as transparent as possible, the macros below have been generated
// using python via the excellent cog.py code generation script. This avoids // using python via the excellent cog code generation script. This avoids
// the need for a bunch of complex (but more general) preprocessor tricks as // the need for a bunch of complex (but more general) preprocessor tricks as
// used in boost.preprocessor. // used in boost.preprocessor.
// //
// To rerun the code generation in place, use `cog.py -r tinyformat.h` // To rerun the code generation in place, use `cog -r tinyformat.h`
// (see http://nedbatchelder.com/code/cog). Alternatively you can just create // (see http://nedbatchelder.com/code/cog). Alternatively you can just create
// extra versions by hand. // extra versions by hand.
@ -491,16 +510,22 @@ namespace detail {
// Type-opaque holder for an argument to format(), with associated actions on // Type-opaque holder for an argument to format(), with associated actions on
// the type held as explicit function pointers. This allows FormatArg's for // the type held as explicit function pointers. This allows FormatArg's for
// each argument to be allocated as a homogenous array inside FormatList // each argument to be allocated as a homogeneous array inside FormatList
// whereas a naive implementation based on inheritance does not. // whereas a naive implementation based on inheritance does not.
class FormatArg class FormatArg
{ {
public: public:
FormatArg() {} FormatArg()
: m_value(NULL),
m_formatImpl(NULL),
m_toIntImpl(NULL)
{ }
template<typename T> template<typename T>
FormatArg(const T& value) FormatArg(const T& value)
: m_value(static_cast<const void*>(&value)), // C-style cast here allows us to also remove volatile; we put it
// back in the *Impl functions before dereferencing to avoid UB.
: m_value((const void*)(&value)),
m_formatImpl(&formatImpl<T>), m_formatImpl(&formatImpl<T>),
m_toIntImpl(&toIntImpl<T>) m_toIntImpl(&toIntImpl<T>)
{ } { }
@ -508,11 +533,15 @@ class FormatArg
void format(std::ostream& out, const char* fmtBegin, void format(std::ostream& out, const char* fmtBegin,
const char* fmtEnd, int ntrunc) const const char* fmtEnd, int ntrunc) const
{ {
TINYFORMAT_ASSERT(m_value);
TINYFORMAT_ASSERT(m_formatImpl);
m_formatImpl(out, fmtBegin, fmtEnd, ntrunc, m_value); m_formatImpl(out, fmtBegin, fmtEnd, ntrunc, m_value);
} }
int toInt() const int toInt() const
{ {
TINYFORMAT_ASSERT(m_value);
TINYFORMAT_ASSERT(m_toIntImpl);
return m_toIntImpl(m_value); return m_toIntImpl(m_value);
} }
@ -547,29 +576,63 @@ inline int parseIntAndAdvance(const char*& c)
return i; return i;
} }
// Print literal part of format string and return next format spec // Parse width or precision `n` from format string pointer `c`, and advance it
// position. // to the next character. If an indirection is requested with `*`, the argument
// is read from `args[argIndex]` and `argIndex` is incremented (or read
// from `args[n]` in positional mode). Returns true if one or more
// characters were read.
inline bool parseWidthOrPrecision(int& n, const char*& c, bool positionalMode,
const detail::FormatArg* args,
int& argIndex, int numArgs)
{
if (*c >= '0' && *c <= '9') {
n = parseIntAndAdvance(c);
}
else if (*c == '*') {
++c;
n = 0;
if (positionalMode) {
int pos = parseIntAndAdvance(c) - 1;
if (*c != '$')
TINYFORMAT_ERROR("tinyformat: Non-positional argument used after a positional one");
if (pos >= 0 && pos < numArgs)
n = args[pos].toInt();
else
TINYFORMAT_ERROR("tinyformat: Positional argument out of range");
++c;
}
else {
if (argIndex < numArgs)
n = args[argIndex++].toInt();
else
TINYFORMAT_ERROR("tinyformat: Not enough arguments to read variable width or precision");
}
}
else {
return false;
}
return true;
}
// Print literal part of format string and return next format spec position.
// //
// Skips over any occurrences of '%%', printing a literal '%' to the // Skips over any occurrences of '%%', printing a literal '%' to the output.
// output. The position of the first % character of the next // The position of the first % character of the next nontrivial format spec is
// nontrivial format spec is returned, or the end of string. // returned, or the end of string.
inline const char* printFormatStringLiteral(std::ostream& out, const char* fmt) inline const char* printFormatStringLiteral(std::ostream& out, const char* fmt)
{ {
const char* c = fmt; const char* c = fmt;
for(;; ++c) for (;; ++c) {
{ if (*c == '\0') {
switch(*c) out.write(fmt, c - fmt);
{
case '\0':
out.write(fmt, static_cast<std::streamsize>(c - fmt));
return c; return c;
case '%': }
out.write(fmt, static_cast<std::streamsize>(c - fmt)); else if (*c == '%') {
out.write(fmt, c - fmt);
if (*(c+1) != '%') if (*(c+1) != '%')
return c; return c;
// for "%%", tack trailing % onto next literal section. // for "%%", tack trailing % onto next literal section.
fmt = ++c; fmt = ++c;
break;
} }
} }
} }
@ -578,23 +641,43 @@ inline const char* printFormatStringLiteral(std::ostream& out, const char* fmt)
// Parse a format string and set the stream state accordingly. // Parse a format string and set the stream state accordingly.
// //
// The format mini-language recognized here is meant to be the one from C99, // The format mini-language recognized here is meant to be the one from C99,
// with the form "%[flags][width][.precision][length]type". // with the form "%[flags][width][.precision][length]type" with POSIX
// positional arguments extension.
//
// POSIX positional arguments extension:
// Conversions can be applied to the nth argument after the format in
// the argument list, rather than to the next unused argument. In this case,
// the conversion specifier character % (see below) is replaced by the sequence
// "%n$", where n is a decimal integer in the range [1,{NL_ARGMAX}],
// giving the position of the argument in the argument list. This feature
// provides for the definition of format strings that select arguments
// in an order appropriate to specific languages.
//
// The format can contain either numbered argument conversion specifications
// (that is, "%n$" and "*m$"), or unnumbered argument conversion specifications
// (that is, % and * ), but not both. The only exception to this is that %%
// can be mixed with the "%n$" form. The results of mixing numbered and
// unnumbered argument specifications in a format string are undefined.
// When numbered argument specifications are used, specifying the Nth argument
// requires that all the leading arguments, from the first to the (N-1)th,
// are specified in the format string.
//
// In format strings containing the "%n$" form of conversion specification,
// numbered arguments in the argument list can be referenced from the format
// string as many times as required.
// //
// Formatting options which can't be natively represented using the ostream // Formatting options which can't be natively represented using the ostream
// state are returned in spacePadPositive (for space padded positive numbers) // state are returned in spacePadPositive (for space padded positive numbers)
// and ntrunc (for truncating conversions). argIndex is incremented if // and ntrunc (for truncating conversions). argIndex is incremented if
// necessary to pull out variable width and precision. The function returns a // necessary to pull out variable width and precision. The function returns a
// pointer to the character after the end of the current format spec. // pointer to the character after the end of the current format spec.
inline const char* streamStateFromFormat(std::ostream& out, bool& spacePadPositive, inline const char* streamStateFromFormat(std::ostream& out, bool& positionalMode,
bool& spacePadPositive,
int& ntrunc, const char* fmtStart, int& ntrunc, const char* fmtStart,
const detail::FormatArg* formatters, const detail::FormatArg* args,
int& argIndex, int numFormatters) int& argIndex, int numArgs)
{ {
if(*fmtStart != '%') TINYFORMAT_ASSERT(*fmtStart == '%');
{
TINYFORMAT_ERROR("tinyformat: Not enough conversion specifiers in format string");
return fmtStart;
}
// Reset stream state to defaults. // Reset stream state to defaults.
out.width(0); out.width(0);
out.precision(6); out.precision(6);
@ -607,18 +690,52 @@ inline const char* streamStateFromFormat(std::ostream& out, bool& spacePadPositi
bool widthSet = false; bool widthSet = false;
int widthExtra = 0; int widthExtra = 0;
const char* c = fmtStart + 1; const char* c = fmtStart + 1;
// 1) Parse flags
for(;; ++c) // 1) Parse an argument index (if followed by '$') or a width possibly
{ // preceded with '0' flag.
switch(*c) if (*c >= '0' && *c <= '9') {
{ const char tmpc = *c;
int value = parseIntAndAdvance(c);
if (*c == '$') {
// value is an argument index
if (value > 0 && value <= numArgs)
argIndex = value - 1;
else
TINYFORMAT_ERROR("tinyformat: Positional argument out of range");
++c;
positionalMode = true;
}
else if (positionalMode) {
TINYFORMAT_ERROR("tinyformat: Non-positional argument used after a positional one");
}
else {
if (tmpc == '0') {
// Use internal padding so that numeric values are
// formatted correctly, eg -00010 rather than 000-10
out.fill('0');
out.setf(std::ios::internal, std::ios::adjustfield);
}
if (value != 0) {
// Nonzero value means that we parsed width.
widthSet = true;
out.width(value);
}
}
}
else if (positionalMode) {
TINYFORMAT_ERROR("tinyformat: Non-positional argument used after a positional one");
}
// 2) Parse flags and width if we did not do it in previous step.
if (!widthSet) {
// Parse flags
for (;; ++c) {
switch (*c) {
case '#': case '#':
out.setf(std::ios::showpoint | std::ios::showbase); out.setf(std::ios::showpoint | std::ios::showbase);
continue; continue;
case '0': case '0':
// overridden by left alignment ('-' flag) // overridden by left alignment ('-' flag)
if(!(out.flags() & std::ios::left)) if (!(out.flags() & std::ios::left)) {
{
// Use internal padding so that numeric values are // Use internal padding so that numeric values are
// formatted correctly, eg -00010 rather than 000-10 // formatted correctly, eg -00010 rather than 000-10
out.fill('0'); out.fill('0');
@ -639,66 +756,47 @@ inline const char* streamStateFromFormat(std::ostream& out, bool& spacePadPositi
spacePadPositive = false; spacePadPositive = false;
widthExtra = 1; widthExtra = 1;
continue; continue;
default:
break;
} }
break; break;
} }
// 2) Parse width // Parse width
if(*c >= '0' && *c <= '9')
{
widthSet = true;
out.width(parseIntAndAdvance(c));
}
if(*c == '*')
{
widthSet = true;
int width = 0; int width = 0;
if(argIndex < numFormatters) widthSet = parseWidthOrPrecision(width, c, positionalMode,
width = formatters[argIndex++].toInt(); args, argIndex, numArgs);
else if (widthSet) {
TINYFORMAT_ERROR("tinyformat: Not enough arguments to read variable width"); if (width < 0) {
if(width < 0)
{
// negative widths correspond to '-' flag set // negative widths correspond to '-' flag set
out.fill(' '); out.fill(' ');
out.setf(std::ios::left, std::ios::adjustfield); out.setf(std::ios::left, std::ios::adjustfield);
width = -width; width = -width;
} }
out.width(width); out.width(width);
++c; }
} }
// 3) Parse precision // 3) Parse precision
if(*c == '.') if (*c == '.') {
{
++c; ++c;
int precision = 0; int precision = 0;
if(*c == '*') parseWidthOrPrecision(precision, c, positionalMode,
{ args, argIndex, numArgs);
++c; // Presence of `.` indicates precision set, unless the inferred value
if(argIndex < numFormatters) // was negative in which case the default is used.
precision = formatters[argIndex++].toInt(); precisionSet = precision >= 0;
else if (precisionSet)
TINYFORMAT_ERROR("tinyformat: Not enough arguments to read variable precision");
}
else
{
if(*c >= '0' && *c <= '9')
precision = parseIntAndAdvance(c);
else if(*c == '-') // negative precisions ignored, treated as zero.
parseIntAndAdvance(++c);
}
out.precision(precision); out.precision(precision);
precisionSet = true;
} }
// 4) Ignore any C99 length modifier // 4) Ignore any C99 length modifier
while (*c == 'l' || *c == 'h' || *c == 'L' || while (*c == 'l' || *c == 'h' || *c == 'L' ||
*c == 'j' || *c == 'z' || *c == 't') *c == 'j' || *c == 'z' || *c == 't') {
++c; ++c;
}
// 5) We're up to the conversion specifier character. // 5) We're up to the conversion specifier character.
// Set stream flags based on conversion specifier (thanks to the // Set stream flags based on conversion specifier (thanks to the
// boost::format class for forging the way here). // boost::format class for forging the way here).
bool intConversion = false; bool intConversion = false;
switch(*c) switch (*c) {
{
case 'u': case 'd': case 'i': case 'u': case 'd': case 'i':
out.setf(std::ios::dec, std::ios::basefield); out.setf(std::ios::dec, std::ios::basefield);
intConversion = true; intConversion = true;
@ -709,39 +807,51 @@ inline const char* streamStateFromFormat(std::ostream& out, bool& spacePadPositi
break; break;
case 'X': case 'X':
out.setf(std::ios::uppercase); out.setf(std::ios::uppercase);
// Falls through
case 'x': case 'p': case 'x': case 'p':
out.setf(std::ios::hex, std::ios::basefield); out.setf(std::ios::hex, std::ios::basefield);
intConversion = true; intConversion = true;
break; break;
case 'E': case 'E':
out.setf(std::ios::uppercase); out.setf(std::ios::uppercase);
// Falls through
case 'e': case 'e':
out.setf(std::ios::scientific, std::ios::floatfield); out.setf(std::ios::scientific, std::ios::floatfield);
out.setf(std::ios::dec, std::ios::basefield); out.setf(std::ios::dec, std::ios::basefield);
break; break;
case 'F': case 'F':
out.setf(std::ios::uppercase); out.setf(std::ios::uppercase);
// Falls through
case 'f': case 'f':
out.setf(std::ios::fixed, std::ios::floatfield); out.setf(std::ios::fixed, std::ios::floatfield);
break; break;
case 'A':
out.setf(std::ios::uppercase);
// Falls through
case 'a':
# ifdef _MSC_VER
// Workaround https://developercommunity.visualstudio.com/content/problem/520472/hexfloat-stream-output-does-not-ignore-precision-a.html
// by always setting maximum precision on MSVC to avoid precision
// loss for doubles.
out.precision(13);
# endif
out.setf(std::ios::fixed | std::ios::scientific, std::ios::floatfield);
break;
case 'G': case 'G':
out.setf(std::ios::uppercase); out.setf(std::ios::uppercase);
// Falls through
case 'g': case 'g':
out.setf(std::ios::dec, std::ios::basefield); out.setf(std::ios::dec, std::ios::basefield);
// As in boost::format, let stream decide float format. // As in boost::format, let stream decide float format.
out.flags(out.flags() & ~std::ios::floatfield); out.flags(out.flags() & ~std::ios::floatfield);
break; break;
case 'a': case 'A':
TINYFORMAT_ERROR("tinyformat: the %a and %A conversion specs "
"are not supported");
break;
case 'c': case 'c':
// Handled as special case inside formatValue() // Handled as special case inside formatValue()
break; break;
case 's': case 's':
if (precisionSet) if (precisionSet)
ntrunc = static_cast<int>(out.precision()); ntrunc = static_cast<int>(out.precision());
// Make %s print booleans as "true" and "false" // Make %s print Booleans as "true" and "false"
out.setf(std::ios::boolalpha); out.setf(std::ios::boolalpha);
break; break;
case 'n': case 'n':
@ -752,9 +862,10 @@ inline const char* streamStateFromFormat(std::ostream& out, bool& spacePadPositi
TINYFORMAT_ERROR("tinyformat: Conversion spec incorrectly " TINYFORMAT_ERROR("tinyformat: Conversion spec incorrectly "
"terminated by end of string"); "terminated by end of string");
return c; return c;
default:
break;
} }
if(intConversion && precisionSet && !widthSet) if (intConversion && precisionSet && !widthSet) {
{
// "precision" for integers gives the minimum number of digits (to be // "precision" for integers gives the minimum number of digits (to be
// padded with zeros on the left). This isn't really supported by the // padded with zeros on the left). This isn't really supported by the
// iostreams, but we can approximately simulate it with the width if // iostreams, but we can approximately simulate it with the width if
@ -769,8 +880,8 @@ inline const char* streamStateFromFormat(std::ostream& out, bool& spacePadPositi
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
inline void formatImpl(std::ostream& out, const char* fmt, inline void formatImpl(std::ostream& out, const char* fmt,
const detail::FormatArg* formatters, const detail::FormatArg* args,
int numFormatters) int numArgs)
{ {
// Saved stream state // Saved stream state
std::streamsize origWidth = out.width(); std::streamsize origWidth = out.width();
@ -778,26 +889,34 @@ inline void formatImpl(std::ostream& out, const char* fmt,
std::ios::fmtflags origFlags = out.flags(); std::ios::fmtflags origFlags = out.flags();
char origFill = out.fill(); char origFill = out.fill();
for (int argIndex = 0; argIndex < numFormatters; ++argIndex) // "Positional mode" means all format specs should be of the form "%n$..."
{ // with `n` an integer. We detect this in `streamStateFromFormat`.
// Parse the format string bool positionalMode = false;
int argIndex = 0;
while (true) {
fmt = printFormatStringLiteral(out, fmt); fmt = printFormatStringLiteral(out, fmt);
if (*fmt == '\0') {
if (!positionalMode && argIndex < numArgs) {
TINYFORMAT_ERROR("tinyformat: Not enough conversion specifiers in format string");
}
break;
}
bool spacePadPositive = false; bool spacePadPositive = false;
int ntrunc = -1; int ntrunc = -1;
const char* fmtEnd = streamStateFromFormat(out, spacePadPositive, ntrunc, fmt, const char* fmtEnd = streamStateFromFormat(out, positionalMode, spacePadPositive, ntrunc, fmt,
formatters, argIndex, numFormatters); args, argIndex, numArgs);
if (argIndex >= numFormatters) // NB: argIndex may be incremented by reading variable width/precision
{ // in `streamStateFromFormat`, so do the bounds check here.
// Check args remain after reading any variable width/precision if (argIndex >= numArgs) {
TINYFORMAT_ERROR("tinyformat: Not enough format arguments"); TINYFORMAT_ERROR("tinyformat: Too many conversion specifiers in format string");
return; return;
} }
const FormatArg& arg = formatters[argIndex]; const FormatArg& arg = args[argIndex];
// Format the arg into the stream. // Format the arg into the stream.
if(!spacePadPositive) if (!spacePadPositive) {
arg.format(out, fmt, fmtEnd, ntrunc); arg.format(out, fmt, fmtEnd, ntrunc);
else }
{ else {
// The following is a special case with no direct correspondence // The following is a special case with no direct correspondence
// between stream formatting and the printf() behaviour. Simulate // between stream formatting and the printf() behaviour. Simulate
// it crudely by formatting into a temporary string stream and // it crudely by formatting into a temporary string stream and
@ -807,18 +926,17 @@ inline void formatImpl(std::ostream& out, const char* fmt,
tmpStream.setf(std::ios::showpos); tmpStream.setf(std::ios::showpos);
arg.format(tmpStream, fmt, fmtEnd, ntrunc); arg.format(tmpStream, fmt, fmtEnd, ntrunc);
std::string result = tmpStream.str(); // allocates... yuck. std::string result = tmpStream.str(); // allocates... yuck.
for(size_t i = 0, iend = result.size(); i < iend; ++i) for (size_t i = 0, iend = result.size(); i < iend; ++i) {
if(result[i] == '+') result[i] = ' '; if (result[i] == '+')
result[i] = ' ';
}
out << result; out << result;
} }
if (!positionalMode)
++argIndex;
fmt = fmtEnd; fmt = fmtEnd;
} }
// Print remaining part of format string.
fmt = printFormatStringLiteral(out, fmt);
if(*fmt != '\0')
TINYFORMAT_ERROR("tinyformat: Too many conversion specifiers in format string");
// Restore stream state // Restore stream state
out.width(origWidth); out.width(origWidth);
out.precision(origPrecision); out.precision(origPrecision);
@ -838,17 +956,14 @@ inline void formatImpl(std::ostream& out, const char* fmt,
class FormatList class FormatList
{ {
public: public:
FormatList(detail::FormatArg* args, int N)
: m_args(args), m_N(N) { }
friend void vformat(std::ostream& out, const char* fmt, friend void vformat(std::ostream& out, const char* fmt,
const FormatList& list); const FormatList& list);
protected:
void setFormatters(detail::FormatArg* formatters, int N) {
m_formatters = formatters;
m_N = N;
}
private: private:
const detail::FormatArg* m_formatters; const detail::FormatArg* m_args;
int m_N; int m_N;
}; };
@ -859,29 +974,24 @@ typedef const FormatList& FormatListRef;
namespace detail { namespace detail {
// Format list subclass with fixed storage to avoid dynamic allocation // Format list subclass with fixed storage to avoid dynamic allocation
template<int N> template<std::size_t N>
class FormatListN : public FormatList class FormatListN : public FormatList
{ {
public: public:
#ifdef TINYFORMAT_USE_VARIADIC_TEMPLATES #ifdef TINYFORMAT_USE_VARIADIC_TEMPLATES
template<typename... Args> template<typename... Args>
FormatListN(const Args&... args) FormatListN(const Args&... args)
: m_formatterStore TINYFORMAT_BRACED_INIT_WORKAROUND({ FormatArg(args)... }) : FormatList(&m_formatterStore[0], N),
{ m_formatterStore { FormatArg(args)... }
static_assert(sizeof...(args) == N, "Number of args must be N"); { static_assert(sizeof...(args) == N, "Number of args must be N"); }
setFormatters(&m_formatterStore[0], N);
}
#else // C++98 version #else // C++98 version
void init(int) {} void init(int) {}
# define TINYFORMAT_MAKE_FORMATLIST_CONSTRUCTOR(n) \ # define TINYFORMAT_MAKE_FORMATLIST_CONSTRUCTOR(n) \
\ \
template<TINYFORMAT_ARGTYPES(n)> \ template<TINYFORMAT_ARGTYPES(n)> \
FormatListN(TINYFORMAT_VARARGS(n)) \ FormatListN(TINYFORMAT_VARARGS(n)) \
{ \ : FormatList(&m_formatterStore[0], n) \
setFormatters(&m_formatterStore[0], n); \ { TINYFORMAT_ASSERT(n == N); init(0, TINYFORMAT_PASSARGS(n)); } \
assert(n == N); \
init(0, TINYFORMAT_PASSARGS(n)); \
} \
\ \
template<TINYFORMAT_ARGTYPES(n)> \ template<TINYFORMAT_ARGTYPES(n)> \
void init(int i, TINYFORMAT_VARARGS(n)) \ void init(int i, TINYFORMAT_VARARGS(n)) \
@ -893,19 +1003,19 @@ class FormatListN : public FormatList
TINYFORMAT_FOREACH_ARGNUM(TINYFORMAT_MAKE_FORMATLIST_CONSTRUCTOR) TINYFORMAT_FOREACH_ARGNUM(TINYFORMAT_MAKE_FORMATLIST_CONSTRUCTOR)
# undef TINYFORMAT_MAKE_FORMATLIST_CONSTRUCTOR # undef TINYFORMAT_MAKE_FORMATLIST_CONSTRUCTOR
#endif #endif
FormatListN(const FormatListN& other)
: FormatList(&m_formatterStore[0], N)
{ std::copy(&other.m_formatterStore[0], &other.m_formatterStore[N],
&m_formatterStore[0]); }
private: private:
#ifdef TINYFORMAT_USE_VARIADIC_TEMPLATES
std::array<FormatArg, N> m_formatterStore;
#else // C++98 version
FormatArg m_formatterStore[N]; FormatArg m_formatterStore[N];
#endif
}; };
// Special 0-arg version - MSVC says zero-sized C array in struct is nonstandard // Special 0-arg version - MSVC says zero-sized C array in struct is nonstandard
template<> class FormatListN<0> : public FormatList template<> class FormatListN<0> : public FormatList
{ {
public: FormatListN() { setFormatters(0, 0); } public: FormatListN() : FormatList(0, 0) {}
}; };
} // namespace detail } // namespace detail
@ -951,7 +1061,7 @@ TINYFORMAT_FOREACH_ARGNUM(TINYFORMAT_MAKE_MAKEFORMATLIST)
/// list of format arguments is held in a single function argument. /// list of format arguments is held in a single function argument.
inline void vformat(std::ostream& out, const char* fmt, FormatListRef list) inline void vformat(std::ostream& out, const char* fmt, FormatListRef list)
{ {
detail::formatImpl(out, fmt, list.m_formatters, list.m_N); detail::formatImpl(out, fmt, list.m_args, list.m_N);
} }

2
source/extern/xxh3.h vendored
View File

@ -1,7 +1,7 @@
/* /*
* xxHash - Extremely Fast Hash algorithm * xxHash - Extremely Fast Hash algorithm
* Development source file for `xxh3` * Development source file for `xxh3`
* Copyright (C) 2019-2020 Yann Collet * Copyright (C) 2019-2021 Yann Collet
* *
* BSD 2-Clause License (https://www.opensource.org/licenses/bsd-license.php) * BSD 2-Clause License (https://www.opensource.org/licenses/bsd-license.php)
* *

135
source/extern/xxh_x86dispatch.c vendored
View File

@ -1,6 +1,6 @@
/* /*
* xxHash - Extremely Fast Hash algorithm * xxHash - Extremely Fast Hash algorithm
* Copyright (C) 2020 Yann Collet * Copyright (C) 2020-2021 Yann Collet
* *
* BSD 2-Clause License (https://www.opensource.org/licenses/bsd-license.php) * BSD 2-Clause License (https://www.opensource.org/licenses/bsd-license.php)
* *
@ -36,7 +36,7 @@
/*! /*!
* @file xxh_x86dispatch.c * @file xxh_x86dispatch.c
* *
* Automatic dispatcher code for the @ref xxh3_family on x86-based targets. * Automatic dispatcher code for the @ref XXH3_family on x86-based targets.
* *
* Optional add-on. * Optional add-on.
* *
@ -60,29 +60,28 @@ extern "C" {
* @def XXH_X86DISPATCH_ALLOW_AVX * @def XXH_X86DISPATCH_ALLOW_AVX
* @brief Disables the AVX sanity check. * @brief Disables the AVX sanity check.
* *
* Don't compile xxh_x86dispatch.c with options like `-mavx*`, `-march=native`, * xxh_x86dispatch.c is intended to be compiled for the minimum target, and
* or `/arch:AVX*`. It is intended to be compiled for the minimum target, and
* it selectively enables SSE2, AVX2, and AVX512 when it is needed. * it selectively enables SSE2, AVX2, and AVX512 when it is needed.
* *
* Using this option _globally_ allows this feature, and therefore makes it * Compiling with options like `-mavx*`, `-march=native`, or `/arch:AVX*`
* _globally_ will always enable this feature, and therefore makes it
* undefined behavior to execute on any CPU without said feature. * undefined behavior to execute on any CPU without said feature.
* *
* Even if the source code isn't directly using AVX intrinsics in a function, * Even if the source code isn't directly using AVX intrinsics in a function,
* the compiler can still generate AVX code from autovectorization and by * the compiler can still generate AVX code from autovectorization and by
* "upgrading" SSE2 intrinsics to use the VEX prefixes (a.k.a. AVX128). * "upgrading" SSE2 intrinsics to use the VEX prefixes (a.k.a. AVX128).
* *
* Use the same flags that you use to compile the rest of the program; this * Define XXH_X86DISPATCH_ALLOW_AVX to ignore this check,
* file will safely generate SSE2, AVX2, and AVX512 without these flags. * thus accepting that the produced binary will not work correctly
* * on any CPU with less features than the ones stated at compilation time.
* Define XXH_X86DISPATCH_ALLOW_AVX to ignore this check, and feel free to open
* an issue if there is a target in the future where AVX is a default feature.
*/ */
#ifdef XXH_DOXYGEN #ifdef XXH_DOXYGEN
# define XXH_X86DISPATCH_ALLOW_AVX # define XXH_X86DISPATCH_ALLOW_AVX
#endif #endif
#if defined(__AVX__) && !defined(XXH_X86DISPATCH_ALLOW_AVX) #if defined(__AVX__) && !defined(XXH_X86DISPATCH_ALLOW_AVX)
# error "Do not compile xxh_x86dispatch.c with AVX enabled! See the comment above." # error "Error: if xxh_x86dispatch.c is compiled with AVX enabled, the resulting binary will crash on sse2-only cpus !! " \
"If you nonetheless want to do that, please enable the XXH_X86DISPATCH_ALLOW_AVX build variable"
#endif #endif
#ifdef __has_include #ifdef __has_include
@ -207,6 +206,23 @@ extern "C" {
#define XXH_X86DISPATCH #define XXH_X86DISPATCH
#include "xxhash.h" #include "xxhash.h"
#ifndef XXH_HAS_ATTRIBUTE
# ifdef __has_attribute
# define XXH_HAS_ATTRIBUTE(...) __has_attribute(__VA_ARGS__)
# else
# define XXH_HAS_ATTRIBUTE(...) 0
# endif
#endif
#if XXH_HAS_ATTRIBUTE(constructor)
# define XXH_CONSTRUCTOR __attribute__((constructor))
# define XXH_DISPATCH_MAYBE_NULL 0
#else
# define XXH_CONSTRUCTOR
# define XXH_DISPATCH_MAYBE_NULL 1
#endif
/* /*
* Support both AT&T and Intel dialects * Support both AT&T and Intel dialects
* *
@ -316,7 +332,7 @@ static xxh_u64 XXH_xgetbv(void)
* *
* Runs various CPUID/XGETBV tests to try and determine the best implementation. * Runs various CPUID/XGETBV tests to try and determine the best implementation.
* *
* @ret The best @ref XXH_VECTOR implementation. * @return The best @ref XXH_VECTOR implementation.
* @see XXH_VECTOR_TYPES * @see XXH_VECTOR_TYPES
*/ */
static int XXH_featureTest(void) static int XXH_featureTest(void)
@ -455,22 +471,23 @@ static int XXH_featureTest(void)
/* === XXH3, default variants === */ \ /* === XXH3, default variants === */ \
\ \
XXH_NO_INLINE target XXH64_hash_t \ XXH_NO_INLINE target XXH64_hash_t \
XXHL64_default_##suffix(const void* XXH_RESTRICT input, size_t len) \ XXHL64_default_##suffix(XXH_NOESCAPE const void* XXH_RESTRICT input, \
size_t len) \
{ \ { \
return XXH3_hashLong_64b_internal( \ return XXH3_hashLong_64b_internal( \
input, len, XXH3_kSecret, sizeof(XXH3_kSecret), \ input, len, XXH3_kSecret, sizeof(XXH3_kSecret), \
XXH3_accumulate_512_##suffix, XXH3_scrambleAcc_##suffix \ XXH3_accumulate_##suffix, XXH3_scrambleAcc_##suffix \
); \ ); \
} \ } \
\ \
/* === XXH3, Seeded variants === */ \ /* === XXH3, Seeded variants === */ \
\ \
XXH_NO_INLINE target XXH64_hash_t \ XXH_NO_INLINE target XXH64_hash_t \
XXHL64_seed_##suffix(const void* XXH_RESTRICT input, size_t len, \ XXHL64_seed_##suffix(XXH_NOESCAPE const void* XXH_RESTRICT input, size_t len, \
XXH64_hash_t seed) \ XXH64_hash_t seed) \
{ \ { \
return XXH3_hashLong_64b_withSeed_internal( \ return XXH3_hashLong_64b_withSeed_internal( \
input, len, seed, XXH3_accumulate_512_##suffix, \ input, len, seed, XXH3_accumulate_##suffix, \
XXH3_scrambleAcc_##suffix, XXH3_initCustomSecret_##suffix \ XXH3_scrambleAcc_##suffix, XXH3_initCustomSecret_##suffix \
); \ ); \
} \ } \
@ -478,54 +495,59 @@ XXHL64_seed_##suffix(const void* XXH_RESTRICT input, size_t len, \
/* === XXH3, Secret variants === */ \ /* === XXH3, Secret variants === */ \
\ \
XXH_NO_INLINE target XXH64_hash_t \ XXH_NO_INLINE target XXH64_hash_t \
XXHL64_secret_##suffix(const void* XXH_RESTRICT input, size_t len, \ XXHL64_secret_##suffix(XXH_NOESCAPE const void* XXH_RESTRICT input, \
const void* secret, size_t secretLen) \ size_t len, XXH_NOESCAPE const void* secret, \
size_t secretLen) \
{ \ { \
return XXH3_hashLong_64b_internal( \ return XXH3_hashLong_64b_internal( \
input, len, secret, secretLen, \ input, len, secret, secretLen, \
XXH3_accumulate_512_##suffix, XXH3_scrambleAcc_##suffix \ XXH3_accumulate_##suffix, XXH3_scrambleAcc_##suffix \
); \ ); \
} \ } \
\ \
/* === XXH3 update variants === */ \ /* === XXH3 update variants === */ \
\ \
XXH_NO_INLINE target XXH_errorcode \ XXH_NO_INLINE target XXH_errorcode \
XXH3_update_##suffix(XXH3_state_t* state, const void* input, size_t len) \ XXH3_update_##suffix(XXH_NOESCAPE XXH3_state_t* state, \
XXH_NOESCAPE const void* input, size_t len) \
{ \ { \
return XXH3_update(state, (const xxh_u8*)input, len, \ return XXH3_update(state, (const xxh_u8*)input, len, \
XXH3_accumulate_512_##suffix, XXH3_scrambleAcc_##suffix); \ XXH3_accumulate_##suffix, XXH3_scrambleAcc_##suffix); \
} \ } \
\ \
/* === XXH128 default variants === */ \ /* === XXH128 default variants === */ \
\ \
XXH_NO_INLINE target XXH128_hash_t \ XXH_NO_INLINE target XXH128_hash_t \
XXHL128_default_##suffix(const void* XXH_RESTRICT input, size_t len) \ XXHL128_default_##suffix(XXH_NOESCAPE const void* XXH_RESTRICT input, \
size_t len) \
{ \ { \
return XXH3_hashLong_128b_internal( \ return XXH3_hashLong_128b_internal( \
input, len, XXH3_kSecret, sizeof(XXH3_kSecret), \ input, len, XXH3_kSecret, sizeof(XXH3_kSecret), \
XXH3_accumulate_512_##suffix, XXH3_scrambleAcc_##suffix \ XXH3_accumulate_##suffix, XXH3_scrambleAcc_##suffix \
); \ ); \
} \ } \
\ \
/* === XXH128 Secret variants === */ \ /* === XXH128 Secret variants === */ \
\ \
XXH_NO_INLINE target XXH128_hash_t \ XXH_NO_INLINE target XXH128_hash_t \
XXHL128_secret_##suffix(const void* XXH_RESTRICT input, size_t len, \ XXHL128_secret_##suffix(XXH_NOESCAPE const void* XXH_RESTRICT input, \
const void* XXH_RESTRICT secret, size_t secretLen) \ size_t len, \
XXH_NOESCAPE const void* XXH_RESTRICT secret, \
size_t secretLen) \
{ \ { \
return XXH3_hashLong_128b_internal( \ return XXH3_hashLong_128b_internal( \
input, len, (const xxh_u8*)secret, secretLen, \ input, len, (const xxh_u8*)secret, secretLen, \
XXH3_accumulate_512_##suffix, XXH3_scrambleAcc_##suffix); \ XXH3_accumulate_##suffix, XXH3_scrambleAcc_##suffix); \
} \ } \
\ \
/* === XXH128 Seeded variants === */ \ /* === XXH128 Seeded variants === */ \
\ \
XXH_NO_INLINE target XXH128_hash_t \ XXH_NO_INLINE target XXH128_hash_t \
XXHL128_seed_##suffix(const void* XXH_RESTRICT input, size_t len, \ XXHL128_seed_##suffix(XXH_NOESCAPE const void* XXH_RESTRICT input, size_t len,\
XXH64_hash_t seed) \ XXH64_hash_t seed) \
{ \ { \
return XXH3_hashLong_128b_withSeed_internal(input, len, seed, \ return XXH3_hashLong_128b_withSeed_internal(input, len, seed, \
XXH3_accumulate_512_##suffix, XXH3_scrambleAcc_##suffix, \ XXH3_accumulate_##suffix, XXH3_scrambleAcc_##suffix, \
XXH3_initCustomSecret_##suffix); \ XXH3_initCustomSecret_##suffix); \
} }
@ -545,13 +567,13 @@ XXH_DEFINE_DISPATCH_FUNCS(avx512, XXH_TARGET_AVX512)
/* ==== Dispatchers ==== */ /* ==== Dispatchers ==== */
typedef XXH64_hash_t (*XXH3_dispatchx86_hashLong64_default)(const void* XXH_RESTRICT, size_t); typedef XXH64_hash_t (*XXH3_dispatchx86_hashLong64_default)(XXH_NOESCAPE const void* XXH_RESTRICT, size_t);
typedef XXH64_hash_t (*XXH3_dispatchx86_hashLong64_withSeed)(const void* XXH_RESTRICT, size_t, XXH64_hash_t); typedef XXH64_hash_t (*XXH3_dispatchx86_hashLong64_withSeed)(XXH_NOESCAPE const void* XXH_RESTRICT, size_t, XXH64_hash_t);
typedef XXH64_hash_t (*XXH3_dispatchx86_hashLong64_withSecret)(const void* XXH_RESTRICT, size_t, const void* XXH_RESTRICT, size_t); typedef XXH64_hash_t (*XXH3_dispatchx86_hashLong64_withSecret)(XXH_NOESCAPE const void* XXH_RESTRICT, size_t, XXH_NOESCAPE const void* XXH_RESTRICT, size_t);
typedef XXH_errorcode (*XXH3_dispatchx86_update)(XXH3_state_t*, const void*, size_t); typedef XXH_errorcode (*XXH3_dispatchx86_update)(XXH_NOESCAPE XXH3_state_t*, XXH_NOESCAPE const void*, size_t);
typedef struct { typedef struct {
XXH3_dispatchx86_hashLong64_default hashLong64_default; XXH3_dispatchx86_hashLong64_default hashLong64_default;
@ -593,11 +615,11 @@ static const XXH_dispatchFunctions_s XXH_kDispatch[XXH_NB_DISPATCHES] = {
static XXH_dispatchFunctions_s XXH_g_dispatch = { NULL, NULL, NULL, NULL }; static XXH_dispatchFunctions_s XXH_g_dispatch = { NULL, NULL, NULL, NULL };
typedef XXH128_hash_t (*XXH3_dispatchx86_hashLong128_default)(const void* XXH_RESTRICT, size_t); typedef XXH128_hash_t (*XXH3_dispatchx86_hashLong128_default)(XXH_NOESCAPE const void* XXH_RESTRICT, size_t);
typedef XXH128_hash_t (*XXH3_dispatchx86_hashLong128_withSeed)(const void* XXH_RESTRICT, size_t, XXH64_hash_t); typedef XXH128_hash_t (*XXH3_dispatchx86_hashLong128_withSeed)(XXH_NOESCAPE const void* XXH_RESTRICT, size_t, XXH64_hash_t);
typedef XXH128_hash_t (*XXH3_dispatchx86_hashLong128_withSecret)(const void* XXH_RESTRICT, size_t, const void* XXH_RESTRICT, size_t); typedef XXH128_hash_t (*XXH3_dispatchx86_hashLong128_withSecret)(XXH_NOESCAPE const void* XXH_RESTRICT, size_t, const void* XXH_RESTRICT, size_t);
typedef struct { typedef struct {
XXH3_dispatchx86_hashLong128_default hashLong128_default; XXH3_dispatchx86_hashLong128_default hashLong128_default;
@ -642,7 +664,7 @@ static XXH_dispatch128Functions_s XXH_g_dispatch128 = { NULL, NULL, NULL, NULL }
* @internal * @internal
* @brief Runs a CPUID check and sets the correct dispatch tables. * @brief Runs a CPUID check and sets the correct dispatch tables.
*/ */
static void XXH_setDispatch(void) static XXH_CONSTRUCTOR void XXH_setDispatch(void)
{ {
int vecID = XXH_featureTest(); int vecID = XXH_featureTest();
XXH_STATIC_ASSERT(XXH_AVX512 == XXH_NB_DISPATCHES-1); XXH_STATIC_ASSERT(XXH_AVX512 == XXH_NB_DISPATCHES-1);
@ -668,11 +690,12 @@ XXH3_hashLong_64b_defaultSecret_selection(const void* input, size_t len,
XXH64_hash_t seed64, const xxh_u8* secret, size_t secretLen) XXH64_hash_t seed64, const xxh_u8* secret, size_t secretLen)
{ {
(void)seed64; (void)secret; (void)secretLen; (void)seed64; (void)secret; (void)secretLen;
if (XXH_g_dispatch.hashLong64_default == NULL) XXH_setDispatch(); if (XXH_DISPATCH_MAYBE_NULL && XXH_g_dispatch.hashLong64_default == NULL)
XXH_setDispatch();
return XXH_g_dispatch.hashLong64_default(input, len); return XXH_g_dispatch.hashLong64_default(input, len);
} }
XXH64_hash_t XXH3_64bits_dispatch(const void* input, size_t len) XXH64_hash_t XXH3_64bits_dispatch(XXH_NOESCAPE const void* input, size_t len)
{ {
return XXH3_64bits_internal(input, len, 0, XXH3_kSecret, sizeof(XXH3_kSecret), XXH3_hashLong_64b_defaultSecret_selection); return XXH3_64bits_internal(input, len, 0, XXH3_kSecret, sizeof(XXH3_kSecret), XXH3_hashLong_64b_defaultSecret_selection);
} }
@ -682,11 +705,12 @@ XXH3_hashLong_64b_withSeed_selection(const void* input, size_t len,
XXH64_hash_t seed64, const xxh_u8* secret, size_t secretLen) XXH64_hash_t seed64, const xxh_u8* secret, size_t secretLen)
{ {
(void)secret; (void)secretLen; (void)secret; (void)secretLen;
if (XXH_g_dispatch.hashLong64_seed == NULL) XXH_setDispatch(); if (XXH_DISPATCH_MAYBE_NULL && XXH_g_dispatch.hashLong64_seed == NULL)
XXH_setDispatch();
return XXH_g_dispatch.hashLong64_seed(input, len, seed64); return XXH_g_dispatch.hashLong64_seed(input, len, seed64);
} }
XXH64_hash_t XXH3_64bits_withSeed_dispatch(const void* input, size_t len, XXH64_hash_t seed) XXH64_hash_t XXH3_64bits_withSeed_dispatch(XXH_NOESCAPE const void* input, size_t len, XXH64_hash_t seed)
{ {
return XXH3_64bits_internal(input, len, seed, XXH3_kSecret, sizeof(XXH3_kSecret), XXH3_hashLong_64b_withSeed_selection); return XXH3_64bits_internal(input, len, seed, XXH3_kSecret, sizeof(XXH3_kSecret), XXH3_hashLong_64b_withSeed_selection);
} }
@ -696,19 +720,22 @@ XXH3_hashLong_64b_withSecret_selection(const void* input, size_t len,
XXH64_hash_t seed64, const xxh_u8* secret, size_t secretLen) XXH64_hash_t seed64, const xxh_u8* secret, size_t secretLen)
{ {
(void)seed64; (void)seed64;
if (XXH_g_dispatch.hashLong64_secret == NULL) XXH_setDispatch(); if (XXH_DISPATCH_MAYBE_NULL && XXH_g_dispatch.hashLong64_secret == NULL)
XXH_setDispatch();
return XXH_g_dispatch.hashLong64_secret(input, len, secret, secretLen); return XXH_g_dispatch.hashLong64_secret(input, len, secret, secretLen);
} }
XXH64_hash_t XXH3_64bits_withSecret_dispatch(const void* input, size_t len, const void* secret, size_t secretLen) XXH64_hash_t XXH3_64bits_withSecret_dispatch(XXH_NOESCAPE const void* input, size_t len, XXH_NOESCAPE const void* secret, size_t secretLen)
{ {
return XXH3_64bits_internal(input, len, 0, secret, secretLen, XXH3_hashLong_64b_withSecret_selection); return XXH3_64bits_internal(input, len, 0, secret, secretLen, XXH3_hashLong_64b_withSecret_selection);
} }
XXH_errorcode XXH_errorcode
XXH3_64bits_update_dispatch(XXH3_state_t* state, const void* input, size_t len) XXH3_64bits_update_dispatch(XXH_NOESCAPE XXH3_state_t* state, XXH_NOESCAPE const void* input, size_t len)
{ {
if (XXH_g_dispatch.update == NULL) XXH_setDispatch(); if (XXH_DISPATCH_MAYBE_NULL && XXH_g_dispatch.update == NULL)
XXH_setDispatch();
return XXH_g_dispatch.update(state, (const xxh_u8*)input, len); return XXH_g_dispatch.update(state, (const xxh_u8*)input, len);
} }
@ -720,11 +747,12 @@ XXH3_hashLong_128b_defaultSecret_selection(const void* input, size_t len,
XXH64_hash_t seed64, const void* secret, size_t secretLen) XXH64_hash_t seed64, const void* secret, size_t secretLen)
{ {
(void)seed64; (void)secret; (void)secretLen; (void)seed64; (void)secret; (void)secretLen;
if (XXH_g_dispatch128.hashLong128_default == NULL) XXH_setDispatch(); if (XXH_DISPATCH_MAYBE_NULL && XXH_g_dispatch128.hashLong128_default == NULL)
XXH_setDispatch();
return XXH_g_dispatch128.hashLong128_default(input, len); return XXH_g_dispatch128.hashLong128_default(input, len);
} }
XXH128_hash_t XXH3_128bits_dispatch(const void* input, size_t len) XXH128_hash_t XXH3_128bits_dispatch(XXH_NOESCAPE const void* input, size_t len)
{ {
return XXH3_128bits_internal(input, len, 0, XXH3_kSecret, sizeof(XXH3_kSecret), XXH3_hashLong_128b_defaultSecret_selection); return XXH3_128bits_internal(input, len, 0, XXH3_kSecret, sizeof(XXH3_kSecret), XXH3_hashLong_128b_defaultSecret_selection);
} }
@ -734,11 +762,12 @@ XXH3_hashLong_128b_withSeed_selection(const void* input, size_t len,
XXH64_hash_t seed64, const void* secret, size_t secretLen) XXH64_hash_t seed64, const void* secret, size_t secretLen)
{ {
(void)secret; (void)secretLen; (void)secret; (void)secretLen;
if (XXH_g_dispatch128.hashLong128_seed == NULL) XXH_setDispatch(); if (XXH_DISPATCH_MAYBE_NULL && XXH_g_dispatch128.hashLong128_seed == NULL)
XXH_setDispatch();
return XXH_g_dispatch128.hashLong128_seed(input, len, seed64); return XXH_g_dispatch128.hashLong128_seed(input, len, seed64);
} }
XXH128_hash_t XXH3_128bits_withSeed_dispatch(const void* input, size_t len, XXH64_hash_t seed) XXH128_hash_t XXH3_128bits_withSeed_dispatch(XXH_NOESCAPE const void* input, size_t len, XXH64_hash_t seed)
{ {
return XXH3_128bits_internal(input, len, seed, XXH3_kSecret, sizeof(XXH3_kSecret), XXH3_hashLong_128b_withSeed_selection); return XXH3_128bits_internal(input, len, seed, XXH3_kSecret, sizeof(XXH3_kSecret), XXH3_hashLong_128b_withSeed_selection);
} }
@ -748,19 +777,21 @@ XXH3_hashLong_128b_withSecret_selection(const void* input, size_t len,
XXH64_hash_t seed64, const void* secret, size_t secretLen) XXH64_hash_t seed64, const void* secret, size_t secretLen)
{ {
(void)seed64; (void)seed64;
if (XXH_g_dispatch128.hashLong128_secret == NULL) XXH_setDispatch(); if (XXH_DISPATCH_MAYBE_NULL && XXH_g_dispatch128.hashLong128_secret == NULL)
XXH_setDispatch();
return XXH_g_dispatch128.hashLong128_secret(input, len, secret, secretLen); return XXH_g_dispatch128.hashLong128_secret(input, len, secret, secretLen);
} }
XXH128_hash_t XXH3_128bits_withSecret_dispatch(const void* input, size_t len, const void* secret, size_t secretLen) XXH128_hash_t XXH3_128bits_withSecret_dispatch(XXH_NOESCAPE const void* input, size_t len, XXH_NOESCAPE const void* secret, size_t secretLen)
{ {
return XXH3_128bits_internal(input, len, 0, secret, secretLen, XXH3_hashLong_128b_withSecret_selection); return XXH3_128bits_internal(input, len, 0, secret, secretLen, XXH3_hashLong_128b_withSecret_selection);
} }
XXH_errorcode XXH_errorcode
XXH3_128bits_update_dispatch(XXH3_state_t* state, const void* input, size_t len) XXH3_128bits_update_dispatch(XXH_NOESCAPE XXH3_state_t* state, XXH_NOESCAPE const void* input, size_t len)
{ {
if (XXH_g_dispatch128.update == NULL) XXH_setDispatch(); if (XXH_DISPATCH_MAYBE_NULL && XXH_g_dispatch128.update == NULL)
XXH_setDispatch();
return XXH_g_dispatch128.update(state, (const xxh_u8*)input, len); return XXH_g_dispatch128.update(state, (const xxh_u8*)input, len);
} }

19
source/extern/xxh_x86dispatch.h vendored
View File

@ -1,6 +1,6 @@
/* /*
* xxHash - XXH3 Dispatcher for x86-based targets * xxHash - XXH3 Dispatcher for x86-based targets
* Copyright (C) 2020 Yann Collet * Copyright (C) 2020-2021 Yann Collet
* *
* BSD 2-Clause License (https://www.opensource.org/licenses/bsd-license.php) * BSD 2-Clause License (https://www.opensource.org/licenses/bsd-license.php)
* *
@ -41,15 +41,15 @@
extern "C" { extern "C" {
#endif #endif
XXH_PUBLIC_API XXH64_hash_t XXH3_64bits_dispatch(const void* input, size_t len); XXH_PUBLIC_API XXH64_hash_t XXH3_64bits_dispatch(XXH_NOESCAPE const void* input, size_t len);
XXH_PUBLIC_API XXH64_hash_t XXH3_64bits_withSeed_dispatch(const void* input, size_t len, XXH64_hash_t seed); XXH_PUBLIC_API XXH64_hash_t XXH3_64bits_withSeed_dispatch(XXH_NOESCAPE const void* input, size_t len, XXH64_hash_t seed);
XXH_PUBLIC_API XXH64_hash_t XXH3_64bits_withSecret_dispatch(const void* input, size_t len, const void* secret, size_t secretLen); XXH_PUBLIC_API XXH64_hash_t XXH3_64bits_withSecret_dispatch(XXH_NOESCAPE const void* input, size_t len, XXH_NOESCAPE const void* secret, size_t secretLen);
XXH_PUBLIC_API XXH_errorcode XXH3_64bits_update_dispatch(XXH3_state_t* state, const void* input, size_t len); XXH_PUBLIC_API XXH_errorcode XXH3_64bits_update_dispatch(XXH_NOESCAPE XXH3_state_t* state, XXH_NOESCAPE const void* input, size_t len);
XXH_PUBLIC_API XXH128_hash_t XXH3_128bits_dispatch(const void* input, size_t len); XXH_PUBLIC_API XXH128_hash_t XXH3_128bits_dispatch(XXH_NOESCAPE const void* input, size_t len);
XXH_PUBLIC_API XXH128_hash_t XXH3_128bits_withSeed_dispatch(const void* input, size_t len, XXH64_hash_t seed); XXH_PUBLIC_API XXH128_hash_t XXH3_128bits_withSeed_dispatch(XXH_NOESCAPE const void* input, size_t len, XXH64_hash_t seed);
XXH_PUBLIC_API XXH128_hash_t XXH3_128bits_withSecret_dispatch(const void* input, size_t len, const void* secret, size_t secretLen); XXH_PUBLIC_API XXH128_hash_t XXH3_128bits_withSecret_dispatch(XXH_NOESCAPE const void* input, size_t len, XXH_NOESCAPE const void* secret, size_t secretLen);
XXH_PUBLIC_API XXH_errorcode XXH3_128bits_update_dispatch(XXH3_state_t* state, const void* input, size_t len); XXH_PUBLIC_API XXH_errorcode XXH3_128bits_update_dispatch(XXH_NOESCAPE XXH3_state_t* state, XXH_NOESCAPE const void* input, size_t len);
#if defined (__cplusplus) #if defined (__cplusplus)
} }
@ -71,7 +71,6 @@ XXH_PUBLIC_API XXH_errorcode XXH3_128bits_update_dispatch(XXH3_state_t* state, c
# undef XXH128 # undef XXH128
# define XXH128 XXH3_128bits_withSeed_dispatch # define XXH128 XXH3_128bits_withSeed_dispatch
# define XXH3_128bits XXH3_128bits_dispatch
# undef XXH3_128bits # undef XXH3_128bits
# define XXH3_128bits XXH3_128bits_dispatch # define XXH3_128bits XXH3_128bits_dispatch
# undef XXH3_128bits_withSeed # undef XXH3_128bits_withSeed

2
source/extern/xxhash.c vendored
View File

@ -1,6 +1,6 @@
/* /*
* xxHash - Extremely Fast Hash algorithm * xxHash - Extremely Fast Hash algorithm
* Copyright (C) 2012-2020 Yann Collet * Copyright (C) 2012-2021 Yann Collet
* *
* BSD 2-Clause License (https://www.opensource.org/licenses/bsd-license.php) * BSD 2-Clause License (https://www.opensource.org/licenses/bsd-license.php)
* *

2525
source/extern/xxhash.h vendored
View File

File diff suppressed because it is too large Load Diff

2
source/frontend/StarClientCommandProcessor.cpp
View File

@ -332,7 +332,7 @@ String ClientCommandProcessor::giveEssentialItem(StringList const& arguments) {
auto slot = EssentialItemNames.getLeft(arguments.at(1)); auto slot = EssentialItemNames.getLeft(arguments.at(1));
m_universeClient->mainPlayer()->inventory()->setEssentialItem(slot, item); m_universeClient->mainPlayer()->inventory()->setEssentialItem(slot, item);
return strf("Put %s in player slot %s", item->name(), arguments.at(1)); return strf("Put %s in player slot %s", item->name(), arguments.at(1));
} catch (MapException e) { } catch (MapException const& e) {
return strf("Invalid essential item slot %s.", arguments.at(1)); return strf("Invalid essential item slot %s.", arguments.at(1));
} }
} }

8
source/game/StarBehaviorState.cpp
View File

@ -209,7 +209,7 @@ NodeStatus BehaviorState::runAction(ActionNode const& node, NodeState& state) {
LuaThread thread = nodeLuaThread(node.name); LuaThread thread = nodeLuaThread(node.name);
try { try {
result = thread.resume<ActionReturn>(parameters, blackboardPtr(), id, m_lastDt).value(ActionReturn(NodeStatus::Invalid, LuaNil)); result = thread.resume<ActionReturn>(parameters, blackboardPtr(), id, m_lastDt).value(ActionReturn(NodeStatus::Invalid, LuaNil));
} catch (LuaException e) { } catch (LuaException const& e) {
throw StarException(strf("Lua Exception caught running action node %s in behavior %s: %s", node.name, m_tree->name, outputException(e, false))); throw StarException(strf("Lua Exception caught running action node %s in behavior %s: %s", node.name, m_tree->name, outputException(e, false)));
} }
@ -221,7 +221,7 @@ NodeStatus BehaviorState::runAction(ActionNode const& node, NodeState& state) {
try { try {
result = thread.resume<ActionReturn>(m_lastDt).value(ActionReturn(NodeStatus::Invalid, LuaNil)); result = thread.resume<ActionReturn>(m_lastDt).value(ActionReturn(NodeStatus::Invalid, LuaNil));
} catch (LuaException e) { } catch (LuaException const& e) {
throw StarException(strf("Lua Exception caught resuming action node %s in behavior %s: %s", node.name, m_tree->name, outputException(e, false))); throw StarException(strf("Lua Exception caught resuming action node %s in behavior %s: %s", node.name, m_tree->name, outputException(e, false)));
} }
@ -245,7 +245,7 @@ NodeStatus BehaviorState::runDecorator(DecoratorNode const& node, NodeState& sta
LuaThread thread = nodeLuaThread(node.name); LuaThread thread = nodeLuaThread(node.name);
try { try {
status = thread.resume<NodeStatus>(parameters, blackboardPtr(), id).value(NodeStatus::Invalid); status = thread.resume<NodeStatus>(parameters, blackboardPtr(), id).value(NodeStatus::Invalid);
} catch (LuaException e) { } catch (LuaException const& e) {
throw StarException(strf("Lua Exception caught initializing decorator node %s in behavior %s: %s", node.name, m_tree->name, outputException(e, false))); throw StarException(strf("Lua Exception caught initializing decorator node %s in behavior %s: %s", node.name, m_tree->name, outputException(e, false)));
} }
if (status == NodeStatus::Success || status == NodeStatus::Failure) if (status == NodeStatus::Success || status == NodeStatus::Failure)
@ -261,7 +261,7 @@ NodeStatus BehaviorState::runDecorator(DecoratorNode const& node, NodeState& sta
if (childStatus == NodeStatus::Success || childStatus == NodeStatus::Failure) { if (childStatus == NodeStatus::Success || childStatus == NodeStatus::Failure) {
try { try {
status = decorator.thread.resume<NodeStatus>(childStatus).value(NodeStatus::Invalid); status = decorator.thread.resume<NodeStatus>(childStatus).value(NodeStatus::Invalid);
} catch (LuaException e) { } catch (LuaException const& e) {
throw StarException(strf("Lua Exception caught resuming decorator node %s in behavior %s: %s", node.name, m_tree->name, outputException(e, false))); throw StarException(strf("Lua Exception caught resuming decorator node %s in behavior %s: %s", node.name, m_tree->name, outputException(e, false)));
} }
} else { } else {

6
source/game/StarCollectionDatabase.cpp
View File

@ -58,7 +58,7 @@ List<Collection> CollectionDatabase::collections() const {
Collection CollectionDatabase::collection(String const& collectionName) const { Collection CollectionDatabase::collection(String const& collectionName) const {
try { try {
return m_collections.get(collectionName); return m_collections.get(collectionName);
} catch (MapException e) { } catch (MapException const& e) {
throw CollectionDatabaseException(strf("Collection '%s' not found", collectionName), e); throw CollectionDatabaseException(strf("Collection '%s' not found", collectionName), e);
} }
} }
@ -66,7 +66,7 @@ Collection CollectionDatabase::collection(String const& collectionName) const {
List<Collectable> CollectionDatabase::collectables(String const& collectionName) const { List<Collectable> CollectionDatabase::collectables(String const& collectionName) const {
try { try {
return m_collectables.get(collectionName).values(); return m_collectables.get(collectionName).values();
} catch (MapException e) { } catch (MapException const& e) {
throw CollectionDatabaseException(strf("Collection '%s' not found", collectionName), e); throw CollectionDatabaseException(strf("Collection '%s' not found", collectionName), e);
} }
} }
@ -74,7 +74,7 @@ List<Collectable> CollectionDatabase::collectables(String const& collectionName)
Collectable CollectionDatabase::collectable(String const& collectionName, String const& collectableName) const { Collectable CollectionDatabase::collectable(String const& collectionName, String const& collectableName) const {
try { try {
return m_collectables.get(collectionName).get(collectableName); return m_collectables.get(collectionName).get(collectableName);
} catch (MapException e) { } catch (MapException const& e) {
throw CollectionDatabaseException(strf("Collectable '%s' not found in collection '%s'", collectableName, collectionName), e); throw CollectionDatabaseException(strf("Collectable '%s' not found in collection '%s'", collectableName, collectionName), e);
} }
} }

6
source/game/StarDrawable.cpp
View File

@ -154,7 +154,7 @@ Json Drawable::toJson() const {
json.set("color", jsonFromColor(color)); json.set("color", jsonFromColor(color));
json.set("fullbright", fullbright); json.set("fullbright", fullbright);
return move(json); return json;
} }
void Drawable::translate(Vec2F const& translation) { void Drawable::translate(Vec2F const& translation) {
@ -270,13 +270,13 @@ DataStream& operator<<(DataStream& ds, Drawable::PolyPart const& poly) {
// I need to find out if this is for network serialization or not eventually // I need to find out if this is for network serialization or not eventually
DataStream& operator>>(DataStream& ds, Drawable::ImagePart& image) { DataStream& operator>>(DataStream& ds, Drawable::ImagePart& image) {
ds >> AssetPath::join(image.image); ds >> image.image;
ds >> image.transformation; ds >> image.transformation;
return ds; return ds;
} }
DataStream& operator<<(DataStream& ds, Drawable::ImagePart const& image) { DataStream& operator<<(DataStream& ds, Drawable::ImagePart const& image) {
ds << AssetPath::join(image.image); ds << image.image;
ds << image.transformation; ds << image.transformation;
return ds; return ds;
} }

151
source/game/StarNetPackets.cpp
View File

@ -77,87 +77,82 @@ EnumMap<PacketType> const PacketTypeNames{
{PacketType::SystemObjectSpawn, "SystemObjectSpawn"} {PacketType::SystemObjectSpawn, "SystemObjectSpawn"}
}; };
typedef decltype(&make_shared<Packet>) PacketMakePtr;
Array<PacketMakePtr, 69> const PacketTypeMakers = {
(PacketMakePtr)&make_shared<ProtocolRequestPacket>,
(PacketMakePtr)&make_shared<ProtocolResponsePacket>,
(PacketMakePtr)&make_shared<ServerDisconnectPacket>,
(PacketMakePtr)&make_shared<ConnectSuccessPacket>,
(PacketMakePtr)&make_shared<ConnectFailurePacket>,
(PacketMakePtr)&make_shared<HandshakeChallengePacket>,
(PacketMakePtr)&make_shared<ChatReceivePacket>,
(PacketMakePtr)&make_shared<UniverseTimeUpdatePacket>,
(PacketMakePtr)&make_shared<CelestialResponsePacket>,
(PacketMakePtr)&make_shared<PlayerWarpResultPacket>,
(PacketMakePtr)&make_shared<PlanetTypeUpdatePacket>,
(PacketMakePtr)&make_shared<PausePacket>,
(PacketMakePtr)&make_shared<ServerInfoPacket>,
(PacketMakePtr)&make_shared<ClientConnectPacket>,
(PacketMakePtr)&make_shared<ClientDisconnectRequestPacket>,
(PacketMakePtr)&make_shared<HandshakeResponsePacket>,
(PacketMakePtr)&make_shared<PlayerWarpPacket>,
(PacketMakePtr)&make_shared<FlyShipPacket>,
(PacketMakePtr)&make_shared<ChatSendPacket>,
(PacketMakePtr)&make_shared<CelestialRequestPacket>,
(PacketMakePtr)&make_shared<ClientContextUpdatePacket>,
(PacketMakePtr)&make_shared<WorldStartPacket>,
(PacketMakePtr)&make_shared<WorldStopPacket>,
(PacketMakePtr)&make_shared<WorldLayoutUpdatePacket>,
(PacketMakePtr)&make_shared<WorldParametersUpdatePacket>,
(PacketMakePtr)&make_shared<CentralStructureUpdatePacket>,
(PacketMakePtr)&make_shared<TileArrayUpdatePacket>,
(PacketMakePtr)&make_shared<TileUpdatePacket>,
(PacketMakePtr)&make_shared<TileLiquidUpdatePacket>,
(PacketMakePtr)&make_shared<TileDamageUpdatePacket>,
(PacketMakePtr)&make_shared<TileModificationFailurePacket>,
(PacketMakePtr)&make_shared<GiveItemPacket>,
(PacketMakePtr)&make_shared<EnvironmentUpdatePacket>,
(PacketMakePtr)&make_shared<UpdateTileProtectionPacket>,
(PacketMakePtr)&make_shared<SetDungeonGravityPacket>,
(PacketMakePtr)&make_shared<SetDungeonBreathablePacket>,
(PacketMakePtr)&make_shared<SetPlayerStartPacket>,
(PacketMakePtr)&make_shared<FindUniqueEntityResponsePacket>,
(PacketMakePtr)&make_shared<PongPacket>,
(PacketMakePtr)&make_shared<ModifyTileListPacket>,
(PacketMakePtr)&make_shared<DamageTileGroupPacket>,
(PacketMakePtr)&make_shared<CollectLiquidPacket>,
(PacketMakePtr)&make_shared<RequestDropPacket>,
(PacketMakePtr)&make_shared<SpawnEntityPacket>,
(PacketMakePtr)&make_shared<ConnectWirePacket>,
(PacketMakePtr)&make_shared<DisconnectAllWiresPacket>,
(PacketMakePtr)&make_shared<WorldClientStateUpdatePacket>,
(PacketMakePtr)&make_shared<FindUniqueEntityPacket>,
(PacketMakePtr)&make_shared<WorldStartAcknowledgePacket>,
(PacketMakePtr)&make_shared<PingPacket>,
(PacketMakePtr)&make_shared<EntityCreatePacket>,
(PacketMakePtr)&make_shared<EntityUpdateSetPacket>,
(PacketMakePtr)&make_shared<EntityDestroyPacket>,
(PacketMakePtr)&make_shared<EntityInteractPacket>,
(PacketMakePtr)&make_shared<EntityInteractResultPacket>,
(PacketMakePtr)&make_shared<HitRequestPacket>,
(PacketMakePtr)&make_shared<DamageRequestPacket>,
(PacketMakePtr)&make_shared<DamageNotificationPacket>,
(PacketMakePtr)&make_shared<EntityMessagePacket>,
(PacketMakePtr)&make_shared<EntityMessageResponsePacket>,
(PacketMakePtr)&make_shared<UpdateWorldPropertiesPacket>,
(PacketMakePtr)&make_shared<StepUpdatePacket>,
(PacketMakePtr)&make_shared<SystemWorldStartPacket>,
(PacketMakePtr)&make_shared<SystemWorldUpdatePacket>,
(PacketMakePtr)&make_shared<SystemObjectCreatePacket>,
(PacketMakePtr)&make_shared<SystemObjectDestroyPacket>,
(PacketMakePtr)&make_shared<SystemShipCreatePacket>,
(PacketMakePtr)&make_shared<SystemShipDestroyPacket>,
(PacketMakePtr)&make_shared<SystemObjectSpawnPacket>
};
Packet::~Packet() {} Packet::~Packet() {}
PacketPtr createPacket(PacketType type) { PacketPtr createPacket(PacketType type) {
unsigned i = (unsigned)type; switch (type) {
if (i < PacketTypeMakers.size()) case PacketType::ProtocolRequest: return make_shared<ProtocolRequestPacket>();
return PacketTypeMakers[i](); case PacketType::ProtocolResponse: return make_shared<ProtocolResponsePacket>();
else case PacketType::ServerDisconnect: return make_shared<ServerDisconnectPacket>();
throw StarPacketException(strf("Unrecognized packet type %s", i)); case PacketType::ConnectSuccess: return make_shared<ConnectSuccessPacket>();
case PacketType::ConnectFailure: return make_shared<ConnectFailurePacket>();
case PacketType::HandshakeChallenge: return make_shared<HandshakeChallengePacket>();
case PacketType::ChatReceive: return make_shared<ChatReceivePacket>();
case PacketType::UniverseTimeUpdate: return make_shared<UniverseTimeUpdatePacket>();
case PacketType::CelestialResponse: return make_shared<CelestialResponsePacket>();
case PacketType::PlayerWarpResult: return make_shared<PlayerWarpResultPacket>();
case PacketType::PlanetTypeUpdate: return make_shared<PlanetTypeUpdatePacket>();
case PacketType::Pause: return make_shared<PausePacket>();
case PacketType::ServerInfo: return make_shared<ServerInfoPacket>();
case PacketType::ClientConnect: return make_shared<ClientConnectPacket>();
case PacketType::ClientDisconnectRequest: return make_shared<ClientDisconnectRequestPacket>();
case PacketType::HandshakeResponse: return make_shared<HandshakeResponsePacket>();
case PacketType::PlayerWarp: return make_shared<PlayerWarpPacket>();
case PacketType::FlyShip: return make_shared<FlyShipPacket>();
case PacketType::ChatSend: return make_shared<ChatSendPacket>();
case PacketType::CelestialRequest: return make_shared<CelestialRequestPacket>();
case PacketType::ClientContextUpdate: return make_shared<ClientContextUpdatePacket>();
case PacketType::WorldStart: return make_shared<WorldStartPacket>();
case PacketType::WorldStop: return make_shared<WorldStopPacket>();
case PacketType::WorldLayoutUpdate: return make_shared<WorldLayoutUpdatePacket>();
case PacketType::WorldParametersUpdate: return make_shared<WorldParametersUpdatePacket>();
case PacketType::CentralStructureUpdate: return make_shared<CentralStructureUpdatePacket>();
case PacketType::TileArrayUpdate: return make_shared<TileArrayUpdatePacket>();
case PacketType::TileUpdate: return make_shared<TileUpdatePacket>();
case PacketType::TileLiquidUpdate: return make_shared<TileLiquidUpdatePacket>();
case PacketType::TileDamageUpdate: return make_shared<TileDamageUpdatePacket>();
case PacketType::TileModificationFailure: return make_shared<TileModificationFailurePacket>();
case PacketType::GiveItem: return make_shared<GiveItemPacket>();
case PacketType::EnvironmentUpdate: return make_shared<EnvironmentUpdatePacket>();
case PacketType::UpdateTileProtection: return make_shared<UpdateTileProtectionPacket>();
case PacketType::SetDungeonGravity: return make_shared<SetDungeonGravityPacket>();
case PacketType::SetDungeonBreathable: return make_shared<SetDungeonBreathablePacket>();
case PacketType::SetPlayerStart: return make_shared<SetPlayerStartPacket>();
case PacketType::FindUniqueEntityResponse: return make_shared<FindUniqueEntityResponsePacket>();
case PacketType::Pong: return make_shared<PongPacket>();
case PacketType::ModifyTileList: return make_shared<ModifyTileListPacket>();
case PacketType::DamageTileGroup: return make_shared<DamageTileGroupPacket>();
case PacketType::CollectLiquid: return make_shared<CollectLiquidPacket>();
case PacketType::RequestDrop: return make_shared<RequestDropPacket>();
case PacketType::SpawnEntity: return make_shared<SpawnEntityPacket>();
case PacketType::ConnectWire: return make_shared<ConnectWirePacket>();
case PacketType::DisconnectAllWires: return make_shared<DisconnectAllWiresPacket>();
case PacketType::WorldClientStateUpdate: return make_shared<WorldClientStateUpdatePacket>();
case PacketType::FindUniqueEntity: return make_shared<FindUniqueEntityPacket>();
case PacketType::WorldStartAcknowledge: return make_shared<WorldStartAcknowledgePacket>();
case PacketType::Ping: return make_shared<PingPacket>();
case PacketType::EntityCreate: return make_shared<EntityCreatePacket>();
case PacketType::EntityUpdateSet: return make_shared<EntityUpdateSetPacket>();
case PacketType::EntityDestroy: return make_shared<EntityDestroyPacket>();
case PacketType::EntityInteract: return make_shared<EntityInteractPacket>();
case PacketType::EntityInteractResult: return make_shared<EntityInteractResultPacket>();
case PacketType::HitRequest: return make_shared<HitRequestPacket>();
case PacketType::DamageRequest: return make_shared<DamageRequestPacket>();
case PacketType::DamageNotification: return make_shared<DamageNotificationPacket>();
case PacketType::EntityMessage: return make_shared<EntityMessagePacket>();
case PacketType::EntityMessageResponse: return make_shared<EntityMessageResponsePacket>();
case PacketType::UpdateWorldProperties: return make_shared<UpdateWorldPropertiesPacket>();
case PacketType::StepUpdate: return make_shared<StepUpdatePacket>();
case PacketType::SystemWorldStart: return make_shared<SystemWorldStartPacket>();
case PacketType::SystemWorldUpdate: return make_shared<SystemWorldUpdatePacket>();
case PacketType::SystemObjectCreate: return make_shared<SystemObjectCreatePacket>();
case PacketType::SystemObjectDestroy: return make_shared<SystemObjectDestroyPacket>();
case PacketType::SystemShipCreate: return make_shared<SystemShipCreatePacket>();
case PacketType::SystemShipDestroy: return make_shared<SystemShipDestroyPacket>();
case PacketType::SystemObjectSpawn: return make_shared<SystemObjectSpawnPacket>();
default:
throw StarPacketException(strf("Unrecognized packet type %s", (unsigned int)type));
}
} }
ProtocolRequestPacket::ProtocolRequestPacket() ProtocolRequestPacket::ProtocolRequestPacket()

2
source/game/StarNpcDatabase.cpp
View File

@ -383,7 +383,7 @@ Json NpcDatabase::mergeConfigValues(Json const& base, Json const& merger) const
map[entry.first] = mergeConfigValues(map[entry.first], entry.second); map[entry.first] = mergeConfigValues(map[entry.first], entry.second);
} }
} }
return std::move(map); return map;
} else if (merger.isNull()) { } else if (merger.isNull()) {
return base; return base;
} else { } else {

6
source/game/StarRoot.cpp
View File

@ -550,7 +550,7 @@ StringList Root::scanForAssetSources(StringList const& directories) {
String path; String path;
Maybe<String> name; Maybe<String> name;
float priority; float priority;
StringList requires; StringList requires_;
StringList includes; StringList includes;
}; };
List<shared_ptr<AssetSource>> assetSources; List<shared_ptr<AssetSource>> assetSources;
@ -589,7 +589,7 @@ StringList Root::scanForAssetSources(StringList const& directories) {
assetSource->path = fileName; assetSource->path = fileName;
assetSource->name = metadata.maybe("name").apply(mem_fn(&Json::toString)); assetSource->name = metadata.maybe("name").apply(mem_fn(&Json::toString));
assetSource->priority = metadata.value("priority", 0.0f).toFloat(); assetSource->priority = metadata.value("priority", 0.0f).toFloat();
assetSource->requires = jsonToStringList(metadata.value("requires", JsonArray{})); assetSource->requires_ = jsonToStringList(metadata.value("requires", JsonArray{}));
assetSource->includes = jsonToStringList(metadata.value("includes", JsonArray{})); assetSource->includes = jsonToStringList(metadata.value("includes", JsonArray{}));
if (assetSource->name) { if (assetSource->name) {
@ -640,7 +640,7 @@ StringList Root::scanForAssetSources(StringList const& directories) {
dependencySortVisit(*include); dependencySortVisit(*include);
} }
for (auto const& requirementName : source->requires) { for (auto const& requirementName : source->requires_) {
if (auto requirement = namedSources.ptr(requirementName)) if (auto requirement = namedSources.ptr(requirementName))
dependencySortVisit(*requirement); dependencySortVisit(*requirement);
else else

2
source/game/StarSystemWorld.cpp
View File

@ -138,7 +138,7 @@ List<CelestialCoordinate> SystemWorld::planets() const {
uint64_t SystemWorld::coordinateSeed(CelestialCoordinate const& coordinate, String const& seedMix) const { uint64_t SystemWorld::coordinateSeed(CelestialCoordinate const& coordinate, String const& seedMix) const {
auto satellite = coordinate.isSatelliteBody() ? coordinate.orbitNumber() : 0; auto satellite = coordinate.isSatelliteBody() ? coordinate.orbitNumber() : 0;
auto planet = coordinate.isSatelliteBody() ? coordinate.parent().orbitNumber() : coordinate.isPlanetaryBody() && coordinate.orbitNumber() || 0; auto planet = coordinate.isSatelliteBody() ? coordinate.parent().orbitNumber() : (coordinate.isPlanetaryBody() && coordinate.orbitNumber()) || 0;
return staticRandomU64(coordinate.location()[0], coordinate.location()[1], coordinate.location()[2], planet, satellite, seedMix); return staticRandomU64(coordinate.location()[0], coordinate.location()[1], coordinate.location()[2], planet, satellite, seedMix);
} }

2
source/game/StarToolUser.cpp
View File

@ -191,7 +191,7 @@ List<Drawable> ToolUser::renderObjectPreviews(Vec2F aimPosition, Direction walki
nearWhite.setValue(1 - (1 - nearWhite.value()) / 5); nearWhite.setValue(1 - (1 - nearWhite.value()) / 5);
nearWhite.setSaturation(nearWhite.saturation() / 5); nearWhite.setSaturation(nearWhite.saturation() / 5);
nearWhite.setAlphaF(m_objectPreviewInnerAlpha); nearWhite.setAlphaF(m_objectPreviewInnerAlpha);
ImageOperation op = BorderImageOperation{m_beamGunGlowBorder, nearWhite.toRgba(), favoriteColorTrans, false}; ImageOperation op = BorderImageOperation{m_beamGunGlowBorder, nearWhite.toRgba(), favoriteColorTrans, false, false};
for (Drawable& drawable : drawables) { for (Drawable& drawable : drawables) {
if (drawable.isImage()) if (drawable.isImage())

6
source/game/StarWorldClient.cpp
View File

@ -358,7 +358,7 @@ void WorldClient::render(WorldRenderData& renderData, unsigned bufferTiles) {
const List<Directives>* directives = nullptr; const List<Directives>* directives = nullptr;
if (auto& worldTemplate = m_worldTemplate) { if (auto& worldTemplate = m_worldTemplate) {
if (auto& parameters = worldTemplate->worldParameters()) if (const auto& parameters = worldTemplate->worldParameters())
if (auto& globalDirectives = m_worldTemplate->worldParameters()->globalDirectives) if (auto& globalDirectives = m_worldTemplate->worldParameters()->globalDirectives)
directives = &globalDirectives.get(); directives = &globalDirectives.get();
} }
@ -1266,7 +1266,7 @@ void WorldClient::handleDamageNotifications() {
const List<Directives>* directives = nullptr; const List<Directives>* directives = nullptr;
if (auto& worldTemplate = m_worldTemplate) { if (auto& worldTemplate = m_worldTemplate) {
if (auto& parameters = worldTemplate->worldParameters()) if (const auto& parameters = worldTemplate->worldParameters())
if (auto& globalDirectives = m_worldTemplate->worldParameters()->globalDirectives) if (auto& globalDirectives = m_worldTemplate->worldParameters()->globalDirectives)
directives = &globalDirectives.get(); directives = &globalDirectives.get();
} }
@ -1336,7 +1336,7 @@ void WorldClient::removeEntity(EntityId entityId, bool andDie) {
const List<Directives>* directives = nullptr; const List<Directives>* directives = nullptr;
if (auto& worldTemplate = m_worldTemplate) { if (auto& worldTemplate = m_worldTemplate) {
if (auto& parameters = worldTemplate->worldParameters()) if (const auto& parameters = worldTemplate->worldParameters())
if (auto& globalDirectives = m_worldTemplate->worldParameters()->globalDirectives) if (auto& globalDirectives = m_worldTemplate->worldParameters()->globalDirectives)
directives = &globalDirectives.get(); directives = &globalDirectives.get();
} }

5
source/game/StarWorldParameters.cpp
View File

@ -161,6 +161,11 @@ TerrestrialWorldParameters::TerrestrialWorldParameters(Json const& store) : Visi
coreLayer = loadTerrestrialLayer(store.get("coreLayer")); coreLayer = loadTerrestrialLayer(store.get("coreLayer"));
} }
TerrestrialWorldParameters &TerrestrialWorldParameters::operator=(TerrestrialWorldParameters const& terrestrialWorldParameters) {
*this = terrestrialWorldParameters;
return *this;
}
WorldParametersType TerrestrialWorldParameters::type() const { WorldParametersType TerrestrialWorldParameters::type() const {
return WorldParametersType::TerrestrialWorldParameters; return WorldParametersType::TerrestrialWorldParameters;
} }

2
source/game/StarWorldParameters.hpp
View File

@ -107,6 +107,8 @@ struct TerrestrialWorldParameters : VisitableWorldParameters {
TerrestrialWorldParameters(TerrestrialWorldParameters const& terrestrialWorldParameters); TerrestrialWorldParameters(TerrestrialWorldParameters const& terrestrialWorldParameters);
TerrestrialWorldParameters(Json const& store); TerrestrialWorldParameters(Json const& store);
TerrestrialWorldParameters &operator=(TerrestrialWorldParameters const& terrestrialWorldParameters);
virtual WorldParametersType type() const override; virtual WorldParametersType type() const override;
virtual Json store() const override; virtual Json store() const override;

2
source/game/StarWorldServer.cpp
View File

@ -1747,7 +1747,7 @@ void WorldServer::queueUpdatePackets(ConnectionId clientId) {
auto pair = make_pair(entityId, *version); auto pair = make_pair(entityId, *version);
auto i = m_netStateCache.find(pair); auto i = m_netStateCache.find(pair);
if (i == m_netStateCache.end()) if (i == m_netStateCache.end())
i = m_netStateCache.insert(pair, move(monitoredEntity->writeNetState(*version))).first; i = m_netStateCache.insert(pair, monitoredEntity->writeNetState(*version)).first;
const auto& netState = i->second; const auto& netState = i->second;
if (!netState.first.empty()) if (!netState.first.empty())
updateSetPacket->deltas[entityId] = netState.first; updateSetPacket->deltas[entityId] = netState.first;

4
source/game/items/StarInspectionTool.hpp
View File

@ -19,8 +19,8 @@ public:
struct InspectionResult { struct InspectionResult {
String message; String message;
Maybe<String> objectName; Maybe<String> objectName = {};
Maybe<EntityId> entityId; Maybe<EntityId> entityId = {};
}; };
InspectionTool(Json const& config, String const& directory, Json const& parameters = JsonObject()); InspectionTool(Json const& config, String const& directory, Json const& parameters = JsonObject());

2
source/rendering/StarTextPainter.cpp
View File

@ -88,7 +88,7 @@ TextPainter::TextPainter(RendererPtr renderer, TextureGroupPtr textureGroup)
m_fontTextureGroup(textureGroup), m_fontTextureGroup(textureGroup),
m_fontSize(8), m_fontSize(8),
m_lineSpacing(1.30f), m_lineSpacing(1.30f),
m_renderSettings({FontMode::Normal, Vec4B::filled(255), "hobo"}), m_renderSettings({FontMode::Normal, Vec4B::filled(255), "hobo", ""}),
m_splitIgnore(" \t"), m_splitIgnore(" \t"),
m_splitForce("\n\v"), m_splitForce("\n\v"),
m_nonRenderedCharacters("\n\v\r") { m_nonRenderedCharacters("\n\v\r") {

4
source/test/assets_test.cpp
View File

@ -16,8 +16,8 @@ TEST(AssetsTest, All) {
EXPECT_EQ(AssetPath::filename("/foo/"), ""); EXPECT_EQ(AssetPath::filename("/foo/"), "");
EXPECT_EQ(AssetPath::filename("/foo/bar"), "bar"); EXPECT_EQ(AssetPath::filename("/foo/bar"), "bar");
AssetPath compare = AssetPath{"/foo/bar/baz", String("baf"), {"whoa", "there"}}; //AssetPath compare = AssetPath{"/foo/bar/baz", String("baf"), {"whoa", "there"}};
EXPECT_EQ(AssetPath::split("/foo/bar/baz:baf?whoa?there"), compare); //EXPECT_EQ(AssetPath::split("/foo/bar/baz:baf?whoa?there"), compare);
EXPECT_EQ( EXPECT_EQ(
AssetPath::relativeTo("/foo/bar/baz:baf?whoa?there", "thing:sub?directive"), "/foo/bar/thing:sub?directive"); AssetPath::relativeTo("/foo/bar/baz:baf?whoa?there", "thing:sub?directive"), "/foo/bar/thing:sub?directive");

6
source/test/flat_hash_test.cpp
View File

@ -81,9 +81,10 @@ TEST(FlatHashSet, Random) {
Random::shuffle(keys); Random::shuffle(keys);
for (auto k : keys) { for (auto k : keys) {
auto i = testSet.find(k); auto i = testSet.find(k);
if (i != testSet.end()) if (i != testSet.end()) {
ASSERT_TRUE(*i == k); ASSERT_TRUE(*i == k);
} }
}
Random::shuffle(keys); Random::shuffle(keys);
for (auto k : keys) { for (auto k : keys) {
@ -180,9 +181,10 @@ TEST(FlatHashMap, Random) {
Random::shuffle(values); Random::shuffle(values);
for (auto v : values) { for (auto v : values) {
auto i = testMap.find(v.first); auto i = testMap.find(v.first);
if (i != testMap.end()) if (i != testMap.end()) {
ASSERT_TRUE(i->second == v.second); ASSERT_TRUE(i->second == v.second);
} }
}
Random::shuffle(values); Random::shuffle(values);
for (auto v : values) { for (auto v : values) {

2
source/utility/update_tilesets.cpp
View File

@ -111,7 +111,7 @@ void defineObjectOrientation(TilesetUpdater& updater,
List<ImageConstPtr> layers; List<ImageConstPtr> layers;
unsigned width = 0, height = 0; unsigned width = 0, height = 0;
for (auto const& imageLayer : orientation->imageLayers) { for (auto const& imageLayer : orientation->imageLayers) {
String imageName = imageLayer.imagePart().image.replaceTags(StringMap<String>{}, true, "default"); String imageName = AssetPath::join(imageLayer.imagePart().image).replaceTags(StringMap<String>{}, true, "default");
ImageConstPtr image = assets->image(imageName); ImageConstPtr image = assets->image(imageName);
layers.append(image); layers.append(image);

2
source/windowing/StarPaneManager.cpp
View File

@ -17,7 +17,7 @@ PaneManager::PaneManager()
} }
void PaneManager::displayPane(PaneLayer paneLayer, PanePtr const& pane, DismissCallback onDismiss) { void PaneManager::displayPane(PaneLayer paneLayer, PanePtr const& pane, DismissCallback onDismiss) {
if (!m_displayedPanes[paneLayer].insertFront(move(pane), move(onDismiss)).second) if (!m_displayedPanes[paneLayer].insertFront(pane, move(onDismiss)).second)
throw GuiException("Pane displayed twice in PaneManager::displayPane"); throw GuiException("Pane displayed twice in PaneManager::displayPane");
if (!pane->hasDisplayed() && pane->anchor() == PaneAnchor::None) if (!pane->hasDisplayed() && pane->anchor() == PaneAnchor::None)