#include <compilateur.h>
Inheritance diagram for NLAISCRIPT::CCompilateur:
Robert Gabriel
Nevrax France
Definition at line 125 of file compilateur.h.
|
|
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(). |
|
||||||||||||||||||||
|
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 } |
|
||||||||||||||||
|
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 } |
|
|
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 }
|
|
|
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 }
|
|
|
Definition at line 384 of file var_control.cpp. References _LastBloc, and NLAISCRIPT::IBlock::addCode().
00385 {
00386 _LastBloc->addCode(new CLdbOpCode (CPramContainer()));
00387 }
|
|
|
Definition at line 379 of file var_control.cpp. References _LastBloc, and NLAISCRIPT::IBlock::addCode().
00380 {
00381 _LastBloc->addCode(new CLdbOpCode (NLAIAGENT::CGroupType()));
00382 }
|
|
|
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 }
|
|
||||||||||||
|
Definition at line 419 of file yacc.cpp. References sint32.
00420 {
00421
00422 return true;
00423 }
|
|
||||||||||||
|
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 }
|
|
|
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 }
|
|
||||||||||||
|
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 }
|
|
|
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 }
|
|
|
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 }
|
|
|
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 }
|
|
|
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 }
|
|
||||||||||||
|
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 }
|
|
|
Definition at line 811 of file yacc.cpp.
00812 {
00813 return true;
00814 }
|
|
|
Logic compilation.
Definition at line 49 of file var_control.cpp.
00050 {
00051 return true;
00052 }
|
|
|
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 }
|
|
|
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 }
|
|
|
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 }
|
|
|
Clean internal list.
Definition at line 358 of file compilateur.cpp. References _TypeList. Referenced by clean().
|
|
|
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 }
|
|
|
|
|
|
|
|
|
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 }
|
|
|
Definition at line 71 of file lex.h. References NLAISCRIPT::FlexLexer::yy_flex_debug.
00071 { return yy_flex_debug; }
|
|
|
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 }
|
|
||||||||||||
|
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().
|
|
|
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 }
|
|
|
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 }
|
|
|
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 }
|
|
||||||||||||||||||||||||
|
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 }
|
|
||||||||||||
|
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 }
|
|
||||||||||||||||
|
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 }
|
|
||||||||||||
|
|
|
|
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 }
|
|
|
Get the debug state.
Definition at line 409 of file compilateur.h. References _Debug. Referenced by NLAISCRIPT::CConstraintMethode::run().
00409 {return _Debug;}
|
|
||||||||||||||||
|
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 }
|
|
||||||||||||||||
|
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 }
|
|
|
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 }
|
|
||||||||||||
|
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 }
|
|
|
Definition at line 423 of file compilateur.h. References _MethodConstraint, and sint32. Referenced by computContraint().
00424 {
00425 return _MethodConstraint.size();
00426 }
|
|
|
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 }
|
|
||||||||||||||||||||
|
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 }
|
|
||||||||||||||||
|
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 }
|
|
|
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 }
|
|
|
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 }
|
|
|
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 }
|
|
|
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 }
|
|
|
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 }
|
|
|
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 }
|
|
|
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().
|
|
||||||||||||
|
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 }
|
|
|
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 }
|
|
||||||||||||||||
|
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 }
|
|
||||||||||||||||||||
|
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 }
|
|
|
|
|
||||||||||||
|
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 }
|
|
||||||||||||
|
Definition at line 2838 of file lexlang.cpp. References size, and NLAISCRIPT::yyFlexLexer::yyout.
02839 {
02840 (void) yyout->write( buf, size );
02841 }
|
|
|
Definition at line 69 of file lex.h. References NLAISCRIPT::FlexLexer::yylineno.
00069 { return yylineno; }
|
|
|
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 }
|
|
|
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 }
|
|
|
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 }
|
|
|
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 }
|
|
|
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 }
|
|
|
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 }
|
|
|
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 }
|
|
|
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 }
|
|
|
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 }
|
|
|
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 }
|
|
|
Definition at line 72 of file lex.h. References NLAISCRIPT::FlexLexer::yy_flex_debug.
00072 { yy_flex_debug = flag; }
|
|
|
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 }
|
|
|
Set the Debug Mode.
Definition at line 407 of file compilateur.h. References _Debug.
00407 { _Debug = bmode;}
|
|
|
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 }
|
|
|
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 }
|
|
|
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 }
|
|
|
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 }
|
|
|
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().
|
|
|
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 }
|
|
|
|
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 }
|
|
||||||||||||
|
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 }
|
|
|
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 }
|
|
||||||||||||
|
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 }
|
|
|
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 }
|
|
||||||||||||
|
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 }
|
|
|
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 }
|
|
||||||||||||||||||||
|
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 }
|
|
||||||||||||
|
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 }
|
|
|
Implements NLAISCRIPT::FlexLexer. Referenced by NLAISCRIPT::yyFlexLexer::switch_streams(), and NLAISCRIPT::yyFlexLexer::~yyFlexLexer(). |
|
|
|
|
|
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 }
|
|
|
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 }
|
|
||||||||||||
|
Referenced by NLAISCRIPT::yyFlexLexer::yy_create_buffer(), and NLAISCRIPT::yyFlexLexer::yyrestart(). |
|
|
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 }
|
|
|
|
|
|
|
|
|
Implements NLAISCRIPT::FlexLexer. Referenced by NLAISCRIPT::yyFlexLexer::switch_streams(). |
|
|
|
|
|
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 }
|
|
|
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().
|
|
|
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 }
|
|
|
Definition at line 46 of file lex.h. References NLAISCRIPT::FlexLexer::yyleng.
00046 { return yyleng; }
|
|
||||||||||||
|
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 }
|
|
|
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 */
|
|
|
Yacc parser.
Referenced by Compile(). |
|
|
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 }
|
|
|
Definition at line 45 of file lex.h. References NLAISCRIPT::FlexLexer::yytext.
00045 { return yytext; }
|
|
||||||||||||
|
|
|
|
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 }
|
|
|
Definition at line 156 of file compilateur.h. Referenced by clean(), registerMethod(), and setParamVarName(). |
|
|
Definition at line 142 of file compilateur.h. Referenced by setParamVarName(). |
|
|
Definition at line 159 of file compilateur.h. Referenced by affectation(), affectationMember(), allocExpression(), cleanTypeConstraint(), errorMethodConstraint(), errorTypeConstraint(), pushParamExpression(), RegisterClass(), runTypeConstraint(), and typeOfMethod(). |
|
|
Definition at line 173 of file compilateur.h. Referenced by affectation(), CCompilateur(), getCode(), getDebugMode(), ifInterrogation(), ifInterrogationEnd(), ifInterrogationPoint(), initParam(), interrogationEnd(), registerMethod(), setDebugMode(), and setNewLine(). |
|
|
Definition at line 157 of file compilateur.h. Referenced by CCompilateur(), getCode(), and registerMethod(). |
|
|
Definition at line 198 of file compilateur.h. |
|
|
Definition at line 154 of file compilateur.h. Referenced by CCompilateur(), Compile(), parseError(), and yyerror(). |
|
|
Definition at line 166 of file compilateur.h. Referenced by setTypeExpressionD(), and setTypeExpressionG(). |
|
|
Definition at line 163 of file compilateur.h. Referenced by affectation(), affectationMember(), CCompilateur(), clean(), ifInterrogation(), pushParamExpression(), setTypeExpression(), setTypeExpressionD(), setTypeExpressionG(), and typeOfMethod(). |
|
|
Definition at line 165 of file compilateur.h. |
|
|
Definition at line 185 of file compilateur.h. |
|
|
Definition at line 168 of file compilateur.h. Referenced by CCompilateur(). |
|
|
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(). |
|
|
Definition at line 197 of file compilateur.h. Referenced by callFunction(). |
|
|
Definition at line 189 of file compilateur.h. |
|
|
Definition at line 187 of file compilateur.h. |
|
|
Definition at line 151 of file compilateur.h. |
|
|
Definition at line 192 of file compilateur.h. Referenced by CCompilateur(). |
|
|
Definition at line 196 of file compilateur.h. Referenced by CCompilateur(), and initParam(). |
|
|
Definition at line 167 of file compilateur.h. Referenced by CCompilateur(). |
|
|
Definition at line 169 of file compilateur.h. Referenced by CCompilateur(), and typeOfMethod(). |
|
|
IO for set out text or for get an input.
Definition at line 135 of file compilateur.h. Referenced by CCompilateur(), Echo(), and yyerror(). |
|
|
Definition at line 152 of file compilateur.h. Referenced by affectation(), and PrivateError(). |
|
|
Last affected variable.
Definition at line 148 of file compilateur.h. Referenced by affectation(), and registerMethod(). |
|
|
Definition at line 181 of file compilateur.h. |
|
|
Definition at line 172 of file compilateur.h. Referenced by callFunction(), and setMethodVar(). |
|
|
Last string.
Definition at line 141 of file compilateur.h. Referenced by CCompilateur(), and setParamVarName(). |
|
|
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(). |
|
|
temporary code parsed for code manager.
Definition at line 146 of file compilateur.h. Referenced by clean(), ifInterrogation(), ifInterrogationEnd(), ifInterrogationPoint(), and interrogationEnd(). |
|
|
temporary code parsed for code manager.
Definition at line 146 of file compilateur.h. Referenced by clean(), ifInterrogationEnd(), and ifInterrogationPoint(). |
|
|
temporary code parsed for code manager.
Definition at line 146 of file compilateur.h. Referenced by clean(). |
|
|
Definition at line 179 of file compilateur.h. |
|
|
Definition at line 182 of file compilateur.h. |
|
|
Type of last statement.
Definition at line 137 of file compilateur.h. Referenced by allocExpression(), processingVar(), setChaineVar(), setImediateVar(), setImediateVarNill(), setMethodVar(), setPerformative(), and setStackVar(). |
|
|
Definition at line 186 of file compilateur.h. Referenced by CCompilateur(). |
|
|
Definition at line 180 of file compilateur.h. |
|
|
Definition at line 190 of file compilateur.h. |
|
|
Definition at line 178 of file compilateur.h. |
|
|
Definition at line 193 of file compilateur.h. |
|
|
Definition at line 170 of file compilateur.h. Referenced by callFunction(), and setMethodVar(). |
|
|
Definition at line 155 of file compilateur.h. |
|
|
temporary code parsed for code manager.
Definition at line 146 of file compilateur.h. Referenced by clean(), getVar(), ifInterrogation(), ifInterrogationEnd(), and interrogationEnd(). |
|
|
Last string.
Definition at line 141 of file compilateur.h. Referenced by CCompilateur(), and setParamVarName(). |
|
|
Definition at line 160 of file compilateur.h. Referenced by buildObject(), callFunction(), clean(), nameMethodeProcessing(), and setMethodVar(). |
|
|
Definition at line 171 of file compilateur.h. Referenced by callFunction(), and setMethodVar(). |
|
|
Definition at line 152 of file compilateur.h. Referenced by nameMethodeProcessing(), and processingVar(). |
|
|
Definition at line 158 of file compilateur.h. Referenced by buildObject(), callFunction(), cleanMethodConstraint(), errorMethodConstraint(), getMethodConstraint(), getNMethodConstraint(), runMethodConstraint(), and setMethodVar(). |
|
|
Definition at line 162 of file compilateur.h. Referenced by registerMethod(). |
|
|
Definition at line 191 of file compilateur.h. |
|
|
Definition at line 161 of file compilateur.h. Referenced by buildObject(), callFunction(), clean(), initParam(), pushParamExpression(), registerMethod(), setMethodVar(), and setParamVarName(). |
|
|
Definition at line 175 of file compilateur.h. Referenced by CCompilateur(), Compile(), and endMessageManager(). |
|
|
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(). |
|
|
Definition at line 174 of file compilateur.h. Referenced by CCompilateur(), getCode(), and ~CCompilateur(). |
|
|
Definition at line 151 of file compilateur.h. |
|
|
Stream that contain source code.
Definition at line 133 of file compilateur.h. Referenced by CCompilateur(), InitFromFile(), InitStream(), yywrap(), and ~CCompilateur(). |
|
|
Definition at line 153 of file compilateur.h. Referenced by callFunction(), cleanTypeList(), and processingVar(). |
|
|
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(). |
|
|
Definition at line 200 of file compilateur.h. Referenced by caseRunMsg(), CCompilateur(), and typeOfMethod(). |
|
|
Definition at line 183 of file compilateur.h. |
|
|
Definition at line 199 of file compilateur.h. Referenced by caseRunMsg(), CCompilateur(), and registerMethod(). |
|
|
|
|
|
|
|
|
|
|
Definition at line 145 of file lex.h. Referenced by NLAISCRIPT::yyFlexLexer::yyFlexLexer(), and NLAISCRIPT::yyFlexLexer::yyinput(). |
|
|
Definition at line 78 of file lex.h. Referenced by NLAISCRIPT::FlexLexer::debug(), NLAISCRIPT::FlexLexer::set_debug(), and NLAISCRIPT::yyFlexLexer::yyFlexLexer(). |
|
|
|
|
|
|
|
|
|
|
|
Definition at line 132 of file lex.h. Referenced by NLAISCRIPT::yyFlexLexer::yy_load_buffer_state(), and NLAISCRIPT::yyFlexLexer::yyinput(). |
|
|
Definition at line 140 of file lex.h. Referenced by NLAISCRIPT::yyFlexLexer::yyFlexLexer(). |
|
|
Definition at line 151 of file lex.h. Referenced by NLAISCRIPT::yyFlexLexer::yy_get_previous_state(), and NLAISCRIPT::yyFlexLexer::yy_try_NUL_trans(). |
|
|
Definition at line 150 of file lex.h. Referenced by NLAISCRIPT::yyFlexLexer::yy_get_previous_state(), and NLAISCRIPT::yyFlexLexer::yy_try_NUL_trans(). |
|
|
Definition at line 161 of file lex.h. Referenced by NLAISCRIPT::yyFlexLexer::yyFlexLexer(). |
|
|
|
|
|
Definition at line 163 of file lex.h. Referenced by NLAISCRIPT::yyFlexLexer::yyFlexLexer(). |
|
|
Definition at line 164 of file lex.h. Referenced by NLAISCRIPT::yyFlexLexer::yyFlexLexer(). |
|
|
|
|
|
Definition at line 141 of file lex.h. Referenced by NLAISCRIPT::yyFlexLexer::yy_get_previous_state(), and NLAISCRIPT::yyFlexLexer::yyFlexLexer(). |
|
|
|
|
|
|
|
|
|
|
|
Definition at line 153 of file lex.h. Referenced by NLAISCRIPT::yyFlexLexer::yyFlexLexer(), and NLAISCRIPT::yyFlexLexer::~yyFlexLexer(). |
|
|
|
|
|
|
|
|
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(). |
|
|
Definition at line 76 of file lex.h. Referenced by NLAISCRIPT::FlexLexer::YYLeng(). |
|
|
|
|
|
Definition at line 77 of file lex.h. Referenced by NLAISCRIPT::FlexLexer::lineno(). |
|
|
Definition at line 127 of file lex.h. Referenced by NLAISCRIPT::yyFlexLexer::LexerOutput(), NLAISCRIPT::yyFlexLexer::switch_streams(), and NLAISCRIPT::yyFlexLexer::yyFlexLexer(). |
|
|
Definition at line 75 of file lex.h. Referenced by NLAISCRIPT::FlexLexer::YYText(). |
1.3.6