ShuriZma
/
xenia-canary
mirror of https://github.com/xenia-canary/xenia-canary.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Renamed handle_ to native_handle_ in some places where it makes more sense.

This commit is contained in:
gibbed 2015-06-10 21:18:12 -05:00
parent cabf9d6261
commit dc371009d9
8 changed files with 42 additions and 41 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -7,28 +7,29 @@
****************************************************************************** ******************************************************************************
*/ */
#include "xenia/base/logging.h"
#include "xenia/kernel/objects/xevent.h" #include "xenia/kernel/objects/xevent.h"
namespace xe { namespace xe {
namespace kernel { namespace kernel {
XEvent::XEvent(KernelState* kernel_state) XEvent::XEvent(KernelState* kernel_state)
: XObject(kernel_state, kTypeEvent), handle_(NULL) {} : XObject(kernel_state, kTypeEvent), native_handle_(NULL) {}
XEvent::~XEvent() { XEvent::~XEvent() {
if (handle_) { if (native_handle_) {
CloseHandle(handle_); CloseHandle(native_handle_);
} }
} }
void XEvent::Initialize(bool manual_reset, bool initial_state) { void XEvent::Initialize(bool manual_reset, bool initial_state) {
assert_null(handle_); assert_null(native_handle_);
handle_ = CreateEvent(NULL, manual_reset, initial_state, NULL); native_handle_ = CreateEvent(NULL, manual_reset, initial_state, NULL);
} }
void XEvent::InitializeNative(void* native_ptr, DISPATCH_HEADER& header) { void XEvent::InitializeNative(void* native_ptr, DISPATCH_HEADER& header) {
assert_null(handle_); assert_null(native_handle_);
bool manual_reset; bool manual_reset;
switch ((header.type_flags >> 24) & 0xFF) { switch ((header.type_flags >> 24) & 0xFF) {
@ -45,20 +46,20 @@ void XEvent::InitializeNative(void* native_ptr, DISPATCH_HEADER& header) {
bool initial_state = header.signal_state ? true : false; bool initial_state = header.signal_state ? true : false;
handle_ = CreateEvent(NULL, manual_reset, initial_state, NULL); native_handle_ = CreateEvent(NULL, manual_reset, initial_state, NULL);
} }
int32_t XEvent::Set(uint32_t priority_increment, bool wait) { int32_t XEvent::Set(uint32_t priority_increment, bool wait) {
return SetEvent(handle_) ? 1 : 0; return SetEvent(native_handle_) ? 1 : 0;
} }
int32_t XEvent::Pulse(uint32_t priority_increment, bool wait) { int32_t XEvent::Pulse(uint32_t priority_increment, bool wait) {
return PulseEvent(handle_) ? 1 : 0; return PulseEvent(native_handle_) ? 1 : 0;
} }
int32_t XEvent::Reset() { return ResetEvent(handle_) ? 1 : 0; } int32_t XEvent::Reset() { return ResetEvent(native_handle_) ? 1 : 0; }
void XEvent::Clear() { ResetEvent(handle_); } void XEvent::Clear() { ResetEvent(native_handle_); }
} // namespace kernel } // namespace kernel
} // namespace xe } // namespace xe

4
src/xenia/kernel/objects/xevent.h
View File

@ -29,10 +29,10 @@ class XEvent : public XObject {
int32_t Reset(); int32_t Reset();
void Clear(); void Clear();
virtual void* GetWaitHandle() { return handle_; } virtual void* GetWaitHandle() { return native_handle_; }
private: private:
HANDLE handle_; HANDLE native_handle_;
}; };
} // namespace kernel } // namespace kernel

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

@ -13,22 +13,22 @@ namespace xe {
namespace kernel { namespace kernel {
XMutant::XMutant(KernelState* kernel_state) XMutant::XMutant(KernelState* kernel_state)
: XObject(kernel_state, kTypeMutant), handle_(NULL) {} : XObject(kernel_state, kTypeMutant), native_handle_(NULL) {}
XMutant::~XMutant() { XMutant::~XMutant() {
if (handle_) { if (native_handle_) {
CloseHandle(handle_); CloseHandle(native_handle_);
} }
} }
void XMutant::Initialize(bool initial_owner) { void XMutant::Initialize(bool initial_owner) {
assert_null(handle_); assert_null(native_handle_);
handle_ = CreateMutex(NULL, initial_owner ? TRUE : FALSE, NULL); native_handle_ = CreateMutex(NULL, initial_owner ? TRUE : FALSE, NULL);
} }
void XMutant::InitializeNative(void* native_ptr, DISPATCH_HEADER& header) { void XMutant::InitializeNative(void* native_ptr, DISPATCH_HEADER& header) {
assert_null(handle_); assert_null(native_handle_);
// Haven't seen this yet, but it's possible. // Haven't seen this yet, but it's possible.
assert_always(); assert_always();
@ -38,7 +38,7 @@ X_STATUS XMutant::ReleaseMutant(uint32_t priority_increment, bool abandon,
bool wait) { bool wait) {
// TODO(benvanik): abandoning. // TODO(benvanik): abandoning.
assert_false(abandon); assert_false(abandon);
BOOL result = ReleaseMutex(handle_); BOOL result = ReleaseMutex(native_handle_);
if (result) { if (result) {
return X_STATUS_SUCCESS; return X_STATUS_SUCCESS;
} else { } else {

4
src/xenia/kernel/objects/xmutant.h
View File

@ -26,10 +26,10 @@ class XMutant : public XObject {
X_STATUS ReleaseMutant(uint32_t priority_increment, bool abandon, bool wait); X_STATUS ReleaseMutant(uint32_t priority_increment, bool abandon, bool wait);
virtual void* GetWaitHandle() { return handle_; } virtual void* GetWaitHandle() { return native_handle_; }
private: private:
HANDLE handle_; HANDLE native_handle_;
}; };
} // namespace kernel } // namespace kernel

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

@ -13,22 +13,22 @@ namespace xe {
namespace kernel { namespace kernel {
XSemaphore::XSemaphore(KernelState* kernel_state) XSemaphore::XSemaphore(KernelState* kernel_state)
: XObject(kernel_state, kTypeSemaphore), handle_(NULL) {} : XObject(kernel_state, kTypeSemaphore), native_handle_(NULL) {}
XSemaphore::~XSemaphore() { XSemaphore::~XSemaphore() {
if (handle_) { if (native_handle_) {
CloseHandle(handle_); CloseHandle(native_handle_);
} }
} }
void XSemaphore::Initialize(int32_t initial_count, int32_t maximum_count) { void XSemaphore::Initialize(int32_t initial_count, int32_t maximum_count) {
assert_null(handle_); assert_null(native_handle_);
handle_ = CreateSemaphore(NULL, initial_count, maximum_count, NULL); native_handle_ = CreateSemaphore(NULL, initial_count, maximum_count, NULL);
} }
void XSemaphore::InitializeNative(void* native_ptr, DISPATCH_HEADER& header) { void XSemaphore::InitializeNative(void* native_ptr, DISPATCH_HEADER& header) {
assert_null(handle_); assert_null(native_handle_);
// NOT IMPLEMENTED // NOT IMPLEMENTED
// We expect Initialize to be called shortly. // We expect Initialize to be called shortly.
@ -36,7 +36,7 @@ void XSemaphore::InitializeNative(void* native_ptr, DISPATCH_HEADER& header) {
int32_t XSemaphore::ReleaseSemaphore(int32_t release_count) { int32_t XSemaphore::ReleaseSemaphore(int32_t release_count) {
LONG previous_count = 0; LONG previous_count = 0;
::ReleaseSemaphore(handle_, release_count, &previous_count); ::ReleaseSemaphore(native_handle_, release_count, &previous_count);
return previous_count; return previous_count;
} }

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

@ -26,10 +26,10 @@ class XSemaphore : public XObject {
int32_t ReleaseSemaphore(int32_t release_count); int32_t ReleaseSemaphore(int32_t release_count);
virtual void* GetWaitHandle() { return handle_; } virtual void* GetWaitHandle() { return native_handle_; }
private: private:
HANDLE handle_; HANDLE native_handle_;
}; };
} // namespace kernel } // namespace kernel

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

@ -17,16 +17,16 @@ namespace xe {
namespace kernel { namespace kernel {
XTimer::XTimer(KernelState* kernel_state) XTimer::XTimer(KernelState* kernel_state)
: XObject(kernel_state, kTypeTimer), handle_(NULL) {} : XObject(kernel_state, kTypeTimer), native_handle_(NULL) {}
XTimer::~XTimer() { XTimer::~XTimer() {
if (handle_) { if (native_handle_) {
CloseHandle(handle_); CloseHandle(native_handle_);
} }
} }
void XTimer::Initialize(uint32_t timer_type) { void XTimer::Initialize(uint32_t timer_type) {
assert_null(handle_); assert_null(native_handle_);
bool manual_reset = false; bool manual_reset = false;
switch (timer_type) { switch (timer_type) {
@ -41,7 +41,7 @@ void XTimer::Initialize(uint32_t timer_type) {
break; break;
} }
handle_ = CreateWaitableTimer(NULL, manual_reset, NULL); native_handle_ = CreateWaitableTimer(NULL, manual_reset, NULL);
} }
X_STATUS XTimer::SetTimer(int64_t due_time, uint32_t period_ms, X_STATUS XTimer::SetTimer(int64_t due_time, uint32_t period_ms,
@ -56,7 +56,7 @@ X_STATUS XTimer::SetTimer(int64_t due_time, uint32_t period_ms,
LARGE_INTEGER due_time_li; LARGE_INTEGER due_time_li;
due_time_li.QuadPart = due_time; due_time_li.QuadPart = due_time;
BOOL result = BOOL result =
SetWaitableTimer(handle_, &due_time_li, period_ms, SetWaitableTimer(native_handle_, &due_time_li, period_ms,
routine ? (PTIMERAPCROUTINE)CompletionRoutine : NULL, routine ? (PTIMERAPCROUTINE)CompletionRoutine : NULL,
this, resume ? TRUE : FALSE); this, resume ? TRUE : FALSE);
@ -81,8 +81,8 @@ void XTimer::CompletionRoutine(XTimer* timer, DWORD timer_low,
} }
X_STATUS XTimer::Cancel() { X_STATUS XTimer::Cancel() {
return CancelWaitableTimer(handle_) == 0 ? X_STATUS_SUCCESS return CancelWaitableTimer(native_handle_) == 0 ? X_STATUS_SUCCESS
: X_STATUS_UNSUCCESSFUL; : X_STATUS_UNSUCCESSFUL;
} }
} // namespace kernel } // namespace kernel

4
src/xenia/kernel/objects/xtimer.h
View File

@ -28,10 +28,10 @@ class XTimer : public XObject {
uint32_t routine_arg, bool resume); uint32_t routine_arg, bool resume);
X_STATUS Cancel(); X_STATUS Cancel();
virtual void* GetWaitHandle() { return handle_; } virtual void* GetWaitHandle() { return native_handle_; }
private: private:
HANDLE handle_; HANDLE native_handle_;
uint32_t current_routine_; uint32_t current_routine_;
uint32_t current_routine_arg_; uint32_t current_routine_arg_;