---

mapplic.cc

#define private public
#include "magic/mobject.h"
#include "magic/mapplic.h"
#include "magic/mclass.h"

#include <time.h>

impl_dynamic (Application, {Object});

/*
  Does not work with EGCS
  
void classDump (const Object& obj) {
    const type_info& tir=typeid(obj);
    int nodetype = tir.__rtti_get_node_type ();
    if (nodetype != type_info::_RTTI_CLASS_TYPE) {
        serr.print ("Node type requested for a non-class object\n");
        return;
    }
    
    const __class_type_info& ci = (const __class_type_info&) tir;
    serr.printf ("class %s ", ci.name ());
    for (int i=0; i<ci.n_bases; i++) {
        const type_info& clbase = *ci.base_list[i];
        serr.printf (": %s ", clbase.name());
    }
    serr.print ("\n");
}
*/

//                                                                          //
//               _             | o                 o                        //
//              / \   --   --  |    ___   ___   |           _               //
//             /   \ |  ) |  ) | | |   \  ___| -+- |  __  |/ \              //
//             |---| |--  |--  | | |     (   |  |  | /  \ |   |             //
//             |   | |    |    | |  \__/  \__|   \ | \__/ |   |             //
//                                                                          //

void myterminate () {
    printf ("%%ERR: Program terminated for unspecified reason\n"
            "%%ERR: This is possibly due to a bad exception\n"
            "%%ERR: or some other internal error\n");
    exit (1);
}

void myunexpected () {
    printf ("%%ERR: Bad exception was thrown. Exiting...\n");
    exit (1);
}

// Defined in mobject.cc
extern int newtrace_disabled;

int main (int argc, char** argv) {
    set_terminate (myterminate);
    set_unexpected (myunexpected);

    randomize;

#ifndef DISABLE_ALL_MEMORY_DEBUGGING
    // Don't trace allocations before this point, since we DON'T want
    // to trace global objects, like class and module objects
    newtrace_disabled = false;
#endif
    
    if (appclass) {
        // Create instance of the (user-inherited) application class
        newComment ("Application instance");
        Application* app = static_cast <Application*> (
            &(ClassLib::getinstance (appclass->getname())));

        // If such was found...
        if (app) {
            app->setParams (argc, argv);

            // Run any one of it's main-methods
            try {
                app->main (app->params());
                if (app->getTried()==1)
                    app->main ();
            } catch (assertion_failed e) {
                // Catch any uncaught exceptions
                fprintf (stderr, "%%EXCEPTION: Caught at main level\n %s\n",
                         (CONSTR) e.what());
                exit (1);
            } catch (exception e) {
                fprintf (stderr,
                         "%%exception: Caught at main level\n %s\n", e.what());
                exit (1);
            } catch (Exception e) {
                fprintf (stderr,
                         "%%Exception: Caught at main level\n %s\n", (CONSTR) e.what());
                exit (1);
            }
            delete app;
        } else {
            // No user-defined Application inheritor was found
            serr.printf ("%%ERR: Internal error in Application "
                         "class creation\n"
                         "%%ERR: An Application class was found "
                         "with name '%s',\n"
                         "%%ERR: but it was not possible to get an instance "
                         "for it\n",
                         (CONSTR) appclass->getname());
            // classDump (*appclass);
        }
    } else {
        fprintf (stderr, "%%ERR: No Application decendant found\n");
    }

#ifndef DISABLE_ALL_MEMORY_DEBUGGING
    // Check for memory leaks
    if (dbgnewmalloced>0) {
        fprintf (stderr, "%%ERR: Detected memory leaks!!!!\n");
        list_allocations ();
    }
#endif

    return 0;
}

void Application::setParams (int argc, char** argv) {
    mArgc = argc;
    mArgv = argv;

    // Move the parameters to String array
    
    Array<String>   params;
    if (argc>1)
        params.resize (argc-1);
    
    for (int i=0; i<params.size; i++)
        params [i] = argv[i+1];

    // Parse any parameters of the format "-xxxx=yyyyy" into a parameter map
    StringMap paramMap;
    for (int p=0; p<params.size; p++)
        if (params[p].length()>1 && params[p][0]=='-') {
            String prm2 = params[p].mid(1);
            Array<String> lr;
            prm2.split (lr, '=');
            if (lr.size==1) { // A normal flag - not handled here
                mParams.add (params[p]); // (Same as below)
            } else if (lr.size>2) { // Multiple =-signs are not allowed
                serr.printf ("Parameters must follow format: -param=value\n");
                exit (1);
            } else // Add to parameter map
                mParamMap.set (lr[0],lr[1]);
        } else
            mParams.add (params[p]);
}

void Application::readConfig (const String& filename) {
    StringMap paramMap = readStringMap (filename);

    // Then add the command-line parameters on top of those
    paramMap += mParamMap;

    mParamMap = paramMap;
    
    // Parameters are from now on REQUIRED
    mParamMap.failByThrow ();
}

---