Merge pull request #4304 from B3n30/std_optional

Replace boost::optional with std::optional where possible
This commit is contained in:
Weiyi Wang 2018-10-11 12:40:00 -04:00 committed by GitHub
commit 9adc407112
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
30 changed files with 115 additions and 109 deletions

View file

@ -317,12 +317,12 @@ void ConfigureInput::setPollingResult(const Common::ParamPackage& params, bool a
poller->Stop(); poller->Stop();
} }
if (!abort) { if (!abort && input_setter) {
(*input_setter)(params); (*input_setter)(params);
} }
updateButtonLabels(); updateButtonLabels();
input_setter = boost::none; input_setter.reset();
} }
void ConfigureInput::keyPressEvent(QKeyEvent* event) { void ConfigureInput::keyPressEvent(QKeyEvent* event) {

View file

@ -1,4 +1,4 @@
// Copyright 2016 Citra Emulator Project // Copyright 2016 Citra Emulator Project
// Licensed under GPLv2 or any later version // Licensed under GPLv2 or any later version
// Refer to the license.txt file included. // Refer to the license.txt file included.
@ -7,11 +7,11 @@
#include <array> #include <array>
#include <functional> #include <functional>
#include <memory> #include <memory>
#include <optional>
#include <string> #include <string>
#include <unordered_map> #include <unordered_map>
#include <QKeyEvent> #include <QKeyEvent>
#include <QWidget> #include <QWidget>
#include <boost/optional.hpp>
#include "common/param_package.h" #include "common/param_package.h"
#include "core/settings.h" #include "core/settings.h"
#include "input_common/main.h" #include "input_common/main.h"
@ -42,7 +42,7 @@ private:
std::unique_ptr<QTimer> poll_timer; std::unique_ptr<QTimer> poll_timer;
/// This will be the the setting function when an input is awaiting configuration. /// This will be the the setting function when an input is awaiting configuration.
boost::optional<std::function<void(const Common::ParamPackage&)>> input_setter; std::optional<std::function<void(const Common::ParamPackage&)>> input_setter;
std::array<Common::ParamPackage, Settings::NativeButton::NumButtons> buttons_param; std::array<Common::ParamPackage, Settings::NativeButton::NumButtons> buttons_param;
std::array<Common::ParamPackage, Settings::NativeAnalog::NumAnalogs> analogs_param; std::array<Common::ParamPackage, Settings::NativeAnalog::NumAnalogs> analogs_param;

View file

@ -99,7 +99,7 @@ System::ResultStatus System::Load(EmuWindow& emu_window, const std::string& file
LOG_CRITICAL(Core, "Failed to obtain loader for {}!", filepath); LOG_CRITICAL(Core, "Failed to obtain loader for {}!", filepath);
return ResultStatus::ErrorGetLoader; return ResultStatus::ErrorGetLoader;
} }
std::pair<boost::optional<u32>, Loader::ResultStatus> system_mode = std::pair<std::optional<u32>, Loader::ResultStatus> system_mode =
app_loader->LoadKernelSystemMode(); app_loader->LoadKernelSystemMode();
if (system_mode.second != Loader::ResultStatus::Success) { if (system_mode.second != Loader::ResultStatus::Success) {
@ -116,7 +116,8 @@ System::ResultStatus System::Load(EmuWindow& emu_window, const std::string& file
} }
} }
ResultStatus init_result{Init(emu_window, system_mode.first.get())}; ASSERT(system_mode.first);
ResultStatus init_result{Init(emu_window, *system_mode.first)};
if (init_result != ResultStatus::Success) { if (init_result != ResultStatus::Success) {
LOG_CRITICAL(Core, "Failed to initialize system (Error {})!", LOG_CRITICAL(Core, "Failed to initialize system (Error {})!",
static_cast<u32>(init_result)); static_cast<u32>(init_result));

View file

@ -38,13 +38,13 @@ Loader::ResultStatus Ticket::Load(const std::vector<u8> file_data, std::size_t o
return Loader::ResultStatus::Success; return Loader::ResultStatus::Success;
} }
boost::optional<std::array<u8, 16>> Ticket::GetTitleKey() const { std::optional<std::array<u8, 16>> Ticket::GetTitleKey() const {
HW::AES::InitKeys(); HW::AES::InitKeys();
std::array<u8, 16> ctr{}; std::array<u8, 16> ctr{};
std::memcpy(ctr.data(), &ticket_body.title_id, sizeof(u64)); std::memcpy(ctr.data(), &ticket_body.title_id, sizeof(u64));
HW::AES::SelectCommonKeyIndex(ticket_body.common_key_index); HW::AES::SelectCommonKeyIndex(ticket_body.common_key_index);
if (!HW::AES::IsNormalKeyAvailable(HW::AES::KeySlotID::TicketCommonKey)) { if (!HW::AES::IsNormalKeyAvailable(HW::AES::KeySlotID::TicketCommonKey)) {
return boost::none; return {};
} }
auto key = HW::AES::GetNormalKey(HW::AES::KeySlotID::TicketCommonKey); auto key = HW::AES::GetNormalKey(HW::AES::KeySlotID::TicketCommonKey);
auto title_key = ticket_body.title_key; auto title_key = ticket_body.title_key;

View file

@ -5,9 +5,9 @@
#pragma once #pragma once
#include <array> #include <array>
#include <optional>
#include <string> #include <string>
#include <vector> #include <vector>
#include <boost/optional.hpp>
#include "common/common_funcs.h" #include "common/common_funcs.h"
#include "common/common_types.h" #include "common/common_types.h"
#include "common/swap.h" #include "common/swap.h"
@ -48,7 +48,7 @@ public:
#pragma pack(pop) #pragma pack(pop)
Loader::ResultStatus Load(const std::vector<u8> file_data, std::size_t offset = 0); Loader::ResultStatus Load(const std::vector<u8> file_data, std::size_t offset = 0);
boost::optional<std::array<u8, 16>> GetTitleKey() const; std::optional<std::array<u8, 16>> GetTitleKey() const;
private: private:
Body ticket_body; Body ticket_body;

View file

@ -147,7 +147,9 @@ ResultCode SharedMemory::Map(Process* target_process, VAddr address, MemoryPermi
if (base_address == 0 && target_address == 0) { if (base_address == 0 && target_address == 0) {
// Calculate the address at which to map the memory block. // Calculate the address at which to map the memory block.
target_address = Memory::PhysicalToVirtualAddress(linear_heap_phys_address).value(); auto maybe_vaddr = Memory::PhysicalToVirtualAddress(linear_heap_phys_address);
ASSERT(maybe_vaddr);
target_address = *maybe_vaddr;
} }
// Map the memory block into the target process // Map the memory block into the target process

View file

@ -132,8 +132,7 @@ ResultCode CIAFile::WriteTitleMetadata() {
auto content_count = container.GetTitleMetadata().GetContentCount(); auto content_count = container.GetTitleMetadata().GetContentCount();
content_written.resize(content_count); content_written.resize(content_count);
auto title_key = container.GetTicket().GetTitleKey(); if (auto title_key = container.GetTicket().GetTitleKey()) {
if (title_key) {
decryption_state->content.resize(content_count); decryption_state->content.resize(content_count);
for (std::size_t i = 0; i < content_count; ++i) { for (std::size_t i = 0; i < content_count; ++i) {
auto ctr = tmd.GetContentCTRByIndex(i); auto ctr = tmd.GetContentCTRByIndex(i);
@ -340,7 +339,7 @@ InstallStatus InstallCIA(const std::string& path,
Service::AM::CIAFile installFile( Service::AM::CIAFile installFile(
Service::AM::GetTitleMediaType(container.GetTitleMetadata().GetTitleID())); Service::AM::GetTitleMediaType(container.GetTitleMetadata().GetTitleID()));
bool title_key_available = container.GetTicket().GetTitleKey().is_initialized(); bool title_key_available = container.GetTicket().GetTitleKey().has_value();
for (std::size_t i = 0; i < container.GetTitleMetadata().GetContentCount(); i++) { for (std::size_t i = 0; i < container.GetTitleMetadata().GetContentCount(); i++) {
if ((container.GetTitleMetadata().GetContentTypeByIndex(static_cast<u16>(i)) & if ((container.GetTitleMetadata().GetContentTypeByIndex(static_cast<u16>(i)) &

View file

@ -208,7 +208,7 @@ ResultVal<MessageParameter> AppletManager::GlanceParameter(AppletId app_id) {
// Note: The NS module always clears the DSPSleep and DSPWakeup signals even in GlanceParameter. // Note: The NS module always clears the DSPSleep and DSPWakeup signals even in GlanceParameter.
if (next_parameter->signal == SignalType::DspSleep || if (next_parameter->signal == SignalType::DspSleep ||
next_parameter->signal == SignalType::DspWakeup) next_parameter->signal == SignalType::DspWakeup)
next_parameter = boost::none; next_parameter = {};
return MakeResult<MessageParameter>(parameter); return MakeResult<MessageParameter>(parameter);
} }
@ -217,7 +217,7 @@ ResultVal<MessageParameter> AppletManager::ReceiveParameter(AppletId app_id) {
auto result = GlanceParameter(app_id); auto result = GlanceParameter(app_id);
if (result.Succeeded()) { if (result.Succeeded()) {
// Clear the parameter // Clear the parameter
next_parameter = boost::none; next_parameter = {};
} }
return result; return result;
} }
@ -237,7 +237,7 @@ bool AppletManager::CancelParameter(bool check_sender, AppletId sender_appid, bo
} }
if (cancellation_success) if (cancellation_success)
next_parameter = boost::none; next_parameter = {};
return cancellation_success; return cancellation_success;
} }

View file

@ -5,8 +5,8 @@
#pragma once #pragma once
#include <array> #include <array>
#include <optional>
#include <vector> #include <vector>
#include <boost/optional.hpp>
#include "core/hle/kernel/event.h" #include "core/hle/kernel/event.h"
#include "core/hle/result.h" #include "core/hle/result.h"
#include "core/hle/service/fs/archive.h" #include "core/hle/service/fs/archive.h"
@ -168,8 +168,7 @@ public:
private: private:
/// Parameter data to be returned in the next call to Glance/ReceiveParameter. /// Parameter data to be returned in the next call to Glance/ReceiveParameter.
/// TODO(Subv): Use std::optional once we migrate to C++17. std::optional<MessageParameter> next_parameter;
boost::optional<MessageParameter> next_parameter;
static constexpr std::size_t NumAppletSlot = 4; static constexpr std::size_t NumAppletSlot = 4;

View file

@ -205,8 +205,10 @@ void Module::Interface::GetSharedFont(Kernel::HLERequestContext& ctx) {
// The shared font has to be relocated to the new address before being passed to the // The shared font has to be relocated to the new address before being passed to the
// application. // application.
VAddr target_address = auto maybe_vaddr =
Memory::PhysicalToVirtualAddress(apt->shared_font_mem->linear_heap_phys_address).value(); Memory::PhysicalToVirtualAddress(apt->shared_font_mem->linear_heap_phys_address);
ASSERT(maybe_vaddr);
VAddr target_address = *maybe_vaddr;
if (!apt->shared_font_relocated) { if (!apt->shared_font_relocated) {
BCFNT::RelocateSharedFont(apt->shared_font_mem, target_address); BCFNT::RelocateSharedFont(apt->shared_font_mem, target_address);
apt->shared_font_relocated = true; apt->shared_font_relocated = true;

View file

@ -133,7 +133,7 @@ void HTTP_C::CreateContext(Kernel::HLERequestContext& ctx) {
} }
// This command can only be called without a bound session. // This command can only be called without a bound session.
if (session_data->current_http_context != boost::none) { if (session_data->current_http_context) {
LOG_ERROR(Service_HTTP, "Command called with a bound context"); LOG_ERROR(Service_HTTP, "Command called with a bound context");
IPC::RequestBuilder rb = rp.MakeBuilder(1, 2); IPC::RequestBuilder rb = rp.MakeBuilder(1, 2);
@ -199,7 +199,7 @@ void HTTP_C::CloseContext(Kernel::HLERequestContext& ctx) {
return; return;
} }
ASSERT_MSG(session_data->current_http_context == boost::none, ASSERT_MSG(!session_data->current_http_context,
"Unimplemented CloseContext on context-bound session"); "Unimplemented CloseContext on context-bound session");
auto itr = contexts.find(context_handle); auto itr = contexts.find(context_handle);
@ -250,7 +250,7 @@ void HTTP_C::AddRequestHeader(Kernel::HLERequestContext& ctx) {
} }
// This command can only be called with a bound context // This command can only be called with a bound context
if (session_data->current_http_context == boost::none) { if (!session_data->current_http_context) {
LOG_ERROR(Service_HTTP, "Command called without a bound context"); LOG_ERROR(Service_HTTP, "Command called without a bound context");
IPC::RequestBuilder rb = rp.MakeBuilder(1, 2); IPC::RequestBuilder rb = rp.MakeBuilder(1, 2);
@ -264,7 +264,7 @@ void HTTP_C::AddRequestHeader(Kernel::HLERequestContext& ctx) {
LOG_ERROR(Service_HTTP, LOG_ERROR(Service_HTTP,
"Tried to add a request header on a mismatched session input context={} session " "Tried to add a request header on a mismatched session input context={} session "
"context={}", "context={}",
context_handle, session_data->current_http_context.get()); context_handle, *session_data->current_http_context);
IPC::RequestBuilder rb = rp.MakeBuilder(1, 2); IPC::RequestBuilder rb = rp.MakeBuilder(1, 2);
rb.Push(ERROR_STATE_ERROR); rb.Push(ERROR_STATE_ERROR);
rb.PushMappedBuffer(value_buffer); rb.PushMappedBuffer(value_buffer);
@ -314,7 +314,7 @@ void HTTP_C::OpenClientCertContext(Kernel::HLERequestContext& ctx) {
if (!session_data->initialized) { if (!session_data->initialized) {
LOG_ERROR(Service_HTTP, "Command called without Initialize"); LOG_ERROR(Service_HTTP, "Command called without Initialize");
result = ERROR_STATE_ERROR; result = ERROR_STATE_ERROR;
} else if (session_data->current_http_context != boost::none) { } else if (session_data->current_http_context) {
LOG_ERROR(Service_HTTP, "Command called with a bound context"); LOG_ERROR(Service_HTTP, "Command called with a bound context");
result = ERROR_NOT_IMPLEMENTED; result = ERROR_NOT_IMPLEMENTED;
} else if (session_data->num_client_certs >= 2) { } else if (session_data->num_client_certs >= 2) {
@ -353,7 +353,7 @@ void HTTP_C::OpenDefaultClientCertContext(Kernel::HLERequestContext& ctx) {
return; return;
} }
if (session_data->current_http_context != boost::none) { if (session_data->current_http_context) {
LOG_ERROR(Service_HTTP, "Command called with a bound context"); LOG_ERROR(Service_HTTP, "Command called with a bound context");
IPC::RequestBuilder rb = rp.MakeBuilder(1, 0); IPC::RequestBuilder rb = rp.MakeBuilder(1, 0);
rb.Push(ERROR_NOT_IMPLEMENTED); rb.Push(ERROR_NOT_IMPLEMENTED);

View file

@ -5,10 +5,10 @@
#pragma once #pragma once
#include <memory> #include <memory>
#include <optional>
#include <string> #include <string>
#include <unordered_map> #include <unordered_map>
#include <vector> #include <vector>
#include <boost/optional.hpp>
#include "core/hle/kernel/shared_memory.h" #include "core/hle/kernel/shared_memory.h"
#include "core/hle/service/service.h" #include "core/hle/service/service.h"
@ -116,8 +116,8 @@ public:
std::string url; std::string url;
RequestMethod method; RequestMethod method;
RequestState state = RequestState::NotStarted; RequestState state = RequestState::NotStarted;
boost::optional<Proxy> proxy; std::optional<Proxy> proxy;
boost::optional<BasicAuth> basic_auth; std::optional<BasicAuth> basic_auth;
SSLConfig ssl_config{}; SSLConfig ssl_config{};
u32 socket_buffer_size; u32 socket_buffer_size;
std::vector<RequestHeader> headers; std::vector<RequestHeader> headers;
@ -127,7 +127,7 @@ public:
struct SessionData : public Kernel::SessionRequestHandler::SessionDataBase { struct SessionData : public Kernel::SessionRequestHandler::SessionDataBase {
/// The HTTP context that is currently bound to this session, this can be empty if no context /// The HTTP context that is currently bound to this session, this can be empty if no context
/// has been bound. Certain commands can only be called on a session with a bound context. /// has been bound. Certain commands can only be called on a session with a bound context.
boost::optional<Context::Handle> current_http_context; std::optional<Context::Handle> current_http_context;
u32 session_id; u32 session_id;

View file

@ -4,8 +4,8 @@
#include <algorithm> #include <algorithm>
#include <exception> #include <exception>
#include <optional>
#include <sstream> #include <sstream>
#include <boost/optional.hpp>
#include "common/common_paths.h" #include "common/common_paths.h"
#include "common/file_util.h" #include "common/file_util.h"
#include "common/logging/log.h" #include "common/logging/log.h"
@ -18,24 +18,24 @@ namespace AES {
namespace { namespace {
boost::optional<AESKey> generator_constant; std::optional<AESKey> generator_constant;
struct KeySlot { struct KeySlot {
boost::optional<AESKey> x; std::optional<AESKey> x;
boost::optional<AESKey> y; std::optional<AESKey> y;
boost::optional<AESKey> normal; std::optional<AESKey> normal;
void SetKeyX(boost::optional<AESKey> key) { void SetKeyX(std::optional<AESKey> key) {
x = key; x = key;
GenerateNormalKey(); GenerateNormalKey();
} }
void SetKeyY(boost::optional<AESKey> key) { void SetKeyY(std::optional<AESKey> key) {
y = key; y = key;
GenerateNormalKey(); GenerateNormalKey();
} }
void SetNormalKey(boost::optional<AESKey> key) { void SetNormalKey(std::optional<AESKey> key) {
normal = key; normal = key;
} }
@ -43,7 +43,7 @@ struct KeySlot {
if (x && y && generator_constant) { if (x && y && generator_constant) {
normal = Lrot128(Add128(Xor128(Lrot128(*x, 2), *y), *generator_constant), 87); normal = Lrot128(Add128(Xor128(Lrot128(*x, 2), *y), *generator_constant), 87);
} else { } else {
normal = boost::none; normal = {};
} }
} }
@ -55,7 +55,7 @@ struct KeySlot {
}; };
std::array<KeySlot, KeySlotID::MaxKeySlotID> key_slots; std::array<KeySlot, KeySlotID::MaxKeySlotID> key_slots;
std::array<boost::optional<AESKey>, 6> common_key_y_slots; std::array<std::optional<AESKey>, 6> common_key_y_slots;
AESKey HexToKey(const std::string& hex) { AESKey HexToKey(const std::string& hex) {
if (hex.size() < 32) { if (hex.size() < 32) {
@ -169,7 +169,7 @@ void SetNormalKey(std::size_t slot_id, const AESKey& key) {
} }
bool IsNormalKeyAvailable(std::size_t slot_id) { bool IsNormalKeyAvailable(std::size_t slot_id) {
return key_slots.at(slot_id).normal.is_initialized(); return key_slots.at(slot_id).normal.has_value();
} }
AESKey GetNormalKey(std::size_t slot_id) { AESKey GetNormalKey(std::size_t slot_id) {

View file

@ -7,10 +7,10 @@
#include <algorithm> #include <algorithm>
#include <initializer_list> #include <initializer_list>
#include <memory> #include <memory>
#include <optional>
#include <string> #include <string>
#include <utility> #include <utility>
#include <vector> #include <vector>
#include <boost/optional.hpp>
#include "common/common_types.h" #include "common/common_types.h"
#include "common/file_util.h" #include "common/file_util.h"
#include "core/file_sys/romfs_reader.h" #include "core/file_sys/romfs_reader.h"
@ -107,7 +107,7 @@ public:
* information. * information.
* @returns A pair with the optional system mode, and and the status. * @returns A pair with the optional system mode, and and the status.
*/ */
virtual std::pair<boost::optional<u32>, ResultStatus> LoadKernelSystemMode() { virtual std::pair<std::optional<u32>, ResultStatus> LoadKernelSystemMode() {
// 96MB allocated to the application. // 96MB allocated to the application.
return std::make_pair(2, ResultStatus::Success); return std::make_pair(2, ResultStatus::Success);
} }

View file

@ -49,11 +49,11 @@ FileType AppLoader_NCCH::IdentifyType(FileUtil::IOFile& file) {
return FileType::Error; return FileType::Error;
} }
std::pair<boost::optional<u32>, ResultStatus> AppLoader_NCCH::LoadKernelSystemMode() { std::pair<std::optional<u32>, ResultStatus> AppLoader_NCCH::LoadKernelSystemMode() {
if (!is_loaded) { if (!is_loaded) {
ResultStatus res = base_ncch.Load(); ResultStatus res = base_ncch.Load();
if (res != ResultStatus::Success) { if (res != ResultStatus::Success) {
return std::make_pair(boost::none, res); return std::make_pair(std::optional<u32>{}, res);
} }
} }

View file

@ -39,7 +39,7 @@ public:
* Loads the Exheader and returns the system mode for this application. * Loads the Exheader and returns the system mode for this application.
* @returns A pair with the optional system mode, and and the status. * @returns A pair with the optional system mode, and and the status.
*/ */
std::pair<boost::optional<u32>, ResultStatus> LoadKernelSystemMode() override; std::pair<std::optional<u32>, ResultStatus> LoadKernelSystemMode() override;
ResultStatus ReadCode(std::vector<u8>& buffer) override; ResultStatus ReadCode(std::vector<u8>& buffer) override;

View file

@ -333,7 +333,7 @@ void RasterizerMarkRegionCached(PAddr start, u32 size, bool cached) {
PAddr paddr = start; PAddr paddr = start;
for (unsigned i = 0; i < num_pages; ++i, paddr += PAGE_SIZE) { for (unsigned i = 0; i < num_pages; ++i, paddr += PAGE_SIZE) {
boost::optional<VAddr> maybe_vaddr = PhysicalToVirtualAddress(paddr); std::optional<VAddr> maybe_vaddr = PhysicalToVirtualAddress(paddr);
// While the physical <-> virtual mapping is 1:1 for the regions supported by the cache, // While the physical <-> virtual mapping is 1:1 for the regions supported by the cache,
// some games (like Pokemon Super Mystery Dungeon) will try to use textures that go beyond // some games (like Pokemon Super Mystery Dungeon) will try to use textures that go beyond
// the end address of VRAM, causing the Virtual->Physical translation to fail when flushing // the end address of VRAM, causing the Virtual->Physical translation to fail when flushing
@ -433,7 +433,9 @@ void RasterizerFlushVirtualRegion(VAddr start, u32 size, FlushMode mode) {
VAddr overlap_start = std::max(start, region_start); VAddr overlap_start = std::max(start, region_start);
VAddr overlap_end = std::min(end, region_end); VAddr overlap_end = std::min(end, region_end);
PAddr physical_start = TryVirtualToPhysicalAddress(overlap_start).value(); auto maybe_paddr = TryVirtualToPhysicalAddress(overlap_start);
ASSERT(maybe_paddr);
PAddr physical_start = *maybe_paddr;
u32 overlap_size = overlap_end - overlap_start; u32 overlap_size = overlap_end - overlap_start;
auto* rasterizer = VideoCore::g_renderer->Rasterizer(); auto* rasterizer = VideoCore::g_renderer->Rasterizer();
@ -740,7 +742,7 @@ void WriteMMIO<u64>(MMIORegionPointer mmio_handler, VAddr addr, const u64 data)
mmio_handler->Write64(addr, data); mmio_handler->Write64(addr, data);
} }
boost::optional<PAddr> TryVirtualToPhysicalAddress(const VAddr addr) { std::optional<PAddr> TryVirtualToPhysicalAddress(const VAddr addr) {
if (addr == 0) { if (addr == 0) {
return 0; return 0;
} else if (addr >= VRAM_VADDR && addr < VRAM_VADDR_END) { } else if (addr >= VRAM_VADDR && addr < VRAM_VADDR_END) {
@ -757,7 +759,7 @@ boost::optional<PAddr> TryVirtualToPhysicalAddress(const VAddr addr) {
return addr - N3DS_EXTRA_RAM_VADDR + N3DS_EXTRA_RAM_PADDR; return addr - N3DS_EXTRA_RAM_VADDR + N3DS_EXTRA_RAM_PADDR;
} }
return boost::none; return {};
} }
PAddr VirtualToPhysicalAddress(const VAddr addr) { PAddr VirtualToPhysicalAddress(const VAddr addr) {
@ -770,7 +772,7 @@ PAddr VirtualToPhysicalAddress(const VAddr addr) {
return *paddr; return *paddr;
} }
boost::optional<VAddr> PhysicalToVirtualAddress(const PAddr addr) { std::optional<VAddr> PhysicalToVirtualAddress(const PAddr addr) {
if (addr == 0) { if (addr == 0) {
return 0; return 0;
} else if (addr >= VRAM_PADDR && addr < VRAM_PADDR_END) { } else if (addr >= VRAM_PADDR && addr < VRAM_PADDR_END) {
@ -785,7 +787,7 @@ boost::optional<VAddr> PhysicalToVirtualAddress(const PAddr addr) {
return addr - N3DS_EXTRA_RAM_PADDR + N3DS_EXTRA_RAM_VADDR; return addr - N3DS_EXTRA_RAM_PADDR + N3DS_EXTRA_RAM_VADDR;
} }
return boost::none; return {};
} }
} // namespace Memory } // namespace Memory

View file

@ -6,9 +6,9 @@
#include <array> #include <array>
#include <cstddef> #include <cstddef>
#include <optional>
#include <string> #include <string>
#include <vector> #include <vector>
#include <boost/optional.hpp>
#include "common/common_types.h" #include "common/common_types.h"
#include "core/mmio.h" #include "core/mmio.h"
@ -214,7 +214,7 @@ std::string ReadCString(VAddr vaddr, std::size_t max_length);
* Converts a virtual address inside a region with 1:1 mapping to physical memory to a physical * Converts a virtual address inside a region with 1:1 mapping to physical memory to a physical
* address. This should be used by services to translate addresses for use by the hardware. * address. This should be used by services to translate addresses for use by the hardware.
*/ */
boost::optional<PAddr> TryVirtualToPhysicalAddress(VAddr addr); std::optional<PAddr> TryVirtualToPhysicalAddress(VAddr addr);
/** /**
* Converts a virtual address inside a region with 1:1 mapping to physical memory to a physical * Converts a virtual address inside a region with 1:1 mapping to physical memory to a physical
@ -227,7 +227,7 @@ PAddr VirtualToPhysicalAddress(VAddr addr);
/** /**
* Undoes a mapping performed by VirtualToPhysicalAddress(). * Undoes a mapping performed by VirtualToPhysicalAddress().
*/ */
boost::optional<VAddr> PhysicalToVirtualAddress(PAddr paddr); std::optional<VAddr> PhysicalToVirtualAddress(PAddr paddr);
/** /**
* Gets a pointer to the memory region beginning at the specified physical address. * Gets a pointer to the memory region beginning at the specified physical address.

View file

@ -4,13 +4,14 @@
#pragma once #pragma once
#include <functional>
#include <memory> #include <memory>
#include <mutex> #include <mutex>
#include <optional>
#include <string> #include <string>
#include <thread> #include <thread>
#include <tuple> #include <tuple>
#include <vector> #include <vector>
#include <boost/optional.hpp>
#include "common/common_types.h" #include "common/common_types.h"
#include "common/thread.h" #include "common/thread.h"
#include "common/vector_math.h" #include "common/vector_math.h"
@ -40,7 +41,7 @@ struct DeviceStatus {
u16 max_x; u16 max_x;
u16 max_y; u16 max_y;
}; };
boost::optional<CalibrationData> touch_calibration; std::optional<CalibrationData> touch_calibration;
}; };
class Client { class Client {

View file

@ -29,24 +29,24 @@ namespace Response {
* Note: Modifies the buffer to zero out the crc (since thats the easiest way to check without * Note: Modifies the buffer to zero out the crc (since thats the easiest way to check without
* copying the buffer) * copying the buffer)
*/ */
boost::optional<Type> Validate(u8* data, std::size_t size) { std::optional<Type> Validate(u8* data, std::size_t size) {
if (size < sizeof(Header)) { if (size < sizeof(Header)) {
LOG_DEBUG(Input, "Invalid UDP packet received"); LOG_DEBUG(Input, "Invalid UDP packet received");
return boost::none; return {};
} }
Header header; Header header;
std::memcpy(&header, data, sizeof(Header)); std::memcpy(&header, data, sizeof(Header));
if (header.magic != SERVER_MAGIC) { if (header.magic != SERVER_MAGIC) {
LOG_ERROR(Input, "UDP Packet has an unexpected magic value"); LOG_ERROR(Input, "UDP Packet has an unexpected magic value");
return boost::none; return {};
} }
if (header.protocol_version != PROTOCOL_VERSION) { if (header.protocol_version != PROTOCOL_VERSION) {
LOG_ERROR(Input, "UDP Packet protocol mismatch"); LOG_ERROR(Input, "UDP Packet protocol mismatch");
return boost::none; return {};
} }
if (header.type < Type::Version || header.type > Type::PadData) { if (header.type < Type::Version || header.type > Type::PadData) {
LOG_ERROR(Input, "UDP Packet is an unknown type"); LOG_ERROR(Input, "UDP Packet is an unknown type");
return boost::none; return {};
} }
// Packet size must equal sizeof(Header) + sizeof(Data) // Packet size must equal sizeof(Header) + sizeof(Data)
@ -59,7 +59,7 @@ boost::optional<Type> Validate(u8* data, std::size_t size) {
Input, Input,
"UDP Packet payload length doesn't match. Received: {} PayloadLength: {} Expected: {}", "UDP Packet payload length doesn't match. Received: {} PayloadLength: {} Expected: {}",
size, header.payload_length, data_len + sizeof(Type)); size, header.payload_length, data_len + sizeof(Type));
return boost::none; return {};
} }
const u32 crc32 = header.crc; const u32 crc32 = header.crc;
@ -70,7 +70,7 @@ boost::optional<Type> Validate(u8* data, std::size_t size) {
result.process_bytes(data, data_len + sizeof(Header)); result.process_bytes(data, data_len + sizeof(Header));
if (crc32 != result.checksum()) { if (crc32 != result.checksum()) {
LOG_ERROR(Input, "UDP Packet CRC check failed. Offset: {}", offsetof(Header, crc)); LOG_ERROR(Input, "UDP Packet CRC check failed. Offset: {}", offsetof(Header, crc));
return boost::none; return {};
} }
return header.type; return header.type;
} }

View file

@ -5,10 +5,10 @@
#pragma once #pragma once
#include <array> #include <array>
#include <optional>
#include <type_traits> #include <type_traits>
#include <vector> #include <vector>
#include <boost/crc.hpp> #include <boost/crc.hpp>
#include <boost/optional.hpp>
#include "common/bit_field.h" #include "common/bit_field.h"
#include "common/swap.h" #include "common/swap.h"
@ -218,7 +218,7 @@ static_assert(sizeof(Message<PadData>) == MAX_PACKET_SIZE,
* @return boost::none if it failed to parse or Type if it succeeded. The client can then safely * @return boost::none if it failed to parse or Type if it succeeded. The client can then safely
* copy the data into the appropriate struct for that Type * copy the data into the appropriate struct for that Type
*/ */
boost::optional<Type> Validate(u8* data, std::size_t size); std::optional<Type> Validate(u8* data, std::size_t size);
} // namespace Response } // namespace Response

View file

@ -42,7 +42,7 @@ public:
std::unique_ptr<Input::TouchDevice> Create(const Common::ParamPackage& params) override { std::unique_ptr<Input::TouchDevice> Create(const Common::ParamPackage& params) override {
{ {
std::lock_guard<std::mutex> guard(status->update_mutex); std::lock_guard<std::mutex> guard(status->update_mutex);
status->touch_calibration.reset({}); status->touch_calibration.emplace();
// These default values work well for DS4 but probably not other touch inputs // These default values work well for DS4 but probably not other touch inputs
status->touch_calibration->min_x = params.Get("min_x", 100); status->touch_calibration->min_x = params.Get("min_x", 100);
status->touch_calibration->min_y = params.Get("min_y", 50); status->touch_calibration->min_y = params.Get("min_y", 50);

View file

@ -8,10 +8,10 @@
#include <cstring> #include <cstring>
#include <iterator> #include <iterator>
#include <memory> #include <memory>
#include <optional>
#include <unordered_set> #include <unordered_set>
#include <utility> #include <utility>
#include <vector> #include <vector>
#include <boost/optional.hpp>
#include <boost/range/iterator_range.hpp> #include <boost/range/iterator_range.hpp>
#include <glad/glad.h> #include <glad/glad.h>
#include "common/alignment.h" #include "common/alignment.h"
@ -881,7 +881,7 @@ constexpr MatchFlags operator|(MatchFlags lhs, MatchFlags rhs) {
template <MatchFlags find_flags> template <MatchFlags find_flags>
Surface FindMatch(const SurfaceCache& surface_cache, const SurfaceParams& params, Surface FindMatch(const SurfaceCache& surface_cache, const SurfaceParams& params,
ScaleMatch match_scale_type, ScaleMatch match_scale_type,
boost::optional<SurfaceInterval> validate_interval = boost::none) { std::optional<SurfaceInterval> validate_interval = {}) {
Surface match_surface = nullptr; Surface match_surface = nullptr;
bool match_valid = false; bool match_valid = false;
u32 match_scale = 0; u32 match_scale = 0;
@ -948,6 +948,7 @@ Surface FindMatch(const SurfaceCache& surface_cache, const SurfaceParams& params
return std::make_pair(surface->CanSubRect(params), surface->GetInterval()); return std::make_pair(surface->CanSubRect(params), surface->GetInterval());
}); });
IsMatch_Helper(std::integral_constant<MatchFlags, MatchFlags::Copy>{}, [&] { IsMatch_Helper(std::integral_constant<MatchFlags, MatchFlags::Copy>{}, [&] {
ASSERT(validate_interval);
auto copy_interval = auto copy_interval =
params.FromInterval(*validate_interval).GetCopyableInterval(surface); params.FromInterval(*validate_interval).GetCopyableInterval(surface);
bool matched = boost::icl::length(copy_interval & *validate_interval) != 0 && bool matched = boost::icl::length(copy_interval & *validate_interval) != 0 &&

View file

@ -910,7 +910,7 @@ bool exec_shader();
)"; )";
} }
boost::optional<std::string> DecompileProgram(const ProgramCode& program_code, std::optional<std::string> DecompileProgram(const ProgramCode& program_code,
const SwizzleData& swizzle_data, u32 main_offset, const SwizzleData& swizzle_data, u32 main_offset,
const RegGetter& inputreg_getter, const RegGetter& inputreg_getter,
const RegGetter& outputreg_getter, bool sanitize_mul, const RegGetter& outputreg_getter, bool sanitize_mul,
@ -923,7 +923,7 @@ boost::optional<std::string> DecompileProgram(const ProgramCode& program_code,
return generator.MoveShaderCode(); return generator.MoveShaderCode();
} catch (const DecompileFail& exception) { } catch (const DecompileFail& exception) {
LOG_INFO(HW_GPU, "Shader decompilation failed: {}", exception.what()); LOG_INFO(HW_GPU, "Shader decompilation failed: {}", exception.what());
return boost::none; return {};
} }
} }

View file

@ -4,8 +4,8 @@
#include <array> #include <array>
#include <functional> #include <functional>
#include <optional>
#include <string> #include <string>
#include <boost/optional.hpp>
#include "common/common_types.h" #include "common/common_types.h"
#include "video_core/shader/shader.h" #include "video_core/shader/shader.h"
@ -19,7 +19,7 @@ using RegGetter = std::function<std::string(u32)>;
std::string GetCommonDeclarations(); std::string GetCommonDeclarations();
boost::optional<std::string> DecompileProgram(const ProgramCode& program_code, std::optional<std::string> DecompileProgram(const ProgramCode& program_code,
const SwizzleData& swizzle_data, u32 main_offset, const SwizzleData& swizzle_data, u32 main_offset,
const RegGetter& inputreg_getter, const RegGetter& inputreg_getter,
const RegGetter& outputreg_getter, bool sanitize_mul, const RegGetter& outputreg_getter, bool sanitize_mul,

View file

@ -1634,9 +1634,8 @@ void main() {
return out; return out;
} }
boost::optional<std::string> GenerateVertexShader(const Pica::Shader::ShaderSetup& setup, std::optional<std::string> GenerateVertexShader(const Pica::Shader::ShaderSetup& setup,
const PicaVSConfig& config, const PicaVSConfig& config, bool separable_shader) {
bool separable_shader) {
std::string out = "#version 330 core\n"; std::string out = "#version 330 core\n";
if (separable_shader) { if (separable_shader) {
out += "#extension GL_ARB_separate_shader_objects : enable\n"; out += "#extension GL_ARB_separate_shader_objects : enable\n";
@ -1664,9 +1663,9 @@ boost::optional<std::string> GenerateVertexShader(const Pica::Shader::ShaderSetu
get_output_reg, config.state.sanitize_mul, false); get_output_reg, config.state.sanitize_mul, false);
if (!program_source_opt) if (!program_source_opt)
return boost::none; return {};
std::string& program_source = program_source_opt.get(); std::string& program_source = *program_source_opt;
out += R"( out += R"(
#define uniforms vs_uniforms #define uniforms vs_uniforms
@ -1822,7 +1821,7 @@ void main() {
return out; return out;
} }
boost::optional<std::string> GenerateGeometryShader(const Pica::Shader::ShaderSetup& setup, std::optional<std::string> GenerateGeometryShader(const Pica::Shader::ShaderSetup& setup,
const PicaGSConfig& config, const PicaGSConfig& config,
bool separable_shader) { bool separable_shader) {
std::string out = "#version 330 core\n"; std::string out = "#version 330 core\n";
@ -1831,7 +1830,7 @@ boost::optional<std::string> GenerateGeometryShader(const Pica::Shader::ShaderSe
} }
if (config.state.num_inputs % config.state.attributes_per_vertex != 0) if (config.state.num_inputs % config.state.attributes_per_vertex != 0)
return boost::none; return {};
switch (config.state.num_inputs / config.state.attributes_per_vertex) { switch (config.state.num_inputs / config.state.attributes_per_vertex) {
case 1: case 1:
@ -1850,7 +1849,7 @@ boost::optional<std::string> GenerateGeometryShader(const Pica::Shader::ShaderSe
out += "layout(triangles_adjacency) in;\n"; out += "layout(triangles_adjacency) in;\n";
break; break;
default: default:
return boost::none; return {};
} }
out += "layout(triangle_strip, max_vertices = 30) out;\n\n"; out += "layout(triangle_strip, max_vertices = 30) out;\n\n";
@ -1879,9 +1878,9 @@ boost::optional<std::string> GenerateGeometryShader(const Pica::Shader::ShaderSe
get_output_reg, config.state.sanitize_mul, true); get_output_reg, config.state.sanitize_mul, true);
if (!program_source_opt) if (!program_source_opt)
return boost::none; return {};
std::string& program_source = program_source_opt.get(); std::string& program_source = *program_source_opt;
out += R"( out += R"(
Vertex output_buffer; Vertex output_buffer;

View file

@ -7,9 +7,9 @@
#include <array> #include <array>
#include <cstring> #include <cstring>
#include <functional> #include <functional>
#include <optional>
#include <string> #include <string>
#include <type_traits> #include <type_traits>
#include <boost/optional.hpp>
#include "common/hash.h" #include "common/hash.h"
#include "video_core/regs.h" #include "video_core/regs.h"
#include "video_core/shader/shader.h" #include "video_core/shader/shader.h"
@ -228,9 +228,8 @@ std::string GenerateTrivialVertexShader(bool separable_shader);
* Generates the GLSL vertex shader program source code for the given VS program * Generates the GLSL vertex shader program source code for the given VS program
* @returns String of the shader source code; boost::none on failure * @returns String of the shader source code; boost::none on failure
*/ */
boost::optional<std::string> GenerateVertexShader(const Pica::Shader::ShaderSetup& setup, std::optional<std::string> GenerateVertexShader(const Pica::Shader::ShaderSetup& setup,
const PicaVSConfig& config, const PicaVSConfig& config, bool separable_shader);
bool separable_shader);
/* /*
* Generates the GLSL fixed geometry shader program source code for non-GS PICA pipeline * Generates the GLSL fixed geometry shader program source code for non-GS PICA pipeline
@ -243,7 +242,7 @@ std::string GenerateFixedGeometryShader(const PicaFixedGSConfig& config, bool se
* configuration * configuration
* @returns String of the shader source code; boost::none on failure * @returns String of the shader source code; boost::none on failure
*/ */
boost::optional<std::string> GenerateGeometryShader(const Pica::Shader::ShaderSetup& setup, std::optional<std::string> GenerateGeometryShader(const Pica::Shader::ShaderSetup& setup,
const PicaGSConfig& config, const PicaGSConfig& config,
bool separable_shader); bool separable_shader);

View file

@ -162,7 +162,7 @@ private:
// program buffer from the previous shader, which is hashed into the config, resulting several // program buffer from the previous shader, which is hashed into the config, resulting several
// different config values from the same shader program. // different config values from the same shader program.
template <typename KeyConfigType, template <typename KeyConfigType,
boost::optional<std::string> (*CodeGenerator)(const Pica::Shader::ShaderSetup&, std::optional<std::string> (*CodeGenerator)(const Pica::Shader::ShaderSetup&,
const KeyConfigType&, bool), const KeyConfigType&, bool),
GLenum ShaderType> GLenum ShaderType>
class ShaderDoubleCache { class ShaderDoubleCache {
@ -177,7 +177,7 @@ public:
return 0; return 0;
} }
std::string& program = program_opt.get(); std::string& program = *program_opt;
auto [iter, new_shader] = shader_cache.emplace(program, OGLShaderStage{separable}); auto [iter, new_shader] = shader_cache.emplace(program, OGLShaderStage{separable});
OGLShaderStage& cached_shader = iter->second; OGLShaderStage& cached_shader = iter->second;
if (new_shader) { if (new_shader) {

View file

@ -600,6 +600,7 @@ void JitShader::Compile_BREAKC(Instruction instr) {
Compile_Assert(looping, "BREAKC must be inside a LOOP"); Compile_Assert(looping, "BREAKC must be inside a LOOP");
if (looping) { if (looping) {
Compile_EvaluateCondition(instr); Compile_EvaluateCondition(instr);
ASSERT(loop_break_label);
jnz(*loop_break_label); jnz(*loop_break_label);
} }
} }
@ -754,7 +755,7 @@ void JitShader::Compile_LOOP(Instruction instr) {
sub(LOOPCOUNT, 1); // Increment loop count by 1 sub(LOOPCOUNT, 1); // Increment loop count by 1
jnz(l_loop_start); // Loop if not equal jnz(l_loop_start); // Loop if not equal
L(*loop_break_label); L(*loop_break_label);
loop_break_label = boost::none; loop_break_label.reset();
looping = false; looping = false;
} }

View file

@ -6,9 +6,9 @@
#include <array> #include <array>
#include <cstddef> #include <cstddef>
#include <optional>
#include <utility> #include <utility>
#include <vector> #include <vector>
#include <boost/optional.hpp>
#include <nihstro/shader_bytecode.h> #include <nihstro/shader_bytecode.h>
#include <xbyak.h> #include <xbyak.h>
#include "common/bit_set.h" #include "common/bit_set.h"
@ -123,7 +123,7 @@ private:
/// Label pointing to the end of the current LOOP block. Used by the BREAKC instruction to break /// Label pointing to the end of the current LOOP block. Used by the BREAKC instruction to break
/// out of the loop. /// out of the loop.
boost::optional<Xbyak::Label> loop_break_label; std::optional<Xbyak::Label> loop_break_label;
/// Offsets in code where a return needs to be inserted /// Offsets in code where a return needs to be inserted
std::vector<unsigned> return_offsets; std::vector<unsigned> return_offsets;