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 #include "nel/ai/script/interpret_object_agent.h"
00027 #include "nel/ai/script/interpret_object_message.h"
00028 
00029 namespace NLAISCRIPT
00030 {
00031         CLdbOpCode::CLdbOpCode(const NLAIAGENT::IObjectIA &b)
00032         {
00033           _B = (NLAIAGENT::IObjectIA *)b.clone();
00034 
00035         }
00036 
00037         NLAIAGENT::TProcessStatement CLdbOpCode::runOpCode(CCodeContext &context)
00038         {
00039                 context.Stack ++;
00040                 context.Stack[(int)context.Stack] = (NLAIAGENT::IObjectIA *)_B->clone();
00041                 return NLAIAGENT::IObjectIA::ProcessIdle;
00042         }
00043 
00044         void CLdbOpCode::getDebugResult(std::string &str,CCodeContext &context) const
00045         {                       
00046                 std::string X;
00047                 _B->getDebugString(X);
00048                 str += "ldb ";
00049                 str += X;               
00050         }
00051         NLAIAGENT::TProcessStatement CLdbMemberOpCode::runOpCode(CCodeContext &context)
00052         {
00053                 context.Stack ++;
00054 
00055                 NLAIAGENT::IObjectIA *t = (NLAIAGENT::IObjectIA *)(context.Self)->getStaticMember(_B);//->clone();
00056                 t->incRef();
00057                 context.Stack[(int)context.Stack] = t;
00058                 return NLAIAGENT::IObjectIA::ProcessIdle;;
00059         }
00060 
00061         void CLdbMemberOpCode::getDebugResult(std::string &str,CCodeContext &context) const
00062         {               
00063                 const NLAIAGENT::IObjectIA *r = (context.Self);
00064                 std::string name = "????";
00065                 std::string className = "????";
00066 
00067                 if(((const NLAIC::CTypeOfObject &)r->getType()) & NLAIC::CTypeOfObject::tInterpret)
00068                 {
00069                         if(((const NLAIC::CTypeOfObject &)r->getType()) & NLAIC::CTypeOfObject::tAgent)
00070                         {                       
00071                                 name = ((NLAIAGENT::CAgentScript *)r)->getClass()->getComponentName(_B);
00072                         }
00073                         else
00074                         if(((const NLAIC::CTypeOfObject &)r->getType()) & NLAIC::CTypeOfObject::tMessage)
00075                         {                       
00076                                 name = ((NLAIAGENT::CMessageScript *)r)->getCreatorClass()->getComponentName(_B);
00077                         }
00078                 }
00079                 className = (const char *)r->getType();
00080                 r = r->getStaticMember(_B);
00081                                         
00082                 str += NLAIC::stringGetBuild("ldb le composant membre %d named: '%s' de la class '%s'",_B, name.c_str(),className.c_str());
00083         }
00084 
00085 
00086         NLAIAGENT::TProcessStatement CLdbStackMemberiOpCode::runOpCode(CCodeContext &context)
00087         {
00088                 NLAIAGENT::IObjectIA *a = ((NLAIAGENT::IObjectIA *)context.Stack);
00089                 NLAIAGENT::IObjectIA *obj = a; 
00090                 std::list<sint32>::iterator i = _I.begin();
00091                 sint32 n = _I.size() - 1;
00092                 
00093                 while(n --)
00094                 {                       
00095                         a = (NLAIAGENT::IObjectIA *)a->getStaticMember(*i++);
00096                 }
00097                 //context.Stack[(int)context.Stack] = (NLAIAGENT::IObjectIA *)a->getStaticMember(*i)->clone();
00098                 a = (NLAIAGENT::IObjectIA *)a->getStaticMember(*i);
00099                 a->incRef();
00100                 context.Stack[(int)context.Stack] = a;
00101                 obj->release();
00102                 return NLAIAGENT::processIdle;
00103         }
00104 
00105         void CLdbStackMemberiOpCode::getDebugResult(std::string &str,CCodeContext &context) const
00106         {       
00107                 NLAIAGENT::IObjectIA *a = ((NLAIAGENT::IObjectIA *)context.Stack);              
00108                 std::list<sint32>::const_iterator i = _I.begin();
00109                 sint32 n = _I.size() - 1;
00110                 std::string name = "????";
00111                 std::string className = "????";
00112                 while(n --)
00113                 {
00114                         if(((const NLAIC::CTypeOfObject &)a->getType()) & NLAIC::CTypeOfObject::tInterpret)
00115                         {
00116                                 if(((const NLAIC::CTypeOfObject &)a->getType()) & NLAIC::CTypeOfObject::tAgent)
00117                                 {                       
00118                                         name = ((NLAIAGENT::CAgentScript *)a)->getClass()->getComponentName(*i);
00119                                 }
00120                                 else
00121                                 if(((const NLAIC::CTypeOfObject &)a->getType()) & NLAIC::CTypeOfObject::tMessage)
00122                                 {                       
00123                                         name = ((NLAIAGENT::CMessageScript *)a)->getCreatorClass()->getComponentName(*i);
00124                                 }
00125                         }
00126                         className = (const char *)a->getType();
00127                         a = (NLAIAGENT::IObjectIA *)a->getStaticMember(*i++);
00128                 }
00129                 std::string txt;
00130                 a->getStaticMember(*i)->getDebugString(txt);
00131                 str += NLAIC::stringGetBuild("ldb %s le composon '%s' membre sur la pile de la class '%s'",txt.c_str(),name.c_str(),className.c_str());
00132         }
00133 
00134         NLAIAGENT::TProcessStatement CLdbHeapMemberiOpCode::runOpCode(CCodeContext &context)
00135         {
00136                 NLAIAGENT::IObjectIA *a = (NLAIAGENT::IObjectIA *)context.Heap[(int)_N];
00137 
00138 #ifdef NL_DEBUG
00139                 std::string text;
00140                 text = NLAIC::stringGetBuild("ldb le composant membre sur le heap de la class '%s'",(const char *)a->getType());                
00141 #endif
00142                 std::list<sint32>::iterator i = _I.begin();             
00143                 sint32 n = _I.size() - 1;
00144                 while(n --)
00145                 {
00146                         
00147                         a = (NLAIAGENT::IObjectIA *)a->getStaticMember(*i++);
00148                 }
00149                 a = (NLAIAGENT::IObjectIA *)a->getStaticMember(*i);//->clone();
00150                 context.Stack ++;
00151                 a->incRef();
00152                 context.Stack[(int)context.Stack] = a;
00153                 return NLAIAGENT::processIdle;
00154         }
00155 
00156         void CLdbHeapMemberiOpCode::getDebugResult(std::string &str,CCodeContext &context) const
00157         {                                               
00158                 NLAIAGENT::IObjectIA *a = (NLAIAGENT::IObjectIA *)context.Heap[(int)_N];
00159 #ifdef NL_DEBUG
00160                 std::string text;
00161                 text = NLAIC::stringGetBuild("ldb le composant membre sur le heap de la class '%s'",(const char *)a->getType());                
00162 #endif
00163                 
00164                 std::string name = "????";
00165                 std::string className = "????";
00166                 std::list<sint32>::const_iterator i = _I.begin();
00167                 while(i != _I.end())
00168                 {
00169                         if(((const NLAIC::CTypeOfObject &)a->getType()) & NLAIC::CTypeOfObject::tInterpret)
00170                         {                       
00171                                 if(((const NLAIC::CTypeOfObject &)a->getType()) & NLAIC::CTypeOfObject::tAgent)
00172                                 {                       
00173                                         name = ((NLAIAGENT::CAgentScript *)a)->getClass()->getComponentName(*i);
00174                                 }
00175                                 else
00176                                 if(((const NLAIC::CTypeOfObject &)a->getType()) & NLAIC::CTypeOfObject::tMessage)
00177                                 {                       
00178                                         name = ((NLAIAGENT::CMessageScript *)a)->getCreatorClass()->getComponentName(*i);
00179                                 }
00180                         }
00181                         className = (const char *)a->getType();
00182                         a = (NLAIAGENT::IObjectIA *)a->getStaticMember(*i++);
00183                 }
00184 
00185                 std::string txt;
00186                 a->getDebugString(txt);
00187                 str += NLAIC::stringGetBuild("ldb %s le composon '%s' membre sur le heap de la class '%s'",txt.c_str(),name.c_str(),className.c_str());         
00188         }
00189 
00190         NLAIAGENT::TProcessStatement CLdbMemberiOpCode::runOpCode(CCodeContext &context)
00191         {
00192                 context.Stack ++;
00193                 NLAIAGENT::IObjectIA *obj = (NLAIAGENT::IObjectIA *)context.Self;
00194                 std::list<sint32>::iterator i = _I.begin();
00195                 while(i != _I.end())
00196                 {
00197                         obj = (NLAIAGENT::IObjectIA *)obj->getStaticMember(*i++);
00198                 }
00199                 context.Stack[(int)context.Stack] = (NLAIAGENT::IObjectIA *)obj;//->clone();
00200                 obj->incRef();
00201                 
00202                 return NLAIAGENT::IObjectIA::ProcessIdle;
00203         }
00204 
00205         void CLdbMemberiOpCode::getDebugResult(std::string &str,CCodeContext &context) const
00206         {                       
00207                 NLAIAGENT::IObjectIA *obj = (NLAIAGENT::IObjectIA *)context.Self;
00208                 std::list<sint32>::const_iterator i = _I.begin();
00209                 int j=0;
00210                 std::string className, name = "????";
00211 
00212                 while(i != _I.end())
00213                 {
00214                         j = *i++;
00215                         if(((const NLAIC::CTypeOfObject &)obj->getType()) & NLAIC::CTypeOfObject::tInterpret)
00216                         {                       
00217                                 if(((const NLAIC::CTypeOfObject &)obj->getType()) & NLAIC::CTypeOfObject::tAgent)
00218                                 {                       
00219                                         name = ((NLAIAGENT::CAgentScript *)obj)->getClass()->getComponentName(j);
00220                                 }
00221                                 else
00222                                 if(((const NLAIC::CTypeOfObject &)obj->getType()) & NLAIC::CTypeOfObject::tMessage)
00223                                 {                       
00224                                         name = ((NLAIAGENT::CMessageScript *)obj)->getCreatorClass()->getComponentName(j);
00225                                 }
00226                         }
00227                         className = (const char *)obj->getType();
00228                         obj = (NLAIAGENT::IObjectIA *)obj->getStaticMember(j);
00229                 }                       
00230                                         
00231                 str += NLAIC::stringGetBuild("ldb le composon '%s' membre <%d> member de la class '%s'",name.c_str(),j,className.c_str());              
00232         }
00233 
00234         NLAIAGENT::TProcessStatement CLdbRefOpCode::runOpCode(CCodeContext &context)
00235         {
00236                 NLAIAGENT::IObjectIA *o = (NLAIAGENT::IObjectIA *)context.Heap[_B];//->clone();
00237                 o->incRef();
00238                 context.Stack ++;
00239                 context.Stack[(int)context.Stack] = o;
00240                 return NLAIAGENT::IObjectIA::ProcessIdle;
00241         }
00242 
00243         void CLdbRefOpCode::getDebugResult(std::string &str,CCodeContext &context) const
00244         {
00245                 std::string X;
00246                 context.Heap[_B]->getDebugString(X);
00247                 str += NLAIC::stringGetBuild("ldb<%d>: %s",_B,X.c_str());
00248         }
00249 }
opcode_ldb.cpp
