X-Git-Url: http://git.tdb.fi/?p=libs%2Fcore.git;a=blobdiff_plain;f=source%2Fcore%2Fapplication.cpp;h=8447eed669d2b8f58c9b078b547b1543b0bab27f;hp=a9aa88ea55bdee578d81238d614120a962be2173;hb=HEAD;hpb=e1ea831a640fba534e7e42e399f04cdf681ef8d3 diff --git a/source/core/application.cpp b/source/core/application.cpp index a9aa88e..c214a06 100644 --- a/source/core/application.cpp +++ b/source/core/application.cpp @@ -1,198 +1,170 @@ -/* -This file is part of libmspframework -Copyright © 2006 Mikko Rasa, Mikkosoft Productions -Distributed under the LGPL -*/ +#include +#include #include -#include +#include +#include +#include +#include +#include +#include +#include #include "application.h" -#include "error.h" +#include "except.h" +#include "getopt.h" using namespace std; namespace Msp { -Poller::Slot &Application::add_pollable(Pollable *obj, short events) -{ - if(!poller_) - poller_=new Poller; - - Poller::Slot &slot=poller_->add_pollable(obj, events); - // Interrupt a possible poll in progress -#ifndef WIN32 //XXX - pthread_kill(main_tid, SIGALRM); -#endif - return slot; -} +Application *Application::_app = nullptr; +Application::Starter *Application::_starter = nullptr; +const char *Application::_argv0 = nullptr; +string Application::_name; +void *Application::_data = nullptr; -EventManager::Event &Application::create_event() +Application::Application(const string &n) { - if(!ev_mgr_) - ev_mgr_=new EventManager(*this); - - return ev_mgr_->create_event(); -} + if(_app) + throw already_called("Application::Application"); -Application::~Application() -{ - if(poller_) - delete poller_; - if(ev_mgr_) - delete ev_mgr_; + if(!n.empty()) + _name = n; + else + _name = FS::basename(_argv0); } -/** -Constructs an instance of the registered application class and runs it. If the -application throws a UsageError, the static usage() function is called. - -This function can only be called once. The global main() function provided by -the library normally does it automatically at program startup. -*/ -int Application::run(int argc, char **argv) +int Application::run(int argc, char **argv, void *data, void (*created_callback)(void *)) { - static bool called=false; - if(called) - { - cerr<<"Trying to call Application::run_app twice!\n"; - return 125; - } - called=true; - - if(!reg_app_) + if(!_starter) { - cerr<<"Trying to run with no application class registered!\n"; + IO::cerr.write("Application::run called with no RegisteredApplication class!\n"); return 126; } -#ifndef WIN32 //XXX - signal(SIGALRM, &sigalrm_); -#endif - + set_startup_info(argv[0], data); + try { - app_=reg_app_->create_app(argc, argv); + try + { + _app = _starter->create_app(argc, argv); + } + catch(const usage_error &e) + { + IO::print(IO::cerr, "%s\n%s\n", e.what(), e.help()); + return 1; + } + + if(created_callback) + created_callback(data); + + int result = _app->main(); + Application *a = _app; + _app = nullptr; + delete a; + return result; } - catch(const UsageError &e) + catch(const exception &e) { - reg_app_->usage(argv[0], e.get_brief()); - return 1; + bool handled = false; + if(const Debug::ErrorReporter *er = Debug::ErrorReporter::get_current()) + handled = er->report_uncaught_exception(e); + + if(!handled) + { + IO::print(IO::cerr, "An uncaught exception occurred.\n"); + IO::print(IO::cerr, " type: %s\n", Debug::demangle(typeid(e).name())); + vector lines = split(e.what(), '\n'); + if(lines.size()<2) + IO::print(IO::cerr, " what(): %s\n", e.what()); + else + { + IO::print(IO::cerr, " what(): %s\n", lines.front()); + for(auto i=lines.begin(); ++i!=lines.end(); ) + IO::print(IO::cerr, " %s\n", *i); + } + } + + delete _app; + _app = nullptr; + + return 124; } +} + +void Application::set_startup_info(const char *argv0, void *data) +{ + if(_argv0) + throw already_called("Application::set_startup_info"); + + static FS::Path exe; - int result=app_->main(); - delete app_; - return result; + if(!argv0 || !*argv0) + { +#ifdef _WIN32 + argv0 = "application.exe"; +#else + argv0 = "./application"; +#endif + } + + bool has_slash = strchr(argv0, FS::DIRSEP); + if(!has_slash) + exe = FS::path_lookup(argv0); + if(exe.empty()) + exe = FS::realpath(argv0); + + _argv0 = exe.c_str(); + _data = data; } -/** -Prints a message describing the usage of the application. The default version -will blame the programmer for being lazy. +void *Application::get_data() +{ + return _data; +} -@param argv0 The value of argv[0], to be used in the message -@param brief Whether to print a brief or long usage message -*/ -void Application::usage(const char *, bool) +const char *Application::get_argv0() { - cerr<<"The programmer was lazy and didn't write a usage() function for this application.\n"; + return _argv0; } -Application::Application(): - exit_code(0), - tick_mode_(IDLE), - poller_(0), - ev_mgr_(0) -#ifndef WIN32 - //XXX Figure out how to get the current thread on win32 - ,main_tid(pthread_self()) -#endif -{ } +const std::string &Application::get_name() +{ + return _name; +} -/** -Default main loop. Calls tick() periodically if do_ticks is true, otherwise -just sleeps. A custom main loop should monitor the done member variable and -return exit_code. -*/ int Application::main() { - done=false; + done = false; while(!done) - { - if(tick_mode_==IDLE) - { - if(poller_) - poller_->poll(0); - tick(); -#ifdef WIN32 - Sleep(0); -#else - sched_yield(); -#endif - } - else - { - if(poller_) - poller_->poll(-1); - else - { -#ifdef WIN32 - Sleep(1); -#else - timespec ts={1000,0}; - nanosleep(&ts, 0); -#endif - } - if(tick_mode_!=NONE) - tick(); - } - } + tick(); return exit_code; } -/** -Sets the specified signal to be delivered to the sighandler member function. -*/ void Application::catch_signal(int s) { - signal(s, &sighandler_); + signal(s, &_sighandler); } -void Application::set_tick_mode(TickMode t) -{ - tick_mode_=t; -#ifndef WIN32 //XXX - pthread_kill(main_tid, SIGALRM); -#endif -} - -/** -Causes the application to exit gracefully with the given exit code. -*/ void Application::exit(int c) { - done=true; - exit_code=c; -#ifndef WIN32 //XXX - pthread_kill(main_tid, SIGALRM); -#endif + done = true; + exit_code = c; } -void Application::sighandler_(int s) +void Application::_sighandler(int s) { - app_->sighandler(s); + _app->sighandler(s); } -Application::RegBase::RegBase() + +Application::Starter::Starter() { - if(reg_app_) - { - cerr<<"Warning: registering the application twice\n"; - delete reg_app_; - } + if(_starter) + throw already_called("Application::Starter::Starter"); - reg_app_=this; + _starter = this; } -Application *Application::app_=0; -Application::RegBase *Application::reg_app_=0; - } // namespace Msp