C++ PathRemoveFileSpec函数代码示例

int main(int argc, char** argv) {

	char szPath[MAX_PATH];

	for (int i = 1; i < argc; i++) {

		PathRemoveFileSpec(lstrcpy(szPath, argv[i]));

		WIN32_FIND_DATA findData;
		HANDLE hFind = FindFirstFile(argv[i], &findData);
		if (hFind != INVALID_HANDLE_VALUE) {
			do {
				char szFile[MAX_PATH];

				PathAppend(lstrcpy(szFile, szPath), findData.cFileName);

				printf("%s\n", szFile);

				wc_info wci;

				FILE* fp = fopen(szFile, "r");
				if (fp) {
					ZeroMemory(&wci, sizeof(wci));

					wci.m_size = _filelength(fileno(fp));
					wci.m_p = malloc(wci.m_size);
					fread(wci.m_p, sizeof(char), wci.m_size, fp);
					fclose(fp);

					wc(wci);

					printf("バイト数: %u\n", wci.m_count_byte);
					printf("  文字数: %u\n", wci.m_count_char);

					free(wci.m_p);
				}
			} while (FindNextFile(hFind, &findData));

			FindClose(hFind);
		}
	}

	_getch();

	return 0;
}

bool ConfigurationHolder::buildConfigFilePath(const WCHAR* fileName)
{
	ZeroMemory(configPath, sizeof(configPath));

	if (!GetModuleFileName(0, configPath, _countof(configPath)))
	{
#ifdef DEBUG_COMMENTS
		Scylla::debugLog.log(L"buildConfigFilePath :: GetModuleFileName failed %d", GetLastError());
#endif
		return false;
	}

	PathRemoveFileSpec(configPath);
	PathAppend(configPath, fileName);

	return true;
}

int wmain( int argc, const wchar_t *argv[] )
{
#ifndef BUILD_SETUP
	if(argc==2)
	{
		if(wcscmp(L"-install",argv[1])==0)
			InstallService();
		else if (wcscmp(L"-uninstall",argv[1])==0)
			UninstallService();
		return 0;
	}
#endif
	SERVICE_TABLE_ENTRY DispatchTable[]={
		{(wchar_t*)g_ServiceName, ServiceMain},
		{NULL, NULL}
	};
	HKEY hKey;
	if (RegOpenKeyEx(HKEY_LOCAL_MACHINE,L"SOFTWARE\\IvoSoft\\ClassicShell",0,KEY_READ|KEY_WOW64_64KEY,&hKey)==ERROR_SUCCESS)
	{
		DWORD log;
		DWORD size=sizeof(log);
		if (RegQueryValueEx(hKey,L"LogService",0,NULL,(BYTE*)&log,&size)==ERROR_SUCCESS && log)
		{
			GetModuleFileName(NULL,g_LogName,_countof(g_LogName));
			PathRemoveFileSpec(g_LogName);
			PathAppend(g_LogName,L"service.log");
			LogText("Starting service\n");
		}

		DWORD dump;
		size=sizeof(dump);

		if (RegQueryValueEx(hKey,L"CrashDump",0,NULL,(BYTE*)&dump,&size)==ERROR_SUCCESS && dump>0)
		{
			if (dump==1) MiniDumpType=MiniDumpNormal;
			if (dump==2) MiniDumpType=MiniDumpWithDataSegs;
			if (dump==3) MiniDumpType=MiniDumpWithFullMemory;
			SetUnhandledExceptionFilter(TopLevelFilter);
		}
		RegCloseKey(hKey);
	}

	StartServiceCtrlDispatcher(DispatchTable);
	return 0;
}

// determine the directory for a given pathname
// (wstring only for now; feel free to make this a template if needed)
/*static*/ wstring File::DirectoryPathOf(wstring path)
{
#ifdef _WIN32
    // Win32 accepts forward slashes, but it seems that PathRemoveFileSpec() does not
    // TODO:
    // "PathCchCanonicalize does the / to \ conversion as a part of the canonicalization, it's
    // probably a good idea to do that anyway since I suspect that the '..' characters might
    // confuse the other PathCch functions" [Larry Osterman]
    // "Consider GetFullPathName both for canonicalization and last element finding." [Jay Krell]
    path = msra::strfun::ReplaceAll<wstring>(path, L"/", L"\\");

    HRESULT hr;
    if (IsWindows8OrGreater()) // PathCchRemoveFileSpec() only available on Windows 8+
    {
        typedef HRESULT(*PathCchRemoveFileSpecProc)(_Inout_updates_(_Inexpressible_(cchPath)) PWSTR, _In_ size_t);
        HINSTANCE hinstLib = LoadLibrary(TEXT("api-ms-win-core-path-l1-1-0.dll"));
        if (hinstLib == nullptr)
            RuntimeError("DirectoryPathOf: LoadLibrary() unexpectedly failed.");
        PathCchRemoveFileSpecProc PathCchRemoveFileSpec = reinterpret_cast<PathCchRemoveFileSpecProc>(GetProcAddress(hinstLib, "PathCchRemoveFileSpec"));
        if (!PathCchRemoveFileSpec)
            RuntimeError("DirectoryPathOf: GetProcAddress() unexpectedly failed.");

        // this is the actual function call we care about
        hr = PathCchRemoveFileSpec(&path[0], path.size());

        FreeLibrary(hinstLib);
    }
    else // on Windows 7-, use older PathRemoveFileSpec() instead
        hr = PathRemoveFileSpec(&path[0]) ? S_OK : S_FALSE;

    if (hr == S_OK) // done
        path.resize(wcslen(&path[0]));
    else if (hr == S_FALSE) // nothing to remove: use .
        path = L".";
    else
        RuntimeError("DirectoryPathOf: Path(Cch)RemoveFileSpec() unexpectedly failed with 0x%08x.", (unsigned int)hr);
#else
    auto pos = path.find_last_of(L"/");
    if (pos != path.npos)
        path.erase(pos);
    else // if no directory path at all, use current directory
        return L".";
#endif
    return path;
}

static BOOL find_portable_dir(LPCWSTR base, LPWSTR *result, BOOL *existing) {
    WCHAR buf[4*MAX_PATH] = {0};

    _snwprintf_s(buf, 4*MAX_PATH, _TRUNCATE, L"%s\\calibre-portable.exe", base);
    *existing = true;

    if (file_exists(buf)) {
        *result = _wcsdup(base);
        if (*result == NULL) { show_error(L"Out of memory"); return false; }
        return true;
    }

    WIN32_FIND_DATA fdFile; 
    HANDLE hFind = NULL;
    _snwprintf_s(buf, 4*MAX_PATH, _TRUNCATE, L"%s\\*", base);

    if((hFind = FindFirstFileEx(buf, FindExInfoStandard, &fdFile, FindExSearchLimitToDirectories, NULL, 0)) != INVALID_HANDLE_VALUE) {
        do {
            if(is_dots(fdFile.cFileName)) continue;

            if(fdFile.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
                _snwprintf_s(buf, 4*MAX_PATH, _TRUNCATE, L"%s\\%s\\calibre-portable.exe", base, fdFile.cFileName);
                if (file_exists(buf)) {
                    *result = _wcsdup(buf);
                    if (*result == NULL) { show_error(L"Out of memory"); return false; }
                    PathRemoveFileSpec(*result);
                    FindClose(hFind);
                    return true;
                }
            } 
        } while(FindNextFile(hFind, &fdFile));
        FindClose(hFind);
    }

    *existing = false;
    _snwprintf_s(buf, 4*MAX_PATH, _TRUNCATE, L"%s\\Calibre Portable", base);
    if (!CreateDirectory(buf, NULL) && GetLastError() != ERROR_ALREADY_EXISTS) {
        show_last_error(L"Failed to create Calibre Portable folder");
        return false;
    }
    *result = _wcsdup(buf);
    if (*result == NULL) { show_error(L"Out of memory"); return false; }

    return true;
}

void CMainFrame::OnCmdRun()
{
	CDocument *pDoc = GetActiveFrame()->GetActiveDocument();
	pDoc->DoFileSave();

	CString strApp = theApp.CombinePath( theApp.GetPath(), theApp.m_strCompilerApp );
	SetEnvironmentVariable( _T("NEWPAS"), '"' + strApp + '"' );

	CString strArgs;
	// using an environ. var. because cmd /C doesn't support more than 1 quoted path
	strArgs.Format( _T("/C %%NEWPAS%% \"%s\" execvm & pause"), (LPCTSTR)pDoc->GetPathName() );

	TCHAR szFolder[MAX_PATH];
	_tcscpy_s( szFolder, MAX_PATH, pDoc->GetPathName() );
	PathRemoveFileSpec( szFolder );

	::ShellExecute( 0, _T("open"), _T("cmd"), strArgs, szFolder, SW_SHOW );
}

bool TexCubeWnd::OnEnvCreate()
{
	if(!m_xCube.Create(this))
	{
		return false;
	}

	D3DLIGHT9 lgt;
	ZeroMemory(&lgt, sizeof(lgt));
	lgt.Type = D3DLIGHT_DIRECTIONAL;
	lgt.Ambient   = D3DXCOLOR(0.8f, 0.8f, 0.8f, 1.0f);
	lgt.Diffuse   = D3DXCOLOR(1.0f, 1.0f, 1.0f, 1.0f);
	lgt.Specular  = D3DXCOLOR(0.2f, 0.2f, 0.2f, 1.0f);
	lgt.Direction = D3DXVECTOR3(1.0f, -1.0f, 0.0f);
	m_pD3Dev9->SetLight(0, &lgt);
	m_pD3Dev9->LightEnable(0, TRUE);

	m_pD3Dev9->SetRenderState(D3DRS_NORMALIZENORMALS, TRUE);
	m_pD3Dev9->SetRenderState(D3DRS_SPECULARENABLE, TRUE);

	char szTexturePath[MAX_PATH] = {0};
	GetModuleFileName(NULL, szTexturePath, sizeof(szTexturePath));
	PathRemoveFileSpec(szTexturePath);
	strcat(szTexturePath, "\\res\\p2c6_tex01.jpg");

	if(!PathFileExists(szTexturePath))
	{
		MessageBox(NULL, "Cannot load texture...", "Error", MB_ICONERROR | MB_OK);
		return false;
	}

	HRESULT hr = D3DXCreateTextureFromFile(m_pD3Dev9, szTexturePath, &m_pTex);
	if(D3D_OK != hr ||
		NULL == m_pTex)
	{
		return false;
	}

	D3DXVECTOR3 pos(0.0f, 0.0f, -4.0f);
	Gfx_SetViewTransform(&pos);
	Gfx_SetProjectionTransform();

	return true;
}

co_rc_t co_winnt_load_driver_lowlevel_by_name(char *name, char *path) 
{ 
	SC_HANDLE   schSCManager; 
	char fullpath[0x100] = {0,};
	char driverfullpath[0x100] = {0,};
	co_rc_t rc;

	GetModuleFileName(co_current_win32_instance, fullpath, sizeof(fullpath));
	PathRemoveFileSpec(fullpath);
	PathCombine(driverfullpath, fullpath, path);

	co_terminal_print("loading %s\n", driverfullpath);

	schSCManager = OpenSCManager(NULL,                 // machine (NULL == local) 
				     NULL,                 // database (NULL == default) 
				     SC_MANAGER_ALL_ACCESS /* access required */ );

	rc = co_winnt_install_driver_lowlevel(schSCManager, name, driverfullpath);
	if (!CO_OK(rc)) {
		CloseServiceHandle(schSCManager);    
		return rc;
	}

	rc = co_winnt_start_driver_lowlevel(schSCManager, name); 
	if (!CO_OK(rc)) {
		co_winnt_remove_driver_lowlevel(schSCManager, name); 
		CloseServiceHandle(schSCManager);    
		return rc;
	}

#if (0)
	rc = co_os_check_device(name); 
	if (!CO_OK(rc)) {
		co_winnt_stop_driver_lowlevel(schSCManager, name);  
		co_winnt_remove_driver_lowlevel(schSCManager, name); 
		CloseServiceHandle(schSCManager);    
		return rc;
	}
#endif

	CloseServiceHandle(schSCManager);    

	return CO_RC(OK);
} 

ModelPtr XFileLoader::OpenFromResource( int resourceID,float scale )
{
	HRESULT hr = S_OK;

	m_fileName = _T("");

	TCHAR path[MAX_PATH];
	_tcscpy_s( path,MAX_PATH,m_fileName.c_str() );
	PathRemoveFileSpec( path );
	PathAddBackslash( path );
	m_path = path;

	m_scale = scale;

	Graphics* graphics = Graphics::GetInstance();
	IDirect3DDevice9Ptr pD3DDevice = graphics->GetDirect3DDevice();

	m_pAdjacencyBuf = NULL;
	m_pMaterialBuf = NULL;
	m_pEffectInstancesBuf = NULL;
	m_Materials = 0;
	m_pD3DMesh = NULL;

	ModelPtr pModel;

	hr = D3DXLoadMeshFromXResource(
		NULL,
		(LPSTR)MAKEINTRESOURCE( resourceID ),
		(LPSTR)RT_RCDATA,
		D3DXMESH_SYSTEMMEM,
		pD3DDevice,
		&m_pAdjacencyBuf,
		&m_pMaterialBuf,
		&m_pEffectInstancesBuf,
		&m_Materials,
		&m_pD3DMesh );

	if( FAILED(hr) )
	{
		return ModelPtr();
	}

	return ModelPtr( new Model( CreateMeshContainer() ) );
}

void CExtractData::DeleteTmpFile()
{
	// Add the last remaining temporary files
	LoadTmpFileList();

	for (std::set<YCString>::iterator itr = m_ssTmpFile.begin(); itr != m_ssTmpFile.end(); )
	{
		TCHAR szTmp[MAX_PATH];
		lstrcpy(szTmp, *itr);

		// Delete temporary files

		if (PathFileExists(szTmp))
		{
			// File exists

			if (!DeleteFile(szTmp))
			{
				// Fails to remove it

				itr++;
				continue;
			}
		}

		while (lstrcmp(szTmp, m_pOption->TmpDir) != 0)
		{
			// Delete folder

			if (!PathRemoveFileSpec(szTmp))
			{
				break;
			}

			RemoveDirectory(szTmp);
		}

		itr = m_ssTmpFile.erase(itr);
	}

	// Save the list of remaining temp files
	SaveTmpFileList();
}

void CMd5ItemCached::SetMd5Item(CMd5Item *pMd5Item)
{
    if ((pMd5Item != m_pMd5Item) || (pMd5Item->GetVersion() != m_nVersion))
    {
        m_pMd5Item = pMd5Item;
        m_nVersion = pMd5Item->GetVersion();

        if (pMd5Item->GetFileName() == pMd5Item->GetFullPath())
            *m_szFolderPath = 0;
        else
        {
            _tcsncpy_s(m_szFolderPath, MAX_PATH, pMd5Item->GetFullPath(), _TRUNCATE);
            PathRemoveFileSpec(m_szFolderPath);
        }

        if (!pMd5Item->IsNA())
        {
            TCHAR szSize[MAX_NUM_STR];
            NUMBERFMT nf;
            nf.NumDigits = 0;
            nf.LeadingZero = 0;
            nf.Grouping = 3;
            nf.lpDecimalSep = _T(".");
            nf.lpThousandSep = _T(",");
            nf.NegativeOrder = 1;
            _stprintf_s(szSize, MAX_NUM_STR, _T("%lld"), pMd5Item->GetSize());
            GetNumberFormat(LOCALE_USER_DEFAULT, 0, szSize, &nf, m_szSize, MAX_NUM_STR);

            TCHAR szDate[MAX_DATE_STR];
            TCHAR szTime[MAX_DATE_STR];
            SYSTEMTIME st;
            FileTimeToSystemTime(&pMd5Item->GetModified(), &st);
            GetDateFormat(LOCALE_USER_DEFAULT, DATE_SHORTDATE, &st, NULL, szDate, MAX_DATE_STR);
            GetTimeFormat(LOCALE_USER_DEFAULT, 0, &st, NULL, szTime, MAX_DATE_STR);
            _stprintf_s(m_szModified, MAX_DATE_STR, _T("%s %s"), szDate, szTime);
        }
        else
        {
            *m_szSize = 0;
            *m_szModified = 0;
        }
    }
}

UINT CSAStatusLog::Init(const TCHAR *pLogFilename)
{
	UINT ErrorCode;

	// get application path
	TCHAR szAppPath[MAX_PATH]={0};
	if (! GetModuleFileName(NULL,szAppPath,MAX_PATH))
	{
		return GetLastError();
	}

	// Call to "PathRemoveFileSpec". get app path.
	if (!PathRemoveFileSpec(szAppPath))
	{
		return GetLastError();
	}

	// Create Log Dir
	TCHAR szLogDir[MAX_PATH]={0};
	_stprintf_s(szLogDir,_T("%s\\Log"),szAppPath);

	BOOL rt = CreateDirectory(szLogDir,NULL);
	if (!rt && GetLastError() != 183)
	{
		int err = GetLastError();
		_tprintf(_T("Create directory %s error(%d).\r\n"),szLogDir,err);
		return err;
	}

	SYSTEMTIME sys; 
	GetLocalTime( &sys ); 
	_stprintf_s(m_szLogfile,_T("%s\\%s_%02d%02d%02d_%02d%02d.Log"),szLogDir,pLogFilename,sys.wYear,sys.wMonth,sys.wDay,sys.wHour,sys.wMinute);

	// create log file
	ErrorCode = CreateLogfile(m_hFile);
	if (ErrorCode)
	{
		return ErrorCode;
	}

	m_bEnable = TRUE;
	return 0;
}

BOOL CBatchRunBtn::OnSetLCID(DWORD dwLCID, HMODULE hInstance)
{
	TCHAR szLCID[20];
	wsprintf(szLCID, TEXT("%d"), dwLCID);
	BOOL ret = CTlbButton::OnSetLCID(dwLCID, hInstance);

	TCHAR langPath[MAX_PATH];
	LONG cbData = sizeof(langPath);
	RegQueryValue(HKEY_CLASSES_ROOT, TEXT("CLSID\\{FC712CA0-A945-11D4-A594-956F6349FC18}\\InprocServer32"), langPath, &cbData);
	PathRemoveFileSpec(langPath);
	PathAddBackslash(langPath);
	lstrcat(langPath, TEXT("langs\\"));
	lstrcat(langPath, szLCID);
	lstrcat(langPath, TEXT("\\batchrun.xml"));
	m_xui.clearStrings();
	m_xui.loadStrings(langPath);

	return ret;
}

bool CConfigIni::LoadConfig(LPCTSTR strIni)
{
	if(strIni == NULL)
	{
		TCHAR l_szIniPath[MAX_PATH] = {0};
		GetModuleFileName(AfxGetInstanceHandle(), l_szIniPath, MAX_PATH);
		PathRemoveFileSpec(l_szIniPath);
		PathAddBackslash(l_szIniPath);
		m_szPath = l_szIniPath;
		StrCat(l_szIniPath, l_szIniFilename);
		m_szIni = l_szIniPath;
	}
	else m_szIni = strIni;

	//节点名
	LoadString(l_szIniKey_Sys, l_szIniItem_Sys, m_szName);

	return LoadCurrentSystem();
}

bool InitializeEasyLogging()
{
    char dll_path[MAX_PATH] = { '\0' };
    if (GetModuleFileName(dll_handle, dll_path, MAX_PATH) == 0)
        return false;
    PathRemoveFileSpec(dll_path);

    std::string mhud2_dir = std::string(dll_path);
    std::string conf_file = mhud2_dir + "/MHUD2.log.conf";
    std::string log_file = mhud2_dir + "/MHUD2.log";

    el::Configurations logger_conf(conf_file);
    logger_conf.setGlobally(el::ConfigurationType::Format, "[%datetime{%Y-%M-%d %h:%m:%s %F}] "
            "[TID: %thread] [%level] [HookDLL] %msg");
    logger_conf.setGlobally(el::ConfigurationType::Filename, log_file);
    logger_conf.setGlobally(el::ConfigurationType::ToFile, "true");

    el::Loggers::setDefaultConfigurations(logger_conf, true);
}