/[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 3260 by schoenebeck, Wed May 31 21:07:44 2017 UTC revision 3561 by schoenebeck, Fri Aug 23 11:44:00 2019 UTC
# Line 1  Line 1 
1  /*  /*
2   * Copyright (c) 2014 - 2017 Christian Schoenebeck and Andreas Persson   * Copyright (c) 2014 - 2019 Christian Schoenebeck and Andreas Persson
3   *   *
4   * http://www.linuxsampler.org   * http://www.linuxsampler.org
5   *   *
# Line 16  Line 16 
16  namespace LinuxSampler {  namespace LinuxSampler {
17            
18  bool isNoOperation(StatementRef statement) {  bool isNoOperation(StatementRef statement) {
19      NoOperation* noOp = dynamic_cast<NoOperation*>(&*statement);      return statement->statementType() == STMT_NOOP;
     return noOp;  
20  }  }
21            
22  Node::Node() {  Node::Node() {
# Line 35  String IntExpr::evalCastToStr() { Line 34  String IntExpr::evalCastToStr() {
34      return ToString(evalInt());      return ToString(evalInt());
35  }  }
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      }      }
44      s += "}";      s += "}";
45      return s;      return s;
46  }*/  }
47    
48    MetricPrefix_t Unit::unitPrefix(vmuint i) const {
49        if (i >= prefix.size()) return VM_NO_PREFIX;
50        return prefix[i];
51    }
52    
53    void Unit::setUnit(const std::vector<MetricPrefix_t>& prefix, StdUnit_t type) {
54        this->prefix.resize( prefix.size() );
55        for (vmuint i = 0; i < prefix.size(); ++i)
56            this->prefix[i] = prefix[i];
57    
58        unit = type;
59    }
60    
61    void Unit::setUnit(const MetricPrefix_t* prefixes, StdUnit_t type) {
62        unit = type;
63        prefix.clear();
64        for (int i = 0; i < 2 && prefixes[i]; ++i)
65            prefix.add(prefixes[i]);
66    }
67    
68    void Unit::copyUnitFrom(const IntExprRef& src) {
69        unit = src->unitType();
70        prefix.clear();
71        for (int i = 0; true; ++i) {
72            MetricPrefix_t p = src->unitPrefix(i);
73            if (!p) return;
74            prefix.add(p);
75        }
76    }
77    
78  int IntLiteral::evalInt() {  vmint IntLiteral::evalInt() {
79      return value;      return value;
80  }  }
81    
82  void IntLiteral::dump(int level) {  void IntLiteral::dump(int level) {
83      printIndents(level);      printIndents(level);
84      printf("IntLiteral %d\n", value);      printf("IntLiteral %lld\n", value);
85  }  }
86    
87  void StringLiteral::dump(int level) {  void StringLiteral::dump(int level) {
# Line 60  void StringLiteral::dump(int level) { Line 89  void StringLiteral::dump(int level) {
89      printf("StringLiteral: '%s'\n", value.c_str());      printf("StringLiteral: '%s'\n", value.c_str());
90  }  }
91    
92  int Add::evalInt() {  vmint Add::evalInt() {
93      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
94      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);;      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);;
95      return (pLHS && pRHS) ? pLHS->evalInt() + pRHS->evalInt() : 0;      return (pLHS && pRHS) ? pLHS->evalInt() + pRHS->evalInt() : 0;
# Line 77  void Add::dump(int level) { Line 106  void Add::dump(int level) {
106      printf(")\n");      printf(")\n");
107  }  }
108    
109  int Sub::evalInt() {  vmint Sub::evalInt() {
110      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
111      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);;      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);;
112      return (pLHS && pRHS) ? pLHS->evalInt() - pRHS->evalInt() : 0;      return (pLHS && pRHS) ? pLHS->evalInt() - pRHS->evalInt() : 0;
# Line 94  void Sub::dump(int level) { Line 123  void Sub::dump(int level) {
123      printf(")\n");      printf(")\n");
124  }  }
125    
126  int Mul::evalInt() {  vmint Mul::evalInt() {
127      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
128      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);;      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);;
129      return (pLHS && pRHS) ? pLHS->evalInt() * pRHS->evalInt() : 0;      return (pLHS && pRHS) ? pLHS->evalInt() * pRHS->evalInt() : 0;
# Line 111  void Mul::dump(int level) { Line 140  void Mul::dump(int level) {
140      printf(")\n");      printf(")\n");
141  }  }
142    
143  int Div::evalInt() {  MetricPrefix_t Mul::unitPrefix(vmuint i) const {
144        const IntExpr* pLHS = dynamic_cast<const IntExpr*>(&*lhs);
145        const IntExpr* pRHS = dynamic_cast<const IntExpr*>(&*rhs);
146        // currently the NKSP parser only allows a unit prefix on either side
147        return (pLHS->unitPrefix(0)) ? pLHS->unitPrefix(i) : pRHS->unitPrefix(i);
148    }
149    
150    StdUnit_t Mul::unitType() const {
151        const IntExpr* pLHS = dynamic_cast<const IntExpr*>(&*lhs);
152        const IntExpr* pRHS = dynamic_cast<const IntExpr*>(&*rhs);
153        // currently the NKSP parser only allows a unit type on either side
154        return (pLHS->unitType()) ? pLHS->unitType() : pRHS->unitType();
155    }
156    
157    vmint Div::evalInt() {
158      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
159      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);
160      if (!pLHS || !pRHS) return 0;      if (!pLHS || !pRHS) return 0;
161      int l = pLHS->evalInt();      vmint l = pLHS->evalInt();
162      int r = pRHS->evalInt();      vmint r = pRHS->evalInt();
163      if (r == 0) return 0;      if (r == 0) return 0;
164      return l / r;      return l / r;
165  }  }
# Line 132  void Div::dump(int level) { Line 175  void Div::dump(int level) {
175      printf(")\n");      printf(")\n");
176  }  }
177    
178  int Mod::evalInt() {  MetricPrefix_t Div::unitPrefix(vmuint i) const {
179        const IntExpr* pLHS = dynamic_cast<const IntExpr*>(&*lhs);
180        const IntExpr* pRHS = dynamic_cast<const IntExpr*>(&*rhs);
181        // currently the NKSP parser only allows either A) a unit prefix on left
182        // side and none on right side or B) an identical unit prefix on both sides
183        return (pLHS->unitPrefix(0) && pRHS->unitPrefix(0)) ? VM_NO_PREFIX : pLHS->unitPrefix(i);
184    }
185    
186    StdUnit_t Div::unitType() const {
187        const IntExpr* pLHS = dynamic_cast<const IntExpr*>(&*lhs);
188        const IntExpr* pRHS = dynamic_cast<const IntExpr*>(&*rhs);
189        // the NKSP parser only allows either A) a unit type on left side and none
190        // on right side or B) an identical unit type on both sides
191        return (pLHS->unitType() && pRHS->unitType()) ? VM_NO_UNIT : pLHS->unitType();
192    }
193    
194    vmint Mod::evalInt() {
195      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
196      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);;      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);;
197      return (pLHS && pRHS) ? pLHS->evalInt() % pRHS->evalInt() : 0;      return (pLHS && pRHS) ? pLHS->evalInt() % pRHS->evalInt() : 0;
# Line 160  void Args::dump(int level) { Line 219  void Args::dump(int level) {
219  }  }
220    
221  bool Args::isPolyphonic() const {  bool Args::isPolyphonic() const {
222      for (int i = 0; i < args.size(); ++i)      for (vmint i = 0; i < args.size(); ++i)
223          if (args[i]->isPolyphonic())          if (args[i]->isPolyphonic())
224              return true;              return true;
225      return false;      return false;
# Line 188  void EventHandlers::dump(int level) { Line 247  void EventHandlers::dump(int level) {
247  }  }
248    
249  EventHandler* EventHandlers::eventHandlerByName(const String& name) const {  EventHandler* EventHandlers::eventHandlerByName(const String& name) const {
250      for (int i = 0; i < args.size(); ++i)      for (vmint i = 0; i < args.size(); ++i)
251          if (args.at(i)->eventHandlerName() == name)          if (args.at(i)->eventHandlerName() == name)
252              return const_cast<EventHandler*>(&*args.at(i));              return const_cast<EventHandler*>(&*args.at(i));
253      return NULL;      return NULL;
# Line 200  EventHandler* EventHandlers::eventHandle Line 259  EventHandler* EventHandlers::eventHandle
259  }  }
260    
261  bool EventHandlers::isPolyphonic() const {  bool EventHandlers::isPolyphonic() const {
262      for (int i = 0; i < args.size(); ++i)      for (vmint i = 0; i < args.size(); ++i)
263          if (args[i]->isPolyphonic())          if (args[i]->isPolyphonic())
264              return true;              return true;
265      return false;      return false;
# Line 252  Statement* Statements::statement(uint i) Line 311  Statement* Statements::statement(uint i)
311  }  }
312    
313  bool Statements::isPolyphonic() const {  bool Statements::isPolyphonic() const {
314      for (int i = 0; i < args.size(); ++i)      for (vmint i = 0; i < args.size(); ++i)
315          if (args[i]->isPolyphonic())          if (args[i]->isPolyphonic())
316              return true;              return true;
317      return false;      return false;
# Line 263  DynamicVariableCall::DynamicVariableCall Line 322  DynamicVariableCall::DynamicVariableCall
322  {  {
323  }  }
324    
325  int DynamicVariableCall::evalInt() {  vmint DynamicVariableCall::evalInt() {
326      VMIntExpr* expr = dynamic_cast<VMIntExpr*>(dynVar);      VMIntExpr* expr = dynamic_cast<VMIntExpr*>(dynVar);
327      if (!expr) return 0;      if (!expr) return 0;
328      return expr->evalInt();      return expr->evalInt();
# Line 316  StmtFlags_t FunctionCall::exec() { Line 375  StmtFlags_t FunctionCall::exec() {
375      return result->resultFlags();      return result->resultFlags();
376  }  }
377    
378  int FunctionCall::evalInt() {  vmint FunctionCall::evalInt() {
379      VMFnResult* result = execVMFn();      VMFnResult* result = execVMFn();
380      if (!result) return 0;      if (!result) return 0;
381      VMIntExpr* intExpr = dynamic_cast<VMIntExpr*>(result->resultValue());      VMIntExpr* intExpr = dynamic_cast<VMIntExpr*>(result->resultValue());
# Line 352  String FunctionCall::evalCastToStr() { Line 411  String FunctionCall::evalCastToStr() {
411  }  }
412    
413  IntVariable::IntVariable(ParserContext* ctx)  IntVariable::IntVariable(ParserContext* ctx)
414      : Variable(ctx, ctx ? ctx->globalIntVarCount++ : 0, false), polyphonic(false)      : Variable(ctx, ctx ? ctx->globalIntVarCount++ : 0, false),
415          Unit(),
416          polyphonic(false), finalVal(false)
417  {  {
418      //printf("globalIntVar parserctx=0x%lx memPOS=%d\n", ctx, memPos);      //printf("globalIntVar parserctx=0x%lx memPOS=%d\n", ctx, memPos);
419      assert(ctx);      assert(ctx);
420  }  }
421    
422  inline static int postfixInc(int& object, int incBy) {  inline static vmint postfixInc(vmint& object, vmint incBy) {
423      const int i = object;      const vmint i = object;
424      object += incBy;      object += incBy;
425      return i;      return i;
426  }  }
427    
428  IntVariable::IntVariable(ParserContext* ctx, bool polyphonic, bool bConst, int size)  IntVariable::IntVariable(ParserContext* ctx, bool polyphonic, bool bConst, vmint size)
429      : 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),
430        polyphonic(polyphonic)        Unit(),
431          polyphonic(polyphonic), finalVal(false)
432  {  {
433      //printf("InvVar size=%d parserCtx=0x%lx\n", size, (uint64_t)ctx);      //printf("InvVar size=%d parserCtx=0x%lx\n", size, (uint64_t)ctx);
434      if (polyphonic) {      if (polyphonic) {
# Line 385  void IntVariable::assign(Expression* exp Line 447  void IntVariable::assign(Expression* exp
447      }      }
448  }  }
449    
450  int IntVariable::evalInt() {  vmint IntVariable::evalInt() {
451      //printf("IntVariable::eval pos=%d\n", memPos);      //printf("IntVariable::eval pos=%d\n", memPos);
452      if (polyphonic) {      if (polyphonic) {
453          //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 401  void IntVariable::dump(int level) { Line 463  void IntVariable::dump(int level) {
463  }  }
464    
465  //ConstIntVariable::ConstIntVariable(ParserContext* ctx, int value)  //ConstIntVariable::ConstIntVariable(ParserContext* ctx, int value)
466  ConstIntVariable::ConstIntVariable(int value)  ConstIntVariable::ConstIntVariable(vmint value)
467      : IntVariable(NULL,false,true), value(value)      : IntVariable(NULL,false,true), value(value)
468  {  {
469  }  }
# Line 417  void ConstIntVariable::assign(Expression Line 479  void ConstIntVariable::assign(Expression
479  */  */
480  }  }
481    
482  int ConstIntVariable::evalInt() {  vmint ConstIntVariable::evalInt() {
483      return value;      return value;
484  }  }
485    
486  void ConstIntVariable::dump(int level) {  void ConstIntVariable::dump(int level) {
487      printIndents(level);      printIndents(level);
488      printf("ConstIntVariable val=%d\n", value);      printf("ConstIntVariable val=%lld\n", value);
489  }  }
490    
491  BuiltInIntVariable::BuiltInIntVariable(const String& name, VMIntRelPtr* ptr)  BuiltInIntVariable::BuiltInIntVariable(const String& name, VMIntPtr* ptr)
492      : IntVariable(NULL,false,false), name(name), ptr(ptr)      : IntVariable(NULL,false,false), name(name), ptr(ptr)
493  {  {
494  }  }
# Line 437  void BuiltInIntVariable::assign(Expressi Line 499  void BuiltInIntVariable::assign(Expressi
499      ptr->assign(valueExpr->evalInt());      ptr->assign(valueExpr->evalInt());
500  }  }
501    
502  int BuiltInIntVariable::evalInt() {  vmint BuiltInIntVariable::evalInt() {
503      return ptr->evalInt();      return ptr->evalInt();
504  }  }
505    
# Line 456  void PolyphonicIntVariable::dump(int lev Line 518  void PolyphonicIntVariable::dump(int lev
518      printf("PolyphonicIntVariable\n");      printf("PolyphonicIntVariable\n");
519  }  }
520    
521  IntArrayVariable::IntArrayVariable(ParserContext* ctx, int size)  IntArrayVariable::IntArrayVariable(ParserContext* ctx, vmint size)
522      : Variable(ctx, 0, false)      : Variable(ctx, 0, false)
523  {  {
524      values.resize(size);      values.resize(size);
525      memset(&values[0], 0, size * sizeof(int));      memset(&values[0], 0, size * sizeof(vmint));
526  }  }
527    
528  IntArrayVariable::IntArrayVariable(ParserContext* ctx, int size, ArgsRef values, bool _bConst)  IntArrayVariable::IntArrayVariable(ParserContext* ctx, vmint size, ArgsRef values, bool _bConst)
529      : Variable(ctx, 0, _bConst)      : Variable(ctx, 0, _bConst)
530  {  {
531      this->values.resize(size);      this->values.resize(size);
532      for (int i = 0; i < values->argsCount(); ++i) {      for (vmint i = 0; i < values->argsCount(); ++i) {
533          VMIntExpr* expr = dynamic_cast<VMIntExpr*>(values->arg(i));          VMIntExpr* expr = dynamic_cast<VMIntExpr*>(values->arg(i));
534          if (expr) this->values[i] = expr->evalInt();          if (expr) this->values[i] = expr->evalInt();
535      }      }
# Line 478  IntArrayVariable::IntArrayVariable(Parse Line 540  IntArrayVariable::IntArrayVariable(Parse
540  {  {
541  }  }
542    
543  int IntArrayVariable::evalIntElement(uint i) {  vmint IntArrayVariable::evalIntElement(vmuint i) {
544      if (i >= values.size()) return 0;      if (i >= values.size()) return 0;
545      return values[i];      return values[i];
546  }  }
547    
548  void IntArrayVariable::assignIntElement(uint i, int value) {  void IntArrayVariable::assignIntElement(vmuint i, vmint value) {
549      if (i >= values.size()) return;      if (i >= values.size()) return;
550      values[i] = value;      values[i] = value;
551  }  }
# Line 491  void IntArrayVariable::assignIntElement( Line 553  void IntArrayVariable::assignIntElement(
553  void IntArrayVariable::dump(int level) {  void IntArrayVariable::dump(int level) {
554      printIndents(level);      printIndents(level);
555      printf("IntArray(");      printf("IntArray(");
556      for (int i = 0; i < values.size(); ++i) {      for (vmint i = 0; i < values.size(); ++i) {
557          if (i % 12 == 0) {          if (i % 12 == 0) {
558              printf("\n");              printf("\n");
559              printIndents(level+1);              printIndents(level+1);
560          }          }
561          printf("%d, ", values[i]);          printf("%lld, ", values[i]);
562      }      }
563      printIndents(level);      printIndents(level);
564      printf(")\n");      printf(")\n");
# Line 507  BuiltInIntArrayVariable::BuiltInIntArray Line 569  BuiltInIntArrayVariable::BuiltInIntArray
569  {  {
570  }  }
571    
572  int BuiltInIntArrayVariable::evalIntElement(uint i) {  vmint BuiltInIntArrayVariable::evalIntElement(vmuint i) {
573      return i >= array->size ? 0 : array->data[i];      return i >= array->size ? 0 : array->data[i];
574  }  }
575    
576  void BuiltInIntArrayVariable::assignIntElement(uint i, int value) {  void BuiltInIntArrayVariable::assignIntElement(vmuint i, vmint value) {
577      if (i >= array->size) return;      if (i >= array->size) return;
578      array->data[i] = value;      array->data[i] = value;
579  }  }
# Line 521  void BuiltInIntArrayVariable::dump(int l Line 583  void BuiltInIntArrayVariable::dump(int l
583      printf("Built-In Int Array Variable '%s'\n", name.c_str());      printf("Built-In Int Array Variable '%s'\n", name.c_str());
584  }  }
585    
586  IntArrayElement::IntArrayElement(IntArrayVariableRef array, IntExprRef arrayIndex)  IntArrayElement::IntArrayElement(IntArrayExprRef array, IntExprRef arrayIndex)
587      : IntVariable(NULL, false, false, 0), array(array), index(arrayIndex)      : IntVariable(NULL, false, false, 0), array(array), index(arrayIndex)
588  {      {    
589  }  }
# Line 529  IntArrayElement::IntArrayElement(IntArra Line 591  IntArrayElement::IntArrayElement(IntArra
591  void IntArrayElement::assign(Expression* expr) {  void IntArrayElement::assign(Expression* expr) {
592      IntExpr* valueExpr = dynamic_cast<IntExpr*>(expr);      IntExpr* valueExpr = dynamic_cast<IntExpr*>(expr);
593      if (!valueExpr) return;      if (!valueExpr) return;
594      int value = valueExpr->evalInt();      vmint value = valueExpr->evalInt();
595    
596      if (!index) return;      if (!index) return;
597      int idx = index->evalInt();      vmint idx = index->evalInt();
598      if (idx < 0 || idx >= array->arraySize()) return;      if (idx < 0 || idx >= array->arraySize()) return;
599    
600      array->assignIntElement(idx, value);      array->assignIntElement(idx, value);
601  }  }
602    
603  int IntArrayElement::evalInt() {  vmint IntArrayElement::evalInt() {
604      if (!index) return 0;      if (!index) return 0;
605      int idx = index->evalInt();      vmint idx = index->evalInt();
606      if (idx < 0 || idx >= array->arraySize()) return 0;      if (idx < 0 || idx >= array->arraySize()) return 0;
607    
608      return array->evalIntElement(idx);      return array->evalIntElement(idx);
# Line 573  String StringVariable::evalStr() { Line 635  String StringVariable::evalStr() {
635    
636  void StringVariable::dump(int level) {  void StringVariable::dump(int level) {
637      printIndents(level);      printIndents(level);
638      printf("StringVariable memPos=%d\n", memPos);      printf("StringVariable memPos=%lld\n", memPos);
639  }  }
640    
641  ConstStringVariable::ConstStringVariable(ParserContext* ctx, String _value)  ConstStringVariable::ConstStringVariable(ParserContext* ctx, String _value)
# Line 596  void ConstStringVariable::dump(int level Line 658  void ConstStringVariable::dump(int level
658      printf("ConstStringVariable val='%s'\n", value.c_str());      printf("ConstStringVariable val='%s'\n", value.c_str());
659  }  }
660    
661    MetricPrefix_t IntBinaryOp::unitPrefix(vmuint i) const {
662        IntExprRef l = (IntExprRef) lhs;
663        IntExprRef r = (IntExprRef) rhs;
664        return (r->unitFactor() < l->unitFactor()) ? r->unitPrefix(i) : l->unitPrefix(i);
665    }
666    
667    StdUnit_t IntBinaryOp::unitType() const {
668        IntExprRef l = (IntExprRef) lhs;
669        IntExprRef r = (IntExprRef) rhs;
670        return (l->unitType()) ? l->unitType() : r->unitType();
671    }
672    
673    bool IntBinaryOp::isFinal() const {
674        IntExprRef l = (IntExprRef) lhs;
675        IntExprRef r = (IntExprRef) rhs;
676        return l->isFinal() || r->isFinal();
677    }
678    
679  void If::dump(int level) {  void If::dump(int level) {
680      printIndents(level);      printIndents(level);
681      if (ifStatements && elseStatements)      if (ifStatements && elseStatements)
# Line 606  void If::dump(int level) { Line 686  void If::dump(int level) {
686          printf("if [INVALID]\n");          printf("if [INVALID]\n");
687  }  }
688    
689  int If::evalBranch() {  vmint If::evalBranch() {
690      if (condition->evalInt()) return 0;      if (condition->evalInt()) return 0;
691      if (elseStatements) return 1;      if (elseStatements) return 1;
692      return -1;      return -1;
693  }  }
694    
695  Statements* If::branch(uint i) const {  Statements* If::branch(vmuint i) const {
696      if (i == 0) return (Statements*) &*ifStatements;      if (i == 0) return (Statements*) &*ifStatements;
697      if (i == 1) return (elseStatements) ? (Statements*) &*elseStatements : NULL;      if (i == 1) return (elseStatements) ? (Statements*) &*elseStatements : NULL;
698      return NULL;      return NULL;
# Line 628  void SelectCase::dump(int level) { Line 708  void SelectCase::dump(int level) {
708      printIndents(level);      printIndents(level);
709      if (select)      if (select)
710          if (select->isConstExpr())          if (select->isConstExpr())
711              printf("Case select %d\n", select->evalInt());              printf("Case select %lld\n", select->evalInt());
712          else          else
713              printf("Case select [runtime expr]\n");              printf("Case select [runtime expr]\n");
714      else      else
715          printf("Case select NULL\n");          printf("Case select NULL\n");
716      for (int i = 0; i < branches.size(); ++i) {      for (vmint i = 0; i < branches.size(); ++i) {
717          printIndents(level+1);          printIndents(level+1);
718          CaseBranch& branch = branches[i];          CaseBranch& branch = branches[i];
719          if (branch.from && branch.to)          if (branch.from && branch.to)
720              if (branch.from->isConstExpr() && branch.to->isConstExpr())              if (branch.from->isConstExpr() && branch.to->isConstExpr())
721                  printf("case %d to %d\n", branch.from->evalInt(), branch.to->evalInt());                  printf("case %lld to %lld\n", branch.from->evalInt(), branch.to->evalInt());
722              else if (branch.from->isConstExpr() && !branch.to->isConstExpr())              else if (branch.from->isConstExpr() && !branch.to->isConstExpr())
723                  printf("case %d to [runtime expr]\n", branch.from->evalInt());                  printf("case %lld to [runtime expr]\n", branch.from->evalInt());
724              else if (!branch.from->isConstExpr() && branch.to->isConstExpr())              else if (!branch.from->isConstExpr() && branch.to->isConstExpr())
725                  printf("case [runtime expr] to %d\n", branch.to->evalInt());                  printf("case [runtime expr] to %lld\n", branch.to->evalInt());
726              else              else
727                  printf("case [runtime expr] to [runtime expr]\n");                  printf("case [runtime expr] to [runtime expr]\n");
728          else if (branch.from)          else if (branch.from)
729              if (branch.from->isConstExpr())              if (branch.from->isConstExpr())
730                  printf("case %d\n", branch.from->evalInt());                  printf("case %lld\n", branch.from->evalInt());
731              else              else
732                  printf("case [runtime expr]\n");                  printf("case [runtime expr]\n");
733          else          else
# Line 655  void SelectCase::dump(int level) { Line 735  void SelectCase::dump(int level) {
735      }      }
736  }  }
737    
738  int SelectCase::evalBranch() {  vmint SelectCase::evalBranch() {
739      int value = select->evalInt();      vmint value = select->evalInt();
740      for (int i = 0; i < branches.size(); ++i) {      for (vmint i = 0; i < branches.size(); ++i) {
741          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" ...
742              if (branches.at(i).from->evalInt() <= value &&              if (branches.at(i).from->evalInt() <= value &&
743                  branches.at(i).to->evalInt() >= value) return i;                  branches.at(i).to->evalInt() >= value) return i;
# Line 668  int SelectCase::evalBranch() { Line 748  int SelectCase::evalBranch() {
748      return -1;      return -1;
749  }  }
750    
751  Statements* SelectCase::branch(uint i) const {  Statements* SelectCase::branch(vmuint i) const {
752      if (i < branches.size())      if (i < branches.size())
753          return const_cast<Statements*>( &*branches[i].statements );          return const_cast<Statements*>( &*branches[i].statements );
754      return NULL;      return NULL;
# Line 676  Statements* SelectCase::branch(uint i) c Line 756  Statements* SelectCase::branch(uint i) c
756    
757  bool SelectCase::isPolyphonic() const {  bool SelectCase::isPolyphonic() const {
758      if (select->isPolyphonic()) return true;      if (select->isPolyphonic()) return true;
759      for (int i = 0; i < branches.size(); ++i)      for (vmint i = 0; i < branches.size(); ++i)
760          if (branches[i].statements->isPolyphonic())          if (branches[i].statements->isPolyphonic())
761              return true;              return true;
762      return false;      return false;
# Line 705  void While::dump(int level) { Line 785  void While::dump(int level) {
785      printIndents(level);      printIndents(level);
786      if (m_condition)      if (m_condition)
787          if (m_condition->isConstExpr())          if (m_condition->isConstExpr())
788              printf("while (%d) {\n", m_condition->evalInt());              printf("while (%lld) {\n", m_condition->evalInt());
789          else          else
790              printf("while ([runtime expr]) {\n");              printf("while ([runtime expr]) {\n");
791      else      else
# Line 769  bool ConcatString::isConstExpr() const { Line 849  bool ConcatString::isConstExpr() const {
849      return lhs->isConstExpr() && rhs->isConstExpr();      return lhs->isConstExpr() && rhs->isConstExpr();
850  }  }
851    
852  int Relation::evalInt() {  vmint Relation::evalInt() {
853      switch (type) {      switch (type) {
854          case LESS_THAN:          case LESS_THAN:
855              return lhs->evalInt() < rhs->evalInt();              return lhs->evalInt() < rhs->evalInt();
# Line 827  bool Relation::isConstExpr() const { Line 907  bool Relation::isConstExpr() const {
907      return lhs->isConstExpr() && rhs->isConstExpr();      return lhs->isConstExpr() && rhs->isConstExpr();
908  }  }
909    
910  int Or::evalInt() {  vmint Or::evalInt() {
911      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
912      if (pLHS->evalInt()) return 1;      if (pLHS->evalInt()) return 1;
913      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);;      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);;
# Line 845  void Or::dump(int level) { Line 925  void Or::dump(int level) {
925      printf(")\n");      printf(")\n");
926  }  }
927    
928  int BitwiseOr::evalInt() {  vmint BitwiseOr::evalInt() {
929      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
930      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);
931      return pLHS->evalInt() | pRHS->evalInt();      return pLHS->evalInt() | pRHS->evalInt();
# Line 862  void BitwiseOr::dump(int level) { Line 942  void BitwiseOr::dump(int level) {
942      printf(")\n");      printf(")\n");
943  }  }
944    
945  int And::evalInt() {  vmint And::evalInt() {
946      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
947      if (!pLHS->evalInt()) return 0;      if (!pLHS->evalInt()) return 0;
948      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);
# Line 880  void And::dump(int level) { Line 960  void And::dump(int level) {
960      printf(")\n");      printf(")\n");
961  }  }
962    
963  int BitwiseAnd::evalInt() {  vmint BitwiseAnd::evalInt() {
964      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
965      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);
966      return pLHS->evalInt() & pRHS->evalInt();      return pLHS->evalInt() & pRHS->evalInt();
# Line 913  void BitwiseNot::dump(int level) { Line 993  void BitwiseNot::dump(int level) {
993      printf(")\n");      printf(")\n");
994  }  }
995    
996    void Final::dump(int level) {
997        printIndents(level);
998        printf("Final(\n");
999        expr->dump(level+1);
1000        printIndents(level);
1001        printf(")\n");
1002    }
1003    
1004  StatementsRef ParserContext::userFunctionByName(const String& name) {  StatementsRef ParserContext::userFunctionByName(const String& name) {
1005      if (!userFnTable.count(name)) {      if (!userFnTable.count(name)) {
1006          return StatementsRef();          return StatementsRef();
# Line 977  void ParserContext::addWrn(int firstLine Line 1065  void ParserContext::addWrn(int firstLine
1065      vIssues.push_back(w);      vIssues.push_back(w);
1066  }  }
1067    
1068    void ParserContext::addPreprocessorComment(int firstLine, int lastLine, int firstColumn, int lastColumn) {
1069        CodeBlock block;
1070        block.firstLine = firstLine;
1071        block.lastLine = lastLine;
1072        block.firstColumn = firstColumn;
1073        block.lastColumn = lastColumn;
1074        vPreprocessorComments.push_back(block);
1075    }
1076    
1077  bool ParserContext::setPreprocessorCondition(const char* name) {  bool ParserContext::setPreprocessorCondition(const char* name) {
1078      if (builtinPreprocessorConditions.count(name)) return false;      if (builtinPreprocessorConditions.count(name)) return false;
1079      if (userPreprocessorConditions.count(name)) return false;      if (userPreprocessorConditions.count(name)) return false;
# Line 1008  std::vector<ParserIssue> ParserContext:: Line 1105  std::vector<ParserIssue> ParserContext::
1105      return vWarnings;      return vWarnings;
1106  }  }
1107    
1108    std::vector<CodeBlock> ParserContext::preprocessorComments() const {
1109        return vPreprocessorComments;
1110    }
1111    
1112  VMEventHandler* ParserContext::eventHandler(uint index) {  VMEventHandler* ParserContext::eventHandler(uint index) {
1113      if (!handlers) return NULL;      if (!handlers) return NULL;
1114      return handlers->eventHandler(index);      return handlers->eventHandler(index);
# Line 1018  VMEventHandler* ParserContext::eventHand Line 1119  VMEventHandler* ParserContext::eventHand
1119      return handlers->eventHandlerByName(name);      return handlers->eventHandlerByName(name);
1120  }  }
1121    
1122  void ParserContext::registerBuiltInConstIntVariables(const std::map<String,int>& vars) {  void ParserContext::registerBuiltInConstIntVariables(const std::map<String,vmint>& vars) {
1123      for (std::map<String,int>::const_iterator it = vars.begin();      for (std::map<String,vmint>::const_iterator it = vars.begin();
1124           it != vars.end(); ++it)           it != vars.end(); ++it)
1125      {      {
1126          ConstIntVariableRef ref = new ConstIntVariable(it->second);          ConstIntVariableRef ref = new ConstIntVariable(it->second);
# Line 1027  void ParserContext::registerBuiltInConst Line 1128  void ParserContext::registerBuiltInConst
1128      }      }
1129  }  }
1130    
1131  void ParserContext::registerBuiltInIntVariables(const std::map<String,VMIntRelPtr*>& vars) {  void ParserContext::registerBuiltInIntVariables(const std::map<String,VMIntPtr*>& vars) {
1132      for (std::map<String,VMIntRelPtr*>::const_iterator it = vars.begin();      for (std::map<String,VMIntPtr*>::const_iterator it = vars.begin();
1133           it != vars.end(); ++it)           it != vars.end(); ++it)
1134      {      {
1135          BuiltInIntVariableRef ref = new BuiltInIntVariable(it->first, it->second);          BuiltInIntVariableRef ref = new BuiltInIntVariable(it->first, it->second);
# Line 1054  void ParserContext::registerBuiltInDynVa Line 1155  void ParserContext::registerBuiltInDynVa
1155      }      }
1156  }  }
1157    
1158    ExecContext::ExecContext() :
1159        status(VM_EXEC_NOT_RUNNING), flags(STMT_SUCCESS), stackFrame(-1),
1160        suspendMicroseconds(0), instructionsCount(0)
1161    {
1162        exitRes.value = NULL;
1163    }
1164    
1165    void ExecContext::forkTo(VMExecContext* ectx) const {
1166        ExecContext* child = dynamic_cast<ExecContext*>(ectx);
1167    
1168        child->polyphonicIntMemory.copyFlatFrom(polyphonicIntMemory);
1169        child->status = VM_EXEC_SUSPENDED;
1170        child->flags = STMT_SUCCESS;
1171        child->stack.copyFlatFrom(stack);
1172        child->stackFrame = stackFrame;
1173        child->suspendMicroseconds = 0;
1174        child->instructionsCount = 0;
1175    }
1176    
1177  } // namespace LinuxSampler  } // namespace LinuxSampler
Legend:
Removed from v.3260  
changed lines
  Added in v.3561
  ViewVC Help
Powered by ViewVC