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/constraint_stack_component.h"
+00028 #include "nel/ai/script/object_unknown.h"
+00029 #include "nel/ai/agent/performative.h"
+00030 #include "nel/ai/script/param_container.h"
+00031 
+00032 namespace NLAISCRIPT
+00033 {
+00034         bool CCompilateur::caseRunMsg()
+00035         {
+00036                 if(isRunMsg && !haveReturn)
+00037                 {
+00038                         isRunMsg = false;
+00039                         char text[4096];
+00040                         strcpy(text,"run message methode must return an message value");
+00041                         yyerror(text);                  
+00042                         return false;
+00043                 }
+00044                 isRunMsg = false;
+00045                 haveReturn = false;
+00046                 return true;
+00047         }
+00048 
+00049         bool CCompilateur::classIsAnOperator()
+00050         {               
+00051                 return true;
+00052         }
+00053         
+00054         sint32 CCompilateur::castVariable(const NLAIAGENT::CStringVarName &v,NLAIAGENT::CStringVarName &t)
+00055         {
+00056                 NLAIAGENT::IObjectIA *var = getVar(v.getString());
+00057                 if(var != NULL)
+00058                 {
+00059                         try
+00060                         {
+00061                                 NLAIC::CIdentType id(t.getString());
+00062                                 IOpType * c= new COperandSimple(new NLAIC::CIdentType(id));
+00063                                 CObjectUnknown *o = (CObjectUnknown *)((CVarPStackParam *)var)->getObject();                            
+00064                                 o->setBaseType(c);
+00065                                 return true;
+00066                         }
+00067                         catch(NLAIE::IException &)
+00068                         {
+00069                                 std::string text;
+00070                                 text = NLAIC::stringGetBuild("can't find %s object in the class factory",t.getString());
+00071                                 yyerror((char *)text.c_str());
+00072                                 return false;
+00073                         }
+00074                         
+00075                 }
+00076                 else
+00077                 {
+00078                         yyerror("cast service is reseved to the local variable");
+00079                         return false;
+00080                 }               
+00081         }
+00082         sint32 CCompilateur::processingVar()
+00083         {
+00084                 if(_LasVarStr.size() >= 1)
+00085                 {
+00086                         NLAIAGENT::IObjectIA *var;
+00087                         var = getVar(_LasVarStr.front().data());
+00088                         if(_LasVarStr.size() == 1)
+00089                         {
+00090                                 if(var == NULL)
+00091                                 {
+00092                                         sint32 i = ((IClassInterpret *)_SelfClass.get())->getStaticMemberIndex(NLAIAGENT::CStringVarName(_LasVarStr.front().data()));
+00093                                         if(i >= 0)
+00094                                         {
+00095                                                 _LastFact.Member.clear();
+00096                                                 _LastFact.Member.push_back(i /*+ getCompementShift((IClassInterpret *)_SelfClass.get())*/);
+00097                                                 _LastFact.ValueVar = NULL;                                              
+00098                                                 _LastFact.VarType = varTypeMember;
+00099                                                 _LastFact.IsUsed = false;                                               
+00100                                                 try
+00101                                                 {                                                       
+00102                                                         if(_FlotingExpressionType != NULL) delete _FlotingExpressionType;
+00103                                                         _FlotingExpressionType = new COperandSimple(new NLAIC::CIdentType ((_SelfClass.get())->getStaticMember(i)->getType()));
+00104                                                 }
+00105                                                 catch(NLAIE::IException &a)
+00106                                                 {                                                       
+00107                                                         yyerror((char *)a.what());
+00108                                                         return 0;
+00109                                                 }
+00110                                         }
+00111                                         else
+00112                                         {
+00113                                                 if(_TypeList.size())
+00114                                                 {
+00115                                                         IOpType *type = _TypeList.back();
+00116                                                         _TypeList.pop_back();
+00117                                                         _LastFact.Member.clear();
+00118                                                         _LastFact.MemberName.clear();
+00119 
+00120                                                         if(_FlotingExpressionType != NULL) _FlotingExpressionType->release();
+00121 
+00122 
+00123                                                         if(type->satisfied())
+00124                                                         {
+00125                                                                 NLAIAGENT::IObjectIA *c = (NLAIAGENT::IObjectIA *)((NLAIC::IClassFactory *)type->getConstraintTypeOf()->getFactory())->getClass();
+00126                                                                 sint32 i = c->getStaticMemberIndex(NLAIAGENT::CStringVarName(_LasVarStr.front().data()));
+00127                                                                 if(i >= 0)
+00128                                                                 {       
+00129                                                                         /*if(((const NLAIC::CTypeOfObject &)*c->getType()) & NLAIC::CTypeOfObject::tAgentInterpret)
+00130                                                                         {
+00131                                                                                 _LastFact.Member.push_back(i + getCompementShift((IClassInterpret *)c));
+00132                                                                         }
+00133                                                                         else*/
+00134                                                                         {
+00135                                                                                 _LastFact.Member.push_back(i);
+00136                                                                         }
+00137                                                                         
+00138                                                                 }
+00139                                                                 else
+00140                                                                 {
+00141                                                                         type->release();                                                                        
+00142                                                                         yyerror("attribut is not define");
+00143                                                                         return 0;
+00144                                                                 }                                                                       
+00145                                                                 NLAIC::CIdentType *id = new NLAIC::CIdentType (c->getType());
+00146                                                                 _FlotingExpressionType = new COperandSimple(id);                                                                                                                                
+00147                                                                 type->release();
+00148                                                         }
+00149                                                         else
+00150                                                         {
+00151                                                                 _LastFact.MemberName = _LasVarStr;
+00152                                                                 type->incRef();
+00153                                                                 IOpType *constr = (IOpType *)getMethodConstraint(CConstraintStackComp(CConstraintStackComp::stackCall,0,_LastFact.MemberName ,type,0,0));
+00154                                                                 if(constr == NULL)
+00155                                                                 {
+00156                                                                         constr = new CConstraintStackComp(CConstraintStackComp::stackCall,0,_LastFact.MemberName,type,yyLine,yyColone);                                                                 
+00157                                                                 }
+00158                                                                 _FlotingExpressionType = constr;
+00159                                                         }                                                       
+00160 
+00161                                                         if(_LastFact.TypeStack) _LastFact.TypeStack->release();
+00162                                                         _LastFact.TypeStack = _FlotingExpressionType;
+00163                                                         _LastFact.TypeStack->incRef();
+00164                                                         _LastFact.ValueVar = NULL;      
+00165                                                         _LastFact.VarType = varTypeStackMember;
+00166                                                         _LastFact.IsUsed = false;
+00167                                                         
+00168                                                 }
+00169                                                 else 
+00170                                                 {
+00171                                                         yyerror("variable used but never declared");                                            
+00172                                                         return 0;
+00173                                                 }
+00174                                         }
+00175                                 }
+00176                                 else
+00177                                 {
+00178                                         _LastFact.ValueVar = var;
+00179                                         _LastFact.VarType = varTypeLocal;
+00180                                         _LastFact.IsUsed = false;
+00181                                         _LasVarStr.clear();                                     
+00182                                         if(var->getType() == CVarPStackParam::IdVarPStackParam)
+00183                                         {       
+00184                                                 if(_FlotingExpressionType != NULL) _FlotingExpressionType->release();
+00185                                                 try
+00186                                                 {
+00187                                                         _FlotingExpressionType = new COperandSimple(new NLAIC::CIdentType(((CVarPStackParam *)var)->getVarType()));
+00188                                                 }       
+00189                                                 catch(NLAIE::CExceptionUnReference &)
+00190                                                 {
+00191                                                         _FlotingExpressionType = (IOpType *)((const CObjectUnknown *)((CVarPStackParam *)var)->getObject())->getClassType();
+00192                                                         _FlotingExpressionType->incRef();
+00193                                                 }                                               
+00194                                         }
+00195                                         else
+00196                                         {                                                                                                       
+00197                                                 if(_FlotingExpressionType != NULL) _FlotingExpressionType->release();
+00198                                                 _FlotingExpressionType = new COperandSimple(new NLAIC::CIdentType(var->getType()));                                             
+00199                                         }                                       
+00200                                 }
+00201                         }
+00202                         else
+00203                         {
+00204 
+00205                                 CConstraintStackComp::OpCodeType opCodeType = CConstraintStackComp::stackCall;
+00206                                 sint32 posStack = 0;                            
+00207                                 NLAIAGENT::CStringVarName varName(_LasVarStr.back().data());
+00208                                 if(var != NULL)
+00209                                 {
+00210                                         _LasVarStr.pop_front();
+00211                                         IOpType *cont = (IOpType *)((const CObjectUnknown *)((CVarPStackParam *)var)->getObject())->getBaseType();
+00212                                         if(cont->satisfied())
+00213                                         {
+00214                                                 const NLAIC::CIdentType &id = *cont->getConstraintTypeOf();
+00215                                                 IClassInterpret *cl;
+00216 
+00217                                                 if(strcmp((const char *)id,((IClassInterpret *)_SelfClass.get())->getClassName()->getString()) == 0)
+00218                                                 {
+00219                                                         cl = (IClassInterpret *)_SelfClass.get();
+00220                                                 }
+00221                                                 else cl = (IClassInterpret *)((CClassInterpretFactory *)id.getFactory())->getClass();
+00222                                                 IOpType *c;                             
+00223                                                 _LastFact.Member.clear();
+00224                                                 if(!isValidateVarName(cl,_LastFact.Member,_LasVarStr,c))
+00225                                                 {
+00226                                                         if(c) c->release();
+00227                                                         std::string text;
+00228                                                         text = NLAIC::stringGetBuild("var '%s' is not define",varName.getString());
+00229                                                         yyerror((char *)text.c_str());
+00230                                                         return false;
+00231                                                 }                                               
+00232                                                 _FlotingExpressionType = c;
+00233                                                 if(_LastFact.TypeStack) _LastFact.TypeStack->release();
+00234                                                 _LastFact.TypeStack = _FlotingExpressionType;
+00235                                                 _LastFact.TypeStack->incRef();
+00236                                                 _LastFact.ValueVar = var;       
+00237                                                 _LastFact.VarType = varTypeHeapMember;
+00238                                                 _LastFact.IsUsed = false;
+00239 #ifdef NL_DEBUG
+00240         std::list<sint32>::iterator i_dbg = _LastFact.Member.begin();
+00241         while(i_dbg != _LastFact.Member.end())
+00242         {
+00243                 int k = *i_dbg++; 
+00244         }
+00245 
+00246 #endif
+00247                                                 return true;                                            
+00248                                         }
+00249                                         else
+00250                                         {
+00251                                                 opCodeType = CConstraintStackComp::heapCall;
+00252                                                 posStack = ((CVarPStackParam *)var)->getIndex();
+00253                                                 cont->incRef();
+00254                                                 _TypeList.push_back(cont);
+00255                                         }
+00256                                         
+00257                                 }
+00258 
+00259                                 if(!_TypeList.size())
+00260                                 {                               
+00261                                         _LastFact.Member.clear();
+00262                                         IOpType *c;                                     
+00263                                         if(!isValidateVarName(_LastFact.Member,_LasVarStr,c))
+00264                                         {
+00265                                                 if(c) c->release();
+00266                                                 std::string text;
+00267                                                 text = NLAIC::stringGetBuild("var '%s' is not define",varName.getString());
+00268                                                 yyerror((char *)text.c_str());
+00269                                                 return false;
+00270                                         }
+00271                                         _LastFact.ValueVar = NULL;                                              
+00272                                         _LastFact.VarType = varTypeMember;
+00273                                         _LastFact.IsUsed = false;
+00274                                         if(_FlotingExpressionType != NULL) _FlotingExpressionType->release();
+00275                                         _FlotingExpressionType = (IOpType *)c;
+00276                                 }
+00277                                 else
+00278                                 {
+00279                                         IOpType *type = _TypeList.back();
+00280                                         _TypeList.pop_back();
+00281                                         _LastFact.Member.clear();
+00282                                         _LastFact.MemberName.clear();
+00283 
+00284                                         if(_FlotingExpressionType != NULL) _FlotingExpressionType->release();
+00285                                         
+00286                                         if(type->satisfied())
+00287                                         {
+00288                                                 IClassInterpret *cl = (IClassInterpret *)type->getConstraintTypeOf()->allocClass();
+00289                                                 IOpType *c;
+00290                                                 if(!isValidateVarName(cl,_LastFact.Member,_LasVarStr,c))
+00291                                                 {
+00292                                                         if(c) c->release();
+00293                                                         type->release();
+00294                                                         cl->release();
+00295                                                         std::string text;
+00296                                                         text = NLAIC::stringGetBuild("var '%s' is not define",varName.getString());
+00297                                                         yyerror((char *)text.c_str());
+00298                                                         return false;
+00299                                                 }                                               
+00300                                                 _FlotingExpressionType = (IOpType *)c;
+00301                                                 type->release();
+00302                                                 cl->release();
+00303                                         }
+00304                                         else
+00305                                         {
+00306                                                 _LastFact.MemberName = _LasVarStr;
+00307                                                 type->incRef();
+00308                                                 IOpType *constr = (IOpType *)getMethodConstraint(CConstraintStackComp(opCodeType,posStack,_LastFact.MemberName ,type,0,0));
+00309                                                 if(constr == NULL)
+00310                                                 {
+00311                                                         constr = new CConstraintStackComp(opCodeType,posStack,_LastFact.MemberName,type,yyLine,yyColone);                                                                       
+00312                                                 }
+00313                                                 else
+00314                                                 {
+00315                                                         constr->incRef();
+00316                                                 }
+00317                                                 _FlotingExpressionType = constr;                                                
+00318                                         }                                       
+00319 
+00320                                         if(_LastFact.TypeStack) _LastFact.TypeStack->release();
+00321                                         _LastFact.TypeStack = _FlotingExpressionType;
+00322                                         _LastFact.TypeStack->incRef();
+00323                                         _LastFact.ValueVar = NULL;      
+00324                                         _LastFact.VarType = varTypeStackMember;
+00325                                         _LastFact.IsUsed = false;
+00326                                 }
+00327                         }
+00328                 }
+00329                 else
+00330                 {
+00331                         yyerror("erreur de definition de variable");
+00332                         return 0;
+00333                 }
+00334                 return true;
+00335         }
+00336         
+00337         bool CCompilateur::setParamVarName()
+00338         {
+00339                 try
+00340                 {
+00341                         NLAIC::CIdentType idType = getTypeOfClass(_LastString);
+00342                         NLAIAGENT::IObjectIA *i;
+00343 
+00344                         if(_BaseObjectDef)
+00345                         {                                               
+00346                                 NLAIC::CIdentType idBase = getTypeOfClass(_LastBaseObjectDef);
+00347                                 COperandSimple *t = new COperandSimple(new NLAIC::CIdentType(idType));
+00348                                 COperandSimple *b = new COperandSimple(new NLAIC::CIdentType(idBase));                  
+00349                                 _Param.back()->push(t);
+00350                                 t->incRef();                    
+00351                                 i = new CObjectUnknown(t,b);
+00352                         }
+00353                         else
+00354                         {                       
+00355                                 COperandSimple *c = new COperandSimple(new NLAIC::CIdentType(idType));
+00356                                 _Param.back()->push(c);
+00357                                 c->incRef();
+00358                                 i = new CObjectUnknown(c);//(NLAIAGENT::IObjectIA *)NLAIC::createInstance(id);
+00359                         }
+00360                                         
+00361                         NLAIAGENT::IVarName *s = new NLAIAGENT::CStringVarName (LastyyText[1]);
+00362                         _Attrib.push_back(pairType(s,i));
+00363                                         
+00364                         i->incRef();
+00365                         _Heap[(int)_Heap] = i;
+00366                         _Heap ++;
+00367                 }
+00368                 catch(NLAIE::IException &e)
+00369                 {
+00370                         std::string text;
+00371                         text = NLAIC::stringGetBuild("Bad reference or class reference undefined '%s'", e.what());
+00372                         yyerror((char *)text.c_str());
+00373                         return 0;
+00374                 }
+00375                 return true;
+00376                 
+00377         }
+00378 
+00379         void CCompilateur::addParamRuleCont()
+00380         {
+00381                 _LastBloc->addCode(new CLdbOpCode (NLAIAGENT::CGroupType()));
+00382         }
+00383 
+00384         void CCompilateur::addParamCont()
+00385         {
+00386                 _LastBloc->addCode(new CLdbOpCode (CPramContainer()));          
+00387         }
+00388 
+00389         void CCompilateur::pushParamExpression()
+00390         {
+00391                 _LastBloc->addCode((new CAddOpCode));
+00392                 _Param.back()->push(_ExpressionType);
+00393                 if(!_ExpressionType->satisfied())
+00394                 {
+00395                         _ConstraintType.push_back(_ExpressionType);
+00396                         _ExpressionType->incRef();
+00397                 }
+00398                 _ExpressionType = NULL;
+00399         }
+00400 
+00401         void CCompilateur::setPerformative(NLAIAGENT::IMessageBase::TPerformatif p)
+00402         {
+00403                 if(_LastFact.Value != NULL) 
+00404                                                         _LastFact.Value->release();
+00405                 switch(p)
+00406                 {
+00407                 case NLAIAGENT::IMessageBase::PExec:
+00408                         _LastFact.Value = new NLAIAGENT::CPExec();
+00409                         break;
+00410                 case NLAIAGENT::IMessageBase::PAchieve:
+00411                         _LastFact.Value = new NLAIAGENT::CPAchieve();
+00412                         break;
+00413                 case NLAIAGENT::IMessageBase::PAsk:
+00414                         _LastFact.Value = new NLAIAGENT::CPAsk();
+00415                         break;
+00416                 case NLAIAGENT::IMessageBase::PBreak:
+00417                         _LastFact.Value = new NLAIAGENT::CPBreak();
+00418                         break;
+00419                 case NLAIAGENT::IMessageBase::PTell:
+00420                         _LastFact.Value = new NLAIAGENT::CPTell();
+00421                         break;
+00422                 case NLAIAGENT::IMessageBase::PKill:
+00423                         _LastFact.Value = new NLAIAGENT::CPKill();
+00424                         break;
+00425                 case NLAIAGENT::IMessageBase::PError:
+00426                         _LastFact.Value = new NLAIAGENT::CPError();
+00427                         break;
+00428                 case NLAIAGENT::IMessageBase::PEven:
+00429                         _LastFact.Value = new NLAIAGENT::CPEven();
+00430                         break;
+00431                 default: break;
+00432                 }               
+00433                 _LastFact.VarType = varTypeImediate;
+00434                 _LastFact.IsUsed = false;               
+00435                 if(_FlotingExpressionType != NULL) _FlotingExpressionType->release();
+00436                 _FlotingExpressionType = new COperandSimple(new NLAIC::CIdentType(_LastFact.Value->getType()));
+00437         }
+00438 
+00439         void CCompilateur::setImediateVarNill()
+00440         {
+00441                 if(_LastFact.Value != NULL) 
+00442                                                         _LastFact.Value->release();
+00443                 
+00444                 _LastFact.Value = &NLAIAGENT::DigitalType::NullOperator;
+00445                 _LastFact.Value->incRef();
+00446                 _LastFact.VarType = varTypeImediate;
+00447                 _LastFact.IsUsed = false;               
+00448                 if(_FlotingExpressionType != NULL) _FlotingExpressionType->release();
+00449                 _FlotingExpressionType = new COperandSimple(new NLAIC::CIdentType(_LastFact.Value->getType()));
+00450         }
+00451 
+00452         void CCompilateur::setImediateVar()
+00453         {
+00454                 if(_LastFact.Value != NULL) 
+00455                                                         _LastFact.Value->release();
+00456                 _LastFact.Value = new NLAIAGENT::DDigitalType(LastyyNum);
+00457                 _LastFact.VarType = varTypeImediate;
+00458                 _LastFact.IsUsed = false;               
+00459                 if(_FlotingExpressionType != NULL) _FlotingExpressionType->release();
+00460                 _FlotingExpressionType = new COperandSimple(new NLAIC::CIdentType(_LastFact.Value->getType()));
+00461         }
+00462 
+00463         void CCompilateur::setListVar()
+00464         {
+00465                 _LastBloc->addCode(new CLdbOpCode (NLAIAGENT::CGroupType()));                                                           
+00466                 NLAIAGENT::CGroupType l;
+00467                 if(_FlotingExpressionType != NULL) _FlotingExpressionType->release();
+00468                 _FlotingExpressionType = new COperandSimple(new NLAIC::CIdentType(l.getType()));
+00469         }
+00470 
+00471         void CCompilateur::setChaineVar()
+00472         {
+00473                 if(_LastFact.Value != NULL) 
+00474                                                         _LastFact.Value->release();
+00475                 _LastFact.Value = new NLAIAGENT::CStringType(NLAIAGENT::CStringVarName(LastyyText[1]));         
+00476                 _LastFact.VarType = varTypeImediate;
+00477                 _LastFact.IsUsed = false;                                                               
+00478                 if(_FlotingExpressionType != NULL) _FlotingExpressionType->release();
+00479                 _FlotingExpressionType = new COperandSimple(new NLAIC::CIdentType(_LastFact.Value->getType()));
+00480         }
+00481 
+00482         void CCompilateur::setStackVar(const NLAIC::CIdentType &type)
+00483         {
+00484                 if(_LastFact.Value != NULL) 
+00485                                                         _LastFact.Value->release();
+00486                 _LastFact.VarType = varForFunc;
+00487                 _LastFact.IsUsed = false;                                                               
+00488                 if(_FlotingExpressionType != NULL) _FlotingExpressionType->release();
+00489                 _FlotingExpressionType = new COperandSimple(new NLAIC::CIdentType(type) );
+00490         }
+00491 
+00492         void CCompilateur::setMethodVar()
+00493         {
+00494 
+00495 #ifdef NL_DEBUG
+00496         std::string mName;
+00497         std::string pName;
+00498         _LastStringParam.back()->getDebugString(mName);
+00499         _Param.back()->getDebugString(pName);
+00500 #endif
+00501                 if(_LastFact.Value != NULL) 
+00502                                                         _LastFact.Value->release();
+00503                 _LastFact.Value = NULL;         
+00504                 _LastFact.VarType = varForFunc;
+00505                 _LastFact.IsUsed = false;               
+00506 
+00507                 if(_FlotingExpressionType != NULL)
+00508                 {
+00509                         _FlotingExpressionType->release();
+00510                         _FlotingExpressionType = NULL;
+00511                 }
+00512                 _LastStringParam.back()->incRef();
+00513                 _Param.back()->incRef();
+00514                 if(_LastbaseClass != NULL)_LastbaseClass->incRef();
+00515                 IConstraint *c = getMethodConstraint(CConstraintMethode((CConstraintMethode::TCallTypeOpCode) _LastTypeCall,_LastPosHeap,_LastbaseClass,_LastStringParam.back(),_Param.back(),0,0));
+00516                 if(c == NULL)
+00517                 {
+00518                         _LastStringParam.back()->incRef();
+00519                         _Param.back()->incRef();
+00520                         if(_LastbaseClass != NULL)_LastbaseClass->incRef();
+00521                         c = new CConstraintMethode((CConstraintMethode::TCallTypeOpCode) _LastTypeCall,_LastPosHeap,_LastbaseClass,_LastStringParam.back(),_Param.back(),yyLine,yyColone);
+00522                         _MethodConstraint.push_back(c);                 
+00523                 }
+00524                 c->incRef();            
+00525                 IConstraint *cm = new CConstraintChkMethodeType(c,0,0); 
+00526                 _FlotingExpressionType = new COperandUnknown(cm);                       
+00527                 
+00528                 _LastStringParam.back()->release();
+00529                 _LastStringParam.pop_back();
+00530                 _Param.back()->release();
+00531                 _Param.pop_back();
+00532 #ifdef NL_DEBUG
+00533         if(_LastStringParam.size()) _LastStringParam.back()->getDebugString(mName);
+00534         if(_Param.size())_Param.back()->getDebugString(pName);
+00535                 
+00536 #endif          
+00537         }
+00538 
+00539         bool CCompilateur::buildObject()
+00540         {                               
+00541                 NLAIAGENT::CStringType *s = (NLAIAGENT::CStringType *)_LastStringParam.back()->get();
+00542                 if(_LastStringParam.back()->size() == 1)
+00543                 {               
+00544                         
+00545                         try
+00546                         {
+00547                                 NLAIC::CIdentType id(s->getStr().getString());
+00548                                 if(_FlotingExpressionType) _FlotingExpressionType->release();
+00549                                 _FlotingExpressionType = new COperandSimple(new NLAIC::CIdentType (id));                                
+00550 
+00551                                 NLAIAGENT::IObjectIA *i = (NLAIAGENT::IObjectIA *)NLAIC::createInstance(id);
+00552                                 
+00553                                 _LastBloc->addCode( new CLdbOpCode( *i ) );
+00554                                 _LastBloc->addCode(new CHaltOpCode());
+00555                                 CBagOfCode *b = _LastBloc->getBagOfCode();
+00556                                 
+00557 
+00558                                 NLAIAGENT::IBaseGroupType *g = new NLAIAGENT::CGroupType();
+00559                                 g->cpy(NLAIAGENT::CStringType(NLAIAGENT::CStringVarName(_CONSTRUCTOR_)));
+00560 
+00561                                 _Param.back()->incRef();                                        
+00562                                 _FlotingExpressionType->incRef();
+00563                                 CConstraintMethode *cm = new CConstraintMethode(CConstraintMethode::newCall,0,_FlotingExpressionType,g,_Param.back(),0,0);
+00564                                 IConstraint *c = getMethodConstraint(*cm);                                      
+00565                                 if(c == NULL)
+00566                                 {
+00567                                         c = cm;
+00568                                         _MethodConstraint.push_back(c);                                         
+00569                                 }
+00570                                 else
+00571                                 {
+00572                                         cm->release();
+00573                                 }
+00574                                 b->addConstraint(c);
+00575                                 i->release();                           
+00576                                 _LastStringParam.back()->release();
+00577                                 _LastStringParam.pop_back();
+00578                                 _Param.back()->release();
+00579                                 _Param.pop_back();              
+00580                         }
+00581                         catch(NLAIE::IException &)
+00582                         {
+00583                                 std::string text;
+00584                                 text = NLAIC::stringGetBuild("can't find '%s'",s->getStr().getString());
+00585                                 yyerror((char *)text.c_str());  
+00586                                 return false;                                   
+00587                         }
+00588                         return true;
+00589                 }
+00590                 return false;
+00591         }
+00592 
+00593         void CCompilateur::setTypeExpression()
+00594         {
+00595                 if(_ExpressionType)
+00596                 {                                                               
+00597                         COperandUnknown *gd = new COperandUnknown(_ExpressionType);
+00598                         _ExpressionType = gd;
+00599                 }
+00600                 else
+00601                 {
+00602                         _ExpressionType = new COperandUnknown(_FlotingExpressionType);
+00603                         _FlotingExpressionType = NULL;
+00604                 }
+00605         }
+00606 
+00607         void CCompilateur::setTypeExpression(NLAIC::CTypeOfOperator::TTypeOp op,const char *txtOp)
+00608         {
+00609                 if ( _ExpressionType )
+00610                 {                                       
+00611                         COperationType *gd = new COperationType;
+00612                         gd->setOperand(_ExpressionType);
+00613                         gd->setOp(op);
+00614                         _ExpressionType = gd;
+00615                 }
+00616                 else
+00617                 {
+00618                         _ExpressionType = new COperationType;           
+00619                         ((COperationType *)_ExpressionType)->setOperand(_FlotingExpressionType);
+00620                         ((COperationType *)_ExpressionType)->setOp(op);
+00621                         _FlotingExpressionType = NULL;
+00622                 }
+00623         }
+00624         
+00625         void CCompilateur::setTypeExpressionG()
+00626         {               
+00627                 if(_ExpressionType)
+00628                 {                                       
+00629                         COperationTypeGD *gd = new COperationTypeGD;
+00630                         gd->setOperationG(_ExpressionType);
+00631                         _ExpressionType = gd;
+00632                 }
+00633                 else
+00634                 {
+00635                         _ExpressionType = new COperationTypeGD;
+00636                         ((COperationTypeGD *)_ExpressionType)->setOperationG(_FlotingExpressionType);
+00637                         _FlotingExpressionType = NULL;
+00638                 }
+00639                 _ExpressionOp.push_back(_ExpressionType);
+00640                 _ExpressionType = NULL;
+00641         }
+00642 
+00643         void CCompilateur::setTypeExpressionD(NLAIC::CTypeOfOperator::TTypeOp op,const char *txtOp)
+00644         {
+00645                 if(_ExpressionType != NULL && _FlotingExpressionType == NULL) _FlotingExpressionType = _ExpressionType;
+00646                 //else if(_ExpressionType == NULL && _FlotingExpressionType != NULL) _FlotingExpressionType = _ExpressionType;
+00647                 _ExpressionType = _ExpressionOp.back();
+00648                 _ExpressionOp.pop_back();
+00649 
+00650                 ((COperationTypeGD *)_ExpressionType)->setOperationD(_FlotingExpressionType);
+00651                 ((COperationTypeGD *)_ExpressionType)->setOp(op);
+00652                 _FlotingExpressionType = NULL;
+00653         }
+00654 }
+
var_control.cpp
