terminate instead of rethrowing an uncaught exception

[libs/core.git] / source / core / application.cpp

diff --git a/source/core/application.cpp b/source/core/application.cpp
index 01bb558e279255fbb5f83676c61886966f9624b2..0e0b69f28af4aa9686ff4e30fb593f8ea58ea635 100644 (file)
--- a/source/core/application.cpp
+++ b/source/core/application.cpp
@@ -1,10 +1,13 @@
-/*
-This file is part of libmspframework
+/* $Id$
+
+This file is part of libmspcore
 Copyright © 2006 Mikko Rasa, Mikkosoft Productions
 Distributed under the LGPL
 */
 #include <signal.h>
 #include <iostream>
+#include "../time/units.h"
+#include "../time/utils.h"
 #include "application.h"
 #include "error.h"
 
@@ -12,35 +15,6 @@ 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;
-}
-
-EventManager::Event &Application::create_event()
-{
-       if(!ev_mgr_)
-               ev_mgr_=new EventManager(*this);
-
-       return ev_mgr_->create_event();
-}
-
-Application::~Application()
-{
-       if(poller_)
-               delete poller_;
-       if(ev_mgr_)
-               delete ev_mgr_;
-}
-
 /**
 Constructs an instance of the registered application class and runs it.  If the
 application throws a UsageError, the static usage() function is called.
@@ -64,86 +38,83 @@ int Application::run(int argc, char **argv)
                return 126;
        }
 
-#ifndef WIN32 //XXX
-       signal(SIGALRM, &sigalrm_);
-#endif
-       
        try
        {
-               app_=reg_app_->create_app(argc, argv);
+               try
+               {
+                       app_=reg_app_->create_app(argc, argv);
+               }
+               catch(const UsageError &e)
+               {
+                       reg_app_->usage(e.what(), argv[0], e.get_brief());
+                       return 1;
+               }
+
+               int result=app_->main();
+               delete app_;
+               return result;
        }
-       catch(const UsageError &e)
+       catch(const exception &e)
        {
-               reg_app_->usage(argv[0], e.get_brief());
-               return 1;
+               cerr<<"An uncaught exception occurred.\n";
+               cerr<<"  type:   "<<typeid(e).name()<<'\n';
+               cerr<<"  what(): "<<e.what()<<'\n';
+               delete app_;
+               terminate();
        }
-
-       int result=app_->main();
-       delete app_;
-       return result;
 }
 
 /**
 Prints a message describing the usage of the application.  The default version
 will blame the programmer for being lazy.
 
-@param   argv0  The value of argv[0], to be used in the message
-@param   brief  Whether to print a brief or long usage message
+@param   reason  Why the function was called
+@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)
+void Application::usage(const char *reason, const char *, bool)
 {
+       if(reason)
+               cerr<<"UsageError: "<<reason<<'\n';
        cerr<<"The programmer was lazy and didn't write a usage() function for this application.\n";
 }
 
 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
+       loop_mode_(TICK_SLEEP)
 { }
 
 /**
-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.
+Default main loop.  Behavior depends on loop_mode_.  A custom main loop should
+monitor the done member variable and return exit_code.
 */
 int Application::main()
 {
+       if(loop_mode_==NONE)
+               return 0;
+
        done=false;
        while(!done)
        {
-               if(tick_mode_==IDLE)
+               if(loop_mode_==SLEEP)
+               {
+                       sleep_sem_.wait();
+                       if(!done)
+                               tick();
+               }
+               else if(loop_mode_==TICK_SLEEP)
                {
-                       if(poller_)
-                               poller_->poll(0);
                        tick();
-#ifdef WIN32
-                       Sleep(0);
-#else
-                       //sched_yield();
-                       timespec ts={0,1000000};
-                       nanosleep(&ts, 0);
-#endif
+                       Time::sleep(Time::msec);
                }
-               else
+               else if(loop_mode_==TICK_YIELD)
                {
-                       if(poller_)
-                               poller_->poll(-1);
-                       else
-                       {
+                       tick();
 #ifdef WIN32
-                               Sleep(1);
+                       Sleep(0);
 #else
-                               timespec ts={1000,0};
-                               nanosleep(&ts, 0);
+                       sched_yield();
 #endif
-                       }
-                       if(tick_mode_!=NONE)
-                               tick();
                }
        }
 
@@ -158,12 +129,25 @@ void Application::catch_signal(int s)
        signal(s, &sighandler_);
 }
 
-void Application::set_tick_mode(TickMode t)
+/**
+Changes the main loop mode.
+*/
+void Application::set_loop_mode(LoopMode l)
 {
-       tick_mode_=t;
-#ifndef WIN32 //XXX
-       pthread_kill(main_tid, SIGALRM);        
-#endif
+       LoopMode old_mode=loop_mode_;
+       loop_mode_=l;
+       if(old_mode==SLEEP)
+               sleep_sem_.signal();
+}
+
+/**
+Causes the tick() function to be executed once if loop mode is SLEEP.  Has no
+effect with other loop modes.
+*/
+void Application::induce_tick()
+{
+       if(loop_mode_==SLEEP)
+               sleep_sem_.signal();
 }
 
 /**
@@ -173,11 +157,13 @@ void Application::exit(int c)
 {
        done=true;
        exit_code=c;
-#ifndef WIN32 //XXX
-       pthread_kill(main_tid, SIGALRM);        
-#endif
+       if(loop_mode_==SLEEP)
+               sleep_sem_.signal();
 }
 
+/**
+Static wrapper function to call a member function of the Application instance.
+*/
 void Application::sighandler_(int s)
 {
        app_->sighandler(s);