nevrax.org : docs

00001 
00006 /* Copyright, 2000 Nevrax Ltd.
00007  *
00008  * This file is part of NEVRAX NEL.
00009  * NEVRAX NEL is free software; you can redistribute it and/or modify
00010  * it under the terms of the GNU General Public License as published by
00011  * the Free Software Foundation; either version 2, or (at your option)
00012  * any later version.
00013 
00014  * NEVRAX NEL is distributed in the hope that it will be useful, but
00015  * WITHOUT ANY WARRANTY; without even the implied warranty of
00016  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
00017  * General Public License for more details.
00018 
00019  * You should have received a copy of the GNU General Public License
00020  * along with NEVRAX NEL; see the file COPYING. If not, write to the
00021  * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
00022  * MA 02111-1307, USA.
00023  */
00024 
00025 #include "nel/ai/script/code_branche_run_debug.h"
00026 #include "nel/ai/script/varstack.h"
00027 
00028 #ifdef NL_DEBUG
00029 #ifdef NL_OS_WINDOWS
00030 #include "windows.h"
00031 #endif
00032 #endif
00033 
00034 namespace NLAISCRIPT
00035 {
00036         /*
00037          * Constructor
00038          */
00039 
00040         void CCodeBrancheRunDebug::initCBRD()
00041         {
00042                 _LineInSourceCodeArray = new int[_Count];
00043                 for(sint32 i = 0 ;i < _Count; i ++) 
00044                 {
00045                         _LineInSourceCodeArray[i] = 0; // It's a mark, because 0 could'nt be a true value.
00046                 }
00047         }
00048 
00049         CCodeBrancheRunDebug::CCodeBrancheRunDebug(sint32 N,const IOpCode &op):
00050                 CCodeBrancheRun(N, op), _SourceCode(NULL)
00051         {
00052                 initCBRD();
00053         }
00054 
00055         CCodeBrancheRunDebug::CCodeBrancheRunDebug(sint32 N, IScriptDebugSource* sourceCode):
00056         CCodeBrancheRun(N),
00057         _SourceCode(sourceCode)
00058         {
00059                 _SourceCode->incRef();
00060                 initCBRD();
00061         }
00062 
00063         CCodeBrancheRunDebug::CCodeBrancheRunDebug(const tListCode &l):
00064         CCodeBrancheRun(l),
00065         _SourceCode(NULL)
00066         {
00067                 initCBRD();
00068         }       
00069 
00070         CCodeBrancheRunDebug::CCodeBrancheRunDebug(const CCodeBrancheRunDebug &l):
00071         CCodeBrancheRun(l),
00072         _LineInSourceCodeArray(NULL),
00073         _SourceCode(l._SourceCode)
00074         {
00075                 _SourceCode->incRef();
00076                 initCBRD();
00077                 for(sint32 i = 0 ;i < _Count; i ++) 
00078                 {
00079                         _LineInSourceCodeArray[i] = l._LineInSourceCodeArray[i];
00080                 }
00081         }
00082 
00083         CCodeBrancheRunDebug::~CCodeBrancheRunDebug()
00084         {
00085                 delete []_LineInSourceCodeArray;
00086                 if (_SourceCode) _SourceCode->release();
00087         }
00088 
00089         const NLAIC::IBasicType* CCodeBrancheRunDebug::clone() const 
00090         {
00091                 NLAIC::IBasicType *x = new CCodeBrancheRunDebug(*this);
00092                 return x;
00093         }
00094 
00095         const NLAIC::IBasicType *CCodeBrancheRunDebug::newInstance() const 
00096         {
00097                 NLAIC::IBasicType *x = new CCodeBrancheRunDebug(1,CHaltOpCode());
00098                 return x;
00099         }
00100 
00101         void CCodeBrancheRunDebug::save(NLMISC::IStream &os)
00102         {
00103                 CCodeBrancheRun::save(os);
00104 
00105                 for(int i = 0 ;i < _Count; i ++)
00106                 {               
00107                         sint32 n = _LineInSourceCodeArray[i];
00108                         os.serial( n );
00109                 }
00110                 _SourceCode->save(os);
00111                 
00112         }
00113 
00114         void CCodeBrancheRunDebug::load(NLMISC::IStream &is)
00115         {               
00116                 int i;
00117                 CCodeBrancheRun::load(is);
00118                 delete[] _LineInSourceCodeArray;
00119                 _LineInSourceCodeArray = new int[_Count];
00120                 for(i = 0 ;i < _Count; i ++)
00121                 {
00122                         sint32 n;
00123                         is.serial( n );
00124                         _LineInSourceCodeArray[i] = (int)n;
00125                 }
00126                 _SourceCode->load(is);
00127         }
00128 
00129         const NLAIAGENT::IObjectIA::CProcessResult& CCodeBrancheRunDebug::run(NLAIAGENT::IObjectIA &self)
00130         {               
00131                 CStackPointer   stack,heap;
00132                 CCodeContext p(stack,heap,this,&self,InputOutput);
00133                 CVarPStack::_LocalTableRef = &heap[0];
00134                 stack --;
00135                 
00136                 run(p);
00137 
00138                 stack -= (sint32)stack; 
00139                 heap -= (sint32)heap; 
00140                 return _RunState;
00141         }       
00142 
00143         const NLAIAGENT::IObjectIA::CProcessResult &CCodeBrancheRunDebug::run(CCodeContext &p)
00144         {
00145                 NLAIAGENT::TProcessStatement i = NLAIAGENT::processIdle;
00146                 
00147                 p.ContextDebug.Active = true; // We are in Debug mode.
00148                 p.ContextDebug.callStackPush(this);
00149 
00150                 _RunState.Result = NULL;
00151                 while(i != NLAIAGENT::processEnd)
00152                 {       
00153                         i = runOpCode(p);
00154                 }
00155                 
00156                 _RunState.ResultState = NLAIAGENT::processIdle;
00157                 return _RunState;
00158         }
00159 #ifdef NL_DEBUG
00160         extern bool NL_AI_DEBUG_SERVER;
00161 #endif
00162         NLAIAGENT::TProcessStatement CCodeBrancheRunDebug::runOpCode(CCodeContext &p)
00163         {
00164                 std::string buf;
00165                 p.ContextDebug.Active = true; // We are in Debug mode.
00166 
00167                 IOpCode &op = nextCode();
00168 
00169 #ifdef NL_DEBUG
00170                 if(NL_AI_DEBUG_SERVER)
00171                 {
00172                         std::string chaine;
00173                         op.getDebugResult(chaine,p);
00174 #ifdef NL_OS_WINDOWS
00175                         OutputDebugString(chaine.c_str());
00176                         OutputDebugString("\n");
00177 #endif
00178                 }
00179 #endif
00180                 if (_LineInSourceCodeArray[_Ip-1] != 0)
00181                 {
00182                         fixContextDebugMode(p);
00183 
00184                         // We print info debug only if we are running the stepByStep codeBrancheRun.
00185                         if (   p.ContextDebug.getDebugMode() == stepByStepMode 
00186                                 && p.ContextDebug.getCallStackTopIndex() == p.ContextDebug.getStepIndex())
00187                         {
00188                                 printCurrentSourceCodeLine();
00189 
00190                                 bool executOpcode = false;
00191 
00192                                 while (!executOpcode)
00193                                 {
00194                                         // Wait command
00195                                         InputOutput->Echo("(db) ");
00196                                         buf = InputOutput->InPut();
00197                                         executOpcode = readCommandLine(p, buf.c_str());
00198                                         if (0 != buf.c_str()[0]) p.ContextDebug.setLastCommandLine(buf.c_str());
00199                                 }
00200                         }
00201                 }
00202 
00203                 if (p.ContextDebug.getDebugMode() == stopMode)
00204                 {
00205                         return NLAIAGENT::processEnd;
00206                 }
00207                 else
00208                 {
00209                         return op.runOpCode(p);
00210                 }
00211         }
00212 
00213         void CCodeBrancheRunDebug::getDebugResult(std::string &str,CCodeContext &p) const
00214         {               
00215                 _TableCode[_Ip]->getDebugResult(str,p);
00216         }
00217         
00218         const NLAIC::CIdentType& CCodeBrancheRunDebug::getType() const
00219         {               
00220                 return IdCodeBrancheRunDebug;
00221         }
00222 
00223         void CCodeBrancheRunDebug::initCode(const tListCode &l)
00224         {
00225                 del();
00226                 _Count = l.size();
00227 
00228                 tListCode::const_iterator i;            
00229                 _TableCode = new IOpCode * [l.size()];
00230                 i = l.begin();
00231                 sint32 k = 0;
00232                 while(i != l.end())
00233                 {
00234                         _TableCode[k ++] = (IOpCode *)*i++;
00235                 }               
00236         }
00237 
00238         void CCodeBrancheRunDebug::initCode(const CCodeBrancheRunDebug &l)
00239         {
00240                 del();
00241 
00242                 _Ip = 0;
00243                 _Count = l._Count;
00244                 
00245                 _TableCode = new IOpCode * [_Count];            
00246                 for(sint32 i = 0; i < _Count;i ++)
00247                 {
00248                         _TableCode[i] = (IOpCode *)l._TableCode[i]->clone();    
00249                 }
00250         }
00251 
00252         void CCodeBrancheRunDebug::setLineCode(int ligne, int index)
00253         {
00254                 _LineInSourceCodeArray[index] = ligne;
00255         }
00256 
00257         std::string CCodeBrancheRunDebug::getSourceFileName() const
00258         {
00259                 return _SourceCode->getSourceName().c_str();
00260         }
00261 
00262         void CCodeBrancheRunDebug::fixContextDebugMode(CCodeContext &P) const
00263         {
00264                 // We are in step by step mode on the current CCodeBrancheRun :
00265                 if (   P.ContextDebug.getBreakPointValue(_LineInSourceCodeArray[_Ip-1],getSourceFileName().c_str()) // After a BreakPoint.
00266                         || P.ContextDebug.getDebugMode() == stepInMode  // After a stepInMode.
00267                         || P.ContextDebug.getDebugMode() == stepOutMode && (P.ContextDebug.getCallStackTopIndex() < P.ContextDebug.getStepIndex()) // After leaving a branche in stepOutMode.
00268                         || P.ContextDebug.getDebugMode() == stepByStepMode && P.ContextDebug.getCallStackTopIndex() < P.ContextDebug.getStepIndex()) // If we reach a higer level branch in stepBySteplMode.
00269                 {
00270                         P.ContextDebug.setDebugMode(stepByStepMode);
00271                         P.ContextDebug.setStepIndex(P.ContextDebug.getCallStackTopIndex());
00272                 }
00273         }
00274 
00275         void CCodeBrancheRunDebug::printSourceCodeLine(int first, int last) const
00276         {
00277                 sint32 i, j, k, size, lineNumber;
00278                 const char* buf;
00279                 char* lineTxt;
00280                 std::string code;
00281 
00282                 lineNumber = this->getCurrentSourceCodeLineNumber();
00283                 code = " ";
00284                 code += _SourceCode->getSourceBuffer();
00285                 code +="\n";
00286                 size = code.size();
00287                 buf = code.c_str();
00288 
00289                 // first should be lowest than last.
00290                 if (first > last) last = first;
00291 
00292                 // Seek the good line
00293                 i = 0; // Line start
00294                 j = 0; // Line end
00295                 k = 0; // Line number
00296                 lineTxt = new char[1024];
00297 
00298                 // Seek the first line
00299                 while (k != first && j < size)
00300                 {
00301                         j++;
00302                         i = j;
00303                         while (buf[j] != '\n')
00304                         {
00305                                 j++;
00306                         }
00307                         k++;
00308                 }
00309 
00310                 // Print until the last line
00311                 while (k != last+1 && j < size)
00312                 {
00313                         strncpy (lineTxt, buf+i,j-i);
00314                         lineTxt[j-i] = 0;
00315 
00316                         // Print debug informations
00317                         if ( k == lineNumber)
00318                         {
00319                                 InputOutput->Echo("%d ->\t %s\n", k, lineTxt);
00320                         }
00321                         else
00322                         {
00323                                 InputOutput->Echo("%d   \t %s\n", k, lineTxt);
00324                         }
00325 
00326                         j++;
00327                         i = j;
00328                         while (buf[j] != '\n')
00329                         {
00330                                 j++;
00331                         }
00332                         k++;
00333                 }
00334                 delete[] lineTxt;
00335         }
00336 
00337         void CCodeBrancheRunDebug::printCurrentSourceCodeLine() const
00338         {
00339                 uint16 lineNumber = getCurrentSourceCodeLineNumber();
00340                 printSourceCodeLine(lineNumber, lineNumber);
00341         }
00342 
00343         uint16  CCodeBrancheRunDebug::getCurrentSourceCodeLineNumber() const
00344         {
00345                 if (_Ip ==0)
00346                         return 0; // This shouldn't appen.
00347                 
00348                 if (_LineInSourceCodeArray[_Ip-1] != 0)
00349                 {
00350                         return (_LineInSourceCodeArray[_Ip-1]);
00351                 }
00352                 else
00353                 {
00354                         sint32 i = 2;
00355                         while (_LineInSourceCodeArray[_Ip-i] == 0)
00356                         {
00357                                 i++;
00358                         }
00359                         return _LineInSourceCodeArray[_Ip-i];
00360                 }
00361         }
00362 
00363         void CCodeBrancheRunDebug::printVariable (CCodeContext &P, const char* c) const
00364         {
00365                 sint32 begin;
00366                 const NLAIAGENT::IObjectIA* base;
00367                 const NLAIAGENT::IVarName* ivn;
00368                 NLAIAGENT::CStringType* st;
00369                 NLAIAGENT::CStringVarName* svn;
00370                 char* buf = new char[1024*8];
00371                 char* bufA = new char[1024*8];
00372                 char* bufX = new char[1024*8];
00373                 int i;
00374                 int j;
00375                 char*  dotPos;
00376                 buf[0] = 0;
00377                 bufA[0] = 0;
00378                 bufX[0] = 0;
00379 
00380                 // Wee look if it's a composed varaible. If so, we just store the first part in buf and the second in bufX.
00381                 strcpy (buf, c);
00382                 dotPos =  strchr(buf,'.');
00383                 if(dotPos != NULL)
00384                 {
00385                         strcpy(bufX, dotPos+1);
00386                         strchr(buf,'.')[0]= '\0';
00387                 }
00388 
00389                 // Seek in the heap from the bottom the buf in order to know if it's a local variable.
00390                 begin = (int)P.ContextDebug.HeapDebug;
00391                 for (i = begin; i>=0; i--)
00392                 {
00393                         base = P.ContextDebug.HeapDebug[i];
00394                         if (base)
00395                         {
00396                                 if (base->getType() == NLAIAGENT::CStringType::IdStringType)
00397                                 {
00398                                         st = (NLAIAGENT::CStringType*) base;
00399                                         ivn = &(st->getStr());
00400                                         if (ivn->getType() == NLAIAGENT::CStringVarName::IdStringVarName)
00401                                         {
00402                                                 svn = (NLAIAGENT::CStringVarName*) ivn;
00403                                                 if (strcmp(svn->getString(), buf) == 0)
00404                                                 {
00405                                                         break;
00406                                                 }
00407                                         }
00408                                 }
00409                         }
00410                 }
00411 
00412                 base = NULL;
00413                 if (i>=0)
00414                 {
00415                         // It's a local variable
00416                         base = P.Heap[i];
00417                 }
00418                 else
00419                 {
00420                         j = P.Self->getStaticMemberIndex(NLAIAGENT::CStringVarName(buf));
00421                         if (j >= 0)
00422                         {
00423                                 // It's a static member.
00424                                 base = P.Self->getStaticMember(j);
00425                         }
00426                 }
00427 
00428                 if (base != NULL)
00429                 {
00430                         // We found a reference.
00431                         if (bufX[0] == 0)
00432                         {
00433                                 // The variable wasn't composit.
00434                                 std::string buf;
00435                                 base->getDebugString(buf);
00436                                 InputOutput->Echo("%s\n",buf.c_str());
00437                         }
00438                         else
00439                         {
00440                                 // The variable was composit.
00441                                 dotPos =  strchr(bufX,'.');
00442                                 while (dotPos != NULL)
00443                                 {
00444                                         strcpy(buf,bufX);
00445                                         strcpy(bufX, dotPos+1);
00446                                         strcpy(bufA,buf);
00447                                         strchr(bufA,'.')[0]= '\0';
00448                                         j = base->getStaticMemberIndex(NLAIAGENT::CStringVarName(bufA));
00449                                         if (j >= 0)
00450                                         {
00451                                                 base =  base->getStaticMember(j);
00452                                         }
00453                                         dotPos =  strchr(bufX,'.');
00454                                 }
00455                                 j = base->getStaticMemberIndex(NLAIAGENT::CStringVarName(bufX));
00456                                 if (j >= 0)
00457                                 {
00458                                         std::string buf;
00459                                         base->getStaticMember(j)->getDebugString(buf);
00460                                         InputOutput->Echo("%s\n",buf.c_str());
00461                                 }
00462                         }
00463                 }
00464 
00465                 delete[] buf;
00466                 delete[] bufA;
00467                 delete[] bufX;
00468         }
00469         void CCodeBrancheRunDebug::printArgs (CCodeContext &P) const
00470         {
00471                 if (P.Param.size() >0 )
00472                 {
00473                         NLAIAGENT::CIteratorContener Ita = ((NLAIAGENT::CGroupType *) P.ContextDebug.Param.back())->getIterator();
00474                         NLAIAGENT::CIteratorContener Itb = ((NLAIAGENT::CGroupType *) P.Param.back())->getIterator();;                  
00475                         while(!Ita.isInEnd())
00476                         {                       
00477                                 std::string buf;
00478                                 Ita++;
00479                                 NLAIAGENT::CStringType *p = (NLAIAGENT::CStringType *)Itb++;
00480                                 p->getDebugString(buf);
00481 //                              InputOutput->Echo("%s = %s\n", o->getStr().getString(), buf);
00482                         }
00483                 }
00484         }
00485 
00486         bool CCodeBrancheRunDebug::readCommandLine(CCodeContext &P, const char* buf)
00487         {
00488                 char* sourceFileName;
00489                 char* varName;
00490                 uint32 lineNumber;
00491                 sint32 first, last;
00492                 bool ret = false;
00493 
00494                 switch (buf[0])
00495                 {
00496                 case 'p' :
00497                         // p(rint) expression   | Inspect variables / attributes, evaluate expressions, call functions/methods.
00498                         varName = new char[1024];
00499                         sscanf(buf+1, "%s", varName);
00500                         printVariable(P,varName);
00501                         delete[] varName;
00502                         break;
00503                 case 'w' :
00504                         // w(here)                              | Dump the call stack : the context of the current program location.
00505                         P.ContextDebug.callStackPrint(InputOutput);
00506                         break;
00507                 case 'u' :
00508                         // u(p)                                 | Travel up (to newer) frames in the call stack.
00509                         P.ContextDebug.stepIndexUp();
00510                         break;
00511                 case 'd' :
00512                         // d(own)                               | Travel down (to older) frames in the call stack.
00513                         P.ContextDebug.stepIndexDown();
00514                         break;
00515                 case 'l' :
00516                         // l(ist) first?, last? | List the current context's source code file : 11 lines, or around lines numbers.
00517                         first = last = 0;
00518                         sscanf(buf+1, "%d %d",&first, &last);
00519                         if (0 == first) first = this->getCurrentSourceCodeLineNumber() - 6;
00520                         if (0 >  first) first = 0;
00521                         if (0 == last) last = first + 11;
00522                         printSourceCodeLine(first, last);
00523                         break;
00524                 case 'b' :
00525                         // b(reak) line?                | Set more breakpoints on functions or line numbers, or list active breaks.
00526                         sourceFileName = new char[1024];
00527                         sourceFileName[0] = 0;
00528                         lineNumber = 0;
00529                         sscanf(buf+1,"%d %s",&lineNumber,sourceFileName);
00530                         if (0 == lineNumber)
00531                         {
00532                                 P.ContextDebug.printActiveBeaks(InputOutput);
00533                         }
00534                         else
00535                         {
00536                                 if (sourceFileName[0])
00537                                 {
00538                                         P.ContextDebug.addBreakPoint((uint16)lineNumber,sourceFileName);
00539                                 }
00540                                 else
00541                                 {
00542                                         P.ContextDebug.addBreakPoint((uint16)lineNumber,getSourceFileName().c_str());
00543                                 }
00544                         }
00545                         delete[] sourceFileName;
00546                         break;
00547                 case 'e' :
00548                         // e(rase) line?                | Erase a specific breakpoint (or all of them)
00549                         sourceFileName = new char[1024];
00550                         sourceFileName[0] = 0;
00551                         sscanf(buf+1,"%d %s",&lineNumber,sourceFileName);
00552                         if (sourceFileName[0])
00553                         {
00554                                 P.ContextDebug.eraseBreakPoint((uint16)lineNumber,sourceFileName);
00555                         }
00556                         else
00557                         {
00558                                 P.ContextDebug.eraseBreakPoint((uint16)lineNumber,getSourceFileName().c_str());
00559                         }
00560                         delete[] sourceFileName;
00561                         break;
00562                 case 's' :
00563                         // s(tep)                               | Run the next line and stop; stop in called functions.
00564                         P.ContextDebug.setDebugMode(stepInMode);
00565                         ret = true;
00566                         break;
00567                 case 'n' :
00568                         // n(ext)                               | Run the next line and stop, but don't stop in functions it calls.
00569                         P.ContextDebug.setDebugMode(stepByStepMode);
00570                         ret = true;
00571                         break;
00572                 case 'r' :
00573                         // r(eturn)                             | Continue silently until the current function returns.
00574                         P.ContextDebug.setDebugMode(stepOutMode);
00575                         ret = true;
00576                         break;
00577                 case 'c' :
00578                         // c(ontinue)                   | Continue programm execution until an error, breakpoint, or exit.
00579                         P.ContextDebug.setDebugMode(runMode);
00580                         ret = true;
00581                         break;
00582                 case 'a' :
00583                         // a(rgs)                               | Print arguments passed to the current context's function.
00584                         printArgs(P);
00585                         break;
00586                 case 'q' :
00587                         // q(uit)                               | Quit the debugger; also terminates the code being debugged.
00588                         P.ContextDebug.setDebugMode(stopMode);
00589                         ret = true;
00590                         break;
00591                 case 0 :
00592                         // <enter-key>                  | Repeat the last command.
00593                         ret = this->readCommandLine(P, P.ContextDebug.getLastCommandLine());
00594                         break;
00595                 case 'h' :
00596                         // h(elp) command ?             | Get command help; you can forget the rest if you remember 'h'.
00597 
00598                         InputOutput->Echo("p(rint) expr.\t| Inspect variables / attributes.\n");
00599                         InputOutput->Echo("w(here)\t\t| Dump the call stack.\n");
00600                         InputOutput->Echo("u(p)\t\t| Travel up (to newer) frames in the call stack.\n");
00601                         InputOutput->Echo("d(own)\t\t| Travel down (to older) frames in the call stack.\n");
00602                         InputOutput->Echo("l(ist) f?, l?\t| List the current context's source code file.\n");
00603                         InputOutput->Echo("b(reak) line?\t| Set more breakpoints on line numbers, or list active breaks.\n");
00604                         InputOutput->Echo("e(rase) line?\t| Erase a specific breakpoint (or all of them)\n");
00605                         InputOutput->Echo("s(tep)\t\t| Run the next line and stop; stop in called functions.\n");
00606                         InputOutput->Echo("n(ext)\t\t| Run the next line and stop, don't stop in functions it calls.\n");
00607                         InputOutput->Echo("r(eturn)\t| Continue silently until the current function returns.\n");
00608                         InputOutput->Echo("c(ontinue)\t| Continue programm execution until breakpoint, or exit.\n");
00609                         InputOutput->Echo("a(rgs)\t\t| Print arguments passed to the current context's function.\n");
00610                         InputOutput->Echo("q(uit)\t\t| Quit the debugger; also terminates the code being debugged.\n");
00611                         InputOutput->Echo("<enter-key>\t| Repeat the last command.\n");
00612                         InputOutput->Echo("h(elp) command ?| Get command help; you can forget the rest if you remember 'h'.\n");
00613                         break;
00614                 }
00615 
00616                 return ret;
00617         }
00618 }
code_branche_run_debug.cpp
