nevrax.org : docs

00001 
+00007 /* Copyright, 2000 Nevrax Ltd.
+00008  *
+00009  * This file is part of NEVRAX NEL.
+00010  * NEVRAX NEL is free software; you can redistribute it and/or modify
+00011  * it under the terms of the GNU General Public License as published by
+00012  * the Free Software Foundation; either version 2, or (at your option)
+00013  * any later version.
+00014 
+00015  * NEVRAX NEL is distributed in the hope that it will be useful, but
+00016  * WITHOUT ANY WARRANTY; without even the implied warranty of
+00017  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+00018  * General Public License for more details.
+00019 
+00020  * You should have received a copy of the GNU General Public License
+00021  * along with NEVRAX NEL; see the file COPYING. If not, write to the
+00022  * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+00023  * MA 02111-1307, USA.
+00024  */
+00025 
+00026 #ifndef NL_OP_CODE_H
+00027 #define NL_OP_CODE_H
+00028 
+00029 #include <math.h>
+00030 #include "nel/ai/logic/varset.h"
+00031 #include "nel/ai/script/opcode_ldb.h"
+00032 #include "nel/ai/script/opcode_lpt.h"
+00033 #include "nel/ai/script/interpret_methodes.h"
+00034 #include "nel/ai/script/constraint.h"
+00035 
+00036 namespace NLAISCRIPT
+00037 {
+00048         class CLdbNewOpCode : public IOpRunCode
+00049         {
+00050         public:
+00051                 static const NLAIC::CIdentType IdLdbNewOpCode;
+00052         private:
+00053                 NLAIAGENT::IObjectIA *_B;
+00054         public:
+00055                 CLdbNewOpCode(const NLAIAGENT::IObjectIA &b): _B( (NLAIAGENT::IObjectIA *) b.clone() )
+00056                 {
+00057                 }
+00058 
+00059                 NLAIAGENT::TProcessStatement runOpCode(CCodeContext &context)
+00060                 {
+00061                         NLAIAGENT::IObjectIA *obj = (NLAIAGENT::IObjectIA *)_B->clone();
+00062                         NLAIAGENT::IBaseGroupType *param = (NLAIAGENT::IBaseGroupType *)context.Stack[(int)context.Stack];
+00063                         obj->init(param);
+00064                         param->release();
+00065                         //context.Stack ++;
+00066                         context.Stack[(int)context.Stack] = obj;
+00067                         return NLAIAGENT::IObjectIA::ProcessIdle;;
+00068                 }
+00069                 
+00070 
+00071                 void getDebugResult(std::string &str,CCodeContext &context) const
+00072                 {
+00073                         std::string X;
+00074                         _B->getDebugString(X);
+00075                         str = "ldb ";
+00076                         str += X;
+00077                 }
+00078 
+00079                 const NLAIC::IBasicType *clone() const
+00080                 {
+00081                         NLAIC::IBasicType *x = new CLdbNewOpCode(*_B);
+00082                         return x;
+00083                 }
+00084 
+00085                 const NLAIC::IBasicType *newInstance() const 
+00086                 {
+00087                         return clone();
+00088                 }
+00089 
+00090                 const NLAIC::CIdentType &getType() const
+00091                 {
+00092                         return IdLdbNewOpCode;
+00093                 }
+00094 
+00095                 void getDebugString(char *) const{ }
+00096 
+00097                 void save(NLMISC::IStream &os)
+00098                 {
+00099                         os.serial( (NLAIC::CIdentType &) (_B->getType()) );
+00100                         _B->save(os);           
+00101                 }
+00102 
+00103                 void load(NLMISC::IStream &is) 
+00104                 {
+00105                         _B->release();
+00106                         NLAIC::CIdentTypeAlloc id;
+00107                         is >> id;
+00108                         _B = (NLAIAGENT::IObjectIA *)id.allocClass();
+00109                         _B->load(is);
+00110                 }
+00111                 const NLAIAGENT::IObjectIA::CProcessResult &run(){return NLAIAGENT::IObjectIA::ProcessRun;;}
+00112                 bool isEqual(const NLAIAGENT::IBasicObjectIA &a) const{ return true;}   
+00113                 
+00114                 virtual ~CLdbNewOpCode()
+00115                 {
+00116                         _B->release();
+00117                 }
+00118         };
+00119 
+00121 
+00127 
+00138         class CNegOpCode: public IOpRunCode
+00139         {
+00140         public:
+00141                 static const NLAIC::CIdentType IdNegOpCode;
+00142         private:
+00143                 
+00144         public:
+00145                                 
+00146                 CNegOpCode()
+00147                 {
+00148                 }
+00149                 
+00150                 NLAIAGENT::TProcessStatement runOpCode(CCodeContext &context);          
+00151 
+00152                 void getDebugResult(std::string &str,CCodeContext &context) const;
+00153                 
+00154                 const NLAIC::IBasicType *clone() const 
+00155                 {                       
+00156                         NLAIC::IBasicType *x = new CNegOpCode();
+00157                         return x;
+00158                 }
+00159                 const NLAIC::IBasicType *newInstance() const 
+00160                 {
+00161                         return clone();
+00162                 }
+00163 
+00164                 const NLAIC::CIdentType &getType() const
+00165                 {
+00166                         return IdNegOpCode;
+00167                 }
+00168                 
+00169 
+00170                 void save(NLMISC::IStream &os)
+00171                 {               
+00172                 }
+00173                                 
+00174                 void load(NLMISC::IStream &is) 
+00175                 {               
+00176                 }
+00177                 
+00178                 virtual ~CNegOpCode()
+00179                 {
+00180                 }
+00181         };
+00182         
+00193         class CAddOpCode: public IOpRunCode
+00194         {
+00195         public:
+00196                 static const NLAIC::CIdentType IdAddOpCode;
+00197         private:
+00198                 
+00199         public:
+00200                 
+00201                 CAddOpCode()
+00202                 {
+00203                 }
+00204                 
+00205                 NLAIAGENT::TProcessStatement runOpCode(CCodeContext &context);
+00206 
+00207                 void getDebugResult(std::string &str,CCodeContext &context) const ;
+00208 
+00209                 const NLAIC::IBasicType *clone() const 
+00210                 {                       
+00211                         NLAIC::IBasicType *x = new CAddOpCode();
+00212                         return x;
+00213                 }
+00214                 const NLAIC::IBasicType *newInstance() const 
+00215                 {
+00216                         return clone();
+00217                 }
+00218 
+00219                 const NLAIC::CIdentType &getType() const
+00220                 {
+00221                         return IdAddOpCode;
+00222                 }
+00223                 
+00224 
+00225                 void save(NLMISC::IStream &os)
+00226                 {               
+00227                 }                               
+00228 
+00229                 void load(NLMISC::IStream &is) 
+00230                 {               
+00231                 }
+00232                 
+00233                 virtual ~CAddOpCode()
+00234                 {
+00235                 }
+00236         };
+00237 
+00248         class CSubOpCode: public IOpRunCode
+00249         {
+00250         public:
+00251                 static const NLAIC::CIdentType IdSubOpCode;
+00252         private:
+00253                 
+00254         public:
+00255 
+00256                 CSubOpCode()
+00257                 {
+00258                 }
+00259                 
+00260                 NLAIAGENT::TProcessStatement runOpCode(CCodeContext &context);
+00261                 
+00262                 void getDebugResult(std::string &str,CCodeContext &context) const;
+00263 
+00264                 const NLAIC::IBasicType *clone() const
+00265                 {
+00266                         NLAIC::IBasicType *x = new CSubOpCode();
+00267                         return x;
+00268                 }
+00269                 
+00270                 const NLAIC::IBasicType *newInstance() const 
+00271                 {
+00272                         return clone();
+00273                 }
+00274 
+00275                 const NLAIC::CIdentType &getType() const
+00276                 {
+00277                         return IdSubOpCode;
+00278                 }
+00279                 
+00280 
+00281                 void save(NLMISC::IStream &os)
+00282                 {               
+00283                 }
+00284 
+00285                 void load(NLMISC::IStream &is) 
+00286                 {               
+00287                 }                               
+00288 
+00289                 virtual ~CSubOpCode()
+00290                 {
+00291                 }
+00292         };
+00293 
+00304         class CDivOpCode: public IOpRunCode
+00305         {
+00306         public:
+00307                 static const NLAIC::CIdentType IdDivOpCode;
+00308         private:
+00309                 
+00310         public:
+00311 
+00312                 CDivOpCode()
+00313                 {               
+00314                 }
+00315                 
+00316                 NLAIAGENT::TProcessStatement runOpCode(CCodeContext &context);
+00317                 void getDebugResult(std::string &str,CCodeContext &context) const;
+00318 
+00319                 const NLAIC::IBasicType *clone() const
+00320                 {
+00321                         NLAIC::IBasicType *x = new CDivOpCode();
+00322                         return x;
+00323                 }
+00324                 
+00325                 const NLAIC::IBasicType *newInstance() const 
+00326                 {
+00327                         return clone();
+00328                 }
+00329 
+00330                 const NLAIC::CIdentType &getType() const
+00331                 {
+00332                         return IdDivOpCode;
+00333                 }
+00334                 
+00335 
+00336                 void save(NLMISC::IStream &os)
+00337                 {               
+00338                 }
+00339 
+00340                 void load(NLMISC::IStream &is) 
+00341                 {               
+00342                 }
+00343                                 
+00344                 virtual ~CDivOpCode()
+00345                 {
+00346                 }
+00347         };
+00348 
+00359         class CMulOpCode: public IOpRunCode
+00360         {
+00361         public:
+00362                 static const NLAIC::CIdentType IdMulOpCode;
+00363                 
+00364         private:
+00365                 
+00366         public:
+00367 
+00368                 CMulOpCode()
+00369                 {
+00370                 }       
+00371                 
+00372                 NLAIAGENT::TProcessStatement runOpCode(CCodeContext &context);
+00373 
+00374                 void getDebugResult(std::string &str,CCodeContext &context) const;
+00375 
+00376                 const NLAIC::IBasicType *clone() const
+00377                 {
+00378                         NLAIC::IBasicType *x = new CMulOpCode();
+00379                         return x;
+00380                 }
+00381                 const NLAIC::IBasicType *newInstance() const 
+00382                 {
+00383                         return clone();
+00384                 }
+00385 
+00386                 const NLAIC::CIdentType &getType() const
+00387                 {
+00388                         return IdMulOpCode;
+00389                 }
+00390                 
+00391 
+00392                 void save(NLMISC::IStream &os)
+00393                 {               
+00394                 }
+00395 
+00396                 void load(NLMISC::IStream &is) 
+00397                 {               
+00398                 }                               
+00399                 
+00400                 virtual ~CMulOpCode()
+00401                 {
+00402                 }
+00403         };
+00404 
+00405 
+00416         class CSupOpCode: public IOpRunCode
+00417         {
+00418         public:
+00419                 static const NLAIC::CIdentType IdSupOpCode;
+00420         private:
+00421                 
+00422         public: 
+00423 
+00424                 CSupOpCode()
+00425                 {               
+00426                 }
+00427                 
+00428                 NLAIAGENT::TProcessStatement runOpCode(CCodeContext &context);          
+00429 
+00430                 void getDebugResult(std::string &str,CCodeContext &context) const;
+00431                 
+00432                 const NLAIC::IBasicType *clone() const
+00433                 {
+00434                         NLAIC::IBasicType *x = new CSupOpCode();
+00435                         return x;
+00436                 }
+00437                 const NLAIC::IBasicType *newInstance() const 
+00438                 {
+00439                         return clone();
+00440                 }
+00441 
+00442                 const NLAIC::CIdentType &getType() const
+00443                 {
+00444                         return IdSupOpCode;
+00445                 }
+00446                 
+00447 
+00448                 void save(NLMISC::IStream &os)
+00449                 {               
+00450                 }
+00451 
+00452                 void load(NLMISC::IStream &is) 
+00453                 {               
+00454                 }                               
+00455                 
+00456                 virtual ~CSupOpCode()
+00457                 {
+00458                 }
+00459         };
+00460 
+00471         class CInfOpCode: public IOpRunCode
+00472         {
+00473         public:
+00474                 static const NLAIC::CIdentType IdInfOpCode;
+00475 
+00476         private:
+00477                 
+00478         public: 
+00479                 
+00480                 CInfOpCode()
+00481                 {
+00482                 }
+00483                 
+00484                 NLAIAGENT::TProcessStatement runOpCode(CCodeContext &context);
+00485 
+00486                 void getDebugResult(std::string &str,CCodeContext &context) const;
+00487 
+00488                 const NLAIC::IBasicType *clone() const
+00489                 {
+00490                         NLAIC::IBasicType *x = new CInfOpCode();
+00491                         return x;
+00492                 }
+00493                 const NLAIC::IBasicType *newInstance() const 
+00494                 {
+00495                         return clone();
+00496                 }
+00497 
+00498                 const NLAIC::CIdentType &getType() const
+00499                 {
+00500                         return IdInfOpCode;
+00501                 }
+00502                 
+00503 
+00504                 void save(NLMISC::IStream &os)
+00505                 {               
+00506                 }
+00507 
+00508                 void load(NLMISC::IStream &is) 
+00509                 {               
+00510                 }                               
+00511 
+00512                 virtual ~CInfOpCode()
+00513                 {
+00514                 }
+00515         };
+00516 
+00527         class CEqOpCode: public IOpRunCode
+00528         {
+00529         public:
+00530                 static const NLAIC::CIdentType IdEqOpCode;
+00531         private:
+00532                 
+00533         public: 
+00534 
+00535                 CEqOpCode()
+00536                 {
+00537                 }
+00538                 
+00539                 NLAIAGENT::TProcessStatement runOpCode(CCodeContext &context);
+00540 
+00541                 void getDebugResult(std::string &str,CCodeContext &context) const;
+00542 
+00543                 const NLAIC::IBasicType *clone() const
+00544                 {
+00545                         NLAIC::IBasicType *x = new CEqOpCode();
+00546                         return x;            
+00547                 }
+00548 
+00549                 const NLAIC::IBasicType *newInstance() const 
+00550                 {
+00551                         return clone();
+00552                 }
+00553 
+00554                 const NLAIC::CIdentType &getType() const
+00555                 {
+00556                         return IdEqOpCode;
+00557                 }
+00558                 
+00559 
+00560                 void save(NLMISC::IStream &os)
+00561                 {               
+00562                 }
+00563 
+00564                 void load(NLMISC::IStream &is) 
+00565                 {               
+00566                 }
+00567                                 
+00568                 virtual ~CEqOpCode()
+00569                 {
+00570                 }
+00571         };
+00572 
+00583         class CSupEqOpCode: public IOpRunCode
+00584         {
+00585         public:
+00586                 static const NLAIC::CIdentType IdSupEqOpCode;
+00587         private:
+00588                 
+00589         public: 
+00590 
+00591                 CSupEqOpCode()
+00592                 {
+00593                 }
+00594                 
+00595                 NLAIAGENT::TProcessStatement runOpCode(CCodeContext &context);
+00596                 void getDebugResult(std::string &str,CCodeContext &context) const;
+00597 
+00598                 const NLAIC::IBasicType *clone() const
+00599                 {
+00600                         NLAIC::IBasicType *x = new CSupEqOpCode();
+00601                         return x;            
+00602                 }
+00603                 const NLAIC::IBasicType *newInstance() const 
+00604                 {
+00605                         return clone();
+00606                 }
+00607 
+00608                 const NLAIC::CIdentType &getType() const
+00609                 {
+00610                         return IdSupEqOpCode;
+00611                 }
+00612                 
+00613 
+00614                 void save(NLMISC::IStream &os)
+00615                 {               
+00616                 }
+00617 
+00618                 void load(NLMISC::IStream &is) 
+00619                 {               
+00620                 }
+00621                                 
+00622                 
+00623                 virtual ~CSupEqOpCode()
+00624                 {
+00625                 }
+00626         };
+00627 
+00638         class CInfEqOpCode: public IOpRunCode
+00639         {
+00640         public:
+00641                 static const NLAIC::CIdentType IdInfEqOpCode;
+00642         private:
+00643                 
+00644         public: 
+00645                 CInfEqOpCode()
+00646                 {               
+00647                 }
+00648                 
+00649                 NLAIAGENT::TProcessStatement runOpCode(CCodeContext &context);          
+00650 
+00651                 void getDebugResult(std::string &str,CCodeContext &context) const;              
+00652                 
+00653                 const NLAIC::IBasicType *clone() const
+00654                 {
+00655                         NLAIC::IBasicType *x = new CInfEqOpCode();
+00656                         return x;            
+00657                 }
+00658 
+00659                 const NLAIC::IBasicType *newInstance() const 
+00660                 {
+00661                         return clone();
+00662                 }
+00663 
+00664                 const NLAIC::CIdentType &getType() const
+00665                 {
+00666                         return IdInfEqOpCode;
+00667                 }
+00668                 
+00669 
+00670                 void save(NLMISC::IStream &os)
+00671                 {               
+00672                 }
+00673 
+00674                 void load(NLMISC::IStream &is) 
+00675                 {               
+00676                 }
+00677                                 
+00678 
+00679                 virtual ~CInfEqOpCode()
+00680                 {
+00681                 }
+00682         };
+00683 
+00694         class CDiffOpCode: public IOpRunCode
+00695         {
+00696         public:
+00697                 static const NLAIC::CIdentType IdDiffOpCode;
+00698         private:
+00699                 
+00700         public: 
+00701                 CDiffOpCode()
+00702                 {
+00703                 }
+00704                 
+00705                 NLAIAGENT::TProcessStatement runOpCode(CCodeContext &context);
+00706 
+00707                 void getDebugResult(std::string &str,CCodeContext &context) const;
+00708 
+00709                 const NLAIC::IBasicType *clone() const
+00710                 {
+00711                         NLAIC::IBasicType *x = new CDiffOpCode();
+00712                         return x;            
+00713                 }
+00714                 const NLAIC::IBasicType *newInstance() const 
+00715                 {
+00716                         return clone();
+00717                 }
+00718 
+00719                 const NLAIC::CIdentType &getType() const
+00720                 {
+00721                         return IdDiffOpCode;
+00722                 }
+00723 
+00724                 void getDebugString(char *) const{ }
+00725 
+00726                 void save(NLMISC::IStream &os)
+00727                 {               
+00728                 }
+00729 
+00730                 void load(NLMISC::IStream &is) 
+00731                 {               
+00732                 }                               
+00733                 
+00734                 virtual ~CDiffOpCode()
+00735                 {
+00736                 }
+00737         };
+00738 
+00749         class CNotOpCode: public IOpRunCode
+00750         {
+00751         public:
+00752                 static const NLAIC::CIdentType IdNotOpCode;
+00753                 
+00754         private:
+00755                 
+00756         public: 
+00757                 CNotOpCode()
+00758                 {
+00759                 }
+00760                 
+00761                 NLAIAGENT::TProcessStatement runOpCode(CCodeContext &context);
+00762                 
+00763                 void getDebugResult(std::string &str,CCodeContext &context) const;
+00764                 
+00765                 const NLAIC::IBasicType *clone() const
+00766                 {
+00767                         NLAIC::IBasicType *x = new CNotOpCode();
+00768                         return x;            
+00769                 }
+00770                 const NLAIC::IBasicType *newInstance() const 
+00771                 {
+00772                         return clone();
+00773                 }
+00774 
+00775                 const NLAIC::CIdentType &getType() const
+00776                 {
+00777                         return IdNotOpCode;
+00778                 }
+00779 
+00780                 void getDebugString(char *) const{ }
+00781 
+00782                 void save(NLMISC::IStream &os)
+00783                 {               
+00784                 }
+00785 
+00786                 void load(NLMISC::IStream &is) 
+00787                 {               
+00788                 }
+00789                                 
+00790                 
+00791                 virtual ~CNotOpCode()
+00792                 {
+00793                 }
+00794         };
+00795 
+00797 
+00808         class CJFalseOpCode: public IOpRunCode
+00809         {
+00810         public:
+00811                 static const NLAIC::CIdentType IdJFalseOpCode;
+00812         private:
+00813                 int _N; 
+00814         public: 
+00815                 CJFalseOpCode(int l):
+00816                 _N(l)
+00817                 {
+00818                 }
+00819                 
+00820                 NLAIAGENT::TProcessStatement runOpCode(CCodeContext &context)
+00821                 {               
+00822                         NLAIAGENT::IObjetOp *op = !*((NLAIAGENT::IObjetOp *)((NLAIAGENT::IObjectIA *)context.Stack));
+00823                         if(op->isTrue()) *context.Code += _N;
+00824                         op->release();
+00825                         context.Stack--;
+00826                         return NLAIAGENT::IObjectIA::ProcessIdle;
+00827                 }
+00828 
+00829                 void getDebugResult(std::string &str,CCodeContext &context) const 
+00830                 {
+00831                         std::string X;          
+00832                         context.Stack[(int)context.Stack]->getDebugString(X);
+00833                         str = NLAIC::stringGetBuild("if !(%s) is false then goto %d",X.c_str(),_N);     
+00834                 }
+00835                 const NLAIC::IBasicType *clone() const
+00836                 {
+00837                         NLAIC::IBasicType *x = new CJFalseOpCode(_N);
+00838                         return x;            
+00839                 }
+00840                 const NLAIC::IBasicType *newInstance() const 
+00841                 {
+00842                         return clone();
+00843                 }
+00844                 const NLAIC::CIdentType &getType() const
+00845                 {
+00846                         return IdJFalseOpCode;
+00847                 }               
+00848 
+00849                 void save(NLMISC::IStream &os)
+00850                 {
+00851                         sint32 n = (sint32) _N;
+00852                         os.serial( n );
+00853                 }
+00854 
+00855                 void load(NLMISC::IStream &is) 
+00856                 {               
+00857                         sint32 n;
+00858                         is.serial( n );
+00859                         _N = (int) n;
+00860                 }
+00861                 
+00862                 virtual ~CJFalseOpCode()
+00863                 {
+00864                 }
+00865         };
+00866 
+00876         class CJmpOpCode: public IOpRunCode
+00877         {
+00878         public:
+00879                 static const NLAIC::CIdentType IdJmpOpCode;
+00880         private:
+00881                 int _N; 
+00882         public: 
+00883                 CJmpOpCode(int l):
+00884                 _N(l)
+00885                 {
+00886                 }
+00887                 
+00888                 
+00889                 NLAIAGENT::TProcessStatement runOpCode(CCodeContext &context)
+00890                 {                               
+00891                         *context.Code += _N;    
+00892                         return NLAIAGENT::IObjectIA::ProcessIdle;;
+00893                 }
+00894 
+00895                 void getDebugResult(std::string &str,CCodeContext &context) const
+00896                 {               
+00897                         str = NLAIC::stringGetBuild("goto %d",_N);      
+00898                 }
+00899                 const NLAIC::IBasicType *clone() const
+00900                 {
+00901                         NLAIC::IBasicType *x = new CJmpOpCode(_N);
+00902                         return x;            
+00903                 }
+00904                 const NLAIC::IBasicType *newInstance() const 
+00905                 {
+00906                         return clone();
+00907                 }
+00908                 const NLAIC::CIdentType &getType() const
+00909                 {
+00910                         return IdJmpOpCode;
+00911                 }
+00912 
+00913                 void save(NLMISC::IStream &os)
+00914                 {
+00915                         sint32 n = (sint32) _N;
+00916                         os.serial( n );
+00917                 }
+00918 
+00919                 void load(NLMISC::IStream &is) 
+00920                 {               
+00921                         sint32 n;
+00922                         is.serial( n );
+00923                         _N = (int) n;
+00924                 }
+00925 
+00926                 virtual ~CJmpOpCode()
+00927                 {
+00928                 }
+00929         };
+00930 
+00931 
+00933 
+00934 
+00946         class CAffOpCode: public IOpRunCode
+00947         {
+00948         public:
+00949                 static const NLAIC::CIdentType IdAffOpCode;
+00950                 
+00951         private:
+00953                 int _I;
+00954         public: 
+00955                 CAffOpCode(int i):
+00956                   _I(i)
+00957                 {
+00958                         
+00959                 }
+00960                 
+00961                 NLAIAGENT::TProcessStatement runOpCode(CCodeContext &context)
+00962                 {                               
+00963                         NLAIAGENT::IObjectIA *i = (NLAIAGENT::IObjectIA *)context.Stack;
+00964                         i->incRef();
+00965                         NLAIAGENT::IObjectIA *tmp = context.Heap[(int)_I];
+00966                         context.Heap[_I] = i;
+00967                         if(tmp) tmp->release();                 
+00968                         context.Stack --;
+00969                         return NLAIAGENT::IObjectIA::ProcessIdle;;
+00970                 }
+00971 
+00972                 void getDebugResult(std::string &str,CCodeContext &context) const
+00973                 {
+00974                         std::string Y;                                  
+00975                         context.Stack[(int)context.Stack]->getDebugString(Y);
+00976                         str = NLAIC::stringGetBuild("Affectation<%d> a %s",_I,Y.c_str());
+00977                 }
+00978 
+00979                 const NLAIC::IBasicType *clone() const
+00980                 {
+00981                         NLAIC::IBasicType *x = new CAffOpCode(_I);
+00982                         return x;            
+00983                 }
+00984                 const NLAIC::IBasicType *newInstance() const 
+00985                 {
+00986                         return clone();
+00987                 }
+00988 
+00989                 const NLAIC::CIdentType &getType() const
+00990                 {
+00991                         return IdAffOpCode;
+00992                 }
+00993 
+00994                 void getDebugString(char *) const{ }
+00995 
+00996                 void save(NLMISC::IStream &os)
+00997                 {
+00998                         sint32 i = (sint32) _I;
+00999                         os.serial( i );
+01000                 }
+01001 
+01002                 void load(NLMISC::IStream &is) 
+01003                 {               
+01004                         sint32 i;
+01005                         is.serial( i );
+01006                         _I = (int) i;
+01007                 }
+01008                                 
+01009 
+01010                 virtual ~CAffOpCode()
+01011                 {
+01012                 }
+01013         };
+01014 
+01016         class CAffOpCodeDebug : public IOpRunCode
+01017         {
+01018         public:
+01019                 static const NLAIC::CIdentType IdAffOpCodeDebug;
+01020                 
+01021         private:
+01022                 int _I;
+01023                 char * _VarName;
+01024 
+01025         public: 
+01026                 CAffOpCodeDebug(int i, const char* varName);
+01027                 
+01028                 virtual ~CAffOpCodeDebug();
+01029 
+01030                 NLAIAGENT::TProcessStatement runOpCode(CCodeContext &context);
+01031 
+01032                 void getDebugResult(std::string &str,CCodeContext &context) const;
+01033 
+01034                 const NLAIC::IBasicType *clone() const;
+01035 
+01036                 const NLAIC::IBasicType *newInstance() const;
+01037 
+01038                 const NLAIC::CIdentType &getType() const;
+01039 
+01040                 void getDebugString(char *) const;
+01041 
+01042                 void save(NLMISC::IStream &os);
+01043 
+01044                 void load(NLMISC::IStream &is);
+01045         };
+01046 
+01058         class CAffHeapMemberiOpCode: public IOpRunCode
+01059         {
+01060         public:
+01061                 static const NLAIC::CIdentType IdAffHeapMemberiOpCode;
+01062         private:
+01063                 std::list<sint32> _I;
+01064                 sint32 _N;
+01065         public: 
+01066                 CAffHeapMemberiOpCode(std::list<sint32> i,sint32 n):
+01067                   _I(i),_N(n)
+01068                 {
+01069                         
+01070                 }
+01071                 
+01072                 NLAIAGENT::TProcessStatement runOpCode(CCodeContext &context);          
+01073 
+01074                 void getDebugResult(std::string &str,CCodeContext &context) const;              
+01075 
+01076                 const NLAIC::IBasicType *clone() const
+01077                 {
+01078                         NLAIC::IBasicType *x = new CAffHeapMemberiOpCode(_I,_N);
+01079                         return x;            
+01080                 }
+01081                 const NLAIC::IBasicType *newInstance() const 
+01082                 {
+01083                         return clone();
+01084                 }
+01085 
+01086                 const NLAIC::CIdentType &getType() const
+01087                 {
+01088                         return IdAffHeapMemberiOpCode;
+01089                 }
+01090 
+01091 
+01092                 void save(NLMISC::IStream &os)
+01093                 {
+01094                         sint32 n = (sint32) _N;
+01095                         os.serial( n );
+01096                         std::list<sint32> &i = (std::list<sint32> &)_I;
+01097                         os.serialCont(i);
+01098                 }
+01099 
+01100                 void load(NLMISC::IStream &is) 
+01101                 {                               
+01102                         sint32 n;
+01103                         is.serial(n);
+01104                         _N = n;
+01105                         is.serialCont(_I);
+01106                 }
+01107 
+01108                 virtual ~CAffHeapMemberiOpCode()
+01109                 {
+01110                 }
+01111         };
+01112 
+01123         class CAffMemberiOpCode: public IOpRunCode
+01124         {
+01125         public:
+01126                 static const NLAIC::CIdentType IdAffMemberiOpCode;
+01127         private:
+01128                 std::list<sint32> _I;
+01129         public: 
+01130                 CAffMemberiOpCode(std::list<sint32> i):
+01131                   _I(i)
+01132                 {
+01133                         
+01134                 }
+01135                 
+01136                 NLAIAGENT::TProcessStatement runOpCode(CCodeContext &context);          
+01137 
+01138                 void getDebugResult(std::string &str,CCodeContext &context) const
+01139                 {
+01140                         
+01141                         str = "Affectation du membre";
+01142                 }
+01143 
+01144                 const NLAIC::IBasicType *clone() const
+01145                 {
+01146                         NLAIC::IBasicType *x = new CAffMemberiOpCode(_I);
+01147                         return x;            
+01148                 }
+01149                 const NLAIC::IBasicType *newInstance() const 
+01150                 {
+01151                         return clone();
+01152                 }
+01153 
+01154                 const NLAIC::CIdentType &getType() const
+01155                 {
+01156                         return IdAffMemberiOpCode;
+01157                 }
+01158 
+01159 
+01160                 void save(NLMISC::IStream &os)
+01161                 {
+01162                         std::list<sint32> &i = (std::list<sint32> &)_I;
+01163                         os.serialCont(i);
+01164                 }
+01165 
+01166                 void load(NLMISC::IStream &is) 
+01167                 {       
+01168                         is.serialCont( _I );
+01169                 }
+01170                                 
+01171 
+01172                 virtual ~CAffMemberiOpCode()
+01173                 {
+01174                 }
+01175         };
+01176 
+01187         class CAffMemberOpCode: public IOpRunCode
+01188         {
+01189         public:
+01190                 static const NLAIC::CIdentType IdAffMemberOpCode;
+01191                 
+01192         private:
+01193                 int _I;
+01194         public: 
+01195                 CAffMemberOpCode(int i):
+01196                   _I(i)
+01197                 {
+01198                         
+01199                 }
+01200                 
+01201                 NLAIAGENT::TProcessStatement runOpCode(CCodeContext &context);
+01202 
+01203                 void getDebugResult(std::string &str,CCodeContext &context) const
+01204                 {                       
+01205                         str = NLAIC::stringGetBuild("Affectation du membre %d",_I);     
+01206                 }
+01207 
+01208                 const NLAIC::IBasicType *clone() const
+01209                 {
+01210                         NLAIC::IBasicType *x = new CAffMemberOpCode(_I);                        
+01211                         return x;            
+01212                 }
+01213                 const NLAIC::IBasicType *newInstance() const 
+01214                 {
+01215                         return clone();
+01216                 }
+01217 
+01218                 const NLAIC::CIdentType &getType() const
+01219                 {
+01220                         return IdAffMemberOpCode;
+01221                 }
+01222 
+01223 
+01224                 void save(NLMISC::IStream &os)
+01225                 {
+01226                         sint32 i = (sint32) _I;
+01227                         os.serial( i );
+01228                 }
+01229 
+01230                 void load(NLMISC::IStream &is) 
+01231                 {               
+01232                         sint32 i;
+01233                         is.serial( i );
+01234                         _I = (int) i;
+01235                 }
+01236                                 
+01237 
+01238                 virtual ~CAffMemberOpCode()
+01239                 {
+01240                 }
+01241         };
+01242 
+01244 
+01246         class CLocAlloc: public IOpRunCode
+01247         {
+01248         public:
+01249                 static const NLAIC::CIdentType IdLocAlloc;
+01250         public: 
+01251         
+01252                 CLocAlloc()
+01253                 {
+01254                         
+01255                 }               
+01256         
+01257                 
+01258                 NLAIAGENT::TProcessStatement runOpCode(CCodeContext &context)
+01259                 {                               
+01260                         /*NLAIAGENT::IObjectIA *i = (NLAIAGENT::IObjectIA *)NLAIC::getRegistry()->createInstance(_B);
+01261                         context.Heap[(int)context.Heap] = NULL;*/
+01262                         context.Heap ++;
+01263                         return NLAIAGENT::IObjectIA::ProcessIdle;;
+01264                 }
+01265 
+01266                 void getDebugResult(std::string &str,CCodeContext &context) const
+01267                 {                                       
+01268                         str = NLAIC::stringGetBuild("Reservation d'un espace memoir locale pour une variable � l'emplacement %d",(int)context.Heap);                            
+01269                 }
+01270 
+01271                 const NLAIC::IBasicType *clone() const
+01272                 {
+01273                         NLAIC::IBasicType *x = new CLocAlloc();
+01274                         return x;            
+01275                 }
+01276                 const NLAIC::IBasicType *newInstance() const 
+01277                 {
+01278                         return clone();
+01279                 }
+01280 
+01281                 const NLAIC::CIdentType &getType() const
+01282                 {
+01283                         return IdLocAlloc;
+01284                 }               
+01285 
+01286                 void save(NLMISC::IStream &os)
+01287                 {                       
+01288                 }
+01289 
+01290                 void load(NLMISC::IStream &is) 
+01291                 {                               
+01292                 }
+01293                                 
+01294                 
+01295                 virtual ~CLocAlloc()
+01296                 {                       
+01297                 }
+01298         };
+01299 
+01301         class CLocAllocDebug: public IOpRunCode
+01302         {
+01303         public:
+01304                 static const NLAIC::CIdentType IdLocAllocDebug;
+01305 
+01306         public: 
+01307         
+01308                 CLocAllocDebug();
+01309                 
+01310                 virtual ~CLocAllocDebug();
+01311 
+01312                 NLAIAGENT::TProcessStatement runOpCode(CCodeContext &context);
+01313 
+01314                 void getDebugResult(std::string &str,CCodeContext &context) const;
+01315 
+01316                 const NLAIC::IBasicType *clone() const;
+01317 
+01318                 const NLAIC::IBasicType *newInstance() const ;
+01319 
+01320                 const NLAIC::CIdentType &getType() const;
+01321 
+01322                 void save(NLMISC::IStream &os);
+01323 
+01324                 void load(NLMISC::IStream &is);
+01325                 
+01326         };
+01327 
+01329         class CMarkAlloc: public IOpRunCode
+01330         {
+01331         public:
+01332                 static const NLAIC::CIdentType IdMarkAlloc;
+01333         public:
+01334                 CMarkAlloc()
+01335                 {
+01336                 }
+01337                 
+01338                 NLAIAGENT::TProcessStatement runOpCode(CCodeContext &context)
+01339                 {                               
+01340                         context.Heap.pushMark();        
+01341                         return NLAIAGENT::IObjectIA::ProcessIdle;;
+01342                 }
+01343                 void getDebugResult(std::string &str,CCodeContext &context) const
+01344                 {               
+01345                         str = NLAIC::stringGetBuild("Marque le bloc de memoire a %d",(int)context.Heap);        
+01346                 }
+01347 
+01348                 const NLAIC::IBasicType *clone() const
+01349                 {
+01350                         NLAIC::IBasicType *x = new CMarkAlloc();
+01351                         return x;            
+01352                 }
+01353                 const NLAIC::IBasicType *newInstance() const 
+01354                 {
+01355                         return clone();
+01356                 }
+01357 
+01358                 const NLAIC::CIdentType &getType() const
+01359                 {
+01360                         return IdMarkAlloc;
+01361                 }
+01362 
+01363 
+01364                 void save(NLMISC::IStream &os)
+01365                 {               
+01366                 }
+01367 
+01368                 void load(NLMISC::IStream &is) 
+01369                 {                               
+01370                 }                               
+01371 
+01372                 virtual ~CMarkAlloc()
+01373                 {
+01374                 }
+01375         };
+01376 
+01378         class CFreeAlloc: public IOpRunCode
+01379         {
+01380         public:
+01381                 static const NLAIC::CIdentType IdFreeAlloc;
+01382         public:
+01383 
+01384                 CFreeAlloc()
+01385                 {
+01386                 }
+01387                 
+01388                 NLAIAGENT::TProcessStatement runOpCode(CCodeContext &context)
+01389                 {                               
+01390                         int i = (int)context.Heap;      
+01391                         i -= context.Heap.popMark();
+01392                         context.Heap -= i;
+01393                         return NLAIAGENT::IObjectIA::ProcessIdle;;
+01394                 }
+01395                 void getDebugResult(std::string &str,CCodeContext &context) const
+01396                 {               
+01397                         str = NLAIC::stringGetBuild("libere le bloc de memoire de %d � %d",(int)context.Heap.mark(),(int)context.Heap); 
+01398                 }
+01399 
+01400                 const NLAIC::IBasicType *clone() const
+01401                 {
+01402                         NLAIC::IBasicType *x = new CFreeAlloc();
+01403                         return x;            
+01404                 }
+01405                 const NLAIC::IBasicType *newInstance() const 
+01406                 {
+01407                         return clone();
+01408                 }
+01409 
+01410                 const NLAIC::CIdentType &getType() const
+01411                 {
+01412                         return IdFreeAlloc;
+01413                 }
+01414 
+01415                 
+01416                 
+01417                 void save(NLMISC::IStream &os)
+01418                 {               
+01419                 }
+01420 
+01421                 void load(NLMISC::IStream &is) 
+01422                 {                               
+01423                 }                               
+01424                 
+01425                 virtual ~CFreeAlloc()
+01426                 {
+01427                 }
+01428         };
+01429 
+01431         class CFreeAllocDebug: public IOpRunCode
+01432         {
+01433         public:
+01434                 static const NLAIC::CIdentType IdFreeAllocDebug;
+01435         public:
+01436 
+01437                 CFreeAllocDebug();
+01438                 
+01439                 NLAIAGENT::TProcessStatement runOpCode(CCodeContext &context);
+01440 
+01441                 virtual ~CFreeAllocDebug();
+01442 
+01443                 void getDebugResult(std::string &str,CCodeContext &context) const;
+01444 
+01445                 const NLAIC::IBasicType *clone() const;
+01446 
+01447                 const NLAIC::IBasicType *newInstance() const;
+01448 
+01449                 const NLAIC::CIdentType &getType() const;
+01450                 
+01451                 void save(NLMISC::IStream &os);
+01452 
+01453                 void load(NLMISC::IStream &is);
+01454         };
+01455 
+01457         class CHaltOpCode: public IOpRunCode
+01458         {
+01459         public:
+01460                 static const NLAIC::CIdentType IdHaltOpCode;
+01461         public: 
+01462                 CHaltOpCode()
+01463                 {
+01464                 }               
+01465                 
+01466                 NLAIAGENT::TProcessStatement runOpCode(CCodeContext &context)
+01467                 {               
+01468                         return NLAIAGENT::IObjectIA::ProcessEnd;
+01469                 }
+01470                 void getDebugResult(std::string &str,CCodeContext &context) const
+01471                 {               
+01472                         str = "Stop";
+01473                 }
+01474 
+01475                 const NLAIC::IBasicType *clone() const
+01476                 {
+01477                         NLAIC::IBasicType *x = new CHaltOpCode();
+01478                         return x;            
+01479                 }
+01480                 const NLAIC::IBasicType *newInstance() const 
+01481                 {
+01482                         return clone();
+01483                 }
+01484                 const NLAIC::CIdentType &getType() const
+01485                 {
+01486                         return IdHaltOpCode;
+01487                 }
+01488 
+01489                 
+01490 
+01491                 void save(NLMISC::IStream &os)
+01492                 {               
+01493                 }
+01494 
+01495                 void load(NLMISC::IStream &is) 
+01496                 {                               
+01497                 }
+01498                                 
+01499 
+01500                 virtual ~CHaltOpCode()
+01501                 {
+01502                 }
+01503         };              
+01504 
+01505 
+01507         class CNopOpCode: public IOpRunCode
+01508         {
+01509         public:
+01510                 static const NLAIC::CIdentType IdNopOpCode;
+01511         public: 
+01512                 CNopOpCode()
+01513                 {
+01514                 }               
+01515                 
+01516                 NLAIAGENT::TProcessStatement runOpCode(CCodeContext &context)
+01517                 {               
+01518                         return NLAIAGENT::IObjectIA::ProcessIdle;
+01519                 }
+01520                 
+01521                 void getDebugResult(std::string &str,CCodeContext &context) const
+01522                 {               
+01523                         str = "No operation";
+01524                 }
+01525 
+01526                 const NLAIC::IBasicType *clone() const
+01527                 {
+01528                         NLAIC::IBasicType *x = new CNopOpCode();
+01529                         return x;            
+01530                 }
+01531                 const NLAIC::IBasicType *newInstance() const 
+01532                 {
+01533                         return clone();
+01534                 }
+01535                 const NLAIC::CIdentType &getType() const
+01536                 {
+01537                         return IdNopOpCode;
+01538                 }
+01539 
+01540                 
+01541 
+01542                 void save(NLMISC::IStream &os)
+01543                 {               
+01544                 }
+01545 
+01546                 void load(NLMISC::IStream &is) 
+01547                 {                               
+01548                 }
+01549                                 
+01550 
+01551                 virtual ~CNopOpCode()
+01552                 {
+01553                 }
+01554         };              
+01555 
+01556         class CTellOpCode : public IOpRunCode
+01557         {
+01558         public:
+01559                 static const NLAIC::CIdentType IdTellOpCode;
+01560         public:
+01561                 CTellOpCode()
+01562                 {
+01563                 }
+01564 
+01565                 NLAIAGENT::TProcessStatement runOpCode(CCodeContext &context)
+01566                 {
+01567                         std::string f;
+01568                         context.Stack[(int)context.Stack]->getDebugString(f);
+01569                         ( (NLAILOGIC::CFactPattern  *) context.Stack[(int)context.Stack] )->propagate();
+01570                         return NLAIAGENT::IObjectIA::ProcessIdle;
+01571                 }
+01572 
+01573                 void getDebugResult(std::string &str,CCodeContext &context) const
+01574                 {
+01575                         std::string f;
+01576                         context.Stack[(int)context.Stack]->getDebugString(f);
+01577                         str = NLAIC::stringGetBuild("tell %s",f.c_str());
+01578                 }
+01579 
+01580                 const NLAIC::IBasicType *clone() const
+01581                 {
+01582                         NLAIC::IBasicType *x = new CTellOpCode();
+01583                         return x;
+01584                 }
+01585 
+01586                 const NLAIC::IBasicType *newInstance() const 
+01587                 {
+01588                         return clone();
+01589                 }
+01590 
+01591                 const NLAIC::CIdentType &getType() const
+01592                 {
+01593                         return IdTellOpCode;
+01594                 }
+01595 
+01596                 void getDebugString(std::string &str) const
+01597                 {
+01598                         str = "tell";
+01599                 }
+01600 
+01601                 void save(NLMISC::IStream &os)
+01602                 {                       
+01603                 }
+01604 
+01605                 void load(NLMISC::IStream &is) 
+01606                 {
+01607                 }                               
+01608                 
+01609                 virtual ~CTellOpCode()
+01610                 {
+01611                 }
+01612         };
+01613 
+01615         class CMakeArgOpCode : public IOpRunCode
+01616         {
+01617         public:
+01618                 static const NLAIC::CIdentType IdMakeArgOpCode;
+01619         public:
+01620 
+01621                 CMakeArgOpCode()
+01622                 {
+01623                 }
+01624 
+01625                 virtual ~CMakeArgOpCode()
+01626                 {
+01627                 }
+01628 
+01629                 NLAIAGENT::TProcessStatement runOpCode(CCodeContext &context)
+01630                 {
+01631                         NLAIAGENT::IObjectIA *param = context.Stack[(int)context.Stack];
+01632                         NLAIAGENT::IBaseGroupType *arglist = new NLAIAGENT::CGroupType;
+01633                         arglist->cpy(*param);
+01634                         param->release();
+01635                         context.Stack[(int)context.Stack] = arglist;
+01636                         return NLAIAGENT::IObjectIA::ProcessIdle;;
+01637                 }
+01638 
+01639                 void getDebugResult(std::string &str,CCodeContext &context) const
+01640                 {
+01641                         std::string buf;
+01642                         NLAIAGENT::IObjectIA *param = context.Stack[(int)context.Stack];
+01643                         param->getDebugString(buf);
+01644                         str = NLAIC::stringGetBuild("ldb %s -> [%s]", buf.c_str(), buf.c_str());
+01645                 }
+01646 
+01647                 const NLAIC::IBasicType *clone() const
+01648                 {
+01649                         NLAIC::IBasicType *clone = new CMakeArgOpCode();
+01650                         return clone;
+01651                 }
+01652 
+01653                 const NLAIC::IBasicType *newInstance() const 
+01654                 {
+01655                         return clone();
+01656                 }
+01657 
+01658                 const NLAIC::CIdentType &getType() const
+01659                 {
+01660                         return IdMakeArgOpCode;
+01661                 }
+01662 
+01663                 void getDebugString(char *txt) const
+01664                 {
+01665                         strcpy(txt, "CMakeArgOpCode");
+01666                 }
+01667 
+01668                 void save(NLMISC::IStream &os)
+01669                 {
+01670                 }
+01671 
+01672                 void load(NLMISC::IStream &is) 
+01673                 {
+01674                 }
+01675 
+01676                 const NLAIAGENT::IObjectIA::CProcessResult &run()
+01677                 {
+01678                         return NLAIAGENT::IObjectIA::ProcessRun;
+01679                 }
+01680 
+01681                 bool isEqual(const NLAIAGENT::IBasicObjectIA &a) const
+01682                 { 
+01683                         return true;
+01684                 }       
+01685                 
+01686         };
+01687 
+01688         class CMarkMsg : public IOpRunCode
+01689         {
+01690         public:
+01691                 static const NLAIC::CIdentType IdMarkMsg;
+01692                 
+01693         private:
+01694                 int _I;
+01695                 int _Heritance;
+01696 
+01697         public:
+01698 
+01699                 CMarkMsg(int h,int i):_I(i),_Heritance(h)
+01700                 {                       
+01701                 }
+01702 
+01703                 virtual ~CMarkMsg()
+01704                 {
+01705                 }
+01706 
+01707                 NLAIAGENT::TProcessStatement runOpCode(CCodeContext &context);          
+01708 
+01709                 void getDebugResult(std::string &str,CCodeContext &context) const
+01710                 {                                               
+01711                         str = NLAIC::stringGetBuild("MarkMsg for method %d in heritance %d", _I, _Heritance);                                   
+01712                 }
+01713 
+01714                 const NLAIC::IBasicType *clone() const
+01715                 {
+01716                         NLAIC::IBasicType *clone = new CMarkMsg(_Heritance,_I);
+01717                         return clone;
+01718                 }
+01719 
+01720                 const NLAIC::IBasicType *newInstance() const 
+01721                 {
+01722                         return clone();
+01723                 }
+01724 
+01725                 const NLAIC::CIdentType &getType() const
+01726                 {
+01727                         return IdMarkMsg;
+01728                 }
+01729 
+01730                 void getDebugString(char *txt) const
+01731                 {
+01732                         strcpy(txt, "CMakeArgOpCode");
+01733                 }
+01734 
+01735                 void save(NLMISC::IStream &os)
+01736                 {
+01737                         sint32 i = (sint32) _I;
+01738                         os.serial( i );
+01739                         i = (sint32) _Heritance;
+01740                         os.serial( i );
+01741                 }
+01742 
+01743                 void load(NLMISC::IStream &is) 
+01744                 {
+01745                         sint32 i;
+01746                         is.serial( i );
+01747                         _I = i;
+01748                         is.serial( i );
+01749                         _Heritance = (int) i;
+01750                 }               
+01751 
+01752                 const NLAIAGENT::IObjectIA::CProcessResult &run()
+01753                 {
+01754                         return NLAIAGENT::IObjectIA::ProcessRun;
+01755                 }
+01756 
+01757                 bool isEqual(const NLAIAGENT::IBasicObjectIA &a) const
+01758                 { 
+01759                         return true;
+01760                 }       
+01761                 
+01762         };
+01763 
+01764         class ILoadObject;
+01765 
+01766         class CMsgSetSender : public IOpRunCode
+01767         {
+01768         public:
+01769                 static const NLAIC::CIdentType IdMsgSetSender;
+01770                                         
+01771 
+01772         public:
+01773                 
+01774                 
+01775                 NLAIAGENT::TProcessStatement runOpCode(CCodeContext &context);
+01776                 void getDebugResult(std::string &str,CCodeContext &context) const;              
+01777 
+01778                 const NLAIC::IBasicType *clone() const
+01779                 {
+01780                         return new CMsgSetSender();
+01781                 }
+01782 
+01783                 const NLAIC::IBasicType *newInstance() const 
+01784                 {
+01785                         return clone();
+01786                 }
+01787 
+01788                 const NLAIC::CIdentType &getType() const
+01789                 {
+01790                         return IdMsgSetSender;
+01791                 }
+01792 
+01793                 void getDebugString(char *txt) const
+01794                 {                       
+01795                 }
+01796 
+01797                 void save(NLMISC::IStream &os);
+01798 
+01799                 void load(NLMISC::IStream &is);         
+01800 
+01801                 const NLAIAGENT::IObjectIA::CProcessResult &run()
+01802                 {
+01803                         return NLAIAGENT::IObjectIA::ProcessRun;
+01804                 }
+01805 
+01806                 bool isEqual(const NLAIAGENT::IBasicObjectIA &a) const
+01807                 { 
+01808                         return true;
+01809                 }       
+01810                 
+01811         };
+01812         
+01813         class CFindRunMsg : public IOpRunCode
+01814         {
+01815         public:
+01816                 static const NLAIC::CIdentType IdFindRunMsg;
+01817                 
+01818         private:
+01819                 CParam *_Param;
+01820                 NLAIAGENT::IBaseGroupType *_MethodName;
+01821                 IOpType *_BaseClass;
+01822                 ILoadObject *_ObjectLoad;
+01823 
+01824         public:
+01825 
+01826                 CFindRunMsg(NLAIAGENT::IBaseGroupType *methodName,CParam *param,IOpType *baseClass,ILoadObject *objectLoad);
+01827 
+01828                 CFindRunMsg(const NLAIAGENT::IBaseGroupType &methodName,const CParam &param,const IOpType &baseClass,const ILoadObject &objectLoad);
+01829 
+01830                 virtual ~CFindRunMsg();
+01831                 
+01832                 NLAIAGENT::TProcessStatement runOpCode(CCodeContext &context);
+01833                 void getDebugResult(std::string &str,CCodeContext &context) const;              
+01834 
+01835                 const NLAIC::IBasicType *clone() const;         
+01836 
+01837                 const NLAIC::IBasicType *newInstance() const 
+01838                 {
+01839                         return clone();
+01840                 }
+01841 
+01842                 const NLAIC::CIdentType &getType() const
+01843                 {
+01844                         return IdFindRunMsg;
+01845                 }
+01846 
+01847                 void getDebugString(char *txt) const
+01848                 {                       
+01849                 }
+01850 
+01851                 void save(NLMISC::IStream &os);
+01852 
+01853                 void load(NLMISC::IStream &is);         
+01854 
+01855                 const NLAIAGENT::IObjectIA::CProcessResult &run()
+01856                 {
+01857                         return NLAIAGENT::IObjectIA::ProcessRun;
+01858                 }
+01859 
+01860                 bool isEqual(const NLAIAGENT::IBasicObjectIA &a) const
+01861                 { 
+01862                         return true;
+01863                 }       
+01864                 
+01865         };
+01866 
+01868         class CAddParamNameDebug: public IOpRunCode
+01869         {
+01870         private :
+01871                 NLAIAGENT::IBaseGroupType* _DebugAttrib;
+01872 
+01873         public:
+01874                 static const NLAIC::CIdentType IdAddParamNameDebug;
+01875         public:
+01876 
+01877                 CAddParamNameDebug(const NLAIAGENT::IBaseGroupType &debugAttrib);
+01878                 
+01879                 NLAIAGENT::TProcessStatement runOpCode(CCodeContext &context);
+01880 
+01881                 virtual ~CAddParamNameDebug();
+01882 
+01883                 void getDebugResult(std::string &str,CCodeContext &context) const;
+01884 
+01885                 const NLAIC::IBasicType *clone() const;
+01886 
+01887                 const NLAIC::IBasicType *newInstance() const;
+01888 
+01889                 const NLAIC::CIdentType &getType() const;
+01890                 
+01891                 void save(NLMISC::IStream &os);
+01892 
+01893                 void load(NLMISC::IStream &is);
+01894         };
+01895 }
+01896 
+01897 #include "nel/ai/script/opcode_call_method.h"
+01898 #include "nel/ai/script/opcode_call_lib_method.h"
+01899 #endif
+01900 
+
opcode.h
