command_parser.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2008 by Kutumov Alexey                                  *
 *   ru.pixel@gmail.com                                                    *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#ifndef __command_parser__header__
#define __command_parser__header__

#include "gpucalc/singleton.h"
#include "gpucalc/string_util.h"
#include "gpucalc/application.h"
#include "gpucalc/task_manager.h"
#include "gpucalc/debugger/debugger.h"

namespace gpucalc
{
 namespace debugger
 {

  const char _CommandClassName [] = "debugger::Command";

  class _GpuCalcExport Command: public Object
  {


   OBJ_DISABLE_COPY(Command)



   public:
    Command(const std::string & CommandName): Object(_CommandClassName, CommandName)
    {
    }


    virtual ~Command()
    {
    }

    virtual const std::string & getCommandName() const = 0;

    virtual void process(const StringList & args) = 0;
  };



  class _GpuCalcExport RunCommand: public Command
  {

   OBJ_DISABLE_COPY(RunCommand)

   
   public:
    RunCommand(): Command("run")
    {
    }


    ~RunCommand()
    {
    }


    const std::string & getCommandName() const
    {
     return this->getObjectName();
    }

    void process(const StringList & args)
    {
     if (Debugger::getSingleton().isDebugging())
     {
      Warning<ERR_INVALID_STATE>(this, "Another Task is debugging, stopping previous debugging...", "debugger::RunCommand::process()",
       __FILE__, __LINE__);
      Debugger::getSingleton().stop();
     }
     else
     {
      Task * DebugTask = Application::getSingleton().getDefaultTaskManager()->find(args[1]);
      Debugger::getSingleton().setTask(DebugTask);
     }
    }
  };



  class _GpuCalcExport PrintCommand: public Command
  {

   
   OBJ_DISABLE_COPY(PrintCommand)
   
   
   public:
    PrintCommand(): Command("print")
    {
    }


    ~PrintCommand()
    {
    }


    const std::string & getCommandName() const
    {
     return this->getObjectName();
    }


    void process(const StringList & args)
    {
     if (Debugger::getSingleton().isDebugging())
     {
      // first argument is a name of command, so skipping it.
      for (StringList::const_iterator i = args.begin() + 1; i != args.end(); ++i)
      {
       Debugger::getSingleton().print(*i);
      }
     }
    }
  };



  class _GpuCalcExport BreakCommand: public Command
  {

   OBJ_DISABLE_COPY(BreakCommand)


   public:
    BreakCommand(): Command("break")
    {
    }


    ~BreakCommand()
    {
    }


    const std::string & getCommandName() const
    {
     return this->getObjectName();
    }


    void process(const StringList & args)
    {
     if (Debugger::getSingleton().isDebugging())
     {
      size_t line;
      auxillary::StringUtil::fromString(args[1], line);
      Debugger::getSingleton().setBreakPoint(line);
     }
    }
  };



  const char _CommandParserName [] = "debugger::CommandParser";


  class _GpuCalcExport CommandParser: public Singleton<CommandParser>
  {

   OBJ_DISABLE_COPY(CommandParser)
   
   
   public:
    CommandParser();


    ~CommandParser();


    void registerCommand(const SharedPtr<Command> & cmd);


    void process(const std::string & expression);


    static CommandParser * getSingletonPtr();


    static CommandParser & getSingleton();


   private:

    typedef std::map<std::string, SharedPtr<Command> >CommandPtrMap;
    CommandPtrMap mCommandPtrMap;
  };
 }
}



#endif