Clean up some warnings

src/citra_qt/debugger/callstack.cpp

@@ -27,10 +27,10 @@ void CallstackWidget::OnCPUStepped()
     ARM_Interface* app_core = Core::g_app_core;
 
     u32 sp = app_core->GetReg(13); //stack pointer
-    u32 addr, ret_addr, call_addr, func_addr;
+    u32 ret_addr, call_addr, func_addr;
 
     int counter = 0;
-    for (int addr = 0x10000000; addr >= sp; addr -= 4)
+    for (u32 addr = 0x10000000; addr >= sp; addr -= 4)
     {
         ret_addr = Memory::Read32(addr);
         call_addr = ret_addr - 4; //get call address???

src/citra_qt/debugger/graphics_framebuffer.cpp

@@ -224,8 +224,8 @@ void GraphicsFramebufferWidget::OnUpdate()
     {
         QImage decoded_image(framebuffer_width, framebuffer_height, QImage::Format_ARGB32);
         u32* color_buffer = (u32*)Memory::GetPointer(framebuffer_address);
-        for (int y = 0; y < framebuffer_height; ++y) {
+        for (unsigned y = 0; y < framebuffer_height; ++y) {
-            for (int x = 0; x < framebuffer_width; ++x) {
+            for (unsigned x = 0; x < framebuffer_width; ++x) {
                 u32 value = *(color_buffer + x + y * framebuffer_width);
 
                 decoded_image.setPixel(x, y, qRgba((value >> 16) & 0xFF, (value >> 8) & 0xFF, value & 0xFF, 255/*value >> 24*/));
@@ -239,8 +239,8 @@ void GraphicsFramebufferWidget::OnUpdate()
     {
         QImage decoded_image(framebuffer_width, framebuffer_height, QImage::Format_ARGB32);
         u8* color_buffer = Memory::GetPointer(framebuffer_address);
-        for (int y = 0; y < framebuffer_height; ++y) {
+        for (unsigned y = 0; y < framebuffer_height; ++y) {
-            for (int x = 0; x < framebuffer_width; ++x) {
+            for (unsigned x = 0; x < framebuffer_width; ++x) {
                 u8* pixel_pointer = color_buffer + x * 3 + y * 3 * framebuffer_width;
 
                 decoded_image.setPixel(x, y, qRgba(pixel_pointer[0], pixel_pointer[1], pixel_pointer[2], 255/*value >> 24*/));
@@ -254,8 +254,8 @@ void GraphicsFramebufferWidget::OnUpdate()
     {
         QImage decoded_image(framebuffer_width, framebuffer_height, QImage::Format_ARGB32);
         u32* color_buffer = (u32*)Memory::GetPointer(framebuffer_address);
-        for (int y = 0; y < framebuffer_height; ++y) {
+        for (unsigned y = 0; y < framebuffer_height; ++y) {
-            for (int x = 0; x < framebuffer_width; ++x) {
+            for (unsigned x = 0; x < framebuffer_width; ++x) {
                 u16 value = *(u16*)(((u8*)color_buffer) + x * 2 + y * framebuffer_width * 2);
                 u8 r = (value >> 11) & 0x1F;
                 u8 g = (value >> 6) & 0x1F;

src/citra_qt/util/spinbox.cpp

@@ -238,7 +238,7 @@ QValidator::State CSpinBox::validate(QString& input, int& pos) const
     if (!prefix.isEmpty() && input.left(prefix.length()) != prefix)
         return QValidator::Invalid;
 
-    unsigned strpos = prefix.length();
+    int strpos = prefix.length();
 
     // Empty "numbers" allowed as intermediate values
     if (strpos >= input.length() - HasSign() - suffix.length())

src/core/file_sys/archive_backend.h

@@ -143,7 +143,16 @@ public:
             case Char:
                 return std::vector<u8>(string.begin(), string.end());
             case Wchar:
-                return std::vector<u8>(u16str.begin(), u16str.end());
+            {
+                // use two u8 for each character of u16str
+                std::vector<u8> to_return(u16str.size() * 2);
+                for (size_t i = 0; i < u16str.size(); ++i) {
+                    u16 tmp_char = u16str.at(i);
+                    to_return[i*2] = (tmp_char & 0xFF00) >> 8;
+                    to_return[i*2 + 1] = (tmp_char & 0x00FF);
+                }
+                return to_return;
+            }
             case Empty:
                 return {};
             default:

src/core/hle/kernel/semaphore.cpp

@@ -20,8 +20,8 @@ public:
     static Kernel::HandleType GetStaticHandleType() { return Kernel::HandleType::Semaphore; }
     Kernel::HandleType GetHandleType() const override { return Kernel::HandleType::Semaphore; }
 
-    u32 max_count;                              ///< Maximum number of simultaneous holders the semaphore can have
+    s32 max_count;                              ///< Maximum number of simultaneous holders the semaphore can have
-    u32 available_count;                        ///< Number of free slots left in the semaphore
+    s32 available_count;                        ///< Number of free slots left in the semaphore
     std::queue<Handle> waiting_threads;         ///< Threads that are waiting for the semaphore
     std::string name;                           ///< Name of semaphore (optional)
 
@@ -49,8 +49,8 @@ public:
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-ResultCode CreateSemaphore(Handle* handle, u32 initial_count, 
+ResultCode CreateSemaphore(Handle* handle, s32 initial_count, 
-    u32 max_count, const std::string& name) {
+    s32 max_count, const std::string& name) {
 
     if (initial_count > max_count)
         return ResultCode(ErrorDescription::InvalidCombination, ErrorModule::Kernel,

src/core/hle/kernel/semaphore.h

@@ -18,7 +18,7 @@ namespace Kernel {
  * @param name Optional name of semaphore
  * @return ResultCode of the error
  */
-ResultCode CreateSemaphore(Handle* handle, u32 initial_count, u32 max_count, const std::string& name = "Unknown");
+ResultCode CreateSemaphore(Handle* handle, s32 initial_count, s32 max_count, const std::string& name = "Unknown");
 
 /**
  * Releases a certain number of slots from a semaphore.

src/core/loader/3dsx.cpp

@@ -223,9 +223,7 @@ int THREEDSXReader::Load3DSXFile(const std::string& filename, u32 base_addr)
         LOG_INFO(Loader, "Loading 3DSX file %s...", filename.c_str());
         FileUtil::IOFile file(filename, "rb");
         if (file.IsOpen()) {
-
+            THREEDSXReader::Load3DSXFile(filename, 0x00100000);
-            THREEDSXReader reader;
-            reader.Load3DSXFile(filename, 0x00100000);
             Kernel::LoadExec(0x00100000);
         } else {
             return ResultStatus::Error;

src/video_core/renderer_opengl/renderer_opengl.cpp

@@ -240,14 +240,14 @@ MathUtil::Rectangle<unsigned> RendererOpenGL::GetViewportExtent() {
     MathUtil::Rectangle<unsigned> viewport_extent;
     if (window_aspect_ratio > emulation_aspect_ratio) {
         // Window is narrower than the emulation content => apply borders to the top and bottom
-        unsigned viewport_height = std::round(emulation_aspect_ratio * framebuffer_width);
+        unsigned viewport_height = static_cast<unsigned>(std::round(emulation_aspect_ratio * framebuffer_width));
         viewport_extent.left = 0;
         viewport_extent.top = (framebuffer_height - viewport_height) / 2;
         viewport_extent.right = viewport_extent.left + framebuffer_width;
         viewport_extent.bottom = viewport_extent.top + viewport_height;
     } else {
         // Otherwise, apply borders to the left and right sides of the window.
-        unsigned viewport_width = std::round(framebuffer_height / emulation_aspect_ratio);
+        unsigned viewport_width = static_cast<unsigned>(std::round(framebuffer_height / emulation_aspect_ratio));
         viewport_extent.left = (framebuffer_width - viewport_width) / 2;
         viewport_extent.top = 0;
         viewport_extent.right = viewport_extent.left + viewport_width;