diff --git a/Aurora/External/support/freetype/include/FTL.TXT b/Aurora/External/support/freetype/include/FTL.TXT new file mode 100644 index 00000000..bbaba33f --- /dev/null +++ b/Aurora/External/support/freetype/include/FTL.TXT @@ -0,0 +1,169 @@ + The FreeType Project LICENSE + ---------------------------- + + 2006-Jan-27 + + Copyright 1996-2002, 2006 by + David Turner, Robert Wilhelm, and Werner Lemberg + + + +Introduction +============ + + The FreeType Project is distributed in several archive packages; + some of them may contain, in addition to the FreeType font engine, + various tools and contributions which rely on, or relate to, the + FreeType Project. + + This license applies to all files found in such packages, and + which do not fall under their own explicit license. The license + affects thus the FreeType font engine, the test programs, + documentation and makefiles, at the very least. + + This license was inspired by the BSD, Artistic, and IJG + (Independent JPEG Group) licenses, which all encourage inclusion + and use of free software in commercial and freeware products + alike. As a consequence, its main points are that: + + o We don't promise that this software works. However, we will be + interested in any kind of bug reports. (`as is' distribution) + + o You can use this software for whatever you want, in parts or + full form, without having to pay us. (`royalty-free' usage) + + o You may not pretend that you wrote this software. If you use + it, or only parts of it, in a program, you must acknowledge + somewhere in your documentation that you have used the + FreeType code. (`credits') + + We specifically permit and encourage the inclusion of this + software, with or without modifications, in commercial products. + We disclaim all warranties covering The FreeType Project and + assume no liability related to The FreeType Project. + + + Finally, many people asked us for a preferred form for a + credit/disclaimer to use in compliance with this license. We thus + encourage you to use the following text: + + """ + Portions of this software are copyright © The FreeType + Project (www.freetype.org). All rights reserved. + """ + + Please replace with the value from the FreeType version you + actually use. + + +Legal Terms +=========== + +0. Definitions +-------------- + + Throughout this license, the terms `package', `FreeType Project', + and `FreeType archive' refer to the set of files originally + distributed by the authors (David Turner, Robert Wilhelm, and + Werner Lemberg) as the `FreeType Project', be they named as alpha, + beta or final release. + + `You' refers to the licensee, or person using the project, where + `using' is a generic term including compiling the project's source + code as well as linking it to form a `program' or `executable'. + This program is referred to as `a program using the FreeType + engine'. + + This license applies to all files distributed in the original + FreeType Project, including all source code, binaries and + documentation, unless otherwise stated in the file in its + original, unmodified form as distributed in the original archive. + If you are unsure whether or not a particular file is covered by + this license, you must contact us to verify this. + + The FreeType Project is copyright (C) 1996-2000 by David Turner, + Robert Wilhelm, and Werner Lemberg. All rights reserved except as + specified below. + +1. No Warranty +-------------- + + THE FREETYPE PROJECT IS PROVIDED `AS IS' WITHOUT WARRANTY OF ANY + KIND, EITHER EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + PURPOSE. IN NO EVENT WILL ANY OF THE AUTHORS OR COPYRIGHT HOLDERS + BE LIABLE FOR ANY DAMAGES CAUSED BY THE USE OR THE INABILITY TO + USE, OF THE FREETYPE PROJECT. + +2. Redistribution +----------------- + + This license grants a worldwide, royalty-free, perpetual and + irrevocable right and license to use, execute, perform, compile, + display, copy, create derivative works of, distribute and + sublicense the FreeType Project (in both source and object code + forms) and derivative works thereof for any purpose; and to + authorize others to exercise some or all of the rights granted + herein, subject to the following conditions: + + o Redistribution of source code must retain this license file + (`FTL.TXT') unaltered; any additions, deletions or changes to + the original files must be clearly indicated in accompanying + documentation. The copyright notices of the unaltered, + original files must be preserved in all copies of source + files. + + o Redistribution in binary form must provide a disclaimer that + states that the software is based in part of the work of the + FreeType Team, in the distribution documentation. We also + encourage you to put an URL to the FreeType web page in your + documentation, though this isn't mandatory. + + These conditions apply to any software derived from or based on + the FreeType Project, not just the unmodified files. If you use + our work, you must acknowledge us. However, no fee need be paid + to us. + +3. Advertising +-------------- + + Neither the FreeType authors and contributors nor you shall use + the name of the other for commercial, advertising, or promotional + purposes without specific prior written permission. + + We suggest, but do not require, that you use one or more of the + following phrases to refer to this software in your documentation + or advertising materials: `FreeType Project', `FreeType Engine', + `FreeType library', or `FreeType Distribution'. + + As you have not signed this license, you are not required to + accept it. However, as the FreeType Project is copyrighted + material, only this license, or another one contracted with the + authors, grants you the right to use, distribute, and modify it. + Therefore, by using, distributing, or modifying the FreeType + Project, you indicate that you understand and accept all the terms + of this license. + +4. Contacts +----------- + + There are two mailing lists related to FreeType: + + o freetype@nongnu.org + + Discusses general use and applications of FreeType, as well as + future and wanted additions to the library and distribution. + If you are looking for support, start in this list if you + haven't found anything to help you in the documentation. + + o freetype-devel@nongnu.org + + Discusses bugs, as well as engine internals, design issues, + specific licenses, porting, etc. + + Our home page can be found at + + http://www.freetype.org + + +--- end of FTL.TXT --- diff --git a/Aurora/External/support/freetype/include/LICENSE.TXT b/Aurora/External/support/freetype/include/LICENSE.TXT new file mode 100644 index 00000000..99dc342d --- /dev/null +++ b/Aurora/External/support/freetype/include/LICENSE.TXT @@ -0,0 +1,37 @@ + +The FreeType 2 font engine is copyrighted work and cannot be used +legally without a software license. In order to make this project +usable to a vast majority of developers, we distribute it under two +mutually exclusive open-source licenses. + +This means that *you* must choose *one* of the two licenses described +below, then obey all its terms and conditions when using FreeType 2 in +any of your projects or products. + + - The FreeType License, found in the file `FTL.TXT', which is similar + to the original BSD license *with* an advertising clause that forces + you to explicitly cite the FreeType project in your product's + documentation. All details are in the license file. This license + is suited to products which don't use the GNU General Public + License. + + Note that this license is compatible to the GNU General Public + License version 3, but not version 2. + + - The GNU General Public License version 2, found in `GPLv2.TXT' (any + later version can be used also), for programs which already use the + GPL. Note that the FTL is incompatible with GPLv2 due to its + advertisement clause. + +The contributed BDF and PCF drivers come with a license similar to that +of the X Window System. It is compatible to the above two licenses (see +file src/bdf/README and src/pcf/README). + +The gzip module uses the zlib license (see src/gzip/zlib.h) which too is +compatible to the above two licenses. + +The MD5 checksum support (only used for debugging in development builds) +is in the public domain. + + +--- end of LICENSE.TXT --- diff --git a/Aurora/RuntimeCompiler/RuntimeCompiler_VS2010.vcxproj b/Aurora/RuntimeCompiler/RuntimeCompiler_VS2010.vcxproj index 5758e7a8..5ae6d1bb 100644 --- a/Aurora/RuntimeCompiler/RuntimeCompiler_VS2010.vcxproj +++ b/Aurora/RuntimeCompiler/RuntimeCompiler_VS2010.vcxproj @@ -127,6 +127,7 @@ + diff --git a/Aurora/RuntimeCompiler/RuntimeCompiler_VS2010.vcxproj.filters b/Aurora/RuntimeCompiler/RuntimeCompiler_VS2010.vcxproj.filters index 0897d89f..98947c5b 100644 --- a/Aurora/RuntimeCompiler/RuntimeCompiler_VS2010.vcxproj.filters +++ b/Aurora/RuntimeCompiler/RuntimeCompiler_VS2010.vcxproj.filters @@ -30,6 +30,9 @@ + + SimpleFileWatcher + diff --git a/Aurora/RuntimeCompiler/SimpleFileWatcher/FileWatcherWin32.cpp b/Aurora/RuntimeCompiler/SimpleFileWatcher/FileWatcherWin32.cpp index 6a351d27..32a09793 100644 --- a/Aurora/RuntimeCompiler/SimpleFileWatcher/FileWatcherWin32.cpp +++ b/Aurora/RuntimeCompiler/SimpleFileWatcher/FileWatcherWin32.cpp @@ -61,6 +61,7 @@ namespace FW /// Unpacks events and passes them to a user defined callback. void CALLBACK WatchCallback(DWORD dwErrorCode, DWORD dwNumberOfBytesTransfered, LPOVERLAPPED lpOverlapped) { +#ifndef WIN32_FW_USE_FINDFIRST_API char szFile[MAX_PATH]; PFILE_NOTIFY_INFORMATION pNotify; WatchStruct* pWatch = (WatchStruct*) lpOverlapped; @@ -92,14 +93,19 @@ namespace FW { RefreshWatch(pWatch); } +#endif } /// Refreshes the directory monitoring. bool RefreshWatch(WatchStruct* pWatch, bool _clear) { +#ifndef WIN32_FW_USE_FINDFIRST_API return ReadDirectoryChangesW( pWatch->mDirHandle, pWatch->mBuffer, sizeof(pWatch->mBuffer), pWatch->mIsRecursive, pWatch->mNotifyFilter, NULL, &pWatch->mOverlapped, _clear ? 0 : WatchCallback) != 0; +#else + return true; +#endif } /// Stops monitoring a directory. @@ -109,6 +115,7 @@ namespace FW { pWatch->mStopNow = TRUE; +#ifndef WIN32_FW_USE_FINDFIRST_API CancelIo(pWatch->mDirHandle); RefreshWatch(pWatch, true); @@ -120,6 +127,8 @@ namespace FW CloseHandle(pWatch->mOverlapped.hEvent); CloseHandle(pWatch->mDirHandle); +#endif + delete[] pWatch->mDirName; HeapFree(GetProcessHeap(), 0, pWatch); } @@ -132,6 +141,7 @@ namespace FW size_t ptrsize = sizeof(*pWatch); pWatch = static_cast(HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, ptrsize)); +#ifndef WIN32_FW_USE_FINDFIRST_API pWatch->mDirHandle = CreateFileA(szDirectory, FILE_LIST_DIRECTORY, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OVERLAPPED, NULL); @@ -155,6 +165,11 @@ namespace FW HeapFree(GetProcessHeap(), 0, pWatch); return NULL; +#else + + return pWatch; + +#endif } #pragma endregion @@ -196,6 +211,10 @@ namespace FW mWatches.insert(std::make_pair(watchid, watch)); +#ifdef WIN32_FW_USE_FINDFIRST_API + fw.add( directory.m_string ); +#endif + return watchid; } @@ -223,7 +242,12 @@ namespace FW return; WatchStruct* watch = iter->second; - mWatches.erase(iter); + +#ifdef WIN32_FW_USE_FINDFIRST_API + fw.remove(watch->mWatchid); +#endif + + mWatches.erase(iter); DestroyWatch(watch); } @@ -231,7 +255,73 @@ namespace FW //-------- void FileWatcherWin32::update() { +#ifndef WIN32_FW_USE_FINDFIRST_API MsgWaitForMultipleObjectsEx(0, NULL, 0, QS_ALLINPUT, MWMO_ALERTABLE); +#endif + +#ifdef WIN32_FW_USE_FINDFIRST_API + static std::vector events; + events.clear(); + + fw.watch(events); + + for( size_t c = 0; c != events.size(); ++c ) + { + switch(events[c].ty) + { + case FileWatcherWin32_AltImpl::CHANGE_SIZE: + { + std::string old_name; + DWORD fni; + std::string new_name = fw.get_event_filename( mWatches[c + 1]->mDirName, events[c].id, events[c].ty, fni, old_name ); + + if( !new_name.empty() ) + { + handleAction(mWatches[c + 1], new_name.c_str(), fni ); + } + + break; + } + case FileWatcherWin32_AltImpl::CHANGE_FILE_NAME: + { + std::string old_name; + DWORD fni; + std::string new_name = fw.get_event_filename( mWatches[c + 1]->mDirName, events[c].id, events[c].ty, fni, old_name ); + + if( !new_name.empty() ) + { + //changed from-to + if( !old_name.empty() ) + { + handleAction(mWatches[c + 1], old_name.c_str(), FILE_ACTION_RENAMED_OLD_NAME ); + handleAction(mWatches[c + 1], new_name.c_str(), FILE_ACTION_RENAMED_NEW_NAME ); + } + else + { + handleAction(mWatches[c + 1], new_name.c_str(), fni ); + } + } + + break; + } + case FileWatcherWin32_AltImpl::CHANGE_CREATION: + { + std::string old_name; + DWORD fni; + std::string new_name = fw.get_event_filename( mWatches[c + 1]->mDirName, events[c].id, events[c].ty, fni, old_name ); + + if( !new_name.empty() ) + { + handleAction(mWatches[c + 1], new_name.c_str(), fni ); + } + + break; + } + default: + break; + } + } +#endif } //-------- diff --git a/Aurora/RuntimeCompiler/SimpleFileWatcher/FileWatcherWin32.h b/Aurora/RuntimeCompiler/SimpleFileWatcher/FileWatcherWin32.h index 0ec2a971..097277ac 100644 --- a/Aurora/RuntimeCompiler/SimpleFileWatcher/FileWatcherWin32.h +++ b/Aurora/RuntimeCompiler/SimpleFileWatcher/FileWatcherWin32.h @@ -25,6 +25,7 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ + #ifndef _FW_FILEWATCHERWIN32_H_ #define _FW_FILEWATCHERWIN32_H_ #pragma once @@ -33,6 +34,15 @@ #if FILEWATCHER_PLATFORM == FILEWATCHER_PLATFORM_WIN32 +// Uncomment define below or include in build options to use FindFirstChangeNotification +// rather than ReadDirectoryChanges +// #define WIN32_FW_USE_FINDFIRST_API + +#ifdef WIN32_FW_USE_FINDFIRST_API +#include "FileWatcherWin32_AltImpl.h" +#endif + + #include namespace FW @@ -75,6 +85,10 @@ namespace FW /// The last watchid WatchID mLastWatchID; +#ifdef WIN32_FW_USE_FINDFIRST_API + FileWatcherWin32_AltImpl fw; +#endif + };//end FileWatcherWin32 };//namespace FW diff --git a/Aurora/RuntimeCompiler/SimpleFileWatcher/FileWatcherWin32_AltImpl.h b/Aurora/RuntimeCompiler/SimpleFileWatcher/FileWatcherWin32_AltImpl.h new file mode 100644 index 00000000..8731e121 --- /dev/null +++ b/Aurora/RuntimeCompiler/SimpleFileWatcher/FileWatcherWin32_AltImpl.h @@ -0,0 +1,339 @@ +// +// Copyright (c) 2013 Márton Tamás +// +// This software is provided 'as-is', without any express or implied +// warranty. In no event will the authors be held liable for any damages +// arising from the use of this software. +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it +// freely, subject to the following restrictions: +// 1. The origin of this software must not be misrepresented; you must not +// claim that you wrote the original software. If you use this software +// in a product, an acknowledgment in the product documentation would be +// appreciated but is not required. +// 2. Altered source versions must be plainly marked as such, and must not be +// misrepresented as being the original software. +// 3. This notice may not be removed or altered from any source distribution. + +// Minor modifications by Doug Binks +// This implementation for FileWatcherWin32 uses FindFirstChangeNotification rather +// than ReadDirectoryChanges + +#ifndef _FileWatcherWin32_AltImpl_h_ +#define _FileWatcherWin32_AltImpl_h_ +#pragma once + + +#if FILEWATCHER_PLATFORM == FILEWATCHER_PLATFORM_WIN32 + +#include +#include +#include + +#define WIN32_LEAN_AND_MEAN +#include + +static int fw_types[] = { FILE_NOTIFY_CHANGE_CREATION, FILE_NOTIFY_CHANGE_SIZE, FILE_NOTIFY_CHANGE_FILE_NAME }; +namespace FW +{ + class FileWatcherWin32_AltImpl + { + struct filedata + { + std::string fname; + LARGE_INTEGER fsize; + FILETIME ftime; + filedata( std::string n = std::string(), LARGE_INTEGER s = LARGE_INTEGER(), FILETIME t = FILETIME() ) + { + fname = n; + fsize = s; + ftime = t; + } + }; + + std::vector< HANDLE > handles[3]; + std::vector< std::vector< filedata > > dir_contents; + + void get_dir_contents( const std::string& path, std::vector< filedata >& contents ) + { + WIN32_FIND_DATAA fd; + HANDLE dir_lister = FindFirstFileA( (path + "\\*").c_str(), &fd ); + + if( dir_lister == INVALID_HANDLE_VALUE ) + { + std::cout << "Couldn't list files." << std::endl; + return; + } + + do + { + if( !(fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ) + { + LARGE_INTEGER fsize; + fsize.LowPart = fd.nFileSizeLow; + fsize.HighPart = fd.nFileSizeHigh; + FILETIME ftime; + ftime.dwLowDateTime = fd.ftCreationTime.dwLowDateTime; + ftime.dwHighDateTime = fd.ftCreationTime.dwHighDateTime; + contents.push_back(filedata( fd.cFileName, fsize, ftime )); + } + } + while(FindNextFileA(dir_lister, &fd) != 0); + + FindClose(dir_lister); + } + public: + + ~FileWatcherWin32_AltImpl() + { + for( int c = 0; c < 3; ++c ) + { + for( size_t d = 0; d != handles[c].size(); ++d ) + { + FindCloseChangeNotification(handles[c][d]); + } + } + } + + enum type + { + CHANGE_CREATION = 0, CHANGE_SIZE, CHANGE_FILE_NAME, CHANGE_NONE + }; + + struct fw_event + { + size_t id; + type ty; + fw_event( size_t i = -1, type t = CHANGE_NONE ) + { + id = i; + ty = t; + } + }; + + size_t add( const std::string& path ) + { + size_t id = handles[0].size(); + + for( int c = 0; c < 3; ++c ) + { + handles[c].push_back( FindFirstChangeNotificationA( path.c_str(), false, fw_types[c] ) ); + } + + for( int c = 0; c < 3; ++c ) + { + if( handles[c][id] == INVALID_HANDLE_VALUE ) + { + std::cerr << "Couldn't create handle." << std::endl; + return -1; + } + } + + dir_contents.resize(id + 1); + get_dir_contents( path, dir_contents[id] ); + + return id; + } + + bool watch(std::vector& ids) + { + for( int c = 0; c < 3; ++c ) + { + DWORD status = WaitForMultipleObjects(handles[c].size(), &handles[c][0], false, 0); + + for( size_t d = 0; d < handles[c].size(); ++d ) + { + if( status == WAIT_OBJECT_0 + d ) + { + ids.push_back( fw_event( d, (type)c ) ); + if( FindNextChangeNotification( handles[c][d] ) == false ) + { + return false; + } + } + } + } + + return true; + } + + std::string get_event_filename( const std::string& path, size_t id, type ty, DWORD& fni, std::string& old_name ) + { + static std::vector< filedata > contents; + contents.clear(); + + get_dir_contents( path, contents ); + + switch(ty) + { + //change in file creation time + //find the not matching creation time + case CHANGE_CREATION: + { + for( auto c = contents.begin(); c != contents.end(); ++c ) + { + for( auto d = dir_contents[id].begin(); d != dir_contents[id].end(); ++d ) + { + if( c->fname == d->fname && + c->ftime.dwLowDateTime != d->ftime.dwLowDateTime || + c->ftime.dwHighDateTime != d->ftime.dwHighDateTime + ) + { + //make sure we 'neutralize' the event + d->ftime.dwLowDateTime = c->ftime.dwLowDateTime; + d->ftime.dwHighDateTime = c->ftime.dwHighDateTime; + fni = FILE_ACTION_ADDED; + return d->fname; + } + } + } + break; + } + //change in file name + //find the new filename, and add it + //remove the old filename + case CHANGE_FILE_NAME: + { + std::string filename; + + bool file_deleted = contents.size() < dir_contents[id].size(); + + for( auto c = contents.begin(); c != contents.end(); ++c ) + { + bool found = false; + for( auto d = dir_contents[id].begin(); d != dir_contents[id].end(); ++d ) + { + if( c->fname == d->fname ) + { + found = true; + break; + } + } + + if( !found ) + { + //this is what we are looking for, the new filename + filename = c->fname; + dir_contents[id].push_back(*c); //add the new file + fni = FILE_ACTION_ADDED; + break; + } + } + + for( auto c = dir_contents[id].begin(); c != dir_contents[id].end(); ++c ) + { + bool found = false; + + for( auto d = contents.begin(); d != contents.end(); ++d ) + { + if( c->fname == d->fname ) + { + found = true; + break; + } + } + + if( !found ) + { + //this is the old filename + + if( file_deleted ) //file removed + { + filename = c->fname; + fni = FILE_ACTION_REMOVED; + } + else + { + old_name = c->fname; + fni = FILE_ACTION_MODIFIED; + } + + dir_contents[id].erase(c); + return filename; + } + } + + //in case a new file was created + if( !filename.empty() ) + { + fni = FILE_ACTION_ADDED; + return filename; + } + + break; + } + //change in file size + //find the not matching file size + case CHANGE_SIZE: + { + for( auto c = contents.begin(); c != contents.end(); ++c ) + { + for( auto d = dir_contents[id].begin(); d != dir_contents[id].end(); ++d ) + { + if( c->fname == d->fname && + ( c->fsize.LowPart != d->fsize.LowPart || + c->fsize.HighPart != d->fsize.HighPart ) + ) + { + //make sure we 'neutralize' the event + d->fsize.LowPart = c->fsize.LowPart; + d->fsize.HighPart = c->fsize.HighPart; + fni = FILE_ACTION_MODIFIED; + return d->fname; + } + } + } + + //new file + for( auto c = contents.begin(); c != contents.end(); ++c ) + { + bool found = false; + for( auto d = dir_contents[id].begin(); d != dir_contents[id].end(); ++d ) + { + if( c->fname == d->fname ) + { + found = true; + break; + } + } + + if( !found ) + { + //this is what we are looking for, the new filename + fni = FILE_ACTION_ADDED; + return c->fname; + } + } + + break; + } + default: + break; + } + + return ""; + } + + void remove( size_t id ) + { + for( int c = 0; c < 3; ++c ) + { + auto it = handles[c].begin(); + auto it2 = dir_contents.begin(); + for( int d = 0; d < id; ++d ) + { + ++it; + ++it2; + }; + FindCloseChangeNotification( handles[c][id] ); + handles[c].erase(it); + dir_contents.erase(it2); + } + } + }; + +} + +#endif + +#endif \ No newline at end of file diff --git a/Aurora/RuntimeObjectSystem/IRuntimeObjectSystem.h b/Aurora/RuntimeObjectSystem/IRuntimeObjectSystem.h index 8df2992b..7d64dcef 100644 --- a/Aurora/RuntimeObjectSystem/IRuntimeObjectSystem.h +++ b/Aurora/RuntimeObjectSystem/IRuntimeObjectSystem.h @@ -25,6 +25,7 @@ struct IObjectFactorySystem; struct IFileChangeNotifier; class BuildTool; struct RuntimeProtector; +struct SystemTable; struct IRuntimeObjectSystem { @@ -62,6 +63,8 @@ struct IRuntimeObjectSystem // clean up temporary object files virtual void CleanObjectFiles() const = 0; + virtual void SetupObjectConstructors(IPerModuleInterface* pPerModuleInterface) = 0; + //ensure subclasses are deleted correctly virtual ~IRuntimeObjectSystem(){}; diff --git a/Aurora/RuntimeObjectSystem/RuntimeObjectSystem.h b/Aurora/RuntimeObjectSystem/RuntimeObjectSystem.h index 1c4a5883..5d65f30e 100644 --- a/Aurora/RuntimeObjectSystem/RuntimeObjectSystem.h +++ b/Aurora/RuntimeObjectSystem/RuntimeObjectSystem.h @@ -113,6 +113,8 @@ class RuntimeObjectSystem : public IRuntimeObjectSystem, public IFileChangeListe return m_TotalLoadedModulesEver; } + virtual void SetupObjectConstructors(IPerModuleInterface* pPerModuleInterface); + // exception handling to catch and protect main app from crashing when using runtime compiling virtual void SetProtectionEnabled( bool bProtectionEnabled_ ); @@ -122,7 +124,6 @@ class RuntimeObjectSystem : public IRuntimeObjectSystem, public IFileChangeListe } virtual bool TryProtectedFunction( RuntimeProtector* pProtectedObject_ ); - void SetupObjectConstructors(IPerModuleInterface* pPerModuleInterface); // IFileChangeListener