/[svn]/linuxsampler/trunk/src/scriptvm/tree.cpp
ViewVC logotype

Diff of /linuxsampler/trunk/src/scriptvm/tree.cpp

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 3556 by schoenebeck, Thu Aug 1 10:22:56 2019 UTC revision 3557 by schoenebeck, Sun Aug 18 00:06:04 2019 UTC
# Line 36  String IntExpr::evalCastToStr() { Line 36  String IntExpr::evalCastToStr() {
36    
37  String IntArrayExpr::evalCastToStr() {  String IntArrayExpr::evalCastToStr() {
38      String s = "{";      String s = "{";
39      for (int i = 0; i < arraySize(); ++i) {      for (vmint i = 0; i < arraySize(); ++i) {
40          int val = evalIntElement(i);          vmint val = evalIntElement(i);
41          if (i) s += ",";          if (i) s += ",";
42          s += ToString(val);          s += ToString(val);
43      }      }
# Line 45  String IntArrayExpr::evalCastToStr() { Line 45  String IntArrayExpr::evalCastToStr() {
45      return s;      return s;
46  }  }
47    
48  int IntLiteral::evalInt() {  vmint IntLiteral::evalInt() {
49      return value;      return value;
50  }  }
51    
52  void IntLiteral::dump(int level) {  void IntLiteral::dump(int level) {
53      printIndents(level);      printIndents(level);
54      printf("IntLiteral %d\n", value);      printf("IntLiteral %lld\n", value);
55  }  }
56    
57  void StringLiteral::dump(int level) {  void StringLiteral::dump(int level) {
# Line 59  void StringLiteral::dump(int level) { Line 59  void StringLiteral::dump(int level) {
59      printf("StringLiteral: '%s'\n", value.c_str());      printf("StringLiteral: '%s'\n", value.c_str());
60  }  }
61    
62  int Add::evalInt() {  vmint Add::evalInt() {
63      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
64      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);;      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);;
65      return (pLHS && pRHS) ? pLHS->evalInt() + pRHS->evalInt() : 0;      return (pLHS && pRHS) ? pLHS->evalInt() + pRHS->evalInt() : 0;
# Line 76  void Add::dump(int level) { Line 76  void Add::dump(int level) {
76      printf(")\n");      printf(")\n");
77  }  }
78    
79  int Sub::evalInt() {  vmint Sub::evalInt() {
80      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
81      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);;      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);;
82      return (pLHS && pRHS) ? pLHS->evalInt() - pRHS->evalInt() : 0;      return (pLHS && pRHS) ? pLHS->evalInt() - pRHS->evalInt() : 0;
# Line 93  void Sub::dump(int level) { Line 93  void Sub::dump(int level) {
93      printf(")\n");      printf(")\n");
94  }  }
95    
96  int Mul::evalInt() {  vmint Mul::evalInt() {
97      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
98      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);;      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);;
99      return (pLHS && pRHS) ? pLHS->evalInt() * pRHS->evalInt() : 0;      return (pLHS && pRHS) ? pLHS->evalInt() * pRHS->evalInt() : 0;
# Line 110  void Mul::dump(int level) { Line 110  void Mul::dump(int level) {
110      printf(")\n");      printf(")\n");
111  }  }
112    
113  int Div::evalInt() {  vmint Div::evalInt() {
114      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
115      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);
116      if (!pLHS || !pRHS) return 0;      if (!pLHS || !pRHS) return 0;
117      int l = pLHS->evalInt();      vmint l = pLHS->evalInt();
118      int r = pRHS->evalInt();      vmint r = pRHS->evalInt();
119      if (r == 0) return 0;      if (r == 0) return 0;
120      return l / r;      return l / r;
121  }  }
# Line 131  void Div::dump(int level) { Line 131  void Div::dump(int level) {
131      printf(")\n");      printf(")\n");
132  }  }
133    
134  int Mod::evalInt() {  vmint Mod::evalInt() {
135      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
136      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);;      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);;
137      return (pLHS && pRHS) ? pLHS->evalInt() % pRHS->evalInt() : 0;      return (pLHS && pRHS) ? pLHS->evalInt() % pRHS->evalInt() : 0;
# Line 159  void Args::dump(int level) { Line 159  void Args::dump(int level) {
159  }  }
160    
161  bool Args::isPolyphonic() const {  bool Args::isPolyphonic() const {
162      for (int i = 0; i < args.size(); ++i)      for (vmint i = 0; i < args.size(); ++i)
163          if (args[i]->isPolyphonic())          if (args[i]->isPolyphonic())
164              return true;              return true;
165      return false;      return false;
# Line 187  void EventHandlers::dump(int level) { Line 187  void EventHandlers::dump(int level) {
187  }  }
188    
189  EventHandler* EventHandlers::eventHandlerByName(const String& name) const {  EventHandler* EventHandlers::eventHandlerByName(const String& name) const {
190      for (int i = 0; i < args.size(); ++i)      for (vmint i = 0; i < args.size(); ++i)
191          if (args.at(i)->eventHandlerName() == name)          if (args.at(i)->eventHandlerName() == name)
192              return const_cast<EventHandler*>(&*args.at(i));              return const_cast<EventHandler*>(&*args.at(i));
193      return NULL;      return NULL;
# Line 199  EventHandler* EventHandlers::eventHandle Line 199  EventHandler* EventHandlers::eventHandle
199  }  }
200    
201  bool EventHandlers::isPolyphonic() const {  bool EventHandlers::isPolyphonic() const {
202      for (int i = 0; i < args.size(); ++i)      for (vmint i = 0; i < args.size(); ++i)
203          if (args[i]->isPolyphonic())          if (args[i]->isPolyphonic())
204              return true;              return true;
205      return false;      return false;
# Line 251  Statement* Statements::statement(uint i) Line 251  Statement* Statements::statement(uint i)
251  }  }
252    
253  bool Statements::isPolyphonic() const {  bool Statements::isPolyphonic() const {
254      for (int i = 0; i < args.size(); ++i)      for (vmint i = 0; i < args.size(); ++i)
255          if (args[i]->isPolyphonic())          if (args[i]->isPolyphonic())
256              return true;              return true;
257      return false;      return false;
# Line 262  DynamicVariableCall::DynamicVariableCall Line 262  DynamicVariableCall::DynamicVariableCall
262  {  {
263  }  }
264    
265  int DynamicVariableCall::evalInt() {  vmint DynamicVariableCall::evalInt() {
266      VMIntExpr* expr = dynamic_cast<VMIntExpr*>(dynVar);      VMIntExpr* expr = dynamic_cast<VMIntExpr*>(dynVar);
267      if (!expr) return 0;      if (!expr) return 0;
268      return expr->evalInt();      return expr->evalInt();
# Line 315  StmtFlags_t FunctionCall::exec() { Line 315  StmtFlags_t FunctionCall::exec() {
315      return result->resultFlags();      return result->resultFlags();
316  }  }
317    
318  int FunctionCall::evalInt() {  vmint FunctionCall::evalInt() {
319      VMFnResult* result = execVMFn();      VMFnResult* result = execVMFn();
320      if (!result) return 0;      if (!result) return 0;
321      VMIntExpr* intExpr = dynamic_cast<VMIntExpr*>(result->resultValue());      VMIntExpr* intExpr = dynamic_cast<VMIntExpr*>(result->resultValue());
# Line 357  IntVariable::IntVariable(ParserContext* Line 357  IntVariable::IntVariable(ParserContext*
357      assert(ctx);      assert(ctx);
358  }  }
359    
360  inline static int postfixInc(int& object, int incBy) {  inline static vmint postfixInc(vmint& object, vmint incBy) {
361      const int i = object;      const vmint i = object;
362      object += incBy;      object += incBy;
363      return i;      return i;
364  }  }
365    
366  IntVariable::IntVariable(ParserContext* ctx, bool polyphonic, bool bConst, int size)  IntVariable::IntVariable(ParserContext* ctx, bool polyphonic, bool bConst, vmint size)
367      : Variable(ctx, !ctx ? 0 : polyphonic ? postfixInc(ctx->polyphonicIntVarCount, size) : postfixInc(ctx->globalIntVarCount, size), bConst),      : Variable(ctx, !ctx ? 0 : polyphonic ? postfixInc(ctx->polyphonicIntVarCount, size) : postfixInc(ctx->globalIntVarCount, size), bConst),
368        polyphonic(polyphonic)        polyphonic(polyphonic)
369  {  {
# Line 384  void IntVariable::assign(Expression* exp Line 384  void IntVariable::assign(Expression* exp
384      }      }
385  }  }
386    
387  int IntVariable::evalInt() {  vmint IntVariable::evalInt() {
388      //printf("IntVariable::eval pos=%d\n", memPos);      //printf("IntVariable::eval pos=%d\n", memPos);
389      if (polyphonic) {      if (polyphonic) {
390          //printf("evalInt() poly memPos=%d execCtx=0x%lx\n", memPos, (uint64_t)context->execContext);          //printf("evalInt() poly memPos=%d execCtx=0x%lx\n", memPos, (uint64_t)context->execContext);
# Line 400  void IntVariable::dump(int level) { Line 400  void IntVariable::dump(int level) {
400  }  }
401    
402  //ConstIntVariable::ConstIntVariable(ParserContext* ctx, int value)  //ConstIntVariable::ConstIntVariable(ParserContext* ctx, int value)
403  ConstIntVariable::ConstIntVariable(int value)  ConstIntVariable::ConstIntVariable(vmint value)
404      : IntVariable(NULL,false,true), value(value)      : IntVariable(NULL,false,true), value(value)
405  {  {
406  }  }
# Line 416  void ConstIntVariable::assign(Expression Line 416  void ConstIntVariable::assign(Expression
416  */  */
417  }  }
418    
419  int ConstIntVariable::evalInt() {  vmint ConstIntVariable::evalInt() {
420      return value;      return value;
421  }  }
422    
423  void ConstIntVariable::dump(int level) {  void ConstIntVariable::dump(int level) {
424      printIndents(level);      printIndents(level);
425      printf("ConstIntVariable val=%d\n", value);      printf("ConstIntVariable val=%lld\n", value);
426  }  }
427    
428  BuiltInIntVariable::BuiltInIntVariable(const String& name, VMIntRelPtr* ptr)  BuiltInIntVariable::BuiltInIntVariable(const String& name, VMIntPtr* ptr)
429      : IntVariable(NULL,false,false), name(name), ptr(ptr)      : IntVariable(NULL,false,false), name(name), ptr(ptr)
430  {  {
431  }  }
# Line 436  void BuiltInIntVariable::assign(Expressi Line 436  void BuiltInIntVariable::assign(Expressi
436      ptr->assign(valueExpr->evalInt());      ptr->assign(valueExpr->evalInt());
437  }  }
438    
439  int BuiltInIntVariable::evalInt() {  vmint BuiltInIntVariable::evalInt() {
440      return ptr->evalInt();      return ptr->evalInt();
441  }  }
442    
# Line 455  void PolyphonicIntVariable::dump(int lev Line 455  void PolyphonicIntVariable::dump(int lev
455      printf("PolyphonicIntVariable\n");      printf("PolyphonicIntVariable\n");
456  }  }
457    
458  IntArrayVariable::IntArrayVariable(ParserContext* ctx, int size)  IntArrayVariable::IntArrayVariable(ParserContext* ctx, vmint size)
459      : Variable(ctx, 0, false)      : Variable(ctx, 0, false)
460  {  {
461      values.resize(size);      values.resize(size);
462      memset(&values[0], 0, size * sizeof(int));      memset(&values[0], 0, size * sizeof(vmint));
463  }  }
464    
465  IntArrayVariable::IntArrayVariable(ParserContext* ctx, int size, ArgsRef values, bool _bConst)  IntArrayVariable::IntArrayVariable(ParserContext* ctx, vmint size, ArgsRef values, bool _bConst)
466      : Variable(ctx, 0, _bConst)      : Variable(ctx, 0, _bConst)
467  {  {
468      this->values.resize(size);      this->values.resize(size);
469      for (int i = 0; i < values->argsCount(); ++i) {      for (vmint i = 0; i < values->argsCount(); ++i) {
470          VMIntExpr* expr = dynamic_cast<VMIntExpr*>(values->arg(i));          VMIntExpr* expr = dynamic_cast<VMIntExpr*>(values->arg(i));
471          if (expr) this->values[i] = expr->evalInt();          if (expr) this->values[i] = expr->evalInt();
472      }      }
# Line 477  IntArrayVariable::IntArrayVariable(Parse Line 477  IntArrayVariable::IntArrayVariable(Parse
477  {  {
478  }  }
479    
480  int IntArrayVariable::evalIntElement(uint i) {  vmint IntArrayVariable::evalIntElement(vmuint i) {
481      if (i >= values.size()) return 0;      if (i >= values.size()) return 0;
482      return values[i];      return values[i];
483  }  }
484    
485  void IntArrayVariable::assignIntElement(uint i, int value) {  void IntArrayVariable::assignIntElement(vmuint i, vmint value) {
486      if (i >= values.size()) return;      if (i >= values.size()) return;
487      values[i] = value;      values[i] = value;
488  }  }
# Line 490  void IntArrayVariable::assignIntElement( Line 490  void IntArrayVariable::assignIntElement(
490  void IntArrayVariable::dump(int level) {  void IntArrayVariable::dump(int level) {
491      printIndents(level);      printIndents(level);
492      printf("IntArray(");      printf("IntArray(");
493      for (int i = 0; i < values.size(); ++i) {      for (vmint i = 0; i < values.size(); ++i) {
494          if (i % 12 == 0) {          if (i % 12 == 0) {
495              printf("\n");              printf("\n");
496              printIndents(level+1);              printIndents(level+1);
497          }          }
498          printf("%d, ", values[i]);          printf("%lld, ", values[i]);
499      }      }
500      printIndents(level);      printIndents(level);
501      printf(")\n");      printf(")\n");
# Line 506  BuiltInIntArrayVariable::BuiltInIntArray Line 506  BuiltInIntArrayVariable::BuiltInIntArray
506  {  {
507  }  }
508    
509  int BuiltInIntArrayVariable::evalIntElement(uint i) {  vmint BuiltInIntArrayVariable::evalIntElement(vmuint i) {
510      return i >= array->size ? 0 : array->data[i];      return i >= array->size ? 0 : array->data[i];
511  }  }
512    
513  void BuiltInIntArrayVariable::assignIntElement(uint i, int value) {  void BuiltInIntArrayVariable::assignIntElement(vmuint i, vmint value) {
514      if (i >= array->size) return;      if (i >= array->size) return;
515      array->data[i] = value;      array->data[i] = value;
516  }  }
# Line 528  IntArrayElement::IntArrayElement(IntArra Line 528  IntArrayElement::IntArrayElement(IntArra
528  void IntArrayElement::assign(Expression* expr) {  void IntArrayElement::assign(Expression* expr) {
529      IntExpr* valueExpr = dynamic_cast<IntExpr*>(expr);      IntExpr* valueExpr = dynamic_cast<IntExpr*>(expr);
530      if (!valueExpr) return;      if (!valueExpr) return;
531      int value = valueExpr->evalInt();      vmint value = valueExpr->evalInt();
532    
533      if (!index) return;      if (!index) return;
534      int idx = index->evalInt();      vmint idx = index->evalInt();
535      if (idx < 0 || idx >= array->arraySize()) return;      if (idx < 0 || idx >= array->arraySize()) return;
536    
537      array->assignIntElement(idx, value);      array->assignIntElement(idx, value);
538  }  }
539    
540  int IntArrayElement::evalInt() {  vmint IntArrayElement::evalInt() {
541      if (!index) return 0;      if (!index) return 0;
542      int idx = index->evalInt();      vmint idx = index->evalInt();
543      if (idx < 0 || idx >= array->arraySize()) return 0;      if (idx < 0 || idx >= array->arraySize()) return 0;
544    
545      return array->evalIntElement(idx);      return array->evalIntElement(idx);
# Line 572  String StringVariable::evalStr() { Line 572  String StringVariable::evalStr() {
572    
573  void StringVariable::dump(int level) {  void StringVariable::dump(int level) {
574      printIndents(level);      printIndents(level);
575      printf("StringVariable memPos=%d\n", memPos);      printf("StringVariable memPos=%lld\n", memPos);
576  }  }
577    
578  ConstStringVariable::ConstStringVariable(ParserContext* ctx, String _value)  ConstStringVariable::ConstStringVariable(ParserContext* ctx, String _value)
# Line 605  void If::dump(int level) { Line 605  void If::dump(int level) {
605          printf("if [INVALID]\n");          printf("if [INVALID]\n");
606  }  }
607    
608  int If::evalBranch() {  vmint If::evalBranch() {
609      if (condition->evalInt()) return 0;      if (condition->evalInt()) return 0;
610      if (elseStatements) return 1;      if (elseStatements) return 1;
611      return -1;      return -1;
612  }  }
613    
614  Statements* If::branch(uint i) const {  Statements* If::branch(vmuint i) const {
615      if (i == 0) return (Statements*) &*ifStatements;      if (i == 0) return (Statements*) &*ifStatements;
616      if (i == 1) return (elseStatements) ? (Statements*) &*elseStatements : NULL;      if (i == 1) return (elseStatements) ? (Statements*) &*elseStatements : NULL;
617      return NULL;      return NULL;
# Line 627  void SelectCase::dump(int level) { Line 627  void SelectCase::dump(int level) {
627      printIndents(level);      printIndents(level);
628      if (select)      if (select)
629          if (select->isConstExpr())          if (select->isConstExpr())
630              printf("Case select %d\n", select->evalInt());              printf("Case select %lld\n", select->evalInt());
631          else          else
632              printf("Case select [runtime expr]\n");              printf("Case select [runtime expr]\n");
633      else      else
634          printf("Case select NULL\n");          printf("Case select NULL\n");
635      for (int i = 0; i < branches.size(); ++i) {      for (vmint i = 0; i < branches.size(); ++i) {
636          printIndents(level+1);          printIndents(level+1);
637          CaseBranch& branch = branches[i];          CaseBranch& branch = branches[i];
638          if (branch.from && branch.to)          if (branch.from && branch.to)
639              if (branch.from->isConstExpr() && branch.to->isConstExpr())              if (branch.from->isConstExpr() && branch.to->isConstExpr())
640                  printf("case %d to %d\n", branch.from->evalInt(), branch.to->evalInt());                  printf("case %lld to %lld\n", branch.from->evalInt(), branch.to->evalInt());
641              else if (branch.from->isConstExpr() && !branch.to->isConstExpr())              else if (branch.from->isConstExpr() && !branch.to->isConstExpr())
642                  printf("case %d to [runtime expr]\n", branch.from->evalInt());                  printf("case %lld to [runtime expr]\n", branch.from->evalInt());
643              else if (!branch.from->isConstExpr() && branch.to->isConstExpr())              else if (!branch.from->isConstExpr() && branch.to->isConstExpr())
644                  printf("case [runtime expr] to %d\n", branch.to->evalInt());                  printf("case [runtime expr] to %lld\n", branch.to->evalInt());
645              else              else
646                  printf("case [runtime expr] to [runtime expr]\n");                  printf("case [runtime expr] to [runtime expr]\n");
647          else if (branch.from)          else if (branch.from)
648              if (branch.from->isConstExpr())              if (branch.from->isConstExpr())
649                  printf("case %d\n", branch.from->evalInt());                  printf("case %lld\n", branch.from->evalInt());
650              else              else
651                  printf("case [runtime expr]\n");                  printf("case [runtime expr]\n");
652          else          else
# Line 654  void SelectCase::dump(int level) { Line 654  void SelectCase::dump(int level) {
654      }      }
655  }  }
656    
657  int SelectCase::evalBranch() {  vmint SelectCase::evalBranch() {
658      int value = select->evalInt();      vmint value = select->evalInt();
659      for (int i = 0; i < branches.size(); ++i) {      for (vmint i = 0; i < branches.size(); ++i) {
660          if (branches.at(i).from && branches.at(i).to) { // i.e. "case 4 to 7" ...          if (branches.at(i).from && branches.at(i).to) { // i.e. "case 4 to 7" ...
661              if (branches.at(i).from->evalInt() <= value &&              if (branches.at(i).from->evalInt() <= value &&
662                  branches.at(i).to->evalInt() >= value) return i;                  branches.at(i).to->evalInt() >= value) return i;
# Line 667  int SelectCase::evalBranch() { Line 667  int SelectCase::evalBranch() {
667      return -1;      return -1;
668  }  }
669    
670  Statements* SelectCase::branch(uint i) const {  Statements* SelectCase::branch(vmuint i) const {
671      if (i < branches.size())      if (i < branches.size())
672          return const_cast<Statements*>( &*branches[i].statements );          return const_cast<Statements*>( &*branches[i].statements );
673      return NULL;      return NULL;
# Line 675  Statements* SelectCase::branch(uint i) c Line 675  Statements* SelectCase::branch(uint i) c
675    
676  bool SelectCase::isPolyphonic() const {  bool SelectCase::isPolyphonic() const {
677      if (select->isPolyphonic()) return true;      if (select->isPolyphonic()) return true;
678      for (int i = 0; i < branches.size(); ++i)      for (vmint i = 0; i < branches.size(); ++i)
679          if (branches[i].statements->isPolyphonic())          if (branches[i].statements->isPolyphonic())
680              return true;              return true;
681      return false;      return false;
# Line 704  void While::dump(int level) { Line 704  void While::dump(int level) {
704      printIndents(level);      printIndents(level);
705      if (m_condition)      if (m_condition)
706          if (m_condition->isConstExpr())          if (m_condition->isConstExpr())
707              printf("while (%d) {\n", m_condition->evalInt());              printf("while (%lld) {\n", m_condition->evalInt());
708          else          else
709              printf("while ([runtime expr]) {\n");              printf("while ([runtime expr]) {\n");
710      else      else
# Line 768  bool ConcatString::isConstExpr() const { Line 768  bool ConcatString::isConstExpr() const {
768      return lhs->isConstExpr() && rhs->isConstExpr();      return lhs->isConstExpr() && rhs->isConstExpr();
769  }  }
770    
771  int Relation::evalInt() {  vmint Relation::evalInt() {
772      switch (type) {      switch (type) {
773          case LESS_THAN:          case LESS_THAN:
774              return lhs->evalInt() < rhs->evalInt();              return lhs->evalInt() < rhs->evalInt();
# Line 826  bool Relation::isConstExpr() const { Line 826  bool Relation::isConstExpr() const {
826      return lhs->isConstExpr() && rhs->isConstExpr();      return lhs->isConstExpr() && rhs->isConstExpr();
827  }  }
828    
829  int Or::evalInt() {  vmint Or::evalInt() {
830      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
831      if (pLHS->evalInt()) return 1;      if (pLHS->evalInt()) return 1;
832      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);;      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);;
# Line 844  void Or::dump(int level) { Line 844  void Or::dump(int level) {
844      printf(")\n");      printf(")\n");
845  }  }
846    
847  int BitwiseOr::evalInt() {  vmint BitwiseOr::evalInt() {
848      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
849      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);
850      return pLHS->evalInt() | pRHS->evalInt();      return pLHS->evalInt() | pRHS->evalInt();
# Line 861  void BitwiseOr::dump(int level) { Line 861  void BitwiseOr::dump(int level) {
861      printf(")\n");      printf(")\n");
862  }  }
863    
864  int And::evalInt() {  vmint And::evalInt() {
865      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
866      if (!pLHS->evalInt()) return 0;      if (!pLHS->evalInt()) return 0;
867      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);
# Line 879  void And::dump(int level) { Line 879  void And::dump(int level) {
879      printf(")\n");      printf(")\n");
880  }  }
881    
882  int BitwiseAnd::evalInt() {  vmint BitwiseAnd::evalInt() {
883      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
884      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);
885      return pLHS->evalInt() & pRHS->evalInt();      return pLHS->evalInt() & pRHS->evalInt();
# Line 1030  VMEventHandler* ParserContext::eventHand Line 1030  VMEventHandler* ParserContext::eventHand
1030      return handlers->eventHandlerByName(name);      return handlers->eventHandlerByName(name);
1031  }  }
1032    
1033  void ParserContext::registerBuiltInConstIntVariables(const std::map<String,int>& vars) {  void ParserContext::registerBuiltInConstIntVariables(const std::map<String,vmint>& vars) {
1034      for (std::map<String,int>::const_iterator it = vars.begin();      for (std::map<String,vmint>::const_iterator it = vars.begin();
1035           it != vars.end(); ++it)           it != vars.end(); ++it)
1036      {      {
1037          ConstIntVariableRef ref = new ConstIntVariable(it->second);          ConstIntVariableRef ref = new ConstIntVariable(it->second);
# Line 1039  void ParserContext::registerBuiltInConst Line 1039  void ParserContext::registerBuiltInConst
1039      }      }
1040  }  }
1041    
1042  void ParserContext::registerBuiltInIntVariables(const std::map<String,VMIntRelPtr*>& vars) {  void ParserContext::registerBuiltInIntVariables(const std::map<String,VMIntPtr*>& vars) {
1043      for (std::map<String,VMIntRelPtr*>::const_iterator it = vars.begin();      for (std::map<String,VMIntPtr*>::const_iterator it = vars.begin();
1044           it != vars.end(); ++it)           it != vars.end(); ++it)
1045      {      {
1046          BuiltInIntVariableRef ref = new BuiltInIntVariable(it->first, it->second);          BuiltInIntVariableRef ref = new BuiltInIntVariable(it->first, it->second);
Legend:
Removed from v.3556  
changed lines
  Added in v.3557
  ViewVC Help
Powered by ViewVC