debugger.cpp

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.             *
 ***************************************************************************/

#include "gpucalc/debugger/debugger.h"

#include "gpucalc/task.h"
#include "gpucalc/data.h"

namespace gpucalc
{

 template<> debugger::Debugger * gpucalc::Singleton<debugger::Debugger>::mSingleton = 0;


 debugger::Debugger * debugger::Debugger::getSingletonPtr()
 {
  return mSingleton;
 }


 debugger::Debugger & debugger::Debugger::getSingleton()
 {
  assert(mSingleton);
  return(* mSingleton);
 }

namespace debugger
{
  Debugger::Debugger(): Singleton<Debugger>(_DebuggerName), mCodeInstructorMap(), mActiveCodeInstructor(0),
   mIsDebug(false), mTask(0), mOriginalSource(), mExpression(), mLine(0)
  {
  }


  Debugger::~Debugger()
  {
  }


  void Debugger::addCodeInstructor(CodeInstructor * CodeInst)
  {
   addToContainer(CodeInst, CodeInst->getLanguageID(), mCodeInstructorMap);
  }


  void Debugger::setTask(Task * task)
  {
   mTask = task;
   Kernel * kernel = task->getActiveKernel();
   mOriginalSource = kernel->getShader()->getSource();
   {
    CodeInstructorMap::iterator i = mCodeInstructorMap.find(kernel->getShader()->getLanguageID());
    if (i != mCodeInstructorMap.end())
    {
     mActiveCodeInstructor = i->second;
    }
    else
    {
     Except<ERR_ITEM_NOT_FOUND>(this,
      "CodeInstructor with language id \"" + kernel->getShader()->getLanguageID() + "\" cannot be found. Debugging is not available.",
      "debugger::Debugger::setTask()", __FILE__, __LINE__);
    }
   }
   mActiveCodeInstructor->setOriginalSource(mOriginalSource);
   mIsDebug = true;
  }


  void Debugger::setBreakPoint(size_t line)
  {
   mLine = line;
  }


  void Debugger::print(const std::string & expression)
  {
   mExpression = expression;
   doPrintingData(process(), 0);
  }


  void Debugger::stepInto()
  {
   /*
   if (mActiveCodeInstructor->isExternalFunctionCalling(mLine))
   {
    mLine = mActiveCodeInstructor->getExternalFunctionBody(mActiveCodeInstructor->getExternalFunctionName(mLine));
   }
   */
   Warning<ERR_NOT_IMPLEMENTED>(this, "StepInto is not implemented yet.", "debugger::Debugger::stepInto()", __FILE__, __LINE__);
   setBreakPoint(mLine + 1);
  }


  void Debugger::stepOver()
  {
   /*
   if (mActiveCodeInstructor->isCycle(mLine))
   {
    mLine = mActiveCodeInstructor->getEndOfCycle(mLine);
   }
   */
   Warning<ERR_NOT_IMPLEMENTED>(this, "StepOver is not implemented yet.", "debugger::Debugger::stepOver()", __FILE__, __LINE__);
   setBreakPoint(mLine + 1);
  }


  const Data & Debugger::process()
  {
   if ((mLine != 0) && (mExpression.length() != 0))
   {
    std::string InstructedSource = mActiveCodeInstructor->instruct(mLine, mExpression);
    mTask->getActiveKernel()->getShader()->setSource(InstructedSource);
    mTask->compute();
    return  mTask->getResultData();
   }
   else
   {
    Except<ERR_INVALIDPARAMS>(this, "Line or Expression are incorrect", "debugger::Debugger::process()", __FILE__, __LINE__);
   }
  }


  void Debugger::stop()
  {
   mIsDebug = false;
   mTask = 0;
   mOriginalSource = std::string();
   mExpression = std::string();
   mLine = 0;
   mActiveCodeInstructor->setOriginalSource(mOriginalSource);
  }


  void Debugger::doPrintingData(const Data & data, size_t xcomp, size_t ycomp, size_t zcomp)
  {
   switch (data.getValueType())
   {
    case FloatType:
     elseOnePrintingData<float>(data, xcomp, ycomp, zcomp);
     break;

    case CharType:
     elseOnePrintingData<char>(data, xcomp, ycomp, zcomp);
     break;

    default:
     Except<ERR_NOT_IMPLEMENTED>(Object(_SingletonClassName, _DebuggerName), "Other value types is not implemented yet.",
      "debugger::Debugger::doPrintingData()", __FILE__, __LINE__);
     break;
   }
  }
  

  template<typename T> void Debugger::elseOnePrintingData(const Data & data, size_t xcomp, size_t ycomp, size_t zcomp)
  {
   size_t offset = data.getNumberOfComponents() * (data.getSizeX() * (zcomp * data.getSizeY() + ycomp) + xcomp);
   for (size_t i = 0; i < data.getNumberOfComponents(); ++i)
   {
    std::cout << static_cast<const T *>(data.pointer())[offset + i] << "\t";
   }
   std::cout << std::endl;
  }
 }
}