2019-11-04 02:54:03 +03:00
|
|
|
// Copyright 2019 yuzu emulator team
|
2014-12-17 08:38:14 +03:00
|
|
|
// Licensed under GPLv2 or any later version
|
2013-09-05 04:17:46 +04:00
|
|
|
// Refer to the license.txt file included.
|
|
|
|
|
2014-08-17 21:45:50 +04:00
|
|
|
#pragma once
|
2013-09-05 04:17:46 +04:00
|
|
|
|
2019-05-09 01:27:29 +03:00
|
|
|
#include <algorithm>
|
2019-11-04 02:54:03 +03:00
|
|
|
#include <array>
|
2018-07-19 16:03:30 +03:00
|
|
|
#include <string>
|
|
|
|
|
2018-05-13 13:34:45 +03:00
|
|
|
#if !defined(ARCHITECTURE_x86_64)
|
2016-04-30 18:34:51 +03:00
|
|
|
#include <cstdlib> // for exit
|
|
|
|
#endif
|
2017-05-28 02:14:10 +03:00
|
|
|
#include "common/common_types.h"
|
2013-09-05 04:17:46 +04:00
|
|
|
|
2015-01-11 18:32:31 +03:00
|
|
|
/// Textually concatenates two tokens. The double-expansion is required by the C preprocessor.
|
|
|
|
#define CONCAT2(x, y) DO_CONCAT2(x, y)
|
2016-09-18 03:38:01 +03:00
|
|
|
#define DO_CONCAT2(x, y) x##y
|
2015-01-11 18:32:31 +03:00
|
|
|
|
2019-11-04 02:54:03 +03:00
|
|
|
/// Helper macros to insert unused bytes or words to properly align structs. These values will be
|
|
|
|
/// zero-initialized.
|
2019-11-15 00:54:01 +03:00
|
|
|
#define INSERT_PADDING_BYTES(num_bytes) \
|
|
|
|
std::array<u8, num_bytes> CONCAT2(pad, __LINE__) {}
|
|
|
|
#define INSERT_PADDING_WORDS(num_words) \
|
|
|
|
std::array<u32, num_words> CONCAT2(pad, __LINE__) {}
|
2015-02-13 07:57:02 +03:00
|
|
|
|
2021-01-15 10:25:40 +03:00
|
|
|
/// These are similar to the INSERT_PADDING_* macros but do not zero-initialize the contents.
|
|
|
|
/// This keeps the structure trivial to construct.
|
|
|
|
#define INSERT_PADDING_BYTES_NOINIT(num_bytes) std::array<u8, num_bytes> CONCAT2(pad, __LINE__)
|
|
|
|
#define INSERT_PADDING_WORDS_NOINIT(num_words) std::array<u32, num_words> CONCAT2(pad, __LINE__)
|
2015-05-07 05:26:19 +03:00
|
|
|
|
2014-11-29 08:38:20 +03:00
|
|
|
#ifndef _MSC_VER
|
2013-09-05 04:17:46 +04:00
|
|
|
|
2015-08-15 05:29:08 +03:00
|
|
|
#ifdef ARCHITECTURE_x86_64
|
2015-01-21 04:16:47 +03:00
|
|
|
#define Crash() __asm__ __volatile__("int $3")
|
|
|
|
#else
|
|
|
|
#define Crash() exit(1)
|
|
|
|
#endif
|
|
|
|
|
2014-11-29 08:38:20 +03:00
|
|
|
#else // _MSC_VER
|
2016-05-27 12:40:01 +03:00
|
|
|
|
|
|
|
// Locale Cross-Compatibility
|
|
|
|
#define locale_t _locale_t
|
|
|
|
|
|
|
|
extern "C" {
|
2016-09-18 03:38:01 +03:00
|
|
|
__declspec(dllimport) void __stdcall DebugBreak(void);
|
2016-05-27 12:40:01 +03:00
|
|
|
}
|
2016-09-19 04:01:46 +03:00
|
|
|
#define Crash() DebugBreak()
|
2016-05-27 12:40:01 +03:00
|
|
|
|
2014-11-29 08:38:20 +03:00
|
|
|
#endif // _MSC_VER ndef
|
2013-09-05 04:17:46 +04:00
|
|
|
|
|
|
|
// Generic function to get last error message.
|
|
|
|
// Call directly after the command or use the error num.
|
|
|
|
// This function might change the error code.
|
|
|
|
// Defined in Misc.cpp.
|
2020-08-14 16:38:45 +03:00
|
|
|
[[nodiscard]] std::string GetLastErrorMsg();
|
2017-10-15 07:11:38 +03:00
|
|
|
|
2020-03-21 05:40:03 +03:00
|
|
|
#define DECLARE_ENUM_FLAG_OPERATORS(type) \
|
2020-08-14 16:38:45 +03:00
|
|
|
[[nodiscard]] constexpr type operator|(type a, type b) noexcept { \
|
2020-03-21 05:40:03 +03:00
|
|
|
using T = std::underlying_type_t<type>; \
|
|
|
|
return static_cast<type>(static_cast<T>(a) | static_cast<T>(b)); \
|
|
|
|
} \
|
2020-08-14 16:38:45 +03:00
|
|
|
[[nodiscard]] constexpr type operator&(type a, type b) noexcept { \
|
2020-03-21 05:40:03 +03:00
|
|
|
using T = std::underlying_type_t<type>; \
|
|
|
|
return static_cast<type>(static_cast<T>(a) & static_cast<T>(b)); \
|
|
|
|
} \
|
2020-08-24 11:39:26 +03:00
|
|
|
[[nodiscard]] constexpr type operator^(type a, type b) noexcept { \
|
2020-03-21 05:40:03 +03:00
|
|
|
using T = std::underlying_type_t<type>; \
|
2020-08-24 11:39:26 +03:00
|
|
|
return static_cast<type>(static_cast<T>(a) ^ static_cast<T>(b)); \
|
|
|
|
} \
|
|
|
|
constexpr type& operator|=(type& a, type b) noexcept { \
|
|
|
|
a = a | b; \
|
2020-03-21 05:40:03 +03:00
|
|
|
return a; \
|
|
|
|
} \
|
|
|
|
constexpr type& operator&=(type& a, type b) noexcept { \
|
2020-08-24 11:39:26 +03:00
|
|
|
a = a & b; \
|
|
|
|
return a; \
|
|
|
|
} \
|
|
|
|
constexpr type& operator^=(type& a, type b) noexcept { \
|
|
|
|
a = a ^ b; \
|
2020-03-21 05:40:03 +03:00
|
|
|
return a; \
|
|
|
|
} \
|
2020-08-14 16:38:45 +03:00
|
|
|
[[nodiscard]] constexpr type operator~(type key) noexcept { \
|
2020-03-21 05:40:03 +03:00
|
|
|
using T = std::underlying_type_t<type>; \
|
|
|
|
return static_cast<type>(~static_cast<T>(key)); \
|
|
|
|
} \
|
2020-08-14 16:38:45 +03:00
|
|
|
[[nodiscard]] constexpr bool True(type key) noexcept { \
|
2020-03-21 05:40:03 +03:00
|
|
|
using T = std::underlying_type_t<type>; \
|
|
|
|
return static_cast<T>(key) != 0; \
|
|
|
|
} \
|
2020-08-14 16:38:45 +03:00
|
|
|
[[nodiscard]] constexpr bool False(type key) noexcept { \
|
2020-03-21 05:40:03 +03:00
|
|
|
using T = std::underlying_type_t<type>; \
|
|
|
|
return static_cast<T>(key) == 0; \
|
|
|
|
}
|
|
|
|
|
2020-12-29 09:24:05 +03:00
|
|
|
/// Evaluates a boolean expression, and returns a result unless that expression is true.
|
|
|
|
#define R_UNLESS(expr, res) \
|
|
|
|
{ \
|
|
|
|
if (!(expr)) { \
|
2021-01-25 09:50:36 +03:00
|
|
|
if (res.IsError()) { \
|
2021-01-29 08:51:16 +03:00
|
|
|
LOG_ERROR(Kernel, "Failed with result: {}", res.raw); \
|
2021-01-25 09:50:36 +03:00
|
|
|
} \
|
2020-12-29 09:24:05 +03:00
|
|
|
return res; \
|
|
|
|
} \
|
|
|
|
}
|
|
|
|
|
2021-01-16 08:52:18 +03:00
|
|
|
#define R_SUCCEEDED(res) (res.IsSuccess())
|
|
|
|
|
|
|
|
/// Evaluates an expression that returns a result, and returns the result if it would fail.
|
|
|
|
#define R_TRY(res_expr) \
|
|
|
|
{ \
|
|
|
|
const auto _tmp_r_try_rc = (res_expr); \
|
|
|
|
if (_tmp_r_try_rc.IsError()) { \
|
|
|
|
return _tmp_r_try_rc; \
|
|
|
|
} \
|
|
|
|
}
|
|
|
|
|
2021-01-20 07:53:11 +03:00
|
|
|
/// Evaluates a boolean expression, and succeeds if that expression is true.
|
|
|
|
#define R_SUCCEED_IF(expr) R_UNLESS(!(expr), RESULT_SUCCESS)
|
|
|
|
|
2017-10-15 07:11:38 +03:00
|
|
|
namespace Common {
|
|
|
|
|
2020-08-14 16:38:45 +03:00
|
|
|
[[nodiscard]] constexpr u32 MakeMagic(char a, char b, char c, char d) {
|
2019-11-13 14:50:49 +03:00
|
|
|
return u32(a) | u32(b) << 8 | u32(c) << 16 | u32(d) << 24;
|
2017-10-15 07:11:38 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
} // namespace Common
|