martin
/
protot
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
protot/3rdparty/RuntimeCompiledCpp/RuntimeObjectSystem/RuntimeObjectSystem.cpp

1023 lines
37 KiB
C++
Raw Blame History

//
// Copyright (c) 2010-2011 Matthew Jack and Doug Binks
//
// 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.
#include "RuntimeObjectSystem.h"
// Remove windows.h define of GetObject which conflicts with EntitySystem GetObject
#if defined _WINDOWS_ && defined GetObject
#undef GetObject
#endif
#include "../RuntimeCompiler/AUArray.h"
#include "../RuntimeCompiler/ICompilerLogger.h"
#include "../RuntimeCompiler/FileChangeNotifier.h"
#include "IObjectFactorySystem.h"
#include "ObjectFactorySystem/ObjectFactorySystem.h"
#include "ObjectInterfacePerModule.h"
#include <algorithm>
#include "IObject.h"
#ifndef _WIN32
//TODO: fix below in a better generic fashion.
#define MAX_PATH 256
#include <dlfcn.h>
#endif
using FileSystemUtils::Path;
FileSystemUtils::Path RuntimeObjectSystem::ProjectSettings::ms_DefaultIntermediatePath;
static Path GetIntermediateFolder( Path basePath_, RCppOptimizationLevel optimizationLevel_ )
{
std::string folder;
#ifdef _DEBUG
folder = "DEBUG_";
#else
folder = "RELEASE_";
#endif
folder += RCppOptimizationLevelStrings[ GetActualOptimizationLevel( optimizationLevel_ ) ];
Path runtimeFolder = basePath_ / folder;
return runtimeFolder;
}
RuntimeObjectSystem::RuntimeObjectSystem()
: m_pCompilerLogger(0)
, m_pSystemTable(0)
, m_pObjectFactorySystem(new ObjectFactorySystem())
, m_pFileChangeNotifier(new FileChangeNotifier())
, m_pBuildTool(new BuildTool())
, m_bCompiling( false )
, m_bLastLoadModuleSuccess( false )
, m_bAutoCompile( true )
, m_TotalLoadedModulesEver(1) // starts at one for current exe
, m_bProtectionEnabled( true )
, m_pImpl( 0 )
, m_CurrentlyBuildingProject( 0 )
{
ProjectSettings::ms_DefaultIntermediatePath = FileSystemUtils::GetCurrentPath() / "Runtime";
CreatePlatformImpl();
}
RuntimeObjectSystem::~RuntimeObjectSystem()
{
m_pFileChangeNotifier->RemoveListener(this);
DeletePlatformImpl();
delete m_pObjectFactorySystem;
delete m_pFileChangeNotifier;
delete m_pBuildTool;
// Note we do not delete compiler logger, creator should do this
}
bool RuntimeObjectSystem::Initialise( ICompilerLogger * pLogger, SystemTable* pSystemTable )
{
m_pCompilerLogger = pLogger;
m_pSystemTable = pSystemTable;
m_pBuildTool->Initialise(m_pCompilerLogger);
// We start by using the code in the current module
IPerModuleInterface* pPerModuleInterface = PerModuleInterface::GetInstance();
pPerModuleInterface->SetModuleFileName( "Main Exe" );
m_pObjectFactorySystem->SetLogger( m_pCompilerLogger );
m_pObjectFactorySystem->SetRuntimeObjectSystem( this );
FileSystemUtils::Path initialDir = FileSystemUtils::GetCurrentPath();
m_FoundSourceDirectoryMappings[initialDir] = initialDir;
SetupObjectConstructors(pPerModuleInterface);
//add this dir to list of include dirs
FileSystemUtils::Path includeDir = FindFile(__FILE__);
includeDir = includeDir.ParentPath();
AddIncludeDir(includeDir.c_str());
//also add the runtime compiler dir to list of dirs
includeDir = includeDir.ParentPath() / Path("RuntimeCompiler");
AddIncludeDir(includeDir.c_str());
return true;
}
void RuntimeObjectSystem::OnFileChange(const IAUDynArray<const char*>& filelist)
{
if( !m_bAutoCompile )
{
return;
}
for( unsigned short proj = 0; proj < m_Projects.size(); ++proj )
{
std::vector<BuildTool::FileToBuild>* pBuildFileList = &m_Projects[ proj ].m_BuildFileList;
if( m_bCompiling )
{
pBuildFileList = &m_Projects[ proj ].m_PendingBuildFileList;
}
if (m_pCompilerLogger) { m_pCompilerLogger->LogInfo( "FileChangeNotifier triggered recompile with changes to:\n" ); }
for( size_t i = 0; i < filelist.Size(); ++i )
{
// check this file is in our project list
TFileList::iterator it = std::find( m_Projects[ proj ].m_RuntimeFileList.begin( ), m_Projects[ proj ].m_RuntimeFileList.end( ), filelist[i] );
if( it == m_Projects[ proj ].m_RuntimeFileList.end() )
{
continue;
}
if (m_pCompilerLogger) { m_pCompilerLogger->LogInfo( " File %s\n", filelist[ i ] ); }
BuildTool::FileToBuild fileToBuild( filelist[ i ] );
bool bFindIncludeDependencies = true; // if this is a header or a source dependency need to find include dependencies
bool bForceIncludeDependencies = true;
if( fileToBuild.filePath.Extension() != ".h" ) //TODO: change to check for .cpp and .c as could have .inc files etc.?
{
bFindIncludeDependencies = false;
pBuildFileList->push_back( fileToBuild );
// file may be a source dependency, check
TFileToFilesIterator itrCurr = m_Projects[ proj ].m_RuntimeSourceDependencyMap.begin( );
while( itrCurr != m_Projects[ proj ].m_RuntimeSourceDependencyMap.end( ) )
{
if( itrCurr->second == fileToBuild.filePath )
{
BuildTool::FileToBuild fileToBuild( itrCurr->first );
pBuildFileList->push_back( fileToBuild );
}
++itrCurr;
}
}
if( bFindIncludeDependencies )
{
TFileToFilesEqualRange range = m_Projects[ proj ].m_RuntimeIncludeMap.equal_range( fileToBuild.filePath );
for( TFileToFilesIterator it = range.first; it != range.second; ++it )
{
BuildTool::FileToBuild fileToBuildFromIncludes( ( *it ).second, bForceIncludeDependencies );
pBuildFileList->push_back( fileToBuildFromIncludes );
}
}
}
}
if( !m_bCompiling )
{
StartRecompile();
}
}
bool RuntimeObjectSystem::GetIsCompiledComplete()
{
return m_bCompiling && m_pBuildTool->GetIsComplete();
}
void RuntimeObjectSystem::CompileAllInProject( bool bForceRecompile, unsigned short projectId_ )
{
ProjectSettings& project = GetProject( projectId_ );
// since this is a compile all we can clear any pending compiles
project.m_BuildFileList.clear( );
// ensure we have an up to date list of files to commpile if autocompile is off
if( !m_bAutoCompile )
{
AUDynArray<IObjectConstructor*> constructors;
m_pObjectFactorySystem->GetAll(constructors);
SetupRuntimeFileTracking(constructors);
}
// add all files except headers
for( size_t i = 0; i < m_Projects[ projectId_ ].m_RuntimeFileList.size( ); ++i )
{
BuildTool::FileToBuild fileToBuild( project.m_RuntimeFileList[ i ], true ); //force re-compile on compile all
if( fileToBuild.filePath.Extension() != ".h") //TODO: change to check for .cpp and .c as could have .inc files etc.?
{
project.m_BuildFileList.push_back( fileToBuild );
}
}
StartRecompile();
}
void RuntimeObjectSystem::CompileAll( bool bForceRecompile )
{
for( unsigned short proj = 0; proj < m_Projects.size(); ++proj )
{
CompileAllInProject( bForceRecompile, proj );
}
}
void RuntimeObjectSystem::SetAutoCompile( bool autoCompile )
{
m_bAutoCompile = autoCompile;
if (m_bAutoCompile)
{
AUDynArray<IObjectConstructor*> constructors;
m_pObjectFactorySystem->GetAll(constructors);
SetupRuntimeFileTracking(constructors);
}
}
// RuntimeObjectSystem::AddToRuntimeFileList - filename should be cleaned of "/../" etc, see FileSystemUtils::Path::GetCleanPath()
void RuntimeObjectSystem::AddToRuntimeFileList( const char* filename, unsigned short projectId_ )
{
ProjectSettings& project = GetProject( projectId_ );
TFileList::iterator it = std::find( project.m_RuntimeFileList.begin( ), project.m_RuntimeFileList.end( ), filename );
if( it == project.m_RuntimeFileList.end( ) )
{
project.m_RuntimeFileList.push_back( filename );
m_pFileChangeNotifier->Watch( filename, this );
}
}
void RuntimeObjectSystem::RemoveFromRuntimeFileList( const char* filename, unsigned short projectId_ )
{
ProjectSettings& project = GetProject( projectId_ );
TFileList::iterator it = std::find( project.m_RuntimeFileList.begin( ), project.m_RuntimeFileList.end( ), filename );
if( it != project.m_RuntimeFileList.end( ) )
{
project.m_RuntimeFileList.erase( it );
}
}
void RuntimeObjectSystem::StartRecompile()
{
m_bCompiling = true;
if( m_pCompilerLogger ) { m_pCompilerLogger->LogInfo( "Compiling...\n" ); }
//Use a temporary filename for the dll
#ifdef _WIN32
char tempPath[ MAX_PATH ];
GetTempPathA( MAX_PATH, tempPath );
char tempFileName[ MAX_PATH ];
GetTempFileNameA( tempPath, "", 0, tempFileName );
std::string strTempFileName( tempFileName );
m_CurrentlyCompilingModuleName = strTempFileName;
#else
char tempPath[] = "/tmp/RCCppTempDylibXXXXXX";
int fileDesc = mkstemp(tempPath);
assert( fileDesc != -1 ); //TODO: should really handle the error
close( fileDesc ); //we don't actually want to make the file as yet
m_CurrentlyCompilingModuleName = tempPath;
#endif
// we step through and build each project in turn if there is anything to build, starting from m_PreviousBuildProject
bool bHaveProjectToBuild = false;
unsigned short project = m_CurrentlyBuildingProject;
if( m_Projects.size( ) )
{
do
{
++project;
if( project >= m_Projects.size( ) )
{
project = 0;
}
if( m_Projects[ project ].m_BuildFileList.size() || m_Projects[ project ].m_PendingBuildFileList.size() )
{
bHaveProjectToBuild = true;
}
} while( !bHaveProjectToBuild && m_CurrentlyBuildingProject != project );
m_CurrentlyBuildingProject = project;
}
if( !bHaveProjectToBuild )
{
if( m_pCompilerLogger ) { m_pCompilerLogger->LogError( "Error - could not find any files to build in any projects\n" ); }
m_bCompiling = false;
return;
}
m_Projects[ project ].m_BuildFileList.insert( m_Projects[ project ].m_BuildFileList.end( ), m_Projects[ project ].m_PendingBuildFileList.begin( ), m_Projects[ project ].m_PendingBuildFileList.end( ) );
m_Projects[ project ].m_PendingBuildFileList.clear( );
std::vector<BuildTool::FileToBuild> ourBuildFileList( m_Projects[ project ].m_BuildFileList );
//Add libraries which need linking
std::vector<FileSystemUtils::Path> linkLibraryList;
for( size_t i = 0; i < ourBuildFileList.size(); ++ i )
{
TFileToFilesEqualRange range = m_Projects[ project ].m_RuntimeLinkLibraryMap.equal_range( ourBuildFileList[ i ].filePath );
for(TFileToFilesIterator it=range.first; it!=range.second; ++it)
{
linkLibraryList.push_back( it->second );
}
}
//Add required source files
const std::vector<const char*> vecRequiredFiles = PerModuleInterface::GetInstance()->GetRequiredSourceFiles();
FileSystemUtils::Path compileDir = PerModuleInterface::GetInstance()->GetCompiledPath();
for( size_t i = 0; i < vecRequiredFiles.size(); ++i )
{
FileSystemUtils::Path fullpath = compileDir / vecRequiredFiles[i];
fullpath = FindFile( fullpath );
BuildTool::FileToBuild reqFile( fullpath, false ); //don't force compile of these
ourBuildFileList.push_back( reqFile );
}
//Add dependency source files
size_t buildListSize = ourBuildFileList.size(); // we will add to the build list, so get the size before the loop
for( size_t i = 0; i < buildListSize; ++ i )
{
TFileToFilesEqualRange range = m_Projects[ project ].m_RuntimeSourceDependencyMap.equal_range( ourBuildFileList[ i ].filePath );
for(TFileToFilesIterator it=range.first; it!=range.second; ++it)
{
BuildTool::FileToBuild reqFile( it->second, false ); //don't force compile of these
ourBuildFileList.push_back( reqFile );
}
}
m_Projects[ project ].m_CompilerOptions.intermediatePath = GetIntermediateFolder( m_Projects[ project ].m_CompilerOptions.baseIntermediatePath,
m_Projects[ project ].m_CompilerOptions.optimizationLevel );
m_pBuildTool->BuildModule( ourBuildFileList,
m_Projects[ project ].m_CompilerOptions,
linkLibraryList, m_CurrentlyCompilingModuleName );
}
bool RuntimeObjectSystem::LoadCompiledModule()
{
m_bLastLoadModuleSuccess = false;
m_bCompiling = false;
// Since the temporary file is created with 0 bytes, loadlibrary can fail with a dialogue we want to prevent. So check size
// We pass in the ec value so the function won't throw an exception on error, but the value itself sometimes seems to
// be set even without an error, so not sure if it should be relied on.
uint64_t sizeOfModule = m_CurrentlyCompilingModuleName.GetFileSize();
HMODULE module = 0;
if( sizeOfModule )
{
#ifdef _WIN32
module = LoadLibraryA( m_CurrentlyCompilingModuleName.c_str() );
#else
module = dlopen( m_CurrentlyCompilingModuleName.c_str(), RTLD_NOW );
#endif
}
if (!module)
{
if (m_pCompilerLogger) { m_pCompilerLogger->LogError( "Failed to load module %s\n",m_CurrentlyCompilingModuleName.c_str()); }
return false;
}
GETPerModuleInterface_PROC pPerModuleInterfaceProcAdd = 0;
#ifdef _WIN32
pPerModuleInterfaceProcAdd = (GETPerModuleInterface_PROC) GetProcAddress(module, "GetPerModuleInterface");
#else
pPerModuleInterfaceProcAdd = (GETPerModuleInterface_PROC) dlsym(module,"GetPerModuleInterface");
#endif
if (!pPerModuleInterfaceProcAdd)
{
if (m_pCompilerLogger) { m_pCompilerLogger->LogError( "Failed GetProcAddress\n"); }
return false;
}
pPerModuleInterfaceProcAdd()->SetModuleFileName( m_CurrentlyCompilingModuleName.c_str() );
pPerModuleInterfaceProcAdd( )->SetProjectIdForAllConstructors( m_CurrentlyBuildingProject );
m_Modules.push_back( module );
if (m_pCompilerLogger) { m_pCompilerLogger->LogInfo( "Compilation Succeeded\n"); }
++m_TotalLoadedModulesEver;
SetupObjectConstructors(pPerModuleInterfaceProcAdd());
m_Projects[ m_CurrentlyBuildingProject ].m_BuildFileList.clear( ); // clear the files from our compile list
m_bLastLoadModuleSuccess = true;
// check if there is another project to build
bool bNeedAnotherCompile = false;
for( unsigned short proj = 0; proj < m_Projects.size( ); ++proj )
{
if( m_Projects[ proj ].m_BuildFileList.size( ) || m_Projects[ proj ].m_PendingBuildFileList.size( ) )
{
bNeedAnotherCompile = true;
}
}
if( bNeedAnotherCompile )//
{
// we have pending files to compile, go ahead and compile them
StartRecompile();
}
return true;
}
void RuntimeObjectSystem::SetupObjectConstructors(IPerModuleInterface* pPerModuleInterface)
{
// Set system Table
pPerModuleInterface->SetSystemTable( m_pSystemTable );
// get hold of the constructors
const std::vector<IObjectConstructor*> &objectConstructors = pPerModuleInterface->GetConstructors();
AUDynArray<IObjectConstructor*> constructors(objectConstructors.size());
for (size_t i = 0, iMax = objectConstructors.size(); i < iMax; ++i)
{
constructors[i] = objectConstructors[i];
}
if (m_bAutoCompile)
{
SetupRuntimeFileTracking(constructors);
}
m_pObjectFactorySystem->AddConstructors(constructors);
}
void RuntimeObjectSystem::SetupRuntimeFileTracking(const IAUDynArray<IObjectConstructor*>& constructors_)
{
#ifndef RCCPPOFF
// for optimization purposes we skip some actions when running for the first time (i.e. no previous constructors)
static bool bFirstTime = true;
for (size_t i = 0, iMax = constructors_.Size(); i < iMax; ++i)
{
const char* pFilename = constructors_[i]->GetFileName(); // GetFileName returns full path including GetCompiledPath()
if( !pFilename )
{
continue;
}
Path filePath = pFilename;
filePath = filePath.GetCleanPath();
filePath = FindFile( filePath );
unsigned short projectId = constructors_[ i ]->GetProjectId();
ProjectSettings& project = GetProject( projectId );
AddToRuntimeFileList( filePath.c_str( ), projectId );
if( !bFirstTime )
{
//remove old include file mappings for this file
TFileToFilesIterator itrCurr = project.m_RuntimeIncludeMap.begin( );
while( itrCurr != project.m_RuntimeIncludeMap.end( ) )
{
if( itrCurr->second == filePath )
{
TFileToFilesIterator itrErase = itrCurr;
++itrCurr;
project.m_RuntimeIncludeMap.erase( itrErase );
}
else
{
++itrCurr;
}
}
//remove previous link libraries for this file
project.m_RuntimeLinkLibraryMap.erase( filePath );
//remove previous source dependencies
project.m_RuntimeSourceDependencyMap.erase( filePath );
}
//we need the compile path for some platforms where the __FILE__ path is relative to the compile path
FileSystemUtils::Path compileDir = constructors_[i]->GetCompiledPath();
//add include file mappings
for (size_t includeNum = 0; includeNum <= constructors_[i]->GetMaxNumIncludeFiles(); ++includeNum)
{
const char* pIncludeFile = constructors_[i]->GetIncludeFile(includeNum);
if( pIncludeFile )
{
FileSystemUtils::Path pathInc = compileDir / pIncludeFile;
pathInc = FindFile( pathInc.GetCleanPath() );
TFileToFilePair includePathPair;
includePathPair.first = pathInc;
includePathPair.second = filePath;
AddToRuntimeFileList( pathInc.c_str(), projectId );
project.m_RuntimeIncludeMap.insert( includePathPair );
}
}
//add link library file mappings
for (size_t linklibraryNum = 0; linklibraryNum <= constructors_[i]->GetMaxNumLinkLibraries(); ++linklibraryNum)
{
const char* pLinkLibrary = constructors_[i]->GetLinkLibrary(linklibraryNum);
if( pLinkLibrary )
{
// We do not use FindFiles for Linked Libraries as these are searched for on
// the library paths, which are themselves searched for.
TFileToFilePair linklibraryPathPair;
linklibraryPathPair.first = filePath;
linklibraryPathPair.second = pLinkLibrary;
project.m_RuntimeLinkLibraryMap.insert( linklibraryPathPair );
}
}
//add source dependency file mappings
for (size_t num = 0; num <= constructors_[i]->GetMaxNumSourceDependencies(); ++num)
{
SourceDependencyInfo sourceDependency = constructors_[i]->GetSourceDependency(num);
FileSystemUtils::Path pathInc[2]; // array of potential include files for later checks
if( sourceDependency.filename )
{
FileSystemUtils::Path pathSrc;
if( sourceDependency.relativeToPath )
{
pathSrc = sourceDependency.relativeToPath;
if( pathSrc.HasExtension() )
{
pathInc[1] = compileDir / pathSrc;
pathSrc = compileDir / pathSrc.ParentPath() / sourceDependency.filename;
}
else
{
pathSrc = compileDir / pathSrc / sourceDependency.filename;
}
}
else
{
pathSrc = compileDir / sourceDependency.filename;
}
pathSrc.ToOSCanonicalCase();
pathSrc = pathSrc.DelimitersToOSDefault();
pathSrc = pathSrc.GetCleanPath();
pathInc[0] = pathSrc;
if( sourceDependency.extension )
{
pathSrc.ReplaceExtension( sourceDependency.extension );
}
pathSrc = FindFile( pathSrc.GetCleanPath() );
TFileToFilePair sourcePathPair;
sourcePathPair.first = filePath;
sourcePathPair.second = pathSrc;
project.m_RuntimeSourceDependencyMap.insert( sourcePathPair );
// if the include file with a source dependancy is logged as an runtime include, then we mark this .cpp as compile dependencies on change
for( int inc=0; inc<2; ++inc )
{
TFileToFilesEqualRange range = project.m_RuntimeIncludeMap.equal_range( pathInc[inc] );
if( range.first != range.second )
{
// add source file to runtime file list
AddToRuntimeFileList( pathSrc.c_str(), projectId );
// also add this as a source dependency, so it gets force compiled on change of header (and not just compiled)
TFileToFilePair includePathPair;
includePathPair.first = pathInc[inc];
includePathPair.second = pathSrc;
project.m_RuntimeIncludeMap.insert( includePathPair );
}
}
}
}
}
bFirstTime = false;
#endif
}
RuntimeObjectSystem::ProjectSettings& RuntimeObjectSystem::GetProject( unsigned short projectId_ )
{
if( projectId_ >= m_Projects.size() )
{
m_Projects.resize(projectId_ + 1);
}
return m_Projects[ projectId_ ];
}
void RuntimeObjectSystem::AddIncludeDir( const char *path_, unsigned short projectId_ )
{
GetProject( projectId_).m_CompilerOptions.includeDirList.push_back( path_ );
}
void RuntimeObjectSystem::AddLibraryDir( const char *path_, unsigned short projectId_ )
{
GetProject( projectId_ ).m_CompilerOptions.libraryDirList.push_back( path_ );
}
void RuntimeObjectSystem::SetAdditionalCompileOptions( const char *options, unsigned short projectId_ )
{
GetProject( projectId_ ).m_CompilerOptions.compileOptions = options;
}
void RuntimeObjectSystem::SetCompilerLocation( const char *path, unsigned short projectId_ )
{
GetProject( projectId_ ).m_CompilerOptions.compilerLocation = path;
}
void RuntimeObjectSystem::SetAdditionalLinkOptions( const char *options, unsigned short projectId_ )
{
GetProject( projectId_ ).m_CompilerOptions.linkOptions = options;
}
void RuntimeObjectSystem::SetOptimizationLevel( RCppOptimizationLevel optimizationLevel_, unsigned short projectId_ )
{
GetProject( projectId_ ).m_CompilerOptions.optimizationLevel = optimizationLevel_;
}
RCppOptimizationLevel RuntimeObjectSystem::GetOptimizationLevel( unsigned short projectId_ )
{
return GetProject( projectId_ ).m_CompilerOptions.optimizationLevel;
}
void RuntimeObjectSystem::SetIntermediateDir( const char* path_, unsigned short projectId_ )
{
GetProject( projectId_ ).m_CompilerOptions.baseIntermediatePath = path_;
}
void RuntimeObjectSystem::CleanObjectFiles() const
{
if( m_pBuildTool )
{
for( unsigned short proj = 0; proj < m_Projects.size(); ++proj )
{
for( int optimizationLevel = 0;
optimizationLevel < RCCPPOPTIMIZATIONLEVEL_SIZE;
++optimizationLevel )
{
Path intermediateFolder = GetIntermediateFolder( m_Projects[ proj ].m_CompilerOptions.baseIntermediatePath, RCppOptimizationLevel( optimizationLevel ) );
m_pBuildTool->Clean( intermediateFolder );
}
}
}
}
FileSystemUtils::Path RuntimeObjectSystem::FindFile( const FileSystemUtils::Path& input )
{
FileSystemUtils::Path requestedDirectory = input;
FileSystemUtils::Path filename;
FileSystemUtils::Path foundFile = input;
bool bIsFile = input.HasExtension();
if( bIsFile )
{
requestedDirectory = requestedDirectory.ParentPath();
filename = input.Filename();
}
requestedDirectory.ToOSCanonicalCase();
filename.ToOSCanonicalCase();
foundFile.ToOSCanonicalCase();
// Step 1: Try input directory
if( requestedDirectory.Exists() )
{
m_FoundSourceDirectoryMappings[ requestedDirectory ] = requestedDirectory;
}
else
{
// Step 2: Attempt to find a pre-existing mapping
bool bFoundMapping = false;
if( m_FoundSourceDirectoryMappings.size() )
{
FileSystemUtils::Path testDir = requestedDirectory;
FileSystemUtils::Path foundDir;
unsigned int depth = 0;
bool bFound = false;
while( testDir.HasParentPath() )
{
TFileMapIterator itrFind = m_FoundSourceDirectoryMappings.find( testDir );
if( itrFind != m_FoundSourceDirectoryMappings.end() )
{
foundDir = itrFind->second;
bFound = true;
break;
}
testDir = testDir.ParentPath();
++depth;
}
if( bFound )
{
if( depth )
{
// not an exact match
FileSystemUtils::Path directory = requestedDirectory;
directory.m_string.replace( 0, testDir.m_string.length(), foundDir.m_string );
if( directory.Exists() )
{
foundFile = directory / filename;
if( foundFile.Exists() )
{
m_FoundSourceDirectoryMappings[ requestedDirectory ] = directory;
if( m_pCompilerLogger ) { m_pCompilerLogger->LogInfo( "Found Directory Mapping: %s to %s\n", requestedDirectory.c_str(), directory.c_str() ); }
bFoundMapping = true;
}
}
}
else
{
// exact match
foundFile = foundDir / filename;
bFoundMapping = true;
}
}
if( !bFoundMapping )
{
// Step 3: Attempt to find a mapping from a known path
TFileList requestedSubPaths;
FileSystemUtils::Path requestedSubPath = requestedDirectory;
while( requestedSubPath.HasParentPath() )
{
requestedSubPaths.push_back( requestedSubPath );
requestedSubPath = requestedSubPath.ParentPath();
}
TFileMapIterator itr = m_FoundSourceDirectoryMappings.begin();
while( ( itr != m_FoundSourceDirectoryMappings.end() ) && !bFoundMapping )
{
FileSystemUtils::Path existingPath = itr->second;
while( ( existingPath.HasParentPath() ) && !bFoundMapping )
{
// check all potentials
for( size_t i=0; i<requestedSubPaths.size(); ++i )
{
FileSystemUtils::Path toCheck = existingPath / requestedSubPaths[i].Filename();
if( toCheck.Exists() )
{
// potential mapping
FileSystemUtils::Path directory = requestedDirectory;
directory.m_string.replace( 0, requestedSubPaths[i].m_string.length(), toCheck.m_string );
if( directory.Exists() )
{
foundFile = directory / filename;
if( foundFile.Exists() )
{
m_FoundSourceDirectoryMappings[ requestedDirectory ] = directory;
if( m_pCompilerLogger ) { m_pCompilerLogger->LogInfo( "Found Directory Mapping: %s to %s\n", requestedDirectory.c_str(), directory.c_str() ); }
bFoundMapping = true;
break;
}
}
}
}
existingPath = existingPath.ParentPath();
}
++itr;
}
}
}
}
if( !foundFile.Exists() )
{
if( m_pCompilerLogger ) { m_pCompilerLogger->LogWarning( "Could not find Directory Mapping for: %s\n", input.c_str() ); }
++m_NumNotFoundSourceFiles;
}
return foundFile;
}
void RuntimeObjectSystem::AddPathToSourceSearch( const char* path )
{
m_FoundSourceDirectoryMappings[ path ] = path;
}
bool RuntimeObjectSystem::TestBuildCallback(const char* file, TestBuildResult type)
{
switch( type )
{
case TESTBUILDRRESULT_SUCCESS: // SUCCESS, yay!
if( m_pCompilerLogger ) { m_pCompilerLogger->LogInfo("TESTBUILDRRESULT_SUCCESS: %s\n", file); }
break;
case TESTBUILDRRESULT_NO_FILES_TO_BUILD: // file registration error or no runtime files of this type
if( m_pCompilerLogger ) { m_pCompilerLogger->LogWarning("TESTBUILDRRESULT_NO_FILES_TO_BUILD\n"); }
break;
case TESTBUILDRRESULT_BUILD_FILE_GONE: // the file is no longer present
if( m_pCompilerLogger ) { m_pCompilerLogger->LogError("TESTBUILDRRESULT_BUILD_FILE_GONE: %s\n", file); }
break;
case TESTBUILDRRESULT_BUILD_NOT_STARTED: // file change detection could be broken, or if an include may not be included anywhere
if( m_pCompilerLogger ) { m_pCompilerLogger->LogError("TESTBUILDRRESULT_BUILD_NOT_STARTED: %s\n", file); }
break;
case TESTBUILDRRESULT_BUILD_FAILED: // a build was started, but it failed or module failed to load. See log.
if( m_pCompilerLogger ) { m_pCompilerLogger->LogError("TESTBUILDRRESULT_BUILD_FAILED: %s\n", file); }
break;
case TESTBUILDRRESULT_OBJECT_SWAP_FAIL: // build succeeded, module loaded but errors on swapping
if( m_pCompilerLogger ) { m_pCompilerLogger->LogError("TESTBUILDRRESULT_OBJECT_SWAP_FAIL: %s\n", file); }
break;
default:
assert(false);
break;
}
return true;
}
// returns 0 on success, -ve number of errors if there is an error and we should quit,
// positive number of errors if there is an error but we should continue
static int TestBuildFile( ICompilerLogger* pLog, RuntimeObjectSystem* pRTObjSys, const Path& file,
ITestBuildNotifier* callback, bool bTestFileTracking )
{
assert( callback );
if( pLog ) { pLog->LogInfo("Testing change to file: %s\n", file.c_str()); }
int numErrors = 0;
if( file.Exists() )
{
if( bTestFileTracking )
{
FileSystemUtils::filetime_t currTime = FileSystemUtils::GetCurrentTime();
FileSystemUtils::filetime_t oldModTime = file.GetLastWriteTime();
if( currTime == oldModTime )
{
// some files may be auto-generated by the program, so may have just been created so won't
// get a time change unless we force it.
currTime += 1;
}
file.SetLastWriteTime( currTime );
// we must also change the directories time, as some of our watchers watch the dir
Path directory = file.ParentPath();
directory.SetLastWriteTime( currTime );
for( int i=0; i<50; ++i )
{
// wait up to 100 seconds (make configurable?)
pRTObjSys->GetFileChangeNotifier()->Update( 1.0f ); // force update by using very large time delta
if( pRTObjSys->GetIsCompiling() ) { break; }
if( !callback->TestBuildWaitAndUpdate() )
{
return -0xD1E;
}
}
}
else
{
AUDynArray<const char*> filelist;
filelist.Add( file.c_str() );
pRTObjSys->OnFileChange( filelist );
}
if( pRTObjSys->GetIsCompiling() )
{
while( !pRTObjSys->GetIsCompiledComplete() )
{
if( !callback->TestBuildWaitAndUpdate() )
{
return -0xD1E;
}
}
int numCurrLoadedModules = pRTObjSys->GetNumberLoadedModules();
if( pRTObjSys->LoadCompiledModule() )
{
if( !callback->TestBuildCallback( file.c_str(), TESTBUILDRRESULT_SUCCESS ) ) { return -0xD1E; }
return 0;
}
else
{
++numErrors;
if( pRTObjSys->GetNumberLoadedModules() == numCurrLoadedModules )
{
if( !callback->TestBuildCallback( file.c_str(), TESTBUILDRRESULT_BUILD_FAILED ) ) { return -numErrors; }
}
else
{
// loaded the module but some other issue
if( !callback->TestBuildCallback( file.c_str(), TESTBUILDRRESULT_OBJECT_SWAP_FAIL ) ) { return -numErrors; }
}
}
}
else
{
++numErrors;
if( !callback->TestBuildCallback( file.c_str(), TESTBUILDRRESULT_BUILD_NOT_STARTED ) ) { return -numErrors; }
}
}
else
{
++numErrors;
if( !callback->TestBuildCallback( file.c_str(), TESTBUILDRRESULT_BUILD_FILE_GONE ) ) { return -numErrors; }
}
return numErrors;
}
// tests one by one touching each runtime modifiable source file
// returns the number of errors - 0 if all passed.
int RuntimeObjectSystem::TestBuildAllRuntimeSourceFiles( ITestBuildNotifier* callback, bool bTestFileTracking )
{
if( m_pCompilerLogger ) { m_pCompilerLogger->LogInfo("TestBuildAllRuntimeSourceFiles Starting\n"); }
ITestBuildNotifier* failCallbackLocal = callback;
if( !failCallbackLocal )
{
failCallbackLocal = this;
}
int numErrors = 0;
size_t numFilesToBuild = 0;
for( unsigned short proj = 0; proj < m_Projects.size( ); ++proj )
{
numFilesToBuild += m_Projects[ proj ].m_RuntimeFileList.size( );
}
if( 0 == numFilesToBuild )
{
failCallbackLocal->TestBuildCallback( NULL, TESTBUILDRRESULT_NO_FILES_TO_BUILD );
}
for( unsigned short proj = 0; proj < m_Projects.size(); ++proj )
{
TFileList filesToTest = m_Projects[ proj ].m_RuntimeFileList; // m_RuntimeFileList could change if file content changes (new includes or source dependencies) so make copy to ensure iterators valid.
for( TFileList::iterator it = filesToTest.begin(); it != filesToTest.end(); ++it )
{
const Path& file = *it;
if( file.Extension() != ".h" ) // exclude headers, use TestBuildAllRuntimeHeaders
{
int fileErrors = TestBuildFile( m_pCompilerLogger, this, file, failCallbackLocal, bTestFileTracking );
if( fileErrors < 0 )
{
// this means exit, and the number of errors is -ve so remove, unless -0xD1E is the response (for no error die)
if( fileErrors != -0xD1E )
{
numErrors -= fileErrors;
}
return numErrors;
}
numErrors += fileErrors;
}
}
}
if( 0 == numErrors )
{
if( m_pCompilerLogger ) { m_pCompilerLogger->LogInfo("All Tests Passed\n"); }
}
else
{
if( m_pCompilerLogger ) { m_pCompilerLogger->LogError("Tests Failed: %d\n", numErrors); }
}
return numErrors;
}
// tests touching each header which has RUNTIME_MODIFIABLE_INCLUDE.
// returns the number of errors - 0 if all passed.
int RuntimeObjectSystem::TestBuildAllRuntimeHeaders( ITestBuildNotifier* callback, bool bTestFileTracking )
{
ITestBuildNotifier* failCallbackLocal = callback;
if( !failCallbackLocal )
{
failCallbackLocal = this;
}
int numErrors = 0;
size_t numFilesToBuild = 0;
for( unsigned short proj = 0; proj < m_Projects.size( ); ++proj )
{
numFilesToBuild += m_Projects[ proj ].m_RuntimeFileList.size( );
}
if( 0 == numFilesToBuild )
{
failCallbackLocal->TestBuildCallback( NULL, TESTBUILDRRESULT_NO_FILES_TO_BUILD );
}
for( unsigned short proj = 0; proj < m_Projects.size(); ++proj )
{
TFileList filesToTest = m_Projects[ proj ].m_RuntimeFileList; // m_RuntimeFileList could change if file content changes (new includes or source dependencies) so make copy to ensure iterators valid.
for( TFileList::iterator it = filesToTest.begin( ); it != filesToTest.end( ); ++it )
{
const Path& file = *it;
if( file.Extension() == ".h" ) // exclude headers, use TestBuildAllRuntimeHeaders
{
int fileErrors = TestBuildFile( m_pCompilerLogger, this, file, failCallbackLocal, bTestFileTracking );
if( fileErrors < 0 )
{
// this means exit, and the number of errors is -ve so remove
return numErrors - fileErrors;
}
numErrors += fileErrors;
}
}
}
if( 0 == numErrors )
{
if( m_pCompilerLogger ) { m_pCompilerLogger->LogInfo("All Tests Passed\n"); }
}
else
{
if( m_pCompilerLogger ) { m_pCompilerLogger->LogError("Tests Failed: %d\n", numErrors); }
}
return numErrors;
}
Reference in New Issue View Git Blame Copy Permalink