NPBool CPlugin::init(NPWindow* pNPWindow)
{
if(pNPWindow == NULL)
return FALSE;
#ifdef XP_WIN
m_hWnd = (HWND)pNPWindow->window;
if(m_hWnd == NULL)
return FALSE;
// subclass window so we can intercept window messages and
// do our drawing to it
lpOldProc = SubclassWindow(m_hWnd, (WNDPROC)PluginWinProc);
// associate window with our CPlugin object so we can access
// it in the window procedure
SetWindowLong(m_hWnd, GWL_USERDATA, (LONG)this);
#endif
m_Window = pNPWindow;
m_bInitialized = TRUE;
g_pNPInstance = m_pNPInstance;
g_pNPWindow = pNPWindow;
PString strPluginPath;
#ifdef XP_WIN // NPAPI plugin
//Get Current Path of exe
char szFullFileName[ MAX_PATH ];
GetModuleFileName ( GetModuleHandle(NULL), szFullFileName, MAX_PATH ) ;
strPluginPath = szFullFileName;
PINDEX nPos = strPluginPath.FindLast( "\\" );
strPluginPath = strPluginPath.Mid( 0, nPos + 1 ) + "plugins\\js2n\\";
#else // not Windows - assuming Linux
BrInitError error;
if (br_init_lib(&error) == 0 && error != BR_INIT_ERROR_DISABLED)
{
printf( "Error - can't init binreloc, code %d\n", error );
}
strPluginPath = br_find_exe_dir("/usr/lib/firefox/plugins/");
strPluginPath += "js2n/";
#endif
g_NativeLogic.Init( g_strPageURL, strPluginPath );
return TRUE;
}
void ConfigRoot::osConfigInstallDir()
{
#ifdef SUPERSERVER
// Try getting the root path from the executable
install_dir = getRootPathFromExePath();
if (install_dir.hasData())
{
return;
}
#elif defined(ENABLE_BINRELOC)
BrInitError brError;
if (br_init_lib(&brError))
{
string temp;
PathUtils::splitLastComponent(install_dir, temp, br_find_exe_dir(FB_PREFIX));
return;
}
#endif
// As a last resort get it from the default install directory
install_dir = string(FB_PREFIX);
}
path_t locate_bin_directory(const logger* log, bool verbose) {
// locate the binary and build its path
#if KZH_PLATFORM == KZH_PLATFORM_LINUX
// use binreloc and fs to build up our paths
int brres = br_init(0);
if (brres == 0) {
if (verbose) {
log->error() << "binreloc could not be initialised";
}
throw std::runtime_error("Unable to resolve paths! binreloc could not be initialized");
}
char *tmp_bin_path = br_find_exe_dir(".");
path_t bin_path = path_t(tmp_bin_path).make_preferred();
free(tmp_bin_path);
br_free();
return bin_path;
#elif KZH_PLATFORM == KZH_PLATFORM_APPLE
// use NSBundlePath() to build up our paths
// return path_t(macBundlePath() + "/Contents/MacOS").make_preferred();
return path_t(macBundlePath()).make_preferred();
#else // Windows
// use GetModuleFileName() and fs to build up our paths on Windows
TCHAR szPath[MAX_PATH];
if (!GetModuleFileName(NULL, szPath, MAX_PATH)) {
if (verbose) {
log->error() << "Unable to resolve path: " << GetLastError();;
}
throw std::runtime_error("Unable to resolve paths! GetModuleFileName() failed. See the log for the error.");
}
return path_t(string_t(szPath)).remove_filename().make_preferred();
#endif
}
int main(int argc,char *argv[])
{
AMX amx;
cell ret = 0;
int err, i;
clock_t start,end;
STACKINFO stackinfo = { 0 };
AMX_IDLE idlefunc;
if (argc < 2)
PrintUsage(argv[0]); /* function "usage" aborts the program */
#if !defined AMX_NODYNALOAD && defined ENABLE_BINRELOC && (defined __LINUX__ || defined __FreeBSD__ || defined __OpenBSD__)
/* see www.autopackage.org for the BinReloc module */
if (br_init(NULL)) {
char *libroot=br_find_exe_dir("");
setenv("AMXLIB",libroot,0);
free(libroot);
} /* if */
#endif
/* Load the program and initialize the abstract machine. */
err = aux_LoadProgram(&amx, argv[1]);
if (err != AMX_ERR_NONE) {
/* try adding an extension */
char filename[_MAX_PATH];
strcpy(filename, argv[1]);
strcat(filename, ".amx");
err = aux_LoadProgram(&amx, filename);
if (err != AMX_ERR_NONE)
PrintUsage(argv[0]);
} /* if */
/* To install the debug hook "just-in-time", the signal function needs
* a pointer to the abstract machine(s) to abort. There are various ways
* to implement this; here I have done so with a simple global variable.
*/
global_amx = &amx;
signal(SIGINT, sigabort);
/* Initialize two core extension modules (more extension modules may be
* loaded & initialized automatically as DLLs or shared libraries.
*/
amx_ConsoleInit(&amx);
err = amx_CoreInit(&amx);
ExitOnError(&amx, err);
/* save the idle function, if set by any of the extension modules */
if (amx_GetUserData(&amx, AMX_USERTAG('I','d','l','e'), (void**)&idlefunc) != AMX_ERR_NONE)
idlefunc = NULL;
for (i = 2; i < argc; i++) {
if (strcmp(argv[i],"-stack") == 0) {
uint16_t flags;
amx_Flags(&amx, &flags);
if ((flags & AMX_FLAG_NOCHECKS) != 0)
printf("This script was compiled with debug information removed.\n"
"Stack monitoring is disfunctional\n\n");
/* Set "user data" with which the debug monitor can monitor stack usage
* per abstract machine (in this example, though, there is only one abstract
* machine, so a global variable would have sufficed).
*/
memset(&stackinfo, 0, sizeof stackinfo);
err = amx_SetUserData(&amx, AMX_USERTAG('S','t','c','k'), &stackinfo);
ExitOnError(&amx, err);
/* Install the debug hook, so that we can start monitoring the stack/heap
* usage right from the beginning of the script.
*/
amx_SetDebugHook(&amx, prun_Monitor);
} /* if */
} /* for */
start=clock();
/* Run the compiled script and time it. The "sleep" instruction causes the
* abstract machine to return in a "restartable" state (it restarts from
* the point that it stopped. This allows for a kind of light-weight
* cooperative multi-tasking. As native functions (or the debug hook) can
* also force an abstract machine to "sleep", you can also use it to create
* "latent functions": functions that allow the host application to continue
* processing, and/or other abstract machines to run, while they wait for
* some resource.
*/
err = amx_Exec(&amx, &ret, AMX_EXEC_MAIN);
while (err == AMX_ERR_SLEEP) {
if (idlefunc != NULL) {
/* If the abstract machine was put to sleep, we can handle events during
* that time. To save the "restart point", we must make a copy of the AMX
* (keeping the stack, frame, instruction pointer and other vital
* registers), but without cloning the entire abstract machine.
* There should be some criterion on when the abstract machine must be
* "woken up". In this example run-time, the parameter of the sleep
* instruction is taken to be a delay in milliseconds. In your own host
* application, you can choose to wait on a resource/semaphore or other.
*/
AMX nested_amx = amx;
clock_t stamp = clock();
while (((clock() - stamp)*1000)/CLOCKS_PER_SEC < amx.pri
&& (err = idlefunc(&nested_amx,amx_Exec)) == AMX_ERR_NONE)
/* nothing */;
ExitOnError(&nested_amx, err);
} /* if */
err = amx_Exec(&amx, &ret, AMX_EXEC_CONT);
} /* while */
if (idlefunc == NULL || err != AMX_ERR_INDEX)
ExitOnError(&amx, err); /* event-driven programs may not have main() */
/* For event-driven programs, we also need to loop over the idle/monitor
* function that some extension module installed (this could be the console
* module, for example). We did this if the main program was put to "sleep",
* but we do that here too.
*/
if (idlefunc != NULL) {
while ((err = idlefunc(&amx,amx_Exec)) == AMX_ERR_NONE)
/* nothing */;
ExitOnError(&amx, err);
} /* if */
end=clock();
/* Free the compiled script and resources. This also unloads and DLLs or
* shared libraries that were registered automatically by amx_Init().
*/
aux_FreeProgram(&amx);
/* Print the return code of the compiled script (often not very useful),
* its run time, and its stack usage.
*/
if (ret!=0)
printf("\nReturn value: %ld\n", (long)ret);
printf("\nRun time: %.2f seconds\n",(double)(end-start)/CLOCKS_PER_SEC);
if (stackinfo.maxstack != 0 || stackinfo.maxheap != 0) {
printf("Stack usage: %ld cells (%ld bytes)\n",
stackinfo.maxstack / sizeof(cell), stackinfo.maxstack);
printf("Heap usage: %ld cells (%ld bytes)\n",
stackinfo.maxheap / sizeof(cell), stackinfo.maxheap);
} /* if */
#if defined AMX_TERMINAL
/* This is likely a graphical terminal, which should not be closed
* automatically
*/
{
extern int amx_termctl(int,int);
while (amx_termctl(4,0))
/* nothing */;
}
#endif
return 0;
}
int main (int argc, char* argv[])
{
char **newargs;
int i, k = 0;
#ifdef _WIN32
/* CommandLineToArgvW() might return a different argc than the
* one passed to main(), so let it overwrite that, as we won't
* use argv[] on Windows anyway.
*/
wchar_t **wargv = CommandLineToArgvW (GetCommandLineW (), &argc);
#endif
newargs = (char **) malloc (sizeof (char *) * (argc + 2) + count_mono_options_args ());
#ifdef _WIN32
newargs [k++] = g_utf16_to_utf8 (wargv [0], -1, NULL, NULL, NULL);
#else
newargs [k++] = argv [0];
#endif
if (mono_options != NULL) {
i = 0;
while (mono_options[i] != NULL)
newargs[k++] = mono_options[i++];
}
BrInitError err = 0;
if (br_init(&err) == 1) {
char *exedir = br_find_exe_dir(NULL);
if (exedir) {
setenv("MONO_PATH",exedir,1);
mono_set_dirs(exedir, exedir);
chdir(exedir);
free(exedir);
}
} else {
switch (err) {
case BR_INIT_ERROR_NOMEM:
printf("Could not allocate enough memory\n");
break;
case BR_INIT_ERROR_OPEN_MAPS:
case BR_INIT_ERROR_READ_MAPS:
case BR_INIT_ERROR_INVALID_MAPS:
printf("Couldn't access /proc/self/maps!\n");
break;
case BR_INIT_ERROR_DISABLED:
printf("BinReloc disabled!!\n");
break;
}
return 1;
}
// Calculate image_name
char *image_name;
char *exe = br_find_exe(NULL);
char *pos = strrchr(exe, '/');
if (pos != NULL) {
image_name = strdup(pos+1);
pos = strstr(image_name,".bin.");
if (pos != NULL) {
strcpy(pos, ".exe");
}
}
free(exe);
newargs [k++] = image_name;
for (i = 1; i < argc; i++) {
#ifdef _WIN32
newargs [k++] = g_utf16_to_utf8 (wargv [i], -1, NULL, NULL, NULL);
#else
newargs [k++] = argv [i];
#endif
}
#ifdef _WIN32
LocalFree (wargv);
#endif
newargs [k] = NULL;
return mono_main (k, newargs);
}
