int main()
{
printf( "EXCOK: start\n" );
set_terminate( &no_handler );
test_basics();
test_scalars();
init_class();
test_class();
test_cl_ptrs();
test_passthru();
test_rethrow();
try {
++throws;
set_unexpected( &unexp );
test_unexpected();
} catch( long l ) {
++catches;
if( l != 675L ) {
printf( "unexpected failure %l\n", l );
}
}
if( throws != catches ) {
printf( "catches != throws\n" );
}
set_terminate( &my_term );
test_term();
printf( "terminate did not abort\n" );
return( 0 );
}
void CCrashHandler::SetThreadExceptionHandlers()
{
// Catch terminate() calls.
// In a multithreaded environment, terminate functions are maintained
// separately for each thread. Each new thread needs to install its own
// terminate function. Thus, each thread is in charge of its own termination handling.
// http://msdn.microsoft.com/en-us/library/t6fk7h29.aspx
set_terminate(TerminateHandler);
// Catch unexpected() calls.
// In a multithreaded environment, unexpected functions are maintained
// separately for each thread. Each new thread needs to install its own
// unexpected function. Thus, each thread is in charge of its own unexpected handling.
// http://msdn.microsoft.com/en-us/library/h46t5b69.aspx
set_unexpected(UnexpectedHandler);
// Catch a floating point error
typedef void (*sigh)(int);
signal(SIGFPE, (sigh)SigfpeHandler);
// Catch an illegal instruction
signal(SIGILL, SigillHandler);
// Catch illegal storage access errors
signal(SIGSEGV, SigsegvHandler);
}
void SortComp::Run() const {
set_terminate(terminator);
ListAlg();
std::list<TestCase*>::iterator t = tList.begin();
std::list<Sort*>::iterator a;
for(; t!=tList.end(); ++t) {
printf("Zestaw danych nr %d\n",(*t)->id);
(*t)->read();
(*t)->copy();
for(a = aList.begin(); a!=aList.end(); ++a) {
try{
(*a)->Run(*t);
(*t)->revert();
}
catch(ErrEmptyRev&) {
printf("zonkk");
}
catch(...) {
printf("zonk");
}
}
(*t)->cleanup();
}
}
void main1()
{
set_terminate(Release);
cout << "Resources alloted in main" << endl;
throw 100;
cout << "Resources released in main" << endl;
}
void cvc4unexpected() {
#if defined(CVC4_DEBUG) && !defined(__WIN32__)
safe_print(STDERR_FILENO,
"\n"
"CVC4 threw an \"unexpected\" exception (one that wasn't properly "
"specified\nin the throws() specifier for the throwing function)."
"\n\n");
const char* lastContents = LastExceptionBuffer::currentContents();
if(lastContents == NULL) {
safe_print(
STDERR_FILENO,
"The exception is unknown (maybe it's not a CVC4::Exception).\n\n");
} else {
safe_print(STDERR_FILENO, "The exception is:\n");
safe_print(STDERR_FILENO, lastContents);
safe_print(STDERR_FILENO, "\n\n");
}
if(!segvSpin) {
print_statistics();
set_terminate(default_terminator);
} else {
safe_print(STDERR_FILENO,
"Spinning so that a debugger can be connected.\n");
safe_print(STDERR_FILENO, "Try: gdb ");
safe_print(STDERR_FILENO, *progName);
safe_print(STDERR_FILENO, " ");
safe_print<int64_t>(STDERR_FILENO, getpid());
safe_print(STDERR_FILENO, "\n");
safe_print(STDERR_FILENO, " or: gdb --pid=");
safe_print<int64_t>(STDERR_FILENO, getpid());
safe_print(STDERR_FILENO, " ");
safe_print(STDERR_FILENO, *progName);
safe_print(STDERR_FILENO, "\n");
for(;;) {
sleep(60);
}
}
#else /* CVC4_DEBUG */
safe_print(STDERR_FILENO, "CVC4 threw an \"unexpected\" exception.\n");
print_statistics();
set_terminate(default_terminator);
#endif /* CVC4_DEBUG */
}
void set_thread_exception_handlers()
{
set_terminate(handle_terminate);
set_unexpected(handle_unexpected);
signal(SIGABRT, handle_signal);
signal(SIGFPE, handle_signal);
signal(SIGILL, handle_signal);
signal(SIGSEGV, handle_signal);
}
//-----------------------------------------------------------------------------
// process_options
//-----------------------------------------------------------------------------
int process_options(struct vpn_params *params, int argc, char *argv[])
{
char* argv0 = argv[0];
char* args = "dhnxi:";
char c;
/* initialize generic portion */
params->max_sessions = 0;
params->debug = 0;
params->log_verbose = 0;
params->daemonize = 1;
params->serverIDRef = 0;
params->serverRef = 0;
params->server_id = 0;
params->server_type = -1;
params->storeRef = 0;
params->next_arg_index = 0;
params->log_path[0] = 0;
// Process command line arguments, if any
while ((opterr == 1) && (c = getopt(argc, argv, args)) != EOF) {
switch (c) {
case 'h':
usage (stdout, argv0);
exit (0);
case 'n':
set_terminate();
/* FALLTHRU */
case 'd':
params->debug = 1;
break;
case 'x':
params->daemonize = 0;
break ;
case 'i':
params->server_id = optarg;
break ;
default:
usage(stderr, argv0);
return -1;
}
}
/* init ppp portion */
ppp_process_options(params);
/* init ipsec portion */
ipsec_process_options(params);
return 0;
}
void *
exceptionedThread(void * arg)
{
int dummy = 0x1;
(void) set_terminate(&terminateFunction);
throw dummy;
return (void *) 0;
}
int main()
{
set_terminate(my_terminate) ;
try
{
throw 1 ; // no catch block
}
catch(const char* message)
{
printf( "%s\n", message );
_fail;
}
_PASS;
}
void setupSignalHandlers() {
set_terminate( myTerminate );
set_new_handler( myNewHandler );
// SIGABRT is the only signal we want handled by signal handlers on both windows and posix.
invariant( signal(SIGABRT, abruptQuit) != SIG_ERR );
#ifdef _WIN32
_set_purecall_handler( ::abort ); // TODO improve?
setWindowsUnhandledExceptionFilter();
massert(10297,
"Couldn't register Windows Ctrl-C handler",
SetConsoleCtrlHandler(static_cast<PHANDLER_ROUTINE>(CtrlHandler), TRUE));
#else
invariant( signal(SIGHUP , SIG_IGN ) != SIG_ERR );
invariant( signal(SIGUSR2, SIG_IGN ) != SIG_ERR );
invariant( signal(SIGPIPE, SIG_IGN) != SIG_ERR );
struct sigaction addrSignals;
memset( &addrSignals, 0, sizeof( struct sigaction ) );
addrSignals.sa_sigaction = abruptQuitWithAddrSignal;
sigemptyset( &addrSignals.sa_mask );
addrSignals.sa_flags = SA_SIGINFO;
invariant( sigaction(SIGSEGV, &addrSignals, 0) == 0 );
invariant( sigaction(SIGBUS, &addrSignals, 0) == 0 );
invariant( sigaction(SIGILL, &addrSignals, 0) == 0 );
invariant( sigaction(SIGFPE, &addrSignals, 0) == 0 );
setupSIGTRAPforGDB();
// asyncSignals is a global variable listing the signals that should be handled by the
// interrupt thread, once it is started via startSignalProcessingThread().
sigemptyset( &asyncSignals );
sigaddset( &asyncSignals, SIGHUP );
sigaddset( &asyncSignals, SIGINT );
sigaddset( &asyncSignals, SIGTERM );
sigaddset( &asyncSignals, SIGQUIT );
sigaddset( &asyncSignals, SIGUSR1 );
sigaddset( &asyncSignals, SIGXCPU );
#endif
}
int
main()
{
INIT_EXCEPTIONS();
#ifdef MUST_EXIT
signal (SIGABRT, catch_abort);
#endif
set_terminate (terminate_handler);
try
{
puts ("Trying something");
throw (Exception());
}
end_try;
}
int CCrashHandler::UnSetThreadExceptionHandlers()
{
crSetErrorMsg(_T("Unspecified error."));
DWORD dwThreadId = GetCurrentThreadId();
CAutoLock lock(&m_csThreadExceptionHandlers);
std::map<DWORD, ThreadExceptionHandlers>::iterator it =
m_ThreadExceptionHandlers.find(dwThreadId);
if(it==m_ThreadExceptionHandlers.end())
{
// No exception handlers were installed for the caller thread?
ATLASSERT(0);
crSetErrorMsg(_T("Crash handler wasn't previously installed for current thread."));
return 1;
}
ThreadExceptionHandlers* handlers = &(it->second);
if(handlers->m_prevTerm!=NULL)
set_terminate(handlers->m_prevTerm);
if(handlers->m_prevUnexp!=NULL)
set_unexpected(handlers->m_prevUnexp);
if(handlers->m_prevSigFPE!=NULL)
signal(SIGFPE, handlers->m_prevSigFPE);
if(handlers->m_prevSigILL!=NULL)
signal(SIGINT, handlers->m_prevSigILL);
if(handlers->m_prevSigSEGV!=NULL)
signal(SIGSEGV, handlers->m_prevSigSEGV);
// Remove from the list
m_ThreadExceptionHandlers.erase(it);
// OK.
crSetErrorMsg(_T("Success."));
return 0;
}
void InstallCrashHandler(const WCHAR *crashDumpPath, const WCHAR *symDir)
{
assert(!gDumpEvent && !gDumpThread);
if (!crashDumpPath)
return;
if (!StoreCrashDumpPaths(symDir))
return;
if (!BuildSymbolPath())
return;
// don't bother sending crash reports when running under Wine
// as they're not helpful
bool isWine= BuildModulesInfo();
if (isWine)
return;
BuildSystemInfo();
// at this point list of modules should be complete (except
// dbghlp.dll which shouldn't be loaded yet)
gExeType = DetectExeType();
// we pre-allocate as much as possible to minimize allocations
// when crash handler is invoked. It's ok to use standard
// allocation functions here.
gCrashHandlerAllocator = new CrashHandlerAllocator();
gCrashDumpPath = str::Dup(crashDumpPath);
gDumpEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
if (!gDumpEvent)
return;
gDumpThread = CreateThread(NULL, 0, CrashDumpThread, NULL, 0, 0);
if (!gDumpThread)
return;
gPrevExceptionFilter = SetUnhandledExceptionFilter(DumpExceptionHandler);
signal(SIGABRT, onSignalAbort);
#if defined(_MSC_VER)
// those are only in msvc? There is std::set_terminate() and
// std::set_unexpected() in C++ in <exception>
set_terminate(onTerminate);
set_unexpected(onUnexpected);
#endif
}
void setupSignals() {
assert( signal(SIGSEGV, abruptQuit) != SIG_ERR );
assert( signal(SIGFPE, abruptQuit) != SIG_ERR );
assert( signal(SIGABRT, abruptQuit) != SIG_ERR );
assert( signal(SIGBUS, abruptQuit) != SIG_ERR );
assert( signal(SIGQUIT, abruptQuit) != SIG_ERR );
assert( signal(SIGPIPE, pipeSigHandler) != SIG_ERR );
setupSIGTRAPforGDB();
sigemptyset( &asyncSignals );
sigaddset( &asyncSignals, SIGHUP );
sigaddset( &asyncSignals, SIGINT );
sigaddset( &asyncSignals, SIGTERM );
assert( pthread_sigmask( SIG_SETMASK, &asyncSignals, 0 ) == 0 );
boost::thread it( interruptThread );
set_terminate( myterminate );
}
static void ssh_set_exceptionHandlers()
{
// установить фильтр исключений
SetUnhandledExceptionFilter(Win32UnhandledExceptionFilter);
// установить режимы отчета библиотеки времени выполнения
//_CrtSetReportMode(_CRT_ERROR, 0);
_CrtSetReportMode(_CRT_ASSERT, 0);
set_terminate(ssh_terminate_handler);
set_unexpected(ssh_unexp_handler);
_set_purecall_handler(ssh_purecall_handler);
_set_invalid_parameter_handler(ssh_invalid_parameter_handler);
_set_new_handler(ssh_new_handler);
// _set_security_error_handler(ssh_security_handler);
signal(SIGABRT, ssh_signal_handler);
signal(SIGINT, ssh_signal_handler);
signal(SIGTERM, ssh_signal_handler);
signal(SIGFPE, ssh_signal_handler);
signal(SIGILL, ssh_signal_handler);
signal(SIGSEGV, ssh_signal_handler);
}
bool CrashHandlerWindows::registerThreadCrashHandlers() {
Autolock autoLock(&m_Lock);
DWORD dwThreadId = GetCurrentThreadId();
std::map<DWORD, ThreadExceptionHandlers>::iterator it = m_pPreviousCrashHandlers->m_threadExceptionHandlers.find(dwThreadId);
if(it != m_pPreviousCrashHandlers->m_threadExceptionHandlers.end()) {
LogWarning << "Crash handlers are already registered for this thread.";
return false;
}
ThreadExceptionHandlers & threadHandlers
= m_pPreviousCrashHandlers->m_threadExceptionHandlers[dwThreadId];
// Catch terminate() calls.
// In a multithreaded environment, terminate functions are maintained
// separately for each thread. Each new thread needs to install its own
// terminate function. Thus, each thread is in charge of its own termination handling.
// http://msdn.microsoft.com/en-us/library/t6fk7h29.aspx
threadHandlers.m_terminateHandler = set_terminate(TerminateHandler);
// Catch unexpected() calls.
// In a multithreaded environment, unexpected functions are maintained
// separately for each thread. Each new thread needs to install its own
// unexpected function. Thus, each thread is in charge of its own unexpected handling.
// http://msdn.microsoft.com/en-us/library/h46t5b69.aspx
threadHandlers.m_unexpectedHandler = set_unexpected(UnexpectedHandler);
// Catch a floating point error
threadHandlers.m_SIGFPEHandler = signal(SIGFPE, (signal_handler)SIGFPEHandler);
// Catch an illegal instruction
threadHandlers.m_SIGILLHandler = signal(SIGILL, SignalHandler);
// Catch illegal storage access errors
threadHandlers.m_SIGSEGVHandler = signal(SIGSEGV, SignalHandler);
return true;
}
void cvc4terminate() {
set_terminate(default_terminator);
#ifdef CVC4_DEBUG
LastExceptionBuffer* current = LastExceptionBuffer::getCurrent();
LastExceptionBuffer::setCurrent(NULL);
delete current;
safe_print(STDERR_FILENO,
"\n"
"CVC4 was terminated by the C++ runtime.\n"
"Perhaps an exception was thrown during stack unwinding. "
"(Don't do that.)\n");
print_statistics();
default_terminator();
#else /* CVC4_DEBUG */
safe_print(STDERR_FILENO,
"CVC4 was terminated by the C++ runtime.\n"
"Perhaps an exception was thrown during stack unwinding.\n");
print_statistics();
default_terminator();
#endif /* CVC4_DEBUG */
}
void CrashHandlerWindows::unregisterThreadCrashHandlers() {
Autolock autoLock(&m_Lock);
DWORD dwThreadId = GetCurrentThreadId();
std::map<DWORD, ThreadExceptionHandlers>::iterator it = m_pPreviousCrashHandlers->m_threadExceptionHandlers.find(dwThreadId);
if(it == m_pPreviousCrashHandlers->m_threadExceptionHandlers.end()) {
LogWarning << "Crash handlers were not registered for this thread.";
return;
}
ThreadExceptionHandlers& threadHandlers = it->second;
set_terminate(threadHandlers.m_terminateHandler);
set_unexpected(threadHandlers.m_unexpectedHandler);
signal(SIGFPE, threadHandlers.m_SIGFPEHandler);
signal(SIGILL, threadHandlers.m_SIGILLHandler);
signal(SIGSEGV, threadHandlers.m_SIGSEGVHandler);
m_pPreviousCrashHandlers->m_threadExceptionHandlers.erase(it);
}
int Test::main( int argc, char *argv[] ) noexcept {
#ifdef AIDKIT_GCC
set_terminate( __gnu_cxx::__verbose_terminate_handler );
#endif
QApplication application( argc, argv );
QStringList arguments = application.arguments();
// if there aren't any parameters then we want the 'silent' mode:
// http://doc.qt.io/qt-5/qtest-overview.html#qt-test-command-line-arguments
if ( arguments.length() == 1 ) {
arguments.append( "-silent" );
}
// Execute the tests and print which have failed:
QVector< Test * > failedTests = executeTests( arguments );
for ( Test *test : failedTests ) {
cerr << "Test failed: '" << test->name() << "'!" << endl;
}
return failedTests.size();
}
//-------------------------------------------------------------------------------------------------
// 主程序入口
//-------------------------------------------------------------------------------------------------
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPTSTR lpCmdLine, int nCmdShow)
{
//
// VS2005之后的版本,微软增加了一些新的异常机制,新机制在出现错误时默认不通知应用程序，
// 这时程序就崩溃了.所以这种情况下,必须调用_set_invalid_parameter_handler、
// _set_purecall_handler设置自己的异常处理函数。
//
// _set_invalid_parameter_handler
// 许多C运行时函数检查参数有效性传递给它们。如果无效参数传递，该功能可以设置errno错误号
// 或返回错误代码。在这种情况下，参数无效处理程序调用。此功能允许该处理程序设置为另一个函数
//
// _set_purecall_handler
// Error-Handling Routines, Sets the handler for a pure virtual function call.
//
// set_terminate
// Exception-Handling Functions, Install your own termination routine to be called by terminate
//
_set_invalid_parameter_handler(InvalidParameterHandler);
_set_purecall_handler(MakeDump);
set_terminate(MakeDump);
// Hook Windows内存分配函数
//HookMemoryFunction();
// vld
//__VLD_THREEAD_NAME;
//__VLD_THREAD_TRACE_AUTO;
// profile统计注册
//sdPF_Func_Register()
// 游戏启动标志
::CreateMutex(NULL, TRUE, "wzclient");
// 硬件与软件检查
// CheckSystem()
// 注册CRT退出回调函数
// atexit(ExitDump)
// 加载多线程渲染库
//HMODULE hMTDirectX9 = NULL;
//if (true)
//{
// std::vector<std::string> kCheckProcessVec;
// kCheckProcessVec.push_back("fraps.exe"); ///< 运行fraps.exe时不开启多线程渲染
// if (!IsProcessRunning(sdUtil::IsProcessRunning(kCheckProcessVec)))
// hMTDirectX9 = ::LoadLibrary("MTDirectX9.dll");
//}
// 开启多线程角色更新
// 加载进度条
//g_pkLoadingDlg = new sdLoadingDlg;
//g_pkLoadingDlg->Initialize();
// 客户端初始化
g_pkGameClient = new sdGameClient;
assert(g_pkGameClient);
g_pkGameClient->Initialize(hInstance);
// 销毁进度条
//g_pkLoadingDlg->Destroy();
//delete g_pkLoadingDlg;
//g_pkLoadingDlg = NULL;
// 显示客户端窗口
::ShowWindow(g_pkGameClient->GetWindowHandle(), SW_SHOWNORMAL);
::UpdateWindow(g_pkGameClient->GetWindowHandle());
// 客户端运行循环
while(g_pkGameClient->Run());
// 客户端销毁
g_pkGameClient->Destroy();
delete g_pkGameClient;
g_pkGameClient = NULL;
// 卸载多线程渲染库
//if (hMTDirectX9 != NULL)
//{
// ::FreeLibrary(hMTDirectX9);
// hMTDirectX9 = NULL;
//}
// 客户端结束后调用浏览器之类的
//::CreateProcess();
return 0;
};
int
main(int argc, char **av)
{
char *prog = *av;
opt *set = NULL;
int i, grpdebug = 0, debug = 0, setlen = 0, listing = 0;
str err = MAL_SUCCEED;
char prmodpath[FILENAME_MAX];
const char *modpath = NULL;
char *binpath = NULL;
str *monet_script;
char *dbpath = NULL;
char *dbextra = NULL;
int verbosity = 0;
static struct option long_options[] = {
{ "config", required_argument, NULL, 'c' },
{ "dbpath", required_argument, NULL, 0 },
{ "dbextra", required_argument, NULL, 0 },
{ "daemon", required_argument, NULL, 0 },
{ "debug", optional_argument, NULL, 'd' },
{ "help", no_argument, NULL, '?' },
{ "version", no_argument, NULL, 0 },
{ "verbose", optional_argument, NULL, 'v' },
{ "readonly", no_argument, NULL, 'r' },
{ "single-user", no_argument, NULL, 0 },
{ "set", required_argument, NULL, 's' },
{ "threads", no_argument, NULL, 0 },
{ "memory", no_argument, NULL, 0 },
{ "properties", no_argument, NULL, 0 },
{ "io", no_argument, NULL, 0 },
{ "transactions", no_argument, NULL, 0 },
{ "trace", optional_argument, NULL, 't' },
{ "modules", no_argument, NULL, 0 },
{ "algorithms", no_argument, NULL, 0 },
{ "optimizers", no_argument, NULL, 0 },
{ "performance", no_argument, NULL, 0 },
{ "forcemito", no_argument, NULL, 0 },
{ "heaps", no_argument, NULL, 0 },
{ NULL, 0, NULL, 0 }
};
#if defined(_MSC_VER) && defined(__cplusplus)
set_terminate(mserver_abort);
#endif
#ifdef _MSC_VER
_CrtSetReportMode(_CRT_ERROR, 0);
_CrtSetReportMode(_CRT_ASSERT, 0);
_set_invalid_parameter_handler(mserver_invalid_parameter_handler);
#ifdef _TWO_DIGIT_EXPONENT
_set_output_format(_TWO_DIGIT_EXPONENT);
#endif
#endif
if (setlocale(LC_CTYPE, "") == NULL) {
fprintf(stderr, "cannot set locale\n");
exit(1);
}
if (getcwd(monet_cwd, FILENAME_MAX - 1) == NULL) {
perror("pwd");
fprintf(stderr,"monet_init: could not determine current directory\n");
exit(-1);
}
/* retrieve binpath early (before monet_init) because some
* implementations require the working directory when the binary was
* called */
binpath = get_bin_path();
if (!(setlen = mo_builtin_settings(&set)))
usage(prog, -1);
for (;;) {
int option_index = 0;
int c = getopt_long(argc, av, "c:d::rs:t::v::?",
long_options, &option_index);
if (c == -1)
break;
switch (c) {
case 0:
if (strcmp(long_options[option_index].name, "dbpath") == 0) {
size_t optarglen = strlen(optarg);
/* remove trailing directory separator */
while (optarglen > 0 &&
(optarg[optarglen - 1] == '/' ||
optarg[optarglen - 1] == '\\'))
optarg[--optarglen] = '\0';
dbpath = absolute_path(optarg);
if( dbpath == NULL)
fprintf(stderr, "#error: can not allocate memory for dbpath\n");
else
setlen = mo_add_option(&set, setlen, opt_cmdline, "gdk_dbpath", dbpath);
break;
}
if (strcmp(long_options[option_index].name, "dbextra") == 0) {
if (dbextra)
fprintf(stderr, "#warning: ignoring multiple --dbextra arguments\n");
else
dbextra = optarg;
break;
}
#ifdef HAVE_CONSOLE
if (strcmp(long_options[option_index].name, "daemon") == 0) {
setlen = mo_add_option(&set, setlen, opt_cmdline, "monet_daemon", optarg);
break;
}
#endif
if (strcmp(long_options[option_index].name, "single-user") == 0) {
setlen = mo_add_option(&set, setlen, opt_cmdline, "gdk_single_user", "yes");
break;
}
if (strcmp(long_options[option_index].name, "version") == 0) {
monet_version();
exit(0);
}
/* debugging options */
if (strcmp(long_options[option_index].name, "properties") == 0) {
grpdebug |= GRPproperties;
break;
}
if (strcmp(long_options[option_index].name, "algorithms") == 0) {
grpdebug |= GRPalgorithms;
break;
}
if (strcmp(long_options[option_index].name, "optimizers") == 0) {
grpdebug |= GRPoptimizers;
break;
}
if (strcmp(long_options[option_index].name, "forcemito") == 0) {
grpdebug |= GRPforcemito;
break;
}
if (strcmp(long_options[option_index].name, "performance") == 0) {
grpdebug |= GRPperformance;
break;
}
if (strcmp(long_options[option_index].name, "io") == 0) {
grpdebug |= GRPio;
break;
}
if (strcmp(long_options[option_index].name, "memory") == 0) {
grpdebug |= GRPmemory;
break;
}
if (strcmp(long_options[option_index].name, "modules") == 0) {
grpdebug |= GRPmodules;
break;
}
if (strcmp(long_options[option_index].name, "transactions") == 0) {
grpdebug |= GRPtransactions;
break;
}
if (strcmp(long_options[option_index].name, "threads") == 0) {
grpdebug |= GRPthreads;
break;
}
if (strcmp(long_options[option_index].name, "trace") == 0) {
mal_trace = 1;
break;
}
if (strcmp(long_options[option_index].name, "heaps") == 0) {
grpdebug |= GRPheaps;
break;
}
usage(prog, -1);
/* not reached */
case 'c':
/* coverity[var_deref_model] */
setlen = mo_add_option(&set, setlen, opt_cmdline, "config", optarg);
break;
case 'd':
if (optarg) {
char *endarg;
debug |= strtol(optarg, &endarg, 10);
if (*endarg != '\0') {
fprintf(stderr, "ERROR: wrong format for --debug=%s\n",
optarg);
usage(prog, -1);
}
} else {
debug |= 1;
}
break;
case 'r':
setlen = mo_add_option(&set, setlen, opt_cmdline, "gdk_readonly", "yes");
break;
case 's': {
/* should add option to a list */
/* coverity[var_deref_model] */
char *tmp = strchr(optarg, '=');
if (tmp) {
*tmp = '\0';
setlen = mo_add_option(&set, setlen, opt_cmdline, optarg, tmp + 1);
} else
fprintf(stderr, "ERROR: wrong format %s\n", optarg);
}
break;
case 't':
mal_trace = 1;
break;
case 'v':
if (optarg) {
char *endarg;
verbosity = (int) strtol(optarg, &endarg, 10);
if (*endarg != '\0') {
fprintf(stderr, "ERROR: wrong format for --verbose=%s\n",
optarg);
usage(prog, -1);
}
} else {
verbosity++;
}
break;
case '?':
/* a bit of a hack: look at the option that the
current `c' is based on and see if we recognize
it: if -? or --help, exit with 0, else with -1 */
usage(prog, strcmp(av[optind - 1], "-?") == 0 || strcmp(av[optind - 1], "--help") == 0 ? 0 : -1);
default:
fprintf(stderr, "ERROR: getopt returned character "
"code '%c' 0%o\n", c, (uint8_t) c);
usage(prog, -1);
}
}
if (!(setlen = mo_system_config(&set, setlen)))
usage(prog, -1);
GDKsetdebug(debug | grpdebug); /* add the algorithm tracers */
if (debug)
mo_print_options(set, setlen);
GDKsetverbose(verbosity);
monet_script = (str *) malloc(sizeof(str) * (argc + 1));
if (monet_script == NULL) {
fprintf(stderr, "!ERROR: cannot allocate memory for script \n");
exit(1);
}
i = 0;
while (optind < argc) {
monet_script[i] = absolute_path(av[optind]);
if (monet_script[i] == NULL) {
fprintf(stderr, "!ERROR: cannot allocate memory for script \n");
exit(1);
}
i++;
optind++;
}
monet_script[i] = NULL;
if (!dbpath) {
dbpath = absolute_path(mo_find_option(set, setlen, "gdk_dbpath"));
if (!dbpath) {
fprintf(stderr, "!ERROR: cannot allocate memory for database directory \n");
exit(1);
}
}
if (BBPaddfarm(dbpath, 1 << PERSISTENT) != GDK_SUCCEED ||
BBPaddfarm(dbextra ? dbextra : dbpath, 1 << TRANSIENT) != GDK_SUCCEED) {
fprintf(stderr, "!ERROR: cannot add farm\n");
exit(1);
}
if (GDKcreatedir(dbpath) != GDK_SUCCEED) {
fprintf(stderr, "!ERROR: cannot create directory for %s\n", dbpath);
exit(1);
}
GDKfree(dbpath);
if (monet_init(set, setlen) == 0) {
mo_free_options(set, setlen);
if (GDKerrbuf && *GDKerrbuf)
fprintf(stderr, "%s\n", GDKerrbuf);
exit(1);
}
mo_free_options(set, setlen);
if (GDKsetenv("monet_version", GDKversion()) != GDK_SUCCEED ||
GDKsetenv("monet_release",
#ifdef MONETDB_RELEASE
MONETDB_RELEASE
#else
"unreleased"
#endif
) != GDK_SUCCEED) {
fprintf(stderr, "!ERROR: GDKsetenv failed\n");
exit(1);
}
if ((modpath = GDKgetenv("monet_mod_path")) == NULL) {
/* start probing based on some heuristics given the binary
* location:
* bin/mserver5 -> ../
* libX/monetdb5/lib/
* probe libX = lib, lib32, lib64, lib/64 */
size_t pref;
/* "remove" common prefix of configured BIN and LIB
* directories from LIBDIR */
for (pref = 0; LIBDIR[pref] != 0 && BINDIR[pref] == LIBDIR[pref]; pref++)
;
const char *libdirs[] = {
&LIBDIR[pref],
"lib",
"lib64",
"lib/64",
"lib32",
NULL,
};
struct stat sb;
if (binpath != NULL) {
char *p = strrchr(binpath, DIR_SEP);
if (p != NULL)
*p = '\0';
p = strrchr(binpath, DIR_SEP);
if (p != NULL) {
*p = '\0';
for (i = 0; libdirs[i] != NULL; i++) {
int len = snprintf(prmodpath, sizeof(prmodpath), "%s%c%s%cmonetdb5",
binpath, DIR_SEP, libdirs[i], DIR_SEP);
if (len == -1 || len >= FILENAME_MAX)
continue;
if (stat(prmodpath, &sb) == 0) {
modpath = prmodpath;
break;
}
}
} else {
printf("#warning: unusable binary location, "
"please use --set monet_mod_path=/path/to/... to "
"allow finding modules\n");
fflush(NULL);
}
} else {
printf("#warning: unable to determine binary location, "
"please use --set monet_mod_path=/path/to/... to "
"allow finding modules\n");
fflush(NULL);
}
if (modpath != NULL &&
GDKsetenv("monet_mod_path", modpath) != GDK_SUCCEED) {
fprintf(stderr, "!ERROR: GDKsetenv failed\n");
exit(1);
}
}
/* configure sabaoth to use the right dbpath and active database */
msab_dbpathinit(GDKgetenv("gdk_dbpath"));
/* wipe out all cruft, if left over */
if ((err = msab_wildRetreat()) != NULL) {
/* just swallow the error */
free(err);
}
/* From this point, the server should exit cleanly. Discussion:
* even earlier? Sabaoth here registers the server is starting up. */
if ((err = msab_registerStarting()) != NULL) {
/* throw the error at the user, but don't die */
fprintf(stderr, "!%s\n", err);
free(err);
}
#ifdef HAVE_SIGACTION
{
struct sigaction sa;
(void) sigemptyset(&sa.sa_mask);
sa.sa_flags = 0;
sa.sa_handler = handler;
if (sigaction(SIGINT, &sa, NULL) == -1 ||
sigaction(SIGQUIT, &sa, NULL) == -1 ||
sigaction(SIGTERM, &sa, NULL) == -1) {
fprintf(stderr, "!unable to create signal handlers\n");
}
}
#else
#ifdef _MSC_VER
if (!SetConsoleCtrlHandler(winhandler, TRUE))
fprintf(stderr, "!unable to create console control handler\n");
#else
if(signal(SIGINT, handler) == SIG_ERR)
fprintf(stderr, "!unable to create signal handlers\n");
#ifdef SIGQUIT
if(signal(SIGQUIT, handler) == SIG_ERR)
fprintf(stderr, "!unable to create signal handlers\n");
#endif
if(signal(SIGTERM, handler) == SIG_ERR)
fprintf(stderr, "!unable to create signal handlers\n");
#endif
#endif
{
str lang = "mal";
/* we inited mal before, so publish its existence */
if ((err = msab_marchScenario(lang)) != NULL) {
/* throw the error at the user, but don't die */
fprintf(stderr, "!%s\n", err);
free(err);
}
}
{
/* unlock the vault, first see if we can find the file which
* holds the secret */
char secret[1024];
char *secretp = secret;
FILE *secretf;
size_t len;
if (GDKgetenv("monet_vault_key") == NULL) {
/* use a default (hard coded, non safe) key */
snprintf(secret, sizeof(secret), "%s", "Xas632jsi2whjds8");
} else {
if ((secretf = fopen(GDKgetenv("monet_vault_key"), "r")) == NULL) {
fprintf(stderr,
"unable to open vault_key_file %s: %s\n",
GDKgetenv("monet_vault_key"), strerror(errno));
/* don't show this as a crash */
msab_registerStop();
exit(1);
}
len = fread(secret, 1, sizeof(secret), secretf);
secret[len] = '\0';
len = strlen(secret); /* secret can contain null-bytes */
if (len == 0) {
fprintf(stderr, "vault key has zero-length!\n");
/* don't show this as a crash */
msab_registerStop();
exit(1);
} else if (len < 5) {
fprintf(stderr, "#warning: your vault key is too short "
"(%zu), enlarge your vault key!\n", len);
}
fclose(secretf);
}
if ((err = AUTHunlockVault(secretp)) != MAL_SUCCEED) {
/* don't show this as a crash */
msab_registerStop();
fprintf(stderr, "%s\n", err);
freeException(err);
exit(1);
}
}
/* make sure the authorisation BATs are loaded */
if ((err = AUTHinitTables(NULL)) != MAL_SUCCEED) {
/* don't show this as a crash */
msab_registerStop();
fprintf(stderr, "%s\n", err);
freeException(err);
exit(1);
}
if (mal_init()) {
/* don't show this as a crash */
msab_registerStop();
return 0;
}
if((err = MSinitClientPrg(mal_clients, "user", "main")) != MAL_SUCCEED) {
msab_registerStop();
fprintf(stderr, "%s\n", err);
freeException(err);
exit(1);
}
emergencyBreakpoint();
for (i = 0; monet_script[i]; i++) {
str msg = evalFile(monet_script[i], listing);
/* check for internal exception message to terminate */
if (msg) {
if (strcmp(msg, "MALException:client.quit:Server stopped.") == 0)
mal_exit(0);
fprintf(stderr, "#%s: %s\n", monet_script[i], msg);
freeException(msg);
}
GDKfree(monet_script[i]);
monet_script[i] = 0;
}
free(monet_script);
if ((err = msab_registerStarted()) != NULL) {
/* throw the error at the user, but don't die */
fprintf(stderr, "!%s\n", err);
free(err);
}
#ifdef HAVE_CONSOLE
if (!monet_daemon) {
MSserveClient(mal_clients);
} else
#endif
while (!interrupted && !GDKexiting()) {
MT_sleep_ms(100);
}
/* mal_exit calls exit, so statements after this call will
* never get reached */
mal_exit(0);
return 0;
}
int __cdecl _tmain(int argc, const TCHAR* argv[], const TCHAR* envp[])
{
int ret = 0;
if (CheckEpoch())
return 1;
cTWInit twInit;
try
{
// set unexpected and terminate handlers
// Note: we do this before Init() in case it attempts to call these handlers
// TODO: move this into the Init() routine
EXCEPTION_NAMESPACE set_terminate(tw_terminate_handler);
EXCEPTION_NAMESPACE set_unexpected(tw_unexpected_handler);
twInit.Init(argv[0]);
TSS_Dependency(cTWAdmin);
// set up the debug output
cDebug::SetDebugLevel(cDebug::D_DEBUG);
// first, get the right mode...
TW_UNIQUE_PTR<iTWAMode> pMode(cTWAdminCmdLine::GetMode(argc, argv));
if (!pMode.get())
{
// no valid mode passed; GetMode will display an appropriate string (include usage statement)
ret = 1;
goto exit;
}
// if version was requested, output version string and exit
if (pMode.get()->GetModeID() == cTWAdminCmdLine::MODE_VERSION)
{
TCOUT << TSS_GetString(cTW, tw::STR_VERSION_LONG) << std::endl;
ret = 0;
goto exit;
}
// process the command line
cCmdLineParser cmdLine;
pMode->InitCmdLineParser(cmdLine);
try
{
cmdLine.Parse(argc, argv);
}
catch (eError& e)
{
cTWUtil::PrintErrorMsg(e);
TCERR << TSS_GetString(cTW, tw::STR_GET_HELP) << std::endl;
ret = 1;
goto exit;
}
// erase the command line
// TODO: it might be a good idea to move this to cTWUtil
int i;
for (i = 1; i < argc; ++i)
memset((char*)argv[i], 0, strlen(argv[i]) * sizeof(TCHAR));
cCmdLineIter iter(cmdLine);
if (iter.SeekToArg(cTWAdminCmdLine::HELP))
{
TCOUT << TSS_GetString(cTWAdmin, twadmin::STR_TWADMIN_VERSION) << std::endl;
TCOUT << TSS_GetString(cTW, tw::STR_VERSION) << std::endl;
//Output a mode specific usage statement
TCOUT << pMode->GetModeUsage();
ret = 1;
goto exit;
}
if (iter.SeekToArg(cTWAdminCmdLine::VERBOSE))
{
TCERR << TSS_GetString(cTW, tw::STR_VERSION) << std::endl;
}
// open up the config file, possibly using the passed in path
cConfigFile config;
bool configFileOpened = false;
cErrorBucketNull errorNull; // don't spit errors to the user
if (pMode->GetModeID() != cTWAdminCmdLine::MODE_GENERATE_KEYS &&
pMode->GetModeID() != cTWAdminCmdLine::MODE_CHANGE_PASSPHRASES &&
pMode->GetModeID() != cTWAdminCmdLine::MODE_CREATE_CONFIG &&
pMode->GetModeID() != cTWAdminCmdLine::MODE_PRINT_CONFIG &&
pMode->GetModeID() != cTWAdminCmdLine::MODE_HELP)
{
try
{
//open cfg file
TSTRING cfgPath;
cTWUtil::OpenConfigFile(config, cmdLine, cTWAdminCmdLine::CFG_FILE, errorNull, cfgPath);
pMode->SetCfgFilePath(cfgPath);
configFileOpened = true;
}
catch (eError& error)
{
TSTRING extra;
extra += TSS_GetString(cTW, tw::STR_NEWLINE);
extra += TSS_GetString(cTWAdmin, twadmin::STR_ERR2_CONFIG_OPEN);
cTWUtil::PrintErrorMsg(error, extra);
ret = 1;
goto exit;
}
}
// ok, now we can initialize the mode object and have it execute
if (!pMode->Init(configFileOpened ? &config : NULL, cmdLine))
{
TCERR << TSS_GetString(cTW, tw::STR_GET_HELP) << std::endl;
ret = 1;
goto exit;
}
ret = pMode->Execute(&twInit.errorQueue);
} //end try block
catch (eError& error)
{
cTWUtil::PrintErrorMsg(error);
ASSERT(false);
ret = 1;
}
catch (std::bad_alloc& e)
{
TCERR << _T("*** Fatal exception: Out of memory ");
TCERR << _T("*** Exiting...\n");
ret = 1;
}
catch (std::exception& e)
{
TCERR << _T("*** Fatal exception: ");
std::cerr << e.what() << std::endl;
TCERR << _T("*** Exiting...\n");
ret = 1;
}
/*
catch (...)
{
TCERR << _T("*** Fatal exception occurred.\n");
TCERR << _T("*** Exiting...\n");
ret = 1;
}
*/
exit:
return ret;
}
///////////////////////////////////////////////////////////////////////////////
// main
///////////////////////////////////////////////////////////////////////////////
int __cdecl _tmain( int argc, const TCHAR* argv[ ], const TCHAR* envp[ ] )
{
if (TimeBombExploded())
return 8;
int ret = 0;
cTWInit twInit;
try
{
// set unexpected and terminate handlers
// Note: we do this before Init() in case it attempts to call these handlers
// TODO: move this into the Init() routine
EXCEPTION_NAMESPACE set_terminate(tw_terminate_handler);
EXCEPTION_NAMESPACE set_unexpected(tw_unexpected_handler);
// Initialization
//
twInit.Init( argv[0] );
TSS_Dependency( cTripwire );
// set up the debug output
cDebug::SetDebugLevel( cDebug::D_DEBUG/*D_DETAIL*//*D_NEVER*/ );
// first, get the right mode...
std::auto_ptr<iTWMode> pMode(cTWCmdLine::GetMode(argc, argv));
if(! pMode.get())
{
// no valid mode passed; GetMode will display an appropriate string (include usage statement)
ret = 8;
goto exit;
}
// if version was requested, output version string and exit
if (pMode.get()->GetModeID() == cTWCmdLine::MODE_VERSION)
{
TCOUT << TSS_GetString( cTW, tw::STR_VERSION_LONG) << std::endl;
ret = 0;
goto exit;
}
// process the command line
cCmdLineParser cmdLine;
pMode->InitCmdLineParser(cmdLine);
try
{
cmdLine.Parse(argc, argv);
}
catch( eError& e )
{
cTWUtil::PrintErrorMsg(e);
TCERR << TSS_GetString( cTW, tw::STR_GET_HELP) << std::endl;
ret = 8;
goto exit;
}
TSTRING commandLine = util_GetWholeCmdLine( argc, argv );
#if IS_UNIX
// erase the command line
// TODO: it might be a good idea to move this to cTWUtil
int i;
for (i = 1; i < argc; ++i)
memset((char*)argv[i], 0, strlen(argv[i])*sizeof(TCHAR));
#endif
cCmdLineIter iter(cmdLine);
if (iter.SeekToArg(cTWCmdLine::HELP))
{
TCOUT << TSS_GetString( cTripwire, tripwire::STR_TRIPWIRE_VERSION) << std::endl;
TCOUT << TSS_GetString( cTW, tw::STR_VERSION) << std::endl;
//
//Since --help was passed, exit after emitting a mode-specific usage statement.
TCOUT << pMode->GetModeUsage();
ret = 8;
goto exit;
}
if (iter.SeekToArg(cTWCmdLine::VERBOSE))
{
TCOUT << TSS_GetString( cTW, tw::STR_VERSION) << std::endl;
}
// open up the config file, possibly using the passed in path
cConfigFile config;
TSTRING strConfigFile;
cErrorReporter errorReporter;
if( pMode->GetModeID() != cTWCmdLine::MODE_HELP )
{
try
{
//open cfg file
cTWUtil::OpenConfigFile(config, cmdLine, cTWCmdLine::CFG_FILE, errorReporter, strConfigFile);
}
catch (eError& error)
{
TSTRING extra;
extra += TSS_GetString( cTW, tw::STR_NEWLINE);
extra += TSS_GetString( cTW, tw::STR_ERR_TWCFG_CANT_READ);
cTWUtil::PrintErrorMsg( error, extra );
ret = 8;
goto exit;
}
}
// ok, now we can initialize the mode object and have it execute
pMode->SetCmdLine( commandLine );
pMode->SetConfigFile( strConfigFile );
if(! pMode->Init(config, cmdLine))
{
TCERR << TSS_GetString( cTW, tw::STR_GET_HELP) << std::endl;
ret = 8;
goto exit;
}
ret = pMode->Execute(&twInit.errorQueue);
}//end try block
catch (eError& error)
{
cTWUtil::PrintErrorMsg(error);
ASSERT(false);
ret = 8;
}
catch (std::bad_alloc e)
{
// Note: We use fputs rather than TCERR as it will probably require the
// least amount of memory to do its thing. If we ran out of memory we
// need to do everything we can to get this string out to the user.
fputs("*** Fatal exception: Out of memory\n", stderr);
fputs("*** Exiting...\n", stderr);
ret = 8;
}
catch (std::exception e)
{
TCERR << _T("*** Fatal exception: ");
std::cerr << e.what() << std::endl;
TCERR << _T("*** Exiting...\n");
ret = 8;
}
/*
catch (...)
{
TCERR << _T("*** Fatal exception occurred.\n");
TCERR << _T("*** Exiting...\n");
ret = 8;
}
*/
exit:
// print out the max memory usage...
/*
#ifdef _DEBUG
TCOUT << _T("Maximum memory footprint = ") << gMaxAlloc << std::endl;
#endif
*/
return ret;
} //end MAIN
int __cdecl _tmain(int argc, const TCHAR** argv)
{
int ret = 0;
if (CheckEpoch())
return 1;
try
{
// set unexpected and terminate handlers
// Note: we do this before Init() in case it attempts to call these handlers
// TODO: move this into the Init() routine
EXCEPTION_NAMESPACE set_terminate(tw_terminate_handler);
EXCEPTION_NAMESPACE set_unexpected(tw_unexpected_handler);
//cTWInit twInit( argv[0] );
SiggenInit();
cDebug::SetDebugLevel(cDebug::D_DETAIL);
cSiggenCmdLine siggen;
// first, process the command line
if (argc < 2)
{
TCOUT << TSS_GetString(cSiggen, siggen::STR_SIGGEN_VERSION) << std::endl;
TCOUT << TSS_GetString(cTW, tw::STR_VERSION) << std::endl;
TCOUT << TSS_GetString(cTW, tw::STR_GET_HELP) << std::endl;
ret = 1;
goto exit;
}
//
// Display the version info...
// this is quick and dirty ... just the way I like it :-) -- mdb
//
if (_tcscmp(argv[1], _T("--version")) == 0)
{
TCOUT << TSS_GetString(cTW, tw::STR_VERSION_LONG) << std::endl;
ret = 0;
goto exit;
}
cCmdLineParser cmdLine;
siggen.InitCmdLineParser(cmdLine);
try
{
cmdLine.Parse(argc, argv);
}
catch (eError& e)
{
cTWUtil::PrintErrorMsg(e);
TCERR << TSS_GetString(cTW, tw::STR_GET_HELP) << std::endl;
ret = 1;
goto exit;
}
cCmdLineIter iter(cmdLine);
if (iter.SeekToArg(cSiggenCmdLine::HELP))
{
TCOUT << TSS_GetString(cSiggen, siggen::STR_SIGGEN_VERSION) << std::endl;
TCOUT << TSS_GetString(cTW, tw::STR_VERSION) << std::endl;
TCOUT << TSS_GetString(cSiggen, siggen::STR_SIGGEN_USAGE) << std::endl;
ret = 1;
goto exit;
}
if (!siggen.Init(cmdLine))
{
TCOUT << TSS_GetString(cSiggen, siggen::STR_SIGGEN_VERSION) << std::endl;
TCOUT << TSS_GetString(cTW, tw::STR_VERSION) << std::endl;
TCOUT << TSS_GetString(cSiggen, siggen::STR_SIGGEN_USAGE) << std::endl;
ret = 1;
goto exit;
}
ret = siggen.Execute();
} //end try block
catch (eError& error)
{
cErrorReporter::PrintErrorMsg(error);
ASSERT(false);
}
exit:
return ret;
} //end MAIN
int main(int argc, char *argv[]) {
#if defined(__GNUC__)
set_terminate(SLGTerminate);
#endif
try {
cerr << "Usage: " << argv[0] << " [options] [configuration file]" << endl <<
" -o [configuration file]" << endl <<
" -f [scene file]" << endl <<
" -w [window width]" << endl <<
" -e [window height]" << endl <<
" -g <disable OpenCL GPU device>" << endl <<
" -p <enable OpenCL CPU device>" << endl <<
" -n [native thread count]" << endl <<
" -r [gpu thread count]" << endl <<
" -l [set high/low latency mode]" << endl <<
" -b <enable high latency mode>" << endl <<
" -s [GPU workgroup size]" << endl <<
" -t [halt time in secs]" << endl <<
" -T <enable the telnet server>" << endl <<
" -D [property name] [property value]" << endl <<
" -d [current directory path]" << endl <<
" -h <display this help and exit>" << endl;
// Initialize FreeImage Library
FreeImage_Initialise(TRUE);
FreeImage_SetOutputMessage(FreeImageErrorHandler);
bool batchMode = false;
bool telnetServerEnabled = false;
Properties cmdLineProp;
for (int i = 1; i < argc; i++) {
if (argv[i][0] == '-') {
// I should check for out of range array index...
if (argv[i][1] == 'h') exit(EXIT_SUCCESS);
else if (argv[i][1] == 'o') {
if (config)
throw runtime_error("Used multiple configuration files");
config = new RenderingConfig(argv[++i]);
}
else if (argv[i][1] == 'e') cmdLineProp.SetString("image.height", argv[++i]);
else if (argv[i][1] == 'w') cmdLineProp.SetString("image.width", argv[++i]);
else if (argv[i][1] == 'f') cmdLineProp.SetString("scene.file", argv[++i]);
else if (argv[i][1] == 'p') cmdLineProp.SetString("opencl.cpu.use", "1");
else if (argv[i][1] == 'g') cmdLineProp.SetString("opencl.gpu.use", "0");
else if (argv[i][1] == 'l') cmdLineProp.SetString("opencl.latency.mode", argv[++i]);
else if (argv[i][1] == 'n') cmdLineProp.SetString("opencl.nativethread.count", argv[++i]);
else if (argv[i][1] == 'r') cmdLineProp.SetString("opencl.renderthread.count", argv[++i]);
else if (argv[i][1] == 's') cmdLineProp.SetString("opencl.gpu.workgroup.size", argv[++i]);
else if (argv[i][1] == 't') cmdLineProp.SetString("batch.halttime", argv[++i]);
else if (argv[i][1] == 'T') telnetServerEnabled = true;
else if (argv[i][1] == 'D') {
cmdLineProp.SetString(argv[i + 1], argv[i + 2]);
i += 2;
}
else if (argv[i][1] == 'd') boost::filesystem::current_path(boost::filesystem::path(argv[++i]));
else {
cerr << "Invalid option: " << argv[i] << endl;
exit(EXIT_FAILURE);
}
} else {
string s = argv[i];
if ((s.length() >= 4) && (s.substr(s.length() - 4) == ".cfg")) {
if (config)
throw runtime_error("Used multiple configuration files");
config = new RenderingConfig(s);
} else
throw runtime_error("Unknow file extension: " + s);
}
}
if (!config)
config = new RenderingConfig("scenes/luxball/render-fast.cfg");
config->cfg.Load(cmdLineProp);
const unsigned int halttime = config->cfg.GetInt("batch.halttime", 0);
const unsigned int haltspp = config->cfg.GetInt("batch.haltspp", 0);
if ((halttime > 0) || (haltspp > 0))
batchMode = true;
else
batchMode = false;
if (batchMode) {
config->Init();
return BatchMode(halttime, haltspp);
} else {
// It is important to initialize OpenGL before OpenCL
unsigned int width = config->cfg.GetInt("image.width", 640);
unsigned int height = config->cfg.GetInt("image.height", 480);
InitGlut(argc, argv, width, height);
config->Init();
if (telnetServerEnabled) {
TelnetServer telnetServer(18081, config);
RunGlut();
} else
RunGlut();
}
#if !defined(LUXRAYS_DISABLE_OPENCL)
} catch (cl::Error err) {
cerr << "OpenCL ERROR: " << err.what() << "(" << err.err() << ")" << endl;
#endif
} catch (runtime_error err) {
cerr << "RUNTIME ERROR: " << err.what() << endl;
} catch (exception err) {
cerr << "ERROR: " << err.what() << endl;
}
return EXIT_SUCCESS;
}
/** Initialize the driver. Sets signal handlers for SIGINT and SIGSEGV. */
void cvc4_init()
{
#ifdef CVC4_DEBUG
LastExceptionBuffer::setCurrent(new LastExceptionBuffer());
#endif
#ifndef __WIN32__
struct rlimit limit;
if(getrlimit(RLIMIT_STACK, &limit)) {
throw Exception(string("getrlimit() failure: ") + strerror(errno));
}
if(limit.rlim_cur != limit.rlim_max) {
limit.rlim_cur = limit.rlim_max;
if(setrlimit(RLIMIT_STACK, &limit)) {
throw Exception(string("setrlimit() failure: ") + strerror(errno));
}
if(getrlimit(RLIMIT_STACK, &limit)) {
throw Exception(string("getrlimit() failure: ") + strerror(errno));
}
}
struct sigaction act1;
act1.sa_sigaction = sigint_handler;
act1.sa_flags = SA_SIGINFO;
sigemptyset(&act1.sa_mask);
if(sigaction(SIGINT, &act1, NULL)) {
throw Exception(string("sigaction(SIGINT) failure: ") + strerror(errno));
}
struct sigaction act2;
act2.sa_sigaction = timeout_handler;
act2.sa_flags = SA_SIGINFO;
sigemptyset(&act2.sa_mask);
if(sigaction(SIGXCPU, &act2, NULL)) {
throw Exception(string("sigaction(SIGXCPU) failure: ") + strerror(errno));
}
struct sigaction act3;
act3.sa_sigaction = ill_handler;
act3.sa_flags = SA_SIGINFO;
sigemptyset(&act3.sa_mask);
if(sigaction(SIGILL, &act3, NULL)) {
throw Exception(string("sigaction(SIGILL) failure: ") + strerror(errno));
}
#ifdef HAVE_SIGALTSTACK
stack_t ss;
ss.ss_sp = (char*) malloc(SIGSTKSZ);
if(ss.ss_sp == NULL) {
throw Exception("Can't malloc() space for a signal stack");
}
ss.ss_size = SIGSTKSZ;
ss.ss_flags = 0;
if(sigaltstack(&ss, NULL) == -1) {
throw Exception(string("sigaltstack() failure: ") + strerror(errno));
}
cvc4StackSize = limit.rlim_cur;
cvc4StackBase = ss.ss_sp;
struct sigaction act4;
act4.sa_sigaction = segv_handler;
act4.sa_flags = SA_SIGINFO | SA_ONSTACK;
sigemptyset(&act4.sa_mask);
if(sigaction(SIGSEGV, &act4, NULL)) {
throw Exception(string("sigaction(SIGSEGV) failure: ") + strerror(errno));
}
#endif /* HAVE_SIGALTSTACK */
struct sigaction act5;
act5.sa_sigaction = sigterm_handler;
act5.sa_flags = SA_SIGINFO;
sigemptyset(&act5.sa_mask);
if (sigaction(SIGTERM, &act5, NULL))
{
throw Exception(string("sigaction(SIGTERM) failure: ") + strerror(errno));
}
#endif /* __WIN32__ */
set_unexpected(cvc4unexpected);
default_terminator = set_terminate(cvc4terminate);
}
void terminate() noexcept
{
// Reset default in case terminate called recursively from within handler
set_terminate(_detail::_default_handler)();
}
// Installs C++ exception handlers that function on per-thread basis
int CCrashHandler::SetThreadExceptionHandlers(DWORD dwFlags)
{
crSetErrorMsg(_T("Unspecified error."));
// If 0 is specified as dwFlags, assume all available exception handlers should be
// installed
if((dwFlags&0x1FFF)==0)
dwFlags |= 0x1FFF;
DWORD dwThreadId = GetCurrentThreadId();
CAutoLock lock(&m_csThreadExceptionHandlers);
std::map<DWORD, ThreadExceptionHandlers>::iterator it =
m_ThreadExceptionHandlers.find(dwThreadId);
if(it!=m_ThreadExceptionHandlers.end())
{
// handlers are already set for the thread
ATLASSERT(0);
crSetErrorMsg(_T("Can't install handlers for current thread twice."));
return 1; // failed
}
ThreadExceptionHandlers handlers;
if(dwFlags&CR_INST_TERMINATE_HANDLER)
{
// Catch terminate() calls.
// In a multithreaded environment, terminate functions are maintained
// separately for each thread. Each new thread needs to install its own
// terminate function. Thus, each thread is in charge of its own termination handling.
// http://msdn.microsoft.com/en-us/library/t6fk7h29.aspx
handlers.m_prevTerm = set_terminate(TerminateHandler);
}
if(dwFlags&CR_INST_UNEXPECTED_HANDLER)
{
// Catch unexpected() calls.
// In a multithreaded environment, unexpected functions are maintained
// separately for each thread. Each new thread needs to install its own
// unexpected function. Thus, each thread is in charge of its own unexpected handling.
// http://msdn.microsoft.com/en-us/library/h46t5b69.aspx
handlers.m_prevUnexp = set_unexpected(UnexpectedHandler);
}
if(dwFlags&CR_INST_SIGFPE_HANDLER)
{
// Catch a floating point error
typedef void (*sigh)(int);
handlers.m_prevSigFPE = signal(SIGFPE, (sigh)SigfpeHandler);
}
if(dwFlags&CR_INST_SIGILL_HANDLER)
{
// Catch an illegal instruction
handlers.m_prevSigILL = signal(SIGILL, SigillHandler);
}
if(dwFlags&CR_INST_SIGSEGV_HANDLER)
{
// Catch illegal storage access errors
handlers.m_prevSigSEGV = signal(SIGSEGV, SigsegvHandler);
}
// Insert the structure to the list of handlers
m_ThreadExceptionHandlers[dwThreadId] = handlers;
// OK.
crSetErrorMsg(_T("Success."));
return 0;
}
int main(int argc, char *argv[]) {
#if defined(__GNUC__) && !defined(__CYGWIN__)
set_terminate(SLGTerminate);
#endif
// This is required to run AMD GPU profiler
//XInitThreads();
luxrays::sdl::LuxRaysSDLDebugHandler = SDLDebugHandler;
try {
// Initialize FreeImage Library
FreeImage_Initialise(TRUE);
FreeImage_SetOutputMessage(FreeImageErrorHandler);
bool batchMode = false;
bool telnetServerEnabled = false;
Properties cmdLineProp;
string configFileName;
for (int i = 1; i < argc; i++) {
if (argv[i][0] == '-') {
// I should check for out of range array index...
if (argv[i][1] == 'h') {
SLG_LOG("Usage: " << argv[0] << " [options] [configuration file]" << endl <<
" -o [configuration file]" << endl <<
" -f [scene file]" << endl <<
" -w [window width]" << endl <<
" -e [window height]" << endl <<
" -t [halt time in secs]" << endl <<
" -T <enable the telnet server>" << endl <<
" -D [property name] [property value]" << endl <<
" -d [current directory path]" << endl <<
" -m Makes the mouse operations work in \"grab mode\"" << endl <<
" -h <display this help and exit>");
exit(EXIT_SUCCESS);
}
else if (argv[i][1] == 'o') {
if (configFileName.compare("") != 0)
throw runtime_error("Used multiple configuration files");
configFileName = string(argv[++i]);
}
else if (argv[i][1] == 'e') cmdLineProp.SetString("image.height", argv[++i]);
else if (argv[i][1] == 'w') cmdLineProp.SetString("image.width", argv[++i]);
else if (argv[i][1] == 'f') cmdLineProp.SetString("scene.file", argv[++i]);
else if (argv[i][1] == 't') cmdLineProp.SetString("batch.halttime", argv[++i]);
else if (argv[i][1] == 'T') telnetServerEnabled = true;
else if (argv[i][1] == 'm') mouseGrabMode = true;
else if (argv[i][1] == 'D') {
cmdLineProp.SetString(argv[i + 1], argv[i + 2]);
i += 2;
}
else if (argv[i][1] == 'd') boost::filesystem::current_path(boost::filesystem::path(argv[++i]));
else {
SLG_LOG("Invalid option: " << argv[i]);
exit(EXIT_FAILURE);
}
} else {
string s = argv[i];
if ((s.length() >= 4) && (s.substr(s.length() - 4) == ".cfg")) {
if (configFileName.compare("") != 0)
throw runtime_error("Used multiple configuration files");
configFileName = s;
} else
throw runtime_error("Unknown file extension: " + s);
}
}
if (configFileName.compare("") == 0)
configFileName = "scenes/luxball/luxball.cfg";
RenderConfig *config = new RenderConfig(&configFileName, &cmdLineProp);
const unsigned int halttime = config->cfg.GetInt("batch.halttime", 0);
const unsigned int haltspp = config->cfg.GetInt("batch.haltspp", 0);
const float haltthreshold = config->cfg.GetFloat("batch.haltthreshold", -1.f);
if ((halttime > 0) || (haltspp > 0) || (haltthreshold >= 0.f))
batchMode = true;
else
batchMode = false;
if (batchMode) {
session = new RenderSession(config);
// Check if I have to do tile rendering
if (config->cfg.IsDefined("batch.tile"))
return BatchTileMode(haltspp, haltthreshold);
else
return BatchSimpleMode(halttime, haltspp, haltthreshold);
} else {
// It is important to initialize OpenGL before OpenCL
// (for OpenGL/OpenCL inter-operability)
u_int width, height;
config->GetScreenSize(&width, &height);
InitGlut(argc, argv, width, height);
session = new RenderSession(config);
// Start the rendering
session->Start();
if (telnetServerEnabled) {
TelnetServer telnetServer(18081, session);
RunGlut();
} else
RunGlut();
}
#if !defined(LUXRAYS_DISABLE_OPENCL)
} catch (cl::Error err) {
SLG_LOG("OpenCL ERROR: " << err.what() << "(" << luxrays::utils::oclErrorString(err.err()) << ")");
return EXIT_FAILURE;
#endif
} catch (runtime_error err) {
SLG_LOG("RUNTIME ERROR: " << err.what());
return EXIT_FAILURE;
} catch (exception err) {
SLG_LOG("ERROR: " << err.what());
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
int
main(int argc, char **av)
{
char *prog = *av;
opt *set = NULL;
int idx = 0, grpdebug = 0, debug = 0, setlen = 0, listing = 0, i = 0;
str dbinit = NULL;
str err = MAL_SUCCEED;
char prmodpath[1024];
char *modpath = NULL;
char *binpath = NULL;
str *monet_script;
static struct option long_options[] = {
{ "config", 1, 0, 'c' },
{ "dbpath", 1, 0, 0 },
{ "dbinit", 1, 0, 0 },
{ "debug", 2, 0, 'd' },
{ "help", 0, 0, '?' },
{ "version", 0, 0, 0 },
{ "readonly", 0, 0, 'r' },
{ "set", 1, 0, 's' },
{ "threads", 0, 0, 0 },
{ "memory", 0, 0, 0 },
{ "properties", 0, 0, 0 },
{ "io", 0, 0, 0 },
{ "transactions", 0, 0, 0 },
{ "trace", 2, 0, 't' },
{ "modules", 0, 0, 0 },
{ "algorithms", 0, 0, 0 },
{ "optimizers", 0, 0, 0 },
{ "performance", 0, 0, 0 },
#if 0
{ "xproperties", 0, 0, 0 },
#endif
{ "forcemito", 0, 0, 0 },
{ "heaps", 0, 0, 0 },
{ 0, 0, 0, 0 }
};
#if defined(_MSC_VER) && defined(__cplusplus)
set_terminate(mserver_abort);
#endif
if (setlocale(LC_CTYPE, "") == NULL) {
GDKfatal("cannot set locale\n");
}
#ifdef HAVE_MALLOPT
if (malloc_init) {
/* for (Red Hat) Linux (6.2) unused and ignored at least as of glibc-2.1.3-15 */
/* for (Red Hat) Linux (8) used at least as of glibc-2.2.93-5 */
if (mallopt(M_MXFAST, 192)) {
fprintf(stderr, "!monet: mallopt(M_MXFAST,192) fails.\n");
}
#ifdef M_BLKSZ
if (mallopt(M_BLKSZ, 8 * 1024)) {
fprintf(stderr, "!monet: mallopt(M_BLKSZ,8*1024) fails.\n");
}
#endif
}
malloc_init = 0;
#else
(void) malloc_init; /* still unused */
#endif
if (getcwd(monet_cwd, PATHLENGTH - 1) == NULL) {
perror("pwd");
GDKfatal("monet_init: could not determine current directory\n");
}
/* retrieve binpath early (before monet_init) because some
* implementations require the working directory when the binary was
* called */
binpath = get_bin_path();
if (!(setlen = mo_builtin_settings(&set)))
usage(prog, -1);
setlen = mo_add_option(&set, setlen, opt_cmdline, "gdk_single_user", "yes");
for (;;) {
int option_index = 0;
int c = getopt_long(argc, av, "c:d::rs:t::?",
long_options, &option_index);
if (c == -1)
break;
switch (c) {
case 0:
if (strcmp(long_options[option_index].name, "dbpath") == 0) {
size_t optarglen = strlen(optarg);
/* remove trailing directory separator */
while (optarglen > 0 &&
(optarg[optarglen - 1] == '/' ||
optarg[optarglen - 1] == '\\'))
optarg[--optarglen] = '\0';
setlen = mo_add_option(&set, setlen, opt_cmdline, "gdk_dbpath", optarg);
break;
}
if (strcmp(long_options[option_index].name, "dbinit") == 0) {
if (dbinit)
fprintf(stderr, "#warning: ignoring multiple --dbinit argument\n");
else
dbinit = optarg;
break;
}
if (strcmp(long_options[option_index].name, "version") == 0) {
monet_version();
exit(0);
}
/* debugging options */
if (strcmp(long_options[option_index].name, "properties") == 0) {
grpdebug |= GRPproperties;
break;
}
if (strcmp(long_options[option_index].name, "algorithms") == 0) {
grpdebug |= GRPalgorithms;
break;
}
if (strcmp(long_options[option_index].name, "optimizers") == 0) {
grpdebug |= GRPoptimizers;
break;
}
#if 0
if (strcmp(long_options[option_index].name, "xproperties") == 0) {
grpdebug |= GRPxproperties;
break;
}
#endif
if (strcmp(long_options[option_index].name, "forcemito") == 0) {
grpdebug |= GRPforcemito;
break;
}
if (strcmp(long_options[option_index].name, "performance") == 0) {
grpdebug |= GRPperformance;
break;
}
if (strcmp(long_options[option_index].name, "io") == 0) {
grpdebug |= GRPio;
break;
}
if (strcmp(long_options[option_index].name, "memory") == 0) {
grpdebug |= GRPmemory;
break;
}
if (strcmp(long_options[option_index].name, "modules") == 0) {
grpdebug |= GRPmodules;
break;
}
if (strcmp(long_options[option_index].name, "transactions") == 0) {
grpdebug |= GRPtransactions;
break;
}
if (strcmp(long_options[option_index].name, "threads") == 0) {
grpdebug |= GRPthreads;
break;
}
if (strcmp(long_options[option_index].name, "trace") == 0) {
mal_trace = optarg? optarg:"ISTest";
break;
}
if (strcmp(long_options[option_index].name, "heaps") == 0) {
grpdebug |= GRPheaps;
break;
}
usage(prog, -1);
/* not reached */
case 'c':
setlen = mo_add_option(&set, setlen, opt_cmdline, "config", optarg);
break;
case 'd':
if (optarg) {
debug |= strtol(optarg, NULL, 10);
} else {
debug |= 1;
}
break;
case 'r':
setlen = mo_add_option(&set, setlen, opt_cmdline, "gdk_readonly", "yes");
break;
case 's': {
/* should add option to a list */
char *tmp = strchr(optarg, '=');
if (tmp) {
*tmp = '\0';
setlen = mo_add_option(&set, setlen, opt_cmdline, optarg, tmp + 1);
} else
fprintf(stderr, "ERROR: wrong format %s\n", optarg);
}
break;
case 't':
mal_trace = optarg? optarg:"ISTest";
break;
case '?':
/* a bit of a hack: look at the option that the
current `c' is based on and see if we recognize
it: if -? or --help, exit with 0, else with -1 */
usage(prog, strcmp(av[optind - 1], "-?") == 0 || strcmp(av[optind - 1], "--help") == 0 ? 0 : -1);
default:
fprintf(stderr, "ERROR: getopt returned character "
"code '%c' 0%o\n", c, c);
usage(prog, -1);
}
}
if (!(setlen = mo_system_config(&set, setlen)))
usage(prog, -1);
if (debug || grpdebug) {
long_str buf;
if (debug)
mo_print_options(set, setlen);
debug |= grpdebug; /* add the algorithm tracers */
snprintf(buf, sizeof(long_str) - 1, "%d", debug);
setlen = mo_add_option(&set, setlen, opt_cmdline, "gdk_debug", buf);
}
#ifdef RDEBUG
printf("parameter ok\n");
#endif
monet_script = (str *) malloc(sizeof(str) * (argc + 1));
if (monet_script) {
monet_script[idx] = NULL;
while (optind < argc) {
monet_script[idx] = absolute_path(av[optind]);
monet_script[idx + 1] = NULL;
optind++;
idx++;
}
}
if (monet_init(set, setlen) == 0) {
mo_free_options(set, setlen);
return 0;
}
mo_free_options(set, setlen);
#ifdef RDEBUG
printf("monet_init ok\n");
#endif
GDKsetenv("monet_version", VERSION);
GDKsetenv("monet_release", MONETDB_RELEASE);
if ((modpath = GDKgetenv("monet_mod_path")) == NULL) {
/* start probing based on some heuristics given the binary
* location:
* bin/mserver5 -> ../
* libX/monetdb5/lib/
* probe libX = lib, lib32, lib64, lib/64 */
char *libdirs[] = { "lib", "lib64", "lib/64", "lib32", NULL };
size_t i;
struct stat sb;
if (binpath != NULL) {
char *p = strrchr(binpath, DIR_SEP);
if (p != NULL)
*p = '\0';
p = strrchr(binpath, DIR_SEP);
if (p != NULL) {
*p = '\0';
for (i = 0; libdirs[i] != NULL; i++) {
snprintf(prmodpath, sizeof(prmodpath), "%s%c%s%cmonetdb5",
binpath, DIR_SEP, libdirs[i], DIR_SEP);
if (stat(prmodpath, &sb) == 0) {
modpath = prmodpath;
break;
}
}
} else {
printf("#warning: unusable binary location, "
"please use --set monet_mod_path=/path/to/... to "
"allow finding modules\n");
fflush(NULL);
}
} else {
printf("#warning: unable to determine binary location, "
"please use --set monet_mod_path=/path/to/... to "
"allow finding modules\n");
fflush(NULL);
}
if (modpath != NULL)
GDKsetenv("monet_mod_path", modpath);
}
#ifdef RDEBUG
printf("modpath ok\n");
#endif
/* configure sabaoth to use the right dbpath and active database */
msab_dbpathinit(GDKgetenv("gdk_dbpath"));
/* wipe out all cruft, if left over */
if ((err = msab_wildRetreat()) != NULL) {
/* just swallow the error */
free(err);
}
/* From this point, the server should exit cleanly. Discussion:
* even earlier? Sabaoth here registers the server is starting up. */
if ((err = msab_registerStarting()) != NULL) {
/* throw the error at the user, but don't die */
fprintf(stderr, "!%s\n", err);
free(err);
}
#ifdef RDEBUG
printf("some stuff\n");
#endif
#ifdef HAVE_SIGACTION
{
struct sigaction sa;
sigemptyset(&sa.sa_mask);
sa.sa_flags = 0;
sa.sa_handler = handler;
if (
sigaction(SIGINT, &sa, NULL) == -1 ||
sigaction(SIGQUIT, &sa, NULL) == -1 ||
sigaction(SIGTERM, &sa, NULL) == -1)
{
fprintf(stderr, "!unable to create signal handlers\n");
}
}
#else
signal(SIGINT, handler);
#ifdef SIGQUIT
signal(SIGQUIT, handler);
#endif
signal(SIGTERM, handler);
#endif
{
str lang = "mal";
/* we inited mal before, so publish its existence */
if ((err = msab_marchScenario(lang)) != NULL) {
/* throw the error at the user, but don't die */
fprintf(stderr, "!%s\n", err);
free(err);
}
}
#ifdef RDEBUG
printf("scenario ok\n");
#endif
{
/* unlock the vault, first see if we can find the file which
* holds the secret */
char secret[1024];
char *secretp = secret;
FILE *secretf;
size_t len;
if (GDKgetenv("monet_vault_key") == NULL) {
/* use a default (hard coded, non safe) key */
snprintf(secret, sizeof(secret), "%s", "Xas632jsi2whjds8");
} else {
if ((secretf = fopen(GDKgetenv("monet_vault_key"), "r")) == NULL) {
snprintf(secret, sizeof(secret),
"unable to open vault_key_file %s: %s",
GDKgetenv("monet_vault_key"), strerror(errno));
/* don't show this as a crash */
msab_registerStop();
GDKfatal("%s", secret);
}
len = fread(secret, 1, sizeof(secret), secretf);
secret[len] = '\0';
len = strlen(secret); /* secret can contain null-bytes */
if (len == 0) {
snprintf(secret, sizeof(secret), "vault key has zero-length!");
/* don't show this as a crash */
msab_registerStop();
GDKfatal("%s", secret);
} else if (len < 5) {
fprintf(stderr, "#warning: your vault key is too short "
"(" SZFMT "), enlarge your vault key!\n", len);
}
fclose(secretf);
}
if ((err = AUTHunlockVault(&secretp)) != MAL_SUCCEED) {
/* don't show this as a crash */
msab_registerStop();
GDKfatal("%s", err);
}
}
/* make sure the authorisation BATs are loaded */
if ((err = AUTHinitTables()) != MAL_SUCCEED) {
/* don't show this as a crash */
msab_registerStop();
GDKfatal("%s", err);
}
#ifdef RDEBUG
printf("vaultkey ok\n");
#endif
if (mal_init()) {
/* don't show this as a crash */
msab_registerStop();
return 0;
}
#ifdef RDEBUG
printf("mal_init ok\n");
#endif
#if (0)
if (!loadLibrary("lib_leaker", TRUE))
return 42;
#endif
#ifdef RDEBUG
printf("lib_leaker ok\n");
#endif
if (GDKgetenv("mal_listing"))
sscanf(GDKgetenv("mal_listing"), "%d", &listing);
MSinitClientPrg(mal_clients, "user", "main");
if (dbinit == NULL)
dbinit = GDKgetenv("dbinit");
if (dbinit)
callString(mal_clients, dbinit, listing);
#ifdef RDEBUG
printf("MSinitClientPrg ok\n");
#endif
emergencyBreakpoint();
if ((err = compileOptimizer(mal_clients, "leaker_pipe")) != MAL_SUCCEED)
mnstr_printf(mal_clients->fdout, "OPT_COMPILE: %s\n", err);
//callString(mal_clients, "sql.start();\n", 0);
if (monet_script)
for (i = 0; monet_script[i]; i++) {
str msg = evalFile(mal_clients, monet_script[i], listing);
/* check for internal exception message to terminate */
if (msg) {
if (strcmp(msg, "MALException:client.quit:Server stopped.") == 0)
mal_exit();
fprintf(stderr, "#%s: %s\n", monet_script[i], msg);
GDKfree(msg);
}
GDKfree(monet_script[i]);
monet_script[i] = 0;
}
if ((err = msab_registerStarted()) != NULL) {
/* throw the error at the user, but don't die */
fprintf(stderr, "!%s\n", err);
free(err);
}
if (monet_script)
free(monet_script);
MSserveClient(mal_clients);
/* mal_exit calls MT_global_exit, so statements after this call will
* never get reached */
mal_exit();
return 0;
}