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 #ifndef NL_OPCODE_LDB_H
+00026 #define NL_OPCODE_LDB_H
+00027 
+00028 namespace NLAISCRIPT
+00029 {                       
+00030         class CLdbOpCode : public IOpRunCode
+00031         {
+00032         public:
+00033                 static const NLAIC::CIdentType IdLdbOpCode;
+00034 
+00035         private:
+00036                 NLAIAGENT::IObjectIA *_B;
+00037         public:
+00038                 CLdbOpCode(const NLAIAGENT::IObjectIA &b);              
+00039 
+00040                 NLAIAGENT::TProcessStatement runOpCode(CCodeContext &context);
+00041 
+00042                 void getDebugResult(std::string &,CCodeContext &context) const;
+00043 
+00044                 const NLAIC::IBasicType *clone() const
+00045                 {
+00046                         NLAIC::IBasicType *x = new CLdbOpCode(*_B);
+00047                         return x;
+00048                 }
+00049 
+00050                 const NLAIC::IBasicType *newInstance() const 
+00051                 {
+00052                         return clone();
+00053                 }
+00054 
+00055                 const NLAIC::CIdentType &getType() const
+00056                 {
+00057                         return IdLdbOpCode;
+00058                 }
+00059 
+00060                 void getDebugString(std::string &) const{ }
+00061 
+00062                 void save(NLMISC::IStream &os)
+00063                 {
+00064                         os.serial( (NLAIC::CIdentType &) _B->getType() );
+00065                         _B->save(os);           
+00066                 }
+00067 
+00068                 void load(NLMISC::IStream &is) 
+00069                 {
+00070                         _B->release();
+00071                         NLAIC::CIdentTypeAlloc id;
+00072                         is.serial( id );
+00073                         _B = (NLAIAGENT::IObjectIA *)id.allocClass();
+00074                         _B->load(is);
+00075                 }                               
+00076                 
+00077                 virtual ~CLdbOpCode()
+00078                 {
+00079                         _B->release();
+00080                 }
+00081         };
+00082 
+00083         class CLdbMemberOpCode : public IOpRunCode
+00084         {
+00085         public:
+00086                 static const NLAIC::CIdentType IdLdbMemberOpCode;
+00087         private:
+00088                 int _B;
+00089         public:
+00090                 CLdbMemberOpCode(int b):
+00091                 _B(b)
+00092                 {
+00093                 }
+00094                 
+00095 
+00096                 NLAIAGENT::TProcessStatement runOpCode(CCodeContext &context);          
+00097 
+00098                 void getDebugResult(std::string &str,CCodeContext &context) const;              
+00099 
+00100                 const NLAIC::IBasicType *clone() const
+00101                 {
+00102                         NLAIC::IBasicType *x = new CLdbMemberOpCode(_B);
+00103                         return x;
+00104                 }
+00105 
+00106                 const NLAIC::IBasicType *newInstance() const 
+00107                 {
+00108                         return clone();
+00109                 }
+00110 
+00111                 const NLAIC::CIdentType &getType() const
+00112                 {
+00113                         return IdLdbMemberOpCode;
+00114                 }               
+00115 
+00116                 void getDebugString(std::string &) const{ }
+00117 
+00118                 void save(NLMISC::IStream &os)
+00119                 {
+00120                         sint32 b = (sint32) _B;
+00121                         os.serial( b );
+00122                 }
+00123 
+00124                 void load(NLMISC::IStream &is) 
+00125                 {                       
+00126                         sint32 b;
+00127                         is.serial(b);                   
+00128                         _B = (int) b;
+00129                 }                               
+00130                 
+00131                 virtual ~CLdbMemberOpCode()
+00132                 {                       
+00133                 }
+00134         };
+00135 
+00136         class CLdbStackMemberiOpCode : public IOpRunCode
+00137         {
+00138         public:
+00139                 static const NLAIC::CIdentType IdLdbStackMemberiOpCode;
+00140         private:                
+00141                  std::list<sint32> _I;
+00142         public:
+00143                 CLdbStackMemberiOpCode(std::list<sint32> b):
+00144                 _I(b)
+00145                 {
+00146                 }
+00147 
+00148                 NLAIAGENT::TProcessStatement runOpCode(CCodeContext &context);          
+00149 
+00150                 void getDebugResult(std::string &str,CCodeContext &context) const;              
+00151 
+00152                 const NLAIC::IBasicType *clone() const
+00153                 {
+00154                         NLAIC::IBasicType *x = new CLdbStackMemberiOpCode(_I);
+00155                         return x;
+00156                 }
+00157 
+00158                 const NLAIC::IBasicType *newInstance() const 
+00159                 {
+00160                         return clone();
+00161                 }
+00162 
+00163                 const NLAIC::CIdentType &getType() const
+00164                 {
+00165                         return IdLdbStackMemberiOpCode;
+00166                 }
+00167 
+00168                 void getDebugString(std::string &) const{ }
+00169 
+00170                 void save(NLMISC::IStream &os)
+00171                 {                       
+00172                         std::list<sint32> &i = (std::list<sint32> &)_I;
+00173                         os.serialCont(i);
+00174                 }
+00175 
+00176                 void load(NLMISC::IStream &is) 
+00177                 {                               
+00178                         is.serialCont(_I);
+00179                 }
+00180                 
+00181                 virtual ~CLdbStackMemberiOpCode()
+00182                 {                       
+00183                 }
+00184         };
+00185 
+00186         class CLdbHeapMemberiOpCode : public IOpRunCode
+00187         {
+00188         public:
+00189                 static const NLAIC::CIdentType IdLdbHeapMemberiOpCode;
+00190         private:
+00191                 std::list<sint32> _I;
+00192                 sint32 _N;
+00193         public:
+00194                 CLdbHeapMemberiOpCode(const std::list<sint32> &b,sint32 n):
+00195                 _I(b),_N(n)
+00196                 {
+00197                 }
+00198 
+00199                 NLAIAGENT::TProcessStatement runOpCode(CCodeContext &context);
+00200 
+00201                 void getDebugResult(std::string &str,CCodeContext &context) const;              
+00202 
+00203                 const NLAIC::IBasicType *clone() const
+00204                 {
+00205                         NLAIC::IBasicType *x = new CLdbHeapMemberiOpCode(_I,_N);
+00206                         return x;
+00207                 }
+00208 
+00209                 const NLAIC::IBasicType *newInstance() const 
+00210                 {
+00211                         return clone();
+00212                 }
+00213 
+00214                 const NLAIC::CIdentType &getType() const
+00215                 {
+00216                         return IdLdbHeapMemberiOpCode;
+00217                 }
+00218 
+00219                 void getDebugString(std::string &) const{ }
+00220 
+00221                 void save(NLMISC::IStream &os)
+00222                 {                       
+00223                         std::list<sint32> &i = (std::list<sint32> &) _I;
+00224                         os.serialCont(i);
+00225                         sint32 n = _N;
+00226                         os.serial(n);
+00227                 }
+00228 
+00229                 void load(NLMISC::IStream &is) 
+00230                 {                               
+00231                         is.serialCont(_I);
+00232                         is.serial(_N);
+00233                 }
+00234                 
+00235                 virtual ~CLdbHeapMemberiOpCode()
+00236                 {                       
+00237                 }
+00238         };
+00239 
+00240         class CLdbMemberiOpCode : public IOpRunCode
+00241         {
+00242         public:
+00243                 static const NLAIC::CIdentType IdLdbMemberiOpCode;
+00244         private:
+00245                 std::list<sint32> _I;
+00246         public:
+00247                 CLdbMemberiOpCode(std::list<sint32> b):
+00248                 _I(b)
+00249                 {
+00250                 }
+00251 
+00252                 NLAIAGENT::TProcessStatement runOpCode(CCodeContext &context);          
+00253 
+00254                 void getDebugResult(std::string &str,CCodeContext &context) const;              
+00255 
+00256                 const NLAIC::IBasicType *clone() const
+00257                 {
+00258                         NLAIC::IBasicType *x = new CLdbMemberiOpCode(_I);
+00259                         return x;
+00260                 }
+00261 
+00262                 const NLAIC::IBasicType *newInstance() const 
+00263                 {
+00264                         return clone();
+00265                 }
+00266 
+00267                 const NLAIC::CIdentType &getType() const
+00268                 {
+00269                         return IdLdbMemberiOpCode;
+00270                 }
+00271 
+00272                 void getDebugString(std::string &) const{ }
+00273 
+00274                 void save(NLMISC::IStream &os)
+00275                 {                       
+00276                         std::list<sint32> &i = (std::list<sint32> &)_I;
+00277                         os.serialCont(i);
+00278                 }
+00279 
+00280                 void load(NLMISC::IStream &is) 
+00281                 {       
+00282                         is.serialCont(_I);
+00283                 }
+00284                 
+00285                 virtual ~CLdbMemberiOpCode()
+00286                 {                       
+00287                 }
+00288         };
+00289 
+00290         class CLdbRefOpCode : public IOpRunCode
+00291         {
+00292         public:
+00293                 static const NLAIC::CIdentType IdLdbRefOpCode;
+00294         private:
+00295                 int _B;
+00296         public:
+00297                 CLdbRefOpCode(int b):
+00298                 _B(b)
+00299                 {                       
+00300                 }
+00301                 
+00302                 NLAIAGENT::TProcessStatement runOpCode(CCodeContext &context);          
+00303 
+00304                 void getDebugResult(std::string &str,CCodeContext &context) const;
+00305 
+00306                 const NLAIC::IBasicType *clone() const
+00307                 {
+00308                         NLAIC::IBasicType *x = new CLdbRefOpCode(_B);
+00309                         return x;
+00310 
+00311                 }
+00312 
+00313                 const NLAIC::IBasicType *newInstance() const 
+00314                 {
+00315                         return clone();
+00316                 }
+00317 
+00318                 const NLAIC::CIdentType &getType() const
+00319                 {
+00320                         return IdLdbRefOpCode;
+00321                 }               
+00322 
+00323                 void save(NLMISC::IStream &os)
+00324                 {
+00325                         sint32 b = (sint32) _B;
+00326                         os.serial( b );
+00327                 }
+00328 
+00329                 void load(NLMISC::IStream &is) 
+00330                 {                               
+00331                         sint32 b;
+00332                         is.serial( b );
+00333                         _B = (int) b;
+00334                 }               
+00335 
+00336                 virtual ~CLdbRefOpCode()
+00337                 {                       
+00338                 }
+00339                 
+00340         };
+00341 }
+00342 
+00343 #endif
+
opcode_ldb.h
