static void ConsoleThreadProc(void *dummy) { MSG msg; (void)dummy; /* initialize the screen */ amx_console(DEFCOLUMNS,DEFWINLINES,0); /* message loop to process user input */ while (amx_termctl(4,0)) { if (GetMessage(&msg,NULL,0,0)) { TranslateMessage(&msg); DispatchMessage(&msg); } /* if */ } /* while */ }
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[]) { AMX amx; cell ret = 0; int err; if (argc != 2) PrintUsage(argv[0]); /* function "usage" aborts the program */ /* Load the program and initialize the abstract machine. */ err = aux_LoadProgram(&amx, argv[1], NULL, srun_Monitor); 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, NULL, srun_Monitor); if (err != AMX_ERR_NONE) PrintUsage(argv[0]); } /* if */ /* Initialize two core extension modules (more extension modules may be * loaded & initialized automatically as DLLs or shared libraries. */ amx_ConsoleInit(&amx); amx_CoreInit(&amx); /* register functions for the bstring library */ err = amx_Register(&amx, bstring_Natives, -1); ExitOnError(&amx, err); /* Initialize the garbage collector, start with a small table. */ gc_setcallback((GC_FREE)bdestroy); err = gc_settable(7, GC_AUTOGROW); ExitOnError(&amx, err); /* 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 enables 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. * In this example, there are no other abstract machines (there is just one) * and this "host" program has nothing else to do than run the abstract * machine. So if it detects a "sleep" it just restarts the abstract machine * immediately. */ err = amx_Exec(&amx, &ret, AMX_EXEC_MAIN, 0); while (err == AMX_ERR_SLEEP) err = amx_Exec(&amx, &ret, AMX_EXEC_CONT, 0); ExitOnError(&amx, err); /* Free the compiled script and resources. This also unloads and DLLs or * shared libraries that were registered automatically by amx_Init(). */ aux_FreeProgram(&amx); /* Free the garbarge collector data and tables. */ gc_settable(0); /* Print the return code of the compiled script (often not very useful). */ if (ret!=0) printf("\nReturn value: %ld\n", (long)ret); #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; }