Mirrors/citra-nightly
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge pull request #4244 from wwylele/swap-enum

Browse source 
common/swap: add swap template for enum
This commit is contained in:
Weiyi Wang 2018-10-04 14:51:49 -04:00 • committed by GitHub
commit eb494c574d
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
10 changed files with 111 additions and 60 deletions
Download patch file Download diff file Expand all files Collapse all files

19
src/core/file_sys/archive_ncch.cpp
View file

@ -12,6 +12,7 @@
#include "common/file_util.h"
#include "common/logging/log.h"
#include "common/string_util.h"
#include "common/swap.h"
#include "core/core.h"
#include "core/file_sys/archive_ncch.h"
#include "core/file_sys/errors.h"
@ -36,9 +37,9 @@ struct NCCHArchivePath {
static_assert(sizeof(NCCHArchivePath) == 0x10, "NCCHArchivePath has wrong size!");
struct NCCHFilePath {
u32_le open_type;
enum_le<NCCHFileOpenType> open_type;
u32_le content_index;
u32_le filepath_type;
enum_le<NCCHFilePathType> filepath_type;
std::array<char, 8> exefs_filepath;
};
static_assert(sizeof(NCCHFilePath) == 0x14, "NCCHFilePath has wrong size!");
@ -56,9 +57,9 @@ Path MakeNCCHArchivePath(u64 tid, Service::FS::MediaType media_type) {
Path MakeNCCHFilePath(NCCHFileOpenType open_type, u32 content_index, NCCHFilePathType filepath_type,
std::array<char, 8>& exefs_filepath) {
NCCHFilePath path;
path.open_type = static_cast<u32_le>(open_type);
path.open_type = open_type;
path.content_index = static_cast<u32_le>(content_index);
path.filepath_type = static_cast<u32_le>(filepath_type);
path.filepath_type = filepath_type;
path.exefs_filepath = exefs_filepath;
std::vector<u8> file(sizeof(path));
std::memcpy(&file[0], &path, sizeof(path));
@ -89,15 +90,14 @@ ResultVal<std::unique_ptr<FileBackend>> NCCHArchive::OpenFile(const Path& path,
std::unique_ptr<FileBackend> file;
// NCCH RomFS
NCCHFilePathType filepath_type = static_cast<NCCHFilePathType>(openfile_path.filepath_type);
if (filepath_type == NCCHFilePathType::RomFS) {
if (openfile_path.filepath_type == NCCHFilePathType::RomFS) {
std::shared_ptr<RomFSReader> romfs_file;
result = ncch_container.ReadRomFS(romfs_file);
std::unique_ptr<DelayGenerator> delay_generator = std::make_unique<RomFSDelayGenerator>();
file = std::make_unique<IVFCFile>(std::move(romfs_file), std::move(delay_generator));
} else if (filepath_type == NCCHFilePathType::Code ||
filepath_type == NCCHFilePathType::ExeFS) {
} else if (openfile_path.filepath_type == NCCHFilePathType::Code ||
openfile_path.filepath_type == NCCHFilePathType::ExeFS) {
std::vector<u8> buffer;
// Load NCCH .code or icon/banner/logo
@ -105,7 +105,8 @@ ResultVal<std::unique_ptr<FileBackend>> NCCHArchive::OpenFile(const Path& path,
std::unique_ptr<DelayGenerator> delay_generator = std::make_unique<ExeFSDelayGenerator>();
file = std::make_unique<NCCHFile>(std::move(buffer), std::move(delay_generator));
} else {
LOG_ERROR(Service_FS, "Unknown NCCH archive type {}!", openfile_path.filepath_type);
LOG_ERROR(Service_FS, "Unknown NCCH archive type {}!",
static_cast<u32>(openfile_path.filepath_type));
result = Loader::ResultStatus::Error;
}

4
src/core/file_sys/archive_selfncch.cpp
View file

@ -25,7 +25,7 @@ enum class SelfNCCHFilePathType : u32 {
};
struct SelfNCCHFilePath {
u32_le type;
enum_le<SelfNCCHFilePathType> type;
std::array<char, 8> exefs_filename;
};
static_assert(sizeof(SelfNCCHFilePath) == 12, "NCCHFilePath has wrong size!");
@ -102,7 +102,7 @@ public:
SelfNCCHFilePath file_path;
std::memcpy(&file_path, binary.data(), sizeof(SelfNCCHFilePath));
switch (static_cast<SelfNCCHFilePathType>(file_path.type)) {
switch (file_path.type) {
case SelfNCCHFilePathType::UpdateRomFS:
return OpenUpdateRomFS();

7
src/core/hle/applets/swkbd.cpp
View file

@ -110,7 +110,7 @@ void SoftwareKeyboard::Update() {
break;
default:
LOG_CRITICAL(Applet_SWKBD, "Unknown button config {}",
static_cast<int>(config.num_buttons_m1));
static_cast<u32>(config.num_buttons_m1));
UNREACHABLE();
}
@ -143,8 +143,9 @@ Frontend::KeyboardConfig SoftwareKeyboard::ToFrontendConfig(
const SoftwareKeyboardConfig& config) const {
using namespace Frontend;
KeyboardConfig frontend_config;
frontend_config.button_config = static_cast<ButtonConfig>(config.num_buttons_m1);
frontend_config.accept_mode = static_cast<AcceptedInput>(config.valid_input);
frontend_config.button_config =
static_cast<ButtonConfig>(static_cast<u32>(config.num_buttons_m1));
frontend_config.accept_mode = static_cast<AcceptedInput>(static_cast<u32>(config.valid_input));
frontend_config.multiline_mode = config.multiline;
frontend_config.max_text_length = config.max_text_length;
frontend_config.max_digits = config.max_digits;

56
src/core/hle/applets/swkbd.h
View file

@ -121,20 +121,20 @@ enum class SoftwareKeyboardResult : s32 {
};
struct SoftwareKeyboardConfig {
SoftwareKeyboardType type;
SoftwareKeyboardButtonConfig num_buttons_m1;
SoftwareKeyboardValidInput valid_input;
SoftwareKeyboardPasswordMode password_mode;
s32 is_parental_screen;
s32 darken_top_screen;
u32 filter_flags;
u32 save_state_flags;
u16 max_text_length;
u16 dict_word_count;
u16 max_digits;
std::array<std::array<u16, MAX_BUTTON_TEXT_LEN + 1>, MAX_BUTTON> button_text;
std::array<u16, 2> numpad_keys;
std::array<u16, MAX_HINT_TEXT_LEN + 1>
enum_le<SoftwareKeyboardType> type;
enum_le<SoftwareKeyboardButtonConfig> num_buttons_m1;
enum_le<SoftwareKeyboardValidInput> valid_input;
enum_le<SoftwareKeyboardPasswordMode> password_mode;
s32_le is_parental_screen;
s32_le darken_top_screen;
u32_le filter_flags;
u32_le save_state_flags;
u16_le max_text_length;
u16_le dict_word_count;
u16_le max_digits;
std::array<std::array<u16_le, MAX_BUTTON_TEXT_LEN + 1>, MAX_BUTTON> button_text;
std::array<u16_le, 2> numpad_keys;
std::array<u16_le, MAX_HINT_TEXT_LEN + 1>
hint_text; ///< Text to display when asking the user for input
bool predictive_input;
bool multiline;
@ -145,25 +145,25 @@ struct SoftwareKeyboardConfig {
bool unknown;
bool default_qwerty;
std::array<bool, 4> button_submits_text;
u16 language;
u16_le language;
u32 initial_text_offset; ///< Offset of the default text in the output SharedMemory
u32 dict_offset;
u32 initial_status_offset;
u32 initial_learning_offset;
u32 shared_memory_size; ///< Size of the SharedMemory
u32 version;
u32_le initial_text_offset; ///< Offset of the default text in the output SharedMemory
u32_le dict_offset;
u32_le initial_status_offset;
u32_le initial_learning_offset;
u32_le shared_memory_size; ///< Size of the SharedMemory
u32_le version;
SoftwareKeyboardResult return_code;
enum_le<SoftwareKeyboardResult> return_code;
u32 status_offset;
u32 learning_offset;
u32_le status_offset;
u32_le learning_offset;
u32 text_offset; ///< Offset in the SharedMemory where the output text starts
u16 text_length; ///< Length in characters of the output text
u32_le text_offset; ///< Offset in the SharedMemory where the output text starts
u16_le text_length; ///< Length in characters of the output text
int callback_result;
std::array<u16, MAX_CALLBACK_MSG_LEN + 1> callback_msg;
s32_le callback_result;
std::array<u16_le, MAX_CALLBACK_MSG_LEN + 1> callback_msg;
bool skip_at_check;
INSERT_PADDING_BYTES(0xAB);
};

2
src/core/hle/service/ldr_ro/cro_helper.h
View file

@ -235,7 +235,7 @@ private:
struct SegmentEntry {
u32_le offset;
u32_le size;
SegmentType type;
enum_le<SegmentType> type;
static constexpr HeaderField TABLE_OFFSET_FIELD = SegmentTableOffset;
};

9
src/core/hle/service/nwm/uds_connection.cpp
View file

@ -14,7 +14,7 @@ constexpr u16 DefaultExtraCapabilities = 0x0431;
std::vector<u8> GenerateAuthenticationFrame(AuthenticationSeq seq) {
AuthenticationFrame frame{};
frame.auth_seq = static_cast<u16>(seq);
frame.auth_seq = seq;
std::vector<u8> data(sizeof(frame));
std::memcpy(data.data(), &frame, sizeof(frame));
@ -26,7 +26,7 @@ AuthenticationSeq GetAuthenticationSeqNumber(const std::vector<u8>& body) {
AuthenticationFrame frame;
std::memcpy(&frame, body.data(), sizeof(frame));
return static_cast<AuthenticationSeq>(frame.auth_seq);
return frame.auth_seq;
}
/**
@ -57,7 +57,7 @@ static std::vector<u8> GenerateSSIDTag(u32 network_id) {
std::vector<u8> GenerateAssocResponseFrame(AssocStatus status, u16 association_id, u32 network_id) {
AssociationResponseFrame frame{};
frame.capabilities = DefaultExtraCapabilities;
frame.status_code = static_cast<u16>(status);
frame.status_code = status;
// The association id is ORed with this magic value (0xC000)
constexpr u16 AssociationIdMagic = 0xC000;
frame.assoc_id = association_id | AssociationIdMagic;
@ -79,8 +79,7 @@ std::tuple<AssocStatus, u16> GetAssociationResult(const std::vector<u8>& body) {
memcpy(&frame, body.data(), sizeof(frame));
constexpr u16 AssociationIdMask = 0x3FFF;
return std::make_tuple(static_cast<AssocStatus>(frame.status_code),
frame.assoc_id & AssociationIdMask);
return std::make_tuple(frame.status_code, frame.assoc_id & AssociationIdMask);
}
} // namespace Service::NWM

8
src/core/hle/service/nwm/uds_connection.h
View file

@ -22,16 +22,16 @@ enum class AuthStatus : u16 { Successful = 0 };
enum class AssocStatus : u16 { Successful = 0 };
struct AuthenticationFrame {
u16_le auth_algorithm = static_cast<u16>(AuthAlgorithm::OpenSystem);
u16_le auth_seq;
u16_le status_code = static_cast<u16>(AuthStatus::Successful);
enum_le<AuthAlgorithm> auth_algorithm = AuthAlgorithm::OpenSystem;
enum_le<AuthenticationSeq> auth_seq;
enum_le<AuthStatus> status_code = AuthStatus::Successful;
};
static_assert(sizeof(AuthenticationFrame) == 6, "AuthenticationFrame has wrong size");
struct AssociationResponseFrame {
u16_le capabilities;
u16_le status_code;
enum_le<AssocStatus> status_code;
u16_le assoc_id;
};

6
src/core/hle/service/nwm/uds_data.cpp
View file

@ -25,7 +25,7 @@ using MacAddress = std::array<u8, 6>;
*/
static std::vector<u8> GenerateLLCHeader(EtherType protocol) {
LLCHeader header{};
header.protocol = static_cast<u16>(protocol);
header.protocol = protocol;
std::vector<u8> buffer(sizeof(header));
memcpy(buffer.data(), &header, sizeof(header));
@ -312,9 +312,7 @@ std::vector<u8> GenerateEAPoLStartFrame(u16 association_id, const NodeInfo& node
EtherType GetFrameEtherType(const std::vector<u8>& frame) {
LLCHeader header;
std::memcpy(&header, frame.data(), sizeof(header));
u16 ethertype = header.protocol;
return static_cast<EtherType>(ethertype);
return header.protocol;
}
u16 GetEAPoLFrameType(const std::vector<u8>& frame) {

8
src/core/hle/service/nwm/uds_data.h
View file

@ -25,11 +25,11 @@ enum class EtherType : u16 { SecureData = 0x876D, EAPoL = 0x888E };
* and the OUI is always 0.
*/
struct LLCHeader {
u8 dsap = static_cast<u8>(SAP::SNAPExtensionUsed);
u8 ssap = static_cast<u8>(SAP::SNAPExtensionUsed);
u8 control = static_cast<u8>(PDUControl::UnnumberedInformation);
SAP dsap = SAP::SNAPExtensionUsed;
SAP ssap = SAP::SNAPExtensionUsed;
PDUControl control = PDUControl::UnnumberedInformation;
std::array<u8, 3> OUI = {};
u16_be protocol;
enum_be<EtherType> protocol;
};
static_assert(sizeof(LLCHeader) == 8, "LLCHeader has the wrong size");