From 0ea5fc66924303d1bf73ba283a383e2aadee02f2 Mon Sep 17 00:00:00 2001 From: neodarz Date: Sat, 11 Aug 2018 20:21:34 +0200 Subject: Initial commit --- docs/doxygen/nel/a02390.html | 10408 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 10408 insertions(+) create mode 100644 docs/doxygen/nel/a02390.html (limited to 'docs/doxygen/nel/a02390.html') diff --git a/docs/doxygen/nel/a02390.html b/docs/doxygen/nel/a02390.html new file mode 100644 index 00000000..84805d15 --- /dev/null +++ b/docs/doxygen/nel/a02390.html @@ -0,0 +1,10408 @@ + + +NeL: NLAISCRIPT::CCompilateur class Reference + + + +

NLAISCRIPT::CCompilateur Class Reference

#include <compilateur.h> +

Inheritance diagram for NLAISCRIPT::CCompilateur: +

+ + + + +

Detailed Description

+This class define compilation of a source code. He is heritage come from the lex parser.

Author:

Chafik sameh

+Robert Gabriel

+Nevrax France

Date:: 2000

+ +

+Definition at line 125 of file compilateur.h. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Public Member Functions
CCompilateur (NLAIC::IIO &Iterface, const char *str, IScriptDebugSource *fileName)
CCompilateur (NLAIC::IIO &Iterface, const char *str, sint32 size, IScriptDebugSource *fileName)
void clean ()
Initialize variable befor parsing.

void cleanMethodConstraint ()
Initialisze the constraint.

void cleanTypeConstraint ()
void cleanTypeList ()
Clean internal list.

virtual NLAIAGENT::IObjectIA::CProcessResult Compile ()
int debug () const
void Echo (char *Er,...)
Same as printf but out put is made to the IO interface.

CFunctionTag findMethode (NLAIAGENT::IBaseGroupType &listName, const CParam &param)
CFunctionTag findMethode (const NLAIAGENT::IObjectIA *baseClass, NLAIAGENT::IBaseGroupType &listName, const CParam &param)
bool getDebugMode () const
Get the debug state.

NLAIAGENT::IObjectIA * getVar (const char *name)
get the locale variable define by name.

void InitFromFile (const char *FileName)
Initialize source code from file.

void InitStream (char *str, sint32 size)
Initialize the std::stream.

sint32 isValidateVarName (std::list< sint32 > &ref, std::list< NLAISCRIPT::CStringType > &nameHierarchy, IOpType *&type)
sint32 isValidateVarName (const NLAIAGENT::IObjectIA *baseClass, std::list< sint32 > &ref, std::list< NLAISCRIPT::CStringType > &nameHierarchy, IOpType *&type)
int lineno () const
bool parseError ()
You can use this to consult the state of the parser.

void set_debug (int flag)
void setDebugMode (bool bmode)
Set the Debug Mode.

virtual void switch_streams (istream *new_in, ostream *new_out)
const NLAIAGENT::IObjectIA * validateHierarchyMethode (std::list< sint32 > &, sint32 &, const NLAIAGENT::IObjectIA *, NLAIAGENT::IBaseGroupType &listName)
yy_buffer_state * yy_create_buffer (istream *s, int size)
void yy_delete_buffer (struct yy_buffer_state *b)
void yy_switch_to_buffer (struct yy_buffer_state *new_buffer)
void yyerror (char *Er)
Occur when there are a parse error.

int YYLeng ()
int yylex (istream *new_in, ostream *new_out=0)
virtual int yylex ()
int yyparse ()
Yacc parser.

void yyrestart (istream *s)
const char * YYText ()
virtual int yywrap ()
This function is needed by the lex parser for initializ the read stream (see lex documment).

virtual ~CCompilateur ()

Protected Member Functions
void addOpCode (IOpCode *x)
void addParamCont ()
void addParamRuleCont ()
sint32 affectation ()
sint32 affectationiMember (const IClassInterpret *baseClass, std::list< NLAISCRIPT::CStringType > &varHName)
sint32 affectationMember (IClassInterpret *, sint32 member)
sint32 affectationMember (sint32 member)
void allocExpression (IOpCode *op, bool gd=false)
bool buildObject ()
bool callFunction ()
void callSend ()
bool caseRunMsg ()
sint32 castVariable (const NLAIAGENT::CStringVarName &, NLAIAGENT::CStringVarName &)
bool checkReturnMethod ()
bool classIsAnOperator ()
Logic compilation.

void CompileFactPattern ()
void CompileOperator ()
bool computContraint ()
bool definClass (const char *className)
bool endMessageManager ()
void errorMethodConstraint ()
void errorTypeConstraint ()
NLAIAGENT::CIdMethod findMethode (sint32 inheritance, NLAIAGENT::CStringType *baseName, const NLAIAGENT::IObjectIA *className, const NLAIAGENT::IVarName &methodeName, const CParam &param)
sint32 findMethodei (NLAIAGENT::IBaseGroupType &listName, const CParam &param)
CCodeBrancheRun * getCode (bool isMain=false)
throw (NLAIE::IException)

const IClassInterpret * getInheritanceRange (sint32 &, const IClassInterpret *, const NLAIAGENT::IVarName &) const
const IClassInterpret * getInheritanceRange (sint32 &, const IClassInterpret *, NLAIAGENT::IBaseGroupType &) const
IConstraint * getMethodConstraint (const IConstraint &c) const
IConstraint * getMethodConstraint (const NLAIAGENT::IBaseGroupType &g, const CParam &p) const
sint32 getNMethodConstraint ()
NLAIC::CIdentType getTypeOfClass (const NLAIAGENT::IVarName &className)
throw (NLAIE::IException)

const NLAIAGENT::IObjectIA * getValidateHierarchyBase (const NLAIAGENT::IObjectIA *base, std::list< sint32 > &ref, sint32 &h, std::list< NLAISCRIPT::CStringType > &listName)
const NLAIAGENT::IObjectIA * getValidateHierarchyBase (std::list< sint32 > &ref, sint32 &h, std::list< NLAISCRIPT::CStringType > &listName)
void ifInterrogation ()
void ifInterrogationEnd ()
void ifInterrogationPoint ()
void initMessageManager ()
void initParam ()
void interrogationEnd ()
virtual void LexerError (const char *msg)
virtual int LexerInput (char *buf, int max_size)
virtual void LexerOutput (const char *buf, int size)
void nameMethodeProcessing ()
void onEndClass ()
sint32 PrivateError ()
sint32 processingVar ()
void pushParamExpression ()
void RegisterClass ()
bool registerMethod ()
sint32 runMethodConstraint ()
sint32 runTypeConstraint ()
void setChaineVar ()
void setImediateVar ()
void setImediateVarNill ()
void setListVar ()
void setMethodVar ()
virtual void setNewLine ()
Tell the _lastBlock about a newLine (for Debug).

bool setParamVarName ()
void setPerformative (NLAIAGENT::IMessageBase::TPerformatif p)
void setStackVar (const NLAIC::CIdentType &)
void setTypeExpression (NLAIC::CTypeOfOperator::TTypeOp op, const char *txtOp)
void setTypeExpression ()
void setTypeExpressionD (NLAIC::CTypeOfOperator::TTypeOp op, const char *txtOp)
void setTypeExpressionG ()
sint32 typeOfMethod ()
void yy_flush_buffer (struct yy_buffer_state *b)
int yy_get_next_buffer ()
yy_state_type yy_get_previous_state ()
void yy_init_buffer (struct yy_buffer_state *b, istream *s)
void yy_load_buffer_state ()
void yy_pop_state ()
void yy_push_state (int new_state)
int yy_top_state ()
yy_state_type yy_try_NUL_trans (yy_state_type current_state)
int yyinput ()
void yyunput (int c, char *buf_ptr)

Protected Attributes
double LastyyNum
char LastyyText [2][1024 *4]
char * yy_c_buf_p
yy_buffer_state * yy_current_buffer
int yy_did_buffer_switch_on_eof
int yy_flex_debug
int yy_full_lp
char * yy_full_match
int * yy_full_state
char yy_hold_char
int yy_init
char * yy_last_accepting_cpos
yy_state_type yy_last_accepting_state
int yy_looking_for_trail_begin
int yy_lp
int yy_more_flag
int yy_more_len
int yy_n_chars
int yy_start
int * yy_start_stack
int yy_start_stack_depth
int yy_start_stack_ptr
yy_state_type * yy_state_buf
yy_state_type * yy_state_ptr
int yyColone
istream * yyin
int yyleng
int yyLine
int yylineno
ostream * yyout
char * yytext

Private Types
typedef std::pair< NLAIAGENT::IVarName *,
+ NLAIAGENT::IObjectIA * > TPairType
This define is use for define an argument of a method in the language.

Private Attributes
std::list< TPairType > _Attrib
bool _BaseObjectDef
std::list< IConstraint * > _ConstraintType
bool _Debug
sint32 _DecalageHeap
TDicoStr * _Dictionary
bool _Error
std::list< IOpType * > _ExpressionOp
IOpType * _ExpressionType
std::list< IOpType * > _ExpressionTypeTmp
NLAILOGIC::CFactBase * _FactBase
bool _FacteurEval
IOpType * _FlotingExpressionType
std::list< bool > _FromStack
std::list< NLAIFUZZY::CFuzzyVar * > _FuzzVars
NLAIAGENT::IVarName * _Goal
CStackPointer _Heap
bool _InCond
bool _InLineParse
bool _IsFacteurIsExpression
bool _IsVoid
NLAIC::IIO & _Iterface
IO for set out text or for get an input.

std::list< NLAISCRIPT::CStringType > _LasAffectationVarStr
NLAIAGENT::IObjectIA * _LastAffectation
Last affected variable.

std::list< const NLAIAGENT::CStringVarName * > _LastAsserts
IConstraint * _LastbaseClass
NLAIAGENT::CStringVarName _LastBaseObjectDef
Last string.

IBlock * _LastBloc
Laste code parsed.

std::list< IBlock * > _LastBloc1
temporary code parsed for code manager.

std::list< IBlock * > _LastBloc2
temporary code parsed for code manager.

std::list< IBlock * > _LastBloc3
temporary code parsed for code manager.

std::list< const NLAIAGENT::CStringVarName * > _LastBooleanConds
std::list< IOpCode * > _LastCodeBranche
CFactorType _LastFact
Type of last statement.

NLAILOGIC::CFactPattern * _LastFactPattern
std::list< NLAIAGENT::CStringVarName * > _LastFuzzyConds
sint32 _LastFVarIndex
std::list< std::list< const
+NLAIAGENT::IVarName * > > _LastLogicParams
NLAIAGENT::IMessageBase::TPerformatif _LastPerf
sint32 _LastPosHeap
sint32 _LastRegistered
std::list< IBlock * > _LastSaveBloc
temporary code parsed for code manager.

NLAIAGENT::CStringVarName _LastString
Last string.

std::list< NLAIAGENT::IBaseGroupType * > _LastStringParam
sint32 _LastTypeCall
std::list< NLAISCRIPT::CStringType > _LasVarStr
std::list< IConstraint * > _MethodConstraint
std::list< NLAIAGENT::CStringVarName > _MethodName
sint32 _NbLogicParams
std::list< CParam * > _Param
NLAIAGENT::IObjectIA * _ResultCompile
CListClass _SelfClass
List of class define in the souce code.

IScriptDebugSource * _SourceFileName
CStackPointer _Stack
std::istrstream * _StreamBuffer
Stream that contain source code.

std::list< IOpType * > _TypeList
CIndexStackPointer _VarState
This variable allow to simulate the heap allocation.

bool haveReturn
bool is_cond
bool isRunMsg
+

Member Typedef Documentation

+ + + + +
+ + +
typedef std::pair<NLAIAGENT::IVarName *,NLAIAGENT::IObjectIA *> NLAISCRIPT::CCompilateur::TPairType [private] +
+
+ + + + + +
+ + + +
+This define is use for define an argument of a method in the language. +
+ +
+Definition at line 129 of file compilateur.h. +
+Referenced by setParamVarName().
+

Constructor & Destructor Documentation

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NLAISCRIPT::CCompilateur::CCompilateur ( NLAIC::IIO & Iterface,
const char * str,
sint32 size,
IScriptDebugSource * fileName
) [inline]
+
+ + + + + +
+ + + +
+The perser need an IO interface, an source code here defined by const char *str and sint32 size. Remark that the const char* fileName variable is necessary for the debug code version. +
+Definition at line 208 of file compilateur.h. +
+References _Debug, _DecalageHeap, _Error, _ExpressionType, _FacteurEval, _FlotingExpressionType, _InCond, _InLineParse, _IsFacteurIsExpression, _IsVoid, _Iterface, _LastBaseObjectDef, _LastBloc, _LastFactPattern, _LastString, _ResultCompile, _SourceFileName, _StreamBuffer, haveReturn, NLAIC::IPointerGestion::incRef(), InitStream(), isRunMsg, sint32, and size. +
+
00208 : +00209 _StreamBuffer(NULL), +00210 _Iterface(Iterface), +00211 _LastBloc((IBlock*)NULL), +00212 _LastString("_"), +00213 _LastBaseObjectDef("_"), +00214 _Debug(false), +00215 _Goal(NULL), +00216 _InCond(false) +00217 { +00218 _SourceFileName = fileName; +00219 _SourceFileName->incRef(); +00220 LastyyText[0][0] = 0; +00221 LastyyText[1][0] = 0; +00222 //_VarState = NULL; +00223 InitStream((char *)str,size); +00224 yyLine = yyColone = 1; +00225 _Error = false; +00226 CCodeBrancheRun::InputOutput = &Iterface; +00227 _DecalageHeap = 0; +00228 _ExpressionType = NULL; +00229 _FlotingExpressionType = NULL; +00230 _IsFacteurIsExpression = false; +00231 _FacteurEval = false; +00232 _IsVoid = true; +00233 _ResultCompile = NULL; +00234 _InLineParse = false; +00235 isRunMsg = false; +00236 haveReturn = false; +00237 _LastFactPattern = NULL; +00238 } + +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
NLAISCRIPT::CCompilateur::CCompilateur ( NLAIC::IIO & Iterface,
const char * str,
IScriptDebugSource * fileName
) [inline]
+
+ + + + + +
+ + + +
+The perser need an IO interface, an source code here defined by const char *str which it define a file name. Remark that the const char* fileName variable is necessary for the debug code version. +
+Definition at line 244 of file compilateur.h. +
+References _Debug, _DecalageHeap, _Error, _ExpressionType, _FacteurEval, _FlotingExpressionType, _InCond, _InLineParse, _IsFacteurIsExpression, _IsVoid, _Iterface, _LastBaseObjectDef, _LastBloc, _LastFactPattern, _LastString, _ResultCompile, _SourceFileName, _StreamBuffer, haveReturn, NLAIC::IPointerGestion::incRef(), InitFromFile(), and isRunMsg. +
+
00244 : +00245 _StreamBuffer(NULL), +00246 _Iterface(Iterface), +00247 _LastBloc((IBlock*)NULL), +00248 _LastString("_"), +00249 _LastBaseObjectDef("_"), +00250 _Debug(false), +00251 _Goal(NULL), +00252 _InCond(false) +00253 { +00254 _SourceFileName = fileName; +00255 _SourceFileName->incRef(); +00256 //_VarState = NULL; +00257 InitFromFile(str); +00258 yyLine = yyColone = 1; +00259 _Error = false; +00260 _DecalageHeap = 0; +00261 _ExpressionType = NULL; +00262 _FlotingExpressionType = NULL; +00263 _IsFacteurIsExpression = false; +00264 _FacteurEval = false; +00265 _IsVoid = true; +00266 _ResultCompile = NULL; +00267 _InLineParse = false; +00268 isRunMsg = false; +00269 haveReturn = false; +00270 _LastFactPattern = NULL; +00271 } + +

+

+ + + + +
+ + + + + + + + + +
virtual NLAISCRIPT::CCompilateur::~CCompilateur ( ) [inline, virtual]
+
+ + + + + +
+ + + +
+ +
+Definition at line 317 of file compilateur.h. +
+References _SourceFileName, _StreamBuffer, clean(), cleanMethodConstraint(), cleanTypeConstraint(), and NLAIC::IPointerGestion::release(). +
+
00318 { +00319 +00320 clean(); +00321 if(_StreamBuffer) delete _StreamBuffer; +00322 cleanMethodConstraint(); +00323 cleanTypeConstraint(); +00324 //_Heap -= (sint32)_Heap; +00325 _SourceFileName->release(); +00326 } +

+

Member Function Documentation

+ + + + +
+ + + + + + + + + + +
void NLAISCRIPT::CCompilateur::addOpCode ( IOpCode * x ) [protected]
+
+ + + + + +
+ + + +
+ +
+Definition at line 491 of file compilateur.cpp. +
+References _LastBloc, NLAISCRIPT::IBlock::addCode(), and x. +
+
00492 { +00493 +00494 //CLdbOpCode *x = new CLdbOpCode (NLAIAGENT::CGroupType()); +00495 _LastBloc->addCode(x); +00496 } +

+

+ + + + +
+ + + + + + + + + +
void NLAISCRIPT::CCompilateur::addParamCont ( ) [protected]
+
+ + + + + +
+ + + +
+ +
+Definition at line 384 of file var_control.cpp. +
+References _LastBloc, and NLAISCRIPT::IBlock::addCode(). +
+
00385 { +00386 _LastBloc->addCode(new CLdbOpCode (CPramContainer())); +00387 } +

+

+ + + + +
+ + + + + + + + + +
void NLAISCRIPT::CCompilateur::addParamRuleCont ( ) [protected]
+
+ + + + + +
+ + + +
+ +
+Definition at line 379 of file var_control.cpp. +
+References _LastBloc, and NLAISCRIPT::IBlock::addCode(). +
+
00380 { +00381 _LastBloc->addCode(new CLdbOpCode (NLAIAGENT::CGroupType())); +00382 } +

+

+ + + + +
+ + + + + + + + + +
sint32 NLAISCRIPT::CCompilateur::affectation ( ) [protected]
+
+ + + + + +
+ + + +
+ +
+Definition at line 138 of file yacc.cpp. +
+References _ConstraintType, _Debug, _ExpressionType, _LasAffectationVarStr, _LastAffectation, _LastBloc, _SelfClass, _VarState, NLAISCRIPT::IBlock::addCode(), NLAISCRIPT::CBagOfCode::addConstraint(), affectationMember(), NLAISCRIPT::IBlock::allocLocVar(), NLAISCRIPT::IBlock::eraseVar(), NLAIAGENT::CGroupType::get(), NLAISCRIPT::IBlock::getBagOfCode(), NLAISCRIPT::IConstraint::getConstraintTypeOf(), NLAIC::CIdentType::getFactory(), getMethodConstraint(), NLAIAGENT::IObjectIA::getStaticMemberIndex(), getVar(), NLAIC::IPointerGestion::incRef(), index, isValidateVarName(), PrivateError(), NLAIC::IPointerGestion::release(), NLAISCRIPT::IConstraint::satisfied(), NLAISCRIPT::COperationTypeGD::setOp(), NLAISCRIPT::COperationTypeGD::setOperationD(), NLAISCRIPT::COperationTypeGD::setOperationG(), sint, sint32, and yyerror(). +
+
00139 { +00140 if(_LasAffectationVarStr.size() >= 1) +00141 { +00142 if(_LasAffectationVarStr.size() == 1) +00143 { +00144 _LastAffectation = getVar(_LasAffectationVarStr.front().data()); +00145 if(_LastAffectation == NULL) +00146 { +00147 sint32 member = ((IClassInterpret *)_SelfClass.get())->getStaticMemberIndex(NLAIAGENT::CStringVarName(_LasAffectationVarStr.front().data())); +00148 if(member < 0) +00149 { +00150 NLAIAGENT::IObjectIA *i; +00151 if(_ExpressionType->satisfied()) +00152 { +00153 NLAIC::CIdentType *id = new NLAIC::CIdentType(*_ExpressionType->getConstraintTypeOf()); +00154 IOpType * c= new COperandSimple(id); +00155 i = new CObjectUnknown(c); +00156 _ExpressionType->release(); +00157 _ExpressionType = NULL; +00158 } +00159 else +00160 { +00161 _ExpressionType->incRef(); +00162 i = new CObjectUnknown(_ExpressionType); +00163 _ConstraintType.push_back(_ExpressionType); +00164 _ExpressionType = NULL; +00165 } +00166 +00167 #ifdef NL_DEBUG +00168 _LastAffectation = new CVarPStackParam((sint32)_VarState,_LasAffectationVarStr.front().data()); +00169 #else +00170 _LastAffectation = new CVarPStackParam((sint32)_VarState); +00171 #endif +00172 +00173 _LastBloc->allocLocVar(_LasAffectationVarStr.front().data(), _LastAffectation); +00174 +00175 _Heap[(int)_Heap] = i; +00176 _Heap ++; +00177 _VarState ++; +00178 if(_LastAffectation) +00179 { +00180 if (_Debug) +00181 { +00182 _LastBloc->addCode(new CLocAllocDebug()); +00183 _LastBloc->addCode(new CAffOpCodeDebug( ((CVarPStackParam *)_LastAffectation)->getIndex(), _LasAffectationVarStr.front().data())); +00184 } +00185 else +00186 { +00187 _LastBloc->addCode(new CLocAlloc()); +00188 _LastBloc->addCode(new CAffOpCode( ((CVarPStackParam *)_LastAffectation)->getIndex())); +00189 } +00190 } +00191 } +00192 else +00193 { +00194 +00195 if(!affectationMember(member)) return false; +00196 } +00197 } +00198 else +00199 { +00200 if (_Debug) +00201 { +00202 _LastBloc->addCode(new CAffOpCodeDebug( ((CVarPStackParam *)_LastAffectation)->getIndex(), _LasAffectationVarStr.front().data())); +00203 } +00204 else +00205 { +00206 _LastBloc->addCode(new CAffOpCode( ((CVarPStackParam *)_LastAffectation)->getIndex())); +00207 } +00208 sint index = ((CVarPStackParam *)_LastAffectation)->getIndex(); +00209 +00210 _LastBloc->eraseVar(_LasAffectationVarStr.front().data()); +00211 +00212 #ifdef NL_DEBUG +00213 _LastAffectation = new CVarPStackParam(index,_LasAffectationVarStr.front().data()); +00214 #else +00215 _LastAffectation = new CVarPStackParam(index); +00216 #endif +00217 +00218 _LastBloc->allocLocVar(_LasAffectationVarStr.front().data(), _LastAffectation); +00219 +00220 NLAIAGENT::IObjectIA *i; +00221 if(_ExpressionType->satisfied()) +00222 { +00223 IOpType * c= new COperandSimple(new NLAIC::CIdentType(*_ExpressionType->getConstraintTypeOf())); +00224 i = new CObjectUnknown(c); +00225 _ExpressionType->release(); +00226 _ExpressionType = NULL; +00227 } +00228 else +00229 { +00230 _ExpressionType->incRef(); +00231 i = new CObjectUnknown(_ExpressionType); +00232 _ExpressionType->incRef(); +00233 _ConstraintType.push_back(_ExpressionType); +00234 _ExpressionType = NULL; +00235 } +00236 _Heap[index]->release(); +00237 _Heap[index] = i; +00238 +00239 } +00240 } +00241 else +00242 { +00243 _LastAffectation = getVar(_LasAffectationVarStr.front().data()); +00244 if(_LastAffectation == NULL) +00245 { +00246 if(!PrivateError()) +00247 { +00248 return false; +00249 } +00250 +00251 if(_ExpressionType->satisfied()) +00252 { +00253 _ExpressionType->release(); +00254 } +00255 else +00256 { +00257 _ConstraintType.push_back(_ExpressionType); +00258 } +00259 _ExpressionType = NULL; +00260 } +00261 else +00262 { +00263 _LasAffectationVarStr.pop_front(); +00264 IOpType *cont = (IOpType *)((const CObjectUnknown *)((CVarPStackParam *)_LastAffectation)->getObject())->getBaseType(); +00265 if(cont->satisfied()) +00266 { +00267 std::list<sint32> ref; +00268 IOpType *constr; +00269 IClassInterpret *cl = (IClassInterpret *)((CClassInterpretFactory *)cont->getConstraintTypeOf()->getFactory())->getClass(); +00270 if(!isValidateVarName(cl,ref,_LasAffectationVarStr,constr)) +00271 { +00272 if(constr) constr->release(); +00273 return false; +00274 } +00275 COperationTypeGD *dg = new COperationTypeGD(); +00276 dg->setOperationD(constr); +00277 dg->setOperationG(_ExpressionType); +00278 dg->setOp(NLAIC::CTypeOfOperator::opAff); +00279 _ConstraintType.push_back(dg); +00280 _ExpressionType = NULL; +00281 _LastBloc->addCode(new CAffHeapMemberiOpCode( ref,((CVarPStackParam *)_LastAffectation)->getIndex())); +00282 +00283 +00284 } +00285 else +00286 { +00287 _LastBloc->addCode(new CHaltOpCode()); +00288 CBagOfCode *b = _LastBloc->getBagOfCode(); +00289 cont->incRef(); +00290 IOpType *c = (IOpType *)getMethodConstraint(CConstraintStackComp(CConstraintStackComp::heapAffectation, +00291 ((CVarPStackParam *)_LastAffectation)->getIndex(), +00292 _LasAffectationVarStr ,cont,0,0)); +00293 if(c == NULL) +00294 { +00295 cont->incRef(); +00296 c = new CConstraintStackComp(CConstraintStackComp::heapAffectation,((CVarPStackParam *)_LastAffectation)->getIndex(), +00297 _LasAffectationVarStr ,cont,0,0); +00298 _ConstraintType.push_back(c); +00299 } +00300 +00301 c->incRef(); +00302 COperationTypeGD *dg = new COperationTypeGD(); +00303 dg->setOperationD(c); +00304 dg->setOperationG(_ExpressionType); +00305 dg->setOp(NLAIC::CTypeOfOperator::opAff); +00306 _ConstraintType.push_back(dg); +00307 _ExpressionType = NULL; +00308 b->addConstraint(c); +00309 } +00310 } +00311 +00312 } +00313 } +00314 else +00315 { +00316 yyerror("erreur de definition de variable"); +00317 return 0; +00318 } +00319 return true; +00320 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
sint32 NLAISCRIPT::CCompilateur::affectationiMember ( const IClassInterpret * baseClass,
std::list< NLAISCRIPT::CStringType > & varHName
) [protected]
+
+ + + + + +
+ + + +
+ +
+Definition at line 419 of file yacc.cpp. +
+References sint32. +
+
00420 { +00421 +00422 return true; +00423 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
sint32 NLAISCRIPT::CCompilateur::affectationMember ( IClassInterpret * ,
sint32 member
) [protected]
+
+ + + + + +
+ + + +
+ +
+Definition at line 327 of file yacc.cpp. +
+References _ConstraintType, _ExpressionType, _LastBloc, NLAISCRIPT::IBlock::addCode(), NLAIAGENT::IObjectIA::getStaticMember(), NLAIC::IPointerGestion::release(), NLAISCRIPT::COperationTypeGD::satisfied(), NLAISCRIPT::COperationTypeGD::setOp(), NLAISCRIPT::COperationTypeGD::setOperationD(), NLAISCRIPT::COperationTypeGD::setOperationG(), sint32, NLAIC::stringGetBuild(), and yyerror(). +
+
00328 { +00329 try +00330 { +00331 _LastBloc->addCode(new CAffMemberOpCode(member)); +00332 COperandSimple *a = new COperandSimple(new NLAIC::CIdentType(base->getStaticMember(member)->getType())); +00333 COperationTypeGD *gd = new COperationTypeGD(); +00334 gd->setOperationG(a); +00335 gd->setOperationD(_ExpressionType); +00336 gd->setOp(NLAIC::CTypeOfOperator::opAff); +00337 if(gd->satisfied()) +00338 { +00339 gd->release(); +00340 } +00341 else +00342 { +00343 _ConstraintType.push_back(gd); +00344 } +00345 _ExpressionType = NULL; +00346 +00347 } +00348 catch(NLAIE::IException &) +00349 { +00350 std::string text; +00351 text = NLAIC::stringGetBuild("Bad reference or class reference undefined"); +00352 yyerror((char *)text.c_str()); +00353 return 0; +00354 } +00355 return true; +00356 } +

+

+ + + + +
+ + + + + + + + + + +
sint32 NLAISCRIPT::CCompilateur::affectationMember ( sint32 member ) [protected]
+
+ + + + + +
+ + + +
+ +
+Definition at line 322 of file yacc.cpp. +
+References _SelfClass, NLAIAGENT::CGroupType::get(), and sint32. +
+Referenced by affectation(). +
+
00323 { +00324 return affectationMember((IClassInterpret *)_SelfClass.get(),member); +00325 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NLAISCRIPT::CCompilateur::allocExpression ( IOpCode * op,
bool gd = false
) [protected]
+
+ + + + + +
+ + + +
+ +
+Definition at line 425 of file yacc.cpp. +
+References _ConstraintType, _LastBloc, _LastFact, NLAISCRIPT::IBlock::addCode(), NLAISCRIPT::CBagOfCode::addConstraint(), NLAISCRIPT::IBlock::getBagOfCode(), NLAISCRIPT::CFactorType::IsUsed, NLAISCRIPT::CFactorType::Member, NLAISCRIPT::CFactorType::TypeStack, NLAISCRIPT::CFactorType::Value, NLAISCRIPT::CFactorType::ValueVar, NLAISCRIPT::varForFunc, NLAISCRIPT::CFactorType::VarType, NLAISCRIPT::varTypeHeapMember, NLAISCRIPT::varTypeImediate, NLAISCRIPT::varTypeLocal, NLAISCRIPT::varTypeMember, NLAISCRIPT::varTypeStackMember, and x. +
+
00426 { +00427 #ifdef NL_DEBUG +00428 std::list<sint32>::iterator i_dbg = _LastFact.Member.begin(); +00429 while(i_dbg != _LastFact.Member.end()) +00430 { +00431 int k = *i_dbg++; +00432 } +00433 +00434 #endif +00435 switch(_LastFact.VarType) +00436 { +00437 case varTypeImediate: +00438 if(!_LastFact.IsUsed) +00439 { +00440 CLdbOpCode *x = new CLdbOpCode (*_LastFact.Value); +00441 _LastBloc->addCode(x); +00442 _LastFact.IsUsed = true; +00443 } +00444 if(op) _LastBloc->addCode(op); +00445 break; +00446 +00447 case varTypeLocal: +00448 if(!_LastFact.IsUsed) +00449 { +00450 if(((NLAIAGENT::IObjectIA *)_LastFact.ValueVar)->getType() == CVarPStackParam::IdVarPStackParam) +00451 { +00452 _LastBloc->addCode(new CLdbRefOpCode ( ((CVarPStackParam *)((NLAIAGENT::IObjectIA *)_LastFact.ValueVar))->getIndex())); +00453 } +00454 else +00455 { +00456 _LastBloc->addCode(new CLdbOpCode (*((NLAIAGENT::IObjectIA *)_LastFact.ValueVar))); +00457 } +00458 _LastFact.IsUsed = true; +00459 } +00460 if(op) _LastBloc->addCode(op); +00461 break; +00462 case varTypeMember: +00463 if(!_LastFact.IsUsed) +00464 { +00465 if(_LastFact.Member.size() == 1) +00466 { +00467 _LastBloc->addCode(new CLdbMemberOpCode(_LastFact.Member.back())); +00468 } +00469 else +00470 { +00471 _LastBloc->addCode(new CLdbMemberiOpCode(_LastFact.Member)); +00472 } +00473 +00474 _LastFact.IsUsed = true; +00475 } +00476 if(op) _LastBloc->addCode(op); +00477 break; +00478 +00479 case varForFunc: +00480 if(op) _LastBloc->addCode(op); +00481 break; +00482 +00483 case varTypeHeapMember: +00484 if(!_LastFact.IsUsed) +00485 { +00486 if(_LastFact.Member.size()) +00487 { +00488 _LastBloc->addCode(new CLdbHeapMemberiOpCode(_LastFact.Member,((CVarPStackParam *)_LastFact.ValueVar)->getIndex())); +00489 } +00490 else +00491 { +00492 _ConstraintType.push_back(_LastFact.TypeStack); +00493 _LastBloc->addCode(new CHaltOpCode()); +00494 CBagOfCode *b = _LastBloc->getBagOfCode(); +00495 b->addConstraint(_LastFact.TypeStack); +00496 _LastFact.TypeStack = NULL; +00497 } +00498 _LastFact.IsUsed = true; +00499 } +00500 if(op) _LastBloc->addCode(op); +00501 break; +00502 +00503 case varTypeStackMember: +00504 if(!_LastFact.IsUsed) +00505 { +00506 if(_LastFact.Member.size()) +00507 { +00508 _LastBloc->addCode(new CLdbStackMemberiOpCode(_LastFact.Member)); +00509 } +00510 else +00511 { +00512 _ConstraintType.push_back(_LastFact.TypeStack); +00513 _LastBloc->addCode(new CHaltOpCode()); +00514 CBagOfCode *b = _LastBloc->getBagOfCode(); +00515 b->addConstraint(_LastFact.TypeStack); +00516 _LastFact.TypeStack = NULL; +00517 } +00518 _LastFact.IsUsed = true; +00519 } +00520 if(op) _LastBloc->addCode(op); +00521 break; +00522 default: break; +00523 } +00524 } +

+

+ + + + +
+ + + + + + + + + +
bool NLAISCRIPT::CCompilateur::buildObject ( ) [protected]
+
+ + + + + +
+ + + +
+ +
+Definition at line 539 of file var_control.cpp. +
+References _CONSTRUCTOR_, _FlotingExpressionType, _LastBloc, _LastStringParam, _MethodConstraint, _Param, NLAISCRIPT::IBlock::addCode(), NLAISCRIPT::CBagOfCode::addConstraint(), NLAIAGENT::IBaseGroupType::cpy(), NLAIC::createInstance(), NLAISCRIPT::IBlock::getBagOfCode(), getMethodConstraint(), id, NLAIC::IPointerGestion::incRef(), NLAIC::IPointerGestion::release(), s, NLAIC::stringGetBuild(), and yyerror(). +
+
00540 { +00541 NLAIAGENT::CStringType *s = (NLAIAGENT::CStringType *)_LastStringParam.back()->get(); +00542 if(_LastStringParam.back()->size() == 1) +00543 { +00544 +00545 try +00546 { +00547 NLAIC::CIdentType id(s->getStr().getString()); +00548 if(_FlotingExpressionType) _FlotingExpressionType->release(); +00549 _FlotingExpressionType = new COperandSimple(new NLAIC::CIdentType (id)); +00550 +00551 NLAIAGENT::IObjectIA *i = (NLAIAGENT::IObjectIA *)NLAIC::createInstance(id); +00552 +00553 _LastBloc->addCode( new CLdbOpCode( *i ) ); +00554 _LastBloc->addCode(new CHaltOpCode()); +00555 CBagOfCode *b = _LastBloc->getBagOfCode(); +00556 +00557 +00558 NLAIAGENT::IBaseGroupType *g = new NLAIAGENT::CGroupType(); +00559 g->cpy(NLAIAGENT::CStringType(NLAIAGENT::CStringVarName(_CONSTRUCTOR_))); +00560 +00561 _Param.back()->incRef(); +00562 _FlotingExpressionType->incRef(); +00563 CConstraintMethode *cm = new CConstraintMethode(CConstraintMethode::newCall,0,_FlotingExpressionType,g,_Param.back(),0,0); +00564 IConstraint *c = getMethodConstraint(*cm); +00565 if(c == NULL) +00566 { +00567 c = cm; +00568 _MethodConstraint.push_back(c); +00569 } +00570 else +00571 { +00572 cm->release(); +00573 } +00574 b->addConstraint(c); +00575 i->release(); +00576 _LastStringParam.back()->release(); +00577 _LastStringParam.pop_back(); +00578 _Param.back()->release(); +00579 _Param.pop_back(); +00580 } +00581 catch(NLAIE::IException &) +00582 { +00583 std::string text; +00584 text = NLAIC::stringGetBuild("can't find '%s'",s->getStr().getString()); +00585 yyerror((char *)text.c_str()); +00586 return false; +00587 } +00588 return true; +00589 } +00590 return false; +00591 } +

+

+ + + + +
+ + + + + + + + + +
bool NLAISCRIPT::CCompilateur::callFunction ( ) [protected]
+
+ + + + + +
+ + + +
+ +
+Definition at line 816 of file yacc.cpp. +
+References _FromStack, _LastbaseClass, _LastBloc, _LastPosHeap, _LastStringParam, _LastTypeCall, _MethodConstraint, _Param, _SEND_, _TypeList, NLAISCRIPT::IBlock::addCode(), NLAISCRIPT::CBagOfCode::addConstraint(), NLAISCRIPT::IBlock::getBagOfCode(), getMethodConstraint(), NLAIAGENT::CStringType::getStr(), getVar(), NLAIC::IPointerGestion::incRef(), NLAIC::IPointerGestion::release(), s, and sint32. +
+
00817 { +00818 #ifdef NL_DEBUG +00819 std::string mName; +00820 std::string pName; +00821 _LastStringParam.back()->getDebugString(mName); +00822 _Param.back()->getDebugString(pName); +00823 //sint32 i = _TypeList.size(); +00824 #endif +00825 NLAIAGENT::CStringType *s = (NLAIAGENT::CStringType *)_LastStringParam.back()->get(); +00826 if( !strcmp(s->getStr().getString(),_SEND_)/* && _Param.back()->size() == 1*/) +00827 { +00828 _LastBloc->addCode(new CMsgSetSender()); +00829 _LastBloc->addCode(new CNopOpCode()); +00830 //sendOp = _LastBloc->getBagOfCode(); +00831 } +00832 +00833 _LastBloc->addCode(new CNopOpCode()); +00834 CBagOfCode *b = _LastBloc->getBagOfCode(); +00835 _LastbaseClass = NULL; +00836 _LastPosHeap = 0; +00837 _LastTypeCall = CConstraintMethode::normalCall; +00838 +00839 IConstraint *c; +00840 _LastPosHeap = 0; +00841 _LastTypeCall = (sint32)CConstraintMethode::normalCall; +00842 if(_FromStack.back() && _TypeList.size()) +00843 { +00844 _LastbaseClass = _TypeList.back(); +00845 _TypeList.pop_back(); +00846 _LastStringParam.back()->incRef(); +00847 _Param.back()->incRef(); +00848 _LastbaseClass->incRef(); +00849 _LastTypeCall = CConstraintMethode::stackCall; +00850 c = getMethodConstraint(CConstraintMethode((CConstraintMethode::TCallTypeOpCode)_LastTypeCall,_LastPosHeap,_LastbaseClass,_LastStringParam.back(),_Param.back(),0,0)); +00851 } +00852 else +00853 { +00854 NLAIAGENT::CStringType *name = (NLAIAGENT::CStringType *)(_LastStringParam.back()->getFront()); +00855 NLAIAGENT::IObjectIA *var = getVar(name->getStr().getString()); +00856 if(var) +00857 { +00858 ((NLAIAGENT::IObjectIA *)_LastStringParam.back()->popFront())->release(); +00859 _LastTypeCall = CConstraintMethode::heapCall; +00860 _LastPosHeap = ((CVarPStackParam *)var)->getIndex(); +00861 _LastbaseClass = (IOpType *)((const CObjectUnknown *)((CVarPStackParam *)var)->getObject())->getBaseType(); +00862 _LastStringParam.back()->incRef(); +00863 _Param.back()->incRef(); +00864 _LastbaseClass->incRef(); +00865 c = getMethodConstraint(CConstraintMethode((CConstraintMethode::TCallTypeOpCode)_LastTypeCall,_LastPosHeap,_LastbaseClass,_LastStringParam.back(),_Param.back(),0,0)); +00866 if(c == NULL) _LastbaseClass->incRef(); +00867 } +00868 else +00869 { +00870 _LastStringParam.back()->incRef(); +00871 _Param.back()->incRef(); +00872 _LastTypeCall = CConstraintMethode::normalCall; +00873 c = getMethodConstraint(CConstraintMethode((CConstraintMethode::TCallTypeOpCode)_LastTypeCall,_LastPosHeap,_LastbaseClass,_LastStringParam.back(),_Param.back(),0,0)); +00874 } +00875 } +00876 if(c == NULL) +00877 { +00878 c = new CConstraintMethode((CConstraintMethode::TCallTypeOpCode)_LastTypeCall,_LastPosHeap,_LastbaseClass,_LastStringParam.back(),_Param.back(),yyLine,yyColone); +00879 _LastStringParam.back()->incRef(); +00880 _Param.back()->incRef(); +00881 _MethodConstraint.push_back(c); +00882 } +00883 b->addConstraint(c); +00884 /*if(sendOp != NULL) +00885 { +00886 NLAIAGENT::IBaseGroupType *nameRun = (NLAIAGENT::IBaseGroupType *)_LastStringParam.back()->clone(); +00887 ((NLAIAGENT::IObjectIA *)nameRun->pop())->release(); +00888 +00889 //_Param.back()->incRef(); +00890 CParam *paramRun = new CParam; +00891 IOpType *p = (IOpType *)(*_Param.back())[1]; +00892 p->incRef(); +00893 paramRun->push(p); +00894 +00895 const NLAIC::CIdentType *id = NULL; +00896 if(_Param.back()->size() == 2) +00897 { +00898 id = ((IOpType *)(*_Param.back())[0])->getConstraintTypeOf(); +00899 if(id == NULL || !(((const NLAIC::CTypeOfObject &)*id) & NLAIC::CTypeOfObject::tPerformative) ) +00900 { +00901 yyerror("argument 1 of send is not an performatif"); +00902 return false; +00903 } +00904 } +00905 else +00906 { +00907 if(_Param.back()->size() == 3) +00908 { +00909 id = ((IOpType *)(*_Param.back())[1])->getConstraintTypeOf(); +00910 if(id == NULL || !(((const NLAIC::CTypeOfObject &)*id) & NLAIC::CTypeOfObject::tPerformative) ) +00911 { +00912 yyerror("argument 2 of send is not an performatif"); +00913 return false; +00914 } +00915 } +00916 } +00917 +00918 +00919 NLAIAGENT::IPerformative *perf = (NLAIAGENT::IPerformative *)id->getFactory()->getClass(); +00920 char runName[1024*4]; +00921 sprintf(runName,"%s%s",_RUN_,perf->getName()); +00922 nameRun->cpy(NLAIAGENT::CStringType ((NLAIAGENT::CStringVarName(runName)))); +00923 nameRun->incRef(); +00924 +00925 #ifdef NL_DEBUG +00926 nameRun->getDebugString(mName); +00927 #endif +00928 +00929 int baseIsNew = false; +00930 if(_LastbaseClass == NULL) +00931 { +00932 _LastbaseClass = new COperandSimple(new NLAIC::CIdentType (_SelfClass.get()->getType())); +00933 baseIsNew = true; +00934 } +00935 _LastbaseClass->incRef(); +00936 paramRun->incRef(); +00937 c = getMethodConstraint(CConstraintFindRun((CConstraintMethode::TCallTypeOpCode)_LastTypeCall,_LastPosHeap,_LastbaseClass,nameRun,paramRun,0,0)); +00938 if(c == NULL) +00939 { +00940 if(_LastbaseClass && !baseIsNew) _LastbaseClass->incRef(); +00941 c = new CConstraintFindRun((CConstraintMethode::TCallTypeOpCode)_LastTypeCall,_LastPosHeap,_LastbaseClass,nameRun,paramRun,yyLine,yyColone); +00942 _MethodConstraint.push_back(c); +00943 } +00944 else +00945 { +00946 nameRun->release(); +00947 } +00948 sendOp->addConstraint(c); +00949 }*/ +00950 return true; +00951 } +

+

+ + + + +
+ + + + + + + + + +
void NLAISCRIPT::CCompilateur::callSend ( ) [protected]
+
+ + + + + +
+ + + +
+ +
+Definition at line 805 of file yacc.cpp. +
+
00806 { +00807 +00808 //IConstraint *c = getMethodConstraint(CConstraintMethode(CConstraintMethode::normalCall, 0 , _LastbaseClass,_LastStringParam.back(),_Param.back(),0,0)); +00809 } +

+

+ + + + +
+ + + + + + + + + +
bool NLAISCRIPT::CCompilateur::caseRunMsg ( ) [protected]
+
+ + + + + +
+ + + +
+ +
+Definition at line 34 of file var_control.cpp. +
+References haveReturn, isRunMsg, and yyerror(). +
+
00035 { +00036 if(isRunMsg && !haveReturn) +00037 { +00038 isRunMsg = false; +00039 char text[4096]; +00040 strcpy(text,"run message methode must return an message value"); +00041 yyerror(text); +00042 return false; +00043 } +00044 isRunMsg = false; +00045 haveReturn = false; +00046 return true; +00047 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
sint32 NLAISCRIPT::CCompilateur::castVariable ( const NLAIAGENT::CStringVarName & ,
NLAIAGENT::CStringVarName &
) [protected]
+
+ + + + + +
+ + + +
+ +
+Definition at line 54 of file var_control.cpp. +
+References getVar(), id, NLAISCRIPT::CObjectUnknown::setBaseType(), sint32, NLAIC::stringGetBuild(), t, v, and yyerror(). +
+
00055 { +00056 NLAIAGENT::IObjectIA *var = getVar(v.getString()); +00057 if(var != NULL) +00058 { +00059 try +00060 { +00061 NLAIC::CIdentType id(t.getString()); +00062 IOpType * c= new COperandSimple(new NLAIC::CIdentType(id)); +00063 CObjectUnknown *o = (CObjectUnknown *)((CVarPStackParam *)var)->getObject(); +00064 o->setBaseType(c); +00065 return true; +00066 } +00067 catch(NLAIE::IException &) +00068 { +00069 std::string text; +00070 text = NLAIC::stringGetBuild("can't find %s object in the class factory",t.getString()); +00071 yyerror((char *)text.c_str()); +00072 return false; +00073 } +00074 +00075 } +00076 else +00077 { +00078 yyerror("cast service is reseved to the local variable"); +00079 return false; +00080 } +00081 } +

+

+ + + + +
+ + + + + + + + + +
bool NLAISCRIPT::CCompilateur::checkReturnMethod ( ) [protected]
+
+ + + + + +
+ + + +
+ +
+Definition at line 811 of file yacc.cpp. +
+
00812 { +00813 return true; +00814 } +

+

+ + + + +
+ + + + + + + + + +
bool NLAISCRIPT::CCompilateur::classIsAnOperator ( ) [protected]
+
+ + + + + +
+ + + +
+Logic compilation. +
+ +
+Definition at line 49 of file var_control.cpp. +
+
00050 { +00051 return true; +00052 } +

+

+ + + + +
+ + + + + + + + + +
void NLAISCRIPT::CCompilateur::clean ( )
+
+ + + + + +
+ + + +
+Initialize variable befor parsing. +
+ +
+Definition at line 366 of file compilateur.cpp. +
+References _Attrib, _ExpressionType, _FlotingExpressionType, _LastBloc, _LastBloc1, _LastBloc2, _LastBloc3, _LastSaveBloc, _LastStringParam, _Param, cleanTypeList(), NLAIC::IPointerGestion::release(), and sint32. +
+Referenced by initParam(), and ~CCompilateur(). +
+
00367 { +00368 sint32 i; +00369 i = _LastBloc1.size(); +00370 while(i --) +00371 { +00372 if(_LastBloc != _LastBloc1.back()) _LastBloc1.back()->release(); +00373 _LastBloc1.pop_back(); +00374 } +00375 i = _LastBloc2.size(); +00376 while(i --) +00377 { +00378 if(_LastBloc != _LastBloc2.back()) _LastBloc2.back()->release(); +00379 _LastBloc2.pop_back(); +00380 } +00381 +00382 i = _LastBloc3.size(); +00383 while(i --) +00384 { +00385 if(_LastBloc != _LastBloc3.back()) _LastBloc3.back()->release(); +00386 _LastBloc3.pop_back(); +00387 } +00388 +00389 //sint32 i = _LastSaveBloc.size(); +00390 i = _LastSaveBloc.size(); +00391 while(i --) +00392 { +00393 IBlock *k = _LastSaveBloc.back(); +00394 if(_LastBloc != k) k->release(); +00395 _LastSaveBloc.pop_back(); +00396 } +00397 if(_LastBloc !=NULL) _LastBloc->release(); +00398 _LastBloc = NULL; +00399 while(_Attrib.size()) +00400 { +00401 _Attrib.back().first->release(); +00402 _Attrib.back().second->release(); +00403 _Attrib.pop_back(); +00404 } +00405 +00406 while(_Param.size()) +00407 { +00408 _Param.back()->release(); +00409 _Param.pop_back(); +00410 } +00411 +00412 while(_LastStringParam.size()) +00413 { +00414 _LastStringParam.back()->release(); +00415 _LastStringParam.pop_back(); +00416 } +00417 +00418 +00419 if(_ExpressionType != NULL) +00420 { +00421 _ExpressionType->release(); +00422 _ExpressionType = NULL; +00423 } +00424 if(_FlotingExpressionType != NULL) +00425 { +00426 _FlotingExpressionType->release(); +00427 _FlotingExpressionType = NULL; +00428 } +00429 +00430 cleanTypeList(); +00431 } +

+

+ + + + +
+ + + + + + + + + +
void NLAISCRIPT::CCompilateur::cleanMethodConstraint ( )
+
+ + + + + +
+ + + +
+Initialisze the constraint. +
+ +
+Definition at line 433 of file compilateur.cpp. +
+References _MethodConstraint. +
+Referenced by computContraint(), and ~CCompilateur(). +
+
00434 { +00435 while(_MethodConstraint.size()) +00436 { +00437 //IConstraint *c = _MethodConstraint.back(); +00438 //c->release(); +00439 _MethodConstraint.pop_back(); +00440 } +00441 } +

+

+ + + + +
+ + + + + + + + + +
void NLAISCRIPT::CCompilateur::cleanTypeConstraint ( )
+
+ + + + + +
+ + + +
+ +
+Definition at line 443 of file compilateur.cpp. +
+References _ConstraintType. +
+Referenced by computContraint(), and ~CCompilateur(). +
+
00444 { +00445 while(_ConstraintType.size()) +00446 { +00447 _ConstraintType.back()->release(); +00448 _ConstraintType.pop_back(); +00449 } +00450 } +

+

+ + + + +
+ + + + + + + + + +
void NLAISCRIPT::CCompilateur::cleanTypeList ( )
+
+ + + + + +
+ + + +
+Clean internal list. +
+ +
+Definition at line 358 of file compilateur.cpp. +
+References _TypeList. +
+Referenced by clean(). +
+
00359 { +00360 while(_TypeList.size()) +00361 { +00362 _TypeList.back()->release(); +00363 _TypeList.pop_back(); +00364 } +00365 } +

+

+ + + + +
+ + + + + + + + + +
NLAIAGENT::IObjectIA::CProcessResult NLAISCRIPT::CCompilateur::Compile ( ) [virtual]
+
+ + + + + +
+ + + +
+This method generate compiled code. Return is a NLAIAGENT::IObjectIA::CProcessResult where:
+ResultState cintaine a processIdle if the code is generate or ProcessError if there are a prsing error. If there are no problem Result contain the code to execut. +
+Definition at line 102 of file compilateur.cpp. +
+References _Error, _ResultCompile, NLAISCRIPT::EraseDico(), NLAISCRIPT::InitDico(), r, NLAISCRIPT::yyFlexLexer::yylex(), yyparse(), and yywrap(). +
+Referenced by NLAILINK::buildScript(). +
+
00103 { +00104 NLAISCRIPT::InitDico(); +00105 (void)yywrap(); +00106 yyLine = yyColone = 1; +00107 _Error = false; +00108 +00109 (void)yyparse(); +00110 while(yylex()); +00111 +00112 NLAISCRIPT::EraseDico(); +00113 +00114 NLAIAGENT::IObjectIA::CProcessResult r; +00115 if(_Error) +00116 { +00117 r.ResultState = NLAIAGENT::processError; +00118 } +00119 else r.ResultState = NLAIAGENT::processIdle; +00120 r.Result = _ResultCompile; +00121 return r; +00122 } +

+

+ + + + +
+ + + + + + + + + +
void NLAISCRIPT::CCompilateur::CompileFactPattern ( ) [protected]
+
+ + + + + +
+ + + +
+
+

+ + + + +
+ + + + + + + + + +
void NLAISCRIPT::CCompilateur::CompileOperator ( ) [protected]
+
+ + + + + +
+ + + +
+
+

+ + + + +
+ + + + + + + + + +
bool NLAISCRIPT::CCompilateur::computContraint ( ) [protected]
+
+ + + + + +
+ + + +
+ +
+Definition at line 557 of file yacc.cpp. +
+References _SelfClass, cleanMethodConstraint(), cleanTypeConstraint(), errorMethodConstraint(), errorTypeConstraint(), NLAIAGENT::CGroupType::get(), getNMethodConstraint(), runMethodConstraint(), sint32, NLAIC::stringGetBuild(), and yyerror(). +
+Referenced by endMessageManager(). +
+
00558 { +00559 +00560 sint32 constraint = getNMethodConstraint(); +00561 if((constraint - runMethodConstraint())) +00562 { +00563 errorMethodConstraint(); +00564 cleanMethodConstraint(); +00565 errorTypeConstraint(); +00566 cleanTypeConstraint(); +00567 return 0; +00568 } +00569 +00570 /*constraint = _ConstraintType.size() - runTypeConstraint(); +00571 while(_ConstraintType.size()) +00572 { +00573 delete _ConstraintType.back(); +00574 _ConstraintType.pop_back(); +00575 }*/ +00576 +00577 cleanMethodConstraint(); +00578 cleanTypeConstraint(); +00579 IClassInterpret *c = (IClassInterpret *)_SelfClass.get(); +00580 try +00581 { +00582 // ((CAgentClass *)c)->buildChildsMessageMap(); +00583 ((CAgentClass *)c)->initStatics(); +00584 } +00585 catch(NLAIE::IException &e) +00586 { +00587 std::string text; +00588 text = NLAIC::stringGetBuild("can't find '%s'",e.what()); +00589 yyerror((char *)text.c_str()); +00590 return false; +00591 } +00592 return true; +00593 } +

+

+ + + + +
+ + + + + + + + + +
int NLAISCRIPT::FlexLexer::debug ( ) const [inline, inherited]
+
+ + + + + +
+ + + +
+ +
+Definition at line 71 of file lex.h. +
+References NLAISCRIPT::FlexLexer::yy_flex_debug. +
+
00071 { return yy_flex_debug; } +

+

+ + + + +
+ + + + + + + + + + +
bool NLAISCRIPT::CCompilateur::definClass ( const char * className ) [protected]
+
+ + + + + +
+ + + +
+ +
+Definition at line 1020 of file yacc.cpp. +
+References _SelfClass, NLAIAGENT::CGroupType::get(), id, and RegisterClass(). +
+
01021 { +01022 try +01023 { +01024 NLAIC::CIdentType id(className); +01025 return false; +01026 } +01027 catch(NLAIE::IException &) +01028 { +01029 ( (IClassInterpret *) _SelfClass.get() )->setClassName(NLAIAGENT::CStringVarName(className)); +01030 ( (IClassInterpret *) _SelfClass.get() )->buildVTable(); +01031 RegisterClass(); +01032 return true; +01033 } +01034 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NLAISCRIPT::CCompilateur::Echo ( char * Er,
...
)
+
+ + + + + +
+ + + +
+Same as printf but out put is made to the IO interface. +
+ +
+Definition at line 91 of file compilateur.cpp. +
+References _Iterface, and NLAIC::IIO::Echo(). +
+
00092 { +00093 std::string Temp; +00094 va_list marker; +00095 va_start (marker, Er); +00096 char LaseErrorCodeOrdreInterprete[32*1024]; +00097 vsprintf (LaseErrorCodeOrdreInterprete, Er, marker); +00098 _Iterface.Echo("%s",LaseErrorCodeOrdreInterprete); +00099 } +

+

+ + + + +
+ + + + + + + + + +
bool NLAISCRIPT::CCompilateur::endMessageManager ( ) [protected]
+
+ + + + + +
+ + + +
+ +
+Definition at line 1012 of file yacc.cpp. +
+References _ResultCompile, _SelfClass, computContraint(), getCode(), and NLAIAGENT::CGroupType::pop(). +
+
01013 { +01014 _ResultCompile = getCode(true); +01015 bool state = computContraint(); +01016 ((NLAIAGENT::IObjectIA *)_SelfClass.pop())->release(); +01017 return state; +01018 } +

+

+ + + + +
+ + + + + + + + + +
void NLAISCRIPT::CCompilateur::errorMethodConstraint ( ) [protected]
+
+ + + + + +
+ + + +
+ +
+Definition at line 340 of file compilateur.cpp. +
+References _ConstraintType, _MethodConstraint, NLAISCRIPT::IConstraint::getColone(), NLAISCRIPT::IConstraint::getError(), NLAISCRIPT::IConstraint::getLine(), NLAIC::IPointerGestion::release(), and yyerror(). +
+Referenced by computContraint(). +
+
00341 { +00342 char txt[1024*16]; +00343 +00344 std::list<IConstraint *>::iterator j,i = _MethodConstraint.begin(); +00345 while(i != _MethodConstraint.end()) +00346 { +00347 j = i ++; +00348 IConstraint *c = *j; +00349 c->getError(txt); +00350 yyLine = c->getLine(); +00351 yyColone = c->getColone(); +00352 yyerror(txt); +00353 if(_ConstraintType.begin() != _ConstraintType.end()) _ConstraintType.erase(j); +00354 c->release(); +00355 } +00356 } +

+

+ + + + +
+ + + + + + + + + +
void NLAISCRIPT::CCompilateur::errorTypeConstraint ( ) [protected]
+
+ + + + + +
+ + + +
+ +
+Definition at line 325 of file compilateur.cpp. +
+References _ConstraintType, NLAIC::IPointerGestion::release(), and NLAISCRIPT::IConstraint::satisfied(). +
+Referenced by computContraint(), and runMethodConstraint(). +
+
00326 { +00327 std::list<IConstraint *>::iterator j,i = _ConstraintType.begin(); +00328 while(i != _ConstraintType.end()) +00329 { +00330 j = i ++; +00331 IConstraint *c = *j; +00332 if( !c->satisfied() ) +00333 { +00334 _ConstraintType.erase(j); +00335 //yyerror((char *)c->getInfo()); +00336 c->release(); +00337 } +00338 } +00339 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NLAIAGENT::CIdMethod NLAISCRIPT::CCompilateur::findMethode ( sint32 inheritance,
NLAIAGENT::CStringType * baseName,
const NLAIAGENT::IObjectIA * className,
const NLAIAGENT::IVarName & methodeName,
const CParam & param
) [protected]
+
+ + + + + +
+ + + +
+ +
+Definition at line 124 of file compilateur.cpp. +
+References NLAIAGENT::CStringType::getStr(), NLAIAGENT::IObjectIA::isMember(), param, q, sint32, and NLAIAGENT::TQueue. +
+
00125 { +00126 +00127 NLAIAGENT::TQueue q; +00128 if(baseName != NULL && baseName->getStr() == NLAIAGENT::CStringVarName((const char *)CAgentClass::IdAgentClass)) +00129 { +00130 q = classType->isMember(&baseName->getStr(),&methodeName,param); +00131 } +00132 else +00133 { +00134 /*std::string s; +00135 methodeName.getDebugString(s); +00136 param.getDebugString(s); +00137 +00138 s += " "; +00139 classType->getDebugString(s); +00140 +00141 NLAIC::Out("%s\n",s.c_str());*/ +00142 q = classType->isMember(NULL,&methodeName,param); +00143 } +00144 +00145 if(q.size()) +00146 { +00147 return q.top(); +00148 } +00149 else +00150 { +00151 return NLAIAGENT::CIdMethod(-1,0.0,NULL,NULL); +00152 } +00153 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
CFunctionTag NLAISCRIPT::CCompilateur::findMethode ( NLAIAGENT::IBaseGroupType & listName,
const CParam & param
)
+
+ + + + + +
+ + + +
+Find a method the last class mounted by the parser. Method is define by a name or hiarchie name (a hiarchie name is a list same as [myBaseClass myClass myMethod] here it define the string myBaseClass.myClass.myMethod()). param is a CParam object where it define the argument type of the method. +
+Definition at line 155 of file compilateur.cpp. +
+References _SelfClass, findMethode(), NLAIAGENT::CGroupType::get(), and param. +
+
00156 { +00157 return findMethode((IClassInterpret *)_SelfClass.get(),listName,param); +00158 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
CFunctionTag NLAISCRIPT::CCompilateur::findMethode ( const NLAIAGENT::IObjectIA * baseClass,
NLAIAGENT::IBaseGroupType & listName,
const CParam & param
)
+
+ + + + + +
+ + + +
+Find a method in a class define by the baseClass pointer. Method is define by a name or hiarchie name (a hiarchie name is a list same as [myBaseClass myClass myMethod] here it define the string myBaseClass.myClass.myMethod()). param is a CParam object where it define the argument type of the method. +
+Definition at line 160 of file compilateur.cpp. +
+References NLAIAGENT::IBaseGroupType::get(), NLAIAGENT::IBaseGroupType::getFront(), NLAISCRIPT::CFunctionTag::Inheritance, NLAISCRIPT::CFunctionTag::Member, NLAISCRIPT::CFunctionTag::Method, NLAISCRIPT::CFunctionTag::MethodName, NLAISCRIPT::CFunctionTag::MethodNum, NLAISCRIPT::CFunctionTag::Object, param, r, NLAIC::IPointerGestion::release(), NLAISCRIPT::CFunctionTag::setTypeObject(), sint32, NLAIAGENT::IBaseGroupType::size(), and validateHierarchyMethode(). +
+Referenced by findMethode(), and NLAISCRIPT::CConstraintMethode::run(). +
+
00161 { +00162 CFunctionTag method; +00163 if(!listName.size()) +00164 { +00165 method.Inheritance = -1; +00166 method.MethodNum = -1; +00167 method.MethodName = NULL; +00168 return method; +00169 } +00170 +00171 sint32 h = listName.size() - 1; +00172 +00173 NLAIAGENT::CIdMethod r; +00174 +00175 if(!h) +00176 { +00177 method.Inheritance = 0;//classType->sizeVTable() - 1; +00178 method.MethodName = &((const NLAIAGENT::CStringType *)listName.get())->getStr(); +00179 +00180 r = findMethode(method.Inheritance,NULL,classType, *method.MethodName,param); +00181 if( r.Index <0) +00182 { +00183 method.MethodName = NULL; +00184 method.Inheritance = -1; +00185 method.MethodNum = -1; +00186 +00187 } +00188 else +00189 { +00190 method.MethodNum = r.Index; +00191 method.Object = classType; +00192 method.setTypeObject(r.ReturnType); +00193 method.Method = (CMethodeName *)r.Method; +00194 } +00195 +00196 } +00197 else +00198 { +00199 NLAIAGENT::CStringType *baseName = (NLAIAGENT::CStringType *)listName.getFront()->clone(); +00200 +00201 if((classType = validateHierarchyMethode(method.Member,method.Inheritance,classType,listName)) != NULL) +00202 { +00203 if(method.Inheritance >= 0) +00204 { +00205 method.MethodName = &((const NLAIAGENT::CStringType *)listName.get())->getStr(); +00206 +00207 r = findMethode(method.Inheritance,baseName,classType,*method.MethodName,param); +00208 if( r.Index < 0) +00209 { +00210 method.MethodName = NULL; +00211 method.Inheritance = -1; +00212 method.MethodNum = -1; +00213 } +00214 else +00215 { +00216 +00217 method.Object = classType; +00218 method.MethodNum = r.Index; +00219 method.Method = (CMethodeName *)r.Method; +00220 method.setTypeObject(r.ReturnType); +00221 +00222 } +00223 } +00224 else +00225 { +00226 method.MethodName = NULL; +00227 method.Inheritance = -1; +00228 method.MethodNum = -1; +00229 } +00230 } +00231 else +00232 { +00233 +00234 method.MethodName = NULL; +00235 method.Inheritance = -1; +00236 method.MethodNum = -1; +00237 +00238 } +00239 baseName->release(); +00240 } +00241 +00242 return method; +00243 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
sint32 NLAISCRIPT::CCompilateur::findMethodei ( NLAIAGENT::IBaseGroupType & listName,
const CParam & param
) [protected]
+
+ + + + + +
+ + + +
+
+

+ + + + +
+ + + + + + + + + + +
CCodeBrancheRun * NLAISCRIPT::CCompilateur::getCode ( bool isMain = false ) [protected]
+
+ + + + + +
+ + + +
+throw (NLAIE::IException) +
+ +
+Definition at line 953 of file yacc.cpp. +
+References _Debug, _DecalageHeap, _LastBloc, _SelfClass, _SourceFileName, _VarState, NLAISCRIPT::IBlock::addCode(), NLAIAGENT::CGroupType::get(), NLAISCRIPT::IBlock::getCode(), NLAISCRIPT::IBlock::getCodeDebug(), NLAISCRIPT::IBlock::isCodeMonted(), NLAISCRIPT::CIndexStackPointer::popMark(), NLAISCRIPT::CStackPointer::restoreShift(), NLAISCRIPT::CStackPointer::restoreShiftState(), NLAISCRIPT::CStackPointer::restoreStack(), NLAISCRIPT::CStackPointer::restoreStackState(), sint32, and x. +
+Referenced by endMessageManager(). +
+
00954 { +00955 if(_LastBloc != NULL && !_LastBloc->isCodeMonted()) +00956 { +00957 _VarState.popMark(); +00958 IOpCode *x; +00959 if (_Debug) +00960 { +00961 x = new CFreeAllocDebug(); +00962 } +00963 else +00964 { +00965 x = new CFreeAlloc(); +00966 } +00967 _LastBloc->addCode(x); +00968 x = new CHaltOpCode(); +00969 _LastBloc->addCode(x); +00970 +00971 CCodeBrancheRun* listCode; +00972 if (_Debug) +00973 { +00974 listCode = _LastBloc->getCodeDebug(_SourceFileName); +00975 } +00976 else +00977 { +00978 listCode = _LastBloc->getCode(); +00979 } +00980 +00981 if(listCode != NULL) +00982 { +00983 if(!isMain) ((IClassInterpret *)_SelfClass.get())->getBrancheCode().setCode((IOpCode *)listCode); +00984 _Heap -= (sint32)_Heap; +00985 if(_Heap.restoreStackState()) _Heap.restoreStack(); +00986 if(_Heap.restoreShiftState()) _Heap.restoreShift(); +00987 _Heap -= (sint32)_Heap; +00988 //listCode->release(); +00989 } +00990 _DecalageHeap = 0; +00991 CVarPStackParam::_Shift = 0; +00992 +00993 return listCode; +00994 +00995 } +00996 return NULL; +00997 } +

+

+ + + + +
+ + + + + + + + + +
bool NLAISCRIPT::CCompilateur::getDebugMode ( ) const [inline]
+
+ + + + + +
+ + + +
+Get the debug state. +
+ +
+Definition at line 409 of file compilateur.h. +
+References _Debug. +
+Referenced by NLAISCRIPT::CConstraintMethode::run(). +
+
00409 {return _Debug;} +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
const IClassInterpret * NLAISCRIPT::CCompilateur::getInheritanceRange ( sint32 & ,
const IClassInterpret * ,
const NLAIAGENT::IVarName &
) const [protected]
+
+ + + + + +
+ + + +
+ +
+Definition at line 61 of file hierarchy.cpp. +
+References NLAISCRIPT::IClassInterpret::getClassName(), NLAISCRIPT::IClassInterpret::getInheritance(), sint32, and NLAISCRIPT::IClassInterpret::sizeVTable(). +
+
00062 { +00063 const IClassInterpret *bassClass = NULL; +00064 bool find = false; +00065 for(sint32 k = classType->sizeVTable() - 1; k > 0 ;k--) +00066 { +00067 bassClass = classType->getInheritance(k); +00068 h = k; +00069 if(*bassClass->getClassName() == className) +00070 { +00071 /*h = -1; +00072 return NULL;*/ +00073 find = true; +00074 return bassClass; +00075 } +00076 +00077 } +00078 if(!find) +00079 { +00080 h = -1; +00081 return NULL; +00082 } +00083 +00084 return NULL; +00085 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
const IClassInterpret * NLAISCRIPT::CCompilateur::getInheritanceRange ( sint32 & ,
const IClassInterpret * ,
NLAIAGENT::IBaseGroupType &
) const [protected]
+
+ + + + + +
+ + + +
+ +
+Definition at line 29 of file hierarchy.cpp. +
+References NLAISCRIPT::IClassInterpret::getClassName(), NLAISCRIPT::IClassInterpret::getInheritance(), NLAIAGENT::IBaseGroupType::getIterator(), sint32, NLAIAGENT::IBaseGroupType::size(), and NLAISCRIPT::IClassInterpret::sizeVTable(). +
+Referenced by getValidateHierarchyBase(). +
+
00030 { +00031 +00032 NLAIAGENT::CIteratorContener it = listName.getIterator(); +00033 sint32 i = listName.size() - 1; +00034 const IClassInterpret *bassClass = NULL; +00035 while(i --) +00036 { +00037 const NLAIAGENT::IVarName &className = ((const NLAIAGENT::CStringType *)it++)->getStr(); +00038 bool find = false; +00039 for(sint32 k = classType->sizeVTable() - 1; k >= 0 ;k--) +00040 { +00041 bassClass = classType->getInheritance(k); +00042 h = k; +00043 if(*bassClass->getClassName() == className) +00044 { +00045 /*h = -1; +00046 return NULL;*/ +00047 find = true; +00048 break; +00049 } +00050 +00051 } +00052 if(!find) +00053 { +00054 h = -1; +00055 return NULL; +00056 } +00057 } +00058 return bassClass; +00059 } +

+

+ + + + +
+ + + + + + + + + + +
IConstraint * NLAISCRIPT::CCompilateur::getMethodConstraint ( const IConstraint & c ) const [protected]
+
+ + + + + +
+ + + +
+ +
+Definition at line 467 of file compilateur.cpp. +
+References _MethodConstraint. +
+
00468 { +00469 std::list<IConstraint *>::const_iterator i = _MethodConstraint.begin(); +00470 while(i != _MethodConstraint.end()) +00471 { +00472 const IConstraint *o = *i; +00473 if(*o == c) return *i; +00474 i++; +00475 } +00476 return false; +00477 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
IConstraint * NLAISCRIPT::CCompilateur::getMethodConstraint ( const NLAIAGENT::IBaseGroupType & g,
const CParam & p
) const [protected]
+
+ + + + + +
+ + + +
+ +
+Definition at line 452 of file compilateur.cpp. +
+References _MethodConstraint, and NLAISCRIPT::CConstraintMethode::isEqual(). +
+Referenced by affectation(), buildObject(), callFunction(), processingVar(), and setMethodVar(). +
+
00453 { +00454 std::list<IConstraint *>::const_iterator i = _MethodConstraint.begin(); +00455 while(i != _MethodConstraint.end()) +00456 { +00457 if((*i)->getTypeOfClass() == CConstraintMethode::constraintMethode) +00458 { +00459 const CConstraintMethode *o = (const CConstraintMethode *)*i; +00460 if(o->isEqual(g,p)) return *i; +00461 } +00462 i++; +00463 } +00464 return false; +00465 } +

+

+ + + + +
+ + + + + + + + + +
sint32 NLAISCRIPT::CCompilateur::getNMethodConstraint ( ) [inline, protected]
+
+ + + + + +
+ + + +
+ +
+Definition at line 423 of file compilateur.h. +
+References _MethodConstraint, and sint32. +
+Referenced by computContraint(). +
+
00424 { +00425 return _MethodConstraint.size(); +00426 } +

+

+ + + + +
+ + + + + + + + + + +
NLAIC::CIdentType NLAISCRIPT::CCompilateur::getTypeOfClass ( const NLAIAGENT::IVarName & className ) [protected]
+
+ + + + + +
+ + + +
+throw (NLAIE::IException) +
+ +
+Definition at line 59 of file compilateur.cpp. +
+References _SelfClass, NLAIC::CRegistry::existsClass(), NLAISCRIPT::CListClass::find(), NLAISCRIPT::IClassInterpret::getInheritanceName(), NLAIC::getRegistry(), NLAIAGENT::IVarName::getString(), and id. +
+Referenced by getValidateHierarchyBase(), and setParamVarName(). +
+
00060 { +00061 #ifdef NL_DEBUG +00062 const char *nameDB = className.getString(); +00063 #endif +00064 +00065 NLAIC::CRegistry *reg = NLAIC::getRegistry(); +00066 if ( reg->existsClass( className.getString() ) ) +00067 { +00068 NLAIC::CIdentType id(className.getString()); +00069 return id; +00070 } +00071 else +00072 { +00073 IClassInterpret *cl= _SelfClass.find(&className); +00074 if(cl == NULL) +00075 { +00076 throw CExceptionHaveNoType("Can't find class"); +00077 } +00078 else +00079 { +00080 return getTypeOfClass(*cl->getInheritanceName()); +00081 } +00082 } +00083 +00084 /* +00085 try +00086 catch (NLAIE::IException &err) +00087 { +00088 }*/ +00089 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
const NLAIAGENT::IObjectIA * NLAISCRIPT::CCompilateur::getValidateHierarchyBase ( const NLAIAGENT::IObjectIA * base,
std::list< sint32 > & ref,
sint32 & h,
std::list< NLAISCRIPT::CStringType > & listName
) [protected]
+
+ + + + + +
+ + + +
+ +
+Definition at line 104 of file hierarchy.cpp. +
+References data, getInheritanceRange(), NLAIAGENT::IObjectIA::getStaticMember(), NLAIAGENT::IObjectIA::getStaticMemberIndex(), NLAIAGENT::CStringVarName::getString(), NLAIC::IBasicType::getType(), getTypeOfClass(), id, NLAIAGENT::IObjectIA::isClassInheritedFrom(), sint32, NLAIC::stringGetBuild(), and yyerror(). +
+
00105 { +00106 std::list<NLAISCRIPT::CStringType> classHName; +00107 std::list<NLAISCRIPT::CStringType> varHName; +00108 const NLAIAGENT::IObjectIA *baseClass = base; +00109 +00110 ref.clear(); +00111 +00112 h = 0; +00113 NLAIAGENT::CStringVarName baseClassName(""); +00114 +00115 while(listName.size()) +00116 { +00117 NLAIAGENT::CStringVarName lastClassName(listName.back().data()); +00118 listName.pop_back(); +00119 try +00120 { +00121 NLAIC::CIdentType id = getTypeOfClass(lastClassName); +00122 if(baseClass->isClassInheritedFrom(NLAIAGENT::CStringVarName(lastClassName.getString()))>=0) +00123 { +00124 classHName.push_front(lastClassName.getString()); +00125 } +00126 else +00127 { +00128 /*char text[4096*4]; +00129 sprintf(text,"you try to access to '%s' and this class is not define in the hierarchy of '%s' class",lastClassName.getString(),(const char *)baseClass->getType()); +00130 yyerror(text);*/ +00131 return NULL; +00132 } +00133 } +00134 catch(NLAIE::IException &) +00135 { +00136 while(classHName.size()) +00137 { +00138 varHName.push_front(classHName.front()); +00139 classHName.pop_front(); +00140 } +00141 varHName.push_front(lastClassName.getString()); +00142 } +00143 } +00144 +00145 if(classHName.size()) +00146 { +00147 std::list<NLAISCRIPT::CStringType>::iterator i = classHName.begin(); +00148 while(i != classHName.end()) +00149 { +00150 NLAIAGENT::CStringVarName str( NLAIAGENT::CStringVarName((*i++).data())); +00151 try +00152 { +00153 NLAIC::CIdentType id(str.getString()); +00154 const NLAIAGENT::IObjectIA *b = (const NLAIAGENT::IObjectIA *)(id.getFactory())->getClass(); +00155 +00156 if((h = baseClass->isClassInheritedFrom(str)) >= 0) +00157 { +00158 baseClass = b; +00159 } +00160 } +00161 catch(NLAIE::IException &) +00162 { +00163 std::string text; +00164 text = NLAIC::stringGetBuild("you try to access to '%s' and this class is not define in the hierarchy of '%s' class",str.getString(),(const char *)baseClass->getType()); +00165 yyerror((char *)text.c_str()); +00166 return NULL; +00167 } +00168 } +00169 +00170 } +00171 if(varHName.size()) +00172 { +00173 sint32 i; +00174 NLAIAGENT::CStringVarName oldLastClassName(""); +00175 +00176 while(varHName.size()) +00177 { +00178 +00179 NLAIAGENT::CStringVarName lastClassName(varHName.front().data()); +00180 varHName.pop_front(); +00181 +00182 i = baseClass->getStaticMemberIndex(lastClassName); +00183 if(i>=0) +00184 { +00185 const NLAIAGENT::IObjectIA *c = baseClass->getStaticMember(i); +00186 /*if((const NLAIC::CTypeOfObject &)baseClass->getType() & NLAIC::CTypeOfObject::tAgentInterpret) +00187 { +00188 i += getCompementShift((IClassInterpret *)baseClass); +00189 }*/ +00190 ref.push_back(i); +00191 h = 0; +00192 if(c != NULL) +00193 { +00194 baseClass = c; +00195 } +00196 else +00197 { +00198 std::string text; +00199 text = NLAIC::stringGetBuild("you try to access to an indefined object in the '%s' class",(const char *)baseClass->getType()); +00200 yyerror((char *)text.c_str()); +00201 return NULL; +00202 +00203 } +00204 +00205 } +00206 else +00207 { +00208 if((const NLAIC::CTypeOfObject &)baseClass->getType() & NLAIC::CTypeOfObject::tInterpret) +00209 { +00210 baseClass = getInheritanceRange(h,(const IClassInterpret *)baseClass,lastClassName); +00211 } +00212 else +00213 { +00214 h = baseClass->isClassInheritedFrom(lastClassName); +00215 } +00216 +00217 if(baseClass == NULL) +00218 { +00219 std::string text; +00220 text = NLAIC::stringGetBuild("you try to access to '%s' and this class is not define in the hierarchy of '%s' class",lastClassName.getString(),oldLastClassName.getString()); +00221 yyerror((char *)text.c_str()); +00222 return NULL; +00223 } +00224 } +00225 } +00226 } +00227 return baseClass; +00228 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
const NLAIAGENT::IObjectIA * NLAISCRIPT::CCompilateur::getValidateHierarchyBase ( std::list< sint32 > & ref,
sint32 & h,
std::list< NLAISCRIPT::CStringType > & listName
) [protected]
+
+ + + + + +
+ + + +
+ +
+Definition at line 99 of file hierarchy.cpp. +
+References _SelfClass, NLAIAGENT::CGroupType::get(), and sint32. +
+Referenced by isValidateVarName(), and validateHierarchyMethode(). +
+
00100 { +00101 return getValidateHierarchyBase((IClassInterpret *)_SelfClass.get(),ref,h,listName); +00102 } +

+

+ + + + +
+ + + + + + + + + + +
NLAIAGENT::IObjectIA* NLAISCRIPT::CCompilateur::getVar ( const char * name ) [inline]
+
+ + + + + +
+ + + +
+get the locale variable define by name. +
+ +
+Definition at line 292 of file compilateur.h. +
+References _LastBloc, _LastSaveBloc, and NLAISCRIPT::IBlock::getVar(). +
+Referenced by affectation(), callFunction(), castVariable(), and processingVar(). +
+
00293 { +00294 NLAIAGENT::IObjectIA *var = _LastBloc->getVar(name); +00295 if(var == NULL) +00296 { +00297 std::list<IBlock *>::reverse_iterator i = _LastSaveBloc.rbegin(); +00298 while(i != _LastSaveBloc.rend()) +00299 { +00300 IBlock *k = *(i); +00301 var = k->getVar(name); +00302 k = *(i); +00303 if(var != NULL) break; +00304 i ++; +00305 } +00306 } +00307 return var; +00308 } +

+

+ + + + +
+ + + + + + + + + +
void NLAISCRIPT::CCompilateur::ifInterrogation ( ) [protected]
+
+ + + + + +
+ + + +
+ +
+Definition at line 63 of file yacc.cpp. +
+References _Debug, _ExpressionType, _LastBloc, _LastBloc1, _LastSaveBloc, _VarState, NLAISCRIPT::IBlock::addCode(), NLAISCRIPT::CIndexStackPointer::pushMark(), and NLAIC::IPointerGestion::release(). +
+
00064 { +00065 _LastSaveBloc.push_back(_LastBloc); +00066 _LastSaveBloc.back()->incRef(); +00067 _LastBloc1.push_back(new IBlock(_Debug)); +00068 _LastBloc1.back()->incRef(); +00069 _LastBloc = _LastBloc1.back(); +00070 _VarState.pushMark(); +00071 _LastBloc->addCode((new CMarkAlloc)); +00072 if(_ExpressionType) +00073 { +00074 _ExpressionType->release(); +00075 _ExpressionType = NULL; +00076 } +00077 } +

+

+ + + + +
+ + + + + + + + + +
void NLAISCRIPT::CCompilateur::ifInterrogationEnd ( ) [protected]
+
+ + + + + +
+ + + +
+ +
+Definition at line 97 of file yacc.cpp. +
+References _Debug, _LastBloc, _LastBloc1, _LastBloc2, _LastSaveBloc, _VarState, NLAISCRIPT::IBlock::addCode(), NLAISCRIPT::IBlock::getBagOfCode(), NLAISCRIPT::CIndexStackPointer::popMark(), NLAISCRIPT::IBlock::pushCode(), NLAIC::IPointerGestion::release(), and sint32. +
+
00098 { +00099 _VarState -= (sint32)_VarState - _VarState.popMark(); +00100 +00101 if (_Debug) +00102 { +00103 _LastBloc2.back()->addCode((new CFreeAllocDebug)); +00104 } +00105 else +00106 { +00107 _LastBloc2.back()->addCode((new CFreeAlloc)); +00108 } +00109 _LastBloc = _LastSaveBloc.back(); +00110 _LastBloc->release(); +00111 _LastSaveBloc.pop_back(); +00112 sint32 i =_LastBloc1.back()->listCode().size(); +00113 _LastBloc->addCode(new CJFalseOpCode (i + 1)); +00114 while(i --) +00115 { +00116 _LastBloc->pushCode(_LastBloc1.back()->getFront()); +00117 CBagOfCode *b = _LastBloc1.back()->listCode().front(); +00118 (_LastBloc->getBagOfCode())->addConstraint(b); +00119 delete b; +00120 _LastBloc1.back()->listCode().pop_front(); +00121 } +00122 i =_LastBloc2.back()->listCode().size(); +00123 _LastBloc->addCode(new CJmpOpCode (i)); +00124 while(i --) +00125 { +00126 _LastBloc->pushCode(_LastBloc2.back()->getFront()); +00127 CBagOfCode *b = _LastBloc2.back()->listCode().front(); +00128 (_LastBloc->getBagOfCode())->addConstraint(b); +00129 delete b; +00130 _LastBloc2.back()->listCode().pop_front(); +00131 } +00132 _LastBloc1.back()->release(); +00133 _LastBloc1.pop_back(); +00134 _LastBloc2.back()->release(); +00135 _LastBloc2.pop_back(); +00136 } +

+

+ + + + +
+ + + + + + + + + +
void NLAISCRIPT::CCompilateur::ifInterrogationPoint ( ) [protected]
+
+ + + + + +
+ + + +
+ +
+Definition at line 79 of file yacc.cpp. +
+References _Debug, _LastBloc, _LastBloc1, _LastBloc2, _VarState, NLAISCRIPT::IBlock::addCode(), NLAISCRIPT::CIndexStackPointer::popMark(), NLAISCRIPT::CIndexStackPointer::pushMark(), and sint32. +
+
00080 { +00081 _VarState -= (sint32)_VarState - _VarState.popMark(); +00082 if (_Debug) +00083 { +00084 _LastBloc1.back()->addCode((new CFreeAllocDebug)); +00085 } +00086 else +00087 { +00088 _LastBloc1.back()->addCode((new CFreeAlloc)); +00089 } +00090 _LastBloc2.push_back(new IBlock(_Debug)); +00091 _LastBloc2.back()->incRef(); +00092 _LastBloc = _LastBloc2.back(); +00093 _VarState.pushMark(); +00094 _LastBloc->addCode((new CMarkAlloc)); +00095 } +

+

+ + + + +
+ + + + + + + + + + +
void NLAISCRIPT::CCompilateur::InitFromFile ( const char * FileName ) [inline]
+
+ + + + + +
+ + + +
+Initialize source code from file. +
+ +
+Definition at line 274 of file compilateur.h. +
+References _StreamBuffer, file, and sint32. +
+Referenced by CCompilateur(). +
+
00275 { +00276 +00277 ifstream file; +00278 file.open(FileName,ios::in); +00279 sint32 Size = file.gcount(); +00280 char *Chaine = NULL; +00281 if(Size) +00282 { +00283 Chaine = new char [Size]; +00284 file.read(Chaine,Size); +00285 file.close(); +00286 if(_StreamBuffer) delete _StreamBuffer; +00287 _StreamBuffer = new std::istrstream(Chaine,Size); +00288 } +00289 } +

+

+ + + + +
+ + + + + + + + + +
void NLAISCRIPT::CCompilateur::initMessageManager ( ) [protected]
+
+ + + + + +
+ + + +
+ +
+Definition at line 999 of file yacc.cpp. +
+References _SelfClass, NLAIC::IPointerGestion::incRef(), initParam(), NLAIAGENT::CGroupType::push(), and setNewLine(). +
+
01000 { +01001 IClassInterpret *o = (IClassInterpret *)(CManagerClass::IdManagerClass.getFactory())->getClass(); +01002 o->incRef(); +01003 _SelfClass.push(o); +01004 initParam(); +01005 setNewLine(); +01006 /*if (_Debug) +01007 { +01008 _LastBloc->addCode(new CAddParamNameDebug(NLAIAGENT::CGroupType())); +01009 }*/ +01010 } +

+

+ + + + +
+ + + + + + + + + +
void NLAISCRIPT::CCompilateur::initParam ( ) [protected]
+
+ + + + + +
+ + + +
+ +
+Definition at line 596 of file yacc.cpp. +
+References _Debug, _InLineParse, _LastBloc, _Param, _VarState, NLAISCRIPT::IBlock::addCode(), clean(), NLAISCRIPT::CIndexStackPointer::clear(), NLAISCRIPT::CIndexStackPointer::pushMark(), and sint32. +
+Referenced by initMessageManager(). +
+
00597 { +00598 clean(); +00599 _LastBloc = new IBlock(_Debug); +00600 _Heap -= (sint32)_Heap; +00601 CVarPStack::_LocalTableRef = &_Heap[0]; +00602 _VarState.clear(); +00603 _VarState.pushMark(); +00604 if(!_InLineParse) _LastBloc->addCode((new CMarkAlloc)); +00605 _Param.push_back(new CParam); +00606 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NLAISCRIPT::CCompilateur::InitStream ( char * str,
sint32 size
) [inline]
+
+ + + + + +
+ + + +
+Initialize the std::stream. +
+ +
+Definition at line 311 of file compilateur.h. +
+References _StreamBuffer, sint32, and size. +
+Referenced by CCompilateur(). +
+
00312 { +00313 if(_StreamBuffer) delete _StreamBuffer; +00314 _StreamBuffer = new std::istrstream(str,size); +00315 } +

+

+ + + + +
+ + + + + + + + + +
void NLAISCRIPT::CCompilateur::interrogationEnd ( ) [protected]
+
+ + + + + +
+ + + +
+ +
+Definition at line 36 of file yacc.cpp. +
+References _Debug, _LastBloc, _LastBloc1, _LastSaveBloc, _VarState, NLAISCRIPT::IBlock::addCode(), NLAISCRIPT::IBlock::getBagOfCode(), NLAISCRIPT::CIndexStackPointer::popMark(), NLAISCRIPT::IBlock::pushCode(), NLAIC::IPointerGestion::release(), and sint32. +
+
00037 { +00038 _VarState -= (sint32)_VarState - _VarState.popMark(); +00039 if (_Debug) +00040 { +00041 _LastBloc1.back()->addCode((new CFreeAllocDebug)); +00042 } +00043 else +00044 { +00045 _LastBloc1.back()->addCode((new CFreeAlloc)); +00046 } +00047 sint32 i =_LastBloc1.back()->listCode().size(); +00048 _LastBloc = _LastSaveBloc.back(); +00049 _LastBloc->release(); +00050 _LastBloc->addCode(new CJFalseOpCode (i)); +00051 while(i --) +00052 { +00053 _LastBloc->pushCode(_LastBloc1.back()->getFront()); +00054 CBagOfCode *b = _LastBloc1.back()->listCode().front(); +00055 (_LastBloc->getBagOfCode())->addConstraint(b); +00056 delete b; +00057 _LastBloc1.back()->listCode().pop_front(); +00058 } +00059 _LastBloc1.back()->release(); +00060 _LastBloc1.pop_back(); +00061 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
sint32 NLAISCRIPT::CCompilateur::isValidateVarName ( std::list< sint32 > & ref,
std::list< NLAISCRIPT::CStringType > & nameHierarchy,
IOpType *& type
)
+
+ + + + + +
+ + + +
+Search if a member variable is validete in the lase class parsed. The variable is define by a CStringType hiarchie name in the nameHierarchy argument (a hiarchie name is a list same as [myBaseClass myClass myVariable] where it define the string myBaseClass.myClass.myVariable = 5). If the var name is validate then ref contain how to make reference and type containe the type of the attribut. +
+Definition at line 380 of file yacc.cpp. +
+References _SelfClass, NLAIAGENT::CGroupType::get(), isValidateVarName(), sint32, and type. +
+
00381 { +00382 return isValidateVarName(_SelfClass.get(),ref,listName,type); +00383 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
sint32 NLAISCRIPT::CCompilateur::isValidateVarName ( const NLAIAGENT::IObjectIA * baseClass,
std::list< sint32 > & ref,
std::list< NLAISCRIPT::CStringType > & nameHierarchy,
IOpType *& type
)
+
+ + + + + +
+ + + +
+Search if a member variable is validete for a class defined by baseClass. The variable is define by a CStringType hiarchie name in the nameHierarchy argument (a hiarchie name is a list same as [myBaseClass myClass myVariable] where it define the string myBaseClass.myClass.myVariable = 5). If the var name is validate then ref contain how to make reference and type containe the type of the attribut. +
+Definition at line 385 of file yacc.cpp. +
+References NLAIAGENT::IObjectIA::getStaticMember(), NLAIAGENT::IObjectIA::getStaticMemberIndex(), NLAIC::IBasicType::getType(), getValidateHierarchyBase(), sint32, and type. +
+Referenced by affectation(), isValidateVarName(), PrivateError(), processingVar(), and NLAISCRIPT::CConstraintStackComp::run(). +
+
00386 { +00387 NLAIAGENT::CStringVarName varName(listName.back().data()); +00388 sint32 h; +00389 listName.pop_back(); +00390 type = NULL; +00391 const NLAIAGENT::IObjectIA *baseClass = getValidateHierarchyBase(base,ref,h,listName); +00392 +00393 if(baseClass) +00394 { +00395 sint32 i = baseClass->getStaticMemberIndex(varName); +00396 if(i>=0) +00397 { +00398 const NLAIAGENT::IObjectIA *c = baseClass->getStaticMember(i); +00399 /*if((const NLAIC::CTypeOfObject &)baseClass->getType() & NLAIC::CTypeOfObject::tAgentInterpret) +00400 { +00401 i += getCompementShift((IClassInterpret *)baseClass); +00402 }*/ +00403 if(c != NULL) +00404 { +00405 ref.push_back(i); +00406 type = new COperandSimple(new NLAIC::CIdentType(c->getType())); +00407 return true; +00408 } +00409 else +00410 { +00411 return false; +00412 } +00413 +00414 } +00415 } +00416 return false; +00417 } +

+

+ + + + +
+ + + + + + + + + + +
virtual void NLAISCRIPT::yyFlexLexer::LexerError ( const char * msg ) [protected, virtual, inherited]
+
+ + + + + +
+ + + +
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
int yyFlexLexer::LexerInput ( char * buf,
int max_size
) [protected, virtual, inherited]
+
+ + + + + +
+ + + +
+ +
+Definition at line 2811 of file lexlang.cpp. +
+References yyin. +
+
02813 { +02814 if ( yyin->eof() || yyin->fail() ) +02815 return 0; +02816 +02817 #ifdef YY_INTERACTIVE +02818 yyin->get( buf[0] ); +02819 +02820 if ( yyin->eof() ) +02821 return 0; +02822 +02823 if ( yyin->bad() ) +02824 return -1; +02825 +02826 return 1; +02827 +02828 #else +02829 (void) yyin->read( buf, max_size ); +02830 +02831 if ( yyin->bad() ) +02832 return -1; +02833 else +02834 return yyin->gcount(); +02835 #endif +02836 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void yyFlexLexer::LexerOutput ( const char * buf,
int size
) [protected, virtual, inherited]
+
+ + + + + +
+ + + +
+ +
+Definition at line 2838 of file lexlang.cpp. +
+References size, and NLAISCRIPT::yyFlexLexer::yyout. +
+
02839 { +02840 (void) yyout->write( buf, size ); +02841 } +

+

+ + + + +
+ + + + + + + + + +
int NLAISCRIPT::FlexLexer::lineno ( ) const [inline, inherited]
+
+ + + + + +
+ + + +
+ +
+Definition at line 69 of file lex.h. +
+References NLAISCRIPT::FlexLexer::yylineno. +
+
00069 { return yylineno; } +

+

+ + + + +
+ + + + + + + + + +
void NLAISCRIPT::CCompilateur::nameMethodeProcessing ( ) [protected]
+
+ + + + + +
+ + + +
+ +
+Definition at line 526 of file yacc.cpp. +
+References _LastStringParam, _LasVarStr, NLAIAGENT::IBaseGroupType::cpy(), and s. +
+
00527 { +00528 NLAIAGENT::IBaseGroupType *g = new NLAIAGENT::CGroupType; +00529 _LastStringParam.push_back(g); +00530 +00531 std::list<NLAISCRIPT::CStringType>::iterator i = _LasVarStr.begin(); +00532 while(i != _LasVarStr.end()) +00533 { +00534 NLAISCRIPT::CStringType &s = *i++; +00535 g->cpy(NLAIAGENT::CStringType(NLAIAGENT::CStringVarName(s.data()))); +00536 } +00537 } +

+

+ + + + +
+ + + + + + + + + +
void NLAISCRIPT::CCompilateur::onEndClass ( ) [protected]
+
+ + + + + +
+ + + +
+ +
+Definition at line 52 of file compilateur.cpp. +
+References _SelfClass, NLAIAGENT::CGroupType::pop(), and NLAIC::IPointerGestion::release(). +
+
00053 { +00054 NLAIAGENT::IObjectIA *o = (NLAIAGENT::IObjectIA *)_SelfClass.pop(); +00055 ((IClassInterpret *)o)->classIsMounted(); +00056 o->release(); +00057 } +

+

+ + + + +
+ + + + + + + + + +
bool NLAISCRIPT::CCompilateur::parseError ( ) [inline]
+
+ + + + + +
+ + + +
+You can use this to consult the state of the parser. +
+ +
+Definition at line 374 of file compilateur.h. +
+References _Error. +
+
00375 { +00376 return _Error == true; +00377 } +

+

+ + + + +
+ + + + + + + + + +
sint32 NLAISCRIPT::CCompilateur::PrivateError ( ) [protected]
+
+ + + + + +
+ + + +
+ +
+Definition at line 358 of file yacc.cpp. +
+References _LasAffectationVarStr, _LastBloc, NLAISCRIPT::IBlock::addCode(), isValidateVarName(), NLAIC::IPointerGestion::release(), and sint32. +
+Referenced by affectation(). +
+
00359 { +00360 std::list<sint32> ref; +00361 IOpType *c; +00362 if(!isValidateVarName(ref,_LasAffectationVarStr,c)) +00363 { +00364 if(c) c->release(); +00365 return false; +00366 } +00367 if(ref.size() == 1) +00368 { +00369 _LastBloc->addCode(new CAffMemberOpCode(ref.back())); +00370 } +00371 else +00372 { +00373 _LastBloc->addCode(new CAffMemberiOpCode (ref)); +00374 } +00375 +00376 if(c) c->release(); +00377 return true; +00378 } +

+

+ + + + +
+ + + + + + + + + +
sint32 NLAISCRIPT::CCompilateur::processingVar ( ) [protected]
+
+ + + + + +
+ + + +
+ +
+Definition at line 82 of file var_control.cpp. +
+References _FlotingExpressionType, _LastFact, _LasVarStr, _SelfClass, _TypeList, NLAIAGENT::CGroupType::get(), NLAISCRIPT::IConstraint::getConstraintTypeOf(), getMethodConstraint(), NLAIAGENT::IObjectIA::getStaticMemberIndex(), NLAIAGENT::CStringVarName::getString(), NLAIC::IBasicType::getType(), getVar(), NLAIC::IPointerGestion::incRef(), NLAISCRIPT::CFactorType::IsUsed, isValidateVarName(), NLAISCRIPT::CFactorType::Member, NLAISCRIPT::CFactorType::MemberName, NLAIC::IPointerGestion::release(), NLAISCRIPT::IConstraint::satisfied(), sint32, NLAIC::stringGetBuild(), type, NLAISCRIPT::CFactorType::TypeStack, NLAISCRIPT::CFactorType::ValueVar, NLAISCRIPT::CFactorType::VarType, NLAISCRIPT::varTypeHeapMember, NLAISCRIPT::varTypeLocal, NLAISCRIPT::varTypeMember, NLAISCRIPT::varTypeStackMember, and yyerror(). +
+
00083 { +00084 if(_LasVarStr.size() >= 1) +00085 { +00086 NLAIAGENT::IObjectIA *var; +00087 var = getVar(_LasVarStr.front().data()); +00088 if(_LasVarStr.size() == 1) +00089 { +00090 if(var == NULL) +00091 { +00092 sint32 i = ((IClassInterpret *)_SelfClass.get())->getStaticMemberIndex(NLAIAGENT::CStringVarName(_LasVarStr.front().data())); +00093 if(i >= 0) +00094 { +00095 _LastFact.Member.clear(); +00096 _LastFact.Member.push_back(i /*+ getCompementShift((IClassInterpret *)_SelfClass.get())*/); +00097 _LastFact.ValueVar = NULL; +00098 _LastFact.VarType = varTypeMember; +00099 _LastFact.IsUsed = false; +00100 try +00101 { +00102 if(_FlotingExpressionType != NULL) delete _FlotingExpressionType; +00103 _FlotingExpressionType = new COperandSimple(new NLAIC::CIdentType ((_SelfClass.get())->getStaticMember(i)->getType())); +00104 } +00105 catch(NLAIE::IException &a) +00106 { +00107 yyerror((char *)a.what()); +00108 return 0; +00109 } +00110 } +00111 else +00112 { +00113 if(_TypeList.size()) +00114 { +00115 IOpType *type = _TypeList.back(); +00116 _TypeList.pop_back(); +00117 _LastFact.Member.clear(); +00118 _LastFact.MemberName.clear(); +00119 +00120 if(_FlotingExpressionType != NULL) _FlotingExpressionType->release(); +00121 +00122 +00123 if(type->satisfied()) +00124 { +00125 NLAIAGENT::IObjectIA *c = (NLAIAGENT::IObjectIA *)((NLAIC::IClassFactory *)type->getConstraintTypeOf()->getFactory())->getClass(); +00126 sint32 i = c->getStaticMemberIndex(NLAIAGENT::CStringVarName(_LasVarStr.front().data())); +00127 if(i >= 0) +00128 { +00129 /*if(((const NLAIC::CTypeOfObject &)*c->getType()) & NLAIC::CTypeOfObject::tAgentInterpret) +00130 { +00131 _LastFact.Member.push_back(i + getCompementShift((IClassInterpret *)c)); +00132 } +00133 else*/ +00134 { +00135 _LastFact.Member.push_back(i); +00136 } +00137 +00138 } +00139 else +00140 { +00141 type->release(); +00142 yyerror("attribut is not define"); +00143 return 0; +00144 } +00145 NLAIC::CIdentType *id = new NLAIC::CIdentType (c->getType()); +00146 _FlotingExpressionType = new COperandSimple(id); +00147 type->release(); +00148 } +00149 else +00150 { +00151 _LastFact.MemberName = _LasVarStr; +00152 type->incRef(); +00153 IOpType *constr = (IOpType *)getMethodConstraint(CConstraintStackComp(CConstraintStackComp::stackCall,0,_LastFact.MemberName ,type,0,0)); +00154 if(constr == NULL) +00155 { +00156 constr = new CConstraintStackComp(CConstraintStackComp::stackCall,0,_LastFact.MemberName,type,yyLine,yyColone); +00157 } +00158 _FlotingExpressionType = constr; +00159 } +00160 +00161 if(_LastFact.TypeStack) _LastFact.TypeStack->release(); +00162 _LastFact.TypeStack = _FlotingExpressionType; +00163 _LastFact.TypeStack->incRef(); +00164 _LastFact.ValueVar = NULL; +00165 _LastFact.VarType = varTypeStackMember; +00166 _LastFact.IsUsed = false; +00167 +00168 } +00169 else +00170 { +00171 yyerror("variable used but never declared"); +00172 return 0; +00173 } +00174 } +00175 } +00176 else +00177 { +00178 _LastFact.ValueVar = var; +00179 _LastFact.VarType = varTypeLocal; +00180 _LastFact.IsUsed = false; +00181 _LasVarStr.clear(); +00182 if(var->getType() == CVarPStackParam::IdVarPStackParam) +00183 { +00184 if(_FlotingExpressionType != NULL) _FlotingExpressionType->release(); +00185 try +00186 { +00187 _FlotingExpressionType = new COperandSimple(new NLAIC::CIdentType(((CVarPStackParam *)var)->getVarType())); +00188 } +00189 catch(NLAIE::CExceptionUnReference &) +00190 { +00191 _FlotingExpressionType = (IOpType *)((const CObjectUnknown *)((CVarPStackParam *)var)->getObject())->getClassType(); +00192 _FlotingExpressionType->incRef(); +00193 } +00194 } +00195 else +00196 { +00197 if(_FlotingExpressionType != NULL) _FlotingExpressionType->release(); +00198 _FlotingExpressionType = new COperandSimple(new NLAIC::CIdentType(var->getType())); +00199 } +00200 } +00201 } +00202 else +00203 { +00204 +00205 CConstraintStackComp::OpCodeType opCodeType = CConstraintStackComp::stackCall; +00206 sint32 posStack = 0; +00207 NLAIAGENT::CStringVarName varName(_LasVarStr.back().data()); +00208 if(var != NULL) +00209 { +00210 _LasVarStr.pop_front(); +00211 IOpType *cont = (IOpType *)((const CObjectUnknown *)((CVarPStackParam *)var)->getObject())->getBaseType(); +00212 if(cont->satisfied()) +00213 { +00214 const NLAIC::CIdentType &id = *cont->getConstraintTypeOf(); +00215 IClassInterpret *cl; +00216 +00217 if(strcmp((const char *)id,((IClassInterpret *)_SelfClass.get())->getClassName()->getString()) == 0) +00218 { +00219 cl = (IClassInterpret *)_SelfClass.get(); +00220 } +00221 else cl = (IClassInterpret *)((CClassInterpretFactory *)id.getFactory())->getClass(); +00222 IOpType *c; +00223 _LastFact.Member.clear(); +00224 if(!isValidateVarName(cl,_LastFact.Member,_LasVarStr,c)) +00225 { +00226 if(c) c->release(); +00227 std::string text; +00228 text = NLAIC::stringGetBuild("var '%s' is not define",varName.getString()); +00229 yyerror((char *)text.c_str()); +00230 return false; +00231 } +00232 _FlotingExpressionType = c; +00233 if(_LastFact.TypeStack) _LastFact.TypeStack->release(); +00234 _LastFact.TypeStack = _FlotingExpressionType; +00235 _LastFact.TypeStack->incRef(); +00236 _LastFact.ValueVar = var; +00237 _LastFact.VarType = varTypeHeapMember; +00238 _LastFact.IsUsed = false; +00239 #ifdef NL_DEBUG +00240 std::list<sint32>::iterator i_dbg = _LastFact.Member.begin(); +00241 while(i_dbg != _LastFact.Member.end()) +00242 { +00243 int k = *i_dbg++; +00244 } +00245 +00246 #endif +00247 return true; +00248 } +00249 else +00250 { +00251 opCodeType = CConstraintStackComp::heapCall; +00252 posStack = ((CVarPStackParam *)var)->getIndex(); +00253 cont->incRef(); +00254 _TypeList.push_back(cont); +00255 } +00256 +00257 } +00258 +00259 if(!_TypeList.size()) +00260 { +00261 _LastFact.Member.clear(); +00262 IOpType *c; +00263 if(!isValidateVarName(_LastFact.Member,_LasVarStr,c)) +00264 { +00265 if(c) c->release(); +00266 std::string text; +00267 text = NLAIC::stringGetBuild("var '%s' is not define",varName.getString()); +00268 yyerror((char *)text.c_str()); +00269 return false; +00270 } +00271 _LastFact.ValueVar = NULL; +00272 _LastFact.VarType = varTypeMember; +00273 _LastFact.IsUsed = false; +00274 if(_FlotingExpressionType != NULL) _FlotingExpressionType->release(); +00275 _FlotingExpressionType = (IOpType *)c; +00276 } +00277 else +00278 { +00279 IOpType *type = _TypeList.back(); +00280 _TypeList.pop_back(); +00281 _LastFact.Member.clear(); +00282 _LastFact.MemberName.clear(); +00283 +00284 if(_FlotingExpressionType != NULL) _FlotingExpressionType->release(); +00285 +00286 if(type->satisfied()) +00287 { +00288 IClassInterpret *cl = (IClassInterpret *)type->getConstraintTypeOf()->allocClass(); +00289 IOpType *c; +00290 if(!isValidateVarName(cl,_LastFact.Member,_LasVarStr,c)) +00291 { +00292 if(c) c->release(); +00293 type->release(); +00294 cl->release(); +00295 std::string text; +00296 text = NLAIC::stringGetBuild("var '%s' is not define",varName.getString()); +00297 yyerror((char *)text.c_str()); +00298 return false; +00299 } +00300 _FlotingExpressionType = (IOpType *)c; +00301 type->release(); +00302 cl->release(); +00303 } +00304 else +00305 { +00306 _LastFact.MemberName = _LasVarStr; +00307 type->incRef(); +00308 IOpType *constr = (IOpType *)getMethodConstraint(CConstraintStackComp(opCodeType,posStack,_LastFact.MemberName ,type,0,0)); +00309 if(constr == NULL) +00310 { +00311 constr = new CConstraintStackComp(opCodeType,posStack,_LastFact.MemberName,type,yyLine,yyColone); +00312 } +00313 else +00314 { +00315 constr->incRef(); +00316 } +00317 _FlotingExpressionType = constr; +00318 } +00319 +00320 if(_LastFact.TypeStack) _LastFact.TypeStack->release(); +00321 _LastFact.TypeStack = _FlotingExpressionType; +00322 _LastFact.TypeStack->incRef(); +00323 _LastFact.ValueVar = NULL; +00324 _LastFact.VarType = varTypeStackMember; +00325 _LastFact.IsUsed = false; +00326 } +00327 } +00328 } +00329 else +00330 { +00331 yyerror("erreur de definition de variable"); +00332 return 0; +00333 } +00334 return true; +00335 } +

+

+ + + + +
+ + + + + + + + + +
void NLAISCRIPT::CCompilateur::pushParamExpression ( ) [protected]
+
+ + + + + +
+ + + +
+ +
+Definition at line 389 of file var_control.cpp. +
+References _ConstraintType, _ExpressionType, _LastBloc, _Param, NLAISCRIPT::IBlock::addCode(), NLAIC::IPointerGestion::incRef(), and NLAISCRIPT::IConstraint::satisfied(). +
+
00390 { +00391 _LastBloc->addCode((new CAddOpCode)); +00392 _Param.back()->push(_ExpressionType); +00393 if(!_ExpressionType->satisfied()) +00394 { +00395 _ConstraintType.push_back(_ExpressionType); +00396 _ExpressionType->incRef(); +00397 } +00398 _ExpressionType = NULL; +00399 } +

+

+ + + + +
+ + + + + + + + + +
void NLAISCRIPT::CCompilateur::RegisterClass ( ) [protected]
+
+ + + + + +
+ + + +
+ +
+Definition at line 539 of file yacc.cpp. +
+References _ConstraintType, _SelfClass, NLAIAGENT::CGroupType::get(), NLAISCRIPT::IClassInterpret::getClassName(), NLAIAGENT::IVarName::getString(), NLAISCRIPT::IClassInterpret::getTypeClass(), id, NLAISCRIPT::IClassInterpret::setType(), and x. +
+Referenced by definClass(). +
+
00540 { +00541 IClassInterpret *c = (IClassInterpret *)_SelfClass.get(); +00542 // c->initStatics(); +00543 const NLAIAGENT::IVarName &className = *c->getClassName(); +00544 #ifdef NL_DEBUG +00545 className.getString(); +00546 _ConstraintType.size(); +00547 #endif +00548 NLAIC::CIdentType id(className.getString(),(const NLAIC::IClassFactory &)CClassInterpretFactory(c), +00549 NLAIC::CTypeOfObject(c->getTypeClass()), NLAIC::CTypeOfOperator(0)); +00550 +00551 +00552 NLAIC::CIdentType *x = new NLAIC::CIdentType(id); +00553 +00554 c->setType(x); +00555 } +

+

+ + + + +
+ + + + + + + + + +
bool NLAISCRIPT::CCompilateur::registerMethod ( ) [protected]
+
+ + + + + +
+ + + +
+ +
+Definition at line 608 of file yacc.cpp. +
+References _Attrib, _Debug, _DecalageHeap, _LastAffectation, _LastBloc, _MethodName, _Param, _RUN_, _SelfClass, _SEND_, NLAISCRIPT::IBlock::allocLocVar(), NLAISCRIPT::CParam::eval(), NLAIAGENT::CGroupType::get(), NLAISCRIPT::CMethodeName::getParam(), isRunMsg, NLAISCRIPT::CParam::push(), NLAIAGENT::CVectorGroupType::pushFront(), r, NLAIC::IPointerGestion::release(), NLAISCRIPT::CStackPointer::restoreShift(), NLAISCRIPT::CStackPointer::restoreShiftState(), NLAISCRIPT::CStackPointer::restoreStack(), NLAISCRIPT::CStackPointer::restoreStackState(), NLAISCRIPT::CParam::setInfo(), NLAISCRIPT::CStackPointer::setShift(), sint, sint32, NLAIC::stringGetBuild(), x, and yyerror(). +
+
00609 { +00610 bool isRun = false; +00611 sint i; +00612 const char *r = (const char *)_RUN_; +00613 +00614 if(r[0] == _MethodName.back().getString()[0] && r[1] == _MethodName.back().getString()[1]) +00615 { +00616 std::list<const char *> listRun; +00617 +00618 listRun.push_back((const char *)NLAIAGENT::CPExec::IdPExec); +00619 listRun.push_back((const char *)NLAIAGENT::CPAchieve::IdPAchieve); +00620 listRun.push_back((const char *)NLAIAGENT::CPAsk::IdPAsk); +00621 listRun.push_back((const char *)NLAIAGENT::CPBreak::IdPBreak); +00622 listRun.push_back((const char *)NLAIAGENT::CPTell::IdPTell); +00623 listRun.push_back((const char *)NLAIAGENT::CPKill::IdPKill); +00624 listRun.push_back((const char *)NLAIAGENT::CPError::IdPError); +00625 listRun.push_back((const char *)NLAIAGENT::CPExec::IdPExec); +00626 +00627 char nameRun[1024]; +00628 for(i = 0; i < (sint)listRun.size(); i ++) +00629 { +00630 strcpy(nameRun,_RUN_); +00631 strcat(nameRun,listRun.back()); +00632 listRun.pop_back(); +00633 if(!strcmp(_MethodName.back().getString(),nameRun)) +00634 { +00635 isRun = true; +00636 isRunMsg = true; +00637 break; +00638 } +00639 } +00640 if(!isRun) +00641 { +00642 strcpy(nameRun,_RUN_); +00643 if(!strcmp(_MethodName.back().getString(),nameRun)) +00644 { +00645 isRun = true; +00646 } +00647 } +00648 } +00649 +00650 bool isSend = !strcmp(_MethodName.back().getString(),_SEND_); +00651 bool runProcces = false; +00652 if( isRun || isSend ) +00653 { +00654 CParam p; +00655 COperandSimple *x = new COperandSimple(new NLAIC::CIdentType("Message")); +00656 p.push(x); +00657 +00658 if( ( isRun && _Param.back()->size() > 1 ) || isSend) +00659 { +00660 std::string text; +00661 text = NLAIC::stringGetBuild("method %s have more than 1 parametre",_MethodName.back().getString()); +00662 yyerror((char *)text.c_str()); +00663 return false; +00664 } +00665 else +00666 if(_Param.back()->size()) +00667 { +00668 if(p.eval(*_Param.back()) < 0.0) +00669 { +00670 std::string text; +00671 text = NLAIC::stringGetBuild("the method %s have a parametre not derived from Message class",_MethodName.back().getString()); +00672 yyerror((char *)text.c_str()); +00673 return false; +00674 } +00675 } +00676 else +00677 if(isRun) +00678 { +00679 runProcces = true; +00680 } +00681 } +00682 +00683 sint32 indexMethod; +00684 try +00685 { +00686 indexMethod = ((IClassInterpret *)_SelfClass.get())->addBrancheCode(_MethodName.back(),*_Param.back()); +00687 } +00688 catch(NLAIE::IException &err) +00689 { +00690 yyerror((char *)err.what()); +00691 +00692 return false; +00693 } +00694 +00695 if(runProcces) +00696 { +00697 if( ((IClassInterpret *)_SelfClass.get())->getRunMethod() >=0 ) +00698 { +00699 std::string text; +00700 text = NLAIC::stringGetBuild("the method Run() have all ready defined"); +00701 yyerror((char *)text.c_str()); +00702 return false; +00703 } +00704 ((IClassInterpret *)_SelfClass.get())->setRunMethod(indexMethod); +00705 } +00706 i = 0; +00707 _DecalageHeap = _Attrib.size(); +00708 _Heap.setShift(_DecalageHeap); +00709 CVarPStackParam::_Shift = _DecalageHeap; +00710 +00711 NLAIAGENT::CStringType* debugStringAttrib; +00712 NLAIAGENT::CVectorGroupType* debugAttrib; +00713 if (_Debug) +00714 { +00715 debugAttrib = new NLAIAGENT::CVectorGroupType(); +00716 } +00717 else debugAttrib = NULL; +00718 +00719 while(_Attrib.size() != 0) +00720 { +00721 i--; +00722 #ifdef NL_DEBUG +00723 _LastAffectation = new CVarPStackParam(i,_Attrib.back().first->getString()); +00724 #else +00725 _LastAffectation = new CVarPStackParam(i); +00726 #endif +00727 // We put the functions atributs in the _LastBloc dico. +00728 if(!_LastBloc->allocLocVar(_Attrib.back().first->getString(),_LastAffectation)) +00729 { +00730 std::string text; +00731 text = NLAIC::stringGetBuild("variable '%s' already defined",_Attrib.back().first->getString()); +00732 yyerror((char *)text.c_str()); +00733 _Heap -= (sint32)_Heap; +00734 if(_Heap.restoreStackState()) _Heap.restoreStack(); +00735 if(_Heap.restoreShiftState()) _Heap.restoreShift(); +00736 _Heap -= (sint32)_Heap; +00737 _LastAffectation->release(); +00738 return 0; +00739 } +00740 if (_Debug) +00741 { +00742 // We store the function var name; +00743 debugStringAttrib = new NLAIAGENT::CStringType(*(_Attrib.back().first)); +00744 debugAttrib->pushFront(debugStringAttrib); +00745 } +00746 _Attrib.back().first->release(); +00747 _Attrib.back().second->release(); +00748 _Attrib.pop_back(); +00749 } +00750 +00751 CMethodeName &thisMethod = ((IClassInterpret *)_SelfClass.get())->getBrancheCode(); +00752 thisMethod.getParam().setInfo(debugAttrib); +00753 /*if (_Debug) +00754 { +00755 _LastBloc->addCode(new CAddParamNameDebug(*debugAttrib)); +00756 debugAttrib->release(); +00757 }*/ +00758 //_Param.back()->clear(); +00759 _Param.back()->release(); +00760 _Param.pop_back(); +00761 return true; +00762 } +

+

+ + + + +
+ + + + + + + + + +
sint32 NLAISCRIPT::CCompilateur::runMethodConstraint ( ) [protected]
+
+ + + + + +
+ + + +
+ +
+Definition at line 286 of file compilateur.cpp. +
+References _MethodConstraint, errorTypeConstraint(), NLAIC::IPointerGestion::release(), NLAISCRIPT::IConstraint::run(), runTypeConstraint(), NLAISCRIPT::IConstraint::satisfied(), and sint32. +
+Referenced by computContraint(). +
+
00287 { +00288 +00289 +00290 sint32 n = 1; +00291 while(n) +00292 { +00293 std::list<IConstraint *>::iterator i = _MethodConstraint.begin(); +00294 n = 0; +00295 +00296 while(i != _MethodConstraint.end()) +00297 { +00298 IConstraint *c = *i++; +00299 if(!c->satisfied()) +00300 { +00301 c->run(*this); +00302 if(c->satisfied()) n++; +00303 } +00304 } +00305 if(runTypeConstraint()) errorTypeConstraint(); +00306 } +00307 +00308 +00309 std::list<IConstraint *>::iterator j,i = _MethodConstraint.begin(); +00310 n = 0; +00311 while(i != _MethodConstraint.end()) +00312 { +00313 j = i; +00314 i ++; +00315 IConstraint *c = *j; +00316 if( c->satisfied() ) +00317 { +00318 _MethodConstraint.erase(j); +00319 n++; +00320 c->release(); +00321 } +00322 } +00323 return n; +00324 } +

+

+ + + + +
+ + + + + + + + + +
sint32 NLAISCRIPT::CCompilateur::runTypeConstraint ( ) [protected]
+
+ + + + + +
+ + + +
+ +
+Definition at line 260 of file compilateur.cpp. +
+References _ConstraintType, NLAIC::IPointerGestion::release(), NLAISCRIPT::IConstraint::run(), NLAISCRIPT::IConstraint::satisfied(), and sint32. +
+Referenced by runMethodConstraint(). +
+
00261 { +00262 sint32 n = 1; +00263 sint32 did = _ConstraintType.size(); +00264 std::list<IConstraint *>::iterator j,i; +00265 while(n != 0) +00266 { +00267 i = _ConstraintType.begin(); +00268 n = 0; +00269 while(i != _ConstraintType.end()) +00270 { +00271 j = i ++; +00272 IConstraint *c = *j; +00273 c->run(*this); +00274 if( c->satisfied() ) +00275 { +00276 _ConstraintType.erase(j); +00277 n++; +00278 c->release(); +00279 } +00280 } +00281 did -= n; +00282 } +00283 return did; +00284 } +

+

+ + + + +
+ + + + + + + + + + +
void NLAISCRIPT::FlexLexer::set_debug ( int flag ) [inline, inherited]
+
+ + + + + +
+ + + +
+ +
+Definition at line 72 of file lex.h. +
+References NLAISCRIPT::FlexLexer::yy_flex_debug. +
+
00072 { yy_flex_debug = flag; } +

+

+ + + + +
+ + + + + + + + + +
void NLAISCRIPT::CCompilateur::setChaineVar ( ) [protected]
+
+ + + + + +
+ + + +
+ +
+Definition at line 471 of file var_control.cpp. +
+References _FlotingExpressionType, _LastFact, NLAIC::IBasicType::getType(), NLAISCRIPT::CFactorType::IsUsed, NLAIC::IPointerGestion::release(), NLAISCRIPT::CFactorType::Value, NLAISCRIPT::CFactorType::VarType, and NLAISCRIPT::varTypeImediate. +
+
00472 { +00473 if(_LastFact.Value != NULL) +00474 _LastFact.Value->release(); +00475 _LastFact.Value = new NLAIAGENT::CStringType(NLAIAGENT::CStringVarName(LastyyText[1])); +00476 _LastFact.VarType = varTypeImediate; +00477 _LastFact.IsUsed = false; +00478 if(_FlotingExpressionType != NULL) _FlotingExpressionType->release(); +00479 _FlotingExpressionType = new COperandSimple(new NLAIC::CIdentType(_LastFact.Value->getType())); +00480 } +

+

+ + + + +
+ + + + + + + + + + +
void NLAISCRIPT::CCompilateur::setDebugMode ( bool bmode ) [inline]
+
+ + + + + +
+ + + +
+Set the Debug Mode. +
+ +
+Definition at line 407 of file compilateur.h. +
+References _Debug. +
+
00407 { _Debug = bmode;} +

+

+ + + + +
+ + + + + + + + + +
void NLAISCRIPT::CCompilateur::setImediateVar ( ) [protected]
+
+ + + + + +
+ + + +
+ +
+Definition at line 452 of file var_control.cpp. +
+References _FlotingExpressionType, _LastFact, NLAIC::IBasicType::getType(), NLAISCRIPT::CFactorType::IsUsed, NLAIC::IPointerGestion::release(), NLAISCRIPT::CFactorType::Value, NLAISCRIPT::CFactorType::VarType, and NLAISCRIPT::varTypeImediate. +
+
00453 { +00454 if(_LastFact.Value != NULL) +00455 _LastFact.Value->release(); +00456 _LastFact.Value = new NLAIAGENT::DDigitalType(LastyyNum); +00457 _LastFact.VarType = varTypeImediate; +00458 _LastFact.IsUsed = false; +00459 if(_FlotingExpressionType != NULL) _FlotingExpressionType->release(); +00460 _FlotingExpressionType = new COperandSimple(new NLAIC::CIdentType(_LastFact.Value->getType())); +00461 } +

+

+ + + + +
+ + + + + + + + + +
void NLAISCRIPT::CCompilateur::setImediateVarNill ( ) [protected]
+
+ + + + + +
+ + + +
+ +
+Definition at line 439 of file var_control.cpp. +
+References _FlotingExpressionType, _LastFact, NLAIC::IBasicType::getType(), NLAIC::IPointerGestion::incRef(), NLAISCRIPT::CFactorType::IsUsed, NLAIC::IPointerGestion::release(), NLAISCRIPT::CFactorType::Value, NLAISCRIPT::CFactorType::VarType, and NLAISCRIPT::varTypeImediate. +
+
00440 { +00441 if(_LastFact.Value != NULL) +00442 _LastFact.Value->release(); +00443 +00444 _LastFact.Value = &NLAIAGENT::DigitalType::NullOperator; +00445 _LastFact.Value->incRef(); +00446 _LastFact.VarType = varTypeImediate; +00447 _LastFact.IsUsed = false; +00448 if(_FlotingExpressionType != NULL) _FlotingExpressionType->release(); +00449 _FlotingExpressionType = new COperandSimple(new NLAIC::CIdentType(_LastFact.Value->getType())); +00450 } +

+

+ + + + +
+ + + + + + + + + +
void NLAISCRIPT::CCompilateur::setListVar ( ) [protected]
+
+ + + + + +
+ + + +
+ +
+Definition at line 463 of file var_control.cpp. +
+References _FlotingExpressionType, _LastBloc, NLAISCRIPT::IBlock::addCode(), NLAISCRIPT::l, and NLAIC::IPointerGestion::release(). +
+
00464 { +00465 _LastBloc->addCode(new CLdbOpCode (NLAIAGENT::CGroupType())); +00466 NLAIAGENT::CGroupType l; +00467 if(_FlotingExpressionType != NULL) _FlotingExpressionType->release(); +00468 _FlotingExpressionType = new COperandSimple(new NLAIC::CIdentType(l.getType())); +00469 } +

+

+ + + + +
+ + + + + + + + + +
void NLAISCRIPT::CCompilateur::setMethodVar ( ) [protected]
+
+ + + + + +
+ + + +
+ +
+Definition at line 492 of file var_control.cpp. +
+References _FlotingExpressionType, _LastbaseClass, _LastFact, _LastPosHeap, _LastStringParam, _LastTypeCall, _MethodConstraint, _Param, getMethodConstraint(), NLAIC::IPointerGestion::incRef(), NLAISCRIPT::CFactorType::IsUsed, NLAIC::IPointerGestion::release(), NLAISCRIPT::CFactorType::Value, NLAISCRIPT::varForFunc, and NLAISCRIPT::CFactorType::VarType. +
+
00493 { +00494 +00495 #ifdef NL_DEBUG +00496 std::string mName; +00497 std::string pName; +00498 _LastStringParam.back()->getDebugString(mName); +00499 _Param.back()->getDebugString(pName); +00500 #endif +00501 if(_LastFact.Value != NULL) +00502 _LastFact.Value->release(); +00503 _LastFact.Value = NULL; +00504 _LastFact.VarType = varForFunc; +00505 _LastFact.IsUsed = false; +00506 +00507 if(_FlotingExpressionType != NULL) +00508 { +00509 _FlotingExpressionType->release(); +00510 _FlotingExpressionType = NULL; +00511 } +00512 _LastStringParam.back()->incRef(); +00513 _Param.back()->incRef(); +00514 if(_LastbaseClass != NULL)_LastbaseClass->incRef(); +00515 IConstraint *c = getMethodConstraint(CConstraintMethode((CConstraintMethode::TCallTypeOpCode) _LastTypeCall,_LastPosHeap,_LastbaseClass,_LastStringParam.back(),_Param.back(),0,0)); +00516 if(c == NULL) +00517 { +00518 _LastStringParam.back()->incRef(); +00519 _Param.back()->incRef(); +00520 if(_LastbaseClass != NULL)_LastbaseClass->incRef(); +00521 c = new CConstraintMethode((CConstraintMethode::TCallTypeOpCode) _LastTypeCall,_LastPosHeap,_LastbaseClass,_LastStringParam.back(),_Param.back(),yyLine,yyColone); +00522 _MethodConstraint.push_back(c); +00523 } +00524 c->incRef(); +00525 IConstraint *cm = new CConstraintChkMethodeType(c,0,0); +00526 _FlotingExpressionType = new COperandUnknown(cm); +00527 +00528 _LastStringParam.back()->release(); +00529 _LastStringParam.pop_back(); +00530 _Param.back()->release(); +00531 _Param.pop_back(); +00532 #ifdef NL_DEBUG +00533 if(_LastStringParam.size()) _LastStringParam.back()->getDebugString(mName); +00534 if(_Param.size())_Param.back()->getDebugString(pName); +00535 +00536 #endif +00537 } +

+

+ + + + +
+ + + + + + + + + +
void NLAISCRIPT::CCompilateur::setNewLine ( ) [protected, virtual]
+
+ + + + + +
+ + + +
+Tell the _lastBlock about a newLine (for Debug). +
+ +
+Implements NLAISCRIPT::yyFlexLexer. +
+Definition at line 479 of file compilateur.cpp. +
+References _Debug, _LastBloc, NLAISCRIPT::IBlock::setCurrentLine(), and NLAISCRIPT::IBlock::setFirstOpCodeInLine(). +
+Referenced by initMessageManager(). +
+
00480 { +00481 if (_Debug) +00482 { +00483 if (_LastBloc != NULL) +00484 { +00485 _LastBloc->setCurrentLine(yyLine); +00486 _LastBloc->setFirstOpCodeInLine(true); +00487 } +00488 } +00489 } +

+

+ + + + +
+ + + + + + + + + +
bool NLAISCRIPT::CCompilateur::setParamVarName ( ) [protected]
+
+ + + + + +
+ + + +
+ +
+Definition at line 337 of file var_control.cpp. +
+References _Attrib, _BaseObjectDef, _LastBaseObjectDef, _LastString, _Param, getTypeOfClass(), NLAIC::IPointerGestion::incRef(), s, NLAIC::stringGetBuild(), t, TPairType, and yyerror(). +
+
00338 { +00339 try +00340 { +00341 NLAIC::CIdentType idType = getTypeOfClass(_LastString); +00342 NLAIAGENT::IObjectIA *i; +00343 +00344 if(_BaseObjectDef) +00345 { +00346 NLAIC::CIdentType idBase = getTypeOfClass(_LastBaseObjectDef); +00347 COperandSimple *t = new COperandSimple(new NLAIC::CIdentType(idType)); +00348 COperandSimple *b = new COperandSimple(new NLAIC::CIdentType(idBase)); +00349 _Param.back()->push(t); +00350 t->incRef(); +00351 i = new CObjectUnknown(t,b); +00352 } +00353 else +00354 { +00355 COperandSimple *c = new COperandSimple(new NLAIC::CIdentType(idType)); +00356 _Param.back()->push(c); +00357 c->incRef(); +00358 i = new CObjectUnknown(c);//(NLAIAGENT::IObjectIA *)NLAIC::createInstance(id); +00359 } +00360 +00361 NLAIAGENT::IVarName *s = new NLAIAGENT::CStringVarName (LastyyText[1]); +00362 _Attrib.push_back(TPairType(s,i)); +00363 +00364 i->incRef(); +00365 _Heap[(int)_Heap] = i; +00366 _Heap ++; +00367 } +00368 catch(NLAIE::IException &e) +00369 { +00370 std::string text; +00371 text = NLAIC::stringGetBuild("Bad reference or class reference undefined '%s'", e.what()); +00372 yyerror((char *)text.c_str()); +00373 return 0; +00374 } +00375 return true; +00376 +00377 } +

+

+ + + + +
+ + + + + + + + + + +
void NLAISCRIPT::CCompilateur::setPerformative ( NLAIAGENT::IMessageBase::TPerformatif p ) [protected]
+
+ + + + + +
+ + + +
+ +
+Definition at line 401 of file var_control.cpp. +
+References _FlotingExpressionType, _LastFact, NLAIC::IBasicType::getType(), NLAISCRIPT::CFactorType::IsUsed, NLAIC::IPointerGestion::release(), NLAISCRIPT::CFactorType::Value, NLAISCRIPT::CFactorType::VarType, and NLAISCRIPT::varTypeImediate. +
+
00402 { +00403 if(_LastFact.Value != NULL) +00404 _LastFact.Value->release(); +00405 switch(p) +00406 { +00407 case NLAIAGENT::IMessageBase::PExec: +00408 _LastFact.Value = new NLAIAGENT::CPExec(); +00409 break; +00410 case NLAIAGENT::IMessageBase::PAchieve: +00411 _LastFact.Value = new NLAIAGENT::CPAchieve(); +00412 break; +00413 case NLAIAGENT::IMessageBase::PAsk: +00414 _LastFact.Value = new NLAIAGENT::CPAsk(); +00415 break; +00416 case NLAIAGENT::IMessageBase::PBreak: +00417 _LastFact.Value = new NLAIAGENT::CPBreak(); +00418 break; +00419 case NLAIAGENT::IMessageBase::PTell: +00420 _LastFact.Value = new NLAIAGENT::CPTell(); +00421 break; +00422 case NLAIAGENT::IMessageBase::PKill: +00423 _LastFact.Value = new NLAIAGENT::CPKill(); +00424 break; +00425 case NLAIAGENT::IMessageBase::PError: +00426 _LastFact.Value = new NLAIAGENT::CPError(); +00427 break; +00428 case NLAIAGENT::IMessageBase::PEven: +00429 _LastFact.Value = new NLAIAGENT::CPEven(); +00430 break; +00431 default: break; +00432 } +00433 _LastFact.VarType = varTypeImediate; +00434 _LastFact.IsUsed = false; +00435 if(_FlotingExpressionType != NULL) _FlotingExpressionType->release(); +00436 _FlotingExpressionType = new COperandSimple(new NLAIC::CIdentType(_LastFact.Value->getType())); +00437 } +

+

+ + + + +
+ + + + + + + + + + +
void NLAISCRIPT::CCompilateur::setStackVar ( const NLAIC::CIdentType & ) [protected]
+
+ + + + + +
+ + + +
+ +
+Definition at line 482 of file var_control.cpp. +
+References _FlotingExpressionType, _LastFact, NLAISCRIPT::CFactorType::IsUsed, NLAIC::IPointerGestion::release(), type, NLAISCRIPT::CFactorType::Value, NLAISCRIPT::varForFunc, and NLAISCRIPT::CFactorType::VarType. +
+
00483 { +00484 if(_LastFact.Value != NULL) +00485 _LastFact.Value->release(); +00486 _LastFact.VarType = varForFunc; +00487 _LastFact.IsUsed = false; +00488 if(_FlotingExpressionType != NULL) _FlotingExpressionType->release(); +00489 _FlotingExpressionType = new COperandSimple(new NLAIC::CIdentType(type) ); +00490 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NLAISCRIPT::CCompilateur::setTypeExpression ( NLAIC::CTypeOfOperator::TTypeOp op,
const char * txtOp
) [protected]
+
+ + + + + +
+ + + +
+ +
+Definition at line 607 of file var_control.cpp. +
+References _ExpressionType, _FlotingExpressionType, NLAISCRIPT::COperationType::setOp(), and NLAISCRIPT::COperationType::setOperand(). +
+
00608 { +00609 if ( _ExpressionType ) +00610 { +00611 COperationType *gd = new COperationType; +00612 gd->setOperand(_ExpressionType); +00613 gd->setOp(op); +00614 _ExpressionType = gd; +00615 } +00616 else +00617 { +00618 _ExpressionType = new COperationType; +00619 ((COperationType *)_ExpressionType)->setOperand(_FlotingExpressionType); +00620 ((COperationType *)_ExpressionType)->setOp(op); +00621 _FlotingExpressionType = NULL; +00622 } +00623 } +

+

+ + + + +
+ + + + + + + + + +
void NLAISCRIPT::CCompilateur::setTypeExpression ( ) [protected]
+
+ + + + + +
+ + + +
+ +
+Definition at line 593 of file var_control.cpp. +
+References _ExpressionType, and _FlotingExpressionType. +
+
00594 { +00595 if(_ExpressionType) +00596 { +00597 COperandUnknown *gd = new COperandUnknown(_ExpressionType); +00598 _ExpressionType = gd; +00599 } +00600 else +00601 { +00602 _ExpressionType = new COperandUnknown(_FlotingExpressionType); +00603 _FlotingExpressionType = NULL; +00604 } +00605 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NLAISCRIPT::CCompilateur::setTypeExpressionD ( NLAIC::CTypeOfOperator::TTypeOp op,
const char * txtOp
) [protected]
+
+ + + + + +
+ + + +
+ +
+Definition at line 643 of file var_control.cpp. +
+References _ExpressionOp, _ExpressionType, and _FlotingExpressionType. +
+
00644 { +00645 if(_ExpressionType != NULL && _FlotingExpressionType == NULL) _FlotingExpressionType = _ExpressionType; +00646 //else if(_ExpressionType == NULL && _FlotingExpressionType != NULL) _FlotingExpressionType = _ExpressionType; +00647 _ExpressionType = _ExpressionOp.back(); +00648 _ExpressionOp.pop_back(); +00649 +00650 ((COperationTypeGD *)_ExpressionType)->setOperationD(_FlotingExpressionType); +00651 ((COperationTypeGD *)_ExpressionType)->setOp(op); +00652 _FlotingExpressionType = NULL; +00653 } +

+

+ + + + +
+ + + + + + + + + +
void NLAISCRIPT::CCompilateur::setTypeExpressionG ( ) [protected]
+
+ + + + + +
+ + + +
+ +
+Definition at line 625 of file var_control.cpp. +
+References _ExpressionOp, _ExpressionType, _FlotingExpressionType, and NLAISCRIPT::COperationTypeGD::setOperationG(). +
+
00626 { +00627 if(_ExpressionType) +00628 { +00629 COperationTypeGD *gd = new COperationTypeGD; +00630 gd->setOperationG(_ExpressionType); +00631 _ExpressionType = gd; +00632 } +00633 else +00634 { +00635 _ExpressionType = new COperationTypeGD; +00636 ((COperationTypeGD *)_ExpressionType)->setOperationG(_FlotingExpressionType); +00637 _FlotingExpressionType = NULL; +00638 } +00639 _ExpressionOp.push_back(_ExpressionType); +00640 _ExpressionType = NULL; +00641 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void yyFlexLexer::switch_streams ( istream * new_in,
ostream * new_out
) [virtual, inherited]
+
+ + + + + +
+ + + +
+ +
+Implements NLAISCRIPT::FlexLexer. +
+Definition at line 2796 of file lexlang.cpp. +
+References YY_BUF_SIZE, NLAISCRIPT::yyFlexLexer::yy_create_buffer(), NLAISCRIPT::yyFlexLexer::yy_current_buffer, NLAISCRIPT::yyFlexLexer::yy_delete_buffer(), NLAISCRIPT::yyFlexLexer::yy_switch_to_buffer(), and NLAISCRIPT::yyFlexLexer::yyout. +
+
02797 { +02798 if ( new_in ) +02799 { +02800 yy_delete_buffer( yy_current_buffer ); +02801 yy_switch_to_buffer( yy_create_buffer( new_in, YY_BUF_SIZE ) ); +02802 } +02803 +02804 if ( new_out ) +02805 yyout = new_out; +02806 } +

+

+ + + + +
+ + + + + + + + + +
sint32 NLAISCRIPT::CCompilateur::typeOfMethod ( ) [protected]
+
+ + + + + +
+ + + +
+ +
+Definition at line 765 of file yacc.cpp. +
+References _ConstraintType, _ExpressionType, _IsVoid, _SelfClass, NLAISCRIPT::COperandListType::add(), NLAIAGENT::CGroupType::get(), NLAISCRIPT::IConstraint::getTypeOfClass(), haveReturn, NLAIC::IPointerGestion::incRef(), NLAISCRIPT::COperandListType::satisfied(), NLAISCRIPT::IConstraint::satisfied(), and sint32. +
+
00766 { +00767 +00768 const IOpType *a; +00769 if((a = ((IClassInterpret *)_SelfClass.get())->getBrancheCode().getTypeOfMethode()) == NULL) +00770 { +00771 ((IClassInterpret *)_SelfClass.get())->getBrancheCode().setTypeOfMethode(_ExpressionType); +00772 if(!_ExpressionType->satisfied()) +00773 { +00774 _ConstraintType.push_back(_ExpressionType); +00775 _ExpressionType->incRef(); +00776 } +00777 haveReturn = true; +00778 } +00779 else +00780 { +00781 if(a->getTypeOfClass() == IConstraint::operandListType) +00782 { +00783 ((COperandListType *)a)->add(_ExpressionType); +00784 } +00785 else +00786 { +00787 COperandListType *c = new COperandListType(); +00788 ((IOpType *)a)->incRef(); +00789 c->add((IOpType *)a); +00790 c->add(_ExpressionType); +00791 ((IClassInterpret *)_SelfClass.get())->getBrancheCode().setTypeOfMethode(c); +00792 if(!c->satisfied()) +00793 { +00794 c->incRef(); +00795 _ConstraintType.push_back(c); +00796 } +00797 haveReturn = true; +00798 } +00799 } +00800 _ExpressionType = NULL; +00801 _IsVoid = false; +00802 return true; +00803 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
const NLAIAGENT::IObjectIA * NLAISCRIPT::CCompilateur::validateHierarchyMethode ( std::list< sint32 > & ,
sint32 & ,
const NLAIAGENT::IObjectIA * ,
NLAIAGENT::IBaseGroupType & listName
)
+
+ + + + + +
+ + + +
+ +
+Definition at line 245 of file compilateur.cpp. +
+References NLAIAGENT::IBaseGroupType::getIterator(), NLAIAGENT::CStringType::getStr(), getValidateHierarchyBase(), NLAIAGENT::CConstIteratorContener::isInEnd(), and sint32. +
+Referenced by findMethode(), and NLAISCRIPT::CConstraintFindRun::run(). +
+
00246 { +00247 std::list<NLAISCRIPT::CStringType> listClassName; +00248 +00249 NLAIAGENT::CIteratorContener it = listName.getIterator(); +00250 +00251 while(!it.isInEnd()) +00252 { +00253 NLAIAGENT::CStringType &name = *((NLAIAGENT::CStringType *)it++); +00254 listClassName.push_back(name.getStr().getString()); +00255 } +00256 listClassName.pop_back(); +00257 return getValidateHierarchyBase(classType,listH,h,listClassName); +00258 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
YY_BUFFER_STATE yyFlexLexer::yy_create_buffer ( istream * s,
int size
) [virtual, inherited]
+
+ + + + + +
+ + + +
+ +
+Implements NLAISCRIPT::FlexLexer. +
+Definition at line 3180 of file lexlang.cpp. +
+References file, size, yy_buffer_state::yy_buf_size, YY_BUFFER_STATE, yy_buffer_state::yy_ch_buf, YY_FATAL_ERROR, yy_flex_alloc(), NLAISCRIPT::yyFlexLexer::yy_init_buffer(), and yy_buffer_state::yy_is_our_buffer. +
+Referenced by NLAISCRIPT::yyFlexLexer::switch_streams(), and NLAISCRIPT::yyFlexLexer::yyrestart(). +
+
03181 { +03182 YY_BUFFER_STATE b; +03183 +03184 b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); +03185 if ( ! b ) +03186 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); +03187 +03188 b->yy_buf_size = size; +03189 +03190 /* yy_ch_buf has to be 2 characters longer than the size given because +03191 * we need to put in 2 end-of-buffer characters. +03192 */ +03193 b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 ); +03194 if ( ! b->yy_ch_buf ) +03195 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); +03196 +03197 b->yy_is_our_buffer = 1; +03198 +03199 yy_init_buffer( b, file ); +03200 +03201 return b; +03202 } +

+

+ + + + +
+ + + + + + + + + + +
void NLAISCRIPT::yyFlexLexer::yy_delete_buffer ( struct yy_buffer_state * b ) [virtual, inherited]
+
+ + + + + +
+ + + +
+ +
+Implements NLAISCRIPT::FlexLexer. +
+Referenced by NLAISCRIPT::yyFlexLexer::switch_streams(), and NLAISCRIPT::yyFlexLexer::~yyFlexLexer().
+

+ + + + +
+ + + + + + + + + + +
void NLAISCRIPT::yyFlexLexer::yy_flush_buffer ( struct yy_buffer_state * b ) [protected, inherited]
+
+ + + + + +
+ + + +
+
+

+ + + + +
+ + + + + + + + + +
int yyFlexLexer::yy_get_next_buffer ( ) [protected, inherited]
+
+ + + + + +
+ + + +
+ +
+Definition at line 2851 of file lexlang.cpp. +
+References EOB_ACT_CONTINUE_SCAN, EOB_ACT_END_OF_FILE, EOB_ACT_LAST_MATCH, yy_buffer_state::yy_buf_size, YY_BUFFER_EOF_PENDING, YY_BUFFER_STATE, yy_buffer_state::yy_buffer_status, NLAISCRIPT::yyFlexLexer::yy_c_buf_p, yy_buffer_state::yy_ch_buf, NLAISCRIPT::yyFlexLexer::yy_current_buffer, YY_END_OF_BUFFER_CHAR, YY_FATAL_ERROR, yy_buffer_state::yy_fill_buffer, yy_flex_realloc(), YY_INPUT, yy_buffer_state::yy_is_our_buffer, YY_MORE_ADJ, YY_READ_BUF_SIZE, NLAISCRIPT::yyFlexLexer::yyin, NLAISCRIPT::yyFlexLexer::yyrestart(), and yytext_ptr. +
+Referenced by NLAISCRIPT::yyFlexLexer::yyinput(). +
+
02852 { +02853 register char *dest = yy_current_buffer->yy_ch_buf; +02854 register char *source = yytext_ptr; +02855 register int number_to_move, i; +02856 int ret_val; +02857 +02858 if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] ) +02859 YY_FATAL_ERROR( +02860 "fatal flex scanner internal error--end of buffer missed" ); +02861 +02862 if ( yy_current_buffer->yy_fill_buffer == 0 ) +02863 { /* Don't try to fill the buffer, so this is an EOF. */ +02864 if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 ) +02865 { +02866 /* We matched a singled characater, the EOB, so +02867 * treat this as a final EOF. +02868 */ +02869 return EOB_ACT_END_OF_FILE; +02870 } +02871 +02872 else +02873 { +02874 /* We matched some text prior to the EOB, first +02875 * process it. +02876 */ +02877 return EOB_ACT_LAST_MATCH; +02878 } +02879 } +02880 +02881 /* Try to read more data. */ +02882 +02883 /* First move last chars to start of buffer. */ +02884 number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1; +02885 +02886 for ( i = 0; i < number_to_move; ++i ) +02887 *(dest++) = *(source++); +02888 +02889 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING ) +02890 /* don't do the read, it's not guaranteed to return an EOF, +02891 * just force an EOF +02892 */ +02893 yy_n_chars = 0; +02894 +02895 else +02896 { +02897 int num_to_read = +02898 yy_current_buffer->yy_buf_size - number_to_move - 1; +02899 +02900 while ( num_to_read <= 0 ) +02901 { /* Not enough room in the buffer - grow it. */ +02902 #ifdef YY_USES_REJECT +02903 YY_FATAL_ERROR( +02904 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" ); +02905 #else +02906 +02907 /* just a shorter name for the current buffer */ +02908 YY_BUFFER_STATE b = yy_current_buffer; +02909 +02910 int yy_c_buf_p_offset = +02911 (int) (yy_c_buf_p - b->yy_ch_buf); +02912 +02913 if ( b->yy_is_our_buffer ) +02914 { +02915 int new_size = b->yy_buf_size * 2; +02916 +02917 if ( new_size <= 0 ) +02918 b->yy_buf_size += b->yy_buf_size / 8; +02919 else +02920 b->yy_buf_size *= 2; +02921 +02922 b->yy_ch_buf = (char *) +02923 /* Include room in for 2 EOB chars. */ +02924 yy_flex_realloc( (void *) b->yy_ch_buf, +02925 b->yy_buf_size + 2 ); +02926 } +02927 else +02928 /* Can't grow it, we don't own it. */ +02929 b->yy_ch_buf = 0; +02930 +02931 if ( ! b->yy_ch_buf ) +02932 YY_FATAL_ERROR( +02933 "fatal error - scanner input buffer overflow" ); +02934 +02935 yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset]; +02936 +02937 num_to_read = yy_current_buffer->yy_buf_size - +02938 number_to_move - 1; +02939 #endif +02940 } +02941 +02942 if ( num_to_read > YY_READ_BUF_SIZE ) +02943 num_to_read = YY_READ_BUF_SIZE; +02944 +02945 /* Read in more data. */ +02946 YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]), +02947 yy_n_chars, num_to_read ); +02948 } +02949 +02950 if ( yy_n_chars == 0 ) +02951 { +02952 if ( number_to_move == YY_MORE_ADJ ) +02953 { +02954 ret_val = EOB_ACT_END_OF_FILE; +02955 yyrestart( yyin ); +02956 } +02957 +02958 else +02959 { +02960 ret_val = EOB_ACT_LAST_MATCH; +02961 yy_current_buffer->yy_buffer_status = +02962 YY_BUFFER_EOF_PENDING; +02963 } +02964 } +02965 +02966 else +02967 ret_val = EOB_ACT_CONTINUE_SCAN; +02968 +02969 yy_n_chars += number_to_move; +02970 yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR; +02971 yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; +02972 +02973 yytext_ptr = &yy_current_buffer->yy_ch_buf[0]; +02974 +02975 return ret_val; +02976 } +

+

+ + + + +
+ + + + + + + + + +
yy_state_type yyFlexLexer::yy_get_previous_state ( ) [protected, inherited]
+
+ + + + + +
+ + + +
+ +
+Definition at line 2981 of file lexlang.cpp. +
+References yy_accept, NLAISCRIPT::yyFlexLexer::yy_c_buf_p, NLAISCRIPT::yyFlexLexer::yy_last_accepting_cpos, NLAISCRIPT::yyFlexLexer::yy_last_accepting_state, YY_MORE_ADJ, yy_NUL_trans, yy_nxt, YY_SC_TO_UI, NLAISCRIPT::yyFlexLexer::yy_start, yy_state_type, and yytext_ptr. +
+
02982 { +02983 register yy_state_type yy_current_state; +02984 register char *yy_cp; +02985 +02986 yy_current_state = yy_start; +02987 +02988 for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp ) +02989 { +02990 if ( *yy_cp ) +02991 { +02992 yy_current_state = yy_nxt[yy_current_state][YY_SC_TO_UI(*yy_cp)]; +02993 } +02994 else +02995 yy_current_state = yy_NUL_trans[yy_current_state]; +02996 if ( yy_accept[yy_current_state] ) +02997 { +02998 yy_last_accepting_state = yy_current_state; +02999 yy_last_accepting_cpos = yy_cp; +03000 } +03001 } +03002 +03003 return yy_current_state; +03004 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NLAISCRIPT::yyFlexLexer::yy_init_buffer ( struct yy_buffer_state * b,
istream * s
) [protected, inherited]
+
+ + + + + +
+ + + +
+ +
+Referenced by NLAISCRIPT::yyFlexLexer::yy_create_buffer(), and NLAISCRIPT::yyFlexLexer::yyrestart().
+

+ + + + +
+ + + + + + + + + +
void yyFlexLexer::yy_load_buffer_state ( ) [protected, inherited]
+
+ + + + + +
+ + + +
+ +
+Definition at line 3171 of file lexlang.cpp. +
+References yy_buffer_state::yy_buf_pos, NLAISCRIPT::yyFlexLexer::yy_c_buf_p, NLAISCRIPT::yyFlexLexer::yy_current_buffer, NLAISCRIPT::yyFlexLexer::yy_hold_char, yy_buffer_state::yy_input_file, yy_buffer_state::yy_n_chars, NLAISCRIPT::yyFlexLexer::yyin, and yytext_ptr. +
+Referenced by NLAISCRIPT::yyFlexLexer::yyrestart(). +
+
03172 { +03173 yy_n_chars = yy_current_buffer->yy_n_chars; +03174 yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos; +03175 yyin = yy_current_buffer->yy_input_file; +03176 yy_hold_char = *yy_c_buf_p; +03177 } +

+

+ + + + +
+ + + + + + + + + +
void NLAISCRIPT::yyFlexLexer::yy_pop_state ( ) [protected, inherited]
+
+ + + + + +
+ + + +
+
+

+ + + + +
+ + + + + + + + + + +
void NLAISCRIPT::yyFlexLexer::yy_push_state ( int new_state ) [protected, inherited]
+
+ + + + + +
+ + + +
+
+

+ + + + +
+ + + + + + + + + + +
void NLAISCRIPT::yyFlexLexer::yy_switch_to_buffer ( struct yy_buffer_state * new_buffer ) [virtual, inherited]
+
+ + + + + +
+ + + +
+ +
+Implements NLAISCRIPT::FlexLexer. +
+Referenced by NLAISCRIPT::yyFlexLexer::switch_streams().
+

+ + + + +
+ + + + + + + + + +
int NLAISCRIPT::yyFlexLexer::yy_top_state ( ) [protected, inherited]
+
+ + + + + +
+ + + +
+
+

+ + + + +
+ + + + + + + + + + +
yy_state_type yyFlexLexer::yy_try_NUL_trans ( yy_state_type current_state ) [protected, inherited]
+
+ + + + + +
+ + + +
+ +
+Definition at line 3013 of file lexlang.cpp. +
+References yy_accept, NLAISCRIPT::yyFlexLexer::yy_c_buf_p, NLAISCRIPT::yyFlexLexer::yy_last_accepting_cpos, NLAISCRIPT::yyFlexLexer::yy_last_accepting_state, yy_NUL_trans, and yy_state_type. +
+
03014 { +03015 register int yy_is_jam; +03016 register char *yy_cp = yy_c_buf_p; +03017 +03018 yy_current_state = yy_NUL_trans[yy_current_state]; +03019 yy_is_jam = (yy_current_state == 0); +03020 +03021 if ( ! yy_is_jam ) +03022 { +03023 if ( yy_accept[yy_current_state] ) +03024 { +03025 yy_last_accepting_state = yy_current_state; +03026 yy_last_accepting_cpos = yy_cp; +03027 } +03028 } +03029 +03030 return yy_is_jam ? 0 : yy_current_state; +03031 } +

+

+ + + + +
+ + + + + + + + + + +
void NLAISCRIPT::CCompilateur::yyerror ( char * Er ) [inline]
+
+ + + + + +
+ + + +
+Occur when there are a parse error. +
+ +
+Definition at line 363 of file compilateur.h. +
+References _Error, _Iterface, and NLAIC::IIO::Echo(). +
+Referenced by affectation(), affectationMember(), buildObject(), caseRunMsg(), castVariable(), computContraint(), errorMethodConstraint(), getValidateHierarchyBase(), processingVar(), registerMethod(), and setParamVarName(). +
+
00364 { +00365 +00366 _Iterface.Echo("%s at line %d et colone %d\n",Er,yyLine,yyColone); +00367 +00368 //_StreamBuffer->close(); +00369 _Error = true; +00370 //yyclearin; +00371 } +

+

+ + + + +
+ + + + + + + + + +
int yyFlexLexer::yyinput ( ) [protected, inherited]
+
+ + + + + +
+ + + +
+ +
+Definition at line 3070 of file lexlang.cpp. +
+References EOB_ACT_CONTINUE_SCAN, EOB_ACT_END_OF_FILE, EOB_ACT_LAST_MATCH, input(), NLAISCRIPT::yyFlexLexer::yy_c_buf_p, yy_buffer_state::yy_ch_buf, NLAISCRIPT::yyFlexLexer::yy_current_buffer, NLAISCRIPT::yyFlexLexer::yy_did_buffer_switch_on_eof, YY_END_OF_BUFFER_CHAR, YY_FATAL_ERROR, NLAISCRIPT::yyFlexLexer::yy_get_next_buffer(), NLAISCRIPT::yyFlexLexer::yy_hold_char, YY_MORE_ADJ, YY_NEW_FILE, yytext_ptr, and NLAISCRIPT::yyFlexLexer::yywrap(). +
+
03071 { +03072 int c; +03073 +03074 *yy_c_buf_p = yy_hold_char; +03075 +03076 if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR ) +03077 { +03078 /* yy_c_buf_p now points to the character we want to return. +03079 * If this occurs *before* the EOB characters, then it's a +03080 * valid NUL; if not, then we've hit the end of the buffer. +03081 */ +03082 if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] ) +03083 /* This was really a NUL. */ +03084 *yy_c_buf_p = '\0'; +03085 +03086 else +03087 { /* need more input */ +03088 yytext_ptr = yy_c_buf_p; +03089 ++yy_c_buf_p; +03090 +03091 switch ( yy_get_next_buffer() ) +03092 { +03093 case EOB_ACT_END_OF_FILE: +03094 { +03095 if ( yywrap() ) +03096 { +03097 yy_c_buf_p = +03098 yytext_ptr + YY_MORE_ADJ; +03099 return EOF; +03100 } +03101 +03102 if ( ! yy_did_buffer_switch_on_eof ) +03103 YY_NEW_FILE; +03104 #ifdef __cplusplus +03105 return yyinput(); +03106 #else +03107 return input(); +03108 #endif +03109 } +03110 +03111 case EOB_ACT_CONTINUE_SCAN: +03112 yy_c_buf_p = yytext_ptr + YY_MORE_ADJ; +03113 break; +03114 +03115 case EOB_ACT_LAST_MATCH: +03116 #ifdef __cplusplus +03117 YY_FATAL_ERROR( +03118 "unexpected last match in yyinput()" ); +03119 #else +03120 YY_FATAL_ERROR( +03121 "unexpected last match in input()" ); +03122 #endif +03123 } +03124 } +03125 } +03126 +03127 c = *(unsigned char *) yy_c_buf_p; /* cast for 8-bit char's */ +03128 *yy_c_buf_p = '\0'; /* preserve yytext */ +03129 yy_hold_char = *++yy_c_buf_p; +03130 +03131 +03132 return c; +03133 } +

+

+ + + + +
+ + + + + + + + + +
int NLAISCRIPT::FlexLexer::YYLeng ( ) [inline, inherited]
+
+ + + + + +
+ + + +
+ +
+Definition at line 46 of file lex.h. +
+References NLAISCRIPT::FlexLexer::yyleng. +
+
00046 { return yyleng; } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
int NLAISCRIPT::FlexLexer::yylex ( istream * new_in,
ostream * new_out = 0
) [inline, inherited]
+
+ + + + + +
+ + + +
+ +
+Definition at line 58 of file lex.h. +
+References NLAISCRIPT::FlexLexer::switch_streams(), and NLAISCRIPT::FlexLexer::yylex(). +
+
00059 { +00060 switch_streams( new_in, new_out ); +00061 return yylex(); +00062 } +

+

+ + + + +
+ + + + + + + + + +
int yyFlexLexer::yylex ( ) [virtual, inherited]
+
+ + + + + +
+ + + +
+ +
+Implements NLAISCRIPT::FlexLexer. +
+Definition at line 1985 of file lexlang.cpp. +
+References ACCOL_D, ACCOL_G, AND_BIN, AND_LOG, CHAINE, CROCHER_D, CROCHER_G, DIFF, DIV, ECHO, EG_LOG, EG_MATH, EOB_ACT_CONTINUE_SCAN, EOB_ACT_END_OF_FILE, EOB_ACT_LAST_MATCH, FOIS, NLAISCRIPT::GetIdentType(), NLAISCRIPT::GetNombre(), INF, INF_EG, INITIAL, INTERROGATION, LEPOINT, MOINS, NOMBRE, NON_BIN, OR_BIN, OR_LOG, PAR_D, PAR_G, PLUS, POINT_DEUX, POINT_VI, POWER, SCOP, SUP, SUP_EG, unput, VIRGULE, yy_accept, YY_BREAK, YY_BUF_SIZE, YY_BUFFER_NEW, YY_BUFFER_NORMAL, yy_create_buffer, YY_DECL, YY_DO_BEFORE_ACTION, YY_END_OF_BUFFER, YY_FATAL_ERROR, yy_get_next_buffer(), yy_get_previous_state(), yy_load_buffer_state, YY_MORE_ADJ, YY_NEW_FILE, yy_nxt, YY_RULE_SETUP, YY_SC_TO_UI, YY_START, YY_STATE_EOF, yy_state_type, yy_try_NUL_trans(), yyin, yyout, yyterminate, yytext, yytext_ptr, and yywrap. +
+Referenced by Compile(). +
+
01986 { +01987 register yy_state_type yy_current_state; +01988 register char *yy_cp, *yy_bp; +01989 register int yy_act; +01990 +01991 #line 25 "lexicon.lex" +01992 +01993 #line 1994 "lexyy.cc" +01994 +01995 if ( yy_init ) +01996 { +01997 yy_init = 0; +01998 +01999 #ifdef YY_USER_INIT +02000 YY_USER_INIT; +02001 #endif +02002 +02003 if ( ! yy_start ) +02004 yy_start = 1; /* first start state */ +02005 +02006 if ( ! yyin ) +02007 yyin = &cin; +02008 +02009 if ( ! yyout ) +02010 yyout = &cout; +02011 +02012 if ( ! yy_current_buffer ) +02013 yy_current_buffer = +02014 yy_create_buffer( yyin, YY_BUF_SIZE ); +02015 +02016 yy_load_buffer_state(); +02017 } +02018 +02019 while ( 1 ) /* loops until end-of-file is reached */ +02020 { +02021 yy_cp = yy_c_buf_p; +02022 +02023 /* Support of yytext. */ +02024 *yy_cp = yy_hold_char; +02025 +02026 /* yy_bp points to the position in yy_ch_buf of the start of +02027 * the current run. +02028 */ +02029 yy_bp = yy_cp; +02030 +02031 yy_current_state = yy_start; +02032 yy_match: +02033 while ( (yy_current_state = yy_nxt[yy_current_state][YY_SC_TO_UI(*yy_cp)]) > 0 ) +02034 { +02035 if ( yy_accept[yy_current_state] ) +02036 { +02037 yy_last_accepting_state = yy_current_state; +02038 yy_last_accepting_cpos = yy_cp; +02039 } +02040 +02041 ++yy_cp; +02042 } +02043 +02044 yy_current_state = -yy_current_state; +02045 +02046 yy_find_action: +02047 yy_act = yy_accept[yy_current_state]; +02048 +02049 YY_DO_BEFORE_ACTION; +02050 +02051 +02052 do_action: /* This label is used only to access EOF actions. */ +02053 +02054 +02055 switch ( yy_act ) +02056 { /* beginning of action switch */ +02057 case 0: /* must back up */ +02058 /* undo the effects of YY_DO_BEFORE_ACTION */ +02059 *yy_cp = yy_hold_char; +02060 yy_cp = yy_last_accepting_cpos + 1; +02061 yy_current_state = yy_last_accepting_state; +02062 goto yy_find_action; +02063 +02064 case 1: +02065 YY_RULE_SETUP +02066 #line 26 "lexicon.lex" +02067 { +02068 /*On ignore les espasement*/ +02069 yyColone += 5; +02070 } +02071 YY_BREAK +02072 case 2: +02073 YY_RULE_SETUP +02074 #line 30 "lexicon.lex" +02075 { +02076 /*On ignore les espasement*/ +02077 yyColone ++; +02078 } +02079 YY_BREAK +02080 case 3: +02081 YY_RULE_SETUP +02082 #line 35 "lexicon.lex" +02083 { +02084 /*On ignore les espasement*/ +02085 yyLine ++; +02086 yyColone = 0; +02087 setNewLine(); +02088 } +02089 YY_BREAK +02090 case 4: +02091 YY_RULE_SETUP +02092 #line 42 "lexicon.lex" +02093 { +02094 strcpy(LastyyText[0], LastyyText[1]); +02095 strcpy(LastyyText[1], yytext); +02096 LastyyNum = NLAISCRIPT::GetNombre(LastyyText[1],2); +02097 yyColone += strlen(yytext); +02098 return NOMBRE; +02099 } +02100 YY_BREAK +02101 case 5: +02102 YY_RULE_SETUP +02103 #line 50 "lexicon.lex" +02104 { +02105 strcpy(LastyyText[0], LastyyText[1]); +02106 strcpy(LastyyText[1], yytext); +02107 LastyyNum = NLAISCRIPT::GetNombre(LastyyText[1],10); +02108 yyColone += strlen(yytext); +02109 return NOMBRE; +02110 } +02111 YY_BREAK +02112 case 6: +02113 YY_RULE_SETUP +02114 #line 57 "lexicon.lex" +02115 { +02116 strcpy(LastyyText[0], LastyyText[1]); +02117 strcpy(LastyyText[1], yytext); +02118 LastyyNum = NLAISCRIPT::GetNombre(LastyyText[1],16); +02119 yyColone += strlen(yytext); +02120 return NOMBRE; +02121 } +02122 YY_BREAK +02123 case 7: +02124 YY_RULE_SETUP +02125 #line 65 "lexicon.lex" +02126 { +02127 strcpy(LastyyText[0], LastyyText[1]); +02128 strcpy(LastyyText[1], yytext); +02129 LastyyNum = NLAISCRIPT::GetNombre(LastyyText[1],0); +02130 yyColone += strlen(yytext); +02131 return NOMBRE; +02132 } +02133 YY_BREAK +02134 case 8: +02135 YY_RULE_SETUP +02136 #line 73 "lexicon.lex" +02137 { +02138 strcpy(LastyyText[0], LastyyText[1]); +02139 strcpy(LastyyText[1], yytext); +02140 LastyyNum = NLAISCRIPT::GetNombre(LastyyText[1],0); +02141 yyColone += strlen(yytext); +02142 return NOMBRE; +02143 } +02144 YY_BREAK +02145 case 9: +02146 YY_RULE_SETUP +02147 #line 81 "lexicon.lex" +02148 { +02149 strcpy(LastyyText[0], LastyyText[1]); +02150 strcpy(LastyyText[1], yytext); +02151 LastyyNum = NLAISCRIPT::GetNombre(LastyyText[1],0); +02152 yyColone += strlen(yytext); +02153 return NOMBRE; +02154 } +02155 YY_BREAK +02156 case 10: +02157 YY_RULE_SETUP +02158 #line 89 "lexicon.lex" +02159 { +02160 strcpy(LastyyText[0], LastyyText[1]); +02161 strcpy(LastyyText[1], yytext); +02162 yyColone += strlen(yytext); +02163 int i = NLAISCRIPT::GetIdentType(yytext); +02164 return i; +02165 +02166 } +02167 YY_BREAK +02168 case 11: +02169 YY_RULE_SETUP +02170 #line 98 "lexicon.lex" +02171 { +02172 yyColone ++; +02173 return LEPOINT; +02174 } +02175 YY_BREAK +02176 case 12: +02177 YY_RULE_SETUP +02178 #line 103 "lexicon.lex" +02179 { +02180 yyColone ++; +02181 return PAR_G; +02182 } +02183 YY_BREAK +02184 case 13: +02185 YY_RULE_SETUP +02186 #line 108 "lexicon.lex" +02187 { +02188 yyColone ++; +02189 return PAR_D; +02190 } +02191 YY_BREAK +02192 case 14: +02193 YY_RULE_SETUP +02194 #line 113 "lexicon.lex" +02195 { +02196 yyColone ++; +02197 int C = yyinput(); +02198 if(C == '=') +02199 { +02200 yyColone ++; +02201 return EG_LOG; +02202 } +02203 else +02204 { +02205 unput(C); +02206 yytext[1] = 0; +02207 } +02208 return EG_MATH; +02209 } +02210 YY_BREAK +02211 case 15: +02212 YY_RULE_SETUP +02213 #line 129 "lexicon.lex" +02214 { +02215 yyColone ++; +02216 int C = yyinput(); +02217 if(C == '=') +02218 { +02219 yyColone ++; +02220 return SUP_EG; +02221 } +02222 else +02223 { +02224 unput(C); +02225 yytext[1] = 0; +02226 } +02227 return SUP; +02228 } +02229 YY_BREAK +02230 case 16: +02231 YY_RULE_SETUP +02232 #line 145 "lexicon.lex" +02233 { +02234 yyColone ++; +02235 int C = yyinput(); +02236 if(C == '=') +02237 { +02238 yyColone ++; +02239 return INF_EG; +02240 } +02241 else +02242 { +02243 unput(C); +02244 yytext[1] = 0; +02245 } +02246 return INF; +02247 } +02248 YY_BREAK +02249 case 17: +02250 YY_RULE_SETUP +02251 #line 162 "lexicon.lex" +02252 { +02253 yyColone ++; +02254 int C = yyinput(); +02255 if(C == '=') +02256 { +02257 yyColone ++; +02258 return DIFF; +02259 } +02260 else +02261 { +02262 unput(C); +02263 yytext[1] = 0; +02264 } +02265 return NON_BIN; +02266 } +02267 YY_BREAK +02268 case 18: +02269 YY_RULE_SETUP +02270 #line 178 "lexicon.lex" +02271 { +02272 yyColone ++; +02273 int C = yyinput(); +02274 if(C == '|') +02275 { +02276 yyColone ++; +02277 return OR_LOG; +02278 } +02279 else +02280 { +02281 unput(C); +02282 yytext[1] = 0; +02283 } +02284 return OR_BIN; +02285 } +02286 YY_BREAK +02287 case 19: +02288 YY_RULE_SETUP +02289 #line 194 "lexicon.lex" +02290 { +02291 yyColone ++; +02292 int C = yyinput(); +02293 if(C == '&') +02294 { +02295 yyColone ++; +02296 return AND_LOG; +02297 } +02298 else +02299 { +02300 unput(C); +02301 yytext[1] = 0; +02302 } +02303 return AND_BIN; +02304 } +02305 YY_BREAK +02306 case 20: +02307 YY_RULE_SETUP +02308 #line 211 "lexicon.lex" +02309 { +02310 yyColone ++; +02311 return PLUS; +02312 } +02313 YY_BREAK +02314 case 21: +02315 YY_RULE_SETUP +02316 #line 216 "lexicon.lex" +02317 { +02318 yyColone ++; +02319 return MOINS; +02320 } +02321 YY_BREAK +02322 case 22: +02323 YY_RULE_SETUP +02324 #line 221 "lexicon.lex" +02325 { +02326 yyColone ++; +02327 return FOIS; +02328 } +02329 YY_BREAK +02330 case 23: +02331 YY_RULE_SETUP +02332 #line 226 "lexicon.lex" +02333 { +02334 yyColone ++; +02335 +02336 int C = yyinput(); +02337 if(C == '*') +02338 { +02339 yyColone ++; +02340 int NbrCom = 1; +02341 int BeginDebut = 0; +02342 int BeginFin = 0; +02343 #ifdef _DEBUG +02344 char DebugStr[2]; +02345 DebugStr[1] = 0; +02346 #endif +02347 while(1) +02348 { +02349 C = yyinput(); +02350 #ifdef _DEBUG +02351 DebugStr[0] = C; +02352 #endif +02353 yyColone ++; +02354 if(C == '\n') +02355 { +02356 yyLine ++; +02357 yyColone = 0; +02358 setNewLine(); +02359 continue; +02360 } +02361 if(C == '*' ) +02362 { +02363 yyColone ++; +02364 C = yyinput(); +02365 #ifdef _DEBUG +02366 DebugStr[0] = C; +02367 #endif +02368 if(C == '/') +02369 { +02370 yyColone ++; +02371 yytext[1] = 0; +02372 NbrCom --; +02373 if(!NbrCom) break; +02374 } +02375 else +02376 { +02377 unput(C); +02378 } +02379 } +02380 else +02381 if(C == '/') +02382 { +02383 yyColone ++; +02384 C = yyinput(); +02385 #ifdef _DEBUG +02386 DebugStr[0] = C; +02387 #endif +02388 if(C == '*') +02389 { +02390 yyColone ++; +02391 NbrCom ++; +02392 } +02393 else +02394 { +02395 unput(C); +02396 +02397 } +02398 } +02399 +02400 } +02401 } +02402 else +02403 if(C == '/') +02404 { +02405 yyColone ++; +02406 #ifdef _DEBUG +02407 char DebugStr[2]; +02408 DebugStr[1] = 0; +02409 #endif +02410 while(1) +02411 { +02412 C = yyinput(); +02413 #ifdef _DEBUG +02414 DebugStr[0] = C; +02415 #endif +02416 yyColone ++; +02417 if(C == '\n') +02418 { +02419 yyLine ++; +02420 yyColone = 0; +02421 setNewLine(); +02422 yytext[1] = 0; +02423 break; +02424 } +02425 } +02426 } +02427 else +02428 { +02429 unput(C); +02430 yytext[1] = 0; +02431 return DIV; +02432 } +02433 +02434 } +02435 YY_BREAK +02436 case 24: +02437 YY_RULE_SETUP +02438 #line 329 "lexicon.lex" +02439 { +02440 yyColone ++; +02441 return VIRGULE; +02442 } +02443 YY_BREAK +02444 case 25: +02445 YY_RULE_SETUP +02446 #line 334 "lexicon.lex" +02447 { +02448 yyColone ++; +02449 return POWER; +02450 } +02451 YY_BREAK +02452 case 26: +02453 YY_RULE_SETUP +02454 #line 339 "lexicon.lex" +02455 { +02456 yyColone ++; +02457 return POINT_VI; +02458 } +02459 YY_BREAK +02460 case 27: +02461 YY_RULE_SETUP +02462 #line 344 "lexicon.lex" +02463 { +02464 yyColone ++; +02465 int C = yyinput(); +02466 if(C == ':') +02467 { +02468 yyColone ++; +02469 return SCOP; +02470 } +02471 else +02472 { +02473 unput(C); +02474 yytext[1] = 0; +02475 } +02476 return POINT_DEUX; +02477 } +02478 YY_BREAK +02479 case 28: +02480 YY_RULE_SETUP +02481 #line 360 "lexicon.lex" +02482 { +02483 yyColone ++; +02484 return ACCOL_G; +02485 } +02486 YY_BREAK +02487 case 29: +02488 YY_RULE_SETUP +02489 #line 364 "lexicon.lex" +02490 { +02491 yyColone ++; +02492 return ACCOL_D; +02493 } +02494 YY_BREAK +02495 case 30: +02496 YY_RULE_SETUP +02497 #line 368 "lexicon.lex" +02498 { +02499 yyColone ++; +02500 return INTERROGATION; +02501 } +02502 YY_BREAK +02503 case 31: +02504 YY_RULE_SETUP +02505 #line 372 "lexicon.lex" +02506 { +02507 yyColone ++; +02508 char c = 0; +02509 int i = 0; +02510 strcpy(LastyyText[0], LastyyText[1]); +02511 while(c != 34) +02512 { +02513 c = yyinput(); +02514 yyColone ++; +02515 switch(c) +02516 { +02517 +02518 case 34: +02519 c = yyinput(); +02520 if(c == 34) +02521 { +02522 LastyyText[1][i] = c; +02523 i++; +02524 c = 0; +02525 } +02526 else +02527 { +02528 LastyyText[1][i] = 0; +02529 unput(c); +02530 c = 34; +02531 } +02532 break; +02533 +02534 case '\n': +02535 case '\r': +02536 yyLine ++; +02537 yyColone = 0; +02538 break; +02539 +02540 case '\t': +02541 yyColone +=5; +02542 break; +02543 case EOF: +02544 return 0; +02545 +02546 default: +02547 LastyyText[1][i] = c; +02548 i ++; +02549 break; +02550 } +02551 +02552 } +02553 return CHAINE; +02554 } +02555 YY_BREAK +02556 case 32: +02557 YY_RULE_SETUP +02558 #line 422 "lexicon.lex" +02559 { +02560 yyColone ++; +02561 char c = 0; +02562 int i = 0; +02563 strcpy(LastyyText[0], LastyyText[1]); +02564 while(c != 39) +02565 { +02566 c = yyinput(); +02567 yyColone ++; +02568 switch(c) +02569 { +02570 +02571 case 39: +02572 c = yyinput(); +02573 if(c == 39) +02574 { +02575 LastyyText[1][i] = c; +02576 i++; +02577 c = 0; +02578 } +02579 else +02580 { +02581 LastyyText[1][i] = 0; +02582 unput(c); +02583 c = 39; +02584 } +02585 break; +02586 +02587 case '\n': +02588 case '\r': +02589 yyLine ++; +02590 yyColone = 0; +02591 break; +02592 +02593 case '\t': +02594 yyColone +=5; +02595 break; +02596 case EOF: +02597 return 0; +02598 +02599 default: +02600 LastyyText[1][i] = c; +02601 i ++; +02602 break; +02603 } +02604 +02605 } +02606 return CHAINE; +02607 } +02608 YY_BREAK +02609 case 33: +02610 YY_RULE_SETUP +02611 #line 471 "lexicon.lex" +02612 { +02613 yyColone ++; +02614 return CROCHER_D; +02615 } +02616 YY_BREAK +02617 case 34: +02618 YY_RULE_SETUP +02619 #line 475 "lexicon.lex" +02620 { +02621 yyColone ++; +02622 return CROCHER_G; +02623 } +02624 YY_BREAK +02625 case 35: +02626 YY_RULE_SETUP +02627 #line 480 "lexicon.lex" +02628 ECHO; +02629 YY_BREAK +02630 #line 2631 "lexyy.cc" +02631 case YY_STATE_EOF(INITIAL): +02632 yyterminate(); +02633 +02634 case YY_END_OF_BUFFER: +02635 { +02636 /* Amount of text matched not including the EOB char. */ +02637 int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1; +02638 +02639 /* Undo the effects of YY_DO_BEFORE_ACTION. */ +02640 *yy_cp = yy_hold_char; +02641 +02642 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW ) +02643 { +02644 /* We're scanning a new file or input source. It's +02645 * possible that this happened because the user +02646 * just pointed yyin at a new source and called +02647 * yylex(). If so, then we have to assure +02648 * consistency between yy_current_buffer and our +02649 * globals. Here is the right place to do so, because +02650 * this is the first action (other than possibly a +02651 * back-up) that will match for the new input source. +02652 */ +02653 yy_n_chars = yy_current_buffer->yy_n_chars; +02654 yy_current_buffer->yy_input_file = yyin; +02655 yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL; +02656 } +02657 +02658 /* Note that here we test for yy_c_buf_p "<=" to the position +02659 * of the first EOB in the buffer, since yy_c_buf_p will +02660 * already have been incremented past the NUL character +02661 * (since all states make transitions on EOB to the +02662 * end-of-buffer state). Contrast this with the test +02663 * in input(). +02664 */ +02665 if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] ) +02666 { /* This was really a NUL. */ +02667 yy_state_type yy_next_state; +02668 +02669 yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text; +02670 +02671 yy_current_state = yy_get_previous_state(); +02672 +02673 /* Okay, we're now positioned to make the NUL +02674 * transition. We couldn't have +02675 * yy_get_previous_state() go ahead and do it +02676 * for us because it doesn't know how to deal +02677 * with the possibility of jamming (and we don't +02678 * want to build jamming into it because then it +02679 * will run more slowly). +02680 */ +02681 +02682 yy_next_state = yy_try_NUL_trans( yy_current_state ); +02683 +02684 yy_bp = yytext_ptr + YY_MORE_ADJ; +02685 +02686 if ( yy_next_state ) +02687 { +02688 /* Consume the NUL. */ +02689 yy_cp = ++yy_c_buf_p; +02690 yy_current_state = yy_next_state; +02691 goto yy_match; +02692 } +02693 +02694 else +02695 { +02696 yy_cp = yy_c_buf_p; +02697 goto yy_find_action; +02698 } +02699 } +02700 +02701 else switch ( yy_get_next_buffer() ) +02702 { +02703 case EOB_ACT_END_OF_FILE: +02704 { +02705 yy_did_buffer_switch_on_eof = 0; +02706 +02707 if ( yywrap() ) +02708 { +02709 /* Note: because we've taken care in +02710 * yy_get_next_buffer() to have set up +02711 * yytext, we can now set up +02712 * yy_c_buf_p so that if some total +02713 * hoser (like flex itself) wants to +02714 * call the scanner after we return the +02715 * YY_NULL, it'll still work - another +02716 * YY_NULL will get returned. +02717 */ +02718 yy_c_buf_p = yytext_ptr + YY_MORE_ADJ; +02719 +02720 yy_act = YY_STATE_EOF(YY_START); +02721 goto do_action; +02722 } +02723 +02724 else +02725 { +02726 if ( ! yy_did_buffer_switch_on_eof ) +02727 YY_NEW_FILE; +02728 } +02729 break; +02730 } +02731 +02732 case EOB_ACT_CONTINUE_SCAN: +02733 yy_c_buf_p = +02734 yytext_ptr + yy_amount_of_matched_text; +02735 +02736 yy_current_state = yy_get_previous_state(); +02737 +02738 yy_cp = yy_c_buf_p; +02739 yy_bp = yytext_ptr + YY_MORE_ADJ; +02740 goto yy_match; +02741 +02742 case EOB_ACT_LAST_MATCH: +02743 yy_c_buf_p = +02744 &yy_current_buffer->yy_ch_buf[yy_n_chars]; +02745 +02746 yy_current_state = yy_get_previous_state(); +02747 +02748 yy_cp = yy_c_buf_p; +02749 yy_bp = yytext_ptr + YY_MORE_ADJ; +02750 goto yy_find_action; +02751 } +02752 break; +02753 } +02754 +02755 default: +02756 YY_FATAL_ERROR( +02757 "fatal flex scanner internal error--no action found" ); +02758 } /* end of action switch */ +02759 } /* end of scanning one token */ +02760 } /* end of yylex */ +

+

+ + + + +
+ + + + + + + + + +
int NLAISCRIPT::CCompilateur::yyparse ( )
+
+ + + + + +
+ + + +
+Yacc parser. +
+ +
+Referenced by Compile().
+

+ + + + +
+ + + + + + + + + + +
void yyFlexLexer::yyrestart ( istream * s ) [virtual, inherited]
+
+ + + + + +
+ + + +
+ +
+Implements NLAISCRIPT::FlexLexer. +
+Definition at line 3136 of file lexlang.cpp. +
+References YY_BUF_SIZE, NLAISCRIPT::yyFlexLexer::yy_create_buffer(), NLAISCRIPT::yyFlexLexer::yy_current_buffer, NLAISCRIPT::yyFlexLexer::yy_init_buffer(), NLAISCRIPT::yyFlexLexer::yy_load_buffer_state(), and NLAISCRIPT::yyFlexLexer::yyin. +
+Referenced by NLAISCRIPT::yyFlexLexer::yy_get_next_buffer(). +
+
03137 { +03138 if ( ! yy_current_buffer ) +03139 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); +03140 +03141 yy_init_buffer( yy_current_buffer, input_file ); +03142 yy_load_buffer_state(); +03143 } +

+

+ + + + +
+ + + + + + + + + +
const char* NLAISCRIPT::FlexLexer::YYText ( ) [inline, inherited]
+
+ + + + + +
+ + + +
+ +
+Definition at line 45 of file lex.h. +
+References NLAISCRIPT::FlexLexer::yytext. +
+
00045 { return yytext; } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NLAISCRIPT::yyFlexLexer::yyunput ( int c,
char * buf_ptr
) [protected, inherited]
+
+ + + + + +
+ + + +
+
+

+ + + + +
+ + + + + + + + + +
virtual int NLAISCRIPT::CCompilateur::yywrap ( ) [inline, virtual]
+
+ + + + + +
+ + + +
+This function is needed by the lex parser for initializ the read stream (see lex documment). +
+ +
+Implements NLAISCRIPT::yyFlexLexer. +
+Definition at line 329 of file compilateur.h. +
+References _StreamBuffer, yyin, and NLAISCRIPT::yyFlexLexer::yyin. +
+Referenced by Compile(). +
+
00330 { +00331 if(_StreamBuffer != NULL && yyin == NULL) +00332 { +00333 yyin = _StreamBuffer; +00334 return 0; +00335 } +00336 return 1; +00337 } +

+

Field Documentation

+ + + + +
+ + +
std::list<TPairType> NLAISCRIPT::CCompilateur::_Attrib [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 156 of file compilateur.h. +
+Referenced by clean(), registerMethod(), and setParamVarName().
+

+ + + + +
+ + +
bool NLAISCRIPT::CCompilateur::_BaseObjectDef [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 142 of file compilateur.h. +
+Referenced by setParamVarName().
+

+ + + + +
+ + +
std::list<IConstraint *> NLAISCRIPT::CCompilateur::_ConstraintType [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 159 of file compilateur.h. +
+Referenced by affectation(), affectationMember(), allocExpression(), cleanTypeConstraint(), errorMethodConstraint(), errorTypeConstraint(), pushParamExpression(), RegisterClass(), runTypeConstraint(), and typeOfMethod().
+

+ + + + +
+ + +
bool NLAISCRIPT::CCompilateur::_Debug [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 173 of file compilateur.h. +
+Referenced by affectation(), CCompilateur(), getCode(), getDebugMode(), ifInterrogation(), ifInterrogationEnd(), ifInterrogationPoint(), initParam(), interrogationEnd(), registerMethod(), setDebugMode(), and setNewLine().
+

+ + + + +
+ + +
sint32 NLAISCRIPT::CCompilateur::_DecalageHeap [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 157 of file compilateur.h. +
+Referenced by CCompilateur(), getCode(), and registerMethod().
+

+ + + + +
+ + +
TDicoStr* NLAISCRIPT::CCompilateur::_Dictionary [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 198 of file compilateur.h.
+

+ + + + +
+ + +
bool NLAISCRIPT::CCompilateur::_Error [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 154 of file compilateur.h. +
+Referenced by CCompilateur(), Compile(), parseError(), and yyerror().
+

+ + + + +
+ + +
std::list<IOpType *> NLAISCRIPT::CCompilateur::_ExpressionOp [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 166 of file compilateur.h. +
+Referenced by setTypeExpressionD(), and setTypeExpressionG().
+

+ + + + +
+ + +
IOpType* NLAISCRIPT::CCompilateur::_ExpressionType [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 163 of file compilateur.h. +
+Referenced by affectation(), affectationMember(), CCompilateur(), clean(), ifInterrogation(), pushParamExpression(), setTypeExpression(), setTypeExpressionD(), setTypeExpressionG(), and typeOfMethod().
+

+ + + + +
+ + +
std::list<IOpType *> NLAISCRIPT::CCompilateur::_ExpressionTypeTmp [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 165 of file compilateur.h.
+

+ + + + +
+ + +
NLAILOGIC::CFactBase* NLAISCRIPT::CCompilateur::_FactBase [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 185 of file compilateur.h.
+

+ + + + +
+ + +
bool NLAISCRIPT::CCompilateur::_FacteurEval [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 168 of file compilateur.h. +
+Referenced by CCompilateur().
+

+ + + + +
+ + +
IOpType* NLAISCRIPT::CCompilateur::_FlotingExpressionType [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 164 of file compilateur.h. +
+Referenced by buildObject(), CCompilateur(), clean(), processingVar(), setChaineVar(), setImediateVar(), setImediateVarNill(), setListVar(), setMethodVar(), setPerformative(), setStackVar(), setTypeExpression(), setTypeExpressionD(), and setTypeExpressionG().
+

+ + + + +
+ + +
std::list<bool> NLAISCRIPT::CCompilateur::_FromStack [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 197 of file compilateur.h. +
+Referenced by callFunction().
+

+ + + + +
+ + +
std::list<NLAIFUZZY::CFuzzyVar *> NLAISCRIPT::CCompilateur::_FuzzVars [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 189 of file compilateur.h.
+

+ + + + +
+ + +
NLAIAGENT::IVarName* NLAISCRIPT::CCompilateur::_Goal [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 187 of file compilateur.h.
+

+ + + + +
+ + +
CStackPointer NLAISCRIPT::CCompilateur::_Heap [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 151 of file compilateur.h.
+

+ + + + +
+ + +
bool NLAISCRIPT::CCompilateur::_InCond [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 192 of file compilateur.h. +
+Referenced by CCompilateur().
+

+ + + + +
+ + +
bool NLAISCRIPT::CCompilateur::_InLineParse [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 196 of file compilateur.h. +
+Referenced by CCompilateur(), and initParam().
+

+ + + + +
+ + +
bool NLAISCRIPT::CCompilateur::_IsFacteurIsExpression [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 167 of file compilateur.h. +
+Referenced by CCompilateur().
+

+ + + + +
+ + +
bool NLAISCRIPT::CCompilateur::_IsVoid [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 169 of file compilateur.h. +
+Referenced by CCompilateur(), and typeOfMethod().
+

+ + + + +
+ + +
NLAIC::IIO& NLAISCRIPT::CCompilateur::_Iterface [private] +
+
+ + + + + +
+ + + +
+IO for set out text or for get an input. +
+ +
+Definition at line 135 of file compilateur.h. +
+Referenced by CCompilateur(), Echo(), and yyerror().
+

+ + + + +
+ + +
std::list<NLAISCRIPT::CStringType> NLAISCRIPT::CCompilateur::_LasAffectationVarStr [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 152 of file compilateur.h. +
+Referenced by affectation(), and PrivateError().
+

+ + + + +
+ + +
NLAIAGENT::IObjectIA* NLAISCRIPT::CCompilateur::_LastAffectation [private] +
+
+ + + + + +
+ + + +
+Last affected variable. +
+ +
+Definition at line 148 of file compilateur.h. +
+Referenced by affectation(), and registerMethod().
+

+ + + + +
+ + +
std::list<const NLAIAGENT::CStringVarName *> NLAISCRIPT::CCompilateur::_LastAsserts [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 181 of file compilateur.h.
+

+ + + + +
+ + +
IConstraint* NLAISCRIPT::CCompilateur::_LastbaseClass [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 172 of file compilateur.h. +
+Referenced by callFunction(), and setMethodVar().
+

+ + + + +
+ + +
NLAIAGENT::CStringVarName NLAISCRIPT::CCompilateur::_LastBaseObjectDef [private] +
+
+ + + + + +
+ + + +
+Last string. +
+ +
+Definition at line 141 of file compilateur.h. +
+Referenced by CCompilateur(), and setParamVarName().
+

+ + + + +
+ + +
IBlock* NLAISCRIPT::CCompilateur::_LastBloc [private] +
+
+ + + + + +
+ + + +
+Laste code parsed. +
+ +
+Definition at line 139 of file compilateur.h. +
+Referenced by addOpCode(), addParamCont(), addParamRuleCont(), affectation(), affectationMember(), allocExpression(), buildObject(), callFunction(), CCompilateur(), clean(), getCode(), getVar(), ifInterrogation(), ifInterrogationEnd(), ifInterrogationPoint(), initParam(), interrogationEnd(), PrivateError(), pushParamExpression(), registerMethod(), setListVar(), and setNewLine().
+

+ + + + +
+ + +
std::list<IBlock*> NLAISCRIPT::CCompilateur::_LastBloc1 [private] +
+
+ + + + + +
+ + + +
+temporary code parsed for code manager. +
+ +
+Definition at line 146 of file compilateur.h. +
+Referenced by clean(), ifInterrogation(), ifInterrogationEnd(), ifInterrogationPoint(), and interrogationEnd().
+

+ + + + +
+ + +
std::list<IBlock*> NLAISCRIPT::CCompilateur::_LastBloc2 [private] +
+
+ + + + + +
+ + + +
+temporary code parsed for code manager. +
+ +
+Definition at line 146 of file compilateur.h. +
+Referenced by clean(), ifInterrogationEnd(), and ifInterrogationPoint().
+

+ + + + +
+ + +
std::list<IBlock*> NLAISCRIPT::CCompilateur::_LastBloc3 [private] +
+
+ + + + + +
+ + + +
+temporary code parsed for code manager. +
+ +
+Definition at line 146 of file compilateur.h. +
+Referenced by clean().
+

+ + + + +
+ + +
std::list<const NLAIAGENT::CStringVarName *> NLAISCRIPT::CCompilateur::_LastBooleanConds [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 179 of file compilateur.h.
+

+ + + + +
+ + +
std::list<IOpCode *> NLAISCRIPT::CCompilateur::_LastCodeBranche [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 182 of file compilateur.h.
+

+ + + + +
+ + +
CFactorType NLAISCRIPT::CCompilateur::_LastFact [private] +
+
+ + + + + +
+ + + +
+Type of last statement. +
+ +
+Definition at line 137 of file compilateur.h. +
+Referenced by allocExpression(), processingVar(), setChaineVar(), setImediateVar(), setImediateVarNill(), setMethodVar(), setPerformative(), and setStackVar().
+

+ + + + +
+ + +
NLAILOGIC::CFactPattern* NLAISCRIPT::CCompilateur::_LastFactPattern [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 186 of file compilateur.h. +
+Referenced by CCompilateur().
+

+ + + + +
+ + +
std::list<NLAIAGENT::CStringVarName *> NLAISCRIPT::CCompilateur::_LastFuzzyConds [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 180 of file compilateur.h.
+

+ + + + +
+ + +
sint32 NLAISCRIPT::CCompilateur::_LastFVarIndex [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 190 of file compilateur.h.
+

+ + + + +
+ + +
std::list< std::list<const NLAIAGENT::IVarName *> > NLAISCRIPT::CCompilateur::_LastLogicParams [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 178 of file compilateur.h.
+

+ + + + +
+ + +
NLAIAGENT::IMessageBase::TPerformatif NLAISCRIPT::CCompilateur::_LastPerf [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 193 of file compilateur.h.
+

+ + + + +
+ + +
sint32 NLAISCRIPT::CCompilateur::_LastPosHeap [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 170 of file compilateur.h. +
+Referenced by callFunction(), and setMethodVar().
+

+ + + + +
+ + +
sint32 NLAISCRIPT::CCompilateur::_LastRegistered [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 155 of file compilateur.h.
+

+ + + + +
+ + +
std::list<IBlock*> NLAISCRIPT::CCompilateur::_LastSaveBloc [private] +
+
+ + + + + +
+ + + +
+temporary code parsed for code manager. +
+ +
+Definition at line 146 of file compilateur.h. +
+Referenced by clean(), getVar(), ifInterrogation(), ifInterrogationEnd(), and interrogationEnd().
+

+ + + + +
+ + +
NLAIAGENT::CStringVarName NLAISCRIPT::CCompilateur::_LastString [private] +
+
+ + + + + +
+ + + +
+Last string. +
+ +
+Definition at line 141 of file compilateur.h. +
+Referenced by CCompilateur(), and setParamVarName().
+

+ + + + +
+ + +
std::list<NLAIAGENT::IBaseGroupType *> NLAISCRIPT::CCompilateur::_LastStringParam [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 160 of file compilateur.h. +
+Referenced by buildObject(), callFunction(), clean(), nameMethodeProcessing(), and setMethodVar().
+

+ + + + +
+ + +
sint32 NLAISCRIPT::CCompilateur::_LastTypeCall [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 171 of file compilateur.h. +
+Referenced by callFunction(), and setMethodVar().
+

+ + + + +
+ + +
std::list<NLAISCRIPT::CStringType> NLAISCRIPT::CCompilateur::_LasVarStr [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 152 of file compilateur.h. +
+Referenced by nameMethodeProcessing(), and processingVar().
+

+ + + + +
+ + +
std::list<IConstraint *> NLAISCRIPT::CCompilateur::_MethodConstraint [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 158 of file compilateur.h. +
+Referenced by buildObject(), callFunction(), cleanMethodConstraint(), errorMethodConstraint(), getMethodConstraint(), getNMethodConstraint(), runMethodConstraint(), and setMethodVar().
+

+ + + + +
+ + +
std::list<NLAIAGENT::CStringVarName > NLAISCRIPT::CCompilateur::_MethodName [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 162 of file compilateur.h. +
+Referenced by registerMethod().
+

+ + + + +
+ + +
sint32 NLAISCRIPT::CCompilateur::_NbLogicParams [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 191 of file compilateur.h.
+

+ + + + +
+ + +
std::list<CParam *> NLAISCRIPT::CCompilateur::_Param [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 161 of file compilateur.h. +
+Referenced by buildObject(), callFunction(), clean(), initParam(), pushParamExpression(), registerMethod(), setMethodVar(), and setParamVarName().
+

+ + + + +
+ + +
NLAIAGENT::IObjectIA* NLAISCRIPT::CCompilateur::_ResultCompile [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 175 of file compilateur.h. +
+Referenced by CCompilateur(), Compile(), and endMessageManager().
+

+ + + + +
+ + +
CListClass NLAISCRIPT::CCompilateur::_SelfClass [private] +
+
+ + + + + +
+ + + +
+List of class define in the souce code. +
+ +
+Definition at line 144 of file compilateur.h. +
+Referenced by affectation(), affectationMember(), computContraint(), definClass(), endMessageManager(), findMethode(), getCode(), getTypeOfClass(), getValidateHierarchyBase(), initMessageManager(), isValidateVarName(), onEndClass(), processingVar(), RegisterClass(), registerMethod(), and typeOfMethod().
+

+ + + + +
+ + +
IScriptDebugSource* NLAISCRIPT::CCompilateur::_SourceFileName [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 174 of file compilateur.h. +
+Referenced by CCompilateur(), getCode(), and ~CCompilateur().
+

+ + + + +
+ + +
CStackPointer NLAISCRIPT::CCompilateur::_Stack [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 151 of file compilateur.h.
+

+ + + + +
+ + +
std::istrstream* NLAISCRIPT::CCompilateur::_StreamBuffer [private] +
+
+ + + + + +
+ + + +
+Stream that contain source code. +
+ +
+Definition at line 133 of file compilateur.h. +
+Referenced by CCompilateur(), InitFromFile(), InitStream(), yywrap(), and ~CCompilateur().
+

+ + + + +
+ + +
std::list<IOpType *> NLAISCRIPT::CCompilateur::_TypeList [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 153 of file compilateur.h. +
+Referenced by callFunction(), cleanTypeList(), and processingVar().
+

+ + + + +
+ + +
CIndexStackPointer NLAISCRIPT::CCompilateur::_VarState [private] +
+
+ + + + + +
+ + + +
+This variable allow to simulate the heap allocation. +
+ +
+Definition at line 150 of file compilateur.h. +
+Referenced by affectation(), getCode(), ifInterrogation(), ifInterrogationEnd(), ifInterrogationPoint(), initParam(), and interrogationEnd().
+

+ + + + +
+ + +
bool NLAISCRIPT::CCompilateur::haveReturn [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 200 of file compilateur.h. +
+Referenced by caseRunMsg(), CCompilateur(), and typeOfMethod().
+

+ + + + +
+ + +
bool NLAISCRIPT::CCompilateur::is_cond [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 183 of file compilateur.h.
+

+ + + + +
+ + +
bool NLAISCRIPT::CCompilateur::isRunMsg [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 199 of file compilateur.h. +
+Referenced by caseRunMsg(), CCompilateur(), and registerMethod().
+

+ + + + +
+ + +
double NLAISCRIPT::yyFlexLexer::LastyyNum [protected, inherited] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 169 of file lex.h.
+

+ + + + +
+ + +
char NLAISCRIPT::yyFlexLexer::LastyyText[2][1024*4] [protected, inherited] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 168 of file lex.h.
+

+ + + + +
+ + +
char* NLAISCRIPT::yyFlexLexer::yy_c_buf_p [protected, inherited] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 138 of file lex.h. +
+Referenced by NLAISCRIPT::yyFlexLexer::yy_get_next_buffer(), NLAISCRIPT::yyFlexLexer::yy_get_previous_state(), NLAISCRIPT::yyFlexLexer::yy_load_buffer_state(), NLAISCRIPT::yyFlexLexer::yy_try_NUL_trans(), NLAISCRIPT::yyFlexLexer::yyFlexLexer(), and NLAISCRIPT::yyFlexLexer::yyinput().
+

+ + + + +
+ + +
struct yy_buffer_state* NLAISCRIPT::yyFlexLexer::yy_current_buffer [protected, inherited] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 129 of file lex.h. +
+Referenced by NLAISCRIPT::yyFlexLexer::switch_streams(), NLAISCRIPT::yyFlexLexer::yy_get_next_buffer(), NLAISCRIPT::yyFlexLexer::yy_load_buffer_state(), NLAISCRIPT::yyFlexLexer::yyFlexLexer(), NLAISCRIPT::yyFlexLexer::yyinput(), NLAISCRIPT::yyFlexLexer::yyrestart(), and NLAISCRIPT::yyFlexLexer::~yyFlexLexer().
+

+ + + + +
+ + +
int NLAISCRIPT::yyFlexLexer::yy_did_buffer_switch_on_eof [protected, inherited] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 145 of file lex.h. +
+Referenced by NLAISCRIPT::yyFlexLexer::yyFlexLexer(), and NLAISCRIPT::yyFlexLexer::yyinput().
+

+ + + + +
+ + +
int NLAISCRIPT::FlexLexer::yy_flex_debug [protected, inherited] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 78 of file lex.h. +
+Referenced by NLAISCRIPT::FlexLexer::debug(), NLAISCRIPT::FlexLexer::set_debug(), and NLAISCRIPT::yyFlexLexer::yyFlexLexer().
+

+ + + + +
+ + +
int NLAISCRIPT::yyFlexLexer::yy_full_lp [protected, inherited] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 158 of file lex.h.
+

+ + + + +
+ + +
char* NLAISCRIPT::yyFlexLexer::yy_full_match [protected, inherited] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 156 of file lex.h.
+

+ + + + +
+ + +
int* NLAISCRIPT::yyFlexLexer::yy_full_state [protected, inherited] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 157 of file lex.h.
+

+ + + + +
+ + +
char NLAISCRIPT::yyFlexLexer::yy_hold_char [protected, inherited] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 132 of file lex.h. +
+Referenced by NLAISCRIPT::yyFlexLexer::yy_load_buffer_state(), and NLAISCRIPT::yyFlexLexer::yyinput().
+

+ + + + +
+ + +
int NLAISCRIPT::yyFlexLexer::yy_init [protected, inherited] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 140 of file lex.h. +
+Referenced by NLAISCRIPT::yyFlexLexer::yyFlexLexer().
+

+ + + + +
+ + +
char* NLAISCRIPT::yyFlexLexer::yy_last_accepting_cpos [protected, inherited] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 151 of file lex.h. +
+Referenced by NLAISCRIPT::yyFlexLexer::yy_get_previous_state(), and NLAISCRIPT::yyFlexLexer::yy_try_NUL_trans().
+

+ + + + +
+ + +
yy_state_type NLAISCRIPT::yyFlexLexer::yy_last_accepting_state [protected, inherited] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 150 of file lex.h. +
+Referenced by NLAISCRIPT::yyFlexLexer::yy_get_previous_state(), and NLAISCRIPT::yyFlexLexer::yy_try_NUL_trans().
+

+ + + + +
+ + +
int NLAISCRIPT::yyFlexLexer::yy_looking_for_trail_begin [protected, inherited] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 161 of file lex.h. +
+Referenced by NLAISCRIPT::yyFlexLexer::yyFlexLexer().
+

+ + + + +
+ + +
int NLAISCRIPT::yyFlexLexer::yy_lp [protected, inherited] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 160 of file lex.h.
+

+ + + + +
+ + +
int NLAISCRIPT::yyFlexLexer::yy_more_flag [protected, inherited] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 163 of file lex.h. +
+Referenced by NLAISCRIPT::yyFlexLexer::yyFlexLexer().
+

+ + + + +
+ + +
int NLAISCRIPT::yyFlexLexer::yy_more_len [protected, inherited] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 164 of file lex.h. +
+Referenced by NLAISCRIPT::yyFlexLexer::yyFlexLexer().
+

+ + + + +
+ + +
int NLAISCRIPT::yyFlexLexer::yy_n_chars [protected, inherited] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 135 of file lex.h.
+

+ + + + +
+ + +
int NLAISCRIPT::yyFlexLexer::yy_start [protected, inherited] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 141 of file lex.h. +
+Referenced by NLAISCRIPT::yyFlexLexer::yy_get_previous_state(), and NLAISCRIPT::yyFlexLexer::yyFlexLexer().
+

+ + + + +
+ + +
int* NLAISCRIPT::yyFlexLexer::yy_start_stack [protected, inherited] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 116 of file lex.h.
+

+ + + + +
+ + +
int NLAISCRIPT::yyFlexLexer::yy_start_stack_depth [protected, inherited] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 115 of file lex.h.
+

+ + + + +
+ + +
int NLAISCRIPT::yyFlexLexer::yy_start_stack_ptr [protected, inherited] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 114 of file lex.h.
+

+ + + + +
+ + +
yy_state_type* NLAISCRIPT::yyFlexLexer::yy_state_buf [protected, inherited] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 153 of file lex.h. +
+Referenced by NLAISCRIPT::yyFlexLexer::yyFlexLexer(), and NLAISCRIPT::yyFlexLexer::~yyFlexLexer().
+

+ + + + +
+ + +
yy_state_type* NLAISCRIPT::yyFlexLexer::yy_state_ptr [protected, inherited] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 154 of file lex.h.
+

+ + + + +
+ + +
int NLAISCRIPT::yyFlexLexer::yyColone [protected, inherited] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 170 of file lex.h.
+

+ + + + +
+ + +
istream* NLAISCRIPT::yyFlexLexer::yyin [protected, inherited] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 126 of file lex.h. +
+Referenced by NLAISCRIPT::yyFlexLexer::yy_get_next_buffer(), NLAISCRIPT::yyFlexLexer::yy_load_buffer_state(), NLAISCRIPT::yyFlexLexer::yyFlexLexer(), NLAISCRIPT::yyFlexLexer::yyrestart(), and yywrap().
+

+ + + + +
+ + +
int NLAISCRIPT::FlexLexer::yyleng [protected, inherited] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 76 of file lex.h. +
+Referenced by NLAISCRIPT::FlexLexer::YYLeng().
+

+ + + + +
+ + +
int NLAISCRIPT::yyFlexLexer::yyLine [protected, inherited] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 170 of file lex.h.
+

+ + + + +
+ + +
int NLAISCRIPT::FlexLexer::yylineno [protected, inherited] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 77 of file lex.h. +
+Referenced by NLAISCRIPT::FlexLexer::lineno().
+

+ + + + +
+ + +
ostream* NLAISCRIPT::yyFlexLexer::yyout [protected, inherited] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 127 of file lex.h. +
+Referenced by NLAISCRIPT::yyFlexLexer::LexerOutput(), NLAISCRIPT::yyFlexLexer::switch_streams(), and NLAISCRIPT::yyFlexLexer::yyFlexLexer().
+

+ + + + +
+ + +
char* NLAISCRIPT::FlexLexer::yytext [protected, inherited] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 75 of file lex.h. +
+Referenced by NLAISCRIPT::FlexLexer::YYText().
+

The documentation for this class was generated from the following files:

Generated on Tue Mar 16 11:26:46 2004 for NeL by + +

+1.3.6

+ + -- cgit v1.2.1


Public Member Functions
	CCompilateur (NLAIC::IIO &Iterface, const char str, IScriptDebugSource fileName)
	CCompilateur (NLAIC::IIO &Iterface, const char str, sint32 size, IScriptDebugSource fileName)
void	clean ()
	Initialize variable befor parsing.
void	cleanMethodConstraint ()
	Initialisze the constraint.
void	cleanTypeConstraint ()
void	cleanTypeList ()
	Clean internal list.
virtual NLAIAGENT::IObjectIA::CProcessResult	Compile ()
int	debug () const
void	Echo (char *Er,...)
	Same as printf but out put is made to the IO interface.
CFunctionTag	findMethode (NLAIAGENT::IBaseGroupType &listName, const CParam &param)
CFunctionTag	findMethode (const NLAIAGENT::IObjectIA *baseClass, NLAIAGENT::IBaseGroupType &listName, const CParam &param)
bool	getDebugMode () const
	Get the debug state.
NLAIAGENT::IObjectIA *	getVar (const char *name)
	get the locale variable define by name.
void	InitFromFile (const char *FileName)
	Initialize source code from file.
void	InitStream (char *str, sint32 size)
	Initialize the std::stream.
sint32	isValidateVarName (std::list< sint32 > &ref, std::list< NLAISCRIPT::CStringType > &nameHierarchy, IOpType *&type)
sint32	isValidateVarName (const NLAIAGENT::IObjectIA baseClass, std::list< sint32 > &ref, std::list< NLAISCRIPT::CStringType > &nameHierarchy, IOpType &type)
int	lineno () const
bool	parseError ()
	You can use this to consult the state of the parser.
void	set_debug (int flag)
void	setDebugMode (bool bmode)
	Set the Debug Mode.
virtual void	switch_streams (istream new_in, ostream new_out)
const NLAIAGENT::IObjectIA *	validateHierarchyMethode (std::list< sint32 > &, sint32 &, const NLAIAGENT::IObjectIA *, NLAIAGENT::IBaseGroupType &listName)
yy_buffer_state *	yy_create_buffer (istream *s, int size)
void	yy_delete_buffer (struct yy_buffer_state *b)
void	yy_switch_to_buffer (struct yy_buffer_state *new_buffer)
void	yyerror (char *Er)
	Occur when there are a parse error.
int	YYLeng ()
int	yylex (istream new_in, ostream new_out=0)
virtual int	yylex ()
int	yyparse ()
	Yacc parser.
void	yyrestart (istream *s)
const char *	YYText ()
virtual int	yywrap ()
	This function is needed by the lex parser for initializ the read stream (see lex documment).
virtual	~CCompilateur ()
Protected Member Functions
void	addOpCode (IOpCode *x)
void	addParamCont ()
void	addParamRuleCont ()
sint32	affectation ()
sint32	affectationiMember (const IClassInterpret *baseClass, std::list< NLAISCRIPT::CStringType > &varHName)
sint32	affectationMember (IClassInterpret *, sint32 member)
sint32	affectationMember (sint32 member)
void	allocExpression (IOpCode *op, bool gd=false)
bool	buildObject ()
bool	callFunction ()
void	callSend ()
bool	caseRunMsg ()
sint32	castVariable (const NLAIAGENT::CStringVarName &, NLAIAGENT::CStringVarName &)
bool	checkReturnMethod ()
bool	classIsAnOperator ()
	Logic compilation.
void	CompileFactPattern ()
void	CompileOperator ()
bool	computContraint ()
bool	definClass (const char *className)
bool	endMessageManager ()
void	errorMethodConstraint ()
void	errorTypeConstraint ()
NLAIAGENT::CIdMethod	findMethode (sint32 inheritance, NLAIAGENT::CStringType baseName, const NLAIAGENT::IObjectIA className, const NLAIAGENT::IVarName &methodeName, const CParam &param)
sint32	findMethodei (NLAIAGENT::IBaseGroupType &listName, const CParam &param)
CCodeBrancheRun *	getCode (bool isMain=false)
	throw (NLAIE::IException)
const IClassInterpret *	getInheritanceRange (sint32 &, const IClassInterpret *, const NLAIAGENT::IVarName &) const
const IClassInterpret *	getInheritanceRange (sint32 &, const IClassInterpret *, NLAIAGENT::IBaseGroupType &) const
IConstraint *	getMethodConstraint (const IConstraint &c) const
IConstraint *	getMethodConstraint (const NLAIAGENT::IBaseGroupType &g, const CParam &p) const
sint32	getNMethodConstraint ()
NLAIC::CIdentType	getTypeOfClass (const NLAIAGENT::IVarName &className)
	throw (NLAIE::IException)
const NLAIAGENT::IObjectIA *	getValidateHierarchyBase (const NLAIAGENT::IObjectIA *base, std::list< sint32 > &ref, sint32 &h, std::list< NLAISCRIPT::CStringType > &listName)
const NLAIAGENT::IObjectIA *	getValidateHierarchyBase (std::list< sint32 > &ref, sint32 &h, std::list< NLAISCRIPT::CStringType > &listName)
void	ifInterrogation ()
void	ifInterrogationEnd ()
void	ifInterrogationPoint ()
void	initMessageManager ()
void	initParam ()
void	interrogationEnd ()
virtual void	LexerError (const char *msg)
virtual int	LexerInput (char *buf, int max_size)
virtual void	LexerOutput (const char *buf, int size)
void	nameMethodeProcessing ()
void	onEndClass ()
sint32	PrivateError ()
sint32	processingVar ()
void	pushParamExpression ()
void	RegisterClass ()
bool	registerMethod ()
sint32	runMethodConstraint ()
sint32	runTypeConstraint ()
void	setChaineVar ()
void	setImediateVar ()
void	setImediateVarNill ()
void	setListVar ()
void	setMethodVar ()
virtual void	setNewLine ()
	Tell the _lastBlock about a newLine (for Debug).
bool	setParamVarName ()
void	setPerformative (NLAIAGENT::IMessageBase::TPerformatif p)
void	setStackVar (const NLAIC::CIdentType &)
void	setTypeExpression (NLAIC::CTypeOfOperator::TTypeOp op, const char *txtOp)
void	setTypeExpression ()
void	setTypeExpressionD (NLAIC::CTypeOfOperator::TTypeOp op, const char *txtOp)
void	setTypeExpressionG ()
sint32	typeOfMethod ()
void	yy_flush_buffer (struct yy_buffer_state *b)
int	yy_get_next_buffer ()
yy_state_type	yy_get_previous_state ()
void	yy_init_buffer (struct yy_buffer_state b, istream s)
void	yy_load_buffer_state ()
void	yy_pop_state ()
void	yy_push_state (int new_state)
int	yy_top_state ()
yy_state_type	yy_try_NUL_trans (yy_state_type current_state)
int	yyinput ()
void	yyunput (int c, char *buf_ptr)
Protected Attributes
double	LastyyNum
char	LastyyText [2][1024 *4]
char *	yy_c_buf_p
yy_buffer_state *	yy_current_buffer
int	yy_did_buffer_switch_on_eof
int	yy_flex_debug
int	yy_full_lp
char *	yy_full_match
int *	yy_full_state
char	yy_hold_char
int	yy_init
char *	yy_last_accepting_cpos
yy_state_type	yy_last_accepting_state
int	yy_looking_for_trail_begin
int	yy_lp
int	yy_more_flag
int	yy_more_len
int	yy_n_chars
int	yy_start
int *	yy_start_stack
int	yy_start_stack_depth
int	yy_start_stack_ptr
yy_state_type *	yy_state_buf
yy_state_type *	yy_state_ptr
int	yyColone
istream *	yyin
int	yyleng
int	yyLine
int	yylineno
ostream *	yyout
char *	yytext
Private Types
typedef std::pair< NLAIAGENT::IVarName , + NLAIAGENT::IObjectIA >	TPairType
	This define is use for define an argument of a method in the language.
Private Attributes
std::list< TPairType >	_Attrib
bool	_BaseObjectDef
std::list< IConstraint * >	_ConstraintType
bool	_Debug
sint32	_DecalageHeap
TDicoStr *	_Dictionary
bool	_Error
std::list< IOpType * >	_ExpressionOp
IOpType *	_ExpressionType
std::list< IOpType * >	_ExpressionTypeTmp
NLAILOGIC::CFactBase *	_FactBase
bool	_FacteurEval
IOpType *	_FlotingExpressionType
std::list< bool >	_FromStack
std::list< NLAIFUZZY::CFuzzyVar * >	_FuzzVars
NLAIAGENT::IVarName *	_Goal
CStackPointer	_Heap
bool	_InCond
bool	_InLineParse
bool	_IsFacteurIsExpression
bool	_IsVoid
NLAIC::IIO &	_Iterface
	IO for set out text or for get an input.
std::list< NLAISCRIPT::CStringType >	_LasAffectationVarStr
NLAIAGENT::IObjectIA *	_LastAffectation
	Last affected variable.
std::list< const NLAIAGENT::CStringVarName * >	_LastAsserts
IConstraint *	_LastbaseClass
NLAIAGENT::CStringVarName	_LastBaseObjectDef
	Last string.
IBlock *	_LastBloc
	Laste code parsed.
std::list< IBlock * >	_LastBloc1
	temporary code parsed for code manager.
std::list< IBlock * >	_LastBloc2
	temporary code parsed for code manager.
std::list< IBlock * >	_LastBloc3
	temporary code parsed for code manager.
std::list< const NLAIAGENT::CStringVarName * >	_LastBooleanConds
std::list< IOpCode * >	_LastCodeBranche
CFactorType	_LastFact
	Type of last statement.
NLAILOGIC::CFactPattern *	_LastFactPattern
std::list< NLAIAGENT::CStringVarName * >	_LastFuzzyConds
sint32	_LastFVarIndex
std::list< std::list< const +NLAIAGENT::IVarName * > >	_LastLogicParams
NLAIAGENT::IMessageBase::TPerformatif	_LastPerf
sint32	_LastPosHeap
sint32	_LastRegistered
std::list< IBlock * >	_LastSaveBloc
	temporary code parsed for code manager.
NLAIAGENT::CStringVarName	_LastString
	Last string.
std::list< NLAIAGENT::IBaseGroupType * >	_LastStringParam
sint32	_LastTypeCall
std::list< NLAISCRIPT::CStringType >	_LasVarStr
std::list< IConstraint * >	_MethodConstraint
std::list< NLAIAGENT::CStringVarName >	_MethodName
sint32	_NbLogicParams
std::list< CParam * >	_Param
NLAIAGENT::IObjectIA *	_ResultCompile
CListClass	_SelfClass
	List of class define in the souce code.
IScriptDebugSource *	_SourceFileName
CStackPointer	_Stack
std::istrstream *	_StreamBuffer
	Stream that contain source code.
std::list< IOpType * >	_TypeList
CIndexStackPointer	_VarState
	This variable allow to simulate the heap allocation.
bool	haveReturn
bool	is_cond
bool	isRunMsg