void CRenameDlg::OnBnClickedButtonBrowseRef()
{
CString ext;
CString path;
if (!m_originalName.IsEmpty())
{
CTGitPath origname(m_sBaseDir);
origname.AppendPathString(m_originalName);
ext = origname.GetFileExtension();
path = origname.GetWinPathString();
}
if (CAppUtils::FileOpenSave(path, nullptr, AFX_IDD_FILESAVE, 0, false, GetSafeHwnd(), ext.Mid(1), !path.IsEmpty()))
{
GetDlgItem(IDC_NAME)->SetFocus();
CTGitPath target(path);
CString targetRoot;
if (!target.HasAdminDir(&targetRoot) || g_Git.m_CurrentDir.CompareNoCase(targetRoot) != 0)
{
CMessageBox::Show(GetSafeHwnd(), IDS_ERR_MUSTBESAMEWT, IDS_APPNAME, MB_OK | MB_ICONEXCLAMATION);
return;
}
CString relPath;
m_sBaseDir.Replace(L"/", L"\\");
if (!PathRelativePathTo(CStrBuf(relPath, MAX_PATH), m_sBaseDir, FILE_ATTRIBUTE_DIRECTORY, path, FILE_ATTRIBUTE_DIRECTORY))
return;
if (CStringUtils::StartsWith(relPath, L".\\"))
relPath = relPath.Mid(2);
m_name = relPath;
UpdateData(FALSE);
}
}
//***********************************************************************************************
CParticleWorkspace::CNode *CParticleWorkspace::addNode(const std::string &filenameWithFullPath) throw( NLMISC::EStream)
{
nlassert(_OV);
// Check that file is not already inserted
std::string fileName = NLMISC::CFile::getFilename(filenameWithFullPath);
for(uint k = 0; k < _Nodes.size(); ++k)
{
if (NLMISC::nlstricmp(_Nodes[k]->getFilename(), fileName) == 0) return NULL;
}
char resultPath[MAX_PATH];
std::string dosPath = NLMISC::CPath::standardizeDosPath(getPath());
std::string relativePath;
if (!PathRelativePathTo(resultPath, dosPath.c_str(), FILE_ATTRIBUTE_DIRECTORY, filenameWithFullPath.c_str(), 0))
{
relativePath = filenameWithFullPath;
}
else
{
relativePath = resultPath;
}
if (relativePath.size() >= 2)
{
if (relativePath[0] == '\\' && relativePath[1] != '\\')
{
relativePath = relativePath.substr(1);
}
}
CNode *newNode = new CNode;
newNode->init(this);
newNode->setRelativePath(relativePath);
_Nodes.push_back(newNode);
setModifiedFlag(true);
return newNode;
}
CString CPath::ConvertFullToRelativePath(CString sFullPath)
{
// Declare variables
CString sRelativePath, sBuffer;
DWORD dwPathType;
// Check if path is pointing to file or folder
if (PathIsDirectory(sFullPath))
{
dwPathType = FILE_ATTRIBUTE_DIRECTORY;
}
else
{
dwPathType = FILE_ATTRIBUTE_NORMAL;
}
// Convert
PathRelativePathTo(sBuffer.GetBuffer(_MAX_PATH), GetPathUpdater(), FILE_ATTRIBUTE_DIRECTORY,
sFullPath, dwPathType);
// Get value of buffer
sRelativePath = sBuffer.GetBuffer(sBuffer.GetLength());
sBuffer.ReleaseBuffer();
// Return result
return sRelativePath;
}
CFileName CFileName::Relative(LPCTSTR compare,LPCTSTR current)
{
CString rc;
bool b=(TRUE==PathRelativePathTo(rc.GetBuffer(1+MAX_PATH),current,FILE_ATTRIBUTE_DIRECTORY,compare,0));
rc.ReleaseBuffer();
//TRACE(_T("compare=%s current=%s result=%s (b=%d)\n"),compare,current,b?rc:compare,b);
return b?rc:compare;
}
unsigned int skipper::directoryCheck(const std::wstring& directory)
{
wchar_t relPath[MAX_PATH];
if (!PathRelativePathTo(relPath, _toSkip.c_str(), FILE_ATTRIBUTE_DIRECTORY, directory.c_str(), FILE_ATTRIBUTE_DIRECTORY))
return DIRECTORY_DONTCARE;
if (relPath[0] == L'.' && relPath[1] == NULL)
return DIRECTORY_EXCLUDE;
return DIRECTORY_DONTCARE;
}
// Format a filename for saving
CString CTinyCadDoc::formatXMLFilename( const TCHAR *filename )
{
TCHAR out[ MAX_PATH ];
if (PathRelativePathTo( out, m_pParent->GetXMLPathName(), 0, filename, 0 ))
{
return out;
}
else
{
return filename;
}
}
std::wstring CFileInfo::ConvertRelativePath(const wstring& szFullPath)
{
TCHAR szRelativePath[MAX_PATH] = L"";
TCHAR szDirtoryPath[MAX_PATH] = L"";
GetCurrentDirectory(sizeof(szDirtoryPath), szDirtoryPath);
PathRelativePathTo((LPWSTR)szRelativePath
, szDirtoryPath
, FILE_ATTRIBUTE_DIRECTORY
, szFullPath.c_str()
, FILE_ATTRIBUTE_NORMAL);
return szRelativePath;
}
CFilePath CFilePath::RelativePathTo(
LPCTSTR psPathTo,
BOOL bSrcIsDir)
{
CString sPath;
if (!psPathTo)
return CFilePath();
int nMaxLen = 3 * msPath.GetLength() / 2 + 1 + _tcslen(psPathTo);
PathRelativePathTo(CStringLock(sPath, nMaxLen), msPath, bSrcIsDir ? FILE_ATTRIBUTE_DIRECTORY : 0, psPathTo, 0);
return CFilePath(sPath, 0);
}
/*
010509 Carl Corcoran
*/
void CCString::Path_AbsoluteToRelative(PCWSTR wszNewRoot)
{
WCHAR wszNewString[MAX_PATH];
WCHAR wszCanonString[MAX_PATH];
PathRelativePathTo(wszNewString,
wszNewRoot, FILE_ATTRIBUTE_DIRECTORY,
this->wszString, FILE_ATTRIBUTE_NORMAL
);
PathCanonicalize(wszCanonString, wszNewString);
this->cpy(wszCanonString);
return;
}
WString FilePath::GetRelativePathFor(const FilePath& _filePath)
{
if (_fullPath.Length()==0 || _filePath._fullPath.Length()==0 || _fullPath[0] != _filePath._fullPath[0])
{
return _filePath._fullPath;
}
wchar_t buffer[MAX_PATH + 1] = { 0 };
PathRelativePathTo(
buffer,
_fullPath.Buffer(),
(IsFolder() ? FILE_ATTRIBUTE_DIRECTORY : 0),
_filePath._fullPath.Buffer(),
(_filePath.IsFolder() ? FILE_ATTRIBUTE_DIRECTORY : 0)
);
return buffer;
}
WString FilePath::GetRelativePathFor(const FilePath& _filePath)
{
if (fullPath.Length()==0 || _filePath.fullPath.Length()==0 || fullPath[0] != _filePath.fullPath[0])
{
return _filePath.fullPath;
}
#if defined VCZH_MSVC
wchar_t buffer[MAX_PATH + 1] = { 0 };
PathRelativePathTo(
buffer,
fullPath.Buffer(),
(IsFolder() ? FILE_ATTRIBUTE_DIRECTORY : 0),
_filePath.fullPath.Buffer(),
(_filePath.IsFolder() ? FILE_ATTRIBUTE_DIRECTORY : 0)
);
return buffer;
#elif defined VCZH_GCC
collections::List<WString> srcComponents, tgtComponents, resultComponents;
GetPathComponents(IsFolder() ? fullPath : GetFolder().GetFullPath(), srcComponents);
GetPathComponents(_filePath.fullPath, tgtComponents);
int minLength = srcComponents.Count() <= tgtComponents.Count() ? srcComponents.Count() : tgtComponents.Count();
int lastCommonComponent = 0;
for(int i = 0; i < minLength; i++)
{
if(srcComponents[i] == tgtComponents[i])
{
lastCommonComponent = i;
}
else
break;
}
for(int i = lastCommonComponent + 1; i < srcComponents.Count(); i++)
{
resultComponents.Add(L"..");
}
for(int i = lastCommonComponent + 1; i < tgtComponents.Count(); i++)
{
resultComponents.Add(tgtComponents[i]);
}
return ComponentsToPath(resultComponents);
#endif
}
CString CPathFinder::GetRelativePath(LPCTSTR szBaseFolder)
{
if (IsRelativePath()) return (LPCTSTR)sCEmptyString;
TCHAR szRelativePath[_MAX_PATH];
CString sRelPath;
PathRelativePathTo(szRelativePath, szBaseFolder, FILE_ATTRIBUTE_DIRECTORY,
GetPath(), IsFilePath() ? 0 : FILE_ATTRIBUTE_DIRECTORY);
sRelPath = szRelativePath;
if (sRelPath.GetLength() > 1)
{
// Remove ".\" from the beginning
if ((sRelPath[0] == '.') && (sRelPath[1] == '\\'))
sRelPath.Right(sRelPath.GetLength() - 2);
}
return sRelPath;
}
static path relative_to(const path &from, const path &to, bool fromdir=true) {
if(PathIsSameRoot(from.buf, to.buf)) {
path p;
if(!PathRelativePathTo(p.buf, from.buf, fromdir?FILE_ATTRIBUTE_DIRECTORY:0, to.buf, 0))
{
TCHAR chBuf[1024];
swprintf_s(chBuf, _countof(chBuf), L"PathRelativePathTo() from:[%s] to:[%s] failed!!", from.buf, to.buf);
TRACEERR("[path] [relative_to]", chBuf, GetLastError());
throw path_error("PathRelativePathTo");
}
return p;
}
else if(to.has_root()) return to;
else
{
TRACEE("[path] [relative_to] * ERROR: unable to create relative path: paths have different roots!!");
throw std::runtime_error("unable to create relative path: paths have different roots");
}
}
std::string OpenFile(HWindow hwnd, char* filter){
char masterDir[512];
GetCurrentDirectory(512, masterDir);
static std::string sLastDir = masterDir;
char szFile[260];
OPENFILENAME ofn;
ZeroMemory(&ofn, sizeof(ofn));
ofn.lStructSize = sizeof(ofn);
ofn.hwndOwner = (HWND)hwnd;
ofn.lpstrFile = szFile;
// Set lpstrFile[0] to '\0' so that GetOpenFileName does not
// use the contents of szFile to initialize itself.
ofn.lpstrFile[0] = '\0';
ofn.nMaxFile = sizeof(szFile);
ofn.lpstrFilter = filter; // "All\0*.*\0Text\0*.TXT\0\0";
ofn.nFilterIndex = 1;
ofn.lpstrFileTitle = NULL;
ofn.nMaxFileTitle = 0;
ofn.lpstrInitialDir = sLastDir.c_str();
ofn.Flags = OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST;
if (GetOpenFileName(&ofn)){
char newDirectory[512];
GetCurrentDirectory(512, newDirectory);
sLastDir = newDirectory;
SetCurrentDirectory(masterDir);
char relative[512];
PathRelativePathTo(relative, masterDir, FILE_ATTRIBUTE_DIRECTORY, szFile, FILE_ATTRIBUTE_NORMAL);
return std::string(relative);
}
char newDirectory[512];
GetCurrentDirectory(512, newDirectory);
sLastDir = newDirectory;
SetCurrentDirectory(masterDir);
return std::string();
}
VOID AddFileFromFileDialog(HWND hWnd)
{
TCHAR FileName[MAX_PATH], RelPath[MAX_PATH], CurrentWorkingDir[MAX_PATH];
TCHAR Command[2*MAX_PATH];
GetCurrentDirectory(MAX_PATH,CurrentWorkingDir);
if (ShowOpenFileDialog(hWnd, FileName)) {
AddMruFile(FileName);
PathRelativePathTo(RelPath,
CurrentWorkingDir,
FILE_ATTRIBUTE_DIRECTORY,
FileName,
FILE_ATTRIBUTE_NORMAL);
wsprintf(Command, TEXT(":add %s"), ExpandFileName(RelPath));
FireCommand(Command);
}
SetCurrentDirectory(CurrentWorkingDir);
}
void CObjectTool::OnStaticMeshLoad()
{
// TODO: 여기에 컨트롤 알림 처리기 코드를 추가합니다.
HRESULT hr = NULL;
CFileFind finder, texfinder;
BOOL bWorking = false;
BOOL bTexWorking = false;
wofstream SaveFile, SaveTex;
bWorking = finder.FindFile(_T("..//Resource/Mesh/*.*"));
bTexWorking = texfinder.FindFile(_T("..//Resource/MeshImage/*.png"));
SaveFile.open(L"..//Resource/MeshPath.txt", ios::out);
SaveTex.open(L"..//Resource/MeshTexPath.txt", ios::out);
GetDlgItem(IDC_BUTTON3)->EnableWindow(FALSE);
while (bTexWorking)
{
bTexWorking = texfinder.FindNextFileW();
if (!texfinder.IsDirectory() && !texfinder.IsDots())
{
CString TexturePath = texfinder.GetFilePath();//경로
CString TextureKey = texfinder.GetFileName();//키값
TCHAR* tcFilePath = new TCHAR[128];
wsprintf(tcFilePath, TexturePath);
TCHAR* tcFileKey = new TCHAR[128];
wsprintf(tcFileKey, TextureKey);
if (m_bFirstLoad == false)
{
vecTexKey.push_back(tcFileKey);
vecTexPath.push_back(tcFilePath);
}
}
}
if (m_bFirstLoad == false)
{
vector<TCHAR*>::iterator Pathiter = vecTexPath.begin();
vector<TCHAR*>::iterator Keyiter = vecTexKey.begin();
vector<TCHAR*>::iterator Pathiter_End = vecTexPath.end();
vector<TCHAR*>::iterator Keyiter_End = vecTexKey.end();
bool bEndofVector = false;
while (!bEndofVector)
{
if (FAILED(CResourcesMgr::GetInstance()->AddTexture(
RESOURCE_STAGE
, (*Keyiter)
, (*Pathiter))))
{
MessageBox(L"Texture Load Failed", *Keyiter);
}
TCHAR szPath[MAX_PATH] = L"";
TCHAR szDirPath[MAX_PATH] = L"";
GetCurrentDirectory(sizeof(szDirPath), szDirPath);
PathRelativePathTo((LPWSTR)szPath,
szDirPath, FILE_ATTRIBUTE_DIRECTORY,
*Pathiter, FILE_ATTRIBUTE_NORMAL);
SaveTex << (*Keyiter) << L"|";
SaveTex << szPath << endl;
++Keyiter;
++Pathiter;
if (Keyiter == Keyiter_End && Pathiter == Pathiter_End)
{
bEndofVector = true;
}
}
bEndofVector = false;
while (!bEndofVector)
{
vecTexKey.pop_back();
vecTexPath.pop_back();
if (vecTexKey.size() == 0 && vecTexPath.size() == 0)
{
bEndofVector = true;
vecTexKey.clear();
vecTexPath.clear();
break;
}
}
}
while (bWorking)
{
bWorking = finder.FindNextFileW();
if (finder.IsDirectory() && finder.IsDots())
continue;
else
{
CString FilePath = finder.GetFilePath();//경로
PathRemoveFileSpec((LPWSTR)(LPCTSTR)FilePath);//파일 이름을 날린다
CString FileKey = finder.GetFileName();//컴포넌트 키값
PathRemoveExtension((LPWSTR)(LPCTSTR)FileKey);//확장자 날린다
CString FileName = finder.GetFileName();//fbx파일
TCHAR* tcFilePath = new TCHAR[128];
wsprintf(tcFilePath, FilePath);
_tcscat(tcFilePath, _T("\\"));
TCHAR* tcFileKey = new TCHAR[128];
wsprintf(tcFileKey, FileKey);
TCHAR* tcFileName = new TCHAR[128];
wsprintf(tcFileName, FileName);
if (m_bFirstLoad == false)
{
vecFileKey.push_back(tcFileKey);
vecFilename.push_back(tcFileName);
vecFilePath.push_back(tcFilePath);
}
m_StaticList.AddString((LPWSTR)(LPCTSTR)FileKey);
}
}
if (m_bFirstLoad == false)
{
vector<TCHAR*>::iterator Pathiter = vecFilePath.begin();
vector<TCHAR*>::iterator Nameiter = vecFilename.begin();
vector<TCHAR*>::iterator Keyiter = vecFileKey.begin();
vector<TCHAR*>::iterator Pathiter_End = vecFilePath.end();
vector<TCHAR*>::iterator Nameiter_End = vecFilename.end();
vector<TCHAR*>::iterator Keyiter_End = vecFileKey.end();
bool bEndofVector = false;
while (!bEndofVector)
{
int len = 128;
char cPath[128];
char cName[128];
WideCharToMultiByte(CP_ACP, 0, (*Pathiter), len, cPath, len, NULL, NULL);
WideCharToMultiByte(CP_ACP, 0, (*Nameiter), len, cName, len, NULL, NULL);
if (FAILED(CResourcesMgr::GetInstance()->AddMesh(
RESOURCE_STAGE,
MESH_STATIC
, (*Keyiter)
, "..\\Resource\\Mesh\\"
, cName)))
{
MessageBox(L"Mesh Load Failed Or Aready Exist Mesh", *Nameiter);
}
TCHAR szPath[MAX_PATH] = L"";
TCHAR szDirPath[MAX_PATH] = L"";
GetCurrentDirectory(sizeof(szDirPath), szDirPath);
PathRelativePathTo((LPWSTR)szPath,
szDirPath, FILE_ATTRIBUTE_DIRECTORY,
*Pathiter, FILE_ATTRIBUTE_NORMAL);
SaveFile << (*Keyiter) << L"|";
SaveFile << szPath << L"|";
SaveFile << (*Nameiter) << endl;
++Keyiter;
++Pathiter;
++Nameiter;
if (Keyiter == Keyiter_End && Pathiter == Pathiter_End && Nameiter == Nameiter_End)
{
bEndofVector = true;
}
}
bEndofVector = false;
while (!bEndofVector)
{
vecFileKey.pop_back();
vecFilename.pop_back();
vecFilePath.pop_back();
if (vecFileKey.size() == 0 && vecFilePath.size() == 0 && vecFilename.size() == 0)
{
bEndofVector = true;
vecFileKey.clear();
vecFilename.clear();
vecFilePath.clear();
break;
}
}
m_bFirstLoad = true;
}
SaveTex.close();
SaveFile.close();
}
nfsstat3 CNFS3Prog::ProcedureREADLINK(void)
{
PrintLog("READLINK");
char *path;
char *pMBBuffer = 0;
post_op_attr symlink_attributes;
nfspath3 data = nfspath3();
//opaque data;
nfsstat3 stat;
HANDLE hFile;
REPARSE_DATA_BUFFER *lpOutBuffer;
lpOutBuffer = (REPARSE_DATA_BUFFER*)malloc(MAXIMUM_REPARSE_DATA_BUFFER_SIZE);
DWORD bytesReturned;
path = GetPath();
stat = CheckFile(path);
if (stat == NFS3_OK) {
hFile = CreateFile(path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_REPARSE_POINT | FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_BACKUP_SEMANTICS, NULL);
if (hFile == INVALID_HANDLE_VALUE) {
stat = NFS3ERR_IO;
}
else
{
lpOutBuffer = (REPARSE_DATA_BUFFER*)malloc(MAXIMUM_REPARSE_DATA_BUFFER_SIZE);
if (!lpOutBuffer) {
stat = NFS3ERR_IO;
}
else {
DeviceIoControl(hFile, FSCTL_GET_REPARSE_POINT, NULL, 0, lpOutBuffer, MAXIMUM_REPARSE_DATA_BUFFER_SIZE, &bytesReturned, NULL);
if (lpOutBuffer->ReparseTag == IO_REPARSE_TAG_SYMLINK || lpOutBuffer->ReparseTag == IO_REPARSE_TAG_MOUNT_POINT)
{
if (lpOutBuffer->ReparseTag == IO_REPARSE_TAG_SYMLINK)
{
size_t plen = lpOutBuffer->SymbolicLinkReparseBuffer.PrintNameLength / sizeof(WCHAR);
pMBBuffer = (char *)malloc((plen + 1));
WCHAR *szPrintName = new WCHAR[plen + 1];
wcsncpy_s(szPrintName, plen + 1, &lpOutBuffer->SymbolicLinkReparseBuffer.PathBuffer[lpOutBuffer->SymbolicLinkReparseBuffer.PrintNameOffset / sizeof(WCHAR)], plen);
szPrintName[plen] = 0;
size_t i;
wcstombs_s(&i, pMBBuffer, (plen + 1), szPrintName, (plen + 1));
// TODO: Revisit with cleaner solution
if (!PathIsRelative(pMBBuffer))
{
std::string strFromChar;
strFromChar.append("\\\\?\\");
strFromChar.append(pMBBuffer);
char *target = _strdup(strFromChar.c_str());
// remove last folder
char *pos = strrchr(path, '\\');
if (pos != NULL) {
*pos = '\0';
}
PathRelativePathTo(pMBBuffer, path, FILE_ATTRIBUTE_DIRECTORY, target, FILE_ATTRIBUTE_DIRECTORY);
}
}
// TODO: Revisit with cleaner solution
if (lpOutBuffer->ReparseTag == IO_REPARSE_TAG_MOUNT_POINT)
{
size_t slen = lpOutBuffer->MountPointReparseBuffer.SubstituteNameLength / sizeof(WCHAR);
pMBBuffer = (char *)malloc((slen + 1));
WCHAR *szSubName = new WCHAR[slen + 1];
wcsncpy_s(szSubName, slen + 1, &lpOutBuffer->MountPointReparseBuffer.PathBuffer[lpOutBuffer->MountPointReparseBuffer.SubstituteNameOffset / sizeof(WCHAR)], slen);
szSubName[slen] = 0;
std::wstring wStringTemp(szSubName);
std::string target(wStringTemp.begin(), wStringTemp.end());
target.erase(0, 2);
target.insert(0, 2, '\\');
// remove last folder, see above
char *pos = strrchr(path, '\\');
if (pos != NULL) {
*pos = '\0';
}
PathRelativePathTo(pMBBuffer, path, FILE_ATTRIBUTE_DIRECTORY, target.c_str(), FILE_ATTRIBUTE_DIRECTORY);
}
// write path always with / separator, so windows created symlinks work too
std::string strFromChar;
strFromChar.append(pMBBuffer);
std::replace(strFromChar.begin(), strFromChar.end(), '\\', '/');
char *result = _strdup(strFromChar.c_str());
data.Set(result);
free(pMBBuffer);
free(result);
}
free(lpOutBuffer);
}
}
CloseHandle(hFile);
}
symlink_attributes.attributes_follow = GetFileAttributesForNFS(path, &symlink_attributes.attributes);
Write(&stat);
Write(&symlink_attributes);
if (stat == NFS3_OK) {
Write(&data);
}
return stat;
}
/**
* Upload locally built symbols to network symbol storage.
*
* Use case:
* Game designers use game from source (without prebuild game .dll-files).
* In this case all game .dll-files are compiled locally.
* For post-mortem debug programmers need .dll and .pdb files from designers.
*/
bool FWindowsPlatformStackWalk::UploadLocalSymbols()
{
InitStackWalking();
#if WINVER > 0x502
// Upload locally compiled files to symbol storage.
FString SymbolStorage;
if (!GConfig->GetString( CrashReporterSettings, TEXT( "UploadSymbolsPath" ), SymbolStorage, GEditorPerProjectIni ) || SymbolStorage.IsEmpty())
{
// Nothing to do.
return true;
}
// Prepare string
SymbolStorage.ReplaceInline( TEXT( "/" ), TEXT( "\\" ), ESearchCase::CaseSensitive );
SymbolStorage = TEXT( "SRV*" ) + SymbolStorage;
int32 ErrorCode = 0;
HANDLE ProcessHandle = GetCurrentProcess();
// Enumerate process modules.
HMODULE* ModuleHandlePointer = GetProcessModules( ProcessHandle );
if (!ModuleHandlePointer)
{
ErrorCode = GetLastError();
return false;
}
#if WITH_EDITOR
// Get Unreal Engine Editor directory for detecting non-game editor binaries.
FString EnginePath = FPaths::ConvertRelativePathToFull( FPaths::EngineDir() );
FPaths::MakePlatformFilename( EnginePath );
#endif
// Upload all locally built modules.
for (int32 ModuleIndex = 0; ModuleHandlePointer[ModuleIndex]; ModuleIndex++)
{
WCHAR ImageName[MAX_PATH] = {0};
FGetModuleFileNameEx( ProcessHandle, ModuleHandlePointer[ModuleIndex], ImageName, MAX_PATH );
#if WITH_EDITOR
WCHAR RelativePath[MAX_PATH];
// Skip binaries inside Unreal Engine Editor directory (non-game editor binaries)
if (PathRelativePathTo( RelativePath, *EnginePath, FILE_ATTRIBUTE_DIRECTORY, ImageName, 0 ) && FCString::Strncmp( RelativePath, TEXT( "..\\" ), 3 ))
{
continue;
}
#endif
WCHAR DebugName[MAX_PATH];
FCString::Strcpy( DebugName, ImageName );
if (PathRenameExtensionW( DebugName, L".pdb" ))
{
// Upload only if found .pdb file
if (PathFileExistsW( DebugName ))
{
// Upload original file
UE_LOG( LogWindows, Log, TEXT( "Uploading to symbol storage: %s" ), ImageName );
if (!SymSrvStoreFileW( ProcessHandle, *SymbolStorage, ImageName, SYMSTOREOPT_PASS_IF_EXISTS ))
{
UE_LOG( LogWindows, Warning, TEXT( "Uploading to symbol storage failed: %s. Error: %d" ), ImageName, GetLastError() );
}
// Upload debug symbols
UE_LOG( LogWindows, Log, TEXT( "Uploading to symbol storage: %s" ), DebugName );
if (!SymSrvStoreFileW( ProcessHandle, *SymbolStorage, DebugName, SYMSTOREOPT_PASS_IF_EXISTS ))
{
UE_LOG( LogWindows, Warning, TEXT( "Uploading to symbol storage failed: %s. Error: %d" ), DebugName, GetLastError() );
}
}
}
}
#else
UE_LOG( LogWindows, Log, TEXT( "Symbol server not supported on Windows XP." ) );
#endif
return true;
}