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 #include "nel/ai/script/compilateur.h"
00025 #include "nel/ai/agent/agent_script.h"
00026 
00027 namespace NLAISCRIPT
00028 {
00029         void CLibMemberMethod::getDebugResult(std::string &str,CCodeContext &context) const
00030         {               
00031                 const NLAIAGENT::IObjectIA *obj = (context.Self);
00032                 str = NLAIC::stringGetBuild("methode %s",obj->getMethodeMemberDebugString(0,_Id).c_str());      
00033         }
00034 
00035         NLAIAGENT::TProcessStatement CLibMemberMethod::runOpCode(CCodeContext &context)
00036         {
00037                 NLAIAGENT::IObjectIA *param = context.Stack[(int)context.Stack];
00038 
00039                 context.Param.push_back(param);
00040                 param->incRef();
00041 
00042                 NLAIAGENT::IObjectIA::CProcessResult r = ((NLAIAGENT::IObjectIA *)context.Self)->runMethodeMember(_Id,param);
00043 
00044                 if(r.Result != NULL)
00045                 {
00046                         param->release(); 
00047                         context.Stack[(int)context.Stack] = r.Result;
00048                 }
00049                 else
00050                 {
00051                         context.Stack --;
00052                 }
00053                 
00054                 context.Param.back()->release();
00055                 context.Param.pop_back();
00056                 return r.ResultState;
00057         }
00058 
00059         void CLibMemberInheritedMethod::getDebugResult(std::string &str,CCodeContext &context) const
00060         {               
00061                 const NLAIAGENT::IObjectIA *obj = (context.Self);
00062                 str = NLAIC::stringGetBuild("methode %s",obj->getMethodeMemberDebugString(_Inheritance,_Id).c_str());
00063         }
00064 
00065         NLAIAGENT::TProcessStatement CLibMemberInheritedMethod::runOpCode(CCodeContext &context)
00066         {
00067                 NLAIAGENT::IObjectIA *param = context.Stack[(int)context.Stack];
00068                 NLAIAGENT::IObjectIA::CProcessResult r = ((NLAIAGENT::IObjectIA *)context.Self)->runMethodeMember(_Inheritance,_Id,param);
00069 
00070                 context.Param.push_back(param);
00071                 param->incRef();
00072                 
00073                 if(r.Result != NULL)
00074                 {
00075                         param->release();
00076                         context.Stack[(int)context.Stack] = r.Result;
00077                 }
00078                 else
00079                 {
00080                         context.Stack --;
00081                 }
00082                 context.Param.back()->release();
00083                 context.Param.pop_back();       
00084                 return r.ResultState;
00085         }
00086 
00087         void CLibMemberMethodi::getDebugResult(std::string &str,CCodeContext &context) const
00088         {               
00089                 const NLAIAGENT::IObjectIA *obj = (context.Self);
00090                 std::list<sint32>::const_iterator it = _I.begin();
00091                 while(it != _I.end())
00092                 {
00093                          obj = (NLAIAGENT::IObjectIA *)obj->getStaticMember(*it++);
00094                 }               
00095 
00096                 str = NLAIC::stringGetBuild("methode %s",obj->getMethodeMemberDebugString(_Inheritance,_Id).c_str());
00097         }
00098 
00099         NLAIAGENT::TProcessStatement CLibMemberMethodi::runOpCode(CCodeContext &context)
00100         {
00101                 std::list<sint32>::iterator it = _I.begin();
00102                 NLAIAGENT::IObjectIA *param = context.Stack[(int)context.Stack];
00103                 NLAIAGENT::IObjectIA *obj = (NLAIAGENT::IObjectIA *)context.Self;
00104 
00105                 context.Param.push_back(param);
00106                 param->incRef();
00107                 
00108                 while(it != _I.end())
00109                 {
00110                          obj = (NLAIAGENT::IObjectIA *)obj->getStaticMember(*it++);
00111                 }
00112 
00113                 NLAIAGENT::IObjectIA::CProcessResult r;
00114 
00115                 if(_Inheritance )  r = obj->runMethodeMember(_Inheritance,_Id,param);
00116                 else r = obj->runMethodeMember(_Id,param);
00117                 
00118                 if(r.Result != NULL)
00119                 {
00120                         param->release();
00121                         context.Stack[(int)context.Stack] = r.Result;
00122                 }
00123                 else
00124                 {
00125                         context.Stack --;
00126                 }
00127                 context.Param.back()->release();
00128                 context.Param.pop_back();
00129                 return r.ResultState;
00130         }
00131 
00132         void CLibCallMethod::getDebugResult(std::string &str,CCodeContext &context) const
00133         {                               
00134                 str = NLAIC::stringGetBuild("methode %s",_Lib->getMethodeMemberDebugString(0,_Id).c_str());
00135         }
00136 
00137         NLAIAGENT::TProcessStatement CLibCallMethod::runOpCode(CCodeContext &context)
00138         {
00139                 NLAIAGENT::IObjectIA *param = context.Stack[(int)context.Stack];
00140                 NLAIAGENT::IObjectIA::CProcessResult r = _Lib->runMethodeMember(_Id,param);
00141 
00142                 context.Param.push_back(param);
00143                 param->incRef();
00144 
00145                 if(r.Result != NULL)
00146                 {
00147                         param->release();
00148                         context.Stack[(int)context.Stack] = r.Result;
00149                 }
00150                 else
00151                 {
00152                         context.Stack --;
00153                 }
00154                 context.Param.back()->release();
00155                 context.Param.pop_back();
00156                 return r.ResultState;
00157         }
00158 
00159         void CLibCallInheritedMethod::getDebugResult(std::string &str,CCodeContext &context) const
00160         {                               
00161                 str = NLAIC::stringGetBuild("methode %s",_Lib->getMethodeMemberDebugString(_Inheritance,_Id).c_str());
00162         }
00163 
00164         NLAIAGENT::TProcessStatement CLibCallInheritedMethod::runOpCode(CCodeContext &context)
00165         {
00166                 NLAIAGENT::IObjectIA *param = context.Stack[(int)context.Stack];
00167                 NLAIAGENT::IObjectIA::CProcessResult r = _Lib->runMethodeMember(_Inheritance,_Id,param);
00168 
00169                 context.Param.push_back(param);
00170                 param->incRef();
00171                 
00172                 if(r.Result != NULL)
00173                 {
00174                         param->release();
00175                         context.Stack[(int)context.Stack] = r.Result;
00176                 }
00177                 else
00178                 {
00179                         context.Stack --;
00180                 }
00181                 context.Param.back()->release();
00182                 context.Param.pop_back();
00183                 return r.ResultState;
00184         }
00185 
00186         void CLibCallMethodi::getDebugResult(std::string &str,CCodeContext &context) const
00187         {               
00188                 std::list<sint32>::const_iterator it = _I.begin();
00189                 const NLAIAGENT::IObjectIA *obj = _Lib;
00190                 while(it != _I.end())
00191                 {
00192                          obj = (NLAIAGENT::IObjectIA *)obj->getStaticMember(*it++);
00193                 }               
00194 
00195                 str = NLAIC::stringGetBuild("methode %s",obj->getMethodeMemberDebugString(_Inheritance,_Id).c_str());
00196         }
00197 
00198         NLAIAGENT::TProcessStatement CLibCallMethodi::runOpCode(CCodeContext &context)
00199         {
00200                 std::list<sint32>::iterator it = _I.begin();
00201                 NLAIAGENT::IObjectIA *param = context.Stack[(int)context.Stack];
00202                 NLAIAGENT::IObjectIA *obj = _Lib;
00203                 while(it != _I.end())
00204                 {
00205                          obj = (NLAIAGENT::IObjectIA *)obj->getStaticMember(*it++);
00206                 }
00207 
00208                 NLAIAGENT::IObjectIA::CProcessResult r;
00209 
00210                 context.Param.push_back(param);
00211                 param->incRef();
00212 
00213                 if(_Inheritance )  r = obj->runMethodeMember(_Inheritance,_Id,param);
00214                 else r = obj->runMethodeMember(_Id,param);
00215                 
00216                 if(r.Result != NULL)
00217                 {
00218                         param->release();
00219                         context.Stack[(int)context.Stack] = r.Result;
00220                 }
00221                 else
00222                 {
00223                         context.Stack --;
00224                 }
00225                 context.Param.back()->release();
00226                 context.Param.pop_back();
00227                 return r.ResultState;
00228         }
00229 
00230         void CLibStackMemberMethod::getDebugResult(std::string &str,CCodeContext &context) const
00231         {
00232                 std::list<sint32>::const_iterator it = _I.begin();
00233                 const NLAIAGENT::IObjectIA *obj = context.Stack[(int)context.Stack - 1];
00234                 while(it != _I.end())
00235                 {
00236                          obj = (NLAIAGENT::IObjectIA *)obj->getStaticMember(*it++);
00237                 }               
00238 
00239                 str = NLAIC::stringGetBuild("methode %s",obj->getMethodeMemberDebugString(_H,_Id).c_str());
00240         }
00241 
00242         NLAIAGENT::TProcessStatement CLibStackMemberMethod::runOpCode(CCodeContext &context)
00243         {
00244                 NLAIAGENT::IObjectIA *obj = context.Stack[(int)context.Stack - 1];
00245                 obj->incRef();
00246                 NLAIAGENT::IObjectIA *param = context.Stack[(int)context.Stack];
00247                 param->incRef();
00248                 context.Stack --;
00249                 context.Stack --;
00250                 std::list<sint32>::iterator it = _I.begin();
00251                 while(it != _I.end())
00252                 {
00253                          obj = (NLAIAGENT::IObjectIA *)obj->getStaticMember(*it++);
00254                 }
00255 
00256                 NLAIAGENT::IObjectIA::CProcessResult r;
00257 
00258                 context.Param.push_back(param);
00259                 param->incRef();
00260 
00261                 if(_H )  r = obj->runMethodeMember(_H,_Id,param);
00262                 else r = obj->runMethodeMember(_Id,param);
00263                 
00264                 param->release();
00265                 if(r.Result != NULL)
00266                 {                       
00267                         context.Stack ++;
00268                         context.Stack[(int)context.Stack] = r.Result;
00269                 }
00270 
00271                 context.Param.back()->release();
00272                 context.Param.pop_back();
00273                 return r.ResultState;
00274         }
00275 
00276         void CLibStackNewMemberMethod::getDebugResult(std::string &str,CCodeContext &context) const
00277         {
00278                 std::list<sint32>::const_iterator it = _I.begin();
00279                 const NLAIAGENT::IObjectIA *obj = context.Stack[(int)context.Stack];
00280                 while(it != _I.end())
00281                 {
00282                          obj = (NLAIAGENT::IObjectIA *)obj->getStaticMember(*it++);
00283                 }               
00284 
00285                 str = NLAIC::stringGetBuild("methode %s",obj->getMethodeMemberDebugString(_H,_Id).c_str());
00286         }
00287 
00288         NLAIAGENT::TProcessStatement CLibStackNewMemberMethod::runOpCode(CCodeContext &context)
00289         {
00290                 NLAIAGENT::IObjectIA *obj = context.Stack[(int)context.Stack];
00291                 obj->incRef();
00292                 NLAIAGENT::IObjectIA *param = context.Stack[(int)context.Stack - 1];            
00293                 context.Stack --;
00294                 context.Stack[(int)context.Stack] = obj;
00295                 std::list<sint32>::iterator it = _I.begin();
00296                 while(it != _I.end())
00297                 {
00298                          obj = (NLAIAGENT::IObjectIA *)obj->getStaticMember(*it++);
00299                 }
00300 
00301                 NLAIAGENT::IObjectIA::CProcessResult r;
00302 
00303                 context.Param.push_back(param);
00304                 param->incRef();
00305 
00306                 if(_H )  r = obj->runMethodeMember(_H,_Id,param);
00307                 else r = obj->runMethodeMember(_Id,param);
00308                 param->release();
00309                 if(r.Result != NULL)
00310                 {                       
00311                         context.Stack ++;
00312                         context.Stack[(int)context.Stack] = r.Result;
00313                 }
00314 
00315                 context.Param.back()->release();
00316                 context.Param.pop_back();
00317                 
00318                 return r.ResultState;
00319         }
00320 
00321         void CLibHeapMemberMethod::getDebugResult(std::string &str,CCodeContext &context) const
00322         {
00323                 std::list<sint32>::const_iterator it = _I.begin();
00324                 const NLAIAGENT::IObjectIA *obj = context.Heap[(int)_Index];
00325                 while(it != _I.end())
00326                 {
00327                          obj = (NLAIAGENT::IObjectIA *)obj->getStaticMember(*it++);
00328                 }               
00329 
00330                 str = NLAIC::stringGetBuild("methode %s",obj->getMethodeMemberDebugString(_H,_Id).c_str());
00331         }
00332 
00333         NLAIAGENT::TProcessStatement CLibHeapMemberMethod::runOpCode(CCodeContext &context)
00334         {
00335                 NLAIAGENT::IObjectIA *obj = context.Heap[(int)_Index];          
00336                 NLAIAGENT::IObjectIA *param = context.Stack[(int)context.Stack];
00337 
00338                 context.Param.push_back(param);
00339                 param->incRef();
00340 
00341 #ifdef NL_DEBUG
00342                 int db_size = context.Param.size();
00343                 static sint kkkkk = 0;
00344                 
00345                 const char *txtDbg = (const char *)obj->getType();
00346 
00347                 kkkkk ++;
00348 #endif
00349                 
00350                 std::list<sint32>::iterator it = _I.begin();
00351                 while(it != _I.end())
00352                 {
00353                          obj = (NLAIAGENT::IObjectIA *)obj->getStaticMember(*it++);
00354                 }
00355 
00356 
00357                 NLAIAGENT::IObjectIA::CProcessResult r;
00358 
00359                 if (_H )  
00360                         r = obj->runMethodeMember(_H,_Id,param);
00361                 else 
00362                         r = obj->runMethodeMember(_Id,param);
00363                 
00364                 if(r.Result != NULL)
00365                 {
00366                         param->release();
00367                         context.Stack[(int)context.Stack] = r.Result;
00368                 }
00369                 else
00370                 {
00371                         context.Stack --;
00372                 }
00373 
00374 #ifdef NL_DEBUG
00375                 db_size = context.Param.size();
00376                 if(!db_size) throw;
00377 #endif
00378                 NLAIAGENT::IObjectIA *p = context.Param.back();
00379                 context.Param.pop_back();
00380                 p->release();
00381                 
00382                 return r.ResultState;           
00383         }       
00384 }
opcode_call_lib_method.cpp
