00001
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026 #ifndef NL_TYPE_DEF_H
00027 #define NL_TYPE_DEF_H
00028 #include "nel/ai/script/constraint.h"
00029
00030 namespace NLAISCRIPT
00031 {
00032 struct CFactorType;
00033
00043 class IOpType: public IConstraint
00044 {
00045
00046 public:
00047 IOpType()
00048 {
00049 }
00050
00052
00053 virtual void run(IConstraint *){}
00054 virtual void run(CCompilateur &){}
00055 virtual void addIndex(int i,CCodeBrancheRun *){}
00056 virtual void getError(char *) const{}
00057 virtual int getLine() const{ return 0;}
00058 virtual int getColone() const{return 0;}
00059 double evalParam(IOpType *);
00060 virtual double eval (IOpType *);
00062
00063 virtual ~IOpType();
00064
00065 public:
00066 static const IOpType*loadIOpType(NLMISC::IStream &f);
00067 };
00068
00078 class COperandVoid: public IOpType
00079 {
00080
00081 public:
00082 COperandVoid()
00083 {
00084 }
00085
00086 const char *getInfo()
00087 {
00088 return "constraint<COperandVoid>";
00089 }
00090
00091 const NLAIC::CIdentType *getConstraintTypeOf()
00092 {
00093 return &NLAIC::CIdentType::VoidType;
00094 }
00095
00096 virtual void serial(NLMISC::IStream &f) throw(NLMISC::EStream)
00097 {
00098 if ( f.isReading() )
00099 {
00100 throw NLMISC::EStream();
00101 }
00102 else
00103 {
00104 sint32 n = (sint32)getTypeOfClass();
00105 f.serial(n);
00106 }
00107 }
00108
00109 virtual ConstraintTypeEnum getTypeOfClass() const
00110 {
00111 return operandVoid;
00112 }
00113
00114 bool operator == (const IConstraint &c) const
00115 {
00116 if(getTypeOfClass() == c.getTypeOfClass())
00117 {
00118 return true;
00119 }
00120 return false;
00121 }
00122
00123 bool dependOn(const IConstraint *) const
00124 {
00125 return false;
00126 }
00127
00128 const IConstraint *clone() const
00129 {
00130 IConstraint *x = new COperandVoid();
00131 return x;
00132 }
00133
00134 bool satisfied()
00135 {
00136 return true;
00137 }
00138
00139 virtual ~COperandVoid()
00140 {
00141 }
00142 };
00143
00153 class COperandAnyObject: public IOpType
00154 {
00155
00156 public:
00157 COperandAnyObject()
00158 {
00159 }
00160
00161 const char *getInfo()
00162 {
00163 return "constraint<COperandAnyObject>";
00164 }
00165
00166 const NLAIC::CIdentType *getConstraintTypeOf()
00167 {
00168 return &NLAIC::CIdentType::VoidType;
00169 }
00170
00171 virtual void serial(NLMISC::IStream &f) throw(NLMISC::EStream)
00172 {
00173 if ( f.isReading() )
00174 {
00175 throw NLMISC::EStream();
00176 }
00177 else
00178 {
00179 sint32 n = (sint32)getTypeOfClass();
00180 f.serial(n);
00181 }
00182 }
00183
00184 virtual ConstraintTypeEnum getTypeOfClass() const
00185 {
00186 return operandAnyObject;
00187 }
00188
00189 bool operator == (const IConstraint &c) const
00190 {
00191 return true;
00192 }
00193
00194 bool dependOn(const IConstraint *) const
00195 {
00196 return false;
00197 }
00198
00199 const IConstraint *clone() const
00200 {
00201 IConstraint *x = new COperandAnyObject();
00202 return x;
00203 }
00204
00205 bool satisfied()
00206 {
00207 return true;
00208 }
00209
00210 virtual ~COperandAnyObject()
00211 {
00212 }
00213 };
00214
00224 class COperandSimple: public IOpType
00225 {
00226 private:
00227 NLAIC::CIdentType *_Ident;
00228 std::string _TxtInfo;
00229
00230 public:
00231 COperandSimple(NLMISC::IStream &f)
00232 {
00233 _Ident = new NLAIC::CIdentType(f);
00234 }
00235 COperandSimple(NLAIC::CIdentType *i) : _Ident(i)
00236 {
00237 }
00238
00239 const char *getInfo()
00240 {
00241 if(_TxtInfo.begin() == _TxtInfo.end())
00242 {
00243 _TxtInfo = NLAIC::stringGetBuild("constraint<COperandSimple> for %s",(const char *)*_Ident);
00244 }
00245 return _TxtInfo.c_str();
00246 }
00247
00248 const NLAIC::CIdentType *getConstraintTypeOf()
00249 {
00250 return _Ident;
00251 }
00252
00253 virtual ConstraintTypeEnum getTypeOfClass() const
00254 {
00255 return operandSimple;
00256 }
00257
00258 bool operator == (const IConstraint &c) const
00259 {
00260 if(getTypeOfClass() == c.getTypeOfClass() && *((const COperandSimple &)c)._Ident == *_Ident)
00261 {
00262 return true;
00263 }
00264 return false;
00265 }
00266
00267 bool dependOn(const IConstraint *) const
00268 {
00269 return false;
00270 }
00271
00272 const IConstraint *clone() const
00273 {
00274 IConstraint *x = new COperandSimple(new NLAIC::CIdentType(*_Ident));
00275 return x;
00276 }
00277
00278 bool satisfied()
00279 {
00280 return true;
00281 }
00282
00283 virtual void serial(NLMISC::IStream &f) throw(NLMISC::EStream)
00284 {
00285 if ( f.isReading() )
00286 {
00287 if(_Ident) _Ident->release();
00288 _Ident = new NLAIC::CIdentType(f);
00289 _TxtInfo.clear();
00290
00291 }
00292 else
00293 {
00294 sint32 n = (sint32)getTypeOfClass();
00295 f.serial(n);
00296 _Ident->serial(f);
00297 }
00298 }
00299
00300 virtual ~COperandSimple()
00301 {
00302 _Ident->release();
00303 }
00304 };
00305
00306
00316 class COperandSimpleListOr: public IOpType
00317 {
00318 private:
00319 std::list<NLAIC::CIdentType *> _TypeListe;
00320
00321 char *_TxtInfo;
00322
00323 public:
00324 COperandSimpleListOr(NLMISC::IStream &f)
00325 {
00326 serial(f);
00327 }
00328
00329 COperandSimpleListOr(const std::list<NLAIC::CIdentType *> &l)
00330 {
00331 char txt[1028*8];
00332 sprintf(txt,"constraint<COperandSimpleListOr> for ...");
00333 _TxtInfo = new char [strlen(txt) + 1];
00334 strcpy(_TxtInfo,txt);
00335
00336 std::list<NLAIC::CIdentType *>::const_iterator i = l.begin();
00337 while(i != l.end())
00338 {
00339 _TypeListe.push_back(new NLAIC::CIdentType(*(*i++)));
00340 }
00341 }
00342
00343
00344 COperandSimpleListOr(int count, ...);
00345
00346 const std::list<NLAIC::CIdentType *> &getList() const
00347 {
00348 return _TypeListe;
00349 }
00350
00351 const char *getInfo()
00352 {
00353 return _TxtInfo;
00354 }
00355
00356 const NLAIC::CIdentType *getConstraintTypeOf()
00357 {
00358 return _TypeListe.back();
00359 }
00360
00361 virtual ConstraintTypeEnum getTypeOfClass() const
00362 {
00363 return operandSimpleListOr;
00364 }
00365
00366 bool operator == (const IConstraint &c) const
00367 {
00368 if(getTypeOfClass() == c.getTypeOfClass())
00369 {
00370 const COperandSimpleListOr &l = (const COperandSimpleListOr &)c;
00371 if(l._TypeListe.size() != _TypeListe.size()) return false;
00372
00373 std::list<NLAIC::CIdentType *>::const_iterator i = _TypeListe.begin();
00374 std::list<NLAIC::CIdentType *>::const_iterator j = l._TypeListe.begin();
00375 while(i != _TypeListe.end())
00376 {
00377 if(!((*i++) == (*j++))) return false;
00378 }
00379 return true;
00380 }
00381 return false;
00382 }
00383
00384 bool dependOn(const IConstraint *) const
00385 {
00386 return false;
00387 }
00388
00389 const IConstraint *clone() const
00390 {
00391 IConstraint *x = new COperandSimpleListOr(_TypeListe);
00392 return x;
00393 }
00394
00395 bool satisfied()
00396 {
00397 return true;
00398 }
00399
00400 virtual void serial(NLMISC::IStream &f) throw(NLMISC::EStream)
00401 {
00402 if ( f.isReading() )
00403 {
00404 while(_TypeListe.size())
00405 {
00406 delete _TypeListe.back();
00407 _TypeListe.pop_back();
00408 }
00409
00410
00411 sint32 i;
00412 f.serial(i);
00413 while(i --)
00414 {
00415 NLAIC::CIdentType *ident = new NLAIC::CIdentType(f);
00416 _TypeListe.push_back(ident);
00417 }
00418 delete _TxtInfo;
00419 char txt[1028*8];
00420 sprintf(txt,"constraint<COperandSimpleListOr> for ...");
00421 _TxtInfo = new char [strlen(txt) + 1];
00422 strcpy(_TxtInfo,txt);
00423 }
00424 else
00425 {
00426 sint32 n = (sint32)getTypeOfClass();
00427 f.serial(n);
00428 n = _TypeListe.size();
00429 f.serial(n);
00430 std::list<NLAIC::CIdentType *>::iterator i = _TypeListe.begin();
00431 while(i != _TypeListe.end())
00432 {
00433 (*i++)->serial(f);
00434 }
00435 }
00436 }
00437
00438 virtual double eval (IOpType *);
00439
00440 virtual ~COperandSimpleListOr()
00441 {
00442 while(_TypeListe.size())
00443 {
00444 delete _TypeListe.back();
00445 _TypeListe.pop_back();
00446 }
00447 delete _TxtInfo;
00448 }
00449 };
00450
00451
00461 class COperandUnknown: public IOpType
00462 {
00463 private:
00464 IConstraint *_Constraint;
00465 NLAIC::CIdentType *_Id;
00466 char *_TxtInfo;
00467 bool _RunIsDone;
00468
00469 public:
00470 COperandUnknown(IConstraint *constraint):_Constraint(constraint),_Id(NULL)
00471 {
00472 char txt[1028*8];
00473 sprintf(txt,"constraint<COperandUnknown> for %s",_Constraint->getInfo());
00474 _TxtInfo = new char [strlen(txt) + 1];
00475 strcpy(_TxtInfo,txt);
00476 _Constraint->addConstraint(this);
00477 _RunIsDone = false;
00478 }
00479
00480 virtual void serial(NLMISC::IStream &f) throw(NLMISC::EStream)
00481 {
00482 if(_Id != NULL)
00483 {
00484 COperandSimple n(new NLAIC::CIdentType (*_Id));
00485 n.serial(f);
00486 }
00487 else throw NLMISC::EStream();
00488 }
00489
00490 const char *getInfo()
00491 {
00492 return _TxtInfo;
00493 }
00494
00495 const NLAIC::CIdentType *getConstraintTypeOf()
00496 {
00497 if(_Id == NULL)
00498 {
00499 _Id = (NLAIC::CIdentType *)_Constraint->getConstraintTypeOf();
00500 }
00501 return _Id;
00502 }
00503
00504 const IConstraint *clone() const
00505 {
00506 IConstraint *x = new COperandUnknown((IConstraint *)_Constraint->clone());
00507 return x;
00508 }
00509
00510 void run(CCompilateur &c)
00511 {
00512 if(_Id == NULL)
00513 {
00514 _Constraint->run(c);
00515 run(_Constraint);
00516 }
00517 }
00518
00519 void run(IConstraint *c)
00520 {
00521 if(c == _Constraint)
00522 {
00523 _Id = (NLAIC::CIdentType *)_Constraint->getConstraintTypeOf();
00524 if(satisfied())
00525 {
00526 _RunIsDone = true;
00527 }
00528 }
00529 }
00530
00531 bool operator == (const IConstraint &c) const
00532 {
00533 if(getTypeOfClass() == c.getTypeOfClass() && *((const COperandUnknown &)c)._Constraint == *_Constraint)
00534 {
00535 return true;
00536 }
00537 return false;
00538 }
00539
00540 bool dependOn(const IConstraint *c) const
00541 {
00542 return _Constraint == c || _Constraint->dependOn(c);
00543 }
00544 virtual ConstraintTypeEnum getTypeOfClass() const
00545 {
00546 return operandUnknown;
00547 }
00548
00549 bool satisfied()
00550 {
00551 return getConstraintTypeOf() != NULL;
00552 }
00553
00554 virtual ~COperandUnknown()
00555 {
00556 if (_Constraint != NULL)
00557 {
00558 if(!_RunIsDone) _Constraint->popConstraint(this);
00559
00560 _Constraint->release();
00561 _Constraint = NULL;
00562
00563 }
00564 delete _TxtInfo;
00565 }
00566 };
00567
00577 class COperationType: public IOpType
00578 {
00579 private:
00581 IOpType *_Operand;
00583 NLAIC::CTypeOfOperator::TTypeOp _Op;
00584 char *_TxtInfo;
00585 NLAIC::CIdentType *_Id;
00586 public:
00587 COperationType(const IOpType &operand,NLAIC::CTypeOfOperator::TTypeOp op):
00588 _Operand((IOpType *)operand.clone()),_Op(op)
00589 {
00590
00591 char txt[1028*8];
00592 sprintf(txt,"constraint<COperationType> for %s",_Operand->getInfo());
00593 _TxtInfo = new char [strlen(txt) + 1];
00594 strcpy(_TxtInfo,txt);
00595 _Id = NULL;
00596 }
00597
00598
00599 COperationType():_Operand(NULL),_Op((NLAIC::CTypeOfOperator::TTypeOp)0)
00600 {
00601 _Id = NULL;
00602 }
00603
00604 virtual void serial(NLMISC::IStream &f) throw(NLMISC::EStream)
00605 {
00606 if(_Id != NULL)
00607 {
00608 COperandSimple n(new NLAIC::CIdentType (*_Id));
00609 n.serial(f);
00610 }
00611 else throw NLMISC::EStream();
00612 }
00613
00614 const char *getInfo()
00615 {
00616 return _TxtInfo;
00617 }
00618
00619 void setOp(NLAIC::CTypeOfOperator::TTypeOp op)
00620 {
00621 _Op = op;
00622 }
00623
00624 void setOperand(IOpType *operand)
00625 {
00626 _Operand = operand;
00627 char txt[1028*8];
00628 sprintf(txt,"constraint<COperationType> for %s",operand->getInfo());
00629 _TxtInfo = new char [strlen(txt) + 1];
00630 strcpy(_TxtInfo,txt);
00631 }
00632
00633 bool dependOn(const IConstraint *c) const
00634 {
00635 return _Operand->dependOn(c);
00636 }
00637
00638 virtual void run(CCompilateur &c)
00639 {
00640 _Operand->run(c);
00641 _Id = (NLAIC::CIdentType *)getConstraintTypeOf();
00642 }
00643
00644
00645 void run(IConstraint *c)
00646 {
00647 }
00648
00649 const NLAIC::CIdentType *getConstraintTypeOf()
00650 {
00651 if(_Id) return _Id;
00652 else return (_Id = (NLAIC::CIdentType *)_Operand->getConstraintTypeOf());
00653 }
00654
00655 bool satisfied()
00656 {
00657 return getConstraintTypeOf() != NULL;
00658 }
00659
00660 const IConstraint *clone() const
00661 {
00662 IConstraint *x = new COperationType((const COperationType &)*_Operand,_Op);
00663 return x;
00664 }
00665
00666
00667 bool operator == (const IConstraint &c) const
00668 {
00669 if(getTypeOfClass() == c.getTypeOfClass() && *((const COperationType &)c)._Operand == *_Operand && ((const COperationType &)c)._Op == _Op)
00670 {
00671 return true;
00672 }
00673 return false;
00674 }
00675
00676 virtual ConstraintTypeEnum getTypeOfClass() const
00677 {
00678 return operationType;
00679 }
00680
00681 virtual ~COperationType()
00682 {
00683 _Operand->release();
00684 delete _TxtInfo;
00685 }
00686 };
00687
00697 class COperationTypeGD: public IOpType
00698 {
00699 private:
00701 IOpType *_OpG;
00702
00703 IOpType *_OpD;
00705 NLAIC::CTypeOfOperator::TTypeOp _Op;
00706 char *_TxtInfo;
00707 NLAIC::CIdentType *_Id;
00708 public:
00709 COperationTypeGD(const COperationType &opG,const COperationType &opD,NLAIC::CTypeOfOperator::TTypeOp op):
00710 _OpG((IOpType *)opG.clone()),_OpD((IOpType *)opD.clone()),_Op(op)
00711 {
00712 char txt[1028*8];
00713 sprintf(txt,"constraint<COperationType> for <%s> <%s>",_OpG->getInfo(),_OpD->getInfo());
00714 _TxtInfo = new char [strlen(txt) + 1];
00715 strcpy(_TxtInfo,txt);
00716 _Id = NULL;
00717 _TxtInfo = NULL;
00718
00719 }
00720
00721 COperationTypeGD()
00722 {
00723 _OpG = _OpD = NULL;
00724 _Op = (NLAIC::CTypeOfOperator::TTypeOp)0;
00725 _Id = NULL;
00726 _TxtInfo = NULL;
00727 }
00728
00729 virtual void serial(NLMISC::IStream &f) throw(NLMISC::EStream)
00730 {
00731 if(_Id != NULL)
00732 {
00733 COperandSimple n(new NLAIC::CIdentType (*_Id));
00734 n.serial(f);
00735 }
00736 else throw NLMISC::EStream();
00737 }
00738
00739 const char *getInfo()
00740 {
00741 if(_TxtInfo == NULL)
00742 {
00743 char txt[1028*8];
00744 sprintf(txt,"constraint<COperationTypeGD> for <%s> <%s>",_OpG->getInfo(),_OpD->getInfo());
00745 _TxtInfo = new char [strlen(txt) + 1];
00746 strcpy(_TxtInfo,txt);
00747 }
00748 return _TxtInfo;
00749 }
00750
00751 bool dependOn(const IConstraint *c) const
00752 {
00753 return _OpG->dependOn(c) || c == _OpG || _OpD->dependOn(c) || c == _OpD;
00754 }
00755
00756 void setOp(NLAIC::CTypeOfOperator::TTypeOp op)
00757 {
00758 _Op = op;
00759 }
00760
00761 void setOperationG(IOpType *opG)
00762 {
00763 _OpG = opG;
00764
00765 }
00766
00767 void setOperationD(IOpType *opD)
00768 {
00769 _OpD = opD;
00770 }
00771
00772 const IConstraint *clone() const
00773 {
00774 IConstraint *x = new COperationTypeGD ((const COperationType &)*_OpG,(const COperationType &)*_OpD,_Op);
00775 return x;
00776 }
00777
00778 virtual void run(CCompilateur &c)
00779 {
00780 _OpG->run(c);
00781 _OpD->run(c);
00782
00783 _Id = (NLAIC::CIdentType *)getConstraintTypeOf();
00784 }
00785
00786
00787 void run(IConstraint *c)
00788 {
00789 }
00790
00791 const NLAIC::CIdentType *getConstraintTypeOf()
00792 {
00793 if(satisfied()) return (_Id = (NLAIC::CIdentType *)_OpG->getConstraintTypeOf());
00794 return NULL;
00795 }
00796
00797 bool satisfied();
00798
00799
00800 bool operator == (const IConstraint &c) const
00801 {
00802 if(getTypeOfClass() == c.getTypeOfClass() && *((const COperationTypeGD &)c)._OpG == *_OpG && *((const COperationTypeGD &)c)._OpD == *_OpD)
00803 {
00804 return true;
00805 }
00806 return false;
00807 }
00808
00809
00810 virtual ConstraintTypeEnum getTypeOfClass() const
00811 {
00812 return operationTypeGD;
00813 }
00814
00815 virtual ~COperationTypeGD()
00816 {
00817 if(_OpG) _OpG->release();
00818 if(_OpD) _OpD->release();
00819 delete _TxtInfo;
00820 }
00821 };
00822
00833 class COperandListType: public IOpType
00834 {
00835 private:
00836 std::list<IOpType *> _List;
00837 NLAIC::CIdentType *_Id;
00838 bool _S;
00839 char *_TxtInfo;
00840 public:
00841
00842 COperandListType(const COperandListType &c)
00843 {
00844 std::list<IOpType *>::const_iterator i = c._List.begin();
00845 _S = c._S;
00846 while(i != c._List.end())
00847 {
00848 _List.push_back(*i);
00849 (*i)->incRef();
00850 i ++;
00851 }
00852 _TxtInfo = new char [strlen(c._TxtInfo) + 1];
00853 strcpy(_TxtInfo,c._TxtInfo);
00854 if(c._Id) _Id = new NLAIC::CIdentType (*c._Id);
00855 }
00856
00857 COperandListType()
00858 {
00859 _Id = NULL;
00860 _S = false;
00861 char txt[1028*8];
00862 sprintf(txt,"constraint<COperandListType>");
00863 _TxtInfo = new char [strlen(txt) + 1];
00864 strcpy(_TxtInfo,txt);
00865 }
00866
00867 virtual void serial(NLMISC::IStream &f) throw(NLMISC::EStream)
00868 {
00869 if(_Id != NULL)
00870 {
00871 COperandSimple n(new NLAIC::CIdentType (*_Id));
00872 n.serial(f);
00873 }
00874 else throw NLMISC::EStream();
00875 }
00876
00877 virtual ConstraintTypeEnum getTypeOfClass() const
00878 {
00879 return operandListType;
00880 }
00881
00882 const IConstraint *clone() const
00883 {
00884 IConstraint *x = new COperandListType (*this);
00885 return x;
00886 }
00887
00888 const NLAIC::CIdentType *getConstraintTypeOf()
00889 {
00890 return _Id;
00891 }
00892
00893 bool operator == (const IConstraint &c) const
00894 {
00895 if(getTypeOfClass() == c.getTypeOfClass())
00896 {
00897 const COperandListType &o = (const COperandListType &)c;
00898
00899 if(o._List.size() != _List.size()) return false;
00900
00901 std::list<IOpType *>::const_iterator i = o._List.begin();
00902 std::list<IOpType *>::const_iterator j = _List.begin();
00903 while(j != _List.end())
00904 {
00905 if(!(*(*i) == *(*j))) return false;
00906 i ++;
00907 j ++;
00908 }
00909 return true;
00910 }
00911 else
00912 {
00913 std::list<IOpType *>::const_iterator j = _List.begin();
00914 while(j != _List.end())
00915 {
00916 if( c == *(*j)) return true;
00917 j ++;
00918 }
00919 return false;
00920 }
00921 return false;
00922 }
00923
00924 const char *getInfo()
00925 {
00926 return _TxtInfo;
00927 }
00928
00929 bool satisfied()
00930 {
00931 return _S;
00932 }
00933
00934 void run(CCompilateur &c)
00935 {
00936 std::list<IOpType *>::iterator i = _List.begin();
00937 _S = true;
00938 while(i != _List.end())
00939 {
00940 IOpType *o = *i++;
00941 o->run(c);
00942 if(o->satisfied())
00943 {
00944 if(_Id == NULL)
00945 {
00946 _Id = new NLAIC::CIdentType(*o->getConstraintTypeOf());
00947 }
00948 else if(!(*_Id == *o->getConstraintTypeOf())) _S = false;
00949 }
00950 }
00951 }
00952
00953 bool dependOn(const IConstraint *a) const
00954 {
00955 std::list<IOpType *>::const_iterator i = _List.begin();
00956 while(i != _List.end())
00957 {
00958 const IConstraint *o = *i++;
00959 if(a == o || o->dependOn(a)) return true;
00960 }
00961 return false;
00962 }
00963
00964 void add(IOpType *o)
00965 {
00966 _List.push_back(o);
00967 }
00968
00969 virtual ~COperandListType()
00970 {
00971 while(_List.size())
00972 {
00973 _List.back()->release();
00974 _List.pop_back();
00975 }
00976 if(_Id) delete _Id;
00977 delete _TxtInfo;
00978 }
00979
00980
00981 };
00982
00984 inline const IOpType *IOpType::loadIOpType(NLMISC::IStream &f)
00985 {
00986 IConstraint::ConstraintTypeEnum k = constraintMethode;
00987 IOpType *x;
00988
00989 f.serial((sint32 &)k);
00990
00991 switch(k)
00992 {
00993 case operandAnyObject:
00994 x = new COperandAnyObject();
00995 return x;
00996
00997 case operandVoid:
00998 x = new COperandVoid();
00999 return x;
01000
01001 case operandSimple:
01002 x = new COperandSimple(f);
01003 return x;
01004
01005 case operandSimpleListOr:
01006 x = new COperandSimpleListOr(f);
01007 return x;
01008 default: break;
01009 }
01010 return NULL;
01011 }
01012 }
01013 #endif
