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/script/constraint.h"
+00026 #include "nel/ai/script/type_def.h"
+00027 #include "nel/ai/script/object_unknown.h"
+00028 
+00029 
+00030 namespace NLAISCRIPT
+00031 {
+00032         void IConstraint::popConstraint(IConstraint *c)
+00033         {
+00034                 std::list<IConstraint *>::iterator it = _ConstraintList.begin();
+00035                 while(it != _ConstraintList.end())
+00036                 {                       
+00037                         if(*it == c)
+00038                         {
+00039                                 _ConstraintList.erase(it);
+00040                                 break;
+00041                         }
+00042                         it ++ ;
+00043                 }               
+00044         }
+00045 }
+00046 
+00047 
+00048 namespace NLAISCRIPT
+00049 {       
+00050         void CConstraintMethode::run(CCompilateur &comp)
+00051         {
+00052                 if(_Satisfied) return;
+00053 #ifdef NL_DEBUG
+00054                 std::string mtxt;
+00055                 std::string ptxt;
+00056                 std::string txt;
+00057                 
+00058                 _MethodName->getDebugString(mtxt);
+00059 
+00060                 /*if(mtxt == "[Get]")
+00061                 {
+00062                         throw;
+00063                 }*/
+00064                 _Param->getDebugString(ptxt);
+00065                 txt = mtxt + ptxt;
+00066 #endif  
+00067                 const NLAIAGENT::IObjectIA *cl = NULL;
+00068                 bool isMember = true;
+00069                 
+00070                 if(_BaseClass)
+00071                 {
+00072                         if(!_BaseClass->satisfied()) _BaseClass->run(comp);
+00073                         if(_BaseClass->satisfied())
+00074                         {
+00075                                 cl = (const NLAIAGENT::IObjectIA *)(_BaseClass->getConstraintTypeOf()->getFactory())->getClass();
+00076                                 _M = comp.findMethode(cl,*_MethodName,*_Param);
+00077                         }
+00078                         else
+00079                         {       
+00080                                 std::string txt;
+00081                                 std::string param;
+00082                                 std::string Method;
+00083                                 
+00084                                 _Param->getDebugString(param);
+00085                                 _MethodName->getDebugString(Method);
+00086                                 txt = NLAIC::stringGetBuild("can't find the method '%s%s'",Method.c_str(),param.c_str());
+00087                                 _Txt = new char [strlen(txt.c_str()) + 1];
+00088                                 strcpy(_Txt,txt.c_str());
+00089                                 return;
+00090                         }                       
+00091                 }
+00092                 else
+00093                 {
+00094                         try
+00095                         {
+00096                                 _M = comp.findMethode(*_MethodName,*_Param);
+00097                         }
+00098                         catch(NLAIE::IException &e)
+00099                         {
+00100                                 std::string txt;
+00101                                 std::string param;
+00102                                 std::string Method;
+00103                                 
+00104                                 _Param->getDebugString(param);
+00105                                 _MethodName->getDebugString(Method);
+00106                                 txt += NLAIC::stringGetBuild("error '%s' when serch '%s%s'",(char *) e.what(),Method.c_str(),param.c_str());
+00107                                 _Txt = new char [strlen(txt.c_str()) + 1];
+00108                                 strcpy(_Txt,txt.c_str());
+00109                                 return;
+00110 
+00111                         }
+00112                         if(_M.MethodName == NULL)
+00113                         {
+00114                                 isMember = false;
+00115                                 NLAIAGENT::CStringType *lib = (NLAIAGENT::CStringType *)_MethodName->getFront();
+00116                                 try
+00117                                 {                                       
+00118                                         NLAIC::CIdentType id(lib->getStr().getString());
+00119                                         _M = comp.findMethode((NLAIAGENT::IObjectIA *)id.getFactory()->getClass() ,*_MethodName,*_Param);
+00120 
+00121                                 }
+00122                                 catch(NLAIE::IException &)
+00123                                 {
+00124                                         std::string txt;
+00125                                         std::string param;
+00126                                         std::string Method;
+00127                                         
+00128                                         _Param->getDebugString(param);
+00129                                         _MethodName->getDebugString(Method);
+00130                                         txt += NLAIC::stringGetBuild("can't find the method '%s%s'",Method.c_str(),param.c_str());
+00131                                         _Txt = new char [strlen(txt.c_str()) + 1];
+00132                                         strcpy(_Txt,txt.c_str());
+00133                                         
+00134                                 }
+00135                         }
+00136                 }                
+00137                 if(_M.MethodName == NULL)
+00138                 {                       
+00139 
+00140                         std::string txt;
+00141                         std::string param;
+00142                         std::string Method;
+00143                         
+00144                         _Param->getDebugString(param);
+00145                         _MethodName->getDebugString(Method);
+00146                         txt += NLAIC::stringGetBuild("can't find the method '%s%s'",Method.c_str(),param.c_str());
+00147                         _Txt = new char [strlen(txt.c_str()) + 1];
+00148                         strcpy(_Txt,txt.c_str());
+00149                 }
+00150                 else
+00151                 {
+00152                         _Satisfied = true;
+00153                         IOpCode *x=0;
+00154                                                 
+00155 
+00156                         if(((const NLAIC::CTypeOfObject &)_M.Object->getType()) & NLAIC::CTypeOfObject::tInterpret)
+00157                         {                               
+00158                                 IMethodContext *methodContex;
+00159                                 if (comp.getDebugMode())
+00160                                 {
+00161                                         methodContex = new CMethodContextDebug();
+00162                                 }
+00163                                 else
+00164                                 {
+00165                                         methodContex = new CMethodContext();
+00166                                 }
+00167                                 
+00168                                 switch(_CallType)
+00169                                 {
+00170                                         case normalCall:
+00171                                                 if(!_M.Member.size())
+00172                                                 {
+00173                                                         x = new CCallMethod(methodContex,_M.Inheritance,_M.MethodNum);
+00174                                                 }
+00175                                                 else
+00176                                                 {
+00177                                                         x = new CCallMethodi(methodContex,_M.Inheritance,_M.MethodNum,_M.Member);
+00178                                                 }
+00179                                                 break;
+00180                                         case stackCall:
+00181                                                 x = new CCallStackMethodi(methodContex,_M.Inheritance,_M.MethodNum,_M.Member);
+00182                                                 break;
+00183                                         case heapCall:
+00184                                                 x = new CCallHeapMethodi(methodContex,_M.Inheritance,_M.MethodNum,_PosHeap,_M.Member);
+00185                                                 break;
+00186                                         case newCall:
+00187                                                 x = new CCallStackNewMethodi(methodContex,_M.Inheritance,_M.MethodNum,_M.Member);
+00188                                                 break;
+00189                                         case searchCall:
+00190                                                 x = NULL;
+00191                                                 delete methodContex;
+00192                                                 break;
+00193                                 }
+00194                         }
+00195                         else
+00196                         {
+00197                                 _Satisfied = true;
+00198                                 switch(_CallType)
+00199                                 {
+00200                                 case normalCall:
+00201                                         if(_M.Member.size())
+00202                                         {                                               
+00203                                                 if(!isMember) x =  new CLibCallMethodi(_M.Inheritance,_M.MethodNum ,_M.Member , *_M.Object);
+00204                                                 else
+00205                                                 {
+00206                                                         x =  new CLibMemberMethodi(_M.Inheritance,_M.MethodNum ,_M.Member );
+00207                                                 }
+00208                                         }
+00209                                         else
+00210                                         {
+00211                                                 if(_M.Inheritance)
+00212                                                 {
+00213                                                         if(!isMember) x =  new CLibCallInheritedMethod(_M.Inheritance,_M.MethodNum , *_M.Object);
+00214                                                         else
+00215                                                         {
+00216                                                                 x =  new CLibMemberInheritedMethod(_M.Inheritance,_M.MethodNum);
+00217                                                         }
+00218                                                 }
+00219                                                 else
+00220                                                 {
+00221                                                         if(!isMember) x =  new CLibCallMethod(_M.MethodNum ,*_M.Object);
+00222                                                         else
+00223                                                         {                                                               
+00224                                                                 x =  new CLibMemberMethod(_M.MethodNum);
+00225                                                         }
+00226                                                 }
+00227                                         }
+00228                                         break;
+00229                                 case stackCall:
+00230                                         x =  new CLibStackMemberMethod(_M.Inheritance,_M.MethodNum ,_M.Member);
+00231                                         break;
+00232                                 case heapCall:
+00233                                         x =  new CLibHeapMemberMethod(_M.Inheritance,_M.MethodNum ,_M.Member,_PosHeap);
+00234                                         break;
+00235                                 case newCall:                                   
+00236                                         x =  new CLibStackNewMemberMethod(_M.Inheritance,_M.MethodNum ,_M.Member);                                      
+00237                                         break;
+00238 
+00239                                 case searchCall:
+00240                                         x = NULL;
+00241                                         break;
+00242                                 }
+00243                         }                       
+00244                         IConstraint *c;                 
+00245 
+00246                         if(_M.Method != NULL)
+00247                         {
+00248                                 c = (IConstraint *)_M.Method->getTypeOfMethode();
+00249                                 setOpCode(comp,x,c,false);
+00250                                 if(_M.ReturnType != NULL)
+00251                                 {
+00252                                         _M.ReturnType->release();
+00253                                         _M.ReturnType = NULL;
+00254                                 }                               
+00255                         }
+00256                         else
+00257                         {
+00258                                 if(_M.ReturnType != NULL)
+00259                                 {
+00260                                         try
+00261                                         {
+00262                                                 NLAIC::CIdentType type = _M.ReturnType->getType();
+00263                                                 NLAIC::CIdentType *tmp = new NLAIC::CIdentType (type);
+00264                                                 c = new COperandSimple ( tmp );
+00265                                                 setOpCode(comp,x,c,true);                                               
+00266                                         }
+00267                                         catch(NLAIE::IException &)
+00268                                         {       
+00269                                                 c = new COperandSimple (new NLAIC::CIdentType (_M.Object->getType()));
+00270                                                 setOpCode(comp,x,c,true);
+00271                                         }
+00272                                         _M.ReturnType->release();
+00273                                         _M.ReturnType = NULL;
+00274                                 }
+00275                                 else
+00276                                 {
+00277                                         c = new COperandSimple (new NLAIC::CIdentType (_M.Object->getType()));
+00278                                         setOpCode(comp,x,c,true);
+00279                                 }                               
+00280                         }
+00281                         
+00282                 }               
+00283         }
+00284 
+00285         void CConstraintMethode::setOpCode(CCompilateur &comp,IOpCode *x,IConstraint *type,bool f)
+00286         {
+00287                 if(x != NULL)
+00288                 {               
+00289                         if(_Code.size())
+00290                         {               
+00291                                 while(_Code.size())
+00292                                 {                       
+00293                                         std::pair<int, CCodeBrancheRun *> &p = _Code.back();
+00294                                         IOpCode *op = (*p.second)[p.first];//
+00295 /*#ifdef NL_DEBUG
+00296                                         std::string dbugS;
+00297                                         p.second->getDebugString(dbugS);
+00298                                         NLAIC::Out("%s \n\tindex <%d> \n\tRef of IOpCode int setOpCode is %d\n", dbugS.c_str(), p.first, op->getRef());
+00299 #endif*/
+00300                                         op->release();
+00301                                         (*p.second)[p.first] = x;
+00302                                         _Code.pop_back();                       
+00303                                         if(_Code.size()) x->incRef();
+00304                                 }
+00305                         }
+00306                         else
+00307                         {
+00308                                 x->release();
+00309                         }
+00310                 }
+00311                 _Type = type;
+00312                 _Type->run(comp);
+00313                 _DelCType = f;
+00314                 runConnexcion();
+00315         }
+00316 
+00317         void CConstraintMethode::getError(char *txt) const
+00318         {                       
+00319                 strcpy(txt,_Txt);
+00320         }
+00321 
+00322         bool CConstraintMethode::isEqual (const NLAIAGENT::IBaseGroupType &g,const CParam &p) const
+00323         {
+00324                 if(((const NLAIAGENT::IBasicObjectIA &)*_MethodName) == ((const NLAIAGENT::IBasicObjectIA &)g) && *_Param == p) return true;
+00325                 return false;
+00326         }
+00327 
+00328         void CConstraintMethode::run(IConstraint *)
+00329         {
+00330         }       
+00331 
+00332         const IConstraint *CConstraintMethode::clone() const
+00333         {
+00334                 IConstraint *x = new CConstraintMethode(_CallType,_PosHeap,_BaseClass,_MethodName,_Param,_Lin,_Col);
+00335                 _BaseClass->incRef();
+00336                 _MethodName->incRef();
+00337                 _Param->incRef();               
+00338                 return x;
+00339         }       
+00340 }
+
constraint.cpp
