Merge pull request #245 from rohit-n/null-nullptr
Change NULLs to nullptrs.
This commit is contained in:
		| @@ -76,9 +76,9 @@ EmuWindow_GLFW::EmuWindow_GLFW() { | ||||
|     std::string window_title = Common::StringFromFormat("Citra | %s-%s", Common::g_scm_branch, Common::g_scm_desc); | ||||
|     m_render_window = glfwCreateWindow(VideoCore::kScreenTopWidth, | ||||
|         (VideoCore::kScreenTopHeight + VideoCore::kScreenBottomHeight), | ||||
|         window_title.c_str(), NULL, NULL); | ||||
|         window_title.c_str(), nullptr, nullptr); | ||||
|  | ||||
|     if (m_render_window == NULL) { | ||||
|     if (m_render_window == nullptr) { | ||||
|         ERROR_LOG(GUI, "Failed to create GLFW window! Exiting..."); | ||||
|         exit(1); | ||||
|     } | ||||
| @@ -123,7 +123,7 @@ void EmuWindow_GLFW::MakeCurrent() { | ||||
|  | ||||
| /// Releases (dunno if this is the "right" word) the GLFW context from the caller thread | ||||
| void EmuWindow_GLFW::DoneCurrent() { | ||||
|     glfwMakeContextCurrent(NULL); | ||||
|     glfwMakeContextCurrent(nullptr); | ||||
| } | ||||
|  | ||||
| void EmuWindow_GLFW::ReloadSetKeymaps() { | ||||
|   | ||||
| @@ -230,7 +230,7 @@ QByteArray GRenderWindow::saveGeometry() | ||||
| { | ||||
|     // If we are a top-level widget, store the current geometry | ||||
|     // otherwise, store the last backup | ||||
|     if (parent() == NULL) | ||||
|     if (parent() == nullptr) | ||||
|         return ((QGLWidget*)this)->saveGeometry(); | ||||
|     else | ||||
|         return geometry; | ||||
|   | ||||
| @@ -5,7 +5,7 @@ | ||||
|  | ||||
| struct Hotkey | ||||
| { | ||||
|     Hotkey() : shortcut(NULL), context(Qt::WindowShortcut) {} | ||||
|     Hotkey() : shortcut(nullptr), context(Qt::WindowShortcut) {} | ||||
|  | ||||
|     QKeySequence keyseq; | ||||
|     QShortcut* shortcut; | ||||
| @@ -81,7 +81,7 @@ QShortcut* GetHotkey(const QString& group, const QString& action, QWidget* widge | ||||
|     Hotkey& hk = hotkey_groups[group][action]; | ||||
|  | ||||
|     if (!hk.shortcut) | ||||
|         hk.shortcut = new QShortcut(hk.keyseq, widget, NULL, NULL, hk.context); | ||||
|         hk.shortcut = new QShortcut(hk.keyseq, widget, nullptr, nullptr, hk.context); | ||||
|  | ||||
|     return hk.shortcut; | ||||
| } | ||||
|   | ||||
| @@ -131,7 +131,7 @@ GMainWindow::GMainWindow() | ||||
| GMainWindow::~GMainWindow() | ||||
| { | ||||
|     // will get automatically deleted otherwise | ||||
|     if (render_window->parent() == NULL) | ||||
|     if (render_window->parent() == nullptr) | ||||
|         delete render_window; | ||||
| } | ||||
|  | ||||
| @@ -213,14 +213,14 @@ void GMainWindow::OnOpenHotkeysDialog() | ||||
| void GMainWindow::ToggleWindowMode() | ||||
| { | ||||
|     bool enable = ui.action_Popout_Window_Mode->isChecked(); | ||||
|     if (enable && render_window->parent() != NULL) | ||||
|     if (enable && render_window->parent() != nullptr) | ||||
|     { | ||||
|         ui.horizontalLayout->removeWidget(render_window); | ||||
|         render_window->setParent(NULL); | ||||
|         render_window->setParent(nullptr); | ||||
|         render_window->setVisible(true); | ||||
|         render_window->RestoreGeometry(); | ||||
|     } | ||||
|     else if (!enable && render_window->parent() == NULL) | ||||
|     else if (!enable && render_window->parent() == nullptr) | ||||
|     { | ||||
|         render_window->BackupGeometry(); | ||||
|         ui.horizontalLayout->addWidget(render_window); | ||||
|   | ||||
| @@ -204,11 +204,11 @@ public: | ||||
|         { | ||||
|             for (auto it = x.begin(), end = x.end(); it != end; ++it) | ||||
|             { | ||||
|                 if (it->second != NULL) | ||||
|                 if (it->second != nullptr) | ||||
|                     delete it->second; | ||||
|             } | ||||
|         } | ||||
|         T *dv = NULL; | ||||
|         T *dv = nullptr; | ||||
|         DoMap(x, dv); | ||||
|     } | ||||
|  | ||||
| @@ -264,11 +264,11 @@ public: | ||||
|         { | ||||
|             for (auto it = x.begin(), end = x.end(); it != end; ++it) | ||||
|             { | ||||
|                 if (it->second != NULL) | ||||
|                 if (it->second != nullptr) | ||||
|                     delete it->second; | ||||
|             } | ||||
|         } | ||||
|         T *dv = NULL; | ||||
|         T *dv = nullptr; | ||||
|         DoMultimap(x, dv); | ||||
|     } | ||||
|  | ||||
| @@ -320,7 +320,7 @@ public: | ||||
|     template<class T> | ||||
|     void Do(std::vector<T *> &x) | ||||
|     { | ||||
|         T *dv = NULL; | ||||
|         T *dv = nullptr; | ||||
|         DoVector(x, dv); | ||||
|     } | ||||
|  | ||||
| @@ -369,7 +369,7 @@ public: | ||||
|     template<class T> | ||||
|     void Do(std::deque<T *> &x) | ||||
|     { | ||||
|         T *dv = NULL; | ||||
|         T *dv = nullptr; | ||||
|         DoDeque(x, dv); | ||||
|     } | ||||
|  | ||||
| @@ -395,7 +395,7 @@ public: | ||||
|     template<class T> | ||||
|     void Do(std::list<T *> &x) | ||||
|     { | ||||
|         T *dv = NULL; | ||||
|         T *dv = nullptr; | ||||
|         Do(x, dv); | ||||
|     } | ||||
|  | ||||
| @@ -433,7 +433,7 @@ public: | ||||
|         { | ||||
|             for (auto it = x.begin(), end = x.end(); it != end; ++it) | ||||
|             { | ||||
|                 if (*it != NULL) | ||||
|                 if (*it != nullptr) | ||||
|                     delete *it; | ||||
|             } | ||||
|         } | ||||
| @@ -518,7 +518,7 @@ public: | ||||
|     void DoClass(T *&x) { | ||||
|         if (mode == MODE_READ) | ||||
|         { | ||||
|             if (x != NULL) | ||||
|             if (x != nullptr) | ||||
|                 delete x; | ||||
|             x = new T(); | ||||
|         } | ||||
| @@ -567,7 +567,7 @@ public: | ||||
|                 { | ||||
|                     if (mode == MODE_READ) | ||||
|                     { | ||||
|                         cur->next = 0; | ||||
|                         cur->next = nullptr; | ||||
|                         list_cur = cur; | ||||
|                         if (prev) | ||||
|                             prev->next = cur; | ||||
| @@ -586,13 +586,13 @@ public: | ||||
|                 if (mode == MODE_READ) | ||||
|                 { | ||||
|                     if (prev) | ||||
|                         prev->next = 0; | ||||
|                         prev->next = nullptr; | ||||
|                     if (list_end) | ||||
|                         *list_end = prev; | ||||
|                     if (list_cur) | ||||
|                     { | ||||
|                         if (list_start == list_cur) | ||||
|                             list_start = 0; | ||||
|                             list_start = nullptr; | ||||
|                         do | ||||
|                         { | ||||
|                             LinkedListItem<T>* next = list_cur->next; | ||||
|   | ||||
| @@ -106,7 +106,7 @@ inline u64 _rotr64(u64 x, unsigned int shift){ | ||||
|             // Restore the global locale | ||||
|             _configthreadlocale(_DISABLE_PER_THREAD_LOCALE); | ||||
|         } | ||||
|         else if(new_locale != NULL) | ||||
|         else if(new_locale != nullptr) | ||||
|         { | ||||
|             // Configure the thread to set the locale only for this thread | ||||
|             _configthreadlocale(_ENABLE_PER_THREAD_LOCALE); | ||||
|   | ||||
| @@ -16,7 +16,7 @@ | ||||
| ConsoleListener::ConsoleListener() | ||||
| { | ||||
| #ifdef _WIN32 | ||||
|     hConsole = NULL; | ||||
|     hConsole = nullptr; | ||||
|     bUseColor = true; | ||||
| #else | ||||
|     bUseColor = isatty(fileno(stdout)); | ||||
| @@ -66,19 +66,19 @@ void ConsoleListener::UpdateHandle() | ||||
| void ConsoleListener::Close() | ||||
| { | ||||
| #ifdef _WIN32 | ||||
|     if (hConsole == NULL) | ||||
|     if (hConsole == nullptr) | ||||
|         return; | ||||
|     FreeConsole(); | ||||
|     hConsole = NULL; | ||||
|     hConsole = nullptr; | ||||
| #else | ||||
|     fflush(NULL); | ||||
|     fflush(nullptr); | ||||
| #endif | ||||
| } | ||||
|  | ||||
| bool ConsoleListener::IsOpen() | ||||
| { | ||||
| #ifdef _WIN32 | ||||
|     return (hConsole != NULL); | ||||
|     return (hConsole != nullptr); | ||||
| #else | ||||
|     return true; | ||||
| #endif | ||||
|   | ||||
| @@ -82,7 +82,7 @@ static void InitSymbolPath( PSTR lpszSymbolPath, PCSTR lpszIniPath ) | ||||
|     } | ||||
|  | ||||
|     // Add user defined path | ||||
|     if ( lpszIniPath != NULL ) | ||||
|     if ( lpszIniPath != nullptr ) | ||||
|         if ( lpszIniPath[0] != '\0' ) | ||||
|         { | ||||
|             strcat( lpszSymbolPath, ";" ); | ||||
| @@ -138,7 +138,7 @@ static BOOL GetFunctionInfoFromAddresses( ULONG fnAddress, ULONG stackAddress, L | ||||
|     DWORD             dwSymSize = 10000; | ||||
|     TCHAR             lpszUnDSymbol[BUFFERSIZE]=_T("?"); | ||||
|     CHAR              lpszNonUnicodeUnDSymbol[BUFFERSIZE]="?"; | ||||
|     LPTSTR            lpszParamSep = NULL; | ||||
|     LPTSTR            lpszParamSep = nullptr; | ||||
|     LPTSTR            lpszParsed = lpszUnDSymbol; | ||||
|     PIMAGEHLP_SYMBOL  pSym = (PIMAGEHLP_SYMBOL)GlobalAlloc( GMEM_FIXED, dwSymSize ); | ||||
|  | ||||
| @@ -187,13 +187,13 @@ static BOOL GetFunctionInfoFromAddresses( ULONG fnAddress, ULONG stackAddress, L | ||||
|  | ||||
|         // Let's go through the stack, and modify the function prototype, and insert the actual | ||||
|         // parameter values from the stack | ||||
|         if ( _tcsstr( lpszUnDSymbol, _T("(void)") ) == NULL && _tcsstr( lpszUnDSymbol, _T("()") ) == NULL) | ||||
|         if ( _tcsstr( lpszUnDSymbol, _T("(void)") ) == nullptr && _tcsstr( lpszUnDSymbol, _T("()") ) == nullptr) | ||||
|         { | ||||
|             ULONG index = 0; | ||||
|             for( ; ; index++ ) | ||||
|             { | ||||
|                 lpszParamSep = _tcschr( lpszParsed, _T(',') ); | ||||
|                 if ( lpszParamSep == NULL ) | ||||
|                 if ( lpszParamSep == nullptr ) | ||||
|                     break; | ||||
|  | ||||
|                 *lpszParamSep = _T('\0'); | ||||
| @@ -205,7 +205,7 @@ static BOOL GetFunctionInfoFromAddresses( ULONG fnAddress, ULONG stackAddress, L | ||||
|             } | ||||
|  | ||||
|             lpszParamSep = _tcschr( lpszParsed, _T(')') ); | ||||
|             if ( lpszParamSep != NULL ) | ||||
|             if ( lpszParamSep != nullptr ) | ||||
|             { | ||||
|                 *lpszParamSep = _T('\0'); | ||||
|  | ||||
| @@ -248,7 +248,7 @@ static BOOL GetSourceInfoFromAddress( UINT address, LPTSTR lpszSourceInfo ) | ||||
|         PCSTR2LPTSTR( lineInfo.FileName, lpszFileName ); | ||||
|         TCHAR fname[_MAX_FNAME]; | ||||
|         TCHAR ext[_MAX_EXT]; | ||||
|         _tsplitpath(lpszFileName, NULL, NULL, fname, ext); | ||||
|         _tsplitpath(lpszFileName, nullptr, nullptr, fname, ext); | ||||
|         _stprintf( lpszSourceInfo, _T("%s%s(%d)"), fname, ext, lineInfo.LineNumber ); | ||||
|         ret = TRUE; | ||||
|     } | ||||
| @@ -332,11 +332,11 @@ void StackTrace( HANDLE hThread, const char* lpszMessage, FILE *file ) | ||||
|                 hProcess, | ||||
|                 hThread, | ||||
|                 &callStack, | ||||
|                 NULL, | ||||
|                 NULL, | ||||
|                 nullptr, | ||||
|                 nullptr, | ||||
|                 SymFunctionTableAccess, | ||||
|                 SymGetModuleBase, | ||||
|                 NULL); | ||||
|                 nullptr); | ||||
|  | ||||
|             if ( index == 0 ) | ||||
|                 continue; | ||||
| @@ -389,11 +389,11 @@ void StackTrace(HANDLE hThread, const char* lpszMessage, FILE *file, DWORD eip, | ||||
|                 hProcess, | ||||
|                 hThread, | ||||
|                 &callStack, | ||||
|                 NULL, | ||||
|                 NULL, | ||||
|                 nullptr, | ||||
|                 nullptr, | ||||
|                 SymFunctionTableAccess, | ||||
|                 SymGetModuleBase, | ||||
|                 NULL); | ||||
|                 nullptr); | ||||
|  | ||||
|             if ( index == 0 ) | ||||
|                 continue; | ||||
|   | ||||
| @@ -57,7 +57,7 @@ public: | ||||
|         // advance the read pointer | ||||
|         m_read_ptr = m_read_ptr->next; | ||||
|         // set the next element to NULL to stop the recursive deletion | ||||
|         tmpptr->next = NULL; | ||||
|         tmpptr->next = nullptr; | ||||
|         delete tmpptr;    // this also deletes the element | ||||
|     } | ||||
|  | ||||
| @@ -86,7 +86,7 @@ private: | ||||
|     class ElementPtr | ||||
|     { | ||||
|     public: | ||||
|         ElementPtr() : current(NULL), next(NULL) {} | ||||
|         ElementPtr() : current(nullptr), next(nullptr) {} | ||||
|  | ||||
|         ~ElementPtr() | ||||
|         { | ||||
|   | ||||
| @@ -140,7 +140,7 @@ bool CreateDir(const std::string &path) | ||||
| { | ||||
|     INFO_LOG(COMMON, "CreateDir: directory %s", path.c_str()); | ||||
| #ifdef _WIN32 | ||||
|     if (::CreateDirectory(Common::UTF8ToTStr(path).c_str(), NULL)) | ||||
|     if (::CreateDirectory(Common::UTF8ToTStr(path).c_str(), nullptr)) | ||||
|         return true; | ||||
|     DWORD error = GetLastError(); | ||||
|     if (error == ERROR_ALREADY_EXISTS) | ||||
| @@ -423,7 +423,7 @@ u32 ScanDirectoryTree(const std::string &directory, FSTEntry& parentEntry) | ||||
|         FSTEntry entry; | ||||
|         const std::string virtualName(Common::TStrToUTF8(ffd.cFileName)); | ||||
| #else | ||||
|     struct dirent dirent, *result = NULL; | ||||
|     struct dirent dirent, *result = nullptr; | ||||
|  | ||||
|     DIR *dirp = opendir(directory.c_str()); | ||||
|     if (!dirp) | ||||
| @@ -491,7 +491,7 @@ bool DeleteDirRecursively(const std::string &directory) | ||||
|     { | ||||
|         const std::string virtualName(Common::TStrToUTF8(ffd.cFileName)); | ||||
| #else | ||||
|     struct dirent dirent, *result = NULL; | ||||
|     struct dirent dirent, *result = nullptr; | ||||
|     DIR *dirp = opendir(directory.c_str()); | ||||
|     if (!dirp) | ||||
|         return false; | ||||
| @@ -552,7 +552,7 @@ void CopyDir(const std::string &source_path, const std::string &dest_path) | ||||
|     if (!FileUtil::Exists(source_path)) return; | ||||
|     if (!FileUtil::Exists(dest_path)) FileUtil::CreateFullPath(dest_path); | ||||
|  | ||||
|     struct dirent dirent, *result = NULL; | ||||
|     struct dirent dirent, *result = nullptr; | ||||
|     DIR *dirp = opendir(source_path.c_str()); | ||||
|     if (!dirp) return; | ||||
|  | ||||
| @@ -586,11 +586,11 @@ std::string GetCurrentDir() | ||||
| { | ||||
|     char *dir; | ||||
|     // Get the current working directory (getcwd uses malloc) | ||||
|     if (!(dir = __getcwd(NULL, 0))) { | ||||
|     if (!(dir = __getcwd(nullptr, 0))) { | ||||
|  | ||||
|         ERROR_LOG(COMMON, "GetCurrentDirectory failed: %s", | ||||
|                 GetLastErrorMsg()); | ||||
|         return NULL; | ||||
|         return nullptr; | ||||
|     } | ||||
|     std::string strDir = dir; | ||||
|     free(dir); | ||||
| @@ -626,7 +626,7 @@ std::string& GetExeDirectory() | ||||
|     if (DolphinPath.empty()) | ||||
|     { | ||||
|         TCHAR Dolphin_exe_Path[2048]; | ||||
|         GetModuleFileName(NULL, Dolphin_exe_Path, 2048); | ||||
|         GetModuleFileName(nullptr, Dolphin_exe_Path, 2048); | ||||
|         DolphinPath = Common::TStrToUTF8(Dolphin_exe_Path); | ||||
|         DolphinPath = DolphinPath.substr(0, DolphinPath.find_last_of('\\')); | ||||
|     } | ||||
| @@ -826,7 +826,7 @@ void SplitFilename83(const std::string& filename, std::array<char, 9>& short_nam | ||||
| } | ||||
|  | ||||
| IOFile::IOFile() | ||||
|     : m_file(NULL), m_good(true) | ||||
|     : m_file(nullptr), m_good(true) | ||||
| {} | ||||
|  | ||||
| IOFile::IOFile(std::FILE* file) | ||||
| @@ -834,7 +834,7 @@ IOFile::IOFile(std::FILE* file) | ||||
| {} | ||||
|  | ||||
| IOFile::IOFile(const std::string& filename, const char openmode[]) | ||||
|     : m_file(NULL), m_good(true) | ||||
|     : m_file(nullptr), m_good(true) | ||||
| { | ||||
|     Open(filename, openmode); | ||||
| } | ||||
| @@ -845,7 +845,7 @@ IOFile::~IOFile() | ||||
| } | ||||
|  | ||||
| IOFile::IOFile(IOFile&& other) | ||||
|     : m_file(NULL), m_good(true) | ||||
|     : m_file(nullptr), m_good(true) | ||||
| { | ||||
|     Swap(other); | ||||
| } | ||||
| @@ -880,14 +880,14 @@ bool IOFile::Close() | ||||
|     if (!IsOpen() || 0 != std::fclose(m_file)) | ||||
|         m_good = false; | ||||
|  | ||||
|     m_file = NULL; | ||||
|     m_file = nullptr; | ||||
|     return m_good; | ||||
| } | ||||
|  | ||||
| std::FILE* IOFile::ReleaseHandle() | ||||
| { | ||||
|     std::FILE* const ret = m_file; | ||||
|     m_file = NULL; | ||||
|     m_file = nullptr; | ||||
|     return ret; | ||||
| } | ||||
|  | ||||
|   | ||||
| @@ -202,11 +202,11 @@ public: | ||||
|         return WriteArray(reinterpret_cast<const char*>(data), length); | ||||
|     } | ||||
|  | ||||
|     bool IsOpen() { return NULL != m_file; } | ||||
|     bool IsOpen() { return nullptr != m_file; } | ||||
|  | ||||
|     // m_good is set to false when a read, write or other function fails | ||||
|     bool IsGood() {    return m_good; } | ||||
|     operator void*() { return m_good ? m_file : NULL; } | ||||
|     operator void*() { return m_good ? m_file : nullptr; } | ||||
|  | ||||
|     std::FILE* ReleaseHandle(); | ||||
|  | ||||
|   | ||||
| @@ -70,7 +70,7 @@ public: | ||||
|             // good header, read some key/value pairs | ||||
|             K key; | ||||
|  | ||||
|             V *value = NULL; | ||||
|             V *value = nullptr; | ||||
|             u32 value_size; | ||||
|             u32 entry_number; | ||||
|  | ||||
|   | ||||
| @@ -21,7 +21,7 @@ void GenericLog(LogTypes::LOG_LEVELS level, LogTypes::LOG_TYPE type, const char* | ||||
|     va_end(args); | ||||
| } | ||||
|  | ||||
| LogManager *LogManager::m_logManager = NULL; | ||||
| LogManager *LogManager::m_logManager = nullptr; | ||||
|  | ||||
| LogManager::LogManager() | ||||
| { | ||||
| @@ -141,7 +141,7 @@ void LogManager::Init() | ||||
| void LogManager::Shutdown() | ||||
| { | ||||
|     delete m_logManager; | ||||
|     m_logManager = NULL; | ||||
|     m_logManager = nullptr; | ||||
| } | ||||
|  | ||||
| LogContainer::LogContainer(const char* shortName, const char* fullName, bool enable) | ||||
|   | ||||
| @@ -30,7 +30,7 @@ | ||||
| #endif | ||||
|  | ||||
| #ifdef IOS | ||||
| void* globalbase = NULL; | ||||
| void* globalbase = nullptr; | ||||
| #endif | ||||
|  | ||||
| #ifdef ANDROID | ||||
| @@ -121,7 +121,7 @@ void MemArena::GrabLowMemSpace(size_t size) | ||||
| { | ||||
| #ifdef _WIN32 | ||||
| #ifndef _XBOX | ||||
|     hMemoryMapping = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, (DWORD)(size), NULL); | ||||
|     hMemoryMapping = CreateFileMapping(INVALID_HANDLE_VALUE, nullptr, PAGE_READWRITE, 0, (DWORD)(size), nullptr); | ||||
|     GetSystemInfo(&sysInfo); | ||||
| #endif | ||||
| #elif defined(ANDROID) | ||||
| @@ -178,7 +178,7 @@ void *MemArena::CreateView(s64 offset, size_t size, void *base) | ||||
| #ifdef _XBOX | ||||
|     size = roundup(size); | ||||
|     // use 64kb pages | ||||
|     void * ptr = VirtualAlloc(NULL, size, MEM_COMMIT | MEM_LARGE_PAGES, PAGE_READWRITE); | ||||
|     void * ptr = VirtualAlloc(nullptr, size, MEM_COMMIT | MEM_LARGE_PAGES, PAGE_READWRITE); | ||||
|     return ptr; | ||||
| #else | ||||
|     size = roundup(size); | ||||
| @@ -243,8 +243,8 @@ u8* MemArena::Find4GBBase() | ||||
|     return base; | ||||
| #else | ||||
| #ifdef IOS | ||||
|     void* base = NULL; | ||||
|     if (globalbase == NULL){ | ||||
|     void* base = nullptr; | ||||
|     if (globalbase == nullptr){ | ||||
|         base = mmap(0, 0x08000000, PROT_READ | PROT_WRITE, | ||||
|             MAP_ANON | MAP_SHARED, -1, 0); | ||||
|         if (base == MAP_FAILED) { | ||||
| @@ -357,7 +357,7 @@ bail: | ||||
|         if (views[j].out_ptr_low && *views[j].out_ptr_low) | ||||
|         { | ||||
|             arena->ReleaseView(*views[j].out_ptr_low, views[j].size); | ||||
|             *views[j].out_ptr_low = NULL; | ||||
|             *views[j].out_ptr_low = nullptr; | ||||
|         } | ||||
|         if (*views[j].out_ptr) | ||||
|         { | ||||
| @@ -369,7 +369,7 @@ bail: | ||||
|                 arena->ReleaseView(*views[j].out_ptr, views[j].size); | ||||
|             } | ||||
| #endif | ||||
|             *views[j].out_ptr = NULL; | ||||
|             *views[j].out_ptr = nullptr; | ||||
|         } | ||||
|     } | ||||
|     return false; | ||||
| @@ -415,7 +415,7 @@ u8 *MemoryMap_Setup(const MemoryView *views, int num_views, u32 flags, MemArena | ||||
| #elif defined(_WIN32) | ||||
|     // Try a whole range of possible bases. Return once we got a valid one. | ||||
|     u32 max_base_addr = 0x7FFF0000 - 0x10000000; | ||||
|     u8 *base = NULL; | ||||
|     u8 *base = nullptr; | ||||
|  | ||||
|     for (u32 base_addr = 0x01000000; base_addr < max_base_addr; base_addr += 0x400000) | ||||
|     { | ||||
| @@ -463,8 +463,8 @@ void MemoryMap_Shutdown(const MemoryView *views, int num_views, u32 flags, MemAr | ||||
|             arena->ReleaseView(*views[i].out_ptr_low, views[i].size); | ||||
|         if (*views[i].out_ptr && (views[i].out_ptr_low && *views[i].out_ptr != *views[i].out_ptr_low)) | ||||
|             arena->ReleaseView(*views[i].out_ptr, views[i].size); | ||||
|         *views[i].out_ptr = NULL; | ||||
|         *views[i].out_ptr = nullptr; | ||||
|         if (views[i].out_ptr_low) | ||||
|             *views[i].out_ptr_low = NULL; | ||||
|             *views[i].out_ptr_low = nullptr; | ||||
|     } | ||||
| } | ||||
|   | ||||
| @@ -93,7 +93,7 @@ void* AllocateMemoryPages(size_t size) | ||||
|     // printf("Mapped memory at %p (size %ld)\n", ptr, | ||||
|     //    (unsigned long)size); | ||||
|  | ||||
|     if (ptr == NULL) | ||||
|     if (ptr == nullptr) | ||||
|         PanicAlert("Failed to allocate raw memory"); | ||||
|  | ||||
|     return ptr; | ||||
| @@ -104,7 +104,7 @@ void* AllocateAlignedMemory(size_t size,size_t alignment) | ||||
| #ifdef _WIN32 | ||||
|     void* ptr =  _aligned_malloc(size,alignment); | ||||
| #else | ||||
|     void* ptr = NULL; | ||||
|     void* ptr = nullptr; | ||||
| #ifdef ANDROID | ||||
|     ptr = memalign(alignment, size); | ||||
| #else | ||||
| @@ -116,7 +116,7 @@ void* AllocateAlignedMemory(size_t size,size_t alignment) | ||||
|     // printf("Mapped memory at %p (size %ld)\n", ptr, | ||||
|     //    (unsigned long)size); | ||||
|  | ||||
|     if (ptr == NULL) | ||||
|     if (ptr == nullptr) | ||||
|         PanicAlert("Failed to allocate aligned memory"); | ||||
|  | ||||
|     return ptr; | ||||
| @@ -130,7 +130,7 @@ void FreeMemoryPages(void* ptr, size_t size) | ||||
|  | ||||
|         if (!VirtualFree(ptr, 0, MEM_RELEASE)) | ||||
|             PanicAlert("FreeMemoryPages failed!\n%s", GetLastErrorMsg()); | ||||
|         ptr = NULL; // Is this our responsibility? | ||||
|         ptr = nullptr; // Is this our responsibility? | ||||
|  | ||||
| #else | ||||
|         munmap(ptr, size); | ||||
| @@ -184,7 +184,7 @@ std::string MemUsage() | ||||
|     // Print information about the memory usage of the process. | ||||
|  | ||||
|     hProcess = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, processID); | ||||
|     if (NULL == hProcess) return "MemUsage Error"; | ||||
|     if (nullptr == hProcess) return "MemUsage Error"; | ||||
|  | ||||
|     if (GetProcessMemoryInfo(hProcess, &pmc, sizeof(pmc))) | ||||
|         Ret = Common::StringFromFormat("%s K", Common::ThousandSeparate(pmc.WorkingSetSize / 1024, 7).c_str()); | ||||
|   | ||||
| @@ -23,9 +23,9 @@ const char* GetLastErrorMsg() | ||||
| #ifdef _WIN32 | ||||
|     static __declspec(thread) char err_str[buff_size] = {}; | ||||
|  | ||||
|     FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM, NULL, GetLastError(), | ||||
|     FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM, nullptr, GetLastError(), | ||||
|         MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), | ||||
|         err_str, buff_size, NULL); | ||||
|         err_str, buff_size, nullptr); | ||||
| #else | ||||
|     static __thread char err_str[buff_size] = {}; | ||||
|  | ||||
|   | ||||
| @@ -77,7 +77,7 @@ | ||||
| inline struct tm* localtime_r(const time_t *clock, struct tm *result) { | ||||
|     if (localtime_s(result, clock) == 0) | ||||
|         return result; | ||||
|     return NULL; | ||||
|     return nullptr; | ||||
| } | ||||
|  | ||||
| #else | ||||
|   | ||||
| @@ -31,7 +31,7 @@ std::string ToUpper(std::string str) { | ||||
| // faster than sscanf | ||||
| bool AsciiToHex(const char* _szValue, u32& result) | ||||
| { | ||||
|     char *endptr = NULL; | ||||
|     char *endptr = nullptr; | ||||
|     const u32 value = strtoul(_szValue, &endptr, 16); | ||||
|  | ||||
|     if (!endptr || *endptr) | ||||
| @@ -69,7 +69,7 @@ bool CharArrayFromFormatV(char* out, int outsize, const char* format, va_list ar | ||||
|     // will be present in the middle of a multibyte sequence. | ||||
|     // | ||||
|     // This is why we lookup an ANSI (cp1252) locale here and use _vsnprintf_l. | ||||
|     static locale_t c_locale = NULL; | ||||
|     static locale_t c_locale = nullptr; | ||||
|     if (!c_locale) | ||||
|         c_locale = _create_locale(LC_ALL, ".1252"); | ||||
|     writtenCount = _vsnprintf_l(out, outsize, format, c_locale, args); | ||||
| @@ -92,7 +92,7 @@ bool CharArrayFromFormatV(char* out, int outsize, const char* format, va_list ar | ||||
| std::string StringFromFormat(const char* format, ...) | ||||
| { | ||||
|     va_list args; | ||||
|     char *buf = NULL; | ||||
|     char *buf = nullptr; | ||||
| #ifdef _WIN32 | ||||
|     int required = 0; | ||||
|  | ||||
| @@ -162,7 +162,7 @@ std::string StripQuotes(const std::string& s) | ||||
|  | ||||
| bool TryParse(const std::string &str, u32 *const output) | ||||
| { | ||||
|     char *endptr = NULL; | ||||
|     char *endptr = nullptr; | ||||
|  | ||||
|     // Reset errno to a value other than ERANGE | ||||
|     errno = 0; | ||||
|   | ||||
| @@ -37,7 +37,7 @@ struct ThreadQueueList { | ||||
|     ~ThreadQueueList() { | ||||
|         for (int i = 0; i < NUM_QUEUES; ++i) | ||||
|         { | ||||
|             if (queues[i].data != NULL) | ||||
|             if (queues[i].data != nullptr) | ||||
|                 free(queues[i].data); | ||||
|         } | ||||
|     } | ||||
| @@ -46,7 +46,7 @@ struct ThreadQueueList { | ||||
|     int contains(const IdType uid) { | ||||
|         for (int i = 0; i < NUM_QUEUES; ++i) | ||||
|         { | ||||
|             if (queues[i].data == NULL) | ||||
|             if (queues[i].data == nullptr) | ||||
|                 continue; | ||||
|  | ||||
|             Queue *cur = &queues[i]; | ||||
| @@ -133,7 +133,7 @@ struct ThreadQueueList { | ||||
|     inline void clear() { | ||||
|         for (int i = 0; i < NUM_QUEUES; ++i) | ||||
|         { | ||||
|             if (queues[i].data != NULL) | ||||
|             if (queues[i].data != nullptr) | ||||
|                 free(queues[i].data); | ||||
|         } | ||||
|         memset(queues, 0, sizeof(queues)); | ||||
| @@ -147,7 +147,7 @@ struct ThreadQueueList { | ||||
|  | ||||
|     inline void prepare(u32 priority) { | ||||
|         Queue *cur = &queues[priority]; | ||||
|         if (cur->next == NULL) | ||||
|         if (cur->next == nullptr) | ||||
|             link(priority, INITIAL_CAPACITY); | ||||
|     } | ||||
|  | ||||
| @@ -176,7 +176,7 @@ private: | ||||
|  | ||||
|         for (int i = (int) priority - 1; i >= 0; --i) | ||||
|         { | ||||
|             if (queues[i].next != NULL) | ||||
|             if (queues[i].next != nullptr) | ||||
|             { | ||||
|                 cur->next = queues[i].next; | ||||
|                 queues[i].next = cur; | ||||
| @@ -193,7 +193,7 @@ private: | ||||
|         int size = cur->end - cur->first; | ||||
|         if (size >= cur->capacity - 2)  { | ||||
|             IdType *new_data = (IdType *)realloc(cur->data, cur->capacity * 2 * sizeof(IdType)); | ||||
|             if (new_data != NULL)  { | ||||
|             if (new_data != nullptr)  { | ||||
|                 cur->capacity *= 2; | ||||
|                 cur->data = new_data; | ||||
|             } | ||||
|   | ||||
| @@ -25,7 +25,7 @@ u32 Timer::GetTimeMs() | ||||
|     return timeGetTime(); | ||||
| #else | ||||
|     struct timeval t; | ||||
|     (void)gettimeofday(&t, NULL); | ||||
|     (void)gettimeofday(&t, nullptr); | ||||
|     return ((u32)(t.tv_sec * 1000 + t.tv_usec / 1000)); | ||||
| #endif | ||||
| } | ||||
| @@ -183,7 +183,7 @@ std::string Timer::GetTimeFormatted() | ||||
|     return StringFromFormat("%s:%03i", tmp, tp.millitm); | ||||
| #else | ||||
|     struct timeval t; | ||||
|     (void)gettimeofday(&t, NULL); | ||||
|     (void)gettimeofday(&t, nullptr); | ||||
|     return StringFromFormat("%s:%03d", tmp, (int)(t.tv_usec / 1000)); | ||||
| #endif | ||||
| } | ||||
| @@ -197,7 +197,7 @@ double Timer::GetDoubleTime() | ||||
|     (void)::ftime(&tp); | ||||
| #else | ||||
|     struct timeval t; | ||||
|     (void)gettimeofday(&t, NULL); | ||||
|     (void)gettimeofday(&t, nullptr); | ||||
| #endif | ||||
|     // Get continuous timestamp | ||||
|     u64 TmpSeconds = Common::Timer::GetTimeSinceJan1970(); | ||||
|   | ||||
| @@ -281,28 +281,28 @@ int u8_read_escape_sequence(const char *str, u32 *dest) | ||||
|     do { | ||||
|       digs[dno++] = str[i++]; | ||||
|     } while (octal_digit(str[i]) && dno < 3); | ||||
|     ch = strtol(digs, NULL, 8); | ||||
|     ch = strtol(digs, nullptr, 8); | ||||
|   } | ||||
|   else if (str[0] == 'x') { | ||||
|     while (hex_digit(str[i]) && dno < 2) { | ||||
|       digs[dno++] = str[i++]; | ||||
|     } | ||||
|     if (dno > 0) | ||||
|       ch = strtol(digs, NULL, 16); | ||||
|       ch = strtol(digs, nullptr, 16); | ||||
|   } | ||||
|   else if (str[0] == 'u') { | ||||
|     while (hex_digit(str[i]) && dno < 4) { | ||||
|       digs[dno++] = str[i++]; | ||||
|     } | ||||
|     if (dno > 0) | ||||
|       ch = strtol(digs, NULL, 16); | ||||
|       ch = strtol(digs, nullptr, 16); | ||||
|   } | ||||
|   else if (str[0] == 'U') { | ||||
|     while (hex_digit(str[i]) && dno < 8) { | ||||
|       digs[dno++] = str[i++]; | ||||
|     } | ||||
|     if (dno > 0) | ||||
|       ch = strtol(digs, NULL, 16); | ||||
|       ch = strtol(digs, nullptr, 16); | ||||
|   } | ||||
|   *dest = ch; | ||||
|  | ||||
| @@ -353,7 +353,7 @@ const char *u8_strchr(const char *s, u32 ch, int *charn) | ||||
|     lasti = i; | ||||
|     (*charn)++; | ||||
|   } | ||||
|   return NULL; | ||||
|   return nullptr; | ||||
| } | ||||
|  | ||||
| const char *u8_memchr(const char *s, u32 ch, size_t sz, int *charn) | ||||
| @@ -378,7 +378,7 @@ const char *u8_memchr(const char *s, u32 ch, size_t sz, int *charn) | ||||
|     lasti = i; | ||||
|     (*charn)++; | ||||
|   } | ||||
|   return NULL; | ||||
|   return nullptr; | ||||
| } | ||||
|  | ||||
| int u8_is_locale_utf8(const char *locale) | ||||
| @@ -419,35 +419,35 @@ bool UTF8StringHasNonASCII(const char *utf8string) { | ||||
|  | ||||
| std::string ConvertWStringToUTF8(const wchar_t *wstr) { | ||||
|     int len = (int)wcslen(wstr); | ||||
|     int size = (int)WideCharToMultiByte(CP_UTF8, 0, wstr, len, 0, 0, NULL, NULL); | ||||
|     int size = (int)WideCharToMultiByte(CP_UTF8, 0, wstr, len, 0, 0, nullptr, nullptr); | ||||
|     std::string s; | ||||
|     s.resize(size); | ||||
|     if (size > 0) { | ||||
|         WideCharToMultiByte(CP_UTF8, 0, wstr, len, &s[0], size, NULL, NULL); | ||||
|         WideCharToMultiByte(CP_UTF8, 0, wstr, len, &s[0], size, nullptr, nullptr); | ||||
|     } | ||||
|     return s; | ||||
| } | ||||
|  | ||||
| std::string ConvertWStringToUTF8(const std::wstring &wstr) { | ||||
|     int len = (int)wstr.size(); | ||||
|     int size = (int)WideCharToMultiByte(CP_UTF8, 0, wstr.c_str(), len, 0, 0, NULL, NULL); | ||||
|     int size = (int)WideCharToMultiByte(CP_UTF8, 0, wstr.c_str(), len, 0, 0, nullptr, nullptr); | ||||
|     std::string s; | ||||
|     s.resize(size); | ||||
|     if (size > 0) { | ||||
|         WideCharToMultiByte(CP_UTF8, 0, wstr.c_str(), len, &s[0], size, NULL, NULL); | ||||
|         WideCharToMultiByte(CP_UTF8, 0, wstr.c_str(), len, &s[0], size, nullptr, nullptr); | ||||
|     } | ||||
|     return s; | ||||
| } | ||||
|  | ||||
| void ConvertUTF8ToWString(wchar_t *dest, size_t destSize, const std::string &source) { | ||||
|     int len = (int)source.size(); | ||||
|     int size = (int)MultiByteToWideChar(CP_UTF8, 0, source.c_str(), len, NULL, 0); | ||||
|     int size = (int)MultiByteToWideChar(CP_UTF8, 0, source.c_str(), len, nullptr, 0); | ||||
|     MultiByteToWideChar(CP_UTF8, 0, source.c_str(), len, dest, std::min((int)destSize, size)); | ||||
| } | ||||
|  | ||||
| std::wstring ConvertUTF8ToWString(const std::string &source) { | ||||
|     int len = (int)source.size(); | ||||
|     int size = (int)MultiByteToWideChar(CP_UTF8, 0, source.c_str(), len, NULL, 0); | ||||
|     int size = (int)MultiByteToWideChar(CP_UTF8, 0, source.c_str(), len, nullptr, 0); | ||||
|     std::wstring str; | ||||
|     str.resize(size); | ||||
|     if (size > 0) { | ||||
|   | ||||
| @@ -67,7 +67,7 @@ s64 idledCycles; | ||||
| static std::recursive_mutex externalEventSection; | ||||
|  | ||||
| // Warning: not included in save state. | ||||
| void(*advanceCallback)(int cyclesExecuted) = NULL; | ||||
| void(*advanceCallback)(int cyclesExecuted) = nullptr; | ||||
|  | ||||
| void SetClockFrequencyMHz(int cpuMhz) | ||||
| { | ||||
| @@ -231,7 +231,7 @@ void ClearPendingEvents() | ||||
|  | ||||
| void AddEventToQueue(Event* ne) | ||||
| { | ||||
|     Event* prev = NULL; | ||||
|     Event* prev = nullptr; | ||||
|     Event** pNext = &first; | ||||
|     for (;;) | ||||
|     { | ||||
| @@ -327,7 +327,7 @@ s64 UnscheduleThreadsafeEvent(int event_type, u64 userdata) | ||||
|     } | ||||
|     if (!tsFirst) | ||||
|     { | ||||
|         tsLast = NULL; | ||||
|         tsLast = nullptr; | ||||
|         return result; | ||||
|     } | ||||
|  | ||||
| @@ -433,7 +433,7 @@ void RemoveThreadsafeEvent(int event_type) | ||||
|     } | ||||
|     if (!tsFirst) | ||||
|     { | ||||
|         tsLast = NULL; | ||||
|         tsLast = nullptr; | ||||
|         return; | ||||
|     } | ||||
|     Event *prev = tsFirst; | ||||
| @@ -495,7 +495,7 @@ void MoveEvents() | ||||
|         AddEventToQueue(tsFirst); | ||||
|         tsFirst = next; | ||||
|     } | ||||
|     tsLast = NULL; | ||||
|     tsLast = nullptr; | ||||
|  | ||||
|     // Move free events to threadsafe pool | ||||
|     while (allocatedTsEvents > 0 && eventPool) | ||||
| @@ -614,7 +614,7 @@ void DoState(PointerWrap &p) | ||||
|     // These (should) be filled in later by the modules. | ||||
|     event_types.resize(n, EventType(AntiCrashCallback, "INVALID EVENT")); | ||||
|  | ||||
|     p.DoLinkedList<BaseEvent, GetNewEvent, FreeEvent, Event_DoState>(first, (Event **)NULL); | ||||
|     p.DoLinkedList<BaseEvent, GetNewEvent, FreeEvent, Event_DoState>(first, (Event **)nullptr); | ||||
|     p.DoLinkedList<BaseEvent, GetNewTsEvent, FreeTsEvent, Event_DoState>(tsFirst, &tsLast); | ||||
|  | ||||
|     p.Do(g_clock_rate_arm11); | ||||
|   | ||||
| @@ -22,7 +22,7 @@ GLuint LoadShaders(const char* vertex_shader, const char* fragment_shader) { | ||||
|     // Compile Vertex Shader | ||||
|     DEBUG_LOG(GPU, "Compiling vertex shader."); | ||||
|  | ||||
|     glShaderSource(vertex_shader_id, 1, &vertex_shader, NULL); | ||||
|     glShaderSource(vertex_shader_id, 1, &vertex_shader, nullptr); | ||||
|     glCompileShader(vertex_shader_id); | ||||
|  | ||||
|     // Check Vertex Shader | ||||
| @@ -31,14 +31,14 @@ GLuint LoadShaders(const char* vertex_shader, const char* fragment_shader) { | ||||
|  | ||||
|     if (info_log_length > 1) { | ||||
|         std::vector<char> vertex_shader_error(info_log_length); | ||||
|         glGetShaderInfoLog(vertex_shader_id, info_log_length, NULL, &vertex_shader_error[0]); | ||||
|         glGetShaderInfoLog(vertex_shader_id, info_log_length, nullptr, &vertex_shader_error[0]); | ||||
|         DEBUG_LOG(GPU, "%s", &vertex_shader_error[0]); | ||||
|     } | ||||
|  | ||||
|     // Compile Fragment Shader | ||||
|     DEBUG_LOG(GPU, "Compiling fragment shader."); | ||||
|  | ||||
|     glShaderSource(fragment_shader_id, 1, &fragment_shader, NULL); | ||||
|     glShaderSource(fragment_shader_id, 1, &fragment_shader, nullptr); | ||||
|     glCompileShader(fragment_shader_id); | ||||
|  | ||||
|     // Check Fragment Shader | ||||
| @@ -47,7 +47,7 @@ GLuint LoadShaders(const char* vertex_shader, const char* fragment_shader) { | ||||
|  | ||||
|     if (info_log_length > 1) { | ||||
|         std::vector<char> fragment_shader_error(info_log_length); | ||||
|         glGetShaderInfoLog(fragment_shader_id, info_log_length, NULL, &fragment_shader_error[0]); | ||||
|         glGetShaderInfoLog(fragment_shader_id, info_log_length, nullptr, &fragment_shader_error[0]); | ||||
|         DEBUG_LOG(GPU, "%s", &fragment_shader_error[0]); | ||||
|     } | ||||
|  | ||||
| @@ -65,7 +65,7 @@ GLuint LoadShaders(const char* vertex_shader, const char* fragment_shader) { | ||||
|  | ||||
|     if (info_log_length > 1) { | ||||
|         std::vector<char> program_error(info_log_length); | ||||
|         glGetProgramInfoLog(program_id, info_log_length, NULL, &program_error[0]); | ||||
|         glGetProgramInfoLog(program_id, info_log_length, nullptr, &program_error[0]); | ||||
|         DEBUG_LOG(GPU, "%s", &program_error[0]); | ||||
|     } | ||||
|  | ||||
|   | ||||
| @@ -17,8 +17,8 @@ | ||||
|  | ||||
| namespace VideoCore { | ||||
|  | ||||
| EmuWindow*      g_emu_window    = NULL;     ///< Frontend emulator window | ||||
| RendererBase*   g_renderer      = NULL;     ///< Renderer plugin | ||||
| EmuWindow*      g_emu_window    = nullptr;     ///< Frontend emulator window | ||||
| RendererBase*   g_renderer      = nullptr;     ///< Renderer plugin | ||||
| int             g_current_frame = 0; | ||||
|  | ||||
| /// Initialize the video core | ||||
|   | ||||
		Reference in New Issue
	
	Block a user
	 bunnei
					bunnei