}

Config config;

if (!Settings::values.enable_log)

LogManager::Shutdown();

// Licensed under GPLv2

// Refer to the license.txt file included.

#include "common/common.h"

#include "video_core/video_core.h"

#include "citra/emu_window/emu_window_glfw.h"

/// Called by GLFW when a key event occurs

void EmuWindow_GLFW::OnKeyEvent(GLFWwindow* win, int key, int scancode, int action, int mods) {

if (action == GLFW_PRESS) {

EmuWindow::KeyPressed({key, keyboard_id});

EmuWindow::KeyReleased({key, keyboard_id});

}

HID_User::PadUpdateComplete();

}

return glfwWindowShouldClose(m_render_window) == 0;

}

/// EmuWindow_GLFW constructor

EmuWindow_GLFW::EmuWindow_GLFW() {

keyboard_id = KeyMap::NewDeviceId();

// GLFW on OSX requires these window hints to be set to create a 3.2+ GL context.

glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);

glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

if (m_render_window == NULL) {

printf("Failed to create GLFW window! Exiting...");

exit(1);

}

glfwSetWindowUserPointer(m_render_window, this);

glfwSetKeyCallback(m_render_window, OnKeyEvent);

DoneCurrent();

}

KeyMap::SetKeyMapping({Settings::values.pad_sup_key, keyboard_id}, HID_User::PAD_CIRCLE_UP);

KeyMap::SetKeyMapping({Settings::values.pad_sdown_key, keyboard_id}, HID_User::PAD_CIRCLE_DOWN);

}

#pragma once

#include "common/emu_window.h"

class EmuWindow_GLFW : public EmuWindow {

public:

EmuWindow_GLFW();

/// Swap buffers to display the next frame

void SwapBuffers() override;

/// Makes the graphics context current for the caller thread

void MakeCurrent() override;

/// Releases (dunno if this is the "right" word) the GLFW context from the caller thread

void DoneCurrent() override;

/// Whether the window is still open, and a close request hasn't yet been sent

const bool IsOpen();

void ReloadSetKeymaps() override;

private:

GLFWwindow* m_render_window; ///< Internal GLFW render window

/// Device id of keyboard for use with KeyMap

#include <QKeyEvent>

#include <QApplication>

#include "common/common.h"

#include "bootmanager.hxx"

#define APP_TITLE APP_NAME " " APP_VERSION

#define COPYRIGHT "Copyright (C) 2013-2014 Citra Team"

filename(""), exec_cpu_step(false), cpu_running(false),

stop_run(false), render_window(render_window)

{

if (cpu_running)

{

Core::RunLoop();

else if (exec_cpu_step)

{

exec_cpu_step = false;

class GGLWidgetInternal : public QGLWidget

{

public:

}

}

void resizeEvent(QResizeEvent* ev) override {

}

private:

};

EmuThread& GRenderWindow::GetEmuThread()

GRenderWindow::GRenderWindow(QWidget* parent) : QWidget(parent), emu_thread(this), keyboard_id(0)

{

keyboard_id = KeyMap::NewDeviceId();

ReloadSetKeymaps();

fmt.setProfile(QGLFormat::CoreProfile);

// Requests a forward-compatible context, which is required to get a 3.2+ context on OS X

fmt.setOption(QGL::NoDeprecatedFunctions);

child = new GGLWidgetInternal(fmt, this);

QBoxLayout* layout = new QHBoxLayout(this);

resize(VideoCore::kScreenTopWidth, VideoCore::kScreenTopHeight + VideoCore::kScreenBottomHeight);

layout->addWidget(child);

layout->setMargin(0);

setLayout(layout);

BackupGeometry();

}

void GRenderWindow::moveContext()

}

void GRenderWindow::PollEvents() {

}

void GRenderWindow::BackupGeometry()

KeyMap::SetKeyMapping({Settings::values.pad_sdown_key, keyboard_id}, HID_User::PAD_CIRCLE_DOWN);

}

#include <QThread>

#include <QGLWidget>

#include "common/common.h"

#include "common/emu_window.h"

class QKeyEvent;

class EmuThread : public QThread

{

Q_OBJECT

public:

/**

* Set image filename

* @param filename

* @warning Only call when not running!

*/

signals:

/**

* Emitted when CPU when we've finished processing a single Gekko instruction

* @warning This will only be emitted when the CPU is not running (SetCpuRunning(false))

* @warning When connecting to this signal from other threads, make sure to specify either Qt::QueuedConnection (invoke slot within the destination object's message thread) or even Qt::BlockingQueuedConnection (additionally block source thread until slot returns)

*/

void BackupGeometry();

void RestoreGeometry();

void restoreGeometry(const QByteArray& geometry); // overridden

EmuThread& GetEmuThread();

void ReloadSetKeymaps() override;

public slots:

private:

QGLWidget* child;

EmuThread emu_thread;

else if (config.keys.key_code[id] == Qt::Key_Control) text = tr("Control");

else if (config.keys.key_code[id] == Qt::Key_Alt) text = tr("Alt");

else if (config.keys.key_code[id] == Qt::Key_Meta) text = tr("Meta");

}

void GKeyConfigButton::OnClicked()

setLayout(layout);

}

u32 sp = app_core->GetReg(13); //stack pointer

u32 addr, ret_addr, call_addr, func_addr;

int counter = 0;

for (int addr = 0x10000000; addr >= sp; addr -= 4)

{

callstack_model->setItem(counter, 0, new QStandardItem(QString("0x%1").arg(addr, 8, 16, QLatin1Char('0'))));

callstack_model->setItem(counter, 1, new QStandardItem(QString("0x%1").arg(ret_addr, 8, 16, QLatin1Char('0'))));

callstack_model->setItem(counter, 2, new QStandardItem(QString("0x%1").arg(call_addr, 8, 16, QLatin1Char('0'))));

name = Symbols::HasSymbol(func_addr) ? Symbols::GetSymbol(func_addr).name : "unknown";

callstack_model->setItem(counter, 3, new QStandardItem(QString("%1_%2").arg(QString::fromStdString(name))

.arg(QString("0x%1").arg(func_addr, 8, 16, QLatin1Char('0')))));

counter++;

}

}

CSPR->setText(1, QString("0x%1").arg(app_core->GetCPSR(), 8, 16, QLatin1Char('0')));

CSPR->child(0)->setText(1, QString("b%1").arg(app_core->GetCPSR() & 0x1F, 5, 2, QLatin1Char('0'))); // M - Mode

}

void OnCPUStepped();

private:

};

connect(GetHotkey("Main Window", "Load File", this), SIGNAL(activated()), this, SLOT(OnMenuLoadFile()));

connect(GetHotkey("Main Window", "Start Emulation", this), SIGNAL(activated()), this, SLOT(OnStartGame()));

show();

PointerWrapSection(PointerWrap &p, int ver, const char *title) : p_(p), ver_(ver), title_(title) {

}

~PointerWrapSection();

bool operator == (const int &v) const { return ver_ == v; }

bool operator != (const int &v) const { return ver_ != v; }

bool operator <= (const int &v) const { return ver_ <= v; }

}

(*ptr) += size;

}

template<class K, class T>

void Do(std::map<K, T *> &x)

{

if (vec_size > 0)

DoArray(&x[0], vec_size);

}

// Store deques.

template<class T>

void Do(std::deque<T *> &x)

}

// Store strings.

{

int stringLen = (int)x.length() + 1;

Do(stringLen);

switch (mode) {

case MODE_READ: x = (char*)*ptr; break;

case MODE_WRITE: memcpy(*ptr, x.c_str(), stringLen); break;

(*ptr) += stringLen;

}

{

int stringLen = sizeof(wchar_t)*((int)x.length() + 1);

Do(stringLen);

void Do(T &x) {

DoHelper<T>::Do(this, x);

}

template<class T>

void DoPOD(T &x) {

DoHelper<T>::Do(this, x);

#define b2(x) ( (x) | ( (x) >> 1) )

#define b4(x) ( b2(x) | ( b2(x) >> 2) )

#define b8(x) ( b4(x) | ( b4(x) >> 4) )

#define b32(x) (b16(x) | (b16(x) >>16) )

#define ROUND_UP_POW2(x) (b32(x - 1) + 1)

#define unlink _unlink

#define snprintf _snprintf

#define vscprintf _vscprintf

// Locale Cross-Compatibility

#define locale_t _locale_t

#define freelocale _free_locale

#define newlocale(mask, locale, base) _create_locale(mask, locale)

#define LC_GLOBAL_LOCALE ((locale_t)-1)

#define LC_ALL_MASK LC_ALL

#define LC_COLLATE_MASK LC_COLLATE

#define LC_MONETARY_MASK LC_MONETARY

#define LC_NUMERIC_MASK LC_NUMERIC

#define LC_TIME_MASK LC_TIME

inline locale_t uselocale(locale_t new_locale)

{

// Retrieve the current per thread locale setting

inline u32 swap32(u32 _data) {return _byteswap_ulong (_data);}

inline u64 swap64(u64 _data) {return _byteswap_uint64(_data);}

#elif _M_ARM

inline u64 swap64(u64 _data) {return ((u64)swap32(_data) << 32) | swap32(_data >> 32);}

#elif __linux__

inline u16 swap16(u16 _data) {return bswap_16(_data);}

inline T FromBigEndian(T data)

{

//static_assert(std::is_arithmetic<T>::value, "function only makes sense with arithmetic types");

swap<sizeof(data)>(reinterpret_cast<u8*>(&data));

return data;

}

* http://code.google.com/p/gekko-gc-emu/

*/

#include <cmath>

#include <cstdint>

/// Union for fast 16-bit type casting

union t16 {

};

/// Union for fast 32-bit type casting

/*

LetterSpace: SetConsoleScreenBufferSize and SetConsoleWindowInfo are

*/

void ConsoleListener::BufferWidthHeight(int BufferWidth, int BufferHeight, int ScreenWidth, int ScreenHeight, bool BufferFirst)

{

BytesWritten += cAttrWritten;

coordScreen = GetCoordinates(BytesWritten, LBufWidth);

const int OldCursor = ConInfo.dwCursorPosition.Y * ConInfo.dwSize.X + ConInfo.dwCursorPosition.X;

COORD Coo = GetCoordinates(OldCursor, LBufWidth);

}

// Clear console screen

void ConsoleListener::ClearScreen(bool Cursor)

#if defined(_WIN32)

dwConSize = csbi.dwSize.X * csbi.dwSize.Y;

// Write space to the entire console

FillConsoleOutputAttribute(hConsole, csbi.wAttributes, dwConSize, coordScreen, &cCharsWritten);

// Reset cursor

#endif

}

#include "common/string_util.h"

#include "common/key_map.h"

class EmuWindow

{

public:

struct WindowConfig {

bool fullscreen;

int res_width;

int res_height;

};

/// Swap buffers to display the next frame

/// Signals a key release action to the HID module

static void KeyReleased(KeyMap::HostDeviceKey key);

}

void SetConfig(const WindowConfig& val) {

}

}

}

}

}

}

};

void PCSTR2LPTSTR( PCSTR lpszIn, LPTSTR lpszOut )

{

#if defined(UNICODE)||defined(_UNICODE)

PCSTR lpAct = lpszIn;

for( ; ; lpAct++ )

lpszOut[index++] = (TCHAR)(*lpAct);

if ( *lpAct == 0 )

break;

#else

// This is trivial :)

strcpy( lpszOut, lpszIn );

CHAR lpszSymbolPath[BUFFERSIZE];

DWORD symOptions = SymGetOptions();

symOptions &= ~SYMOPT_UNDNAME;

SymSetOptions( symOptions );

InitSymbolPath( lpszSymbolPath, lpszInitialSymbolPath );

#ifndef _M_X64

DWORD dwDisp = 0;

if ( SymGetSymFromAddr( GetCurrentProcess(), (ULONG)fnAddress, &dwDisp, pSym ) )

//makes it compile but hell im not sure if this works...

DWORD64 dwDisp = 0;

if ( SymGetSymFromAddr( GetCurrentProcess(), (ULONG)fnAddress, (PDWORD64)&dwDisp, pSym ) )

#endif

{

// Make the symbol readable for humans

UNDNAME_NO_THISTYPE |

UNDNAME_NO_SPECIAL_SYMS |

UNDNAME_NO_MEMBER_TYPE |

_tcscat( lpszSymbol, lpszParsed );

ret = TRUE;

GlobalFree( pSym );

return ret;

PrintFunctionAndSourceInfo(file, callStack);

{

bResult = StackWalk(

IMAGE_FILE_MACHINE_I386,

hProcess,

hThread,

&callStack,

NULL,

SymFunctionTableAccess,

SymGetModuleBase,

if ( index == 0 )

continue;

break;

PrintFunctionAndSourceInfo(file, callStack);

PrintFunctionAndSourceInfo(file, callStack);

{

bResult = StackWalk(

IMAGE_FILE_MACHINE_I386,

hProcess,

hThread,

&callStack,

NULL,

SymFunctionTableAccess,

SymGetModuleBase,

if ( index == 0 )

continue;

break;

PrintFunctionAndSourceInfo(file, callStack);

// create the element, add it to the queue

m_write_ptr->current = new T(std::forward<Arg>(t));

// set the next pointer to a new element ptr

m_write_ptr = m_write_ptr->next = new ElementPtr();

Common::AtomicIncrement(m_size);

}

bool bkeepLooping = true;

while (bkeepLooping)

if (findData.cFileName[0] != '.')

{

std::string strFilename;

#endif

if (result < 0) {

filename.c_str(), GetLastErrorMsg());

return false;

}

{

INFO_LOG(COMMON, "Delete: file %s", filename.c_str());

// being there, not the actual delete.

if (!Exists(filename))

{

#ifdef _WIN32

if (!DeleteFile(Common::UTF8ToTStr(filename).c_str()))

{

filename.c_str(), GetLastErrorMsg());

return false;

}

#else

if (unlink(filename.c_str()) == -1) {

filename.c_str(), GetLastErrorMsg());

return false;

}

return false;

}

bool Rename(const std::string &srcFilename, const std::string &destFilename)

{

srcFilename.c_str(), destFilename.c_str());

if (rename(srcFilename.c_str(), destFilename.c_str()) == 0)

return true;

srcFilename.c_str(), destFilename.c_str(), GetLastErrorMsg());

return false;

}

bool Copy(const std::string &srcFilename, const std::string &destFilename)

{

srcFilename.c_str(), destFilename.c_str());

#ifdef _WIN32

if (CopyFile(Common::UTF8ToTStr(srcFilename).c_str(), Common::UTF8ToTStr(destFilename).c_str(), FALSE))

return true;

srcFilename.c_str(), destFilename.c_str(), GetLastErrorMsg());

return false;

#else

FILE *input = fopen(srcFilename.c_str(), "rb");

if (!input)

{

srcFilename.c_str(), destFilename.c_str(), GetLastErrorMsg());

return false;

}

if (!output)

{

fclose(input);

srcFilename.c_str(), destFilename.c_str(), GetLastErrorMsg());

return false;

}

{

if (ferror(input) != 0)

{

srcFilename.c_str(), destFilename.c_str(), GetLastErrorMsg());

goto bail;

}

int wnum = fwrite(buffer, sizeof(char), rnum, output);

if (wnum != rnum)

{

srcFilename.c_str(), destFilename.c_str(), GetLastErrorMsg());

goto bail;

}

WARN_LOG(COMMON, "GetSize: failed %s: is a directory", filename.c_str());

return 0;

}

struct stat64 buf;

#ifdef _WIN32

if (_tstat64(Common::UTF8ToTStr(filename).c_str(), &buf) == 0)

return size;

}

bool CreateEmptyFile(const std::string &filename)

{

if (!FileUtil::IOFile(filename, "wb"))

{

#endif

// check for "." and ".."

if (((virtualName[0] == '.') && (virtualName[1] == '\0')) ||

(virtualName[2] == '\0')))

continue;

entry.virtualName = virtualName;

foundEntries += (u32)entry.size;

}

else

entry.isDirectory = false;

entry.size = GetSize(entry.physicalName.c_str());

}

++foundEntries;

// Push into the tree

} while (FindNextFile(hFind, &ffd) != 0);

FindClose(hFind);

#else

// check for "." and ".."

if (((virtualName[0] == '.') && (virtualName[1] == '\0')) ||

(virtualName[2] == '\0')))

continue;

closedir(dirp);

#endif

FileUtil::DeleteDir(directory);

return true;

}

std::string GetCurrentDir()

{

char *dir;

if (!(dir = __getcwd(NULL, 0))) {

ERROR_LOG(COMMON, "GetCurrentDirectory failed: %s",

}

#if defined(__APPLE__)

{

CFURLRef BundleRef;

char AppBundlePath[MAXPATHLEN];

if (FileUtil::Exists(ROOT_DIR DIR_SEP USERDATA_DIR))

paths[D_USER_IDX] = ROOT_DIR DIR_SEP USERDATA_DIR DIR_SEP;

else

getenv("PWD") : "") + DIR_SEP EMU_DATA_DIR DIR_SEP;

#endif

paths[F_MAINLOG_IDX] = paths[D_LOGS_IDX] + MAIN_LOG;

}

}

return paths[DirIDX];

}

// if (!FileUtil::Exists(dir))

// dir = SHARED_USER_DIR THEMES_DIR "/" + theme_name + "/";

//#endif

// return dir;

//}

// User directory indices for GetUserPath

enum {

};

namespace FileUtil

// FileSystem tree node/

struct FSTEntry

{

};

// Returns true if file filename exists

class IOFile : public NonCopyable

{

public:

private:

};

} // namespace

void OpenFStream(T& fstream, const std::string& filename, std::ios_base::openmode openmode)

{

#ifdef _WIN32

#else

#endif

}

inline void bmix64(u64 & h1, u64 & h2, u64 & k1, u64 & k2, u64 & c1, u64 & c2)

{

k1 *= c2;

h1 ^= k1;

h1 += h2;

h2 = _rotl64(h2,41);

k2 = _rotl64(k2,23);

k2 *= c1;

h2 ^= k2;

}

* NOTE: This hash function is used for custom texture loading/dumping, so

* it should not be changed, which would require all custom textures to be

* recalculated for their new hash values. If the hashing function is

u64 k = data[0];

data+=Step;

k *= m;

k *= m;

h ^= k;

h *= m;

case 1: h ^= u64(data2[0]);

h *= m;

};

h ^= h >> r;

h *= m;

h ^= h >> r;

return h;

#else

// CRC32 hash using the SSE4.2 instruction

u64 GetCRC32(const u8 *src, int len, u32 samples)

inline void bmix32(u32 & h1, u32 & h2, u32 & k1, u32 & k2, u32 & c1, u32 & c2)

{

k1 *= c2;

h1 ^= k1;

h1 += h2;

h2 = _rotl(h2,17);

k2 = _rotl(k2,11);

k2 *= c1;

h2 ^= k2;

//----------

// tail

const u8 * tail = (const u8*)(data + nblocks*8);

u32 k1 = 0;

out[0] = h1;

out[1] = h2;

return *((u64 *)&out);

}

{

u64 k = data[0];

data+=Step;

k *= m;

h ^= k;

}

const u8 * data2 = (const u8*)end;

case 1: h ^= u64(data2[0]);

h *= m;

};

h ^= h >> r;

h *= m;

h ^= h >> r;

m_file.seekg(0, std::ios::beg);

std::fstream::pos_type start_pos = m_file.tellg();

std::streamoff file_size = end_pos - start_pos;

if (m_file.is_open() && ValidateHeader())

{

// good header, read some key/value pairs

// read key/value and pass to reader

if (Read(&key) &&

Read(&entry_number) &&

entry_number == m_num_entries+1)

{

WriteHeader();

return 0;

}

void Sync()

{

m_file.flush();

enum {

OS_LEVEL, // Printed by the emulated operating system

NOTICE_LEVEL, // VERY important information that is NOT errors. Like startup and OSReports.

WARNING_LEVEL, // Something is suspicious.

INFO_LEVEL, // General information.

DEBUG_LEVEL, // Detailed debugging - might make things slow.

MEMMAP,

MEMCARD_MANAGER,

OSREPORT,

PROCESSORINTERFACE,

PIXELENGINE,

SERIALINTERFACE,

HW,

TIME,

NETPLAY,

NUMBER_OF_LOGS // Must be last

};

} // namespace

const char* function, const char* fmt, ...)

#ifdef __GNUC__

__attribute__((format(printf, 6, 7)))

#include "common/timer.h"

#include "common/thread.h"

const char* function, const char* fmt, ...)

{

va_list args;

m_Log[LogTypes::ACTIONREPLAY] = new LogContainer("ActionReplay", "ActionReplay");

m_Log[LogTypes::MEMCARD_MANAGER] = new LogContainer("MemCard Manager", "MemCard Manager");

m_Log[LogTypes::NETPLAY] = new LogContainer("NETPLAY", "Netplay");

m_fileLog = new FileLogListener(FileUtil::GetUserPath(F_MAINLOG_IDX).c_str());

m_consoleLog = new ConsoleListener();

delete m_debuggerLog;

}

int line, const char* function, const char *fmt, va_list args)

{

char temp[MAX_MSGLEN];

Common::CharArrayFromFormatV(temp, MAX_MSGLEN, fmt, args);

static const char level_to_char[7] = "ONEWID";

level_to_char[(int)level], log->GetShortName(), function, temp);

#ifdef ANDROID

#endif

log->Trigger(level, msg);

}

{

public:

LogContainer(const char* shortName, const char* fullName, bool enable = false);

const char* GetShortName() const { return m_shortName; }

const char* GetFullName() const { return m_fullName; }

static u32 GetMaxLevel() { return LogTypes::MAX_LOGLEVEL; }

const char* function, const char *fmt, va_list args);

void SetLogLevel(LogTypes::LOG_TYPE type, LogTypes::LOG_LEVELS level)

value.d = dvalue;

u64 sign = value.i & DOUBLE_SIGN;

u64 exp = value.i & DOUBLE_EXP;

{

// Nice normalized number.

return sign ? PPC_FPCLASS_NN : PPC_FPCLASS_PN;

value.f = fvalue;

u32 sign = value.i & FLOAT_SIGN;

u32 exp = value.i & FLOAT_EXP;

{

// Nice normalized number.

return sign ? PPC_FPCLASS_NN : PPC_FPCLASS_PN;

// Denormalized number.

return sign ? PPC_FPCLASS_ND : PPC_FPCLASS_PD;

}

{

// Infinite

return sign ? PPC_FPCLASS_NINF : PPC_FPCLASS_PINF;

{

//Zero

return sign ? PPC_FPCLASS_NZ : PPC_FPCLASS_PZ;

mtx.data[0] = c;

mtx.data[2] = s;

mtx.data[4] = 1;

mtx.data[8] = c;

}

#include "common/common.h"

#include <algorithm>

#include <vector>

namespace MathUtil

Rectangle(T theLeft, T theTop, T theRight, T theBottom)

: left(theLeft), top(theTop), right(theRight), bottom(theBottom)

{ }

bool operator==(const Rectangle& r) { return left==r.left && top==r.top && right==r.right && bottom==r.bottom; }

// If the rectangle is in a coordinate system with a lower-left origin, use

// this Clamp.

// If the rectangle is in a coordinate system with an upper-left origin,

// use this Clamp.

{

if (left < x1) left = x1;

if (right > x2) right = x2;

// Hopefully this ABI will never change...

/*

* ashmem_create_region - creates a new ashmem region and returns the file

// yeah, this could also be done in like two bitwise ops...

static bool Memory_TryBase(u8 *base, const MemoryView *views, int num_views, u32 flags, MemArena *arena) {

// OK, we know where to find free space. Now grab it!

// printf("Mapped executable memory at %p (size %ld)\n", ptr,

// (unsigned long)size);

#ifdef _WIN32

if (ptr == nullptr)

{

if (ptr == MAP_FAILED)

{

ptr = nullptr;

PanicAlert("Failed to allocate executable memory");

}

#if !defined(_WIN32) && defined(__x86_64__) && !defined(MAP_32BIT)

if (ptr)

{

#ifdef _WIN32

if (!VirtualFree(ptr, 0, MEM_RELEASE))

PanicAlert("FreeMemoryPages failed!\n%s", GetLastErrorMsg());

ptr = NULL; // Is this our responsibility?

#else

munmap(ptr, size);

#endif

CRITICAL

};

bool yes_no, int Style);

typedef std::string (*StringTranslator)(const char* text);

#ifndef GEKKO

#ifdef _WIN32

// Use these macros (that do the same thing) if the message should be translated.

#else

// Use these macros (that do the same thing) if the message should be translated.

#endif

#else

// GEKKO

{

std::ostringstream oss;

oss << std::setfill('0') << std::hex;

for (int line = 0; size; ++data, --size)

{

oss << std::setw(2) << (int)*data;

if (line_len == ++line)

{

oss << '\n';

errno = 0;

unsigned long value = strtoul(str.c_str(), &endptr, 0);

if (!endptr || *endptr)

return false;

//#include <string>

//#include <assert.h>

{

/* 0 1 2 3 4 5 6 7 8 9 A B C D E F */

/* 0 */ 16,16,16,16, 16,16,16,16, 16,16,16,16, 16,16,16,16,

const unsigned char * pSrc = (const unsigned char *)sSrc.c_str();

const size_t SRC_LEN = sSrc.length();

const unsigned char * const SRC_END = pSrc + SRC_LEN;

char * const pStart = new char[SRC_LEN];

char * pEnd = pStart;

for (; pSrc < SRC_END; ++pSrc)

{

*pEnd++ = *pSrc;

else

{

out_buffer.resize(out_buffer_size - dst_bytes);

out_buffer.swap(result);

iconv_close(conv_desc);

return result;

}

out_buffer.swap(result);

iconv_close(conv_desc);

return result;

}

static bool TryParse(const std::string &str, N *const output)

{

std::istringstream iss(str);

N tmp = 0;

if (iss >> tmp)

{

{

TSymbolsMap::iterator foundSymbolItr;

TSymbol symbol;

foundSymbolItr = g_symbols.find(_address);

if (foundSymbolItr != g_symbols.end())

{

{

return GetSymbol(_address).name;

}

void Remove(u32 _address)

{

g_symbols.erase(_address);

const std::string GetName(u32 _address);

void Remove(u32 _address);

void Clear();

return 0;

#endif

}

#ifdef _WIN32

void SetThreadAffinity(std::thread::native_handle_type thread, u32 mask)

// Sets the debugger-visible name of the current thread.

// Uses undocumented (actually, it is now documented) trick.

// http://msdn.microsoft.com/library/default.asp?url=/library/en-us/vsdebug/html/vxtsksettingthreadname.asp

// This is implemented much nicer in upcoming msvc++, see:

// http://msdn.microsoft.com/en-us/library/xcb2z8hs(VS.100).aspx

void SetCurrentThreadName(const char* szThreadName)

__except(EXCEPTION_CONTINUE_EXECUTION)

{}

}

#else // !WIN32, so must be POSIX threads

void SetThreadAffinity(std::thread::native_handle_type thread, u32 mask)

void SetThreadAffinity(std::thread::native_handle_type thread, u32 mask);

void SetCurrentThreadAffinity(u32 mask);

class Event

{

public:

Event()

: is_set(false)

void Set()

{

const size_t m_count;

volatile size_t m_waiting;

};

void SleepCurrentThread(int ms);

void SwitchCurrentThread(); // On Linux, this is equal to sleep 1ms

{

std::this_thread::yield();

}

void SetCurrentThreadName(const char *name);

} // namespace Common

// Copyright 2014 Citra Emulator Project / PPSSPP Project

// Licensed under GPLv2

#pragma once

struct ThreadQueueList {

// Number of queues (number of priority levels starting at 0.)

static const int NUM_QUEUES = 128;

// Initial number of threads a single queue can handle.

static const int INITIAL_CAPACITY = 32;

hle/kernel/shared_memory.cpp

hle/kernel/thread.cpp

hle/service/ac_u.cpp

hle/service/apt_u.cpp

hle/service/boss_u.cpp

hle/service/cfg_u.cpp

hle/service/dsp_dsp.cpp

hle/service/err_f.cpp

hle/service/fs_user.cpp

hle/service/frd_u.cpp

hle/service/gsp_gpu.cpp

hle/service/hid_user.cpp

hle/service/mic_u.cpp

hle/service/ndm_u.cpp

hle/service/nwm_uds.cpp

hle/service/ptm_u.cpp

hle/service/service.cpp

hle/service/soc_u.cpp

hle/kernel/shared_memory.h

hle/kernel/thread.h

hle/service/ac_u.h

hle/service/apt_u.h

hle/service/boss_u.h

hle/service/cfg_u.h

hle/service/dsp_dsp.h

hle/service/err_f.h

hle/service/fs_user.h

hle/service/frd_u.h

hle/service/gsp_gpu.h

hle/service/hid_user.h

hle/service/mic_u.h

hle/service/ndm_u.h

hle/service/nwm_uds.h

hle/service/ptm_u.h

hle/service/service.h

hle/service/soc_u.h

// Copyright 2014 Citra Emulator Project

// Licensed under GPLv2

#pragma once

* Get the current CPSR register

* @return Returns the value of the CPSR register

*/

/**

* Set the current CPSR register

}

protected:

/**

* Executes the given number of instructions

* @param num_instructions Number of instructions to executes

while (std::getline(infile, line)) {

std::istringstream iss(line);

}

u32 address = std::stoul(address_str, nullptr, 16);

// Copyright 2014 Citra Emulator Project

// Licensed under GPLv2

#include "core/arm/skyeye_common/armcpu.h"

#include "core/arm/skyeye_common/armemu.h"

state->NumInstrsToExecute = num_instructions;

// Dyncom only breaks on instruction dispatch. This only happens on every instruction when

// instructions may actually be executed than specified.

ticks += InterpreterMainLoop(state.get());

}

// Copyright 2014 Citra Emulator Project

// Licensed under GPLv2

#pragma once

/**

* Set the Program Counter to an address

*/

void SetPC(u32 pc) override;

// Copyright 2014 Citra Emulator Project

// Licensed under GPLv2

#pragma once

// Copyright 2014 Citra Emulator Project

// Licensed under GPLv2

#include "core/arm/interpreter/arm_interpreter.h"

state->lateabtSig = LOW;

// Reset the core to initial state

ARMul_Reset(state);

state->NextInstr = RESUME; // NOTE: This will be overwritten by LoadContext

state->Emulate = 3;

// Copyright 2014 Citra Emulator Project

// Licensed under GPLv2

#pragma once

/**

* Set the Program Counter to an address

*/

void SetPC(u32 pc) override;

namespace Core {

/// Run the core CPU loop

void RunLoop(int tight_loop) {

int Init() {

NOTICE_LOG(MASTER_LOG, "initialized OK");

g_sys_core = new ARM_Interpreter();

switch (Settings::values.cpu_core) {

break;

}

return 0;

}

void Shutdown() {

delete g_app_core;

delete g_sys_core;

s64 time;

u64 userdata;

int type;

};

typedef LinkedListItem<BaseEvent> Event;

// This must be run ONLY from within the cpu thread

// cyclesIntoFuture may be VERY inaccurate if called from anything else

void ScheduleEvent(s64 cyclesIntoFuture, int event_type, u64 userdata)

{

Event *ne = GetNewEvent();

{

if (first->time <= globalTimer)

{

Event* evt = first;

first = first->next;

event_types[evt->type].callback(evt->userdata, (int)(globalTimer - evt->time));

//currentMIPS->downcount = slicelength;

//if (Common::AtomicLoadAcquire(hasTsEvents))

//ProcessFifoWaitEvents();

//if (!first)

//{

//}

//else

//{

//}

//if (advanceCallback)

}

void LogPendingEvents()

ERROR_LOG(TIME, "Unimplemented function!");

//int cyclesDown = currentMIPS->downcount;

//if (maxIdle != 0 && cyclesDown > maxIdle)

//if (first && cyclesDown > 0)

//{

//}

//INFO_LOG(TIME, "Idle for %i cycles! (%f ms)", cyclesDown, cyclesDown / (float)(g_clock_rate_arm11 * 0.001f));

//idledCycles += cyclesDown;

//currentMIPS->downcount -= cyclesDown;

//if (currentMIPS->downcount == 0)

}

std::string GetScheduledEventsSummary()

p.Do(idledCycles);

}

int GetClockFrequencyMHz();

extern int slicelength;

* @return Size of the archive in bytes

*/

virtual size_t GetSize() const = 0;

/**

* Set the size of the archive in bytes

*/

bool Archive_RomFS::CreateDirectory(const Path& path) const {

ERROR_LOG(FILESYS, "Attempted to create a directory in ROMFS.");

return false;

/**

* Open a directory specified by its path

* Get the IdCode of the archive (e.g. RomFS, SaveData, etc.)

* @return IdCode of the archive

*/

/**

* Open a file specified by its path, using the specified mode

* @return Size of the archive in bytes

*/

size_t GetSize() const override;

/**

* Set the size of the archive in bytes

*/

* Get the IdCode of the archive (e.g. RomFS, SaveData, etc.)

* @return IdCode of the archive

*/

/**

* Open a file specified by its path, using the specified mode

WARN_LOG(FILESYS, "File %s: size=%llu dir=%d", filename.c_str(), file.size, file.isDirectory);

// TODO(Link Mauve): use a proper conversion to UTF-16.

entry.filename[j] = filename[j];

if (!filename[j])

break;

// Copyright 2014 Citra Emulator Project

// Licensed under GPLv2

#include "common/common_types.h"

// Copyright 2014 Citra Emulator Project

// Licensed under GPLv2

#include "core/hle/coprocessor.h"

#include "core/hle/hle.h"

template<s32 func(s32*, u32*, s32, bool, s64)> void Wrap() {

s32 param_1 = 0;

(PARAM(3) != 0), (((s64)PARAM(4) << 32) | PARAM(0)));

Core::g_app_core->SetReg(1, (u32)param_1);

FuncReturn(retval);

}

template<s32 func(s64*, u32, void*, s32)> void Wrap(){

(s32)PARAM(3)));

}

// Copyright 2014 Citra Emulator Project

// Licensed under GPLv2

#include <vector>

const FunctionDef* GetSVCInfo(u32 opcode) {

u32 func_num = opcode & 0xFFFFFF; // 8 bits

if (func_num > 0xFF) {

return nullptr;

}

return &g_module_db[0].func_table[func_num];

void Init() {

Service::Init();

RegisterAllModules();

NOTICE_LOG(HLE, "initialized OK");

// Copyright 2014 Citra Emulator Project

// Licensed under GPLv2

#pragma once

// Address arbiters are an underlying kernel synchronization object that can be created/used via

// supervisor calls (SVCs). They function as sort of a global lock. Typically, games/other CTR

// applications use them as an underlying mechanism to implement thread-safe barriers, events, and

////////////////////////////////////////////////////////////////////////////////////////////////////

// Kernel namespace

FileSys::Archive* backend; ///< Archive backend interface

/**

* @param wait Boolean wait set if current thread should wait as a result of sync operation

* @return Result of operation, 0 on success, otherwise error code

*/

Result SyncRequest(bool* wait) override {

u32* cmd_buff = Service::GetCommandBuffer();

FileCommand cmd = static_cast<FileCommand>(cmd_buff[0]);

switch (cmd) {

// Read from archive...

case FileCommand::Read:

archive->backend = backend;

MountArchive(archive);

return archive;

}

// Copyright 2014 Citra Emulator Project

// Licensed under GPLv2

#include <map>

#include <algorithm>

for (size_t i = 0; i < evt->waiting_threads.size(); ++i) {

ResumeThreadFromWait( evt->waiting_threads[i]);

// the event. This will result in the next thread waiting on the event to block. Otherwise,

// the event will not be reset, and the next thread to call WaitSynchronization on it will

// not block. Not sure if this is correct behavior, but it seems to work.

// Copyright 2014 Citra Emulator Project

// Licensed under GPLv2

#pragma once

// Copyright 2014 Citra Emulator Project / PPSSPP Project

// Licensed under GPLv2

#include "common/common.h"

for (int i = 0; i < MAX_COUNT; i++) {

if (occupied[i]) {

if (pool[i]) {

pool[i]->GetName().c_str());

}

}

*/

bool LoadExec(u32 entry_point) {

Init();

Core::g_app_core->SetPC(entry_point);

// 0x30 is the typical main thread priority I've seen used so far

// Copyright 2014 Citra Emulator Project / PPSSPP Project

// Licensed under GPLv2

#pragma once

Archive = 12,

Directory = 13,

};

enum {

DEFAULT_STACK_SIZE = 0x4000,

};

virtual Kernel::HandleType GetHandleType() const = 0;

/**

* @param wait Boolean wait set if current thread should wait as a result of sync operation

* @return Result of operation, 0 on success, otherwise error code

*/

delete pool[handle - HANDLE_OFFSET];

}

return error;

bool IsValid(Handle handle);

}

bool GetIDType(Handle handle, HandleType* type) const {

!occupied[handle - HANDLE_OFFSET]) {

ERROR_LOG(KERNEL, "Kernel: Bad object handle %i (%08x)", handle, handle);

return false;

int GetCount();

private:

enum {

MAX_COUNT = 0x1000,

HANDLE_OFFSET = 0x100,

// Copyright 2014 Citra Emulator Project

// Licensed under GPLv2

#include <map>

#include <vector>

std::string name; ///< Name of mutex (optional)

/**

* @param wait Boolean wait set if current thread should wait as a result of sync operation

* @return Result of operation, 0 on success, otherwise error code

*/

// Copyright 2014 Citra Emulator Project

// Licensed under GPLv2

#pragma once

// Copyright 2014 Citra Emulator Project

// Licensed under GPLv2

#include "common/common.h"

* @param other_permissions Memory block map other permissions (specified by SVC field)

* @return Result of operation, 0 on success, otherwise error code

*/

MemoryPermission other_permissions) {

if (address < Memory::SHARED_MEMORY_VADDR || address >= Memory::SHARED_MEMORY_VADDR_END) {

// Copyright 2014 Citra Emulator Project

// Licensed under GPLv2

#pragma once

* @param other_permissions Memory block map other permissions (specified by SVC field)

* @return Result of operation, 0 on success, otherwise error code

*/

MemoryPermission other_permissions);

/**

// Copyright 2014 Citra Emulator Project / PPSSPP Project

// Licensed under GPLv2

#include <algorithm>

#include <list>

};

// Lists all thread ids that aren't deleted/etc.

// Lists only ready thread ids.

/// Gets the current thread

inline Thread* GetCurrentThread() {

}

/// Gets the current thread handle

/// Sets the current thread

inline void SetCurrentThread(Thread* t) {

}

/// Saves the current CPU context

t->context.pc = t->context.reg_15 = t->entry_point;

t->context.sp = t->stack_top;

t->context.cpsr = 0x1F; // Usermode

// TODO(bunnei): This instructs the CPU core to start the execution as if it is "resuming" a

// thread. This is somewhat Sky-Eye specific, and should be re-architected in the future to be

// agnostic of the CPU core.

Handle handle = t->GetHandle();

if (t->IsReady()) {

if (!ready) {

}

} else if (ready) {

if (t->IsRunning()) {

} else {

}

t->status = THREADSTATUS_READY;

}

Thread* thread = g_object_pool.GetFast<Thread>(handle);

_assert_msg_(KERNEL, (thread != nullptr), "called, but thread is nullptr!");

return false;

return true;

void StopThread(Handle handle, const char* reason) {

Thread* thread = g_object_pool.GetFast<Thread>(handle);

_assert_msg_(KERNEL, (thread != nullptr), "called, but thread is nullptr!");

ChangeReadyState(thread, false);

thread->status = THREADSTATUS_DORMANT;

for (size_t i = 0; i < thread->waiting_threads.size(); ++i) {

}

ChangeReadyState(t, (new_status & THREADSTATUS_READY) != 0);

t->status = new_status;

if (new_status == THREADSTATUS_WAIT) {

if (t->wait_type == WAITTYPE_NONE) {

ERROR_LOG(KERNEL, "Waittype none not allowed");

s32 priority = THREADPRIO_LOWEST;

// Iterate through threads, find highest priority thread that is waiting to be arbitrated...

// TODO(bunnei): Verify arbiter address...

if (!VerifyWait(handle, WAITTYPE_ARB, arbiter))

/// Arbitrate all threads currently waiting

void ArbitrateAllThreads(u32 arbiter, u32 address) {

// Iterate through threads, find highest priority thread that is waiting to be arbitrated...

// TODO(bunnei): Verify arbiter address...

if (VerifyWait(handle, WAITTYPE_ARB, arbiter))

/// Switches CPU context to that of the specified thread

void SwitchContext(Thread* t) {

Thread* cur = GetCurrentThread();

// Save context for current thread

if (cur) {

SaveContext(cur->context);

if (cur->IsRunning()) {

ChangeReadyState(cur, true);

}

Thread* NextThread() {

Handle next;

Thread* cur = GetCurrentThread();

if (cur && cur->IsRunning()) {

} else {

}

if (next == 0) {

return nullptr;

return;

}

INFO_LOG(KERNEL, "0x%02X 0x%08X (current)", thread->current_priority, GetCurrentThreadHandle());

if (priority != -1) {

INFO_LOG(KERNEL, "0x%02X 0x%08X", priority, handle);

}

Thread* CreateThread(Handle& handle, const char* name, u32 entry_point, s32 priority,

s32 processor_id, u32 stack_top, int stack_size) {

"CreateThread priority=%d, outside of allowable range!", priority)

Thread* thread = new Thread;

handle = Kernel::g_object_pool.Create(thread);

thread->status = THREADSTATUS_DORMANT;

thread->entry_point = entry_point;

return -1;

}

if ((u32)stack_size < 0x200) {

stack_size);

return -1;

}

return -1;

}

Handle handle;

stack_size);

ResetThread(thread, arg, 0);

// Change thread priority

s32 old = thread->current_priority;

thread->current_priority = priority;

// Change thread status to "ready" and push to ready queue

if (thread->IsRunning()) {

thread->status = (thread->status & ~THREADSTATUS_RUNNING) | THREADSTATUS_READY;

}

if (thread->IsReady()) {

}

return 0;

/// Sets up the primary application thread

Handle SetupMainThread(s32 priority, int stack_size) {

Handle handle;

// Initialize new "main" thread

THREADPROCESSORID_0, Memory::SCRATCHPAD_VADDR_END, stack_size);

ResetThread(thread, 0, 0);

// If running another thread already, set it to "ready" state

Thread* cur = GetCurrentThread();

if (cur && cur->IsRunning()) {

ChangeReadyState(cur, true);

}

// Run new "main" thread

SetCurrentThread(thread);

thread->status = THREADSTATUS_RUNNING;

HLE::g_reschedule = false;

if (next > 0) {

INFO_LOG(KERNEL, "context switch 0x%08X -> 0x%08X", prev->GetHandle(), next->GetHandle());

SwitchContext(next);

// Hack - There is no mechanism yet to waken the primary thread if it has been put to sleep

// by a simulated VBLANK thread switch. So, we'll just immediately set it to "ready" again.

// immediately placed back in the queue for execution.

if (prev->wait_type == WAITTYPE_VBLANK) {

ResumeThreadFromWait(prev->GetHandle());

// Copyright 2014 Citra Emulator Project / PPSSPP Project

// Licensed under GPLv2

#pragma once

{0x000E0042, nullptr, "GetCurrentAPInfo"},

{0x00100042, nullptr, "GetCurrentNZoneInfo"},

{0x00110042, nullptr, "GetNZoneApNumService"},

{0x002D0082, nullptr, "SetRequestEulaVersion"},

{0x00300004, nullptr, "RegisterDisconnectEvent"},

{0x003C0042, nullptr, "GetAPSSIDList"},

{0x00400042, nullptr, "SetClientVersion"},

};

////////////////////////////////////////////////////////////////////////////////////////////////////

// Namespace AC_U

namespace AC_U {

* Gets the string port name used by CTROS for the service

* @return Port name of service

*/

return "ac:u";

}

};

void Initialize(Service::Interface* self) {

u32* cmd_buff = Service::GetCommandBuffer();

cmd_buff[3] = Kernel::CreateEvent(RESETTYPE_ONESHOT, "APT_U:Menu"); // APT menu event handle

cmd_buff[4] = Kernel::CreateEvent(RESETTYPE_ONESHOT, "APT_U:Pause"); // APT pause event handle

cmd_buff[1] = 0; // No error

WARN_LOG(KERNEL, "(STUBBED) called unk=0x%08X, buffer1_size=0x%08x, buffer2_size=0x%08x, "

buffer1_addr, buffer2_addr);

}

// Application and title launching service. These services handle signaling for home/power button as

// well. Only one session for either APT service can be open at a time, normally processes close the

// svcBreak when the command isn't accessible). See http://3dbrew.org/wiki/NS#APT_Services.

/// Interface to "APT:U" service

Interface::Interface() {

Register(FunctionTable, ARRAY_SIZE(FunctionTable));

}

Interface::~Interface() {

}

} // namespace

* Gets the string port name used by CTROS for the service

* @return Port name of service

*/

return "cfg:u";

}

};

{0x001100C2, nullptr, "LoadComponent"},

{0x00120000, nullptr, "UnloadComponent"},

{0x00130082, nullptr, "FlushDataCache"},

{0x00150082, nullptr, "RegisterInterruptEvents"},

{0x00160000, nullptr, "GetSemaphoreEventHandle"},

{0x00170040, nullptr, "SetSemaphoreMask"},

{0x00180040, nullptr, "GetPhysicalAddress"},

{0x001A0042, nullptr, "SetIirFilterI2S1_cmd1"},

{0x001B0042, nullptr, "SetIirFilterI2S1_cmd2"},

{0x001C0082, nullptr, "SetIirFilterEQ"},

* Gets the string port name used by CTROS for the service

* @return Port name of service

*/

return "dsp:DSP";

}

};

Interface::Interface() {

Register(FunctionTable, ARRAY_SIZE(FunctionTable));

}

Interface::~Interface() {

}

} // namespace

* Gets the string port name used by CTROS for the service

* @return Port name of service

*/

return "err:f";

}

};

} // namespace

* Gets the string port name used by CTROS for the service

* @return Port name of service

*/

return "frd:u";

}

};

// puts all the sections of the http://3dbrew.org/wiki/Error_codes to something non-zero, to make

// sure we don't mislead the application into thinking something worked.

u32* cmd_buff = Service::GetCommandBuffer();

// TODO(Link Mauve): check the behavior when cmd_buff[1] isn't 32, as per

* 1 : Result of function, 0 on success, otherwise error code

* 3 : File handle

*/

u32* cmd_buff = Service::GetCommandBuffer();

// TODO(Link Mauve): cmd_buff[2], aka archive handle lower word, isn't used according to

* 1 : Result of function, 0 on success, otherwise error code

* 3 : File handle

*/

u32* cmd_buff = Service::GetCommandBuffer();

auto archive_id = static_cast<FileSys::Archive::IdCode>(cmd_buff[2]);

* Outputs:

* 1 : Result of function, 0 on success, otherwise error code

*/

u32* cmd_buff = Service::GetCommandBuffer();

// TODO: cmd_buff[2], aka archive handle lower word, isn't used according to

DEBUG_LOG(KERNEL, "called");

}

u32* cmd_buff = Service::GetCommandBuffer();

// TODO(Link Mauve): cmd_buff[2], aka archive handle lower word, isn't used according to

* 2 : Archive handle lower word (unused)

* 3 : Archive handle upper word (same as file handle)

*/

u32* cmd_buff = Service::GetCommandBuffer();

auto archive_id = static_cast<FileSys::Archive::IdCode>(cmd_buff[1]);

* 1 : Result of function, 0 on success, otherwise error code

* 2 : Whether the Sdmc could be detected

*/

u32* cmd_buff = Service::GetCommandBuffer();

cmd_buff[1] = 0;

cmd_buff[2] = Settings::values.use_virtual_sd ? 1 : 0;

DEBUG_LOG(KERNEL, "called");

}

sizeof(InterruptRelayQueue) * thread_id);

}

// TODO: Return proper error codes

if (base_address + size_in_bytes >= 0x420000) {

ERROR_LOG(GPU, "Write address out of range! (address=0x%08x, size=0x%08x)",

}

/// Write a GSP GPU hardware register

u32* cmd_buff = Service::GetCommandBuffer();

u32 reg_addr = cmd_buff[1];

u32 size = cmd_buff[2];

}

/// Read a GSP GPU hardware register

u32* cmd_buff = Service::GetCommandBuffer();

u32 reg_addr = cmd_buff[1];

u32 size = cmd_buff[2];

}

}

u32 base_address = 0x400000;

if (info.active_fb == 0) {

WriteHWRegs(base_address + 4 * GPU_REG_INDEX(framebuffer_config[screen_id].address_left1), 4, &info.address_left);

* Outputs:

* 1: Result code

*/

u32* cmd_buff = Service::GetCommandBuffer();

u32 screen_id = cmd_buff[1];

FrameBufferInfo* fb_info = (FrameBufferInfo*)&cmd_buff[2];

* 2 : Thread index into GSP command buffer

* 4 : Handle to GSP shared memory

*/

u32* cmd_buff = Service::GetCommandBuffer();

u32 flags = cmd_buff[1];

g_interrupt_event = cmd_buff[3];

}

/// Executes the next GSP command

// Utility function to convert register ID to address

auto WriteGPURegister = [](u32 id, u32 data) {

GPU::Write<u32>(0x1EF00000 + 4 * id, data);

}

/// This triggers handling of the GX command written to the command buffer in shared memory.

// Iterate through each thread's command queue...

for (unsigned thread_id = 0; thread_id < 0x4; ++thread_id) {

*

* Indicate the circle pad is pushed completely to the edge in 1 of 8 directions.

*/

static const s16 max_value = 0x9C;

next_circle_x = next_state.circle_left ? -max_value : 0x0;

next_circle_x += next_state.circle_right ? max_value : 0x0;

* 7 : Gyroscope event

* 8 : Event signaled by HID_User

*/

u32* cmd_buff = Service::GetCommandBuffer();

cmd_buff[1] = 0; // No error

namespace HID_User {

* Structure of a Pad controller state.

*/

struct PadState {

{0x000D0040, nullptr, "SetClamp"},

{0x000E0000, nullptr, "GetClamp"},

{0x000F0040, nullptr, "unknown_input1"},

};

////////////////////////////////////////////////////////////////////////////////////////////////////

* Gets the string port name used by CTROS for the service

* @return Port name of service

*/

return "mic:u";

}

};

* Gets the string port name used by CTROS for the service

* @return Port name of service

*/

return "nwm:UDS";

}

};

{0x00030000, nullptr, "GetRtcAlarm"},

{0x00040000, nullptr, "CancelRtcAlarm"},

{0x00050000, nullptr, "GetAdapterState"},

{0x00070000, nullptr, "GetBatteryLevel"},

{0x00080000, nullptr, "GetBatteryChargeState"},

{0x00090000, nullptr, "GetPedometerState"},

{0x000A0042, nullptr, "GetStepHistoryEntry"},

{0x000D0040, nullptr, "SetPedometerRecordingMode"},

{0x000E0000, nullptr, "GetPedometerRecordingMode"},

{0x000F0084, nullptr, "GetStepHistoryAll"},

* Gets the string port name used by CTROS for the service

* @return Port name of service

*/

return "ptm:u";

}

};

#include "core/hle/service/service.h"

#include "core/hle/service/ac_u.h"

#include "core/hle/service/apt_u.h"

#include "core/hle/service/boss_u.h"

#include "core/hle/service/cfg_u.h"

#include "core/hle/service/dsp_dsp.h"

#include "core/hle/service/err_f.h"

#include "core/hle/service/fs_user.h"

#include "core/hle/service/frd_u.h"

#include "core/hle/service/gsp_gpu.h"

#include "core/hle/service/hid_user.h"

#include "core/hle/service/mic_u.h"

#include "core/hle/service/ndm_u.h"

#include "core/hle/service/nwm_uds.h"

#include "core/hle/service/ptm_u.h"

#include "core/hle/service/soc_u.h"

#include "core/hle/service/srv.h"

/// Initialize ServiceManager

void Init() {

g_manager = new Manager;

g_manager->AddService(new SRV::Interface);

g_manager->AddService(new AC_U::Interface);

g_manager->AddService(new APT_U::Interface);

g_manager->AddService(new BOSS_U::Interface);

g_manager->AddService(new CFG_U::Interface);

g_manager->AddService(new DSP_DSP::Interface);

g_manager->AddService(new ERR_F::Interface);

g_manager->AddService(new FRD_U::Interface);

g_manager->AddService(new FS_User::Interface);

g_manager->AddService(new GSP_GPU::Interface);

g_manager->AddService(new HID_User::Interface);

g_manager->AddService(new MIC_U::Interface);

g_manager->AddService(new NDM_U::Interface);

g_manager->AddService(new NWM_UDS::Interface);

g_manager->AddService(new PTM_U::Interface);

g_manager->AddService(new SOC_U::Interface);

g_manager->AddService(new SSL_C::Interface);

class Interface : public Kernel::Object {

friend class Manager;

public:

std::string GetName() const override { return GetPortName(); }

std::string GetTypeName() const override { return GetPortName(); }

}

/**

* @param wait Boolean wait set if current thread should wait as a result of sync operation

* @return Result of operation, 0 on success, otherwise error code

*/

auto itr = m_functions.find(cmd_buff[0]);

if (itr == m_functions.end()) {

GetPortName().c_str(), cmd_buff[0]);

// TODO(bunnei): Hack - ignore error

u32* cmd_buff = Service::GetCommandBuffer();

cmd_buff[1] = 0;

}

if (itr->second.func == nullptr) {

GetPortName().c_str(), itr->second.name.c_str());

// TODO(bunnei): Hack - ignore error

u32* cmd_buff = Service::GetCommandBuffer();

cmd_buff[1] = 0;

itr->second.func(this);

* Gets the string port name used by CTROS for the service

* @return Port name of service

*/

return "soc:U";

}

};

namespace SRV {

DEBUG_LOG(OSHLE, "called");

u32* cmd_buff = Service::GetCommandBuffer();

cmd_buff[1] = 0; // No error

}

DEBUG_LOG(OSHLE, "called");

u32* cmd_buff = Service::GetCommandBuffer();

cmd_buff[3] = g_event_handle;

}

Result res = 0;

u32* cmd_buff = Service::GetCommandBuffer();

// Copyright 2014 Citra Emulator Project

// Licensed under GPLv2

#include <map>

};

/// Map application or GSP heap memory

operation, addr0, addr1, size, permissions);

switch (operation) {

}

/// Maps a memory block to specified address

handle, addr, permissions, other_permissions);

Kernel::MemoryPermission permissions_type = static_cast<Kernel::MemoryPermission>(permissions);

case Kernel::MemoryPermission::Write:

case Kernel::MemoryPermission::ReadWrite:

case Kernel::MemoryPermission::DontCare:

static_cast<Kernel::MemoryPermission>(other_permissions));

break;

default:

}

/// Connect to an OS service given the port name, returns the handle to the port to out

Service::Interface* service = Service::g_manager->FetchFromPortName(port_name);

DEBUG_LOG(SVC, "called port_name=%s", port_name);

}

/// Synchronize to an OS service

Kernel::Object* object = Kernel::g_object_pool.GetFast<Kernel::Object>(handle);

_assert_msg_(KERNEL, (object != nullptr), "called, but kernel object is nullptr!");

}

/// Close a handle

// ImplementMe

ERROR_LOG(SVC, "(UNIMPLEMENTED) called handle=0x%08X", handle);

return 0;

}

/// Wait for a handle to synchronize, timeout after the specified nanoseconds

// TODO(bunnei): Do something with nano_seconds, currently ignoring this

bool wait = false;

bool wait_infinite = (nano_seconds == -1); // Used to wait until a thread has terminated

Kernel::Object* object = Kernel::g_object_pool.GetFast<Kernel::Object>(handle);

object->GetName().c_str(), nano_seconds);

_assert_msg_(KERNEL, (object != nullptr), "called, but kernel object is nullptr!");

}

/// Wait for the given handles to synchronize, timeout after the specified nanoseconds

s64 nano_seconds) {

// TODO(bunnei): Do something with nano_seconds, currently ignoring this

bool unlock_all = true;

bool wait_infinite = (nano_seconds == -1); // Used to wait until a thread has terminated

handle_count, (wait_all ? "true" : "false"), nano_seconds);

// Iterate through each handle, synchronize kernel object

_assert_msg_(KERNEL, (object != nullptr), "called handle=0x%08X, but kernel object "

"is nullptr!", handles[i]);

object->GetName().c_str());

Result res = object->WaitSynchronization(&wait);

}

/// Create an address arbiter (to allocate access to shared resources)

DEBUG_LOG(SVC, "called");

Handle handle = Kernel::CreateAddressArbiter();

*arbiter = handle;

}

/// Arbitrate address

value);

}

/// Used to output a message on a debug hardware unit - does nothing on a retail unit

OS_LOG(SVC, "%s", string);

}

/// Get resource limit

// With regards to proceess values:

// the current KThread.

*resource_limit = 0xDEADBEEF;

ERROR_LOG(SVC, "(UNIMPLEMENTED) called process=0x%08X", process);

}

/// Get resource limit current values

s32 name_count) {

ERROR_LOG(SVC, "(UNIMPLEMENTED) called resource_limit=%08X, names=%s, name_count=%d",

resource_limit, names, name_count);

}

/// Creates a new thread

std::string name;

if (Symbols::HasSymbol(entry_point)) {

TSymbol symbol = Symbols::GetSymbol(entry_point);

Core::g_app_core->SetReg(1, thread);

DEBUG_LOG(SVC, "called entrypoint=0x%08X (%s), arg=0x%08X, stacktop=0x%08X, "

name.c_str(), arg, stack_top, priority, processor_id, thread);

return 0;

}

/// Called when a thread exits

Handle thread = Kernel::GetCurrentThreadHandle();

DEBUG_LOG(SVC, "called, pc=0x%08X", Core::g_app_core->GetPC()); // PC = 0x0010545C

}

/// Gets the priority for the specified thread

*priority = Kernel::GetThreadPriority(handle);

return 0;

}

/// Sets the priority for the specified thread

return Kernel::SetThreadPriority(handle, priority);

}

/// Create a mutex

*mutex = Kernel::CreateMutex((initial_locked != 0));

initial_locked ? "true" : "false", *mutex);

return 0;

}

/// Release a mutex

DEBUG_LOG(SVC, "called handle=0x%08X", handle);

_assert_msg_(KERNEL, (handle != 0), "called, but handle is nullptr!");

Kernel::ReleaseMutex(handle);

}

/// Get current thread ID

ERROR_LOG(SVC, "(UNIMPLEMENTED) called thread=0x%08X", thread);

return 0;

}

/// Query memory

ERROR_LOG(SVC, "(UNIMPLEMENTED) called addr=0x%08X", addr);

return 0;

}

/// Create an event

*evt = Kernel::CreateEvent((ResetType)reset_type);

reset_type, *evt);

return 0;

}

/// Duplicates a kernel handle

DEBUG_LOG(SVC, "called handle=0x%08X", handle);

// Translate kernel handles -> real handles

}

_assert_msg_(KERNEL, (handle != Kernel::CurrentProcess),

"(UNIMPLEMENTED) process handle duplication!");

// TODO(bunnei): FixMe - This is a hack to return the handle that we were asked to duplicate.

*out = handle;

}

/// Signals an event

Result res = Kernel::SignalEvent(evt);

DEBUG_LOG(SVC, "called event=0x%08X", evt);

return res;

}

/// Clears an event

Result res = Kernel::ClearEvent(evt);

DEBUG_LOG(SVC, "called event=0x%08X", evt);

return res;

}

/// Sleep the current thread

DEBUG_LOG(SVC, "called nanoseconds=%lld", nanoseconds);

}

/// This returns the total CPU ticks elapsed since the CPU was powered-on

return (s64)Core::g_app_core->GetTicks();

}

// Copyright 2014 Citra Emulator Project

// Licensed under GPLv2

#pragma once

template <typename T>

inline void Read(T &var, const u32 addr) {

switch (addr & 0xFFFFF000) {

// TODO(bunnei): What is the virtual address of NDMA?

// case VADDR_NDMA:

// NDMA::Read(var, addr);

template <typename T>

inline void Write(u32 addr, const T data) {

switch (addr & 0xFFFFF000) {

// TODO(bunnei): What is the virtual address of NDMA?

// NDMA::Write(addr, data);

// break;

for (int i = 0; i < header->e_phnum; i++) {

Elf32_Phdr *p = segments + i;

p->p_filesz, p->p_memsz);

if (p->p_type == PT_LOAD) {

segment_addr[i] = base_addr + p->p_vaddr;

memcpy(Memory::GetPointer(segment_addr[i]), GetSegmentPtr(i), p->p_filesz);

p->p_memsz);

}

}

* @param size Size of compressed buffer

* @return Size of decompressed buffer

*/

u32 offset_size = *(u32*)(buffer + size - 4);

return offset_size + size;

}

* @param decompressed_size Size of decompressed buffer

* @return True on success, otherwise false

*/

u8* footer = compressed + compressed_size - 8;

u32 buffer_top_and_bottom = *(u32*)footer;

u32 out = decompressed_size;

* @return ResultStatus result of function

*/

ResultStatus AppLoader_NCCH::LoadExec() const {

return ResultStatus::ErrorNotLoaded;

std::vector<u8> code;

return ResultStatus::Error;

}

return ResultStatus::ErrorNotUsed;

/**

* Loads an NCCH file (e.g. from a CCI, or the first NCCH in a CXI)

file.Seek(ncch_offset, 0);

file.ReadBytes(&ncch_header, sizeof(NCCH_Header));

}

// Verify we are loading the correct file type...

if (0 != memcmp(&ncch_header.magic, "NCCH", 4))

return ResultStatus::ErrorInvalidFormat;

u32 entry_point;

u32 ncch_offset; // Offset to NCCH header, can be 0 or after NCSD header

u32 exefs_offset;

NCCH_Header ncch_header;

ExeFs_Header exefs_header;

ExHeader_Header exheader_header;

namespace Memory {

// We don't declare the IO region in here since its handled by other means.

static MemoryView g_views[] = {

};

/*static MemoryView views[] =

g_views[i].size = FCRAM_SIZE;

}

NOTICE_LOG(MEMMAP, "initialized OK, RAM at %p (mirror at 0 @ %p)", g_heap,

}

void Shutdown() {

u32 flags = 0;

NOTICE_LOG(MEMMAP, "shutdown OK");

}

* Maps a block of memory on the heap

* @param size Size of block in bytes

* @param operation Memory map operation type

*/

u32 MapBlock_Heap(u32 size, u32 operation, u32 permissions);

namespace Memory {

/// Convert a physical address to virtual address

VAddr PhysicalToVirtualAddress(const PAddr addr) {

block.operation = operation;

block.permissions = permissions;

block.address = last_block.address + last_block.size;

}

return block.GetVirtualAddress();

}

block.operation = operation;

block.permissions = permissions;

block.address = last_block.address + last_block.size;

}

return block.GetVirtualAddress();

}

namespace System {

// State of the full emulator

extern volatile State g_state;

void RunLoopUntil(u64 global_cycles);

void Shutdown();

return;

#ifndef HAVE_PNG

#else

return;

// Write data to file

// Utility class to log Pica commands.

struct PicaTrace {

struct Write : public std::pair<u32,u32> {

u32& Id() { return first; }

const u32& Id() const { return first; }

/// Swap buffers (render frame)

virtual void SwapBuffers() = 0;

* Set the emulator window to use for renderer

* @param window EmuWindow handle to emulator window to use for rendering

*/

* Draws the emulated screens to the emulator window.

*/

void RendererOpenGL::DrawScreens() {

glClear(GL_COLOR_BUFFER_BIT);

glUseProgram(program_id);

render_window = window;

}

/// Initialize the renderer

void RendererOpenGL::Init() {

render_window->MakeCurrent();

#pragma once

#include "generated/gl_3_2_core.h"

#include "core/hw/gpu.h"

class EmuWindow;

static void LoadFBToActiveGLTexture(const GPU::Regs::FramebufferConfig& framebuffer,

const TextureInfo& texture);

EmuWindow* render_window; ///< Handle to render window

u32 last_mode; ///< Last render mode

void DumpTGA(std::string filename, short width, short height, u8* raw_data) {

TGAHeader hdr = {0, 0, 2, 0, 0, 0, 0, width, height, 24, 0};

FILE* fout = fopen(filename.c_str(), "wb");

fwrite(&hdr, sizeof(TGAHeader), 1, fout);

for (int y = 0; y < height; y++) {

putc(raw_data[(3 * (y * width)) + (3 * x) + 2], fout); // r

}

}

fclose(fout);

}

} // namespace

/// Adjust RGBA8 color with RGBA6 precision

static inline u32 rgba8_with_rgba6(u32 src) {

}

/// Adjust RGBA8 color with RGB565 precision

static inline u32 rgba8_with_rgb565(u32 src) {

}

/// Adjust Z24 depth value with Z16 precision

static inline u32 z24_with_z16(u32 src) {

}

} // namespace