NeL: NLAISCRIPT::IBlock class Reference

00071                 {
00072                         _Debug = debugMode;
00073                         _Cbr = NULL;
00074                         _FirstOpCodeInLine = true;
00075                         _CurrentLine = 0;
00076                         _HaveToDeleteDico = false;
00077                         _DicoLocVar = dico;
00078                 }

00081                 {
00082                         _Debug = debugMode;
00083                         _Cbr = NULL;
00084                         _FirstOpCodeInLine = true;
00085                         _CurrentLine = 0;
00086                         _HaveToDeleteDico = true;
00087                         _DicoLocVar = new TDicoStr;
00088                 }

00092                 {
00093                         while(_ListCode.size() != 0)
00094                         {
00095                                 ((IOpCode *)*_ListCode.front())->release();
00096                                 delete _ListCode.front();
00097                                 _ListCode.pop_front();
00098                         }
00099                         
00100                         if(_Cbr)  _Cbr->release();
00101                         TDicoStrIter it = _DicoLocVar->begin();
00102                         while(it != _DicoLocVar->end())
00103                         {
00104 #ifdef NL_DEBUG                         
00105                                 const NLAIAGENT::IObjectIA *o = (*it).second;
00106 #endif                                                          
00107                                 (*it).second->release();
00108                                 it ++;
00109                         }               
00110                         if(_HaveToDeleteDico) delete _DicoLocVar;
00111                         
00112                 }

00247                 {                       
00248                         //op->incRef();
00249                         CBagOfCode *x = new CBagOfCode(op);
00250                         _ListCode.push_back(x);
00251 
00252                         // Debug part
00253                         CConstraintDebug* pcdb;
00254                         if (_Debug && _FirstOpCodeInLine)
00255                         {
00256                                 pcdb = new CConstraintDebug(_CurrentLine, 1);
00257                                 x->addConstraint(pcdb);
00258                                 _FirstOpCodeInLine = false;
00259                         }
00260                 }

00149                 {
00150                         if(getVar(name) != NULL) return false;
00151                         _DicoLocVar->insert(TDicoStr::value_type(NLAISCRIPT::CStringType(name),var));           
00152                         return true;
00153                 }

00209                 {
00210                         NLAIC::IBasicType *x = new IBlock(_Debug);
00211                         return x;
00212                 }

00094                 {
00095                         return --_Ref;
00096                 }

00128                 {
00129                         TDicoStr::iterator Itr = _DicoLocVar->find(NLAISCRIPT::CStringType(Name));
00130 
00131                         if(Itr != _DicoLocVar->end())
00132                         {
00133                                 _DicoLocVar->erase(Itr);
00134                         }
00135                         
00136                         return NULL;
00137                 }

00270                 {                       
00271                         return (IOpCode *)*_ListCode.back();
00272                 }

00285                 {                       
00286                         return _ListCode.back();
00287                 }

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

00157                 {
00158                         if(/*_Cbr == NULL && */_ListCode.size())
00159                         {
00160                                 sint32 k = _ListCode.size();
00161                                 CCodeBrancheRun *cbr;
00162                                 cbr = new CCodeBrancheRun(k);                                                   
00163                                 for(sint32 i = 0; i < k; i++)
00164                                 {
00165                                         CBagOfCode *x = _ListCode.front();
00166                                         (*cbr)[i] = (IOpCode *)*x;
00167                                         x->setConstraintIndex(i,cbr);
00168                                         delete x;
00169                                         _ListCode.pop_front();
00170                                 }
00171                                 return cbr;
00172 
00173                         }               
00174                         return NULL;
00175                 }

00179                 {
00180                         if(/*_Cbr == NULL && */_ListCode.size())
00181                         {
00182                                 sint32 k = _ListCode.size();
00183                                 CCodeBrancheRunDebug *cbr;
00184                                 cbr = new CCodeBrancheRunDebug(k, sourceCode);
00185 
00186                                 for(sint32 i = 0; i < k; i++)
00187                                 {
00188                                         CBagOfCode *x = _ListCode.front();
00189                                         (*cbr)[i] = (IOpCode *)*x;
00190                                         x->setConstraintIndex(i,cbr);
00191                                         delete x;
00192                                         _ListCode.pop_front();
00193                                 }
00194                                 return cbr;
00195 
00196                         }               
00197                         return NULL;
00198                 }

00275                 {                       
00276                         return (IOpCode *)*_ListCode.front();
00277                 }

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

00100                 {
00101                         return _Ref;
00102                 }

00220                 {
00221                         return IdBlock;
00222                 }

00116                 {
00117                         TDicoStr::iterator Itr = _DicoLocVar->find(NLAISCRIPT::CStringType(Name));
00118 
00119                         if(Itr != _DicoLocVar->end())
00120                         {
00121                                 return (*Itr).second;
00122                         }
00123                         
00124                         return NULL;
00125                 }

00081                 {
00082                         _Ref ++;
00083                 }

00202                 {               
00203                         return _Cbr != NULL;
00204                 }

00236 { return true;}

00241                 {
00242                         return _ListCode;
00243                 }

00142                 {
00143                         _HaveToDeleteDico = false;
00144                         return _DicoLocVar;
00145                 }

00215                 {
00216                         return clone();
00217                 }

00280                 {
00281                         _ListCode.push_back(bOp);
00282                 }

00265                 {                                               
00266                         _ListCode.push_back(new CBagOfCode(op));
00267                 }

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

00029         {
00030                 return NLAIAGENT::IObjectIA::ProcessRun;
00031         }

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

00292                 {
00293                         _CurrentLine = line;
00294                 }

00298                 {
00299                         _FirstOpCodeInLine = b;
00300                 }


Public Member Functions
void	addCode (IOpCode *op)
	Add a op-code pointer, warnning the function increment the ref of the pointer by incRef().
bool	allocLocVar (const char name, NLAIAGENT::IObjectIA var)
	Allocs a new local var .
sint32	decRef ()
	Decrement the reference of an object.
NLAIAGENT::IObjectIA *	eraseVar (const char *Name)
CCodeBrancheRun *	getCode ()
	Builds the code, here we update all IConstarint reference.
CCodeBrancheRunDebug *	getCodeDebug (IScriptDebugSource *sourceCode)
	Build a CCodeBrancheRunDebug.
virtual const std::string	getInfo ()
const sint32 &	getRef () const
	get the refence count.
NLAIAGENT::IObjectIA *	getVar (const char *Name)
	Gets a pointer to a locale variable.
	IBlock (bool debugMode)
	IBlock (bool debugMode, TDicoStr *dico)
	Construct with an active dictionarry and debug mode.
void	incRef ()
	Inc a reference. We use this when we have to conserve a pointer memeory for exemple in a list.
sint32	isCodeMonted ()
	If the code is builded.
TListCode &	listCode ()
	Get the list of code.
TDicoStr *	lockDictionarry ()
	Locks the dictionnarry and get it.
virtual void	release ()
	Release allow to release the pointer. The last release when the _Ref is nul delete the object.
virtual void	serial (NLMISC::IStream &f) throw (NLMISC::EStream)
void	setCurrentLine (uint16 line)
	Set the current line number in the source code.
void	setFirstOpCodeInLine (bool b)
	Set the Flag _FirstOpCodeInLine.
virtual	~IBlock ()
Base class method.
const NLAIC::IBasicType *	clone () const
void	getDebugString (std::string &) const
const NLAIC::CIdentType &	getType () const
bool	isEqual (const NLAIAGENT::IBasicObjectIA &a) const
void	load (NLMISC::IStream &is)
const NLAIC::IBasicType *	newInstance () const
const NLAIAGENT::IObjectIA::CProcessResult &	run ()
void	save (NLMISC::IStream &os)
Op-code list manipulation.
IOpCode *	getBack ()
CBagOfCode *	getBagOfCode ()
IOpCode *	getFront ()
void	pushBagCode (CBagOfCode *bOp)
void	pushCode (IOpCode *op)
Static Public Attributes
const NLAIC::CIdentType	IdBlock
Protected Types
typedef std::map< NLAISCRIPT::CStringType, NLAIAGENT::IObjectIA * >::iterator	TDicoStrIter
	this typedef define an correct std::map iterator for store local variable in the heap.
Private Attributes
CCodeBrancheRun *	_Cbr
	Op-code that define the block. This object is build at the end of parse.
uint16	_CurrentLine
	True while no new opCode as been add since the laste .
bool	_Debug
TDicoStr *	_DicoLocVar
	Local variable is stored here.
bool	_FirstOpCodeInLine
	Switch between a normal CCodeBrancheRun and a debug one.
bool	_HaveToDeleteDico
	If user want a reference to the local variable dictionary then we don't have to delete it.
TListCode	_ListCode
	This list containe the bag of code.

NLAISCRIPT::IBlock Class Reference

Detailed Description

Public Member Functions

Static Public Attributes

Protected Types

Private Attributes

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Field Documentation