TTASim.cc File Reference

#include <string>
#include <iostream>
#include <boost/shared_ptr.hpp>
#include "SimulatorCmdLineOptions.hh"
#include "SimulatorFrontend.hh"
#include "FileSystem.hh"
#include "SimulatorInterpreter.hh"
#include "SimulatorCLI.hh"
#include "SimulatorToolbox.hh"

Include dependency graph for TTASim.cc:

Go to the source code of this file.

Classes
class	SigINTHandler
class	SigFPEHandler
class	SigSegvHandler

Functions
int	main (int argc, char *argv[])

Detailed Description

Implementation of ttasim.

The command line version of the TTA Simulator / Debugger

Author

Pekka Jääskeläinen 2005-2012 (pjaaskel-no.spam-cs.tut.fi)

Note

rating: red

Definition in file TTASim.cc.

Function Documentation

main()

int main	(	int	argc,
		char *	argv[]
	)

Main function.

Parses the command line and figures out whether to start the interactive debugging mode or not.

Parameters

argc	The command line argument count.
argv	The command line arguments (passed to the interpreter).

Returns

The return status.

Todo:

: read command line options and initialize the simulator (frontend) using the given values.

Definition at line 172 of file TTASim.cc.

                                 {
 
    Application::initialize(argc, argv);
    
    boost::shared_ptr<SimulatorFrontend> simFront;
    /// @todo: read command line options and initialize the 
    /// simulator (frontend) using the given values.
    SimulatorCmdLineOptions* options = new SimulatorCmdLineOptions;
    try {
        options->parse(argv, argc);
        Application::setCmdLineOptions(options);
    } catch (ParserStopRequest) {
        return EXIT_SUCCESS;
    } catch (const IllegalCommandLine& i) {
        std::cerr << i.errorMessage() << std::endl;
        return EXIT_FAILURE;
    }
    
    simFront.reset(new SimulatorFrontend(options->backendType()));
    
    SimulatorCLI* cli = new SimulatorCLI(*simFront);
 
    if (options->debugMode()) {
        // handler for catching ctrl-c from the user (stops simulation)
        SigINTHandler* ctrlcHandler = new SigINTHandler(*simFront);
        Application::setSignalHandler(SIGINT, *ctrlcHandler);
 
        if (simFront->isCompiledSimulation()) {
 
            /* Catch errors caused by the simulated program
               in compiled simulation these show up as normal
               signals as the simulation code is native code we are 
               running in the simulation process. */
            SigFPEHandler fpeHandler(*simFront);
            SigSegvHandler segvHandler(*simFront);
            Application::setSignalHandler(SIGFPE, fpeHandler);
            Application::setSignalHandler(SIGSEGV, segvHandler);
        }
    }
 
    // check if there is an initialization file in user's home dir and 
    // execute it
    const std::string personalInitScript =
        FileSystem::homeDirectory() + DIR_SEPARATOR + SIM_INIT_FILE_NAME;
    if (FileSystem::fileExists(personalInitScript)) {
        cli->interpreter().processScriptFile(personalInitScript);
    }   
    
    std::string machineToLoad = options->machineFile();
    std::string programToLoad = options->programFile();
    const std::string scriptString = options->scriptString();
    
    if (options->numberOfArguments() != 0) {
        std::cerr << SimulatorToolbox::textGenerator().text(
            Texts::TXT_ILLEGAL_ARGUMENTS).str() << std::endl;
        return EXIT_FAILURE;
    }  
 
    // check if there is an initialization file in the current dir and
    // execute it
    const std::string currentDirInitScript =
        FileSystem::currentWorkingDir() + DIR_SEPARATOR + SIM_INIT_FILE_NAME;
    if (FileSystem::fileExists(currentDirInitScript)) {
        cli->interpreter().processScriptFile(currentDirInitScript);
    }
 
    if (machineToLoad != "") {
        cli->interpreteAndPrintResults(std::string("mach " ) + machineToLoad);
    }
 
    if (programToLoad != "") {
        cli->interpreteAndPrintResults(std::string("prog " ) + programToLoad);
        if (scriptString == "") {
            // by default, if program is given, start simulation immediately
            cli->interpreteAndPrintResults("run");
        }
    }
 
    if (scriptString != "") {
        cli->interpreteAndPrintResults(scriptString);
    }
 
    
    if (options->debugMode()) {        
        cli->run();   
        Application::restoreSignalHandler(SIGINT);
        if (simFront->isCompiledSimulation()) {
            Application::restoreSignalHandler(SIGFPE);
            Application::restoreSignalHandler(SIGSEGV);
        }        
    }
    delete cli;
    return EXIT_SUCCESS;
}

References FileSystem::currentWorkingDir(), Exception::errorMessage(), FileSystem::fileExists(), FileSystem::homeDirectory(), Application::initialize(), SimulatorCLI::interpreteAndPrintResults(), SimulatorCLI::interpreter(), CmdLineParser::numberOfArguments(), options, CmdLineOptions::parse(), TclInterpreter::processScriptFile(), Application::restoreSignalHandler(), SimulatorCLI::run(), Application::setCmdLineOptions(), Application::setSignalHandler(), SIM_INIT_FILE_NAME, Texts::TextGenerator::text(), SimulatorToolbox::textGenerator(), and Texts::TXT_ILLEGAL_ARGUMENTS.

Here is the call graph for this function: