fabi/Xenia-Canary
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Cleaning up asserts and file/line macros.

Browse Source
This commit is contained in:
Ben Vanik
2014-07-12 16:51:52 -07:00
parent 840357413c
commit bf882714d0
92 changed files with 636 additions and 613 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
src/xenia/apu/audio_system.cc
View File

@@ -82,7 +82,7 @@ void AudioSystem::ThreadStart() {
auto result = WaitForMultipleObjectsEx(maximum_client_count_, client_wait_handles_, FALSE, INFINITE, FALSE);
if (result == WAIT_FAILED) {
DWORD err = GetLastError();
XEASSERTALWAYS();
assert_always();
break;
}
@@ -131,7 +131,7 @@ void AudioSystem::Shutdown() {
X_STATUS AudioSystem::RegisterClient(
uint32_t callback, uint32_t callback_arg, size_t* out_index) {
XEASSERTTRUE(unused_clients_.size());
assert_true(unused_clients_.size());
xe_mutex_lock(lock_);
auto index = unused_clients_.front();
@@ -143,7 +143,7 @@ X_STATUS AudioSystem::RegisterClient(
if (XFAILED(result)) {
return result;
}
XEASSERTNOTNULL(driver != NULL);
assert_not_null(driver);
unused_clients_.pop();
@@ -165,8 +165,8 @@ void AudioSystem::SubmitFrame(size_t index, uint32_t samples_ptr) {
SCOPE_profile_cpu_f("apu");
xe_mutex_lock(lock_);
XEASSERTTRUE(index < maximum_client_count_);
XEASSERTTRUE(clients_[index].driver != NULL);
assert_true(index < maximum_client_count_);
assert_true(clients_[index].driver != NULL);
(clients_[index].driver)->SubmitFrame(samples_ptr);
ResetEvent(client_wait_handles_[index]);
xe_mutex_unlock(lock_);
@@ -176,7 +176,7 @@ void AudioSystem::UnregisterClient(size_t index) {
SCOPE_profile_cpu_f("apu");
xe_mutex_lock(lock_);
XEASSERTTRUE(index < maximum_client_count_);
assert_true(index < maximum_client_count_);
DestroyDriver(clients_[index].driver);
clients_[index] = { 0 };
unused_clients_.push(index);
@@ -199,4 +199,4 @@ void AudioSystem::WriteRegister(uint64_t addr, uint64_t value) {
uint32_t r = addr & 0xFFFF;
XELOGAPU("WriteRegister(%.4X, %.8X)", r, value);
// 1804h is written to with 0x02000000 and 0x03000000 around a lock operation
}
}

2
src/xenia/apu/nop/nop_audio_system.cc
View File

@@ -29,5 +29,5 @@ X_STATUS NopAudioSystem::CreateDriver(size_t index, HANDLE wait_handle, AudioDri
}
void NopAudioSystem::DestroyDriver(AudioDriver* driver) {
XEASSERTALWAYS();
assert_always();
}

10
src/xenia/apu/xaudio2/xaudio2_audio_driver.cc
View File

@@ -67,7 +67,7 @@ void XAudio2AudioDriver::Initialize() {
hr = XAudio2Create(&audio_, 0, XAUDIO2_DEFAULT_PROCESSOR);
if (FAILED(hr)) {
XELOGE("XAudio2Create failed with %.8X", hr);
XEASSERTALWAYS();
assert_always();
return;
}
@@ -83,7 +83,7 @@ void XAudio2AudioDriver::Initialize() {
hr = audio_->CreateMasteringVoice(&mastering_voice_);
if (FAILED(hr)) {
XELOGE("CreateMasteringVoice failed with %.8X", hr);
XEASSERTALWAYS();
assert_always();
return;
}
@@ -106,14 +106,14 @@ void XAudio2AudioDriver::Initialize() {
voice_callback_);
if (FAILED(hr)) {
XELOGE("CreateSourceVoice failed with %.8X", hr);
XEASSERTALWAYS();
assert_always();
return;
}
hr = pcm_voice_->Start();
if (FAILED(hr)) {
XELOGE("Start failed with %.8X", hr);
XEASSERTALWAYS();
assert_always();
return;
}
@@ -148,7 +148,7 @@ void XAudio2AudioDriver::SubmitFrame(uint32_t frame_ptr) {
hr = pcm_voice_->SubmitSourceBuffer(&buffer);
if (FAILED(hr)) {
XELOGE("SubmitSourceBuffer failed with %.8X", hr);
XEASSERTALWAYS();
assert_always();
return;
}
}

6
src/xenia/apu/xaudio2/xaudio2_audio_system.cc
View File

@@ -31,7 +31,7 @@ void XAudio2AudioSystem::Initialize() {
}
X_STATUS XAudio2AudioSystem::CreateDriver(size_t index, HANDLE wait, AudioDriver** out_driver) {
XEASSERTNOTNULL(out_driver);
assert_not_null(out_driver);
auto driver = new XAudio2AudioDriver(emulator_, wait);
driver->Initialize();
*out_driver = driver;
@@ -39,9 +39,9 @@ X_STATUS XAudio2AudioSystem::CreateDriver(size_t index, HANDLE wait, AudioDriver
}
void XAudio2AudioSystem::DestroyDriver(AudioDriver* driver) {
XEASSERTNOTNULL(driver);
assert_not_null(driver);
auto xdriver = static_cast<XAudio2AudioDriver*>(driver);
xdriver->Shutdown();
XEASSERTNOTNULL(xdriver);
assert_not_null(xdriver);
delete xdriver;
}

74
src/xenia/assert.h
View File

@@ -1,74 +0,0 @@
/**
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2013 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
#ifndef XENIA_ASSERT_H_
#define XENIA_ASSERT_H_
#include <assert.h>
#include <xenia/assert.h>
#include <xenia/config.h>
#include <xenia/platform.h>
#include <xenia/string.h>
#include <xenia/types.h>
#if 0 && XE_COMPILER_MSVC && defined(UNICODE) && UNICODE
// http://msdn.microsoft.com/en-us/library/b0084kay.aspx
#if !defined(__WFILE__)
#define WIDEN2(x) L##x
#define WIDEN(x) WIDEN2(x)
#define __WFILE__ WIDEN(__FILE__)
#define __WFUNCTION__ WIDEN(__FUNCTION__)
#endif
#define XE_CURRENT_FILE __WFILE__
#define XE_CURRENT_FUNCTION __WFUNCTION__
#else
#define XE_CURRENT_FILE __FILE__
#define XE_CURRENT_FUNCTION __FUNCTION__
#endif // MSVC
#define XE_CURRENT_LINE __LINE__
#define __XE_ASSERT(expr) assert(expr)
#if XE_OPTION_ENABLE_ASSERTS
#define XEASSERTCORE(expr) __XE_ASSERT(expr)
#else
#define XEASSERTCORE(expr) XE_EMPTY_MACRO
#endif // ENABLE_ASSERTS
#define XEASSERTALWAYS() XEASSERTCORE( 0 )
#define XEASSERT(expr) XEASSERTCORE( (expr) )
#define XEASSERTTRUE(expr) XEASSERTCORE( (expr) )
#define XEASSERTFALSE(expr) XEASSERTCORE(!(expr) )
#define XEASSERTZERO(expr) XEASSERTCORE( (expr) == 0 )
#define XEASSERTNOTZERO(expr) XEASSERTCORE( (expr) != 0 )
#define XEASSERTNULL(expr) XEASSERTCORE( (expr) == NULL )
#define XEASSERTNOTNULL(expr) XEASSERTCORE( (expr) != NULL )
#define XEASSERTUNHANDLEDCASE(var) XEASSERTALWAYS()
#if XE_COMPILER_MSVC
// http://msdn.microsoft.com/en-us/library/bb918086.aspx
// TODO(benvanik): if 2010+, use static_assert?
// http://msdn.microsoft.com/en-us/library/dd293588.aspx
#define XESTATICASSERT(expr, message) _STATIC_ASSERT(expr)
//#elif XE_COMPILER_GNUC
// http://stackoverflow.com/questions/3385515/static-assert-in-c
//#define XESTATICASSERT(expr, message) ({ extern int __attribute__((error("assertion failure: '" #expr "' not true - " #message))) compile_time_check(); ((expr)?0:compile_time_check()),0; })
#else
// http://stackoverflow.com/questions/3385515/static-assert-in-c
#define XESTATICASSERT3(expr, L) typedef char static_assertion_##L[(expr)?1:-1]
#define XESTATICASSERT2(expr, L) XESTATICASSERT3(expr, L)
#define XESTATICASSERT(expr, message) XESTATICASSERT2(expr, __LINE__)
#endif // MSVC
#define XEASSERTSTRUCTSIZE(target, size) XESTATICASSERT(sizeof(target) == size, "bad definition for " ## target ## ": must be " ## size ## " bytes")
#endif // XENIA_ASSERT_H_

1
src/xenia/atomic.h
View File

@@ -13,6 +13,7 @@
#include <cstdint>
#include <xenia/platform.h>
#include <xenia/types.h>
// These functions are modeled off of the Apple OSAtomic routines

3
src/xenia/common.h
View File

@@ -10,7 +10,8 @@
#ifndef XENIA_COMMON_H_
#define XENIA_COMMON_H_
#include <xenia/assert.h>
#include <poly/assert.h>
#include <xenia/atomic.h>
#include <xenia/byte_order.h>
#include <xenia/config.h>

2
src/xenia/core/path_posix.cc
View File

@@ -12,5 +12,5 @@
const xechar_t* xe_path_get_tmp(const xechar_t* prefix) {
//
XEASSERTALWAYS();
assert_always();
}

4
src/xenia/core/path_win.cc
View File

@@ -11,7 +11,7 @@
const xechar_t* xe_path_get_tmp(const xechar_t* prefix) {
//
XEASSERTALWAYS();
//
assert_always();
return NULL;
}

4
src/xenia/cpu/processor.cc
View File

@@ -68,7 +68,7 @@ Processor::~Processor() {
}
int Processor::Setup() {
XEASSERTNULL(runtime_);
assert_null(runtime_);
runtime_ = new XenonRuntime(memory_, export_resolver_);
if (!runtime_) {
@@ -127,7 +127,7 @@ uint64_t Processor::Execute(
SCOPE_profile_cpu_f("cpu");
PPCContext* context = thread_state->context();
XEASSERT(arg_count <= 5);
assert_true(arg_count <= 5);
for (size_t i = 0; i < arg_count; ++i) {
context->r[3 + i] = args[i];
}

20
src/xenia/cpu/xenon_memory.cc
View File

@@ -174,7 +174,7 @@ LONG CALLBACK CheckMMIOHandler(PEXCEPTION_POINTERS ex_info) {
auto action = ex_info->ExceptionRecord->ExceptionInformation[0];
if (action == 0) {
uint64_t value = range.read(range.context, address & 0xFFFFFFFF);
XEASSERT((disasm.Argument1.ArgType & BE::REGISTER_TYPE) ==
assert_true((disasm.Argument1.ArgType & BE::REGISTER_TYPE) ==
BE::REGISTER_TYPE);
uint64_t* reg_ptr = GetContextRegPtr(disasm.Argument1.ArgType,
ex_info->ContextRecord);
@@ -203,7 +203,7 @@ LONG CALLBACK CheckMMIOHandler(PEXCEPTION_POINTERS ex_info) {
} else if ((disasm.Argument2.ArgType & BE::CONSTANT_TYPE) == BE::CONSTANT_TYPE) {
value = disasm.Instruction.Immediat;
} else {
XEASSERTALWAYS();
assert_always();
}
switch (disasm.Argument2.ArgSize) {
case 8:
@@ -290,7 +290,7 @@ int XenonMemory::Initialize() {
NULL);
if (!mapping_) {
XELOGE("Unable to reserve the 4gb guest address space.");
XEASSERTNOTNULL(mapping_);
assert_not_null(mapping_);
XEFAIL();
}
@@ -306,7 +306,7 @@ int XenonMemory::Initialize() {
}
if (!mapping_base_) {
XELOGE("Unable to find a continuous block in the 64bit address space.");
XEASSERTALWAYS();
assert_always();
XEFAIL();
}
membase_ = mapping_base_;
@@ -362,7 +362,7 @@ int XenonMemory::MapViews(uint8_t* mapping_base) {
0xC0000000, 0xDFFFFFFF, 0x00000000, // - physical 16mb pages
0xE0000000, 0xFFFFFFFF, 0x00000000, // - physical 4k pages
};
XEASSERT(XECOUNT(map_info) == XECOUNT(views_.all_views));
assert_true(XECOUNT(map_info) == XECOUNT(views_.all_views));
for (size_t n = 0; n < XECOUNT(map_info); n++) {
views_.all_views[n] = (uint8_t*)MapViewOfFileEx(
mapping_,
@@ -398,14 +398,14 @@ bool XenonMemory::AddMappedRange(uint64_t address, uint64_t mask,
protect = PAGE_READONLY;
} else {
// Write-only memory is not supported.
XEASSERTALWAYS();
assert_always();
}
if (!VirtualAlloc(Translate(address),
size,
MEM_COMMIT, protect)) {
return false;
}
XEASSERT(g_mapped_range_count_ + 1 < XECOUNT(g_mapped_ranges_));
assert_true(g_mapped_range_count_ + 1 < XECOUNT(g_mapped_ranges_));
g_mapped_ranges_[g_mapped_range_count_++] = {
reinterpret_cast<uint64_t>(mapping_base_) | address,
0xFFFFFFFF00000000 | mask,
@@ -518,13 +518,13 @@ uint64_t XenonMemory::HeapAlloc(
if (base_address >= XENON_MEMORY_VIRTUAL_HEAP_LOW &&
base_address < XENON_MEMORY_VIRTUAL_HEAP_HIGH) {
// Overlapping managed heap.
XEASSERTALWAYS();
assert_always();
return 0;
}
if (base_address >= XENON_MEMORY_PHYSICAL_HEAP_LOW &&
base_address < XENON_MEMORY_PHYSICAL_HEAP_HIGH) {
// Overlapping managed heap.
XEASSERTALWAYS();
assert_always();
return 0;
}
@@ -534,7 +534,7 @@ uint64_t XenonMemory::HeapAlloc(
void* pv = VirtualAlloc(p, size, MEM_COMMIT, PAGE_READWRITE);
if (!pv) {
// Failed.
XEASSERTALWAYS();
assert_always();
return 0;
}

2
src/xenia/cpu/xenon_thread_state.cc
View File

@@ -32,7 +32,7 @@ XenonThreadState::XenonThreadState(
// Allocate with 64b alignment.
context_ = (PPCContext*)xe_malloc_aligned(sizeof(PPCContext));
XEASSERT(((uint64_t)context_ & 0xF) == 0);
assert_true(((uint64_t)context_ & 0xF) == 0);
xe_zero_struct(context_, sizeof(PPCContext));
// Stash pointers to common structures that callbacks may need.

2
src/xenia/emulator.cc
View File

@@ -127,7 +127,7 @@ XECLEANUP:
}
void Emulator::set_main_window(Window* window) {
XEASSERTNULL(main_window_);
assert_null(main_window_);
main_window_ = window;
window->closed.AddListener([](UIEvent& e) {

6
src/xenia/export_resolver.cc
View File

@@ -78,7 +78,7 @@ KernelExport* ExportResolver::GetExportByOrdinal(const char* library_name,
KernelExport* ExportResolver::GetExportByName(const char* library_name,
const char* name) {
// TODO(benvanik): lookup by name.
XEASSERTALWAYS();
assert_always();
return NULL;
}
@@ -86,7 +86,7 @@ void ExportResolver::SetVariableMapping(const char* library_name,
const uint32_t ordinal,
uint32_t value) {
KernelExport* kernel_export = GetExportByOrdinal(library_name, ordinal);
XEASSERTNOTNULL(kernel_export);
assert_not_null(kernel_export);
kernel_export->is_implemented = true;
kernel_export->variable_ptr = value;
}
@@ -96,7 +96,7 @@ void ExportResolver::SetFunctionMapping(
void* shim_data, xe_kernel_export_shim_fn shim,
xe_kernel_export_impl_fn impl) {
KernelExport* kernel_export = GetExportByOrdinal(library_name, ordinal);
XEASSERTNOTNULL(kernel_export);
assert_not_null(kernel_export);
kernel_export->is_implemented = true;
kernel_export->function_data.shim_data = shim_data;
kernel_export->function_data.shim = shim;

26
src/xenia/gpu/command_processor.cc
View File

@@ -144,10 +144,10 @@ void CommandProcessor::ExecutePrimaryBuffer(
uint32_t n = 0;
while (args.ptr != end_ptr) {
n += ExecutePacket(args);
XEASSERT(args.ptr < args.max_address);
assert_true(args.ptr < args.max_address);
}
if (end_index > start_index) {
XEASSERT(n == (end_index - start_index));
assert_true(n == (end_index - start_index));
}
XETRACECP(" ExecutePrimaryBuffer End");
@@ -164,7 +164,7 @@ void CommandProcessor::ExecuteIndirectBuffer(uint32_t ptr, uint32_t length) {
args.ptr_mask = 0;
for (uint32_t n = 0; n < length;) {
n += ExecutePacket(args);
XEASSERT(n <= length);
assert_true(n <= length);
}
XETRACECP(" ExecuteIndirectBuffer End");
@@ -343,7 +343,7 @@ uint32_t CommandProcessor::ExecutePacket(PacketArgs& args) {
value = GpuSwap(value, endianness);
} else {
// Register.
XEASSERT(poll_reg_addr < RegisterFile::kRegisterCount);
assert_true(poll_reg_addr < RegisterFile::kRegisterCount);
value = regs->values[poll_reg_addr].u32;
if (poll_reg_addr == XE_GPU_REG_COHER_STATUS_HOST) {
MakeCoherent();
@@ -438,7 +438,7 @@ uint32_t CommandProcessor::ExecutePacket(PacketArgs& args) {
value = GpuSwap(value, endianness);
} else {
// Register.
XEASSERT(poll_reg_addr < RegisterFile::kRegisterCount);
assert_true(poll_reg_addr < RegisterFile::kRegisterCount);
value = regs->values[poll_reg_addr].u32;
}
bool matched = false;
@@ -496,7 +496,7 @@ uint32_t CommandProcessor::ExecutePacket(PacketArgs& args) {
// Just an event flag? Where does this write?
} else {
// Write to an address.
XEASSERTALWAYS();
assert_always();
ADVANCE_PTR(count - 1);
}
}
@@ -564,7 +564,7 @@ uint32_t CommandProcessor::ExecutePacket(PacketArgs& args) {
draw_command_.index_buffer = nullptr;
} else {
// Unknown source select.
XEASSERTALWAYS();
assert_always();
}
driver_->Draw(draw_command_);
} else {
@@ -584,7 +584,7 @@ uint32_t CommandProcessor::ExecutePacket(PacketArgs& args) {
uint32_t index_count = d0 >> 16;
uint32_t prim_type = d0 & 0x3F;
uint32_t src_sel = (d0 >> 6) & 0x3;
XEASSERT(src_sel == 0x2); // 'SrcSel=AutoIndex'
assert_true(src_sel == 0x2); // 'SrcSel=AutoIndex'
if (!driver_->PrepareDraw(draw_command_)) {
draw_command_.prim_type = (XE_GPU_PRIMITIVE_TYPE)prim_type;
draw_command_.start_index = 0;
@@ -619,7 +619,7 @@ uint32_t CommandProcessor::ExecutePacket(PacketArgs& args) {
}
break;
default:
XEASSERTALWAYS();
assert_always();
break;
}
}
@@ -660,7 +660,7 @@ uint32_t CommandProcessor::ExecutePacket(PacketArgs& args) {
uint32_t start_size = READ_PTR();
uint32_t start = start_size >> 16;
uint32_t size = start_size & 0xFFFF; // dwords
XEASSERT(start == 0);
assert_true(start == 0);
driver_->LoadShader((XE_GPU_SHADER_TYPE)type,
GpuToCpu(packet_ptr, addr), size * 4, start);
}
@@ -675,9 +675,9 @@ uint32_t CommandProcessor::ExecutePacket(PacketArgs& args) {
uint32_t start_size = READ_PTR();
uint32_t start = start_size >> 16;
uint32_t size = start_size & 0xFFFF; // dwords
XEASSERT(start == 0);
assert_true(start == 0);
// TODO(benvanik): figure out if this could wrap.
XEASSERT(args.ptr + size * 4 < args.max_address);
assert_true(args.ptr + size * 4 < args.max_address);
driver_->LoadShader((XE_GPU_SHADER_TYPE)type,
args.ptr, size * 4, start);
ADVANCE_PTR(size);
@@ -751,7 +751,7 @@ uint32_t CommandProcessor::ExecutePacket(PacketArgs& args) {
void CommandProcessor::WriteRegister(
uint32_t packet_ptr, uint32_t index, uint32_t value) {
RegisterFile* regs = driver_->register_file();
XEASSERT(index < RegisterFile::kRegisterCount);
assert_true(index < RegisterFile::kRegisterCount);
regs->values[index].u32 = value;
// If this is a COHER register, set the dirty flag.

2
src/xenia/gpu/d3d11/d3d11_buffer_resource.cc
View File

@@ -53,7 +53,7 @@ int D3D11IndexBufferResource::InvalidateRegion(
SCOPE_profile_cpu_f("gpu");
// All that's done so far:
XEASSERT(info_.endianness == 0x2);
assert_true(info_.endianness == 0x2);
D3D11_MAPPED_SUBRESOURCE res;
HRESULT hr = resource_cache_->context()->Map(

10
src/xenia/gpu/d3d11/d3d11_graphics_system.cc
View File

@@ -33,8 +33,8 @@ D3D11GraphicsSystem::~D3D11GraphicsSystem() {
void D3D11GraphicsSystem::Initialize() {
GraphicsSystem::Initialize();
XEASSERTNULL(timer_queue_);
XEASSERTNULL(vsync_timer_);
assert_null(timer_queue_);
assert_null(vsync_timer_);
timer_queue_ = CreateTimerQueue();
CreateTimerQueueTimer(
@@ -111,7 +111,7 @@ void D3D11GraphicsSystem::Initialize() {
// Create the window.
// This will pump through the run-loop and and be where our swapping
// will take place.
XEASSERTNULL(window_);
assert_null(window_);
window_ = new D3D11Window(run_loop_, dxgi_factory_, device_);
if (window_->Initialize("Xenia D3D11", 1280, 720)) {
XELOGE("Failed to create D3D11Window");
@@ -126,7 +126,7 @@ void D3D11GraphicsSystem::Initialize() {
// Create the driver.
// This runs in the worker thread and builds command lines to present
// in the window.
XEASSERTNULL(driver_);
assert_null(driver_);
driver_ = new D3D11GraphicsDriver(
memory_, window_->swap_chain(), device_);
if (driver_->Initialize()) {
@@ -180,7 +180,7 @@ void __stdcall D3D11GraphicsSystem::VsyncCallback(D3D11GraphicsSystem* gs,
void D3D11GraphicsSystem::Shutdown() {
GraphicsSystem::Shutdown();
if (vsync_timer_) {
DeleteTimerQueueTimer(timer_queue_, vsync_timer_, NULL);
}

12
src/xenia/gpu/d3d11/d3d11_profiler_display.cc
View File

@@ -140,7 +140,7 @@ D3D11ProfilerDisplay::D3D11ProfilerDisplay(D3D11Window* window) : window_(window
!SetupShaders() ||
!SetupFont()) {
// Hrm.
XEASSERTALWAYS();
assert_always();
}
// Pass through mouse events.
@@ -183,7 +183,7 @@ bool D3D11ProfilerDisplay::SetupState() {
blend_desc.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_ZERO;
blend_desc.RenderTarget[0].RenderTargetWriteMask = 0x0F;
hr = device->CreateBlendState(&blend_desc, &blend_state_);
XEASSERT(SUCCEEDED(hr));
assert_true(SUCCEEDED(hr));
D3D11_DEPTH_STENCIL_DESC depth_stencil_desc;
xe_zero_struct(&depth_stencil_desc, sizeof(depth_stencil_desc));
@@ -191,7 +191,7 @@ bool D3D11ProfilerDisplay::SetupState() {
depth_stencil_desc.StencilEnable = false;
depth_stencil_desc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ZERO;
hr = device->CreateDepthStencilState(&depth_stencil_desc, &depth_stencil_state_);
XEASSERT(SUCCEEDED(hr));
assert_true(SUCCEEDED(hr));
return true;
}
@@ -484,7 +484,7 @@ D3D11ProfilerDisplay::Vertex* D3D11ProfilerDisplay::AllocateVertices(
if (draw_state_.vertex_index + count > XECOUNT(draw_state_.vertex_buffer)) {
Flush();
}
XEASSERT(draw_state_.vertex_index + count <= XECOUNT(draw_state_.vertex_buffer));
assert_true(draw_state_.vertex_index + count <= XECOUNT(draw_state_.vertex_buffer));
size_t head = draw_state_.vertex_index;
draw_state_.vertex_index += count;
@@ -493,7 +493,7 @@ D3D11ProfilerDisplay::Vertex* D3D11ProfilerDisplay::AllocateVertices(
draw_state_.commands[draw_state_.command_index - 1].primitive == primitive) {
draw_state_.commands[draw_state_.command_index - 1].vertex_count += count;
} else {
XEASSERT(draw_state_.command_index < XECOUNT(draw_state_.commands));
assert_true(draw_state_.command_index < XECOUNT(draw_state_.commands));
draw_state_.commands[draw_state_.command_index].primitive = primitive;
draw_state_.commands[draw_state_.command_index].vertex_count = count;
++draw_state_.command_index;
@@ -511,7 +511,7 @@ void D3D11ProfilerDisplay::Flush() {
context->Map(vertex_buffer_, 0, D3D11_MAP_WRITE_DISCARD, 0, &res);
memcpy(res.pData, draw_state_.vertex_buffer, sizeof(Vertex) * draw_state_.vertex_index);
context->Unmap(vertex_buffer_, 0);
uint32_t stride = 20;
uint32_t offset = 0;
context->IASetVertexBuffers(0, 1, &vertex_buffer_, &stride, &offset);

4
src/xenia/gpu/d3d11/d3d11_shader_resource.cc
View File

@@ -252,7 +252,7 @@ int D3D11VertexShaderResource::CreateInputLayout(const void* byte_code,
vtx_format = DXGI_FORMAT_R32G32B32A32_FLOAT;
break;
default:
XEASSERTALWAYS();
assert_always();
break;
}
element_descs[el_index].SemanticName = "XE_VF";
@@ -299,7 +299,7 @@ int D3D11VertexShaderResource::DemandGeometryShader(
shader = new D3D11QuadListGeometryShader(device);
break;
default:
XEASSERTALWAYS();
assert_always();
return 1;
}
if (!shader) {

12
src/xenia/gpu/d3d11/d3d11_shader_translator.cc
View File

@@ -58,7 +58,7 @@ const char* GetFormatTypeName(const VertexBufferResource::DeclElement& el) {
return "float4";
default:
XELOGE("Unknown vertex format: %d", el.format);
XEASSERTALWAYS();
assert_always();
return "float4";
}
}
@@ -141,7 +141,7 @@ int D3D11ShaderTranslator::TranslateVertexShader(
append(
"struct VS_OUTPUT {\n");
if (alloc_counts.positions) {
XEASSERT(alloc_counts.positions == 1);
assert_true(alloc_counts.positions == 1);
append(
" float4 oPos : SV_POSITION;\n");
}
@@ -244,7 +244,7 @@ int D3D11ShaderTranslator::TranslatePixelShader(
append(
"struct VS_OUTPUT {\n");
if (alloc_counts.positions) {
XEASSERT(alloc_counts.positions == 1);
assert_true(alloc_counts.positions == 1);
append(
" float4 oPos : SV_POSITION;\n");
}
@@ -417,7 +417,7 @@ void D3D11ShaderTranslator::AppendDestRegName(uint32_t num, uint32_t dst_exp) {
default:
// TODO(benvanik): other render targets?
// TODO(benvanik): depth?
XEASSERTALWAYS();
assert_always();
break;
}
break;
@@ -1272,7 +1272,7 @@ int D3D11ShaderTranslator::GetFormatComponentCount(uint32_t format) {
return 4;
default:
XELOGE("Unknown vertex format: %d", format);
XEASSERTALWAYS();
assert_always();
return 4;
}
}
@@ -1348,7 +1348,7 @@ int D3D11ShaderTranslator::TranslateExec(const instr_cf_exec_t& cf) {
case TEX_SET_GRADIENTS_H:
case TEX_SET_GRADIENTS_V:
default:
XEASSERTALWAYS();
assert_always();
break;
}
} else {

4
src/xenia/gpu/d3d11/d3d11_texture_resource.cc
View File

@@ -136,13 +136,13 @@ int D3D11TextureResource::CreateHandle2D() {
int D3D11TextureResource::CreateHandle3D() {
XELOGE("D3D11: CreateTexture3D not yet implemented");
XEASSERTALWAYS();
assert_always();
return 1;
}
int D3D11TextureResource::CreateHandleCube() {
XELOGE("D3D11: CreateTextureCube not yet implemented");
XEASSERTALWAYS();
assert_always();
return 1;
}

12
src/xenia/gpu/graphics_driver.cc
View File

@@ -157,7 +157,7 @@ int GraphicsDriver::PopulateShaders(DrawCommand& command) {
XELOGE("No pixel shader bound; ignoring");
return 1;
}
xe_gpu_program_cntl_t program_cntl;
program_cntl.dword_0 = register_file_[XE_GPU_REG_SQ_PROGRAM_CNTL].u32;
if (!vertex_shader_->is_prepared()) {
@@ -181,7 +181,7 @@ int GraphicsDriver::PopulateShaders(DrawCommand& command) {
int GraphicsDriver::PopulateInputAssembly(DrawCommand& command) {
SCOPE_profile_cpu_f("gpu");
const auto& buffer_inputs = command.vertex_shader->buffer_inputs();
command.vertex_buffer_count = buffer_inputs.count;
for (size_t n = 0; n < buffer_inputs.count; n++) {
@@ -201,10 +201,10 @@ int GraphicsDriver::PopulateInputAssembly(DrawCommand& command) {
fetch = &group->vertex_fetch_2;
break;
}
XEASSERTNOTNULL(fetch);
assert_not_null(fetch);
// If this assert doesn't hold, maybe we just abort?
XEASSERT(fetch->type == 0x3);
XEASSERTNOTZERO(fetch->size);
assert_true(fetch->type == 0x3);
assert_not_zero(fetch->size);
const auto& info = desc.info;
@@ -278,7 +278,7 @@ int GraphicsDriver::PopulateSamplerSet(
XELOGW("D3D11: unknown texture format %d", info.format);
return 0; // invalid texture used
}
// TODO(benvanik): quick validate without refetching intraframe.
// Fetch texture from the cache.
MemoryRange memory_range;

8
src/xenia/gpu/graphics_system.cc
View File

@@ -72,7 +72,7 @@ void GraphicsSystem::ThreadStart() {
// Initialize driver and ringbuffer.
Initialize();
XEASSERTNOTNULL(driver_);
assert_not_null(driver_);
SetEvent(thread_wait_);
// Main run loop.
@@ -128,7 +128,7 @@ void GraphicsSystem::InitializeRingBuffer(uint32_t ptr, uint32_t page_count) {
while (!driver_) {
Sleep(0);
}
XEASSERTNOTNULL(driver_);
assert_not_null(driver_);
command_processor_->Initialize(driver_, ptr, page_count);
}
@@ -154,7 +154,7 @@ uint64_t GraphicsSystem::ReadRegister(uint64_t addr) {
return 1;
}
XEASSERT(r >= 0 && r < RegisterFile::kRegisterCount);
assert_true(r >= 0 && r < RegisterFile::kRegisterCount);
return regs->values[r].u32;
}
@@ -175,7 +175,7 @@ void GraphicsSystem::WriteRegister(uint64_t addr, uint64_t value) {
break;
}
XEASSERT(r >= 0 && r < RegisterFile::kRegisterCount);
assert_true(r >= 0 && r < RegisterFile::kRegisterCount);
regs->values[r].u32 = (uint32_t)value;
}

6
src/xenia/gpu/nop/nop_graphics_system.cc
View File

@@ -40,11 +40,11 @@ NopGraphicsSystem::~NopGraphicsSystem() {
void NopGraphicsSystem::Initialize() {
GraphicsSystem::Initialize();
XEASSERTNULL(driver_);
assert_null(driver_);
driver_ = new NopGraphicsDriver(memory_);
XEASSERTNULL(timer_queue_);
XEASSERTNULL(vsync_timer_);
assert_null(timer_queue_);
assert_null(vsync_timer_);
timer_queue_ = CreateTimerQueue();
CreateTimerQueueTimer(

18
src/xenia/gpu/shader_resource.cc
View File

@@ -29,7 +29,7 @@ ShaderResource::ShaderResource(const MemoryRange& memory_range,
// Verify.
dword_count_ = memory_range.length / 4;
XEASSERT(dword_count_ <= 512);
assert_true(dword_count_ <= 512);
// Copy bytes and swap.
size_t byte_size = dword_count_ * sizeof(uint32_t);
@@ -122,7 +122,7 @@ void ShaderResource::GatherExec(const instr_cf_exec_t* cf) {
case TEX_SET_GRADIENTS_H:
case TEX_SET_GRADIENTS_V:
default:
XEASSERTALWAYS();
assert_always();
break;
}
} else {
@@ -145,7 +145,7 @@ void ShaderResource::GatherExec(const instr_cf_exec_t* cf) {
}
void ShaderResource::GatherVertexFetch(const instr_fetch_vtx_t* vtx) {
XEASSERT(type_ == XE_GPU_SHADER_TYPE_VERTEX);
assert_true(type_ == XE_GPU_SHADER_TYPE_VERTEX);
// dst_reg/dst_swiz
// src_reg/src_swiz
@@ -188,16 +188,16 @@ void ShaderResource::GatherVertexFetch(const instr_fetch_vtx_t* vtx) {
auto& desc = inputs.descs[n];
auto& info = desc.info;
if (desc.fetch_slot == fetch_slot) {
XEASSERT(info.element_count <= XECOUNT(info.elements));
assert_true(info.element_count <= XECOUNT(info.elements));
// It may not hold that all strides are equal, but I hope it does.
XEASSERT(!vtx->stride || info.stride_words == vtx->stride);
assert_true(!vtx->stride || info.stride_words == vtx->stride);
el = &info.elements[info.element_count++];
break;
}
}
if (!el) {
XEASSERTNOTZERO(vtx->stride);
XEASSERT(inputs.count + 1 < XECOUNT(inputs.descs));
assert_not_zero(vtx->stride);
assert_true(inputs.count + 1 < XECOUNT(inputs.descs));
auto& desc = inputs.descs[inputs.count++];
desc.input_index = inputs.count - 1;
desc.fetch_slot = fetch_slot;
@@ -243,7 +243,7 @@ void ShaderResource::GatherVertexFetch(const instr_fetch_vtx_t* vtx) {
break;
default:
XELOGE("Unknown vertex format: %d", el->format);
XEASSERTALWAYS();
assert_always();
break;
}
}
@@ -251,7 +251,7 @@ void ShaderResource::GatherVertexFetch(const instr_fetch_vtx_t* vtx) {
void ShaderResource::GatherTextureFetch(const xenos::instr_fetch_tex_t* tex) {
// TODO(benvanik): check dest_swiz to see if we are writing anything.
XEASSERT(sampler_inputs_.count + 1 < XECOUNT(sampler_inputs_.descs));
assert_true(sampler_inputs_.count + 1 < XECOUNT(sampler_inputs_.descs));
auto& input = sampler_inputs_.descs[sampler_inputs_.count++];
input.input_index = sampler_inputs_.count - 1;
input.fetch_slot = tex->const_idx & 0xF; // ?

4
src/xenia/kernel/fs/devices/disc_image_device.cc
View File

@@ -98,11 +98,11 @@ Entry* DiscImageDevice::ResolvePath(const char* path) {
}
X_STATUS DiscImageDevice::QueryVolume(XVolumeInfo* out_info, size_t length) {
XEASSERTALWAYS();
assert_always();
return X_STATUS_NOT_IMPLEMENTED;
}
X_STATUS DiscImageDevice::QueryFileSystemAttributes(XFileSystemAttributeInfo* out_info, size_t length) {
XEASSERTALWAYS();
assert_always();
return X_STATUS_NOT_IMPLEMENTED;
}

4
src/xenia/kernel/fs/devices/disc_image_entry.cc
View File

@@ -53,7 +53,7 @@ DiscImageEntry::~DiscImageEntry() {
}
X_STATUS DiscImageEntry::QueryInfo(XFileInfo* out_info) {
XEASSERTNOTNULL(out_info);
assert_not_null(out_info);
out_info->creation_time = 0;
out_info->last_access_time = 0;
out_info->last_write_time = 0;
@@ -66,7 +66,7 @@ X_STATUS DiscImageEntry::QueryInfo(XFileInfo* out_info) {
X_STATUS DiscImageEntry::QueryDirectory(
XDirectoryInfo* out_info, size_t length, const char* file_name, bool restart) {
XEASSERTNOTNULL(out_info);
assert_not_null(out_info);
if (restart == true && gdfx_entry_iterator_ != gdfx_entry_->children.end()) {
gdfx_entry_iterator_ = gdfx_entry_->children.end();

4
src/xenia/kernel/fs/devices/host_path_device.cc
View File

@@ -67,7 +67,7 @@ Entry* HostPathDevice::ResolvePath(const char* path) {
// TODO(gibbed): call into HostPathDevice?
X_STATUS HostPathDevice::QueryVolume(XVolumeInfo* out_info, size_t length) {
XEASSERTNOTNULL(out_info);
assert_not_null(out_info);
const char* name = "test"; // TODO(gibbed): actual value
auto end = (uint8_t*)out_info + length;
@@ -86,7 +86,7 @@ X_STATUS HostPathDevice::QueryVolume(XVolumeInfo* out_info, size_t length) {
// TODO(gibbed): call into HostPathDevice?
X_STATUS HostPathDevice::QueryFileSystemAttributes(XFileSystemAttributeInfo* out_info, size_t length) {
XEASSERTNOTNULL(out_info);
assert_not_null(out_info);
const char* name = "test"; // TODO(gibbed): actual value
auto end = (uint8_t*)out_info + length;

4
src/xenia/kernel/fs/devices/host_path_entry.cc
View File

@@ -54,7 +54,7 @@ HostPathEntry::~HostPathEntry() {
#define COMBINE_TIME(t) (((uint64_t)t.dwHighDateTime << 32) | t.dwLowDateTime)
X_STATUS HostPathEntry::QueryInfo(XFileInfo* out_info) {
XEASSERTNOTNULL(out_info);
assert_not_null(out_info);
WIN32_FILE_ATTRIBUTE_DATA data;
if (!GetFileAttributesEx(
@@ -75,7 +75,7 @@ X_STATUS HostPathEntry::QueryInfo(XFileInfo* out_info) {
X_STATUS HostPathEntry::QueryDirectory(
XDirectoryInfo* out_info, size_t length, const char* file_name, bool restart) {
XEASSERTNOTNULL(out_info);
assert_not_null(out_info);
WIN32_FIND_DATA ffd;

4
src/xenia/kernel/fs/devices/stfs_container_device.cc
View File

@@ -100,11 +100,11 @@ Entry* STFSContainerDevice::ResolvePath(const char* path) {
X_STATUS STFSContainerDevice::QueryVolume(XVolumeInfo* out_info, size_t length) {
XEASSERTALWAYS();
assert_always();
return X_STATUS_NOT_IMPLEMENTED;
}
X_STATUS STFSContainerDevice::QueryFileSystemAttributes(XFileSystemAttributeInfo* out_info, size_t length) {
XEASSERTALWAYS();
assert_always();
return X_STATUS_NOT_IMPLEMENTED;
}

4
src/xenia/kernel/fs/devices/stfs_container_entry.cc
View File

@@ -32,7 +32,7 @@ STFSContainerEntry::~STFSContainerEntry() {
}
X_STATUS STFSContainerEntry::QueryInfo(XFileInfo* out_info) {
XEASSERTNOTNULL(out_info);
assert_not_null(out_info);
out_info->creation_time = stfs_entry_->update_timestamp;
out_info->last_access_time = stfs_entry_->access_timestamp;
out_info->last_write_time = stfs_entry_->update_timestamp;
@@ -45,7 +45,7 @@ X_STATUS STFSContainerEntry::QueryInfo(XFileInfo* out_info) {
X_STATUS STFSContainerEntry::QueryDirectory(
XDirectoryInfo* out_info, size_t length, const char* file_name, bool restart) {
XEASSERTNOTNULL(out_info);
assert_not_null(out_info);
if (restart && stfs_entry_iterator_ != stfs_entry_->children.end()) {
stfs_entry_iterator_ = stfs_entry_->children.end();

2
src/xenia/kernel/fs/entry.cc
View File

@@ -26,7 +26,7 @@ MemoryMapping::~MemoryMapping() {
Entry::Entry(Type type, Device* device, const char* path) :
type_(type),
device_(device) {
XEASSERTNOTNULL(device);
assert_not_null(device);
path_ = xestrdupa(path);
// TODO(benvanik): *shudder*
absolute_path_ = xestrdupa((std::string(device->path()) + std::string(path)).c_str());

6
src/xenia/kernel/kernel_state.cc
View File

@@ -42,7 +42,7 @@ KernelState::KernelState(Emulator* emulator) :
object_table_ = new ObjectTable();
object_mutex_ = xe_mutex_alloc(10000);
XEASSERTNULL(shared_kernel_state_);
assert_null(shared_kernel_state_);
shared_kernel_state_ = this;
}
@@ -55,7 +55,7 @@ KernelState::~KernelState() {
delete dispatcher_;
XEASSERT(shared_kernel_state_ == this);
assert_true(shared_kernel_state_ == this);
shared_kernel_state_ = NULL;
}
@@ -81,7 +81,7 @@ XModule* KernelState::GetModule(const char* name) {
return NULL;
} else {
// TODO(benvanik): support user modules/loading/etc.
XEASSERTALWAYS();
assert_always();
return NULL;
}
}

8
src/xenia/kernel/object_table.cc
View File

@@ -22,7 +22,7 @@ ObjectTable::ObjectTable() :
table_(NULL),
last_free_entry_(0) {
table_mutex_ = xe_mutex_alloc(0);
XEASSERTNOTNULL(table_mutex_);
assert_not_null(table_mutex_);
}
ObjectTable::~ObjectTable() {
@@ -88,7 +88,7 @@ X_STATUS ObjectTable::FindFreeSlot(uint32_t* out_slot) {
}
X_STATUS ObjectTable::AddHandle(XObject* object, X_HANDLE* out_handle) {
XEASSERTNOTNULL(out_handle);
assert_not_null(out_handle);
X_STATUS result = X_STATUS_SUCCESS;
@@ -156,7 +156,7 @@ X_STATUS ObjectTable::RemoveHandle(X_HANDLE handle) {
}
X_STATUS ObjectTable::GetObject(X_HANDLE handle, XObject** out_object) {
XEASSERTNOTNULL(out_object);
assert_not_null(out_object);
X_STATUS result = X_STATUS_SUCCESS;
@@ -197,7 +197,7 @@ X_STATUS ObjectTable::GetObject(X_HANDLE handle, XObject** out_object) {
X_HANDLE ObjectTable::TranslateHandle(X_HANDLE handle) {
if (handle == 0xFFFFFFFF) {
// CurrentProcess
//XEASSERTALWAYS();
//assert_always();
return 0;
} else if (handle == 0xFFFFFFFE) {
// CurrentThread

6
src/xenia/kernel/objects/xevent.cc
View File

@@ -26,13 +26,13 @@ XEvent::~XEvent() {
}
void XEvent::Initialize(bool manual_reset, bool initial_state) {
XEASSERTNULL(handle_);
assert_null(handle_);
handle_ = CreateEvent(NULL, manual_reset, initial_state, NULL);
}
void XEvent::InitializeNative(void* native_ptr, DISPATCH_HEADER& header) {
XEASSERTNULL(handle_);
assert_null(handle_);
bool manual_reset;
switch (header.type_flags >> 24) {
@@ -43,7 +43,7 @@ void XEvent::InitializeNative(void* native_ptr, DISPATCH_HEADER& header) {
manual_reset = false;
break;
default:
XEASSERTALWAYS();
assert_always();
return;
}

6
src/xenia/kernel/objects/xfile.h
View File

@@ -81,7 +81,7 @@ public:
} while (info->next_entry_offset != 0);
}
};
XEASSERTSTRUCTSIZE(XDirectoryInfo, 72);
static_assert_size(XDirectoryInfo, 72);
// http://msdn.microsoft.com/en-us/library/windows/hardware/ff540287(v=vs.85).aspx
class XVolumeInfo {
@@ -102,7 +102,7 @@ public:
xe_copy_memory(dst + 20, this->label_length, this->label, this->label_length);
}
};
XEASSERTSTRUCTSIZE(XVolumeInfo, 24);
static_assert_size(XVolumeInfo, 24);
// http://msdn.microsoft.com/en-us/library/windows/hardware/ff540251(v=vs.85).aspx
class XFileSystemAttributeInfo {
@@ -121,7 +121,7 @@ public:
xe_copy_memory(dst + 12, this->fs_name_length, this->fs_name, this->fs_name_length);
}
};
XEASSERTSTRUCTSIZE(XFileSystemAttributeInfo, 16);
static_assert_size(XFileSystemAttributeInfo, 16);
class XFile : public XObject {
public:

8
src/xenia/kernel/objects/xmutant.cc
View File

@@ -26,22 +26,22 @@ XMutant::~XMutant() {
}
void XMutant::Initialize(bool initial_owner) {
XEASSERTNULL(handle_);
assert_null(handle_);
handle_ = CreateMutex(NULL, initial_owner ? TRUE : FALSE, NULL);
}
void XMutant::InitializeNative(void* native_ptr, DISPATCH_HEADER& header) {
XEASSERTNULL(handle_);
assert_null(handle_);
// Haven't seen this yet, but it's possible.
XEASSERTALWAYS();
assert_always();
}
X_STATUS XMutant::ReleaseMutant(
uint32_t priority_increment, bool abandon, bool wait) {
// TODO(benvanik): abandoning.
XEASSERTFALSE(abandon);
assert_false(abandon);
BOOL result = ReleaseMutex(handle_);
if (result) {
return X_STATUS_SUCCESS;

2
src/xenia/kernel/objects/xnotify_listener.cc
View File

@@ -28,7 +28,7 @@ XNotifyListener::~XNotifyListener() {
}
void XNotifyListener::Initialize(uint64_t mask) {
XEASSERTNULL(wait_handle_);
assert_null(wait_handle_);
lock_ = xe_mutex_alloc();
wait_handle_ = CreateEvent(NULL, TRUE, FALSE, NULL);

4
src/xenia/kernel/objects/xsemaphore.cc
View File

@@ -26,13 +26,13 @@ XSemaphore::~XSemaphore() {
}
void XSemaphore::Initialize(int32_t initial_count, int32_t maximum_count) {
XEASSERTNULL(handle_);
assert_null(handle_);
handle_ = CreateSemaphore(NULL, initial_count, maximum_count, NULL);
}
void XSemaphore::InitializeNative(void* native_ptr, DISPATCH_HEADER& header) {
XEASSERTNULL(handle_);
assert_null(handle_);
// NOT IMPLEMENTED
// We expect Initialize to be called shortly.

4
src/xenia/kernel/objects/xthread.cc
View File

@@ -334,7 +334,7 @@ X_STATUS XThread::PlatformCreate() {
this);
#else
// TODO(benvanik): pthread_create_suspended_np on linux
XEASSERTALWAYS();
assert_always();
#endif // OSX
} else {
result_code = pthread_create(
@@ -552,7 +552,7 @@ X_STATUS XThread::Delay(
if (timeout_ticks > 0) {
// Absolute time, based on January 1, 1601.
// TODO(benvanik): convert time to relative time.
XEASSERTALWAYS();
assert_always();
timeout_ms = 0;
} else if (timeout_ticks < 0) {
// Relative time.

6
src/xenia/kernel/objects/xtimer.cc
View File

@@ -28,7 +28,7 @@ XTimer::~XTimer() {
}
void XTimer::Initialize(uint32_t timer_type) {
XEASSERTNULL(handle_);
assert_null(handle_);
bool manual_reset = false;
switch (timer_type) {
@@ -39,7 +39,7 @@ void XTimer::Initialize(uint32_t timer_type) {
manual_reset = false;
break;
default:
XEASSERTALWAYS();
assert_always();
break;
}
@@ -71,7 +71,7 @@ X_STATUS XTimer::SetTimer(
void XTimer::CompletionRoutine(
XTimer* timer, DWORD timer_low, DWORD timer_high) {
XEASSERT(timer->current_routine_);
assert_true(timer->current_routine_);
// Queue APC to call back routine with (arg, low, high).
// TODO(benvanik): APC dispatch.

38
src/xenia/kernel/util/xex2.cc
View File

@@ -238,7 +238,7 @@ int xe_xex2_read_header(const uint8_t *addr, const size_t length,
{
const size_t max_count = XECOUNT(header->import_libraries);
size_t count = XEGETUINT32BE(pp + 0x08);
XEASSERT(count <= max_count);
assert_true(count <= max_count);
if (count > max_count) {
XELOGW("ignoring %zu extra entries in XEX_HEADER_IMPORT_LIBRARIES",
(max_count - count));
@@ -260,7 +260,7 @@ int xe_xex2_read_header(const uint8_t *addr, const size_t length,
const uint16_t name_index = XEGETUINT16BE(pp + 0x24) & 0xFF;
for (size_t i = 0, j = 0; i < string_table_size;) {
XEASSERT(j <= 0xFF);
assert_true(j <= 0xFF);
if (j == name_index) {
XEIGNORE(xestrcpya(library->name, XECOUNT(library->name),
string_table + i));
@@ -293,7 +293,7 @@ int xe_xex2_read_header(const uint8_t *addr, const size_t length,
{
const size_t max_count = XECOUNT(header->static_libraries);
size_t count = (opt_header->length - 4) / 16;
XEASSERT(count <= max_count);
assert_true(count <= max_count);
if (count > max_count) {
XELOGW("ignoring %zu extra entries in XEX_HEADER_STATIC_LIBRARIES",
(max_count - count));
@@ -326,7 +326,7 @@ int xe_xex2_read_header(const uint8_t *addr, const size_t length,
switch (fmt->compression_type) {
case XEX_COMPRESSION_NONE:
// TODO: XEX_COMPRESSION_NONE
XEASSERTALWAYS();
assert_always();
break;
case XEX_COMPRESSION_BASIC:
{
@@ -368,7 +368,7 @@ int xe_xex2_read_header(const uint8_t *addr, const size_t length,
break;
case XEX_COMPRESSION_DELTA:
// TODO: XEX_COMPRESSION_DELTA
XEASSERTALWAYS();
assert_always();
break;
}
}
@@ -460,7 +460,7 @@ typedef struct mspack_memory_file_t {
} mspack_memory_file;
mspack_memory_file *mspack_memory_open(struct mspack_system *sys,
void* buffer, const size_t buffer_size) {
XEASSERT(buffer_size < INT_MAX);
assert_true(buffer_size < INT_MAX);
if (buffer_size >= INT_MAX) {
return NULL;
}
@@ -575,7 +575,7 @@ int xe_xex2_read_image_uncompressed(const xe_xex2_header_t *header,
uncompressed_size);
return 0;
default:
XEASSERTALWAYS();
assert_always();
return 1;
}
@@ -642,7 +642,7 @@ int xe_xex2_read_image_basic_compressed(const xe_xex2_header_t *header,
}
break;
default:
XEASSERTALWAYS();
assert_always();
return 1;
}
@@ -701,7 +701,7 @@ int xe_xex2_read_image_compressed(const xe_xex2_header_t *header,
(uint8_t*)input_buffer, input_size);
break;
default:
XEASSERTALWAYS();
assert_always();
return false;
}
@@ -809,7 +809,7 @@ int xe_xex2_read_image(xe_xex2_ref xex, const uint8_t *xex_addr,
return xe_xex2_read_image_compressed(
header, xex_addr, xex_length, memory);
default:
XEASSERTALWAYS();
assert_always();
return 1;
}
}
@@ -922,7 +922,7 @@ int xe_xex2_find_import_infos(xe_xex2_ref xex,
break;
}
}
XEASSERT(library_index != (size_t)-1);
assert_true(library_index != (size_t)-1);
// Records:
// The number of records does not correspond to the number of imports!
@@ -947,9 +947,9 @@ int xe_xex2_find_import_infos(xe_xex2_ref xex,
// Allocate storage.
xe_xex2_import_info_t *infos = (xe_xex2_import_info_t*)xe_calloc(
info_count * sizeof(xe_xex2_import_info_t));
XEEXPECTNOTNULL(infos);
assert_not_null(infos);
XEASSERTNOTZERO(info_count);
assert_not_zero(info_count);
// Construct infos.
for (size_t n = 0, i = 0; n < library->record_count; n++) {
@@ -958,7 +958,7 @@ int xe_xex2_find_import_infos(xe_xex2_ref xex,
const uint32_t type = (value & 0xFF000000) >> 24;
// Verify library index matches given library.
//XEASSERT(library_index == ((value >> 16) & 0xFF));
//assert_true(library_index == ((value >> 16) & 0xFF));
switch (type) {
case 0x00:
@@ -971,14 +971,14 @@ int xe_xex2_find_import_infos(xe_xex2_ref xex,
case 0x01:
{
// Thunk for previous record.
XEASSERT(i > 0);
assert_true(i > 0);
xe_xex2_import_info_t* info = &infos[i - 1];
XEASSERT(info->ordinal == (value & 0xFFFF));
assert_true(info->ordinal == (value & 0xFFFF));
info->thunk_address = record;
}
break;
default:
//XEASSERTALWAYS();
//assert_always();
break;
}
}
@@ -986,10 +986,6 @@ int xe_xex2_find_import_infos(xe_xex2_ref xex,
xex->library_imports[library_index].count = info_count;
xex->library_imports[library_index].infos = infos;
return 0;
XECLEANUP:
xe_free(infos);
return 1;
}
int xe_xex2_get_import_infos(xe_xex2_ref xex,

2
src/xenia/kernel/xam_content.cc
View File

@@ -33,7 +33,7 @@ SHIM_CALL XamContentGetLicenseMask_shim(
mask_ptr,
overlapped_ptr);
XEASSERTZERO(overlapped_ptr);
assert_zero(overlapped_ptr);
// Arcade games seem to call this and check the result mask for random bits.
// If we fail, the games seem to use a hardcoded mask, which is likely trial.

8
src/xenia/kernel/xam_msg.cc
View File

@@ -44,8 +44,8 @@ SHIM_CALL XMsgInProcessCall_shim(
uint32_t a = SHIM_MEM_32(arg1 + 0); // 0x00000002
uint32_t b = SHIM_MEM_32(arg1 + 4); // out ptr to 4b - expect 0
XELOGD("XMPGetStatusEx(%.8X, %.8X)", a, b);
XEASSERTZERO(arg2);
XEASSERT(a == 2);
assert_zero(arg2);
assert_true(a == 2);
SHIM_SET_MEM_32(b, 0);
handled = true;
} else if (message == 0x0007001A) {
@@ -59,8 +59,8 @@ SHIM_CALL XMsgInProcessCall_shim(
uint32_t a = SHIM_MEM_32(arg1 + 0); // 0x00000002
uint32_t b = SHIM_MEM_32(arg1 + 4); // out ptr to 4b - expect 0
XELOGD("XMPGetStatus(%.8X, %.8X)", a, b);
XEASSERTZERO(arg2);
XEASSERT(a == 2);
assert_zero(arg2);
assert_true(a == 2);
SHIM_SET_MEM_32(b, 0);
handled = true;
}

2
src/xenia/kernel/xam_user.cc
View File

@@ -136,7 +136,7 @@ SHIM_CALL XamUserReadProfileSettings_shim(
// 0xfffe07d1 = profile?
// TODO(benvanik): implement overlapped support
XEASSERTZERO(overlapped_ptr);
assert_zero(overlapped_ptr);
// First call asks for size (fill buffer_size_ptr).
// Second call asks for buffer contents with that size.

8
src/xenia/kernel/xboxkrnl_audio.cc
View File

@@ -75,7 +75,7 @@ SHIM_CALL XAudioGetVoiceCategoryVolumeChangeMask_shim(
"XAudioGetVoiceCategoryVolumeChangeMask(%.8X, %.8X)",
driver_ptr, out_ptr);
XEASSERT((driver_ptr & 0xFFFF0000) == 0x41550000);
assert_true((driver_ptr & 0xFFFF0000) == 0x41550000);
auto audio_system = state->emulator()->audio_system();
@@ -124,7 +124,7 @@ SHIM_CALL XAudioRegisterRenderDriverClient_shim(
return;
}
XEASSERTTRUE(!(index & ~0x0000FFFF));
assert_true(!(index & ~0x0000FFFF));
SHIM_SET_MEM_32(driver_ptr, 0x41550000 | (index & 0x0000FFFF));
SHIM_SET_RETURN_32(X_ERROR_SUCCESS);
}
@@ -138,7 +138,7 @@ SHIM_CALL XAudioUnregisterRenderDriverClient_shim(
"XAudioUnregisterRenderDriverClient(%.8X)",
driver_ptr);
XEASSERT((driver_ptr & 0xFFFF0000) == 0x41550000);
assert_true((driver_ptr & 0xFFFF0000) == 0x41550000);
auto audio_system = state->emulator()->audio_system();
audio_system->UnregisterClient(driver_ptr & 0x0000FFFF);
@@ -155,7 +155,7 @@ SHIM_CALL XAudioSubmitRenderDriverFrame_shim(
"XAudioSubmitRenderDriverFrame(%.8X, %.8X)",
driver_ptr, samples_ptr);
XEASSERT((driver_ptr & 0xFFFF0000) == 0x41550000);
assert_true((driver_ptr & 0xFFFF0000) == 0x41550000);
auto audio_system = state->emulator()->audio_system();
audio_system->SubmitFrame(driver_ptr & 0x0000FFFF, samples_ptr);

18
src/xenia/kernel/xboxkrnl_debug.cc
View File

@@ -168,7 +168,7 @@ SHIM_CALL DbgPrint_shim(
local[0] = '\0';
strncat(local, start, end + 1 - start);
XEASSERT(arg_size == 8 || arg_size == 4);
assert_true(arg_size == 8 || arg_size == 4);
if (arg_size == 8) {
if (arg_extras == 0) {
uint64_t value = arg_index < 7
@@ -179,7 +179,7 @@ SHIM_CALL DbgPrint_shim(
arg_index++;
}
else {
XEASSERT(false);
assert_true(false);
}
}
else if (arg_size == 4) {
@@ -192,13 +192,13 @@ SHIM_CALL DbgPrint_shim(
arg_index++;
}
else {
XEASSERT(false);
assert_true(false);
}
}
}
else if (*end == 'n')
{
XEASSERT(arg_size == 4);
assert_true(arg_size == 4);
if (arg_extras == 0) {
uint32_t value = arg_index < 7
? SHIM_GET_ARG_32(1 + arg_index)
@@ -207,7 +207,7 @@ SHIM_CALL DbgPrint_shim(
arg_index++;
}
else {
XEASSERT(false);
assert_true(false);
}
}
else if (*end == 's' ||
@@ -216,7 +216,7 @@ SHIM_CALL DbgPrint_shim(
local[0] = '\0';
strncat(local, start, end + 1 - start);
XEASSERT(arg_size == 4);
assert_true(arg_size == 4);
if (arg_extras == 0) {
uint32_t value = arg_index < 7
? SHIM_GET_ARG_32(1 + arg_index)
@@ -227,11 +227,11 @@ SHIM_CALL DbgPrint_shim(
arg_index++;
}
else {
XEASSERT(false);
assert_true(false);
}
}
else {
XEASSERT(false);
assert_true(false);
break;
}
@@ -271,7 +271,7 @@ SHIM_CALL RtlRaiseException_shim(
// SetThreadName. FFS.
uint32_t thread_info_ptr = record_ptr + 20;
uint32_t type = SHIM_MEM_32(thread_info_ptr + 0);
XEASSERT(type == 0x1000);
assert_true(type == 0x1000);
uint32_t name_ptr = SHIM_MEM_32(thread_info_ptr + 4);
uint32_t thread_id = SHIM_MEM_32(thread_info_ptr + 8);

4
src/xenia/kernel/xboxkrnl_hal.cc
View File

@@ -25,13 +25,13 @@ namespace kernel {
void xeHalReturnToFirmware(uint32_t routine) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
// void
// IN FIRMWARE_REENTRY Routine
// Routine must be 1 'HalRebootRoutine'
XEASSERT(routine == 1);
assert_true(routine == 1);
// TODO(benvank): diediedie much more gracefully
// Not sure how to blast back up the stack in LLVM without exceptions, though.

32
src/xenia/kernel/xboxkrnl_io.cc
View File

@@ -70,8 +70,8 @@ SHIM_CALL NtCreateFile_shim(
attrs.root_directory != 0) {
result = state->object_table()->GetObject(
attrs.root_directory, (XObject**)&root_file);
XEASSERT(XSUCCEEDED(result));
XEASSERT(root_file->type() == XObject::Type::kTypeFile);
assert_true(XSUCCEEDED(result));
assert_true(root_file->type() == XObject::Type::kTypeFile);
auto root_path = root_file->absolute_path();
auto target_path = xestrdupa((std::string(root_path) + std::string(object_name)).c_str());
@@ -147,9 +147,9 @@ SHIM_CALL NtOpenFile_shim(
if (attrs.root_directory != 0xFFFFFFFD) { // ObDosDevices
result = state->object_table()->GetObject(
attrs.root_directory, (XObject**)&root_file);
XEASSERT(XSUCCEEDED(result));
XEASSERT(root_file->type() == XObject::Type::kTypeFile);
XEASSERTALWAYS();
assert_true(XSUCCEEDED(result));
assert_true(root_file->type() == XObject::Type::kTypeFile);
assert_always();
}
// Resolve the file using the virtual file system.
@@ -226,7 +226,7 @@ SHIM_CALL NtReadFile_shim(
byte_offset);
// Async not supported yet.
XEASSERTNULL(apc_routine_ptr);
assert_zero(apc_routine_ptr);
X_STATUS result = X_STATUS_SUCCESS;
uint32_t info = 0;
@@ -338,13 +338,13 @@ SHIM_CALL NtSetInformationFile_shim(
// struct FILE_POSITION_INFORMATION {
// LARGE_INTEGER CurrentByteOffset;
// };
XEASSERT(length == 8);
assert_true(length == 8);
info = 8;
file->set_position(SHIM_MEM_64(file_info_ptr));
break;
default:
// Unsupported, for now.
XEASSERTALWAYS();
assert_always();
info = 0;
break;
}
@@ -394,7 +394,7 @@ SHIM_CALL NtQueryInformationFile_shim(
switch (file_info_class) {
case XFileInternalInformation:
// Internal unique file pointer. Not sure why anyone would want this.
XEASSERT(length == 8);
assert_true(length == 8);
info = 8;
// TODO(benvanik): use pointer to fs:: entry?
SHIM_SET_MEM_64(file_info_ptr, hash_combine(0, file->absolute_path()));
@@ -403,7 +403,7 @@ SHIM_CALL NtQueryInformationFile_shim(
// struct FILE_POSITION_INFORMATION {
// LARGE_INTEGER CurrentByteOffset;
// };
XEASSERT(length == 8);
assert_true(length == 8);
info = 8;
SHIM_SET_MEM_64(file_info_ptr, file->position());
break;
@@ -418,7 +418,7 @@ SHIM_CALL NtQueryInformationFile_shim(
// ULONG FileAttributes;
// ULONG Unknown;
// };
XEASSERT(length == 56);
assert_true(length == 56);
XFileInfo file_info;
result = file->QueryInfo(&file_info);
if (XSUCCEEDED(result)) {
@@ -447,7 +447,7 @@ SHIM_CALL NtQueryInformationFile_shim(
break;
default:
// Unsupported, for now.
XEASSERTALWAYS();
assert_always();
info = 0;
break;
}
@@ -489,9 +489,9 @@ SHIM_CALL NtQueryFullAttributesFile_shim(
if (attrs.root_directory != 0xFFFFFFFD) { // ObDosDevices
result = state->object_table()->GetObject(
attrs.root_directory, (XObject**)&root_file);
XEASSERT(XSUCCEEDED(result));
XEASSERT(root_file->type() == XObject::Type::kTypeFile);
XEASSERTALWAYS();
assert_true(XSUCCEEDED(result));
assert_true(root_file->type() == XObject::Type::kTypeFile);
assert_always();
}
// Resolve the file using the virtual file system.
@@ -560,7 +560,7 @@ SHIM_CALL NtQueryVolumeInformationFile_shim(
}
default:
// Unsupported, for now.
XEASSERTALWAYS();
assert_always();
info = 0;
break;
}

22
src/xenia/kernel/xboxkrnl_memory.cc
View File

@@ -29,7 +29,7 @@ X_STATUS xeNtAllocateVirtualMemory(
uint32_t allocation_type, uint32_t protect_bits,
uint32_t unknown) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
// NTSTATUS
// _Inout_ PVOID *BaseAddress,
@@ -39,7 +39,7 @@ X_STATUS xeNtAllocateVirtualMemory(
// ? handle?
// I've only seen zero.
XEASSERT(unknown == 0);
assert_true(unknown == 0);
// This allocates memory from the kernel heap, which is initialized on startup
// and shared by both the kernel implementation and user code.
@@ -73,7 +73,7 @@ X_STATUS xeNtAllocateVirtualMemory(
// already happened.
if (*base_addr_ptr) {
// Having a pointer already means that this is likely a follow-on COMMIT.
XEASSERT(!(allocation_type & X_MEM_RESERVE) &&
assert_true(!(allocation_type & X_MEM_RESERVE) &&
(allocation_type & X_MEM_COMMIT));
return X_STATUS_SUCCESS;
}
@@ -127,7 +127,7 @@ X_STATUS xeNtFreeVirtualMemory(
uint32_t* base_addr_ptr, uint32_t* region_size_ptr,
uint32_t free_type, uint32_t unknown) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
// NTSTATUS
// _Inout_ PVOID *BaseAddress,
@@ -136,7 +136,7 @@ X_STATUS xeNtFreeVirtualMemory(
// ? handle?
// I've only seen zero.
XEASSERT(unknown == 0);
assert_true(unknown == 0);
if (!*base_addr_ptr) {
return X_STATUS_MEMORY_NOT_ALLOCATED;
@@ -193,7 +193,7 @@ uint32_t xeMmAllocatePhysicalMemoryEx(
uint32_t type, uint32_t region_size, uint32_t protect_bits,
uint32_t min_addr_range, uint32_t max_addr_range, uint32_t alignment) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
// Type will usually be 0 (user request?), where 1 and 2 are sometimes made
// by D3D/etc.
@@ -230,8 +230,8 @@ uint32_t xeMmAllocatePhysicalMemoryEx(
// and the memory must be allocated there. I haven't seen a game do this,
// and instead they all do min=0 / max=-1 to indicate the system should pick.
// If we have to suport arbitrary placement things will get nasty.
XEASSERT(min_addr_range == 0);
XEASSERT(max_addr_range == 0xFFFFFFFF);
assert_true(min_addr_range == 0);
assert_true(max_addr_range == 0xFFFFFFFF);
// Allocate.
uint32_t flags = MEMORY_FLAG_PHYSICAL;
@@ -280,7 +280,7 @@ SHIM_CALL MmAllocatePhysicalMemoryEx_shim(
void xeMmFreePhysicalMemory(uint32_t type, uint32_t base_address) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
// base_address = result of MmAllocatePhysicalMemory.
@@ -310,7 +310,7 @@ SHIM_CALL MmFreePhysicalMemory_shim(
uint32_t xeMmQueryAddressProtect(uint32_t base_address) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
uint32_t access = state->memory()->QueryProtect(base_address);
@@ -334,7 +334,7 @@ SHIM_CALL MmQueryAddressProtect_shim(
uint32_t xeMmQueryAllocationSize(uint32_t base_address) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
size_t size = state->memory()->QuerySize(base_address);

2
src/xenia/kernel/xboxkrnl_misc.cc
View File

@@ -28,7 +28,7 @@ void xeKeBugCheckEx(uint32_t code, uint32_t param1, uint32_t param2, uint32_t pa
XELOGD("*** STOP: 0x%.8X (0x%.8X, 0x%.8X, 0x%.8X, 0x%.8X)", code, param1, param2, param3, param4);
fflush(stdout);
DebugBreak();
XEASSERTALWAYS();
assert_always();
}
SHIM_CALL KeBugCheck_shim(

10
src/xenia/kernel/xboxkrnl_modules.cc
View File

@@ -43,7 +43,7 @@ X_STATUS xeExGetXConfigSetting(
value = 0x00001000; // USA/Canada
break;
default:
XEASSERTUNHANDLEDCASE(setting);
assert_unhandled_case(setting);
return X_STATUS_INVALID_PARAMETER_2;
}
break;
@@ -80,12 +80,12 @@ X_STATUS xeExGetXConfigSetting(
value = 0;
break;
default:
XEASSERTUNHANDLEDCASE(setting);
assert_unhandled_case(setting);
return X_STATUS_INVALID_PARAMETER_2;
}
break;
default:
XEASSERTUNHANDLEDCASE(category);
assert_unhandled_case(category);
return X_STATUS_INVALID_PARAMETER_1;
}
@@ -134,7 +134,7 @@ SHIM_CALL ExGetXConfigSetting_shim(
int xeXexCheckExecutablePriviledge(uint32_t privilege) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
// BOOL
// DWORD Privilege
@@ -176,7 +176,7 @@ SHIM_CALL XexCheckExecutablePrivilege_shim(
int xeXexGetModuleHandle(const char* module_name,
X_HANDLE* module_handle_ptr) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
// BOOL
// LPCSZ ModuleName

32
src/xenia/kernel/xboxkrnl_rtl.cc
View File

@@ -30,7 +30,7 @@ namespace kernel {
uint32_t xeRtlCompareMemory(uint32_t source1_ptr, uint32_t source2_ptr,
uint32_t length) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
// SIZE_T
// _In_ const VOID *Source1,
@@ -74,7 +74,7 @@ SHIM_CALL RtlCompareMemory_shim(
uint32_t xeRtlCompareMemoryUlong(uint32_t source_ptr, uint32_t length,
uint32_t pattern) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
// SIZE_T
// _In_ PVOID Source,
@@ -124,7 +124,7 @@ SHIM_CALL RtlCompareMemoryUlong_shim(
void xeRtlFillMemoryUlong(uint32_t destination_ptr, uint32_t length,
uint32_t pattern) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
// VOID
// _Out_ PVOID Destination,
@@ -172,7 +172,7 @@ SHIM_CALL RtlFillMemoryUlong_shim(
// http://msdn.microsoft.com/en-us/library/ff561918
void xeRtlInitAnsiString(uint32_t destination_ptr, uint32_t source_ptr) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
// VOID
// _Out_ PANSI_STRING DestinationString,
@@ -207,7 +207,7 @@ SHIM_CALL RtlInitAnsiString_shim(
// http://msdn.microsoft.com/en-us/library/ff561899
void xeRtlFreeAnsiString(uint32_t string_ptr) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
// VOID
// _Inout_ PANSI_STRING AnsiString
@@ -242,7 +242,7 @@ SHIM_CALL RtlFreeAnsiString_shim(
// http://msdn.microsoft.com/en-us/library/ff561934
void xeRtlInitUnicodeString(uint32_t destination_ptr, uint32_t source_ptr) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
// VOID
// _Out_ PUNICODE_STRING DestinationString,
@@ -281,7 +281,7 @@ SHIM_CALL RtlInitUnicodeString_shim(
// http://msdn.microsoft.com/en-us/library/ff561903
void xeRtlFreeUnicodeString(uint32_t string_ptr) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
// VOID
// _Inout_ PUNICODE_STRING UnicodeString
@@ -310,7 +310,7 @@ SHIM_CALL RtlFreeUnicodeString_shim(
X_STATUS xeRtlUnicodeStringToAnsiString(
uint32_t destination_ptr, uint32_t source_ptr, uint32_t alloc_dest) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
// NTSTATUS
// _Inout_ PANSI_STRING DestinationString,
@@ -318,7 +318,7 @@ X_STATUS xeRtlUnicodeStringToAnsiString(
// _In_ BOOLEAN AllocateDestinationString
XELOGE("RtlUnicodeStringToAnsiString not yet implemented");
XEASSERTALWAYS();
assert_always();
if (alloc_dest) {
// Allocate a new buffer to place the string into.
@@ -438,7 +438,7 @@ SHIM_CALL RtlNtStatusToDosError_shim(
uint32_t xeRtlImageXexHeaderField(uint32_t xex_header_base_ptr,
uint32_t image_field) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
// PVOID
// PVOID XexHeaderBase
@@ -525,11 +525,11 @@ typedef struct {
#pragma pack(pop)
}
XEASSERTSTRUCTSIZE(X_RTL_CRITICAL_SECTION, 28);
static_assert_size(X_RTL_CRITICAL_SECTION, 28);
void xeRtlInitializeCriticalSection(uint32_t cs_ptr) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
// VOID
// _Out_ LPCRITICAL_SECTION lpCriticalSection
@@ -556,7 +556,7 @@ SHIM_CALL RtlInitializeCriticalSection_shim(
X_STATUS xeRtlInitializeCriticalSectionAndSpinCount(
uint32_t cs_ptr, uint32_t spin_count) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
// NTSTATUS
// _Out_ LPCRITICAL_SECTION lpCriticalSection,
@@ -597,7 +597,7 @@ SHIM_CALL RtlInitializeCriticalSectionAndSpinCount_shim(
// TODO(benvanik): remove the need for passing in thread_id.
void xeRtlEnterCriticalSection(uint32_t cs_ptr, uint32_t thread_id) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
// VOID
// _Inout_ LPCRITICAL_SECTION lpCriticalSection
@@ -651,7 +651,7 @@ SHIM_CALL RtlEnterCriticalSection_shim(
// TODO(benvanik): remove the need for passing in thread_id.
uint32_t xeRtlTryEnterCriticalSection(uint32_t cs_ptr, uint32_t thread_id) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
// DWORD
// _Inout_ LPCRITICAL_SECTION lpCriticalSection
@@ -689,7 +689,7 @@ SHIM_CALL RtlTryEnterCriticalSection_shim(
void xeRtlLeaveCriticalSection(uint32_t cs_ptr) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
// VOID
// _Inout_ LPCRITICAL_SECTION lpCriticalSection

52
src/xenia/kernel/xboxkrnl_strings.cc
View File

@@ -173,7 +173,7 @@ SHIM_CALL vsprintf_shim(
local[0] = '\0';
strncat(local, start, end + 1 - start);
XEASSERT(arg_size == 8 || arg_size == 4);
assert_true(arg_size == 8 || arg_size == 4);
if (arg_size == 8) {
if (arg_extras == 0) {
uint64_t value = SHIM_MEM_64(arg_ptr + (arg_index * 8)); // TODO: check if this is correct...
@@ -182,7 +182,7 @@ SHIM_CALL vsprintf_shim(
arg_index++;
}
else {
XEASSERT(false);
assert_true(false);
}
}
else if (arg_size == 4) {
@@ -193,20 +193,20 @@ SHIM_CALL vsprintf_shim(
arg_index++;
}
else {
XEASSERT(false);
assert_true(false);
}
}
}
else if (*end == 'n')
{
XEASSERT(arg_size == 4);
assert_true(arg_size == 4);
if (arg_extras == 0) {
uint32_t value = (uint32_t)SHIM_MEM_64(arg_ptr + (arg_index * 8)); // TODO: check if this is correct...
SHIM_SET_MEM_32(value, (uint32_t)((b - buffer) / sizeof(char)));
arg_index++;
}
else {
XEASSERT(false);
assert_true(false);
}
}
else if (*end == 's' ||
@@ -215,7 +215,7 @@ SHIM_CALL vsprintf_shim(
local[0] = '\0';
strncat(local, start, end + 1 - start);
XEASSERT(arg_size == 4);
assert_true(arg_size == 4);
if (arg_extras == 0) {
uint32_t value = (uint32_t)SHIM_MEM_64(arg_ptr + (arg_index * 8)); // TODO: check if this is correct...
const void* pointer = (const void*)SHIM_MEM_ADDR(value);
@@ -224,11 +224,11 @@ SHIM_CALL vsprintf_shim(
arg_index++;
}
else {
XEASSERT(false);
assert_true(false);
}
}
else {
XEASSERT(false);
assert_true(false);
break;
}
format = end;
@@ -386,7 +386,7 @@ SHIM_CALL _vsnprintf_shim(
local[0] = '\0';
strncat(local, start, end + 1 - start);
XEASSERT(arg_size == 8 || arg_size == 4);
assert_true(arg_size == 8 || arg_size == 4);
if (arg_size == 8) {
if (arg_extras == 0) {
uint64_t value = SHIM_MEM_64(arg_ptr + (arg_index * 8)); // TODO: check if this is correct...
@@ -395,7 +395,7 @@ SHIM_CALL _vsnprintf_shim(
arg_index++;
}
else {
XEASSERT(false);
assert_true(false);
}
}
else if (arg_size == 4) {
@@ -406,20 +406,20 @@ SHIM_CALL _vsnprintf_shim(
arg_index++;
}
else {
XEASSERT(false);
assert_true(false);
}
}
}
else if (*end == 'n')
{
XEASSERT(arg_size == 4);
assert_true(arg_size == 4);
if (arg_extras == 0) {
uint32_t value = (uint32_t)SHIM_MEM_64(arg_ptr + (arg_index * 8)); // TODO: check if this is correct...
SHIM_SET_MEM_32(value, (uint32_t)((b - buffer) / sizeof(char)));
arg_index++;
}
else {
XEASSERT(false);
assert_true(false);
}
}
else if (*end == 's' ||
@@ -428,7 +428,7 @@ SHIM_CALL _vsnprintf_shim(
local[0] = '\0';
strncat(local, start, end + 1 - start);
XEASSERT(arg_size == 4);
assert_true(arg_size == 4);
if (arg_extras == 0) {
uint32_t value = (uint32_t)SHIM_MEM_64(arg_ptr + (arg_index * 8)); // TODO: check if this is correct...
const void* pointer = (const void*)SHIM_MEM_ADDR(value);
@@ -437,11 +437,11 @@ SHIM_CALL _vsnprintf_shim(
arg_index++;
}
else {
XEASSERT(false);
assert_true(false);
}
}
else {
XEASSERT(false);
assert_true(false);
break;
}
format = end;
@@ -612,7 +612,7 @@ SHIM_CALL _vswprintf_shim(
local[0] = '\0';
wcsncat(local, start, end + 1 - start);
XEASSERT(arg_size == 8 || arg_size == 4);
assert_true(arg_size == 8 || arg_size == 4);
if (arg_size == 8) {
if (arg_extras == 0) {
uint64_t value = SHIM_MEM_64(arg_ptr + (arg_index * 8)); // TODO: check if this is correct...
@@ -621,7 +621,7 @@ SHIM_CALL _vswprintf_shim(
arg_index++;
}
else {
XEASSERT(false);
assert_true(false);
}
}
else if (arg_size == 4) {
@@ -632,20 +632,20 @@ SHIM_CALL _vswprintf_shim(
arg_index++;
}
else {
XEASSERT(false);
assert_true(false);
}
}
}
else if (*end == 'n')
{
XEASSERT(arg_size == 4);
assert_true(arg_size == 4);
if (arg_extras == 0) {
uint32_t value = (uint32_t)SHIM_MEM_64(arg_ptr + (arg_index * 8)); // TODO: check if this is correct...
SHIM_SET_MEM_32(value, (uint32_t)((b - buffer) / sizeof(wchar_t)));
arg_index++;
}
else {
XEASSERT(false);
assert_true(false);
}
}
else if (*end == 'p') {
@@ -653,7 +653,7 @@ SHIM_CALL _vswprintf_shim(
local[0] = '\0';
wcsncat(local, start, end + 1 - start);
XEASSERT(arg_size == 4);
assert_true(arg_size == 4);
if (arg_extras == 0) {
uint32_t value = (uint32_t)SHIM_MEM_64(arg_ptr + (arg_index * 8)); // TODO: check if this is correct...
const void* pointer = (void*)SHIM_MEM_ADDR(value);
@@ -662,7 +662,7 @@ SHIM_CALL _vswprintf_shim(
arg_index++;
}
else {
XEASSERT(false);
assert_true(false);
}
}
else if (*end == 's') {
@@ -670,7 +670,7 @@ SHIM_CALL _vswprintf_shim(
local[0] = '\0';
wcsncat(local, start, end + 1 - start);
XEASSERT(arg_size == 4);
assert_true(arg_size == 4);
if (arg_extras == 0) {
uint32_t value = (uint32_t)SHIM_MEM_64(arg_ptr + (arg_index * 8)); // TODO: check if this is correct...
const wchar_t* data = (const wchar_t*)SHIM_MEM_ADDR(value);
@@ -687,11 +687,11 @@ SHIM_CALL _vswprintf_shim(
arg_index++;
}
else {
XEASSERT(false);
assert_true(false);
}
}
else {
XEASSERT(false);
assert_true(false);
break;
}
format = end;

46
src/xenia/kernel/xboxkrnl_threading.cc
View File

@@ -69,7 +69,7 @@ X_STATUS xeExCreateThread(
uint32_t xapi_thread_startup,
uint32_t start_address, uint32_t start_context, uint32_t creation_flags) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
// DWORD
// LPHANDLE Handle,
@@ -158,7 +158,7 @@ SHIM_CALL ExTerminateThread_shim(
X_STATUS xeNtResumeThread(uint32_t handle, uint32_t* out_suspend_count) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
X_STATUS result = X_STATUS_SUCCESS;
@@ -198,7 +198,7 @@ SHIM_CALL NtResumeThread_shim(
X_STATUS xeKeResumeThread(void* thread_ptr, uint32_t* out_suspend_count) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
X_STATUS result = X_STATUS_SUCCESS;
@@ -236,7 +236,7 @@ SHIM_CALL KeResumeThread_shim(
X_STATUS xeNtSuspendThread(uint32_t handle, uint32_t* out_suspend_count) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
X_STATUS result = X_STATUS_SUCCESS;
@@ -276,7 +276,7 @@ SHIM_CALL NtSuspendThread_shim(
uint32_t xeKeSetAffinityThread(void* thread_ptr, uint32_t affinity) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
XThread* thread = (XThread*)XObject::GetObject(state, thread_ptr);
if (thread) {
@@ -326,7 +326,7 @@ SHIM_CALL KeQueryBasePriorityThread_shim(
uint32_t xeKeSetBasePriorityThread(void* thread_ptr, int32_t increment) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
int32_t prev_priority = 0;
@@ -358,7 +358,7 @@ SHIM_CALL KeSetBasePriorityThread_shim(
uint32_t xeKeGetCurrentProcessType() {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
// DWORD
@@ -595,7 +595,7 @@ SHIM_CALL KeTlsSetValue_shim(
X_STATUS xeNtCreateEvent(uint32_t* handle_ptr, void* obj_attributes,
uint32_t event_type, uint32_t initial_state) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
XEvent* ev = new XEvent(state);
ev->Initialize(!event_type, !!initial_state);
@@ -638,10 +638,10 @@ SHIM_CALL NtCreateEvent_shim(
int32_t xeKeSetEvent(void* event_ptr, uint32_t increment, uint32_t wait) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
XEvent* ev = (XEvent*)XObject::GetObject(state, event_ptr);
XEASSERTNOTNULL(ev);
assert_not_null(ev);
if (!ev) {
return 0;
}
@@ -708,7 +708,7 @@ SHIM_CALL KePulseEvent_shim(
void* event_ptr = SHIM_MEM_ADDR(event_ref);
XEvent* ev = (XEvent*)XObject::GetObject(state, event_ptr);
XEASSERTNOTNULL(ev);
assert_not_null(ev);
if (ev) {
result = ev->Pulse(increment, !!wait);
}
@@ -746,10 +746,10 @@ SHIM_CALL NtPulseEvent_shim(
int32_t xeKeResetEvent(void* event_ptr) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
XEvent* ev = (XEvent*)XEvent::GetObject(state, event_ptr);
XEASSERTNOTNULL(ev);
assert_not_null(ev);
if (!ev) {
return 0;
}
@@ -825,11 +825,11 @@ SHIM_CALL NtCreateSemaphore_shim(
void xeKeInitializeSemaphore(
void* semaphore_ptr, int32_t count, int32_t limit) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
XSemaphore* sem = (XSemaphore*)XSemaphore::GetObject(
state, semaphore_ptr, 5 /* SemaphoreObject */);
XEASSERTNOTNULL(sem);
assert_not_null(sem);
if (!sem) {
return;
}
@@ -856,10 +856,10 @@ SHIM_CALL KeInitializeSemaphore_shim(
int32_t xeKeReleaseSemaphore(
void* semaphore_ptr, int32_t increment, int32_t adjustment, bool wait) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
XSemaphore* sem = (XSemaphore*)XSemaphore::GetObject(state, semaphore_ptr);
XEASSERTNOTNULL(sem);
assert_not_null(sem);
if (!sem) {
return 0;
}
@@ -954,7 +954,7 @@ SHIM_CALL NtReleaseMutant_shim(
// Whatever arg 1 is all games seem to set it to 0, so whether it's
// abandon or wait we just say false. Which is good, cause they are
// both ignored.
XEASSERTZERO(unknown);
assert_zero(unknown);
uint32_t priority_increment = 0;
bool abandon = false;
bool wait = false;
@@ -1016,8 +1016,8 @@ SHIM_CALL NtSetTimerEx_shim(
uint32_t period_ms = SHIM_GET_ARG_32(6);
uint32_t unk_zero = SHIM_GET_ARG_32(7);
XEASSERT(unk_one == 1);
XEASSERT(unk_zero == 0);
assert_true(unk_one == 1);
assert_true(unk_zero == 0);
uint64_t due_time = SHIM_MEM_64(due_time_ptr);
@@ -1075,7 +1075,7 @@ X_STATUS xeKeWaitForSingleObject(
void* object_ptr, uint32_t wait_reason, uint32_t processor_mode,
uint32_t alertable, uint64_t* opt_timeout) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
XObject* object = XObject::GetObject(state, object_ptr);
if (!object) {
@@ -1153,7 +1153,7 @@ SHIM_CALL KeWaitForMultipleObjects_shim(
count, objects_ptr, wait_type, wait_reason, processor_mode,
alertable, timeout_ptr, wait_block_array_ptr);
XEASSERT(wait_type >= 0 && wait_type <= 1);
assert_true(wait_type >= 0 && wait_type <= 1);
X_STATUS result = X_STATUS_SUCCESS;
@@ -1192,7 +1192,7 @@ SHIM_CALL NtWaitForMultipleObjectsEx_shim(
count, handles_ptr, wait_type, wait_mode,
alertable, timeout_ptr);
XEASSERT(wait_type >= 0 && wait_type <= 1);
assert_true(wait_type >= 0 && wait_type <= 1);
X_STATUS result = X_STATUS_SUCCESS;

10
src/xenia/kernel/xboxkrnl_video.cc
View File

@@ -146,7 +146,7 @@ SHIM_CALL VdQueryVideoMode_shim(
void xeVdInitializeEngines(uint32_t unk0, uint32_t callback, uint32_t unk1,
uint32_t unk2_ptr, uint32_t unk3_ptr) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
GraphicsSystem* gs = state->emulator()->graphics_system();
if (!gs) {
return;
@@ -188,7 +188,7 @@ SHIM_CALL VdShutdownEngines_shim(
void xeVdSetGraphicsInterruptCallback(uint32_t callback, uint32_t user_data) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
GraphicsSystem* gs = state->emulator()->graphics_system();
if (!gs) {
return;
@@ -217,7 +217,7 @@ SHIM_CALL VdSetGraphicsInterruptCallback_shim(
void xeVdInitializeRingBuffer(uint32_t ptr, uint32_t page_count) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
GraphicsSystem* gs = state->emulator()->graphics_system();
if (!gs) {
return;
@@ -249,7 +249,7 @@ SHIM_CALL VdInitializeRingBuffer_shim(
void xeVdEnableRingBufferRPtrWriteBack(uint32_t ptr, uint32_t block_size) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
GraphicsSystem* gs = state->emulator()->graphics_system();
if (!gs) {
return;
@@ -317,7 +317,7 @@ SHIM_CALL VdGetSystemCommandBuffer_shim(
void xeVdSetSystemCommandBufferGpuIdentifierAddress(uint32_t unk) {
KernelState* state = shared_kernel_state_;
XEASSERTNOTNULL(state);
assert_not_null(state);
GraphicsSystem* gs = state->emulator()->graphics_system();
if (!gs) {
return;

2
src/xenia/kernel/xboxkrnl_video.h
View File

@@ -36,7 +36,7 @@ typedef struct {
}
X_VIDEO_MODE;
#pragma pack(pop)
XEASSERTSTRUCTSIZE(X_VIDEO_MODE, 48);
static_assert_size(X_VIDEO_MODE, 48);
void xeVdGetCurrentDisplayGamma(uint32_t* arg0, float* arg1);
uint32_t xeVdQueryVideoFlags();

14
src/xenia/kernel/xobject.cc
View File

@@ -29,8 +29,8 @@ XObject::XObject(KernelState* kernel_state, Type type) :
}
XObject::~XObject() {
XEASSERTZERO(handle_ref_count_);
XEASSERTZERO(pointer_ref_count_);
assert_zero(handle_ref_count_);
assert_zero(pointer_ref_count_);
}
Memory* XObject::memory() const {
@@ -62,7 +62,7 @@ void XObject::Retain() {
void XObject::Release() {
if (!xe_atomic_dec_32(&pointer_ref_count_)) {
XEASSERT(pointer_ref_count_ >= handle_ref_count_);
assert_true(pointer_ref_count_ >= handle_ref_count_);
delete this;
}
}
@@ -75,7 +75,7 @@ uint32_t XObject::TimeoutTicksToMs(int64_t timeout_ticks) {
if (timeout_ticks > 0) {
// Absolute time, based on January 1, 1601.
// TODO(benvanik): convert time to relative time.
XEASSERTALWAYS();
assert_always();
return 0;
} else if (timeout_ticks < 0) {
// Relative time.
@@ -135,7 +135,7 @@ X_STATUS XObject::WaitMultiple(
void** wait_handles = (void**)alloca(sizeof(void*) * count);
for (uint32_t n = 0; n < count; n++) {
wait_handles[n] = objects[n]->GetWaitHandle();
XEASSERTNOTNULL(wait_handles[n]);
assert_not_null(wait_handles[n]);
}
DWORD timeout_ms = opt_timeout ?
@@ -167,7 +167,7 @@ void XObject::SetNativePointer(uint32_t native_ptr) {
header.wait_list_flink = XESWAP32(header_be->wait_list_flink);
header.wait_list_blink = XESWAP32(header_be->wait_list_blink);
XEASSERT(!(header.wait_list_blink & 0x1));
assert_true(!(header.wait_list_blink & 0x1));
// Stash pointer in struct.
uint64_t object_ptr = reinterpret_cast<uint64_t>(this);
@@ -252,7 +252,7 @@ XObject* XObject::GetObject(KernelState* kernel_state, void* native_ptr,
case 23: // ProfileObject
case 24: // ThreadedDpcObject
default:
XEASSERTALWAYS();
assert_always();
XObject::UnlockType();
return NULL;
}

4
src/xenia/logging.h
View File

@@ -32,14 +32,14 @@ void xe_handle_fatal(
#if XE_OPTION_ENABLE_LOGGING
#define XELOGCORE(level, fmt, ...) xe_log_line( \
XE_CURRENT_FILE, XE_CURRENT_LINE, XE_CURRENT_FUNCTION, level, \
__FILE__, __LINE__, __FUNCTION__, level, \
fmt, ##__VA_ARGS__)
#else
#define XELOGCORE(level, fmt, ...) XE_EMPTY_MACRO
#endif // ENABLE_LOGGING
#define XEFATAL(fmt, ...) do { \
xe_handle_fatal(XE_CURRENT_FILE, XE_CURRENT_LINE, XE_CURRENT_FUNCTION, \
xe_handle_fatal(__FILE__, __LINE__, __FUNCTION__, \
fmt, ##__VA_ARGS__); \
} while (false);

4
src/xenia/profiling.h
View File

@@ -55,7 +55,7 @@ namespace xe {
// Enters a CPU profiling scope by function name, active for the duration of
// the containing block. No previous definition required.
#define SCOPE_profile_cpu_f(group_name) \
MICROPROFILE_SCOPEI(group_name, XE_CURRENT_FUNCTION, xe::Profiler::GetColor(XE_CURRENT_FUNCTION))
MICROPROFILE_SCOPEI(group_name, __FUNCTION__, xe::Profiler::GetColor(__FUNCTION__))
// Enters a previously defined GPU profiling scope, active for the duration
// of the containing block.
@@ -70,7 +70,7 @@ namespace xe {
// Enters a GPU profiling scope by function name, active for the duration of
// the containing block. No previous definition required.
#define SCOPE_profile_gpu_f(group_name) \
MICROPROFILE_SCOPEGPUI(group_name, XE_CURRENT_FUNCTION, xe::Profiler::GetColor(XE_CURRENT_FUNCTION))
MICROPROFILE_SCOPEGPUI(group_name, __FUNCTION__, xe::Profiler::GetColor(__FUNCTION__))
// Tracks a CPU value counter.
#define COUNT_profile_cpu(name, count) MICROPROFILE_META_CPU(name, count)

1
src/xenia/sources.gypi
View File

@@ -1,7 +1,6 @@
# Copyright 2013 Ben Vanik. All Rights Reserved.
{
'sources': [
'assert.h',
'atomic.h',
'byte_order.h',
'common.h',

2
src/xenia/ui/window.cc
View File

@@ -100,7 +100,7 @@ bool Window::OnResize(uint32_t width, uint32_t height) {
}
void Window::EndResizing() {
XEASSERT(resizing_);
assert_true(resizing_);
resizing_ = false;
auto e = UIEvent(this);
resized(e);