int uv__set_process_title(const char* title) {
#if TARGET_OS_IPHONE
return -1;
#else
typedef CFTypeRef (*LSGetCurrentApplicationASNType)(void);
typedef OSStatus (*LSSetApplicationInformationItemType)(int,
CFTypeRef,
CFStringRef,
CFStringRef,
CFDictionaryRef*);
CFBundleRef launch_services_bundle;
LSGetCurrentApplicationASNType ls_get_current_application_asn;
LSSetApplicationInformationItemType ls_set_application_information_item;
CFStringRef* display_name_key;
ProcessSerialNumber psn;
CFTypeRef asn;
CFStringRef display_name;
OSStatus err;
launch_services_bundle =
CFBundleGetBundleWithIdentifier(CFSTR("com.apple.LaunchServices"));
if (launch_services_bundle == NULL)
return -1;
ls_get_current_application_asn = (LSGetCurrentApplicationASNType)
CFBundleGetFunctionPointerForName(launch_services_bundle,
CFSTR("_LSGetCurrentApplicationASN"));
if (ls_get_current_application_asn == NULL)
return -1;
ls_set_application_information_item = (LSSetApplicationInformationItemType)
CFBundleGetFunctionPointerForName(launch_services_bundle,
CFSTR("_LSSetApplicationInformationItem"));
if (ls_set_application_information_item == NULL)
return -1;
display_name_key = CFBundleGetDataPointerForName(launch_services_bundle,
CFSTR("_kLSDisplayNameKey"));
if (display_name_key == NULL || *display_name_key == NULL)
return -1;
/* Force the process manager to initialize. */
GetCurrentProcess(&psn);
display_name = CFStringCreateWithCString(NULL, title, kCFStringEncodingUTF8);
asn = ls_get_current_application_asn();
err = ls_set_application_information_item(-2, /* Magic value. */
asn,
*display_name_key,
display_name,
NULL);
return (err == noErr) ? 0 : -1;
#endif /* !TARGET_OS_IPHONE */
}
bool PluginPackage::load()
{
if (m_isLoaded) {
m_loadCount++;
return true;
}
WTF::RetainPtr<CFStringRef> path(AdoptCF, m_path.createCFString());
WTF::RetainPtr<CFURLRef> url(AdoptCF, CFURLCreateWithFileSystemPath(kCFAllocatorDefault, path.get(),
kCFURLPOSIXPathStyle, false));
m_module = CFBundleCreate(NULL, url.get());
if (!m_module || !CFBundleLoadExecutable(m_module)) {
LOG(Plugins, "%s not loaded", m_path.utf8().data());
return false;
}
m_isLoaded = true;
NP_GetEntryPointsFuncPtr NP_GetEntryPoints = 0;
NP_InitializeFuncPtr NP_Initialize;
NPError npErr;
NP_Initialize = (NP_InitializeFuncPtr)CFBundleGetFunctionPointerForName(m_module, CFSTR("NP_Initialize"));
NP_GetEntryPoints = (NP_GetEntryPointsFuncPtr)CFBundleGetFunctionPointerForName(m_module, CFSTR("NP_GetEntryPoints"));
m_NPP_Shutdown = (NPP_ShutdownProcPtr)CFBundleGetFunctionPointerForName(m_module, CFSTR("NP_Shutdown"));
if (!NP_Initialize || !NP_GetEntryPoints || !m_NPP_Shutdown)
goto abort;
memset(&m_pluginFuncs, 0, sizeof(m_pluginFuncs));
m_pluginFuncs.size = sizeof(m_pluginFuncs);
initializeBrowserFuncs();
npErr = NP_Initialize(&m_browserFuncs);
LOG_NPERROR(npErr);
if (npErr != NPERR_NO_ERROR)
goto abort;
npErr = NP_GetEntryPoints(&m_pluginFuncs);
LOG_NPERROR(npErr);
if (npErr != NPERR_NO_ERROR)
goto abort;
m_loadCount++;
return true;
abort:
unloadWithoutShutdown();
return false;
}
PluginEntryProc getMainEntry ()
{
PluginEntryProc mainProc = 0;
#if _WIN32
mainProc = (PluginEntryProc)GetProcAddress ((HMODULE)module, "VSTPluginMain");
if (!mainProc)
mainProc = (PluginEntryProc)GetProcAddress ((HMODULE)module, "main");
#elif TARGET_API_MAC_CARBON
mainProc = (PluginEntryProc)CFBundleGetFunctionPointerForName ((CFBundleRef)module, CFSTR("VSTPluginMain"));
if (!mainProc)
mainProc = (PluginEntryProc)CFBundleGetFunctionPointerForName ((CFBundleRef)module, CFSTR("main_macho"));
#endif
return mainProc;
}
/*
* LoadGlxBundle
* The Quartz mode X server needs to dynamically load the appropriate
* bundle before initializing GLX.
*/
static void LoadGlxBundle(void)
{
CFBundleRef mainBundle;
CFStringRef bundleName;
CFURLRef bundleURL;
CFBundleRef glxBundle;
// Get the main bundle for the application
mainBundle = CFBundleGetMainBundle();
// Choose the bundle to load
ErrorF("Loading GLX bundle ");
if (quartzUseAGL) {
bundleName = CFSTR("glxAGL.bundle");
ErrorF("glxAGL.bundle (using Apple's OpenGL)\n");
} else {
bundleName = CFSTR("glxMesa.bundle");
ErrorF("glxMesa.bundle (using Mesa)\n");
}
// Look for the appropriate GLX bundle in the main bundle by name
bundleURL = CFBundleCopyResourceURL(mainBundle, bundleName,
NULL, NULL);
if (!bundleURL) {
FatalError("Could not find GLX bundle.");
}
// Make a bundle instance using the URLRef
glxBundle = CFBundleCreate(kCFAllocatorDefault, bundleURL);
if (!CFBundleLoadExecutable(glxBundle)) {
FatalError("Could not load GLX bundle.");
}
// Find the GLX init functions
GlxExtensionInit = (void *) CFBundleGetFunctionPointerForName(
glxBundle, CFSTR("GlxExtensionInit"));
GlxWrapInitVisuals = (void *) CFBundleGetFunctionPointerForName(
glxBundle, CFSTR("GlxWrapInitVisuals"));
if (!GlxExtensionInit || !GlxWrapInitVisuals) {
FatalError("Could not initialize GLX bundle.");
}
// Release the CF objects
CFRelease(mainBundle);
CFRelease(bundleURL);
}
static void GetMissingQTFunctionPointers()
{
OSErr err;
CFBundleRef sysBundle;
err = LoadFrameworkBundle(CFSTR("QuickTime.framework"), &sysBundle);
if (err == noErr)
{
mNewQTNextPtr = (NewQTNextTaskPtr) CFBundleGetFunctionPointerForName( sysBundle, CFSTR("NewQTNextTaskNeededSoonerCallbackUPP") );
mQTInstallNextPtr = (QTInstallNextTaskPtr) CFBundleGetFunctionPointerForName( sysBundle, CFSTR("QTInstallNextTaskNeededSoonerCallback") );
mQTGetTimeUntilNextTaskPtr = (QTGetTimeUntilNextTaskPtr) CFBundleGetFunctionPointerForName( sysBundle, CFSTR("QTGetTimeUntilNextTask") );
mDisposeQTNextTaskPtr = (DisposeQTNextTaskPtr)CFBundleGetFunctionPointerForName( sysBundle, CFSTR("DisposeQTNextTaskNeededSoonerCallbackUPP") );
mQTUninstallNextTaskPtr = (QTUninstallNextTaskPtr)CFBundleGetFunctionPointerForName( sysBundle, CFSTR("QTUninstallNextTaskNeededSoonerCallback") );;
}
}
static WTF::RetainPtr<CFDictionaryRef> readPListFile(CFStringRef fileName, bool createFile, CFBundleRef bundle)
{
if (createFile) {
BP_CreatePluginMIMETypesPreferencesFuncPtr funcPtr =
(BP_CreatePluginMIMETypesPreferencesFuncPtr)CFBundleGetFunctionPointerForName(bundle, CFSTR("BP_CreatePluginMIMETypesPreferences"));
if (funcPtr)
funcPtr();
}
WTF::RetainPtr<CFDictionaryRef> map;
WTF::RetainPtr<CFURLRef> url =
CFURLCreateWithFileSystemPath(kCFAllocatorDefault, fileName, kCFURLPOSIXPathStyle, false);
CFDataRef resource = 0;
SInt32 code;
if (!CFURLCreateDataAndPropertiesFromResource(kCFAllocatorDefault, url.get(), &resource, 0, 0, &code))
return map;
WTF::RetainPtr<CFPropertyListRef> propertyList =
CFPropertyListCreateFromXMLData(kCFAllocatorDefault, resource, kCFPropertyListImmutable, 0);
CFRelease(resource);
if (!propertyList)
return map;
if (CFGetTypeID(propertyList.get()) != CFDictionaryGetTypeID())
return map;
map = static_cast<CFDictionaryRef>(static_cast<CFPropertyListRef>(propertyList.get()));
return map;
}
void *mac_getBundleSym(CFBundleRef bundle, const char *name)
{
CFStringRef nameRef = CFStringCreateWithCString(NULL, name, kCFStringEncodingASCII);
void *sym = CFBundleGetFunctionPointerForName(bundle, nameRef);
CFRelease(nameRef);
return sym;
}
__private_extern__ void _CFBundlePlugInLoaded(CFBundleRef bundle) {
CFDictionaryRef infoDict = CFBundleGetInfoDictionary(bundle);
CFStringRef tempStr;
CFPlugInDynamicRegisterFunction func = NULL;
if (!__CFBundleGetPlugInData(bundle)->_isPlugIn || __CFBundleGetPlugInData(bundle)->_isDoingDynamicRegistration || !infoDict || !CFBundleIsExecutableLoaded(bundle)) return;
tempStr = (CFStringRef)CFDictionaryGetValue(infoDict, CFSTR("CFPlugInNeedsDynamicRegistration"));
if (tempStr && CFGetTypeID(tempStr) == CFStringGetTypeID() && CFStringCompare(tempStr, CFSTR("YES"), kCFCompareCaseInsensitive) == kCFCompareEqualTo) {
CFDictionaryRemoveValue((CFMutableDictionaryRef)infoDict, CFSTR("CFPlugInNeedsDynamicRegistration"));
tempStr = (CFStringRef)CFDictionaryGetValue(infoDict, kCFPlugInDynamicRegisterFunctionKey);
if (!tempStr || CFGetTypeID(tempStr) != CFStringGetTypeID() || CFStringGetLength(tempStr) <= 0) tempStr = CFSTR("CFPlugInDynamicRegister");
__CFBundleGetPlugInData(bundle)->_loadOnDemand = false;
__CFBundleGetPlugInData(bundle)->_isDoingDynamicRegistration = true;
/* Find the symbol and call it. */
func = (CFPlugInDynamicRegisterFunction)CFBundleGetFunctionPointerForName(bundle, tempStr);
if (func) {
func(bundle);
// MF:!!! Unload function is never called. Need to deal with this!
}
__CFBundleGetPlugInData(bundle)->_isDoingDynamicRegistration = false;
if (__CFBundleGetPlugInData(bundle)->_loadOnDemand && __CFBundleGetPlugInData(bundle)->_instanceCount == 0) CFBundleUnloadExecutable(bundle); // Unload now if we can/should.
} else {
CFDictionaryRemoveValue((CFMutableDictionaryRef)infoDict, CFSTR("CFPlugInNeedsDynamicRegistration"));
}
}
void HeadlessView::loadExtensions() {
if (extensionsLoaded) {
return;
}
#ifdef MBGL_USE_CGL
gl::InitializeExtensions([](const char * name) {
static CFBundleRef framework = CFBundleGetBundleWithIdentifier(CFSTR("com.apple.opengl"));
if (!framework) {
throw std::runtime_error("Failed to load OpenGL framework.");
}
CFStringRef str = CFStringCreateWithCString(kCFAllocatorDefault, name, kCFStringEncodingASCII);
void* symbol = CFBundleGetFunctionPointerForName(framework, str);
CFRelease(str);
return reinterpret_cast<gl::glProc>(symbol);
});
#endif
#ifdef MBGL_USE_GLX
gl::InitializeExtensions([](const char * name) {
return glXGetProcAddress(reinterpret_cast<const GLubyte *>(name));
});
#endif
extensionsLoaded = true;
}
//-----------------------------------------------------------------------------
void *DynamicLibrary::getProcAddress( const char *function )
{
OSErr err = noErr;
void *fnAddress = NULL;
#if defined(TORQUE_OS_MAC_CARB)
if (platState.osX)
{
CFStringRef str = CFStringCreateWithCString(NULL, function, kCFStringEncodingMacRoman);
fnAddress = CFBundleGetFunctionPointerForName( (CFBundleRef)hInst, str );
if (fnAddress == NULL)
err = cfragNoSymbolErr;
CFRelease(str);
}
else
#endif
{
err = FindSymbol((CFragConnectionID)hInst, str2p(function), (char**)&fnAddress, NULL);
}
if (!fnAddress) {
if (mErrorReport)
Con::errorf("DynamicLibrary: function '%s' not found!", function);
mError = true;
}
return fnAddress;
}
void* OSCodeFragment::GetSymbol(const char* inSymbolName)
{
if (fFragmentP == NULL)
return NULL;
#if defined(HPUX) || defined(HPUX10)
void *symaddr = NULL;
int status;
errno = 0;
status = shl_findsym((shl_t *)&fFragmentP, symname, TYPE_PROCEDURE, &symaddr);
if (status == -1 && errno == 0) /* try TYPE_DATA instead */
status = shl_findsym((shl_t *)&fFragmentP, inSymbolName, TYPE_DATA, &symaddr);
return (status == -1 ? NULL : symaddr);
#elif defined(DLSYM_NEEDS_UNDERSCORE)
char *symbol = (char*)malloc(sizeof(char)*(strlen(inSymbolName)+2));
void *retval;
qtss_sprintf(symbol, "_%s", inSymbolName);
retval = dlsym(fFragmentP, symbol);
free(symbol);
return retval;
#elif defined(__Win32__)
return ::GetProcAddress(fFragmentP, inSymbolName);
#elif defined(__MacOSX__)
CFStringRef theString = CFStringCreateWithCString( kCFAllocatorDefault, inSymbolName, kCFStringEncodingASCII);
void* theSymbol = (void*)CFBundleGetFunctionPointerForName( fFragmentP, theString );
CFRelease(theString);
return theSymbol;
#else
return dlsym(fFragmentP, inSymbolName);
#endif
}
void* get_gl_proc_address_by_api(const char* name)
{
void* ret = NULL;
#ifdef GLLOADER_GLES
ret = (void*)(eglGetProcAddress(name));
#endif
#ifdef GLLOADER_WGL
ret = (void*)(::wglGetProcAddress(name));
#endif
#ifdef GLLOADER_AGL
CFURLRef bundleURL = CFURLCreateWithFileSystemPath(kCFAllocatorDefault,
CFSTR("/System/Library/Frameworks/OpenGL.framework"), kCFURLPOSIXPathStyle, true);
CFStringRef functionName = CFStringCreateWithCString(kCFAllocatorDefault, name, kCFStringEncodingASCII);
CFBundleRef bundle = CFBundleCreate(kCFAllocatorDefault, bundleURL);
assert(bundle != NULL);
ret = CFBundleGetFunctionPointerForName(bundle, functionName);
CFRelease(bundleURL);
CFRelease(functionName);
CFRelease(bundle);
#endif
#ifdef GLLOADER_GLX
ret = (void*)(glXGetProcAddressARB(reinterpret_cast<const GLubyte*>(name)));
#endif
return ret;
}
void CFBundleGetFunctionPointersForNames(CFBundleRef bundle, CFArrayRef functionNames, void *ftbl[]) {
SInt32 i, c;
if (!ftbl) return;
c = CFArrayGetCount(functionNames);
for (i = 0; i < c; i++) ftbl[i] = CFBundleGetFunctionPointerForName(bundle, (CFStringRef)CFArrayGetValueAtIndex(functionNames, i));
}
void InitBMDStreamingAPI(void)
{
CFURLRef bundleURL;
bundleURL = CFURLCreateWithFileSystemPath(kCFAllocatorDefault, CFSTR(kBMDStreamingAPI_BundlePath), kCFURLPOSIXPathStyle, true);
if (bundleURL != NULL)
{
gBMDStreamingAPIBundleRef = CFBundleCreate(kCFAllocatorDefault, bundleURL);
if (gBMDStreamingAPIBundleRef != NULL)
{
gCreateDiscoveryFunc = (CreateDiscoveryFunc)CFBundleGetFunctionPointerForName(gBMDStreamingAPIBundleRef, CFSTR("CreateBMDStreamingDiscoveryInstance_0002"));
gCreateNALParserFunc = (CreateNALParserFunc)CFBundleGetFunctionPointerForName(gBMDStreamingAPIBundleRef, CFSTR("CreateBMDStreamingH264NALParser_0001"));
}
CFRelease(bundleURL);
}
}
static CFBundleRef LoadRadioEffectComponent()
{
bool bLoaded = false;
CFBundleRef Bundle = NULL;
CFBundleRef MainBundleRef = CFBundleGetMainBundle();
if( MainBundleRef )
{
CFURLRef ComponentURLRef = CFBundleCopyResourceURL( MainBundleRef, CFSTR("RadioEffectUnit"), CFSTR("component"), 0 );
if( ComponentURLRef )
{
Bundle = CFBundleCreate(kCFAllocatorDefault, ComponentURLRef);
if(Bundle)
{
CFArrayRef Components = (CFArrayRef)CFBundleGetValueForInfoDictionaryKey(Bundle, CFSTR("AudioComponents"));
if ( Components && CFArrayGetCount(Components) )
{
CFDictionaryRef ComponentInfo = (CFDictionaryRef)CFArrayGetValueAtIndex(Components, 0);
CFNumberRef ComponentVersion = (CFNumberRef)CFDictionaryGetValue(ComponentInfo, CFSTR("version"));
CFStringRef ComponentFactoryFunction = (CFStringRef)CFDictionaryGetValue(ComponentInfo, CFSTR("factoryFunction"));
if( ComponentVersion && ComponentFactoryFunction )
{
int32 Version = 0;
CFNumberGetValue(ComponentVersion, kCFNumberSInt32Type, &Version);
AudioComponentFactoryFunction Factory = (AudioComponentFactoryFunction)CFBundleGetFunctionPointerForName(Bundle, ComponentFactoryFunction);
if(Factory)
{
// fill out the AudioComponentDescription
AudioComponentDescription theDescription;
theDescription.componentType = kAudioUnitType_Effect;
theDescription.componentSubType = 'Rdio';
theDescription.componentManufacturer = 'Epic';
theDescription.componentFlagsMask = 0;
AudioComponent RadioComponent = AudioComponentFindNext(nullptr, &theDescription);
if ( !RadioComponent )
{
RadioComponent = AudioComponentRegister(&theDescription, CFSTR("Epic Games: RadioEffectUnit"), Version, Factory);
check(RadioComponent);
}
bLoaded = (RadioComponent != NULL);
}
}
}
if(!bLoaded)
{
CFRelease(Bundle);
Bundle = NULL;
}
}
CFRelease( ComponentURLRef );
}
}
return Bundle;
}
void InitDeckLinkAPI_v7_6 (void)
{
CFURLRef bundleURL;
bundleURL = CFURLCreateWithFileSystemPath(kCFAllocatorDefault, CFSTR(kDeckLinkAPI_BundlePath), kCFURLPOSIXPathStyle, true);
if (bundleURL != NULL)
{
gBundleRef = CFBundleCreate(kCFAllocatorDefault, bundleURL);
if (gBundleRef != NULL)
{
gCreateIteratorFunc = (CreateIteratorFunc_v7_6)CFBundleGetFunctionPointerForName(gBundleRef, CFSTR("CreateDeckLinkIteratorInstance"));
gCreateOpenGLPreviewFunc = (CreateOpenGLScreenPreviewHelperFunc_v7_6)CFBundleGetFunctionPointerForName(gBundleRef, CFSTR("CreateOpenGLScreenPreviewHelper"));
gCreateCocoaPreviewFunc = (CreateCocoaScreenPreviewFunc_v7_6)CFBundleGetFunctionPointerForName(gBundleRef, CFSTR("CreateCocoaScreenPreview"));
gCreateVideoConversionFunc = (CreateVideoConversionInstanceFunc_v7_6)CFBundleGetFunctionPointerForName(gBundleRef, CFSTR("CreateVideoConversionInstance"));
}
CFRelease(bundleURL);
}
}
static void_t* GetProcessAddress (CFBundleRef bundle, const char* lpszprocname) {
if (NULL == bundle)
return NULL;
CFStringRef cfprocname = CFStringCreateWithCString (NULL, lpszprocname, CFStringGetSystemEncoding());
void_t* processAddress = CFBundleGetFunctionPointerForName (bundle, cfprocname);
CFRelease (cfprocname);
return processAddress;
}
int printOnOSXFormat(char * string,char *format) {
CFBundleRef bundle;
int(*fprintf_ptr)(FILE *stream, const char *format, ...) = NULL;
int(*fcnFlush_ptr)(FILE *stream) = NULL;
void* fcn_ptr = NULL;
void* fcnFlushx_ptr = NULL;
OSErr err;
FILE* stderr_ptr = NULL;
void* __sf_ptr = NULL;
err = LoadFrameworkBundle( CFSTR("System.framework"), &bundle );
fcn_ptr = CFBundleGetFunctionPointerForName(bundle, CFSTR("fprintf"));
fcnFlushx_ptr = CFBundleGetFunctionPointerForName(bundle, CFSTR("fflush"));
__sf_ptr = CFBundleGetDataPointerForName(bundle, CFSTR("__sF"));
if(fcn_ptr) {
/* cast it */
fprintf_ptr = ( int(*)(FILE *stream, const char *format, ...) ) fcn_ptr;
} else {
/* it failed, handle that somehow */
return;
}
if(fcnFlushx_ptr) {
/* cast it */
fcnFlush_ptr = ( int(*)(FILE *stream) ) fcnFlushx_ptr;
} else {
/* it failed, handle that somehow */
return;
}
if(__sf_ptr) {
stderr_ptr = (FILE*) ( ((char*)__sf_ptr) + 176);
/* 176 = 88*2, where 88=sizeof(FILE) under BSD */
} else {
/* it failed */
return;
}
fprintf_ptr(stderr_ptr, format,string);
fcnFlush_ptr(stderr_ptr);
}
static void *_get_proc(const char *proc)
{
void *res;
CFStringRef procname = CFStringCreateWithCString(kCFAllocatorDefault, proc,
kCFStringEncodingASCII);
res = CFBundleGetFunctionPointerForName(bundle, procname);
CFRelease(procname);
return res;
}
/*ARGSUSED*/
static long
krb5int_get_plugin_sym (struct plugin_file_handle *h,
const char *csymname, int isfunc, void **ptr,
struct errinfo *ep)
{
long err = 0;
void *sym = NULL;
#if USE_DLOPEN
if (!err && !sym && (h->dlhandle != NULL)) {
/* XXX Do we need to add a leading "_" to the symbol name on any
modern platforms? */
sym = dlsym (h->dlhandle, csymname);
if (sym == NULL) {
const char *e = dlerror (); /* XXX copy and save away */
Tprintf ("dlsym(%s): %s\n", csymname, e);
err = ENOENT; /* XXX */
krb5int_set_error(ep, err, "%s", e);
}
}
#endif
#if USE_CFBUNDLE
if (!err && !sym && (h->bundle != NULL)) {
CFStringRef cfsymname = NULL;
if (!err) {
cfsymname = CFStringCreateWithCString (kCFAllocatorDefault, csymname,
kCFStringEncodingASCII);
if (cfsymname == NULL) { err = ENOMEM; }
}
if (!err) {
if (isfunc) {
sym = CFBundleGetFunctionPointerForName (h->bundle, cfsymname);
} else {
sym = CFBundleGetDataPointerForName (h->bundle, cfsymname);
}
if (sym == NULL) { err = ENOENT; } /* XXX */
}
if (cfsymname != NULL) { CFRelease (cfsymname); }
}
#endif
if (!err && (sym == NULL)) {
err = ENOENT; /* unimplemented */
}
if (!err) {
*ptr = sym;
}
return err;
}
void* GetProcessAddress(CFBundleRef bundleRef, const char* lpProcName)
{
void *processAddress = NULL;
if(NULL != bundleRef)
{
CFStringRef cfProcName = CFStringCreateWithCString(kCFAllocatorSystemDefault, lpProcName, CFStringGetSystemEncoding());
processAddress = CFBundleGetFunctionPointerForName(bundleRef, cfProcName);
CFRelease(cfProcName);
}
return processAddress;
}
void *Bundle::lookupSymbol(const char *name)
{
CFRef<CFStringRef> cfName(CFStringCreateWithCString(NULL, name,
kCFStringEncodingMacRoman));
if (!cfName)
UnixError::throwMe(EBADEXEC); // sort of
void *function = CFBundleGetFunctionPointerForName(cfBundle(), cfName);
if (function == NULL)
UnixError::throwMe(EBADEXEC); // sort of
return function;
}
gl::glProc HeadlessBackend::initializeExtension(const char* name) {
static CFBundleRef framework = CFBundleGetBundleWithIdentifier(CFSTR("com.apple.opengl"));
if (!framework) {
throw std::runtime_error("Failed to load OpenGL framework.");
}
CFStringRef str = CFStringCreateWithCString(kCFAllocatorDefault, name, kCFStringEncodingASCII);
void* symbol = CFBundleGetFunctionPointerForName(framework, str);
CFRelease(str);
return reinterpret_cast<gl::glProc>(symbol);
}
/*
* QuartzLoadDisplayBundle
* Try to load the appropriate bundle containing the back end display code.
*/
Bool QuartzLoadDisplayBundle(
const char *dpyBundleName)
{
CFBundleRef mainBundle;
CFStringRef bundleName;
CFURLRef bundleURL;
CFBundleRef dpyBundle;
QuartzModeBundleInitPtr bundleInit;
// Get the main bundle for the application
mainBundle = CFBundleGetMainBundle();
// Make CFString from bundle name
bundleName = CFStringCreateWithCStringNoCopy(kCFAllocatorDefault,
dpyBundleName,
kCFStringEncodingASCII,
kCFAllocatorNull);
// Look for the appropriate bundle in the main bundle
bundleURL = CFBundleCopyResourceURL(mainBundle, bundleName,
NULL, NULL);
if (!bundleURL) {
ErrorF("Could not find display mode bundle %s.\n", dpyBundleName);
return FALSE;
}
// Make a bundle instance using the URLRef
dpyBundle = CFBundleCreate(kCFAllocatorDefault, bundleURL);
if (!CFBundleLoadExecutable(dpyBundle)) {
ErrorF("Could not load display mode bundle %s.\n", dpyBundleName);
return FALSE;
}
// Lookup the bundle initialization function
bundleInit = (void *)
CFBundleGetFunctionPointerForName(dpyBundle,
CFSTR("QuartzModeBundleInit"));
if (!bundleInit) {
ErrorF("Could not initialize display mode bundle %s.\n",
dpyBundleName);
return FALSE;
}
if (!bundleInit())
return FALSE;
// Release the CF objects
CFRelease(bundleName);
CFRelease(bundleURL);
return TRUE;
}
AEffect *loadVst2xPlugin(LibraryHandle libraryHandle)
{
// Somewhat cheap hack to avoid a tricky compiler warning. Casting from void* to a proper function
// pointer will cause GCC to warn that "ISO C++ forbids casting between pointer-to-function and
// pointer-to-object". Here, we represent both types in a union and use the correct one in the given
// context, thus avoiding the need to cast anything.
// See also: http://stackoverflow.com/a/2742234/14302
union {
Vst2xPluginEntryFunc entryPointFuncPtr;
void *entryPointVoidPtr;
} entryPoint;
entryPoint.entryPointVoidPtr = CFBundleGetFunctionPointerForName(libraryHandle, CFSTR("VSTPluginMain"));
Vst2xPluginEntryFunc mainEntryPoint = entryPoint.entryPointFuncPtr;
// VST plugins previous to the 2.4 SDK used main_macho for the entry point name
if (mainEntryPoint == NULL) {
entryPoint.entryPointVoidPtr = CFBundleGetFunctionPointerForName(libraryHandle, CFSTR("main_macho"));
mainEntryPoint = entryPoint.entryPointFuncPtr;
}
if (mainEntryPoint == NULL) {
logError("Couldn't get a pointer to plugin's main()");
CFBundleUnloadExecutable(libraryHandle);
CFRelease(libraryHandle);
return NULL;
}
AEffect *plugin = mainEntryPoint(pluginVst2xHostCallback);
if (plugin == NULL) {
logError("Plugin's main() returns null");
CFBundleUnloadExecutable(libraryHandle);
CFRelease(libraryHandle);
return NULL;
}
return plugin;
}
void * _glfwPlatformGetProcAddress( const char *procname )
{
CFStringRef symbolName = CFStringCreateWithCString( kCFAllocatorDefault,
procname,
kCFStringEncodingASCII );
void *symbol = CFBundleGetFunctionPointerForName( _glfwLibs.OpenGLFramework,
symbolName );
CFRelease( symbolName );
return symbol;
}
void * aglGetProcAddress (char * pszProc)
{
static bool first_time = true;
if (first_time)
{
first_time = false;
if (aglInitEntryPoints() != noErr)
return NULL;
}
return CFBundleGetFunctionPointerForName (gBundleRefOpenGL,
CFStringCreateWithCStringNoCopy (NULL,
pszProc, CFStringGetSystemEncoding (), NULL));
}
void set_message(wchar_t const* filename) {
#ifdef __APPLE__
CFBundleRef mainBundle = CFBundleGetMainBundle();
CFURLRef pluginURL = CFBundleCopyBuiltInPlugInsURL(mainBundle);
CFStringRef fn = CFStringCreateWithWString(kCFAllocatorDefault, filename, kCFStringEncodingUTF8);
CFURLRef path = CFURLCreateCopyAppendingPathComponent(NULL, pluginURL, fn, FALSE);
CFBundleRef bundle = CFBundleCreate(kCFAllocatorSystemDefault, path);
CFRelease(path);
CFRelease(fn);
CFRelease(pluginURL);
if (bundle==NULL)
throw filename;
FuncLoadMessage func = (FuncLoadMessage)CFBundleGetFunctionPointerForName(bundle, CFSTR("load_message"));
if (func==NULL) {
CFRelease(bundle);
throw filename;
}
#elif _MSC_VER
wstring path = wstring(L"dll\\")+filename;
HMODULE handle = LoadLibrary(path.c_str());
if (handle==0)
throw path.c_str();
FuncLoadMessage func = (FuncLoadMessage)GetProcAddress(handle, "load_message");
if (func==0)
throw path.c_str();
#else
#error Not implemented
#endif
vector<wstring> message;
message.resize(Message::NUMBER_OF_MESSAGES);
func(message);
message_object.reset(new Message);
message_object->set(message);
#ifdef __APPLE__
CFRelease(bundle);
#endif
}
/////////////////////////////////////////////////////////////
// Get a pointer to an OpenGL extension
// Note on the Mac, this does a lot of work that could be saved
// if you call this function repeatedly. Write your own function that
// gets the bundle once, gets all the function pointers, then releases
// the bundle.
void *gltGetExtensionPointer(const char *szExtensionName)
{
#ifdef WIN32
// Well, this one is simple. An OpenGL context must be
// current first. Returns NULL if extension not supported
return (void *)wglGetProcAddress(szExtensionName);
#endif
#ifdef linux
// Pretty much ditto above
return (void *)glXGetProcAddress(szExtensionName);
#endif
#ifdef __APPLE__
// Mac is a bit more tricky.
// First we need the bundle
CFBundleRef openGL = 0;
SInt16 fwVersion = 0;
SInt32 fwDir = 0;
if(FindFolder(kSystemDomain, kFrameworksFolderType, kDontCreateFolder, &fwVersion, &fwDir) != noErr)
return NULL;
FSSpec fSpec;
FSRef fRef;
if(FSMakeFSSpec(fwVersion, fwDir, "\pOpenGL.framework", &fSpec) != noErr)
return NULL;
FSpMakeFSRef(&fSpec, &fRef);
CFURLRef url = CFURLCreateFromFSRef(kCFAllocatorDefault, &fRef);
if(!url)
return NULL;
openGL = CFBundleCreate(kCFAllocatorDefault, url);
CFRelease(url);
// Then load the function pointer from the bundle
CFStringRef string = CFStringCreateWithCString(kCFAllocatorDefault, szExtensionName, kCFStringEncodingMacRoman);
void *pFunc = CFBundleGetFunctionPointerForName(openGL, string);
// Release the bundle and string
CFRelease(string);
CFRelease(openGL);
// Return the function ponter
return pFunc;
#endif
}
void* ioFindExternalFunctionIn(char *lookupName, void * moduleHandle) {
void * functionPtr = 0;
CFStringRef theString;
if (!moduleHandle)
return nil;
theString = CFStringCreateWithCString(kCFAllocatorDefault,lookupName,gCurrentVMEncoding);
if (theString == nil)
return nil;
functionPtr = (void*)CFBundleGetFunctionPointerForName((CFBundleRef) moduleHandle,theString);
CFRelease(theString);
return (void*) functionPtr;
}