debugger.cxx File Reference

#include "RuntimeSALOME.hxx"
#include "Proc.hxx"
#include "Exception.hxx"
#include "Executor.hxx"
#include "parsers.hxx"
#include "Thread.hxx"
#include <iostream>
#include <fstream>
#include "YacsTrace.hxx"

Include dependency graph for debugger.cxx:

Go to the source code of this file.

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

Function Documentation

void* executorFunc

(

void *

arg

)

Definition at line 40 of file debugger.cxx.

References YACS::ENGINE::Executor::RunB().

Referenced by main().

{
  void **argT=(void **)arg;
  Executor *myExec = (Executor *)argT[0];
  Proc *myProc = (Proc *)argT[1];
  myExec->RunB(myProc, 2);
  return 0;
}

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

Definition at line 50 of file debugger.cxx.

References DEBTRACE, YACS::ENGINE::Executor::displayDot(), executorFunc(), gui.CONNECTOR::f(), YACS::ENGINE::Executor::getExecutorState(), YACS::ENGINE::Executor::isNotFinished(), YACS::YACSLoader::load(), loader, p, YACS::ENGINE::Executor::resumeCurrentBreakPoint(), YACS::ENGINE::Executor::setExecMode(), YACS::STEPBYSTEP, YACS::Exception::what(), and YACS::ENGINE::Proc::writeDot().

{
  if (argc != 2)
  {
    cerr << "usage: " << argv[0] << " schema.xml" << endl;
    return 1;
  }

  RuntimeSALOME::setRuntime();

  YACSLoader loader;
  Executor *executor = new Executor();
 
  try
    {
      Proc* p=loader.load(argv[1]);
      std::ofstream f("toto");
      p->writeDot(f);
      f.close();

      executor->setExecMode(YACS::STEPBYSTEP);
      void **args=new void *[2];
      args[0]=(void *)executor;
      args[1]=(void *)p;
      Thread* execThread = new Thread(executorFunc,args);
      char com;
      cerr << "enter a char to start" << endl;
      cin >> com;
      //executor->wakeUp();
      while (executor->isNotFinished())
        {
          YACS::ExecutorState executorState = executor->getExecutorState();
          cerr << "executorState: " << executorState << endl;
          cerr << "command display=d step=s : ";
          cin >> com;
          switch (com)
            {
            case 's':
              {
                executor->setExecMode(YACS::STEPBYSTEP);
                bool res = executor->resumeCurrentBreakPoint();
                cerr << "resumeCurrentBreakPoint(): " << res << endl;
                break;
              }
            case 'd':
              {
                executor->displayDot(p);
                break;
              }
            default:
              {
                cerr << "commande inconnue" << endl;
              }
            }
        }
      execThread->join();
      std::ofstream g("titi");
      p->writeDot(g);
      g.close();
      delete executor;
      return 0;
  }
  catch (YACS::Exception& e)
    {
      DEBTRACE("exception YACS levee " << e.what());
      return 1;
    }
  catch (const std::ios_base::failure&)
    {
      DEBTRACE("io failure");
      return 1;
    }
  catch(CORBA::SystemException& ex)
    {
      DEBTRACE("...");
      CORBA::Any tmp;
      tmp <<= ex;
      CORBA::TypeCode_var tc = tmp.type();
      const char *p = tc->name();
      if ( *p != '\0' )
        {
          DEBTRACE("Caught a CORBA::SystemException. " <<p);
        }
      else
        {
          DEBTRACE("Caught a CORBA::SystemException. " << tc->id());
        }
    return 1;
    }
  catch(omniORB::fatalException& fe)
    {
      DEBTRACE("Caught omniORB::fatalException: file: "<<fe.file()<<" line: "<<fe.line()<<" msg: "<<fe.errmsg());
      return 1;
    }
  catch(...)
    {
      DEBTRACE("Caught unknown exception.");
      return 1;
    }
}