bool getFrameworkPath(char *respath)
{
char tmpPath[MAXPATHLEN];
CFBundleRef appBundle = CFBundleGetMainBundle();
if (!appBundle)
return false;
CFURLRef frameworksURL = CFBundleCopyPrivateFrameworksURL(appBundle);
if (!frameworksURL)
return false;
CFURLRef absFrameworksURL = CFURLCopyAbsoluteURL(frameworksURL);
CFRelease(frameworksURL);
if (!absFrameworksURL)
return false;
CFURLGetFileSystemRepresentation(absFrameworksURL, true,
(UInt8*) tmpPath,
sizeof(tmpPath));
printf("abs fw url = %s\n", tmpPath);
CFRelease(absFrameworksURL);
snprintf(respath, MAXPATHLEN, "%s/XUL.framework/Versions/Current", tmpPath);
return true;
}
void
TclpSetVariables(
Tcl_Interp *interp)
{
#ifndef NO_UNAME
struct utsname name;
#endif
int unameOK;
Tcl_DString ds;
#ifdef HAVE_COREFOUNDATION
char tclLibPath[MAXPATHLEN + 1];
#if MAC_OS_X_VERSION_MAX_ALLOWED > 1020
/*
* Set msgcat fallback locale to current CFLocale identifier.
*/
CFLocaleRef localeRef;
if (CFLocaleCopyCurrent != NULL && CFLocaleGetIdentifier != NULL &&
(localeRef = CFLocaleCopyCurrent())) {
CFStringRef locale = CFLocaleGetIdentifier(localeRef);
if (locale) {
char loc[256];
if (CFStringGetCString(locale, loc, 256, kCFStringEncodingUTF8)) {
if (!Tcl_CreateNamespace(interp, "::tcl::mac", NULL, NULL)) {
Tcl_ResetResult(interp);
}
Tcl_SetVar(interp, "::tcl::mac::locale", loc, TCL_GLOBAL_ONLY);
}
}
CFRelease(localeRef);
}
#endif /* MAC_OS_X_VERSION_MAX_ALLOWED > 1020 */
if (MacOSXGetLibraryPath(interp, MAXPATHLEN, tclLibPath) == TCL_OK) {
CONST char *str;
CFBundleRef bundleRef;
Tcl_SetVar(interp, "tclDefaultLibrary", tclLibPath, TCL_GLOBAL_ONLY);
Tcl_SetVar(interp, "tcl_pkgPath", tclLibPath, TCL_GLOBAL_ONLY);
Tcl_SetVar(interp, "tcl_pkgPath", " ",
TCL_GLOBAL_ONLY | TCL_APPEND_VALUE);
str = TclGetEnv("DYLD_FRAMEWORK_PATH", &ds);
if ((str != NULL) && (str[0] != '\0')) {
char *p = Tcl_DStringValue(&ds);
/*
* Convert DYLD_FRAMEWORK_PATH from colon to space separated.
*/
do {
if (*p == ':') {
*p = ' ';
}
} while (*p++);
Tcl_SetVar(interp, "tcl_pkgPath", Tcl_DStringValue(&ds),
TCL_GLOBAL_ONLY | TCL_APPEND_VALUE);
Tcl_SetVar(interp, "tcl_pkgPath", " ",
TCL_GLOBAL_ONLY | TCL_APPEND_VALUE);
Tcl_DStringFree(&ds);
}
bundleRef = CFBundleGetMainBundle();
if (bundleRef) {
CFURLRef frameworksURL;
Tcl_StatBuf statBuf;
frameworksURL = CFBundleCopyPrivateFrameworksURL(bundleRef);
if (frameworksURL) {
if (CFURLGetFileSystemRepresentation(frameworksURL, TRUE,
(unsigned char*) tclLibPath, MAXPATHLEN) &&
! TclOSstat(tclLibPath, &statBuf) &&
S_ISDIR(statBuf.st_mode)) {
Tcl_SetVar(interp, "tcl_pkgPath", tclLibPath,
TCL_GLOBAL_ONLY | TCL_APPEND_VALUE);
Tcl_SetVar(interp, "tcl_pkgPath", " ",
TCL_GLOBAL_ONLY | TCL_APPEND_VALUE);
}
CFRelease(frameworksURL);
}
frameworksURL = CFBundleCopySharedFrameworksURL(bundleRef);
if (frameworksURL) {
if (CFURLGetFileSystemRepresentation(frameworksURL, TRUE,
(unsigned char*) tclLibPath, MAXPATHLEN) &&
! TclOSstat(tclLibPath, &statBuf) &&
S_ISDIR(statBuf.st_mode)) {
Tcl_SetVar(interp, "tcl_pkgPath", tclLibPath,
TCL_GLOBAL_ONLY | TCL_APPEND_VALUE);
Tcl_SetVar(interp, "tcl_pkgPath", " ",
TCL_GLOBAL_ONLY | TCL_APPEND_VALUE);
}
CFRelease(frameworksURL);
}
}
Tcl_SetVar(interp, "tcl_pkgPath", pkgPath,
TCL_GLOBAL_ONLY | TCL_APPEND_VALUE);
} else
#endif /* HAVE_COREFOUNDATION */
{
Tcl_SetVar(interp, "tcl_pkgPath", pkgPath, TCL_GLOBAL_ONLY);
}
#ifdef DJGPP
Tcl_SetVar2(interp, "tcl_platform", "platform", "dos", TCL_GLOBAL_ONLY);
#else
Tcl_SetVar2(interp, "tcl_platform", "platform", "unix", TCL_GLOBAL_ONLY);
#endif
unameOK = 0;
#ifndef NO_UNAME
if (uname(&name) >= 0) {
CONST char *native;
unameOK = 1;
native = Tcl_ExternalToUtfDString(NULL, name.sysname, -1, &ds);
Tcl_SetVar2(interp, "tcl_platform", "os", native, TCL_GLOBAL_ONLY);
Tcl_DStringFree(&ds);
/*
* The following code is a special hack to handle differences in the
* way version information is returned by uname. On most systems the
* full version number is available in name.release. However, under
* AIX the major version number is in name.version and the minor
* version number is in name.release.
*/
if ((strchr(name.release, '.') != NULL)
|| !isdigit(UCHAR(name.version[0]))) { /* INTL: digit */
Tcl_SetVar2(interp, "tcl_platform", "osVersion", name.release,
TCL_GLOBAL_ONLY);
} else {
#ifdef DJGPP
/*
* For some obscure reason DJGPP puts major version into
* name.release and minor into name.version. As of DJGPP 2.04 this
* is documented in djgpp libc.info file.
*/
Tcl_SetVar2(interp, "tcl_platform", "osVersion", name.release,
TCL_GLOBAL_ONLY);
Tcl_SetVar2(interp, "tcl_platform", "osVersion", ".",
TCL_GLOBAL_ONLY|TCL_APPEND_VALUE);
Tcl_SetVar2(interp, "tcl_platform", "osVersion", name.version,
TCL_GLOBAL_ONLY|TCL_APPEND_VALUE);
#else
Tcl_SetVar2(interp, "tcl_platform", "osVersion", name.version,
TCL_GLOBAL_ONLY);
Tcl_SetVar2(interp, "tcl_platform", "osVersion", ".",
TCL_GLOBAL_ONLY|TCL_APPEND_VALUE);
Tcl_SetVar2(interp, "tcl_platform", "osVersion", name.release,
TCL_GLOBAL_ONLY|TCL_APPEND_VALUE);
#endif /* DJGPP */
}
Tcl_SetVar2(interp, "tcl_platform", "machine", name.machine,
TCL_GLOBAL_ONLY);
}
#endif /* !NO_UNAME */
if (!unameOK) {
Tcl_SetVar2(interp, "tcl_platform", "os", "", TCL_GLOBAL_ONLY);
Tcl_SetVar2(interp, "tcl_platform", "osVersion", "", TCL_GLOBAL_ONLY);
Tcl_SetVar2(interp, "tcl_platform", "machine", "", TCL_GLOBAL_ONLY);
}
/*
* Copy the username of the real user (according to getuid()) into
* tcl_platform(user).
*/
{
struct passwd *pwEnt = TclpGetPwUid(getuid());
const char *user;
if (pwEnt == NULL) {
user = "";
Tcl_DStringInit(&ds); /* ensure cleanliness */
} else {
user = Tcl_ExternalToUtfDString(NULL, pwEnt->pw_name, -1, &ds);
}
Tcl_SetVar2(interp, "tcl_platform", "user", user, TCL_GLOBAL_ONLY);
Tcl_DStringFree(&ds);
}
}
nsresult
GRE_GetGREPathWithProperties(const GREVersionRange *versions,
PRUint32 versionsLength,
const GREProperty *properties,
PRUint32 propertiesLength,
char *aBuffer, PRUint32 aBufLen)
{
#ifdef TARGET_XPCOM_ABI
// append the ABI to the properties to match only binary
// compatible GREs
static const GREProperty kExtraProperty =
{ "abi", TARGET_XPCOM_ABI };
nsAutoArrayPtr<GREProperty> allProperties(new GREProperty[propertiesLength + 1]);
if (!allProperties)
return NS_ERROR_OUT_OF_MEMORY;
for (PRUint32 i=0; i<propertiesLength; i++) {
allProperties[i].property = properties[i].property;
allProperties[i].value = properties[i].value;
}
allProperties[propertiesLength].property = kExtraProperty.property;
allProperties[propertiesLength].value = kExtraProperty.value;
PRUint32 allPropertiesLength = propertiesLength + 1;
#else
const GREProperty *allProperties = properties;
PRUint32 allPropertiesLength = propertiesLength;
#endif
// if GRE_HOME is in the environment, use that GRE
const char* env = getenv("GRE_HOME");
if (env && *env) {
char p[MAXPATHLEN];
snprintf(p, sizeof(p), "%s" XPCOM_FILE_PATH_SEPARATOR XPCOM_DLL, env);
p[sizeof(p) - 1] = '\0';
#if XP_UNIX
if (realpath(p, aBuffer))
return NS_OK;
#elif WINCE
if (p[0] != '\\')
{
WCHAR dir[MAX_PATH];
WCHAR path[MAX_PATH];
MultiByteToWideChar(CP_ACP, 0, p, -1, path, MAX_PATH);
_wfullpath(dir,path,MAX_PATH);
WideCharToMultiByte(CP_ACP, 0, dir, -1, aBuffer, MAX_PATH, NULL, NULL);
}
else {
strcpy(aBuffer, p);
}
return NS_OK;
#elif XP_WIN
if (_fullpath(aBuffer, p, aBufLen))
return NS_OK;
#elif XP_OS2
// realpath on OS/2 returns a unix-ized path, so re-native-ize
if (realpath(p, aBuffer)) {
for (char* ptr = strchr(aBuffer, '/'); ptr; ptr = strchr(ptr, '/'))
*ptr = '\\';
return NS_OK;
}
#elif XP_BEOS
BPath path;
status_t result;
result = path.SetTo(p,0,true);
if (result == B_OK)
{
sprintf(aBuffer, path.Path());
return NS_OK;
}
#else
// hope for the best
// xxxbsmedberg: other platforms should have a "make absolute" function
#endif
if (strlen(p) >= aBufLen)
return NS_ERROR_FILE_NAME_TOO_LONG;
strcpy(aBuffer, p);
return NS_OK;
}
// the Gecko bits that sit next to the application or in the LD_LIBRARY_PATH
env = getenv("USE_LOCAL_GRE");
if (env && *env) {
*aBuffer = nsnull;
return NS_OK;
}
#ifdef XP_MACOSX
aBuffer[0] = '\0';
// Check the bundle first, for <bundle>/Contents/Frameworks/XUL.framework/libxpcom.dylib
CFBundleRef appBundle = CFBundleGetMainBundle();
if (appBundle) {
CFURLRef fwurl = CFBundleCopyPrivateFrameworksURL(appBundle);
CFURLRef absfwurl = nsnull;
if (fwurl) {
absfwurl = CFURLCopyAbsoluteURL(fwurl);
CFRelease(fwurl);
}
if (absfwurl) {
CFURLRef xulurl =
CFURLCreateCopyAppendingPathComponent(NULL, absfwurl,
CFSTR(GRE_FRAMEWORK_NAME),
PR_TRUE);
if (xulurl) {
CFURLRef xpcomurl =
CFURLCreateCopyAppendingPathComponent(NULL, xulurl,
CFSTR("libxpcom.dylib"),
PR_FALSE);
if (xpcomurl) {
char tbuffer[MAXPATHLEN];
if (CFURLGetFileSystemRepresentation(xpcomurl, PR_TRUE,
(UInt8*) tbuffer,
sizeof(tbuffer)) &&
access(tbuffer, R_OK | X_OK) == 0) {
if (!realpath(tbuffer, aBuffer)) {
aBuffer[0] = '\0';
}
}
CFRelease(xpcomurl);
}
CFRelease(xulurl);
}
CFRelease(absfwurl);
}
}
if (aBuffer[0])
return NS_OK;
// Check ~/Library/Frameworks/XUL.framework/Versions/<version>/libxpcom.dylib
const char *home = getenv("HOME");
if (home && *home && GRE_FindGREFramework(home,
versions, versionsLength,
allProperties, allPropertiesLength,
aBuffer, aBufLen)) {
return NS_OK;
}
// Check /Library/Frameworks/XUL.framework/Versions/<version>/libxpcom.dylib
if (GRE_FindGREFramework("",
versions, versionsLength,
allProperties, allPropertiesLength,
aBuffer, aBufLen)) {
return NS_OK;
}
#elif defined(XP_UNIX)
env = getenv("MOZ_GRE_CONF");
if (env && GRE_GetPathFromConfigFile(env,
versions, versionsLength,
allProperties, allPropertiesLength,
aBuffer, aBufLen)) {
return NS_OK;
}
env = getenv("HOME");
if (env && *env) {
char buffer[MAXPATHLEN];
// Look in ~/.gre.config
snprintf(buffer, sizeof(buffer),
"%s" XPCOM_FILE_PATH_SEPARATOR GRE_CONF_NAME, env);
if (GRE_GetPathFromConfigFile(buffer,
versions, versionsLength,
allProperties, allPropertiesLength,
aBuffer, aBufLen)) {
return NS_OK;
}
// Look in ~/.gre.d/*.conf
snprintf(buffer, sizeof(buffer),
"%s" XPCOM_FILE_PATH_SEPARATOR GRE_USER_CONF_DIR, env);
if (GRE_GetPathFromConfigDir(buffer,
versions, versionsLength,
allProperties, allPropertiesLength,
aBuffer, aBufLen)) {
return NS_OK;
}
}
// Look for a global /etc/gre.conf file
if (GRE_GetPathFromConfigFile(GRE_CONF_PATH,
versions, versionsLength,
allProperties, allPropertiesLength,
aBuffer, aBufLen)) {
return NS_OK;
}
// Look for a group of config files in /etc/gre.d/
if (GRE_GetPathFromConfigDir(GRE_CONF_DIR,
versions, versionsLength,
allProperties, allPropertiesLength,
aBuffer, aBufLen)) {
return NS_OK;
}
#elif defined(XP_BEOS)
env = getenv("MOZ_GRE_CONF");
if (env && GRE_GetPathFromConfigFile(env,
versions, versionsLength,
allProperties, allPropertiesLength,
aBuffer, aBufLen)) {
return NS_OK;
}
char p[MAXPATHLEN];
if (find_directory(B_USER_SETTINGS_DIRECTORY, 0, 0, p, MAXPATHLEN)) {
char buffer[MAXPATHLEN];
// Look in B_USER_SETTINGS_DIRECTORY/gre.config
snprintf(buffer, sizeof(buffer),
"%s" XPCOM_FILE_PATH_SEPARATOR GRE_CONF_NAME, p);
if (GRE_GetPathFromConfigFile(buffer,
versions, versionsLength,
allProperties, allPropertiesLength,
aBuffer, aBufLen)) {
return NS_OK;
}
// Look in B_USER_SETTINGS_DIRECTORY/gre.d/*.conf
snprintf(buffer, sizeof(buffer),
"%s" XPCOM_FILE_PATH_SEPARATOR GRE_CONF_DIR, p);
if (GRE_GetPathFromConfigDir(buffer,
versions, versionsLength,
allProperties, allPropertiesLength,
aBuffer, aBufLen)) {
return NS_OK;
}
}
// Hope Zeta OS and Haiku OS multiuser versions will respect BeBook,
// for BeOS R5 COMMON and USER are equal
if (find_directory(B_COMMON_SETTINGS_DIRECTORY, 0, 0, p, MAXPATHLEN)) {
char buffer[MAXPATHLEN];
// Look for a B_COMMON_SETTINGS_DIRECTORY/gre.conf file
snprintf(buffer, sizeof(buffer),
"%s" XPCOM_FILE_PATH_SEPARATOR GRE_CONF_PATH, p);
if (GRE_GetPathFromConfigFile(buffer,
versions, versionsLength,
allProperties, allPropertiesLength,
aBuffer, aBufLen)) {
return NS_OK;
}
// Look for a group of config files in B_COMMON_SETTINGS_DIRECTORY/gre.d/
snprintf(buffer, sizeof(buffer),
"%s" XPCOM_FILE_PATH_SEPARATOR GRE_CONF_DIR, p);
if (GRE_GetPathFromConfigDir(buffer,
versions, versionsLength,
allProperties, allPropertiesLength,
aBuffer, aBufLen)) {
return NS_OK;
}
}
#elif defined(XP_WIN)
HKEY hRegKey = NULL;
// A couple of key points here:
// 1. Note the usage of the "Software\\mozilla.org\\GRE" subkey - this allows
// us to have multiple versions of GREs on the same machine by having
// subkeys such as 1.0, 1.1, 2.0 etc. under it.
// 2. In this sample below we're looking for the location of GRE version 1.2
// i.e. we're compatible with GRE 1.2 and we're trying to find it's install
// location.
//
// Please see http://www.mozilla.org/projects/embedding/GRE.html for
// more info.
//
if (::RegOpenKeyExW(HKEY_CURRENT_USER, GRE_WIN_REG_LOC, 0,
KEY_READ, &hRegKey) == ERROR_SUCCESS) {
PRBool ok = GRE_GetPathFromRegKey(hRegKey,
versions, versionsLength,
allProperties, allPropertiesLength,
aBuffer, aBufLen);
::RegCloseKey(hRegKey);
if (ok)
return NS_OK;
}
if (::RegOpenKeyExW(HKEY_LOCAL_MACHINE, GRE_WIN_REG_LOC, 0,
KEY_ENUMERATE_SUB_KEYS, &hRegKey) == ERROR_SUCCESS) {
PRBool ok = GRE_GetPathFromRegKey(hRegKey,
versions, versionsLength,
allProperties, allPropertiesLength,
aBuffer, aBufLen);
::RegCloseKey(hRegKey);
if (ok)
return NS_OK;
}
#endif
return NS_ERROR_FAILURE;
}
/* functions */
m64p_error AttachCoreLib(const char *CoreLibFilepath)
{
/* check if Core DLL is already attached */
if (CoreHandle != NULL)
return M64ERR_INVALID_STATE;
/* load the DLL */
m64p_error rval = M64ERR_INTERNAL;
/* first, try a library path+name that was given on the command-line */
if (CoreLibFilepath != NULL)
{
rval = osal_dynlib_open(&CoreHandle, CoreLibFilepath);
}
/* then try a library path that was given at compile time */
#if defined(COREDIR)
if (rval != M64ERR_SUCCESS || CoreHandle == NULL)
{
rval = osal_dynlib_open(&CoreHandle, COREDIR OSAL_DEFAULT_DYNLIB_FILENAME);
}
#endif
/* for MacOS, look for the library in the Frameworks folder of the app bundle */
#if defined(__APPLE__)
CFBundleRef mainBundle = CFBundleGetMainBundle();
if (mainBundle != NULL)
{
CFURLRef frameworksURL = CFBundleCopyPrivateFrameworksURL(mainBundle);
if (frameworksURL != NULL)
{
char libPath[1024 + 32];
if (CFURLGetFileSystemRepresentation(frameworksURL, TRUE, (uint8_t *) libPath, 1024))
{
strcat(libPath, "/" OSAL_DEFAULT_DYNLIB_FILENAME);
rval = osal_dynlib_open(&CoreHandle, libPath);
}
CFRelease(frameworksURL);
}
}
#endif
/* then try just the filename of the shared library, to let dlopen() look through the system lib dirs */
if (rval != M64ERR_SUCCESS || CoreHandle == NULL)
{
rval = osal_dynlib_open(&CoreHandle, OSAL_DEFAULT_DYNLIB_FILENAME);
}
/* as a last-ditch effort, try loading library in current directory */
if (rval != M64ERR_SUCCESS || CoreHandle == NULL)
{
rval = osal_dynlib_open(&CoreHandle, OSAL_CURRENT_DIR OSAL_DEFAULT_DYNLIB_FILENAME);
}
/* if we haven't found a good core library by now, then we're screwed */
if (rval != M64ERR_SUCCESS || CoreHandle == NULL)
{
DebugMessage(M64MSG_ERROR, "AttachCoreLib() Error: failed to find Mupen64Plus Core library");
CoreHandle = NULL;
return M64ERR_INPUT_NOT_FOUND;
}
/* attach and call the PluginGetVersion function, check the Core and API versions for compatibility with this front-end */
ptr_PluginGetVersion CoreVersionFunc;
CoreVersionFunc = (ptr_PluginGetVersion) osal_dynlib_getproc(CoreHandle, "PluginGetVersion");
if (CoreVersionFunc == NULL)
{
DebugMessage(M64MSG_ERROR, "AttachCoreLib() Error: Shared library '%s' invalid; no PluginGetVersion() function found.", CoreLibFilepath);
osal_dynlib_close(CoreHandle);
CoreHandle = NULL;
return M64ERR_INPUT_INVALID;
}
m64p_plugin_type PluginType = (m64p_plugin_type) 0;
int Compatible = 0;
int CoreVersion = 0;
const char *CoreName = NULL;
(*CoreVersionFunc)(&PluginType, &CoreVersion, &g_CoreAPIVersion, &CoreName, &g_CoreCapabilities);
if (PluginType != M64PLUGIN_CORE)
DebugMessage(M64MSG_ERROR, "AttachCoreLib() Error: Shared library '%s' invalid; this is not the emulator core.", CoreLibFilepath);
else if (CoreVersion < MINIMUM_CORE_VERSION)
DebugMessage(M64MSG_ERROR, "AttachCoreLib() Error: Shared library '%s' incompatible; core version %i.%i.%i is below minimum supported %i.%i.%i",
CoreLibFilepath, VERSION_PRINTF_SPLIT(CoreVersion), VERSION_PRINTF_SPLIT(MINIMUM_CORE_VERSION));
else if ((g_CoreAPIVersion & 0xffff0000) != (CORE_API_VERSION & 0xffff0000))
DebugMessage(M64MSG_ERROR, "AttachCoreLib() Error: Shared library '%s' incompatible; core API major version %i.%i.%i doesn't match with this application (%i.%i.%i)",
CoreLibFilepath, VERSION_PRINTF_SPLIT(g_CoreAPIVersion), VERSION_PRINTF_SPLIT(CORE_API_VERSION));
else
Compatible = 1;
/* exit if not compatible */
if (Compatible == 0)
{
osal_dynlib_close(CoreHandle);
CoreHandle = NULL;
return M64ERR_INCOMPATIBLE;
}
/* attach and call the CoreGetAPIVersion function, check Config API version for compatibility */
ptr_CoreGetAPIVersions CoreAPIVersionFunc;
CoreAPIVersionFunc = (ptr_CoreGetAPIVersions) osal_dynlib_getproc(CoreHandle, "CoreGetAPIVersions");
if (CoreAPIVersionFunc == NULL)
{
DebugMessage(M64MSG_ERROR, "AttachCoreLib() Error: Library '%s' broken; no CoreAPIVersionFunc() function found.", CoreLibFilepath);
osal_dynlib_close(CoreHandle);
CoreHandle = NULL;
return M64ERR_INPUT_INVALID;
}
int ConfigAPIVersion, DebugAPIVersion, VidextAPIVersion;
(*CoreAPIVersionFunc)(&ConfigAPIVersion, &DebugAPIVersion, &VidextAPIVersion, NULL);
if ((ConfigAPIVersion & 0xffff0000) != (CONFIG_API_VERSION & 0xffff0000) || ConfigAPIVersion < CONFIG_API_VERSION)
{
DebugMessage(M64MSG_ERROR, "AttachCoreLib() Error: Emulator core '%s' incompatible; Config API version %i.%i.%i doesn't match application: %i.%i.%i",
CoreLibFilepath, VERSION_PRINTF_SPLIT(ConfigAPIVersion), VERSION_PRINTF_SPLIT(CONFIG_API_VERSION));
osal_dynlib_close(CoreHandle);
CoreHandle = NULL;
return M64ERR_INCOMPATIBLE;
}
/* print some information about the core library */
DebugMessage(M64MSG_INFO, "attached to core library '%s' version %i.%i.%i", CoreName, VERSION_PRINTF_SPLIT(CoreVersion));
if (g_CoreCapabilities & M64CAPS_DYNAREC)
DebugMessage(M64MSG_INFO, " Includes support for Dynamic Recompiler.");
if (g_CoreCapabilities & M64CAPS_DEBUGGER)
DebugMessage(M64MSG_INFO, " Includes support for MIPS r4300 Debugger.");
if (g_CoreCapabilities & M64CAPS_CORE_COMPARE)
DebugMessage(M64MSG_INFO, " Includes support for r4300 Core Comparison.");
/* get function pointers to the common and front-end functions */
CoreErrorMessage = (ptr_CoreErrorMessage) osal_dynlib_getproc(CoreHandle, "CoreErrorMessage");
CoreStartup = (ptr_CoreStartup) osal_dynlib_getproc(CoreHandle, "CoreStartup");
CoreShutdown = (ptr_CoreShutdown) osal_dynlib_getproc(CoreHandle, "CoreShutdown");
CoreAttachPlugin = (ptr_CoreAttachPlugin) osal_dynlib_getproc(CoreHandle, "CoreAttachPlugin");
CoreDetachPlugin = (ptr_CoreDetachPlugin) osal_dynlib_getproc(CoreHandle, "CoreDetachPlugin");
CoreDoCommand = (ptr_CoreDoCommand) osal_dynlib_getproc(CoreHandle, "CoreDoCommand");
CoreOverrideVidExt = (ptr_CoreOverrideVidExt) osal_dynlib_getproc(CoreHandle, "CoreOverrideVidExt");
CoreAddCheat = (ptr_CoreAddCheat) osal_dynlib_getproc(CoreHandle, "CoreAddCheat");
CoreCheatEnabled = (ptr_CoreCheatEnabled) osal_dynlib_getproc(CoreHandle, "CoreCheatEnabled");
/* get function pointers to the configuration functions */
ConfigListSections = (ptr_ConfigListSections) osal_dynlib_getproc(CoreHandle, "ConfigListSections");
ConfigOpenSection = (ptr_ConfigOpenSection) osal_dynlib_getproc(CoreHandle, "ConfigOpenSection");
ConfigDeleteSection = (ptr_ConfigDeleteSection) osal_dynlib_getproc(CoreHandle, "ConfigDeleteSection");
ConfigSaveSection = (ptr_ConfigSaveSection) osal_dynlib_getproc(CoreHandle, "ConfigSaveSection");
ConfigListParameters = (ptr_ConfigListParameters) osal_dynlib_getproc(CoreHandle, "ConfigListParameters");
ConfigSaveFile = (ptr_ConfigSaveFile) osal_dynlib_getproc(CoreHandle, "ConfigSaveFile");
ConfigSetParameter = (ptr_ConfigSetParameter) osal_dynlib_getproc(CoreHandle, "ConfigSetParameter");
ConfigGetParameter = (ptr_ConfigGetParameter) osal_dynlib_getproc(CoreHandle, "ConfigGetParameter");
ConfigGetParameterType = (ptr_ConfigGetParameterType) osal_dynlib_getproc(CoreHandle, "ConfigGetParameterType");
ConfigGetParameterHelp = (ptr_ConfigGetParameterHelp) osal_dynlib_getproc(CoreHandle, "ConfigGetParameterHelp");
ConfigSetDefaultInt = (ptr_ConfigSetDefaultInt) osal_dynlib_getproc(CoreHandle, "ConfigSetDefaultInt");
ConfigSetDefaultFloat = (ptr_ConfigSetDefaultFloat) osal_dynlib_getproc(CoreHandle, "ConfigSetDefaultFloat");
ConfigSetDefaultBool = (ptr_ConfigSetDefaultBool) osal_dynlib_getproc(CoreHandle, "ConfigSetDefaultBool");
ConfigSetDefaultString = (ptr_ConfigSetDefaultString) osal_dynlib_getproc(CoreHandle, "ConfigSetDefaultString");
ConfigGetParamInt = (ptr_ConfigGetParamInt) osal_dynlib_getproc(CoreHandle, "ConfigGetParamInt");
ConfigGetParamFloat = (ptr_ConfigGetParamFloat) osal_dynlib_getproc(CoreHandle, "ConfigGetParamFloat");
ConfigGetParamBool = (ptr_ConfigGetParamBool) osal_dynlib_getproc(CoreHandle, "ConfigGetParamBool");
ConfigGetParamString = (ptr_ConfigGetParamString) osal_dynlib_getproc(CoreHandle, "ConfigGetParamString");
ConfigExternalOpen = (ptr_ConfigExternalOpen) osal_dynlib_getproc(CoreHandle, "ConfigExternalOpen");
ConfigExternalClose = (ptr_ConfigExternalClose) osal_dynlib_getproc(CoreHandle, "ConfigExternalClose");
ConfigExternalGetParameter = (ptr_ConfigExternalGetParameter) osal_dynlib_getproc(CoreHandle, "ConfigExternalGetParameter");
ConfigHasUnsavedChanges = (ptr_ConfigHasUnsavedChanges) osal_dynlib_getproc(CoreHandle, "ConfigHasUnsavedChanges");
ConfigGetSharedDataFilepath = (ptr_ConfigGetSharedDataFilepath) osal_dynlib_getproc(CoreHandle, "ConfigGetSharedDataFilepath");
ConfigGetUserConfigPath = (ptr_ConfigGetUserConfigPath) osal_dynlib_getproc(CoreHandle, "ConfigGetUserConfigPath");
ConfigGetUserDataPath = (ptr_ConfigGetUserDataPath) osal_dynlib_getproc(CoreHandle, "ConfigGetUserDataPath");
ConfigGetUserCachePath = (ptr_ConfigGetUserCachePath) osal_dynlib_getproc(CoreHandle, "ConfigGetUserCachePath");
/* get function pointers to the debugger functions */
DebugSetCallbacks = (ptr_DebugSetCallbacks) osal_dynlib_getproc(CoreHandle, "DebugSetCallbacks");
DebugSetCoreCompare = (ptr_DebugSetCoreCompare) osal_dynlib_getproc(CoreHandle, "DebugSetCoreCompare");
DebugSetRunState = (ptr_DebugSetRunState) osal_dynlib_getproc(CoreHandle, "DebugSetRunState");
DebugGetState = (ptr_DebugGetState) osal_dynlib_getproc(CoreHandle, "DebugGetState");
DebugStep = (ptr_DebugStep) osal_dynlib_getproc(CoreHandle, "DebugStep");
DebugDecodeOp = (ptr_DebugDecodeOp) osal_dynlib_getproc(CoreHandle, "DebugDecodeOp");
DebugMemGetRecompInfo = (ptr_DebugMemGetRecompInfo) osal_dynlib_getproc(CoreHandle, "DebugMemGetRecompInfo");
DebugMemGetMemInfo = (ptr_DebugMemGetMemInfo) osal_dynlib_getproc(CoreHandle, "DebugMemGetMemInfo");
DebugMemGetPointer = (ptr_DebugMemGetPointer) osal_dynlib_getproc(CoreHandle, "DebugMemGetPointer");
DebugMemRead64 = (ptr_DebugMemRead64) osal_dynlib_getproc(CoreHandle, "DebugMemRead64");
DebugMemRead32 = (ptr_DebugMemRead32) osal_dynlib_getproc(CoreHandle, "DebugMemRead32");
DebugMemRead16 = (ptr_DebugMemRead16) osal_dynlib_getproc(CoreHandle, "DebugMemRead16");
DebugMemRead8 = (ptr_DebugMemRead8) osal_dynlib_getproc(CoreHandle, "DebugMemRead8");
DebugMemWrite64 = (ptr_DebugMemWrite64) osal_dynlib_getproc(CoreHandle, "DebugMemWrite64");
DebugMemWrite32 = (ptr_DebugMemWrite32) osal_dynlib_getproc(CoreHandle, "DebugMemWrite32");
DebugMemWrite16 = (ptr_DebugMemWrite16) osal_dynlib_getproc(CoreHandle, "DebugMemWrite16");
DebugMemWrite8 = (ptr_DebugMemWrite8) osal_dynlib_getproc(CoreHandle, "DebugMemWrite8");
DebugGetCPUDataPtr = (ptr_DebugGetCPUDataPtr) osal_dynlib_getproc(CoreHandle, "DebugGetCPUDataPtr");
DebugBreakpointLookup = (ptr_DebugBreakpointLookup) osal_dynlib_getproc(CoreHandle, "DebugBreakpointLookup");
DebugBreakpointCommand = (ptr_DebugBreakpointCommand) osal_dynlib_getproc(CoreHandle, "DebugBreakpointCommand");
DebugBreakpointTriggeredBy = (ptr_DebugBreakpointTriggeredBy) osal_dynlib_getproc(CoreHandle, "DebugBreakpointTriggeredBy");
DebugVirtualToPhysical = (ptr_DebugVirtualToPhysical) osal_dynlib_getproc(CoreHandle, "DebugVirtualToPhysical");
return M64ERR_SUCCESS;
}
int
main(int argc, char **argv)
{
nsresult rv;
char *lastSlash;
char iniPath[MAXPATHLEN];
char tmpPath[MAXPATHLEN];
char greDir[MAXPATHLEN];
bool greFound = false;
#if defined(XP_MACOSX)
CFBundleRef appBundle = CFBundleGetMainBundle();
if (!appBundle)
return 1;
CFURLRef resourcesURL = CFBundleCopyResourcesDirectoryURL(appBundle);
if (!resourcesURL)
return 1;
CFURLRef absResourcesURL = CFURLCopyAbsoluteURL(resourcesURL);
CFRelease(resourcesURL);
if (!absResourcesURL)
return 1;
CFURLRef iniFileURL =
CFURLCreateCopyAppendingPathComponent(kCFAllocatorDefault,
absResourcesURL,
CFSTR("application.ini"),
false);
CFRelease(absResourcesURL);
if (!iniFileURL)
return 1;
CFStringRef iniPathStr =
CFURLCopyFileSystemPath(iniFileURL, kCFURLPOSIXPathStyle);
CFRelease(iniFileURL);
if (!iniPathStr)
return 1;
CFStringGetCString(iniPathStr, iniPath, sizeof(iniPath),
kCFStringEncodingUTF8);
CFRelease(iniPathStr);
#else
#ifdef XP_WIN
wchar_t wide_path[MAX_PATH];
if (!::GetModuleFileNameW(NULL, wide_path, MAX_PATH))
return 1;
WideCharToMultiByte(CP_UTF8, 0, wide_path,-1,
iniPath, MAX_PATH, NULL, NULL);
#elif defined(XP_OS2)
PPIB ppib;
PTIB ptib;
DosGetInfoBlocks(&ptib, &ppib);
DosQueryModuleName(ppib->pib_hmte, sizeof(iniPath), iniPath);
#else
// on unix, there is no official way to get the path of the current binary.
// instead of using the MOZILLA_FIVE_HOME hack, which doesn't scale to
// multiple applications, we will try a series of techniques:
//
// 1) use realpath() on argv[0], which works unless we're loaded from the
// PATH
// 2) manually walk through the PATH and look for ourself
// 3) give up
struct stat fileStat;
strncpy(tmpPath, argv[0], sizeof(tmpPath));
lastSlash = strrchr(tmpPath, '/');
if (lastSlash) {
*lastSlash = 0;
realpath(tmpPath, iniPath);
} else {
const char *path = getenv("PATH");
if (!path)
return 1;
char *pathdup = strdup(path);
if (!pathdup)
return 1;
bool found = false;
char *token = strtok(pathdup, ":");
while (token) {
sprintf(tmpPath, "%s/%s", token, argv[0]);
if (stat(tmpPath, &fileStat) == 0) {
found = true;
lastSlash = strrchr(tmpPath, '/');
*lastSlash = 0;
realpath(tmpPath, iniPath);
break;
}
token = strtok(NULL, ":");
}
free (pathdup);
if (!found)
return 1;
}
lastSlash = iniPath + strlen(iniPath);
*lastSlash = '/';
#endif
#ifndef XP_UNIX
lastSlash = strrchr(iniPath, PATH_SEPARATOR_CHAR);
if (!lastSlash)
return 1;
#endif
*(++lastSlash) = '\0';
// On Linux/Win, look for XULRunner in appdir/xulrunner
snprintf(greDir, sizeof(greDir),
"%sxulrunner" XPCOM_FILE_PATH_SEPARATOR XPCOM_DLL,
iniPath);
greFound = FolderExists(greDir);
#ifdef XP_UNIX
if (greFound) {
char resolved_greDir[MAXPATHLEN] = "";
if (realpath(greDir, resolved_greDir) && *resolved_greDir) {
strncpy(greDir, resolved_greDir, MAXPATHLEN);
}
}
#endif
strncpy(lastSlash, "application.ini", sizeof(iniPath) - (lastSlash - iniPath));
#endif
// If -app parameter was passed in, it is now time to take it under
// consideration.
const char *appDataFile;
appDataFile = getenv("XUL_APP_FILE");
if (!appDataFile || !*appDataFile)
if (argc > 1 && IsArg(argv[1], "app")) {
if (argc == 2) {
Output(false, "specify APP-FILE (optional)\n");
return 1;
}
argv[1] = argv[0];
++argv;
--argc;
appDataFile = argv[1];
argv[1] = argv[0];
++argv;
--argc;
char kAppEnv[MAXPATHLEN];
snprintf(kAppEnv, MAXPATHLEN, "XUL_APP_FILE=%s", appDataFile);
if (putenv(kAppEnv))
Output(false, "Couldn't set %s.\n", kAppEnv);
char *result = (char*) calloc(sizeof(char), MAXPATHLEN);
if (NS_FAILED(GetRealPath(appDataFile, &result))) {
Output(true, "Invalid application.ini path.\n");
return 1;
}
// We have a valid application.ini path passed in to the -app parameter
// but not yet a valid greDir, so lets look for it also on the same folder
// as the stub.
if (!greFound) {
lastSlash = strrchr(iniPath, PATH_SEPARATOR_CHAR);
if (!lastSlash)
return 1;
*(++lastSlash) = '\0';
snprintf(greDir, sizeof(greDir), "%s" XPCOM_DLL, iniPath);
greFound = FolderExists(greDir);
}
// copy it back.
strcpy(iniPath, result);
}
nsINIParser parser;
rv = parser.Init(iniPath);
if (NS_FAILED(rv)) {
fprintf(stderr, "Could not read application.ini\n");
return 1;
}
if (!greFound) {
#ifdef XP_MACOSX
// Check for <bundle>/Contents/Frameworks/XUL.framework/libxpcom.dylib
CFURLRef fwurl = CFBundleCopyPrivateFrameworksURL(appBundle);
CFURLRef absfwurl = nullptr;
if (fwurl) {
absfwurl = CFURLCopyAbsoluteURL(fwurl);
CFRelease(fwurl);
}
if (absfwurl) {
CFURLRef xulurl =
CFURLCreateCopyAppendingPathComponent(NULL, absfwurl,
CFSTR("XUL.framework"),
true);
if (xulurl) {
CFURLRef xpcomurl =
CFURLCreateCopyAppendingPathComponent(NULL, xulurl,
CFSTR("libxpcom.dylib"),
false);
if (xpcomurl) {
char tbuffer[MAXPATHLEN];
if (CFURLGetFileSystemRepresentation(xpcomurl, true,
(UInt8*) tbuffer,
sizeof(tbuffer)) &&
access(tbuffer, R_OK | X_OK) == 0) {
if (realpath(tbuffer, greDir)) {
greFound = true;
}
else {
greDir[0] = '\0';
}
}
CFRelease(xpcomurl);
}
CFRelease(xulurl);
}
CFRelease(absfwurl);
}
#endif
if (!greFound) {
Output(false, "Could not find the Mozilla runtime.\n");
return 1;
}
}
#ifdef XP_OS2
// On OS/2 we need to set BEGINLIBPATH to be able to find XULRunner DLLs
strcpy(tmpPath, greDir);
lastSlash = strrchr(tmpPath, PATH_SEPARATOR_CHAR);
if (lastSlash) {
*lastSlash = '\0';
}
DosSetExtLIBPATH(tmpPath, BEGIN_LIBPATH);
#endif
rv = XPCOMGlueStartup(greDir);
if (NS_FAILED(rv)) {
if (rv == NS_ERROR_OUT_OF_MEMORY) {
char applicationName[2000] = "this application";
parser.GetString("App", "Name", applicationName, sizeof(applicationName));
Output(true, "Not enough memory available to start %s.\n",
applicationName);
} else {
Output(true, "Couldn't load XPCOM.\n");
}
return 1;
}
static const nsDynamicFunctionLoad kXULFuncs[] = {
{ "XRE_CreateAppData", (NSFuncPtr*) &XRE_CreateAppData },
{ "XRE_FreeAppData", (NSFuncPtr*) &XRE_FreeAppData },
{ "XRE_main", (NSFuncPtr*) &XRE_main },
{ nullptr, nullptr }
};
rv = XPCOMGlueLoadXULFunctions(kXULFuncs);
if (NS_FAILED(rv)) {
Output(true, "Couldn't load XRE functions.\n");
return 1;
}
NS_LogInit();
int retval;
{ // Scope COMPtr and AutoAppData
nsCOMPtr<nsIFile> iniFile;
#ifdef XP_WIN
// On Windows iniPath is UTF-8 encoded so we need to convert it.
rv = NS_NewLocalFile(NS_ConvertUTF8toUTF16(iniPath), false,
getter_AddRefs(iniFile));
#else
rv = NS_NewNativeLocalFile(nsDependentCString(iniPath), false,
getter_AddRefs(iniFile));
#endif
if (NS_FAILED(rv)) {
Output(true, "Couldn't find application.ini file.\n");
return 1;
}
AutoAppData appData(iniFile);
if (!appData) {
Output(true, "Error: couldn't parse application.ini.\n");
return 1;
}
NS_ASSERTION(appData->directory, "Failed to get app directory.");
if (!appData->xreDirectory) {
// chop "libxul.so" off the GRE path
lastSlash = strrchr(greDir, PATH_SEPARATOR_CHAR);
if (lastSlash) {
*lastSlash = '\0';
}
#ifdef XP_WIN
// same as iniPath.
NS_NewLocalFile(NS_ConvertUTF8toUTF16(greDir), false,
&appData->xreDirectory);
#else
NS_NewNativeLocalFile(nsDependentCString(greDir), false,
&appData->xreDirectory);
#endif
}
retval = XRE_main(argc, argv, appData, 0);
}
NS_LogTerm();
return retval;
}
