HMODULE LoadLibraryA(LPCSTR lpLibFileName)
{
#if defined(_UWP)
int status;
HMODULE hModule = NULL;
WCHAR* filenameW = NULL;
if (!lpLibFileName)
return NULL;
status = ConvertToUnicode(CP_UTF8, 0, lpLibFileName, -1, &filenameW, 0);
if (status < 1)
return NULL;
hModule = LoadPackagedLibrary(filenameW, 0);
free(filenameW);
return hModule;
#else
HMODULE library;
library = dlopen(lpLibFileName, RTLD_LOCAL | RTLD_LAZY);
if (!library)
{
WLog_ERR(TAG, "LoadLibraryA: %s", dlerror());
return NULL;
}
return library;
#endif
}
void*
chck_dl_load(const char *file, const char **out_error)
{
assert(file);
void *handle = NULL;
const char *error = NULL;
#if defined(_WIN32) || defined(_WIN64)
#if defined(__WINRT__)
/**
* WinRT only publically supports LoadPackagedLibrary() for loading .dll
* files. LoadLibrary() is a private API, and not available for apps
* (that can be published to MS' Windows Store.)
*/
handle = (void*)LoadPackagedLibrary(file, 0);
#else
handle = (void*)LoadLibrary(file);
#endif
if (!handle)
error = "Failed to load dll file.";
#elif defined(__posix__) || defined(__unix__) || defined(__linux__) || defined(__APPLE__)
if (!(handle = dlopen(file, RTLD_NOW | RTLD_LOCAL)))
error = dlerror();
#else
error = "cdl: unsupported os";
#endif
if (out_error)
*out_error = error;
return handle;
}
//----------------------------------------------------------------------------------------
amf_handle AMF_CDECL_CALL amf_load_library(const wchar_t* filename)
{
#if defined(METRO_APP)
return LoadPackagedLibrary(filename, 0);
#else
return LoadLibraryW(filename);
#endif
}
HMODULE LoadLibraryW(LPCWSTR lpLibFileName)
{
#if defined(_UWP)
return LoadPackagedLibrary(lpLibFileName, 0);
#else
return (HMODULE) NULL;
#endif
}
bool dynamic_link( const char* library, const dynamic_link_descriptor descriptors[], size_t required, dynamic_link_handle*, int flags ) {
dynamic_link_handle tmp_handle = NULL;
TCHAR wlibrary[256];
if ( MultiByteToWideChar(CP_UTF8, 0, library, -1, wlibrary, 255) == 0 ) return false;
if ( flags & DYNAMIC_LINK_LOAD )
tmp_handle = LoadPackagedLibrary( wlibrary, 0 );
if (tmp_handle != NULL){
return resolve_symbols(tmp_handle, descriptors, required);
}else{
return false;
}
}
HINSTANCE DL_LoadLibrary(const char *a)
{
#ifdef __WINPHONE
// int mbstowcs(wchar_t *out, const char *in, size_t size);
const size_t WCHARBUF = 256;
wchar_t wszDest[WCHARBUF];
MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, a, -1, wszDest, WCHARBUF);
return LoadPackagedLibrary(wszDest,0);
#else
return LoadLibrary(a);
#endif
}
std::wstring EventLogChannel::findLibrary(const wchar_t* name)
{
std::wstring path;
HMODULE dll = LoadPackagedLibrary(name, 0);//LoadLibraryW(name);
if (dll)
{
const DWORD maxPathLen = MAX_PATH + 1;
wchar_t name[maxPathLen];
int n = 0;//GetModuleFileNameW(dll, name, maxPathLen);
if (n > 0) path = name;
FreeLibrary(dll);
}
return path;
}
tsk_plugin_t* tsk_plugin_create(const char* path)
{
tsk_plugin_t* plugin;
symbol_get_def_count funcptr_get_def_count;
tsk_plugin_handle_t* handle;
#if TSK_UNDER_WINDOWS
# if TSK_UNDER_WINDOWS_RT
wchar_t* szPath = (wchar_t*)tsk_calloc(tsk_strlen(path) + 1, sizeof(wchar_t));
static const wchar_t* szFormat = L"%hs";
swprintf(szPath, tsk_strlen(path) * sizeof(wchar_t), szFormat, path);
handle = LoadPackagedLibrary(szPath, 0x00000000);
TSK_FREE(szPath);
# else /* Windows desktop */
UINT currErrMode = SetErrorMode(SEM_FAILCRITICALERRORS); // save current ErrorMode. GetErrorMode() not supported on XP.
SetErrorMode(currErrMode | SEM_FAILCRITICALERRORS);
handle = LoadLibraryA(path);
SetErrorMode(currErrMode); // restore ErrorMode
# endif
#else
handle = dlopen(path, RTLD_NOW);
#endif
if(!handle){
TSK_DEBUG_ERROR("Failed to load library with path=%s", path);
return tsk_null;
}
if(!(funcptr_get_def_count = (symbol_get_def_count)_tsk_plugin_handle_get_symbol(handle, TSK_PLUGIN_FUNC_NAME_DEF_COUNT))){
TSK_DEBUG_ERROR("Cannot find function with name=%s", TSK_PLUGIN_FUNC_NAME_DEF_COUNT);
_tsk_plugin_handle_destroy(&handle);
return tsk_null;
}
if(!(plugin = (tsk_plugin_t*)tsk_object_new(&tsk_plugin_def_s))){
TSK_DEBUG_ERROR("Failed to create plugin object");
_tsk_plugin_handle_destroy(&handle);
return tsk_null;
}
plugin->handle = handle;
plugin->def_count = funcptr_get_def_count();
plugin->path = tsk_strdup(path);
TSK_DEBUG_INFO("Plugin with path=[%s] created with [%d] defs", plugin->path, plugin->def_count);
return plugin;
}
/**
@Status Caveat
@Notes This function can only find libraries in the root of the current
package. The mode parameter is ignored. In addition, error information
is not available on failure.
*/
void* dlopen(const char* path, int mode) {
try {
// We can only load libraries from within our own package or any dependent
// packages, so absolute paths are not much use to us. From whatever path
// we're given, just strip off everything but the leaf file name and try
// to load that. This isn't always correct, but it is sometimes correct.
std::wstring widePath(path, path + strlen(path));
DWORD pathLength = GetFullPathNameW(widePath.c_str(), 0, nullptr, nullptr);
auto fullPath = std::make_unique<WCHAR[]>(pathLength);
LPWSTR fileName = nullptr;
GetFullPathNameW(widePath.c_str(), pathLength, fullPath.get(), &fileName);
return LoadPackagedLibrary(fileName, 0);
} catch (...) {
}
return NULL;
}
void *
SDL_LoadObject(const char *sofile)
{
LPTSTR tstr = WIN_UTF8ToString(sofile);
#ifdef __WINRT__
/* WinRT only publically supports LoadPackagedLibrary() for loading .dll
files. LoadLibrary() is a private API, and not available for apps
(that can be published to MS' Windows Store.)
*/
void *handle = (void *) LoadPackagedLibrary(tstr, 0);
#else
void *handle = (void *) LoadLibrary(tstr);
#endif
SDL_free(tstr);
/* Generate an error message if all loads failed */
if (handle == NULL) {
char errbuf[512];
SDL_strlcpy(errbuf, "Failed loading ", SDL_arraysize(errbuf));
SDL_strlcat(errbuf, sofile, SDL_arraysize(errbuf));
WIN_SetError(errbuf);
}
return handle;
}
Module hxLoadLibrary(String inLib) { return LoadPackagedLibrary(inLib.__WCStr(),0); }
int ms_factory_load_plugins(MSFactory *factory, const char *dir){
int num=0;
#if defined(_WIN32) && !defined(_WIN32_WCE)
WIN32_FIND_DATA FileData;
HANDLE hSearch;
char szDirPath[1024];
#ifdef UNICODE
wchar_t wszDirPath[1024];
#endif
char szPluginFile[1024];
BOOL fFinished = FALSE;
const char *tmp = NULL;
BOOL debug = FALSE;
#ifndef MS2_WINDOWS_UNIVERSAL
tmp = getenv("DEBUG");
#endif
debug = (tmp != NULL && atoi(tmp) == 1);
snprintf(szDirPath, sizeof(szDirPath), "%s", dir);
// Start searching for .dll files in the current directory.
#ifdef MS2_WINDOWS_DESKTOP
snprintf(szDirPath, sizeof(szDirPath), "%s\\*.dll", dir);
#else
snprintf(szDirPath, sizeof(szDirPath), "%s\\libms*.dll", dir);
#endif
#ifdef UNICODE
mbstowcs(wszDirPath, szDirPath, sizeof(wszDirPath));
hSearch = FindFirstFileExW(wszDirPath, FindExInfoStandard, &FileData, FindExSearchNameMatch, NULL, 0);
#else
hSearch = FindFirstFileExA(szDirPath, FindExInfoStandard, &FileData, FindExSearchNameMatch, NULL, 0);
#endif
if (hSearch == INVALID_HANDLE_VALUE)
{
ms_message("no plugin (*.dll) found in [%s] [%d].", szDirPath, (int)GetLastError());
return 0;
}
snprintf(szDirPath, sizeof(szDirPath), "%s", dir);
while (!fFinished)
{
/* load library */
#ifdef MS2_WINDOWS_DESKTOP
UINT em=0;
#endif
HINSTANCE os_handle;
#ifdef UNICODE
wchar_t wszPluginFile[2048];
char filename[512];
wcstombs(filename, FileData.cFileName, sizeof(filename));
snprintf(szPluginFile, sizeof(szPluginFile), "%s\\%s", szDirPath, filename);
mbstowcs(wszPluginFile, szPluginFile, sizeof(wszPluginFile));
#else
snprintf(szPluginFile, sizeof(szPluginFile), "%s\\%s", szDirPath, FileData.cFileName);
#endif
#ifdef MS2_WINDOWS_DESKTOP
if (!debug) em = SetErrorMode (SEM_FAILCRITICALERRORS);
#ifdef UNICODE
os_handle = LoadLibraryExW(wszPluginFile, NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
#else
os_handle = LoadLibraryExA(szPluginFile, NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
#endif
if (os_handle==NULL)
{
ms_message("Fail to load plugin %s with altered search path: error %i",szPluginFile,(int)GetLastError());
#ifdef UNICODE
os_handle = LoadLibraryExW(wszPluginFile, NULL, 0);
#else
os_handle = LoadLibraryExA(szPluginFile, NULL, 0);
#endif
}
if (!debug) SetErrorMode (em);
#else
os_handle = LoadPackagedLibrary(wszPluginFile, 0);
#endif
if (os_handle==NULL)
ms_error("Fail to load plugin %s: error %i", szPluginFile, (int)GetLastError());
else{
init_func_t initroutine;
char szPluginName[256];
char szMethodName[256];
char *minus;
#ifdef UNICODE
snprintf(szPluginName, sizeof(szPluginName), "%s", filename);
#else
snprintf(szPluginName, sizeof(szPluginName), "%s", FileData.cFileName);
#endif
/*on mingw, dll names might be libsomething-3.dll. We must skip the -X.dll stuff*/
minus=strchr(szPluginName,'-');
if (minus) *minus='\0';
else szPluginName[strlen(szPluginName)-4]='\0'; /*remove .dll*/
snprintf(szMethodName, sizeof(szMethodName), "%s_init", szPluginName);
initroutine = (init_func_t) GetProcAddress (os_handle, szMethodName);
if (initroutine!=NULL){
initroutine(factory);
ms_message("Plugin loaded (%s)", szPluginFile);
// Add this new loaded plugin to the list (useful for FreeLibrary at the end)
factory->ms_plugins_loaded_list=ms_list_append(factory->ms_plugins_loaded_list,os_handle);
num++;
}else{
ms_warning("Could not locate init routine of plugin %s. Should be %s",
szPluginFile, szMethodName);
}
}
if (!FindNextFile(hSearch, &FileData)) {
if (GetLastError() == ERROR_NO_MORE_FILES){
fFinished = TRUE;
}
else
{
ms_error("couldn't find next plugin dll.");
fFinished = TRUE;
}
}
}
/* Close the search handle. */
FindClose(hSearch);
#elif defined(HAVE_DLOPEN)
char plugin_name[64];
DIR *ds;
MSList *loaded_plugins = NULL;
struct dirent *de;
char *ext;
char *fullpath;
ds=opendir(dir);
if (ds==NULL){
ms_message("Cannot open directory %s: %s",dir,strerror(errno));
return -1;
}
while( (de=readdir(ds))!=NULL){
if (
#ifndef __QNX__
(de->d_type==DT_REG || de->d_type==DT_UNKNOWN || de->d_type==DT_LNK) &&
#endif
(ext=strstr(de->d_name,PLUGINS_EXT))!=NULL) {
void *handle;
snprintf(plugin_name, MIN(sizeof(plugin_name), ext - de->d_name + 1), "%s", de->d_name);
if (ms_list_find_custom(loaded_plugins, (MSCompareFunc)strcmp, plugin_name) != NULL) continue;
loaded_plugins = ms_list_append(loaded_plugins, ms_strdup(plugin_name));
fullpath=ms_strdup_printf("%s/%s",dir,de->d_name);
ms_message("Loading plugin %s...",fullpath);
if ( (handle=dlopen(fullpath,RTLD_NOW))==NULL){
ms_warning("Fail to load plugin %s : %s",fullpath,dlerror());
}else {
char *initroutine_name=ms_malloc0(strlen(de->d_name)+10);
char *p;
void *initroutine=NULL;
strcpy(initroutine_name,de->d_name);
p=strstr(initroutine_name,PLUGINS_EXT);
if (p!=NULL){
strcpy(p,"_init");
initroutine=dlsym(handle,initroutine_name);
}
#ifdef __APPLE__
if (initroutine==NULL){
/* on macosx: library name are libxxxx.1.2.3.dylib */
/* -> MUST remove the .1.2.3 */
p=strstr(initroutine_name,".");
if (p!=NULL)
{
strcpy(p,"_init");
initroutine=dlsym(handle,initroutine_name);
}
}
#endif
if (initroutine!=NULL){
init_func_t func=(init_func_t)initroutine;
func(factory);
ms_message("Plugin loaded (%s)", fullpath);
num++;
}else{
ms_warning("Could not locate init routine of plugin %s",de->d_name);
}
ms_free(initroutine_name);
}
ms_free(fullpath);
}
}
ms_list_for_each(loaded_plugins, ms_free);
ms_list_free(loaded_plugins);
closedir(ds);
#else
ms_warning("no loadable plugin support: plugins cannot be loaded.");
num=-1;
#endif
return num;
}
bool Renderer::initializeCompiler()
{
TRACE_EVENT0("gpu", "initializeCompiler");
#if defined(ANGLE_PLATFORM_WP8)
mD3dCompilerModule = NULL;
mD3DCompileFunc = NULL;
mHasCompiler = false;
return true;
#endif //#if defined(ANGLE_PLATFORM_WP8)
#if defined(ANGLE_PLATFORM_WINRT) && (_MSC_VER >= 1800)
ERR("No D3D compiler module available - must use precompiled shaders\n");
mD3dCompilerModule = NULL;
mD3DCompileFunc = reinterpret_cast<pCompileFunc>(D3DCompile);
mHasCompiler = true;
return true;
#endif // #if defined(ANGLE_PLATFORM_WINRT) && (_MSC_VER >= 1800)
#if defined(ANGLE_PRELOADED_D3DCOMPILER_MODULE_NAMES)
// Find a D3DCompiler module that had already been loaded based on a predefined list of versions.
static TCHAR* d3dCompilerNames[] = ANGLE_PRELOADED_D3DCOMPILER_MODULE_NAMES;
for (size_t i = 0; i < ArraySize(d3dCompilerNames); ++i)
{
if (GetModuleHandleEx(0, d3dCompilerNames[i], &mD3dCompilerModule))
{
break;
}
}
#else
// Load the version of the D3DCompiler DLL associated with the Direct3D version ANGLE was built with.
#if defined(ANGLE_PLATFORM_WINRT)
#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
mD3dCompilerModule = LoadLibrary(D3DCOMPILER_DLL);
#else
mD3dCompilerModule = LoadPackagedLibrary((LPCWSTR)D3DCOMPILER_DLL, 0);
#endif
if (!mD3dCompilerModule)
{
ERR("No D3D compiler module found - must use precompiled shaders\n");
mD3DCompileFunc = NULL;
mHasCompiler = false;
return true;
}
#else
mD3dCompilerModule = LoadLibrary(D3DCOMPILER_DLL);
#endif //
#endif // ANGLE_PRELOADED_D3DCOMPILER_MODULE_NAMES
if (!mD3dCompilerModule)
{
ERR("No D3D compiler module found - aborting!\n");
mHasCompiler = FALSE;
return false;
}
mD3DCompileFunc = reinterpret_cast<pCompileFunc>(GetProcAddress(mD3dCompilerModule, "D3DCompile"));
ASSERT(mD3DCompileFunc);
return mD3DCompileFunc != NULL;
}
icvInitFFMPEG()
{
#if defined _WIN32
const wchar_t* module_name_ = L"opencv_ffmpeg"
CVAUX_STRW(CV_MAJOR_VERSION) CVAUX_STRW(CV_MINOR_VERSION) CVAUX_STRW(CV_SUBMINOR_VERSION)
#if (defined _MSC_VER && defined _M_X64) || (defined __GNUC__ && defined __x86_64__)
L"_64"
#endif
L".dll";
# ifdef WINRT
icvFFOpenCV = LoadPackagedLibrary( module_name_, 0 );
# else
const std::wstring module_name(module_name_);
const wchar_t* ffmpeg_env_path = _wgetenv(L"OPENCV_FFMPEG_DLL_DIR");
std::wstring module_path =
ffmpeg_env_path
? ((std::wstring(ffmpeg_env_path) + L"\\") + module_name)
: module_name;
icvFFOpenCV = LoadLibraryW(module_path.c_str());
if(!icvFFOpenCV && !ffmpeg_env_path)
{
HMODULE m = cv_GetCurrentModule();
if (m)
{
wchar_t path[MAX_PATH];
const size_t path_size = sizeof(path)/sizeof(*path);
size_t sz = GetModuleFileNameW(m, path, path_size);
/* Don't handle paths longer than MAX_PATH until that becomes a real issue */
if (sz > 0 && sz < path_size)
{
wchar_t* s = wcsrchr(path, L'\\');
if (s)
{
s[0] = 0;
module_path = (std::wstring(path) + L"\\") + module_name;
icvFFOpenCV = LoadLibraryW(module_path.c_str());
}
}
}
}
# endif
if( icvFFOpenCV )
{
icvCreateFileCapture_FFMPEG_p =
(CvCreateFileCapture_Plugin)GetProcAddress(icvFFOpenCV, "cvCreateFileCapture_FFMPEG");
icvReleaseCapture_FFMPEG_p =
(CvReleaseCapture_Plugin)GetProcAddress(icvFFOpenCV, "cvReleaseCapture_FFMPEG");
icvGrabFrame_FFMPEG_p =
(CvGrabFrame_Plugin)GetProcAddress(icvFFOpenCV, "cvGrabFrame_FFMPEG");
icvRetrieveFrame_FFMPEG_p =
(CvRetrieveFrame_Plugin)GetProcAddress(icvFFOpenCV, "cvRetrieveFrame_FFMPEG");
icvSetCaptureProperty_FFMPEG_p =
(CvSetCaptureProperty_Plugin)GetProcAddress(icvFFOpenCV, "cvSetCaptureProperty_FFMPEG");
icvGetCaptureProperty_FFMPEG_p =
(CvGetCaptureProperty_Plugin)GetProcAddress(icvFFOpenCV, "cvGetCaptureProperty_FFMPEG");
icvCreateVideoWriter_FFMPEG_p =
(CvCreateVideoWriter_Plugin)GetProcAddress(icvFFOpenCV, "cvCreateVideoWriter_FFMPEG");
icvReleaseVideoWriter_FFMPEG_p =
(CvReleaseVideoWriter_Plugin)GetProcAddress(icvFFOpenCV, "cvReleaseVideoWriter_FFMPEG");
icvWriteFrame_FFMPEG_p =
(CvWriteFrame_Plugin)GetProcAddress(icvFFOpenCV, "cvWriteFrame_FFMPEG");
#if 0
if( icvCreateFileCapture_FFMPEG_p != 0 &&
icvReleaseCapture_FFMPEG_p != 0 &&
icvGrabFrame_FFMPEG_p != 0 &&
icvRetrieveFrame_FFMPEG_p != 0 &&
icvSetCaptureProperty_FFMPEG_p != 0 &&
icvGetCaptureProperty_FFMPEG_p != 0 &&
icvCreateVideoWriter_FFMPEG_p != 0 &&
icvReleaseVideoWriter_FFMPEG_p != 0 &&
icvWriteFrame_FFMPEG_p != 0 )
{
printf("Successfully initialized ffmpeg plugin!\n");
}
else
{
printf("Failed to load FFMPEG plugin: module handle=%p\n", icvFFOpenCV);
}
#endif
}
#elif defined HAVE_FFMPEG
icvCreateFileCapture_FFMPEG_p = (CvCreateFileCapture_Plugin)cvCreateFileCapture_FFMPEG;
icvReleaseCapture_FFMPEG_p = (CvReleaseCapture_Plugin)cvReleaseCapture_FFMPEG;
icvGrabFrame_FFMPEG_p = (CvGrabFrame_Plugin)cvGrabFrame_FFMPEG;
icvRetrieveFrame_FFMPEG_p = (CvRetrieveFrame_Plugin)cvRetrieveFrame_FFMPEG;
icvSetCaptureProperty_FFMPEG_p = (CvSetCaptureProperty_Plugin)cvSetCaptureProperty_FFMPEG;
icvGetCaptureProperty_FFMPEG_p = (CvGetCaptureProperty_Plugin)cvGetCaptureProperty_FFMPEG;
icvCreateVideoWriter_FFMPEG_p = (CvCreateVideoWriter_Plugin)cvCreateVideoWriter_FFMPEG;
icvReleaseVideoWriter_FFMPEG_p = (CvReleaseVideoWriter_Plugin)cvReleaseVideoWriter_FFMPEG;
icvWriteFrame_FFMPEG_p = (CvWriteFrame_Plugin)cvWriteFrame_FFMPEG;
#endif
}
bool QLibraryPrivate::load_sys()
{
#ifndef Q_OS_WINRT
//avoid 'Bad Image' message box
UINT oldmode = SetErrorMode(SEM_FAILCRITICALERRORS|SEM_NOOPENFILEERRORBOX);
#endif
// We make the following attempts at locating the library:
//
// WinCE
// if (absolute)
// fileName
// fileName + ".dll"
// else
// fileName + ".dll"
// fileName
// QFileInfo(fileName).absoluteFilePath()
//
// Windows
// if (absolute)
// fileName
// fileName + ".dll"
// else
// fileName + ".dll"
// fileName
//
// NB If it's a plugin we do not ever try the ".dll" extension
QStringList attempts;
if (pluginState != IsAPlugin)
attempts.append(fileName + QLatin1String(".dll"));
// If the fileName is an absolute path we try that first, otherwise we
// use the system-specific suffix first
QFileSystemEntry fsEntry(fileName);
if (fsEntry.isAbsolute()) {
attempts.prepend(fileName);
} else {
attempts.append(fileName);
#if defined(Q_OS_WINCE)
attempts.append(QFileInfo(fileName).absoluteFilePath());
#endif
}
#ifdef Q_OS_WINRT
if (fileName.startsWith(QLatin1Char('/')))
attempts.prepend(QDir::rootPath() + fileName);
#endif
Q_FOREACH (const QString &attempt, attempts) {
#ifndef Q_OS_WINRT
pHnd = LoadLibrary((wchar_t*)QDir::toNativeSeparators(attempt).utf16());
#else // Q_OS_WINRT
QString path = QDir::toNativeSeparators(QDir::current().relativeFilePath(attempt));
pHnd = LoadPackagedLibrary((LPCWSTR)path.utf16(), 0);
if (pHnd)
qualifiedFileName = attempt;
#endif // !Q_OS_WINRT
// If we have a handle or the last error is something other than "unable
// to find the module", then bail out
if (pHnd || ::GetLastError() != ERROR_MOD_NOT_FOUND)
break;
}
static int findApiSymbols(void)
{
HMODULE dll = NULL;
#define LOOKUP_NOFALLBACK(x, reallyLook) \
symLookup(dll, (PHYSFS_FARPROC *) &p##x, #x, reallyLook, NULL)
#define LOOKUP(x, reallyLook) \
symLookup(dll, (PHYSFS_FARPROC *) &p##x, #x, \
reallyLook, (PHYSFS_FARPROC) fallback##x)
/* Apparently Win9x HAS the Unicode entry points, they just don't WORK. */
/* ...so don't look them up unless we're on NT+. (see osHasUnicode.) */
libUserEnv = LoadPackagedLibrary(L"userenv.dll", 0);
dll = (HMODULE)libUserEnv;
if (dll != NULL)
LOOKUP_NOFALLBACK(GetUserProfileDirectoryW, osHasUnicode);
/* !!! FIXME: what do they call advapi32.dll on Win64? */
libAdvApi32 = LoadPackagedLibrary(L"advapi32.dll", 0);
dll = (HMODULE)libAdvApi32;
//if (dll != NULL)
// LOOKUP(GetUserNameW, osHasUnicode);
/* !!! FIXME: what do they call kernel32.dll on Win64? */
libKernel32 = LoadPackagedLibrary(L"kernel32.dll", 0);
dll = (HMODULE)libKernel32;
if (dll != NULL)
{
LOOKUP_NOFALLBACK(GetFileAttributesExA, 1);
LOOKUP_NOFALLBACK(GetFileAttributesExW, osHasUnicode);
LOOKUP_NOFALLBACK(FindFirstFileW, osHasUnicode);
LOOKUP_NOFALLBACK(FindNextFileW, osHasUnicode);
LOOKUP(GetModuleFileNameW, osHasUnicode);
LOOKUP(FormatMessageW, osHasUnicode);
LOOKUP(GetFileAttributesW, osHasUnicode);
LOOKUP(GetCurrentDirectoryW, osHasUnicode);
LOOKUP(CreateDirectoryW, osHasUnicode);
LOOKUP(RemoveDirectoryW, osHasUnicode);
LOOKUP(CreateFileW, osHasUnicode);
LOOKUP(DeleteFileW, osHasUnicode);
} /* if */
#undef LOOKUP_NOFALLBACK
#undef LOOKUP
return(1);
} /* findApiSymbols */
