NeL: NLAISCRIPT::CCodeBrancheRun class Reference

00540                                                          :_TableCode(NULL),_Ip(0),_Count(l._Count)
00541                 {
00542                         _TableCode = new IOpCode * [_Count];
00543                         for(int i = 0 ;i < _Count; i ++) 
00544                         {
00545                                 _TableCode[i] = (IOpCode *)l._TableCode[i];//->clone();                         
00546                                 _TableCode[i]->incRef();
00547                         }
00548                 }

00551                                                    :
00552                         _TableCode(NULL),_Ip(0),_Count(l.size())
00553                 {
00554                         initCode(l);    
00555                 }

00205                                                                :_TableCode(NULL),_Ip(0),_Count(N)
00206         {               
00207                 _TableCode = new IOpCode * [N];
00208                 for(int i = 0 ;i < _Count; i ++) 
00209                 {
00210                         _TableCode[i] = (IOpCode *)op.clone();                  
00211                 }
00212 
00213         }

00215                                              :_TableCode(NULL),_Ip(0),_Count(N)
00216         {               
00217                 _TableCode = new IOpCode * [N];
00218                 for(int i = 0 ;i < _Count; i ++) 
00219                 {
00220                         _TableCode[i] = NULL;                   
00221                 }
00222 
00223         }

00563                                                   :_TableCode(NULL),_Ip(0),_Count(0)
00564                 {
00565                         load(is);
00566                 }

00569                 {
00570                         del();
00571                 }

00351         {
00352                 return TQueue();
00353         }

00654                 {
00655                         NLAIC::IBasicType *x = new CCodeBrancheRun(*this);                      
00656                         return x;
00657                 }

00094                 {
00095                         return --_Ref;
00096                 }

00523                 {
00524                         if(_TableCode != NULL)
00525                         {
00526                                 for(int i = 0 ;i < _Count; i ++)
00527                                 {
00528                                         if(_TableCode[i]) _TableCode[i]->release();
00529                                 }
00530                                 delete []_TableCode;
00531                         }
00532                 }

00117                 {
00118                         return std::string("<unnamed>");
00119                 }

00226         {               
00227                 _TableCode[_Ip]->getDebugResult(str,P);
00228         }

00091         {
00092                 t += NLAIC::stringGetBuild("<CCodeBrancheRun _count = %d>", _Count);
00093         }

00293                 {
00294                         std::string s;
00295                         getDebugString(s);
00296                         return s;
00297                 }

00312         {
00313                 switch(id)
00314                 {
00315                 case 0:
00316                         {
00317                                 return std::string("IObjectIA::sendMessage(IMessage)");
00318                         }                       
00319                         break;
00320                 case 1:                 
00321                         break;
00322                 case 2:                 
00323                         return std::string("IObjectIA::run()");
00324                         break;
00325 
00326                 case 3:
00327                         {                               
00328                                 return std::string("IObjectIA::getStaticMember(Integer)");                              
00329                         }
00330                 }
00331                 return std::string("Mathod_?????(Param_?????)");
00332         }

00252         {
00253                 return 4;
00254         }

00100                 {
00101                         return _Ref;
00102                 }

00262                 {
00263                         return getStaticMember(getStaticMemberIndex(compName));
00264                 }

00194         {
00195                 return NULL;
00196         }

00189         {
00190                 return -1;
00191         }

00181         {
00182                 std::string text;
00183                 text = NLAIC::stringGetBuild("sint32 IObjectIA::getStaticMemberSize() note implementaited for the '%s' interface",(const char *)getType());
00184                 throw NLAIE::CExceptionNotImplemented(text.c_str());
00185                 return 0;       
00186         }

00231         {               
00232                 return IdCodeBrancheRun;
00233         }

00081                 {
00082                         _Ref ++;
00083                 }

00117         {
00118                 
00119         }

00628                 {
00629                         _Ip = 0;
00630                 }

00590                 {
00591                         del();
00592 
00593                         _Ip = 0;
00594                         _Count = l._Count;
00595                         
00596                         _TableCode = new IOpCode * [_Count];            
00597                         for(int i = 0; i < _Count;i ++)
00598                         {
00599                                 _TableCode[i ++] = (IOpCode *)l._TableCode[i]->clone();
00600                         }
00601                 }

00575                 {
00576                         del();
00577                         _Count = l.size();
00578 
00579                         TListCode::const_iterator i;            
00580                         _TableCode = new IOpCode * [l.size()];
00581                         i = l.begin();
00582                         int k = 0;
00583                         while(i != l.end())
00584                         {
00585                                 _TableCode[k ++] = (IOpCode *)*i++;
00586                         }               
00587                 }

00247         {
00248                 return -1;
00249         }

00664 { return true;}

00357         {
00358                 return true;
00359         }

00207         {               
00208                 static CStringVarName send(_SEND_);
00209                 static CStringVarName constructor(_CONSTRUCTOR_);
00210                 static CStringVarName run(_RUN_);
00211                 static CStringVarName statM("GetStaticMember");
00212 
00213                 if(*methodName == send)
00214                 {
00215                         TQueue r;                       
00216                         CObjectType *c = new CObjectType(new NLAIC::CIdentType(NLAIC::CIdentType::VoidType));
00217                         r.push(CIdMethod(0,0.0,NULL,c));
00218                         return r;
00219                 }
00220                 else
00221                 if(*methodName == constructor && !((const NLAISCRIPT::CParam &)param).size())
00222                 {
00223                         TQueue r;
00224                         CObjectType *c = new CObjectType(new NLAIC::CIdentType(NLAIC::CIdentType::VoidType));
00225                         r.push(CIdMethod(1,0.0,NULL,c));
00226                         return r;
00227                 }
00228                 else
00229                 if(*methodName == run && !((const NLAISCRIPT::CParam &)param).size())
00230                 {
00231                         TQueue r;
00232                         CObjectType *c = new CObjectType(new NLAIC::CIdentType(NLAIC::CIdentType::VoidType));
00233                         r.push(CIdMethod(2,0.0,NULL,c));
00234                         return r;                       
00235                 }
00236                 if(*methodName == statM && ((const NLAISCRIPT::CParam &)param).size())
00237                 {
00238                         TQueue r;
00239                         CObjectType *c = new CObjectType(new NLAIC::CIdentType(*IAgent::IdAgent));
00240                         r.push(CIdMethod(3,0.0,NULL,c));
00241                         return r;                       
00242                 }
00243                 return TQueue();
00244         }

00062         {
00063                 NLAIC::CIdentTypeAlloc id;              
00064                 del();
00065 
00066                 sint32 count;
00067                 is.serial( count );
00068                 _Count = count;
00069                 _TableCode = new IOpCode * [_Count];
00070                 for(int i = 0 ;i < _Count; i ++)
00071                 {
00072                         std::string s;
00073                         is.serial( s );
00074 #ifdef NL_DEBUG                 
00075                         const char *ss = s.data();
00076 #endif                  
00077                         is.serial( id );
00078                         _TableCode[i] = (IOpCode *)id.allocClass();
00079                         _TableCode[i]->load(is);                        
00080                 }
00081 
00082         }

00085         {
00086                 NLAIC::IBasicType *x = new CCodeBrancheRun(1,CHaltOpCode());
00087                 return x;
00088         }

00634                 {
00635                         return *_TableCode[_Ip++];
00636                 }

00623                 {
00624                         return _Ip;
00625                 }

00617                 {
00618                         _Ip += l;
00619                 }

00611                 {
00612                         _Ip = l;
00613                 }

00135         {                                               
00136                 if(a.getType() == getType() ) return isEqual(a);                        
00137                 return false;
00138         }

00605                 {
00606                         return _TableCode[i];
00607                 }

00087                 {
00088                         if(decRef() == 0) 
00089                                         delete this;
00090                 }

00096         {
00097                 _RunState.ResultState = NLAIAGENT::processBuzzy;
00098                 _RunState.Result = NULL;
00099                 CStackPointer   stack,heap;
00100                 CCodeContext p(stack,heap,this,NULL,InputOutput);
00101                 
00102                 CVarPStack::_LocalTableRef = &heap[0];
00103                 stack --;
00104 
00105                 run(p);
00106 
00107                 stack -= (int)stack; 
00108                 heap -= (int)heap; 
00109                 return _RunState;
00110         }

00139         {               
00140                 NLAIAGENT::TProcessStatement i = NLAIAGENT::processIdle;
00141 #ifdef NL_DEBUG
00142                 if(NL_AI_DEBUG_SERVER)
00143                 {
00144                         Marker += "\t";
00145                         kMarker ++;
00146 #ifdef NL_OS_WINDOWS
00147                         std::string chaine = std::string("\n\n") + Marker;
00148                         chaine += NLAIC::stringGetBuild("Begin with sp = %d \n\n", p.Stack.CIndexStackPointer::operator int());
00149                         OutputDebugString(chaine.c_str());
00150 #endif
00151                 }
00152 #endif
00153                 
00154                 while(i != NLAIAGENT::processEnd)
00155                 {       
00156                         i = runOpCode(p);
00157                 }
00158 
00159 
00160 #ifdef NL_DEBUG
00161                 if(NL_AI_DEBUG_SERVER)
00162                 {
00163                         std::string chaine = std::string("\n\n") + Marker;
00164 #ifdef NL_OS_WINDOWS                    
00165                         chaine += NLAIC::stringGetBuild("End with sp = %d \n\n", p.Stack.CIndexStackPointer::operator int());
00166                         OutputDebugString(chaine.c_str());
00167 #endif
00168                         kMarker --;                     
00169                         sint i;
00170                         chaine = "";
00171                         for(i = 0; i < (sint)kMarker; i ++)
00172                         {
00173                                 chaine += Marker [i];                           
00174                         }
00175                         Marker = chaine;
00176                 }
00177 #endif
00178                 _Ip = 0;
00179                 _RunState.ResultState = NLAIAGENT::processIdle;
00180                 return _RunState;
00181         }

00113         {
00114                 _RunState.ResultState = NLAIAGENT::processBuzzy;
00115                 _RunState.Result = NULL;
00116                 CStackPointer   stack,heap;
00117                 CCodeContext p(stack,heap,this,&self,InputOutput);      
00118                 CVarPStack::_LocalTableRef = &heap[0];
00119                 stack --;
00120 
00121                 run(p);
00122 
00123                 stack -= (int)stack; 
00124                 heap -= (int)heap; 
00125                 return _RunState;
00126         }

00267         {
00268                 
00269                 switch(id)
00270                 {
00271                 case 0:
00272                         {
00273                                 IMessageBase *msg;
00274 
00275                                 IPerformative *p;
00276                                 msg = (IMessageBase *)((IBaseGroupType *)a)->pop();
00277                                 //this->incRef();
00278                                 msg->setReceiver(this);
00279                                 p = (IPerformative *)((IBaseGroupType *)a)->pop();
00280                                 msg->setPerformatif((IMessageBase::TPerformatif)(sint)p->getNumber());
00281                                 p->release();
00282                                 if(((IBaseGroupType *)a)->size())
00283                                 {                                       
00284                                         CStringType *name = (CStringType *)((IBaseGroupType *)a)->pop();
00285                                         IObjectIA::CProcessResult r = sendMessage(name->getStr(),msg);
00286                                         name->release();
00287                                         return r;
00288                                         
00289                                 }                               
00290                                 return sendMessage(msg);
00291                         }                       
00292                         break;
00293                 case 1:                 
00294                         break;
00295                 case 2:
00296                         return run();
00297                         break;
00298 
00299                 case 3:
00300                         {
00301                                 CProcessResult r;
00302                                 NLAIAGENT::IBaseGroupType *param = (NLAIAGENT::IBaseGroupType *)a;
00303                                 r.Result =      (IObjectIA *)getStaticMember((sint)((NLAIAGENT::INombreDefine *)param->get())->getNumber());
00304                                 r.Result->incRef();
00305                                 return r;
00306                         }
00307                 }
00308                 return CProcessResult();
00309         }

00258         {
00259                 /*char text[2048*8];
00260                 sprintf(text,"method  runMethodeMember(sint32 h, sint32 id,const IObjectIA &) not implemented for the '%s' interface",(const char *)getType());
00261                 throw NLAIE::CExceptionNotImplemented(text);
00262                 return CProcessResult();*/
00263                 return IObjectIA::runMethodeMember(id,a);
00264         }

00184         {               
00185                 IOpCode &op = nextCode();
00186 
00187 #ifdef NL_DEBUG
00188                 if(NL_AI_DEBUG_SERVER)
00189                 {
00190                         std::string chaine,chainedebug;
00191                         op.getDebugResult(chainedebug,p);
00192                         if(kMarker) chaine = Marker + chainedebug;
00193                         else  chaine = chainedebug;
00194                         chaine += "\n";
00195 
00196 #ifdef NL_OS_WINDOWS
00197                         OutputDebugString(chaine.c_str());
00198 #endif
00199                 }
00200 #endif
00201 
00202                 return op.runOpCode(p);
00203         }

00164         {
00165                 std::string text;
00166                 text = NLAIC::stringGetBuild("const CProcessResult &IObjectIA::runStep() note implementaited for the '%s' interface",(const char *)getType());
00167                 throw NLAIE::CExceptionNotImplemented(text.c_str());
00168                 return IObjectIA::ProcessNotComplit;
00169         }

00043         {
00044                 if(_TableCode != NULL)
00045                 {
00046                         sint32 count = _Count;
00047                         os.serial( count );
00048                         for(int i = 0 ;i < _Count; i ++)
00049                         {               
00050                                 std::string text;
00051                                 text = NLAIC::stringGetBuild("Opcode '%s' No: %d",(const char *)_TableCode[i]->getType(),i);
00052                                 count = i;
00053                                 std::string x( text );
00054                                 os.serial(x );
00055                                 os.serial( (NLAIC::CIdentType &)  _TableCode[i]->getType() );
00056                                 os.serial( *_TableCode[i] );
00057                         }
00058                 }
00059         }

00335         {
00336                 std::string text;
00337                 text = NLAIC::stringGetBuild("method 'sendMessage(%s,const IObjectIA &)' '%s' interface",name.getString(), (const char *)getType());
00338                 throw NLAIE::CExceptionNotImplemented(text.c_str());
00339                 return CProcessResult();
00340         }

00343         {
00344                 std::string text;
00345                 text = NLAIC::stringGetBuild("method 'sendMessage(const IObjectIA &)' '%s' interface", (const char *)getType());
00346                 throw NLAIE::CExceptionNotImplemented(text.c_str());
00347                 return CProcessResult();
00348         }

00329                 {
00330                         if ( f.isReading() )
00331                                 load( f );
00332                         else
00333                                 save( f );
00334                 }

00199         {
00200                 std::string text;
00201                 text = NLAIC::stringGetBuild("Function void IObjectIA::setStaticMember(sint32,IObjectIA *) note implementaited for the '%s' interface",(const char *)getType());
00202                 throw NLAIE::CExceptionNotImplemented(text.c_str());
00203                 return false;
00204         }

00269                 {
00270                         return setStaticMember(getStaticMemberIndex(compName),change);
00271                 }


IBasicInterface method.
const NLAIC::IBasicType *	clone () const
void	getDebugString (std::string &) const
const NLAIC::CIdentType &	getType () const
void	load (NLMISC::IStream &f)
const NLAIC::IBasicType *	newInstance () const
void	save (NLMISC::IStream &f)
Public Member Functions
virtual TQueue	canProcessMessage (const IVarName &)
	CCodeBrancheRun (NLMISC::IStream &is)
	the constructor built a class with a stream.
	CCodeBrancheRun (int N)
	the constructor built a class with N NUL op code.
	CCodeBrancheRun (int N, const IOpCode &op)
	the constructor built a class with N op code copy of the op parametre.
	CCodeBrancheRun (const TListCode &l)
	you can construct the class with a liste of op code.
	CCodeBrancheRun (const CCodeBrancheRun &l)
	copy constructor of the class.
sint32	decRef ()
	Decrement the reference of an object.
virtual const std::string	getInfo ()
virtual std::string	getMethodeMemberDebugString (sint32, sint32) const
virtual sint32	getMethodIndexSize () const
const sint32 &	getRef () const
	get the refence count.
const IObjectIA *	getStaticMember (const IVarName &compName) const
virtual const IObjectIA *	getStaticMember (sint32) const
virtual sint32	getStaticMemberIndex (const IVarName &) const
virtual sint32	getStaticMemberSize () const
void	incRef ()
	Inc a reference. We use this when we have to conserve a pointer memeory for exemple in a list.
virtual void	init (IObjectIA *)
void	init ()
void	initCode (const CCodeBrancheRun &l)
void	initCode (const TListCode &l)
virtual sint32	isClassInheritedFrom (const IVarName &) const
virtual bool	isEqual (const IBasicObjectIA &a) const=0
virtual bool	isLocal ()
	If the result is true the object is loclal else its a representation of an object on the server. By the method return true.
virtual TQueue	isMember (const IVarName , const IVarName , const IObjectIA &) const
IOpCode &	nextCode ()
	get the op code from the curent position.
	operator uint32 ()
	get the ip pointer.
void	operator+= (uint32 l)
	move the ip pointer at l element.
void	operator= (uint32 l)
	set the code pointer to l range.
bool	operator== (const IBasicObjectIA &classType) const
IOpCode *&	operator[] (int i)
	allow us to acces to an element in the internal table of the class.
virtual void	release ()
	Release allow to release the pointer. The last release when the _Ref is nul delete the object.
virtual CProcessResult	runMethodeMember (sint32 index, IObjectIA *)
virtual CProcessResult	runMethodeMember (sint32, sint32, IObjectIA *)
virtual const CProcessResult &	runStep ()
virtual CProcessResult	sendMessage (const IVarName &, IObjectIA *)
virtual CProcessResult	sendMessage (IObjectIA *)
virtual void	serial (NLMISC::IStream &f) throw (NLMISC::EStream)
virtual bool	setStaticMember (sint32, IObjectIA *)
bool	setStaticMember (const IVarName &compName, IObjectIA *change)
virtual	~CCodeBrancheRun ()
ICodeBranche method.
void	getDebugResult (std::string &str, CCodeContext &context) const
	gets debug string from the op-code.
virtual const NLAIAGENT::IObjectIA::CProcessResult &	run (CCodeContext &)
	Run with a given context.
virtual const NLAIAGENT::IObjectIA::CProcessResult &	run (NLAIAGENT::IObjectIA &self)
	Run for a given self class. The method create a new context.
NLAIAGENT::TProcessStatement	runOpCode (CCodeContext &context)
	Computation of the op-code with a given context.
Static Public Attributes
const NLAIC::CIdentType	IdCodeBrancheRun
NLAIC::IIO *	InputOutput = NULL
TProcessStatement	ProcessBuzzy = processBuzzy
TProcessStatement	ProcessEnd = processEnd
TProcessStatement	ProcessError = processError
TProcessStatement	ProcessIdle = processIdle
TProcessStatement	ProcessLocked = processLocked
CProcessResult	ProcessNotComplit = IObjectIA::CProcessResult(processNotComplete)
CProcessResult	ProcessRun = IObjectIA::CProcessResult()
Protected Member Functions
void	del ()
	del allow the class to del and reinitialize the class.
Protected Attributes
int	_Count
	The count of the op code table.
int	_Ip
	The code pointer index of the curent op code in run.
NLAIAGENT::IObjectIA::CProcessResult	_RunState
	The state of tje last run method called.
IOpCode **	_TableCode
	Table for storage the op code.

NLAISCRIPT::CCodeBrancheRun Class Reference

Detailed Description

IBasicInterface method.

Public Member Functions

Static Public Attributes

Protected Member Functions

Protected Attributes

Constructor & Destructor Documentation

Member Function Documentation

Field Documentation