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/agent/message_script.h"
00025 #include "nel/ai/script/interpret_object_message.h"
00026 #include "nel/ai/script/codage.h"
00027 #include "nel/ai/script/type_def.h"
00028 #include "nel/ai/script/object_unknown.h"
00029 #include "nel/ai/agent/msg.h"
00030 #include "nel/ai/e/ai_exception.h"
00031 
00032 namespace NLAIAGENT
00033 {
00034         static CGroupType listBidon;
00035 
00036         CMessageScript::CMessageScript(const CMessageScript &m):IMessageBase(m)
00037         {
00038                 _MessageClass = m._MessageClass;
00039                 /*if ( _MessageClass )
00040                         _MessageClass->incRef();*/
00041                 //CVectorGroupType *x = new CVectorGroupType(m.size());
00042         }
00043         
00044         CMessageScript::CMessageScript(NLAISCRIPT::CMessageClass *b) : _MessageClass( b )
00045         {
00046                 /*if ( _MessageClass )
00047                         _MessageClass->incRef();*/
00048         }
00049 
00050         CMessageScript::CMessageScript( std::list<IObjectIA *> &components, NLAISCRIPT::CMessageClass *message_class ): _MessageClass( message_class )
00051         {       
00052                 /*if ( _MessageClass )
00053                         _MessageClass->incRef();*/
00054 
00055                 // Creates the static components array
00056                 CVectorGroupType *x = new CVectorGroupType(components.size());
00057                 std::list<IObjectIA *>::iterator it_c = components.begin();             
00058                 sint32 i = 0;
00059                 while ( it_c != components.end() )
00060                 {                       
00061                         x->setObject(i,*it_c);
00062                         it_c++;                                 
00063                         i ++;
00064                 }
00065                 setMessageGroup(x);
00066                 setGroup(CMessageGroup::msgScriptingGroup);
00067         }       
00068 
00069         CMessageScript::~CMessageScript()
00070         {
00071 /*#ifdef NL_DEBUG
00072                 const char *name = (const char *)getType();
00073 #endif*/
00074                 /*if ( _MessageClass )
00075                         _MessageClass->release();               */
00076         }
00077 
00078         sint32 CMessageScript::getMethodIndexSize() const
00079         {
00080                 return IMessageBase::getMethodIndexSize() + _MessageClass->getMethodIndexSize();
00081         }
00082 
00083         sint32 CMessageScript::getBaseMethodCount() const
00084         {
00085                 return IMessageBase::getMethodIndexSize();
00086         }
00087 
00088 
00089         NLAISCRIPT::IOpCode *CMessageScript::getMethode(sint32 inheritance,sint32 index)
00090         {
00091 #ifdef NL_DEBUG
00092                 if ( index >= _MessageClass->getMethodIndexSize())
00093                 {
00094                         throw NLAIE::CExceptionIndexError();
00095                 }
00096 
00097                 if ( inheritance >= _MessageClass->sizeVTable())
00098                 {
00099                         throw NLAIE::CExceptionIndexError();
00100                 }
00101 #endif
00102                 return (NLAISCRIPT::IOpCode *)_MessageClass->getBrancheCode(inheritance,index).getCode();
00103         }
00104 
00105         NLAISCRIPT::IOpCode *CMessageScript::getMethode(sint32 index)
00106         {
00107 #ifdef NL_DEBUG
00108                 if ( index >= _MessageClass->getMethodIndexSize())
00109                 {
00110                         throw NLAIE::CExceptionIndexError();
00111                 }
00112 #endif
00113                 return (NLAISCRIPT::IOpCode *)_MessageClass->getBrancheCode(index).getCode();
00114         }
00115 
00116 
00117         IObjectIA::CProcessResult CMessageScript::runMethodeMember(sint32 inheritance, sint32 index, IObjectIA *c)
00118         {
00119                 if(c->getType() != NLAISCRIPT::CCodeContext::IdCodeContext)
00120                 {
00121                         return IMessageBase::runMethodeMember(inheritance,index, c);
00122                 }
00123 
00124                 NLAISCRIPT::IOpCode *opPtr = NULL;
00125                 NLAISCRIPT::CCodeContext &context = (NLAISCRIPT::CCodeContext &)*c;
00126 
00127                 sint32 i = index - getBaseMethodCount();
00128                 if(i < 0)
00129                 {
00130                         /*if (context.ContextDebug.Active)
00131                         {
00132                                 context.ContextDebug.Param.push_back(&listBidon);
00133                                 listBidon.incRef();
00134                         }*/
00135 
00136                         IObjectIA::CProcessResult r = IMessageBase::runMethodeMember(index,(IObjectIA *)context.Param.back());
00137                         if(r.Result != NULL)
00138                         {
00139                                 context.Stack++;
00140                                 context.Stack[(int)context.Stack] = r.Result;
00141                         }
00142                         r.Result = NULL;
00143                         return r;
00144                 }
00145                 else
00146                 {
00147                         opPtr = getMethode( inheritance, i);
00148                 }
00149                 
00150                 IObjectIA::CProcessResult r;
00151 
00152                 if(opPtr)
00153                 {
00154                         NLAISCRIPT::IOpCode &op = *opPtr;
00155                         NLAISCRIPT::CCodeBrancheRun *opTmp = context.Code;
00156                         sint32 ip = (uint32)*context.Code;
00157                         context.Code = (NLAISCRIPT::CCodeBrancheRun *)&op;              
00158                         *context.Code = 0;
00159 
00160                         /*TProcessStatement k = IObjectIA::ProcessIdle;
00161 
00162                         while(k != IObjectIA::ProcessEnd)
00163                         {
00164                                 k = op.run(context);    
00165                         }*/
00166                         
00167                         r = ((NLAISCRIPT::ICodeBranche *)opPtr)->run(context);
00168 
00169                         // If we are in Debug Mode
00170                         if (context.ContextDebug.Active)
00171                         {
00172                                 context.ContextDebug.callStackPop();
00173                         }
00174                         
00175                         *context.Code = ip;
00176                         context.Code = opTmp;
00177                 }
00178                 else
00179                 {
00180                         throw NLAIE::CExceptionUnReference("CMessageScript::runMethodeMember(sint32 , sint32, IObjectIA *) because code is null");
00181                 }
00182                 /*IObjectIA::CProcessResult r;
00183                 r.Result = NULL;
00184                 r.ResultState = k;*/
00185                 return r;
00186         }
00187 
00188         IObjectIA::CProcessResult CMessageScript::runMethodeMember(sint32 index,IObjectIA *c)
00189         {
00190                 if(c->getType() != NLAISCRIPT::CCodeContext::IdCodeContext)
00191                 {
00192                         return IMessageBase::runMethodeMember(index, c);
00193                 }
00194 
00195                 NLAISCRIPT::IOpCode *opPtr = NULL;
00196                 NLAISCRIPT::CCodeContext &context = (NLAISCRIPT::CCodeContext &)*c;
00197 
00198                 sint32 i = index - getBaseMethodCount();
00199                 if(i < 0)
00200                 {
00201                         /*if (context.ContextDebug.Active)
00202                         {
00203                                 context.ContextDebug.Param.push_back(&listBidon);
00204                                 listBidon.incRef();
00205                         }*/
00206 
00207                         IObjectIA::CProcessResult r = IMessageBase::runMethodeMember(index,(IObjectIA *)context.Param.back());
00208                         if(r.Result != NULL)
00209                         {
00210                                 context.Stack++;
00211                                 context.Stack[(int)context.Stack] = r.Result;
00212                         }
00213                         r.Result = NULL;
00214                         return r;
00215                 }
00216                 else
00217                 {
00218                         opPtr = getMethode(i);
00219                 }
00220 
00221                 IObjectIA::CProcessResult r;
00222 
00223                 if(opPtr)
00224                 {
00225                         NLAISCRIPT::IOpCode &op = *opPtr;
00226                         NLAISCRIPT::CCodeBrancheRun *opTmp = context.Code;
00227                         sint32 ip = (uint32)*context.Code;
00228                         context.Code = (NLAISCRIPT::CCodeBrancheRun *)&op;              
00229                         *context.Code = 0;
00230 
00231                         /*:TProcessStatement k = IObjectIA::ProcessIdle;
00232 
00233                         while(k != IObjectIA::ProcessEnd)
00234                         {
00235                                 k = op.run(context);    
00236                         }*/             
00237 
00238                         r = ((NLAISCRIPT::ICodeBranche *)opPtr)->run(context);
00239 
00240                         // If we are in Debug Mode
00241                         if (context.ContextDebug.Active)
00242                         {
00243                                 context.ContextDebug.callStackPop();
00244                         }
00245 
00246                         *context.Code = ip;
00247                         context.Code = opTmp;
00248                 }
00249                 else
00250                 {
00251                         throw NLAIE::CExceptionUnReference("CMessageScript::runMethodeMember(sint32, IObjectIA *) because code is null");
00252                 }
00253                 /*IObjectIA::CProcessResult r;
00254                 r.Result = NULL;
00255                 r.ResultState = k;*/
00256                 return r;
00257         }       
00258 
00259         sint32 CMessageScript::isClassInheritedFrom(const IVarName &class_name) const
00260         {
00261                 return _MessageClass->isClassInheritedFrom( class_name );
00262         }       
00263 
00264         bool CMessageScript::setStaticMember(sint32 index,IObjectIA *op)
00265         {
00266 #ifdef NL_DEBUG
00267                 if ( index >= size() )
00268                 {
00269                         throw NLAIE::CExceptionIndexError();
00270                 }
00271 #endif
00272                 CVectorGroupType *a = (CVectorGroupType *)getMessageGroup();
00273                 IObjectIA *b = (IObjectIA *)(*a)[ index ];
00274                 a->setObject(index, op);
00275                 if(op != b) b->release();
00276                 else return true;
00277                 return false;
00278         }
00279 
00280         const IObjectIA *CMessageScript::getStaticMember(sint32 index) const
00281         {
00282 #ifdef NL_DEBUG
00283                 if ( index >= size() )
00284                 {
00285                         throw NLAIE::CExceptionIndexError();
00286                 }
00287 #endif
00288                 return (*this)[ index ];                
00289         }
00290 
00291         sint32 CMessageScript::getStaticMemberIndex(const IVarName &name) const
00292         {
00293                 return _MessageClass->getStaticMemberIndex(name);
00294         }
00295 
00296         sint32 CMessageScript::getStaticMemberSize() const
00297         {
00298                 return 0;
00299         }
00300 
00301         tQueue CMessageScript::isMember(const IVarName *className,const IVarName *methodName,const IObjectIA &param) const
00302         {       
00303 
00304                 tQueue result = IMessageBase::isMember(className, methodName, param);
00305                 
00306                 if ( result.size()  )
00307                 {
00308                         return result;
00309                 }
00310 
00311                 if( *methodName == CStringVarName("send") )
00312                 {
00313                         tQueue r;
00314                         NLAISCRIPT::COperandVoid typeR;
00315                         NLAISCRIPT::CObjectUnknown *t = new NLAISCRIPT::CObjectUnknown((NLAISCRIPT::IOpType *)typeR.clone());                   
00316                         r.push(CIdMethod(0,0.0,NULL,t));
00317                         return r;
00318                 }
00319 
00320                 return result;
00321         }
00322 
00323         void CMessageScript::save(NLMISC::IStream &os)
00324         {
00325                 IMessageBase::save(os);
00326         }
00327 
00328         void CMessageScript::load(NLMISC::IStream &is)
00329         {
00330                 IMessageBase::load(is);
00331         }
00332 
00333         const NLAIC::IBasicType *CMessageScript::clone() const
00334         {               
00335                 CMessageScript *cl = new CMessageScript( *this );
00336 
00337                 return cl;
00338         }
00339 
00340         const NLAIC::IBasicType *CMessageScript::newInstance() const
00341         {
00342                 CMessageScript *instance;
00343                 if ( _MessageClass )
00344                 {
00345                         instance = (CMessageScript *) _MessageClass->buildNewInstance();
00346                 }
00347                 else 
00348                 {
00349                         instance = new CMessageScript();
00350                 }
00351                 return instance;
00352         }
00353 
00354         void CMessageScript::getDebugString(std::string &t) const
00355         {
00356                 if ( _MessageClass )
00357                         t += NLAIC::stringGetBuild("<%s> (scripted)\n   -StaticComponents:\n",(const char *)_MessageClass->getType());
00358                 else
00359                         t += NLAIC::stringGetBuild("<undefined_class> (scripted)\n   -StaticComponents:\n");
00360                 
00361                 for (sint32 i = 0; i < size(); i++ )
00362                 {
00363                         std::string buf;
00364                         t += "     ";
00365                         if ( _MessageClass->getComponent(i) )
00366                         {
00367                                 t += _MessageClass->getComponentName(i);
00368                         }
00369                         else
00370                                 t += "<unnamed>";
00371 
00372                         t += "     ";
00373                         (*this)[i]->getDebugString(buf);
00374                         t += buf;
00375                         t += "\n";
00376 
00377                 }
00378         }
00379 
00380         bool CMessageScript::isEqual(const IBasicObjectIA &a) const
00381         {
00382                 return IMessageBase::isEqual(a);
00383         }
00384 
00385         const NLAIC::CIdentType &CMessageScript::getType() const
00386         {
00387                 if ( _MessageClass ) 
00388                         return _MessageClass->getType();
00389                 else
00390                         return IdMessageScript;
00391         }       
00392 
00393         const IObjectIA::CProcessResult &CMessageScript::run()
00394         {
00395                 return IObjectIA::ProcessRun;
00396         }
00397 }
message_script.cpp
