/[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 3056 by schoenebeck, Fri Dec 16 12:57:59 2016 UTC revision 3573 by schoenebeck, Tue Aug 27 21:36:53 2019 UTC
# Line 1  Line 1 
1  /*  /*
2   * Copyright (c) 2014 - 2016 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 RealExpr::evalCastToStr() {
38        return ToString(evalReal());
39    }
40    
41    String IntArrayExpr::evalCastToStr() {
42      String s = "{";      String s = "{";
43      for (int i = 0; i < arraySize(); ++i) {      for (vmint i = 0; i < arraySize(); ++i) {
44          int val = evalIntElement(i);          vmint val = evalIntElement(i);
45          if (i) s += ",";          if (i) s += ",";
46          s += ToString(val);          s += ToString(val);
47      }      }
48      s += "}";      s += "}";
49      return s;      return s;
50  }*/  }
51    
52    String RealArrayExpr::evalCastToStr() {
53        String s = "{";
54        for (vmint i = 0; i < arraySize(); ++i) {
55            vmfloat val = evalRealElement(i);
56            if (i) s += ",";
57            s += ToString(val);
58        }
59        s += "}";
60        return s;
61    }
62    
63    MetricPrefix_t Unit::unitPrefix(vmuint i) const {
64        if (i >= prefix.size()) return VM_NO_PREFIX;
65        return prefix[i];
66    }
67    
68  int IntLiteral::evalInt() {  void Unit::setUnit(const std::vector<MetricPrefix_t>& prefix, StdUnit_t type) {
69        this->prefix.resize( prefix.size() );
70        for (vmuint i = 0; i < prefix.size(); ++i)
71            this->prefix[i] = prefix[i];
72    
73        unit = type;
74    }
75    
76    void Unit::setUnit(const MetricPrefix_t* prefixes, StdUnit_t type) {
77        unit = type;
78        prefix.clear();
79        for (int i = 0; i < 2 && prefixes[i]; ++i)
80            prefix.add(prefixes[i]);
81    }
82    
83    void Unit::copyUnitFrom(const UnitRef& src) {
84        unit = src->unitType();
85        prefix.clear();
86        for (int i = 0; true; ++i) {
87            MetricPrefix_t p = src->unitPrefix(i);
88            if (!p) return;
89            prefix.add(p);
90        }
91    }
92    
93    vmint IntLiteral::evalInt() {
94      return value;      return value;
95  }  }
96    
97  void IntLiteral::dump(int level) {  void IntLiteral::dump(int level) {
98      printIndents(level);      printIndents(level);
99      printf("IntLiteral %d\n", value);      printf("IntLiteral %lld\n", value);
100    }
101    
102    vmfloat RealLiteral::evalReal() {
103        return value;
104    }
105    
106    void RealLiteral::dump(int level) {
107        printIndents(level);
108        printf("RealLiteral %f\n", value);
109  }  }
110    
111  void StringLiteral::dump(int level) {  void StringLiteral::dump(int level) {
# Line 60  void StringLiteral::dump(int level) { Line 113  void StringLiteral::dump(int level) {
113      printf("StringLiteral: '%s'\n", value.c_str());      printf("StringLiteral: '%s'\n", value.c_str());
114  }  }
115    
116  int Add::evalInt() {  vmint Add::evalInt() {
117      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
118      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);;      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);;
119      return (pLHS && pRHS) ? pLHS->evalInt() + pRHS->evalInt() : 0;      return (pLHS && pRHS) ? pLHS->evalInt() + pRHS->evalInt() : 0;
120  }  }
121    
122    vmfloat Add::evalReal() {
123        RealExpr* pLHS = dynamic_cast<RealExpr*>(&*lhs);
124        RealExpr* pRHS = dynamic_cast<RealExpr*>(&*rhs);;
125        return (pLHS && pRHS) ? pLHS->evalReal() + pRHS->evalReal() : 0;
126    }
127    
128  void Add::dump(int level) {  void Add::dump(int level) {
129      printIndents(level);      printIndents(level);
130      printf("Add(\n");      printf("Add(\n");
# Line 77  void Add::dump(int level) { Line 136  void Add::dump(int level) {
136      printf(")\n");      printf(")\n");
137  }  }
138    
139  int Sub::evalInt() {  vmint Sub::evalInt() {
140      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
141      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);;      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);;
142      return (pLHS && pRHS) ? pLHS->evalInt() - pRHS->evalInt() : 0;      return (pLHS && pRHS) ? pLHS->evalInt() - pRHS->evalInt() : 0;
143  }  }
144    
145    vmfloat Sub::evalReal() {
146        RealExpr* pLHS = dynamic_cast<RealExpr*>(&*lhs);
147        RealExpr* pRHS = dynamic_cast<RealExpr*>(&*rhs);;
148        return (pLHS && pRHS) ? pLHS->evalReal() - pRHS->evalReal() : 0;
149    }
150    
151  void Sub::dump(int level) {  void Sub::dump(int level) {
152      printIndents(level);      printIndents(level);
153      printf("Sub(\n");      printf("Sub(\n");
# Line 94  void Sub::dump(int level) { Line 159  void Sub::dump(int level) {
159      printf(")\n");      printf(")\n");
160  }  }
161    
162  int Mul::evalInt() {  vmint Mul::evalInt() {
163      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
164      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);;      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);;
165      return (pLHS && pRHS) ? pLHS->evalInt() * pRHS->evalInt() : 0;      return (pLHS && pRHS) ? pLHS->evalInt() * pRHS->evalInt() : 0;
166  }  }
167    
168    vmfloat Mul::evalReal() {
169        RealExpr* pLHS = dynamic_cast<RealExpr*>(&*lhs);
170        RealExpr* pRHS = dynamic_cast<RealExpr*>(&*rhs);;
171        return (pLHS && pRHS) ? pLHS->evalReal() * pRHS->evalReal() : 0;
172    }
173    
174  void Mul::dump(int level) {  void Mul::dump(int level) {
175      printIndents(level);      printIndents(level);
176      printf("Mul(\n");      printf("Mul(\n");
# Line 111  void Mul::dump(int level) { Line 182  void Mul::dump(int level) {
182      printf(")\n");      printf(")\n");
183  }  }
184    
185  int Div::evalInt() {  MetricPrefix_t Mul::unitPrefix(vmuint i) const {
186        const ScalarNumberExpr* pLHS = dynamic_cast<const ScalarNumberExpr*>(&*lhs);
187        const ScalarNumberExpr* pRHS = dynamic_cast<const ScalarNumberExpr*>(&*rhs);
188        // currently the NKSP parser only allows a unit prefix on either side
189        return (pLHS->unitPrefix(0)) ? pLHS->unitPrefix(i) : pRHS->unitPrefix(i);
190    }
191    
192    StdUnit_t Mul::unitType() const {
193        const ScalarNumberExpr* pLHS = dynamic_cast<const ScalarNumberExpr*>(&*lhs);
194        const ScalarNumberExpr* pRHS = dynamic_cast<const ScalarNumberExpr*>(&*rhs);
195        // currently the NKSP parser only allows a unit type on either side
196        return (pLHS->unitType()) ? pLHS->unitType() : pRHS->unitType();
197    }
198    
199    vmint Div::evalInt() {
200      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
201      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);
202      if (!pLHS || !pRHS) return 0;      if (!pLHS || !pRHS) return 0;
203      int l = pLHS->evalInt();      vmint l = pLHS->evalInt();
204      int r = pRHS->evalInt();      vmint r = pRHS->evalInt();
205      if (r == 0) return 0;      if (r == 0) return 0;
206      return l / r;      return l / r;
207  }  }
208    
209    vmfloat Div::evalReal() {
210        RealExpr* pLHS = dynamic_cast<RealExpr*>(&*lhs);
211        RealExpr* pRHS = dynamic_cast<RealExpr*>(&*rhs);;
212        if (!pLHS || !pRHS) return 0;
213        vmfloat l = pLHS->evalReal();
214        vmfloat r = pRHS->evalReal();
215        if (r == vmfloat(0)) return 0;
216        return l / r;
217    }
218    
219  void Div::dump(int level) {  void Div::dump(int level) {
220      printIndents(level);      printIndents(level);
221      printf("Div(\n");      printf("Div(\n");
# Line 132  void Div::dump(int level) { Line 227  void Div::dump(int level) {
227      printf(")\n");      printf(")\n");
228  }  }
229    
230  int Mod::evalInt() {  MetricPrefix_t Div::unitPrefix(vmuint i) const {
231        const ScalarNumberExpr* pLHS = dynamic_cast<const ScalarNumberExpr*>(&*lhs);
232        const ScalarNumberExpr* pRHS = dynamic_cast<const ScalarNumberExpr*>(&*rhs);
233        // currently the NKSP parser only allows either A) a unit prefix on left
234        // side and none on right side or B) an identical unit prefix on both sides
235        return (pLHS->unitPrefix(0) && pRHS->unitPrefix(0)) ? VM_NO_PREFIX : pLHS->unitPrefix(i);
236    }
237    
238    StdUnit_t Div::unitType() const {
239        const ScalarNumberExpr* pLHS = dynamic_cast<const ScalarNumberExpr*>(&*lhs);
240        const ScalarNumberExpr* pRHS = dynamic_cast<const ScalarNumberExpr*>(&*rhs);
241        // the NKSP parser only allows either A) a unit type on left side and none
242        // on right side or B) an identical unit type on both sides
243        return (pLHS->unitType() && pRHS->unitType()) ? VM_NO_UNIT : pLHS->unitType();
244    }
245    
246    vmint Mod::evalInt() {
247      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
248      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);;      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);;
249      return (pLHS && pRHS) ? pLHS->evalInt() % pRHS->evalInt() : 0;      return (pLHS && pRHS) ? pLHS->evalInt() % pRHS->evalInt() : 0;
# Line 160  void Args::dump(int level) { Line 271  void Args::dump(int level) {
271  }  }
272    
273  bool Args::isPolyphonic() const {  bool Args::isPolyphonic() const {
274      for (int i = 0; i < args.size(); ++i)      for (vmint i = 0; i < args.size(); ++i)
275          if (args[i]->isPolyphonic())          if (args[i]->isPolyphonic())
276              return true;              return true;
277      return false;      return false;
# Line 188  void EventHandlers::dump(int level) { Line 299  void EventHandlers::dump(int level) {
299  }  }
300    
301  EventHandler* EventHandlers::eventHandlerByName(const String& name) const {  EventHandler* EventHandlers::eventHandlerByName(const String& name) const {
302      for (int i = 0; i < args.size(); ++i)      for (vmint i = 0; i < args.size(); ++i)
303          if (args.at(i)->eventHandlerName() == name)          if (args.at(i)->eventHandlerName() == name)
304              return const_cast<EventHandler*>(&*args.at(i));              return const_cast<EventHandler*>(&*args.at(i));
305      return NULL;      return NULL;
# Line 200  EventHandler* EventHandlers::eventHandle Line 311  EventHandler* EventHandlers::eventHandle
311  }  }
312    
313  bool EventHandlers::isPolyphonic() const {  bool EventHandlers::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 252  Statement* Statements::statement(uint i) Line 363  Statement* Statements::statement(uint i)
363  }  }
364    
365  bool Statements::isPolyphonic() const {  bool Statements::isPolyphonic() const {
366      for (int i = 0; i < args.size(); ++i)      for (vmint i = 0; i < args.size(); ++i)
367          if (args[i]->isPolyphonic())          if (args[i]->isPolyphonic())
368              return true;              return true;
369      return false;      return false;
# Line 263  DynamicVariableCall::DynamicVariableCall Line 374  DynamicVariableCall::DynamicVariableCall
374  {  {
375  }  }
376    
377  int DynamicVariableCall::evalInt() {  vmint DynamicVariableCall::evalInt() {
378      VMIntExpr* expr = dynamic_cast<VMIntExpr*>(dynVar);      VMIntExpr* expr = dynamic_cast<VMIntExpr*>(dynVar);
379      if (!expr) return 0;      if (!expr) return 0;
380      return expr->evalInt();      return expr->evalInt();
# Line 316  StmtFlags_t FunctionCall::exec() { Line 427  StmtFlags_t FunctionCall::exec() {
427      return result->resultFlags();      return result->resultFlags();
428  }  }
429    
430  int FunctionCall::evalInt() {  vmint FunctionCall::evalInt() {
431      VMFnResult* result = execVMFn();      VMFnResult* result = execVMFn();
432      if (!result) return 0;      if (!result) return 0;
433      VMIntExpr* intExpr = dynamic_cast<VMIntExpr*>(result->resultValue());      VMIntExpr* intExpr = dynamic_cast<VMIntExpr*>(result->resultValue());
# Line 324  int FunctionCall::evalInt() { Line 435  int FunctionCall::evalInt() {
435      return intExpr->evalInt();      return intExpr->evalInt();
436  }  }
437    
438    vmfloat FunctionCall::evalReal() {
439        VMFnResult* result = execVMFn();
440        if (!result) return 0;
441        VMRealExpr* realExpr = dynamic_cast<VMRealExpr*>(result->resultValue());
442        if (!realExpr) return 0;
443        return realExpr->evalReal();
444    }
445    
446  VMIntArrayExpr* FunctionCall::asIntArray() const {  VMIntArrayExpr* FunctionCall::asIntArray() const {
447      VMFnResult* result = const_cast<FunctionCall*>(this)->execVMFn();      VMFnResult* result = const_cast<FunctionCall*>(this)->execVMFn();
448      if (!result) return 0;      if (!result) return 0;
# Line 331  VMIntArrayExpr* FunctionCall::asIntArray Line 450  VMIntArrayExpr* FunctionCall::asIntArray
450      return intArrExpr;      return intArrExpr;
451  }  }
452    
453    VMRealArrayExpr* FunctionCall::asRealArray() const {
454        VMFnResult* result = const_cast<FunctionCall*>(this)->execVMFn();
455        if (!result) return 0;
456        VMRealArrayExpr* realArrExpr = dynamic_cast<VMRealArrayExpr*>(result->resultValue());
457        return realArrExpr;
458    }
459    
460  String FunctionCall::evalStr() {  String FunctionCall::evalStr() {
461      VMFnResult* result = execVMFn();      VMFnResult* result = execVMFn();
462      if (!result) return "";      if (!result) return "";
# Line 342  String FunctionCall::evalStr() { Line 468  String FunctionCall::evalStr() {
468  String FunctionCall::evalCastToStr() {  String FunctionCall::evalCastToStr() {
469      VMFnResult* result = execVMFn();      VMFnResult* result = execVMFn();
470      if (!result) return "";      if (!result) return "";
471      if (result->resultValue()->exprType() == STRING_EXPR) {      const ExprType_t resultType = result->resultValue()->exprType();
472        if (resultType == STRING_EXPR) {
473          VMStringExpr* strExpr = dynamic_cast<VMStringExpr*>(result->resultValue());          VMStringExpr* strExpr = dynamic_cast<VMStringExpr*>(result->resultValue());
474          return strExpr ? strExpr->evalStr() : "";          return strExpr ? strExpr->evalStr() : "";
475        } else if (resultType == REAL_EXPR) {
476            VMRealExpr* realExpr = dynamic_cast<VMRealExpr*>(result->resultValue());
477            return realExpr ? ToString(realExpr->evalReal()) : "";
478      } else {      } else {
479          VMIntExpr* intExpr = dynamic_cast<VMIntExpr*>(result->resultValue());          VMIntExpr* intExpr = dynamic_cast<VMIntExpr*>(result->resultValue());
480          return intExpr ? ToString(intExpr->evalInt()) : "";          return intExpr ? ToString(intExpr->evalInt()) : "";
481      }      }
482  }  }
483    
484    ScalarNumberVariable::ScalarNumberVariable(ParserContext* ctx, vmint _memPos,
485                                               bool _bConst, bool _bPolyphonic,
486                                               bool _bFinal)
487        : Variable(ctx, _memPos, _bConst),
488          Unit(),
489          polyphonic(_bPolyphonic), finalVal(_bFinal)
490    {
491    }
492    
493  IntVariable::IntVariable(ParserContext* ctx)  IntVariable::IntVariable(ParserContext* ctx)
494      : Variable(ctx, ctx ? ctx->globalIntVarCount++ : 0, false), polyphonic(false)      : ScalarNumberVariable(ctx, ctx ? ctx->globalIntVarCount++ : 0)
495  {  {
496      //printf("globalIntVar parserctx=0x%lx memPOS=%d\n", ctx, memPos);      //printf("globalIntVar parserctx=0x%lx memPOS=%d\n", ctx, memPos);
497      assert(ctx);      assert(ctx);
498  }  }
499    
500  inline static int postfixInc(int& object, int incBy) {  inline static vmint postfixInc(vmint& object, vmint incBy) {
501      const int i = object;      const vmint i = object;
502      object += incBy;      object += incBy;
503      return i;      return i;
504  }  }
505    
506  IntVariable::IntVariable(ParserContext* ctx, bool polyphonic, bool bConst, int size)  IntVariable::IntVariable(ParserContext* ctx, bool bPolyphonic, bool bConst, vmint size)
507      : Variable(ctx, !ctx ? 0 : polyphonic ? postfixInc(ctx->polyphonicIntVarCount, size) : postfixInc(ctx->globalIntVarCount, size), bConst),      : ScalarNumberVariable(
508        polyphonic(polyphonic)            ctx,
509              !ctx ? 0 : bPolyphonic ? postfixInc(ctx->polyphonicIntVarCount, size) :
510                                       postfixInc(ctx->globalIntVarCount, size),
511              bConst, bPolyphonic
512          )
513  {  {
514      //printf("InvVar size=%d parserCtx=0x%lx\n", size, (uint64_t)ctx);      //printf("IntVar size=%d parserCtx=0x%lx\n", size, (uint64_t)ctx);
515      if (polyphonic) {      if (bPolyphonic) {
516          //printf("polyIntVar memPOS=%d\n", memPos);          //printf("polyIntVar memPOS=%d\n", memPos);
517          assert(ctx);          assert(ctx);
518      }      }
# Line 378  IntVariable::IntVariable(ParserContext* Line 521  IntVariable::IntVariable(ParserContext*
521  void IntVariable::assign(Expression* expr) {  void IntVariable::assign(Expression* expr) {
522      IntExpr* intExpr = dynamic_cast<IntExpr*>(expr);      IntExpr* intExpr = dynamic_cast<IntExpr*>(expr);
523      if (intExpr) {      if (intExpr) {
524          if (polyphonic)          if (isPolyphonic())
525              context->execContext->polyphonicIntMemory[memPos] = intExpr->evalInt();              context->execContext->polyphonicIntMemory[memPos] = intExpr->evalInt();
526          else          else
527              (*context->globalIntMemory)[memPos] = intExpr->evalInt();              (*context->globalIntMemory)[memPos] = intExpr->evalInt();
528      }      }
529  }  }
530    
531  int IntVariable::evalInt() {  vmint IntVariable::evalInt() {
532      //printf("IntVariable::eval pos=%d\n", memPos);      //printf("IntVariable::eval pos=%d\n", memPos);
533      if (polyphonic) {      if (isPolyphonic()) {
534          //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);
535          return context->execContext->polyphonicIntMemory[memPos];          return context->execContext->polyphonicIntMemory[memPos];
536      }      }
# Line 400  void IntVariable::dump(int level) { Line 543  void IntVariable::dump(int level) {
543      //printf("IntVariable memPos=%d\n", memPos);      //printf("IntVariable memPos=%d\n", memPos);
544  }  }
545    
546  //ConstIntVariable::ConstIntVariable(ParserContext* ctx, int value)  RealVariable::RealVariable(ParserContext* ctx)
547  ConstIntVariable::ConstIntVariable(int value)      : ScalarNumberVariable(ctx, ctx ? ctx->globalRealVarCount++ : 0)
548    {
549        //printf("globalRealVar parserctx=0x%lx memPOS=%d\n", ctx, memPos);
550        assert(ctx);
551    }
552    
553    RealVariable::RealVariable(ParserContext* ctx, bool bPolyphonic, bool bConst, vmint size)
554        : ScalarNumberVariable(
555              ctx,
556              !ctx ? 0 : bPolyphonic ? postfixInc(ctx->polyphonicRealVarCount, size) :
557                                       postfixInc(ctx->globalRealVarCount, size),
558              bConst, bPolyphonic
559          )
560    {
561        //printf("RealVar size=%d parserCtx=0x%lx\n", size, (uint64_t)ctx);
562        if (bPolyphonic) {
563            //printf("polyRealVar memPOS=%d\n", memPos);
564            assert(ctx);
565        }
566    }
567    
568    void RealVariable::assign(Expression* expr) {
569        RealExpr* realExpr = dynamic_cast<RealExpr*>(expr);
570        if (realExpr) {
571            if (isPolyphonic())
572                context->execContext->polyphonicRealMemory[memPos] = realExpr->evalReal();
573            else
574                (*context->globalRealMemory)[memPos] = realExpr->evalReal();
575        }
576    }
577    
578    vmfloat RealVariable::evalReal() {
579        //printf("RealVariable::eval pos=%d\n", memPos);
580        if (isPolyphonic()) {
581            //printf("evalReal() poly memPos=%d execCtx=0x%lx\n", memPos, (uint64_t)context->execContext);
582            return context->execContext->polyphonicRealMemory[memPos];
583        }
584        return (*context->globalRealMemory)[memPos];
585    }
586    
587    void RealVariable::dump(int level) {
588        printIndents(level);
589        printf("RealVariable\n");
590        //printf("RealVariable memPos=%d\n", memPos);
591    }
592    
593    ConstIntVariable::ConstIntVariable(vmint value)
594      : IntVariable(NULL,false,true), value(value)      : IntVariable(NULL,false,true), value(value)
595  {  {
596  }  }
# Line 417  void ConstIntVariable::assign(Expression Line 606  void ConstIntVariable::assign(Expression
606  */  */
607  }  }
608    
609  int ConstIntVariable::evalInt() {  vmint ConstIntVariable::evalInt() {
610      return value;      return value;
611  }  }
612    
613  void ConstIntVariable::dump(int level) {  void ConstIntVariable::dump(int level) {
614      printIndents(level);      printIndents(level);
615      printf("ConstIntVariable val=%d\n", value);      printf("ConstIntVariable val=%lld\n", value);
616    }
617    
618    ConstRealVariable::ConstRealVariable(vmfloat value)
619        : RealVariable(NULL,false,true), value(value)
620    {
621    }
622    
623    void ConstRealVariable::assign(Expression* expr) {
624        // ignore assignment
625    }
626    
627    vmfloat ConstRealVariable::evalReal() {
628        return value;
629    }
630    
631    void ConstRealVariable::dump(int level) {
632        printIndents(level);
633        printf("ConstRealVariable val=%f\n", value);
634  }  }
635    
636  BuiltInIntVariable::BuiltInIntVariable(const String& name, VMIntRelPtr* ptr)  BuiltInIntVariable::BuiltInIntVariable(const String& name, VMIntPtr* ptr)
637      : IntVariable(NULL,false,false), name(name), ptr(ptr)      : IntVariable(NULL,false,false), name(name), ptr(ptr)
638  {  {
639  }  }
# Line 437  void BuiltInIntVariable::assign(Expressi Line 644  void BuiltInIntVariable::assign(Expressi
644      ptr->assign(valueExpr->evalInt());      ptr->assign(valueExpr->evalInt());
645  }  }
646    
647  int BuiltInIntVariable::evalInt() {  vmint BuiltInIntVariable::evalInt() {
648      return ptr->evalInt();      return ptr->evalInt();
649  }  }
650    
# Line 456  void PolyphonicIntVariable::dump(int lev Line 663  void PolyphonicIntVariable::dump(int lev
663      printf("PolyphonicIntVariable\n");      printf("PolyphonicIntVariable\n");
664  }  }
665    
666  IntArrayVariable::IntArrayVariable(ParserContext* ctx, int size)  PolyphonicRealVariable::PolyphonicRealVariable(ParserContext* ctx)
667        : RealVariable(ctx,true,false)
668    {
669    }
670    
671    void PolyphonicRealVariable::dump(int level) {
672        printIndents(level);
673        printf("PolyphonicRealVariable\n");
674    }
675    
676    IntArrayVariable::IntArrayVariable(ParserContext* ctx, vmint size)
677      : Variable(ctx, 0, false)      : Variable(ctx, 0, false)
678  {  {
679      values.resize(size);      values.resize(size);
680      memset(&values[0], 0, size * sizeof(int));      memset(&values[0], 0, size * sizeof(vmint));
681  }  }
682    
683  IntArrayVariable::IntArrayVariable(ParserContext* ctx, int size, ArgsRef values)  IntArrayVariable::IntArrayVariable(ParserContext* ctx, vmint size, ArgsRef values, bool _bConst)
684      : Variable(ctx, 0, false)      : Variable(ctx, 0, _bConst)
685  {  {
686      this->values.resize(size);      this->values.resize(size);
687      for (int i = 0; i < values->argsCount(); ++i) {      for (vmint i = 0; i < values->argsCount(); ++i) {
688          VMIntExpr* expr = dynamic_cast<VMIntExpr*>(values->arg(i));          VMIntExpr* expr = dynamic_cast<VMIntExpr*>(values->arg(i));
689          if (expr) this->values[i] = expr->evalInt();          if (expr) this->values[i] = expr->evalInt();
690      }      }
# Line 478  IntArrayVariable::IntArrayVariable(Parse Line 695  IntArrayVariable::IntArrayVariable(Parse
695  {  {
696  }  }
697    
698  int IntArrayVariable::evalIntElement(uint i) {  vmint IntArrayVariable::evalIntElement(vmuint i) {
699      if (i >= values.size()) return 0;      if (i >= values.size()) return 0;
700      return values[i];      return values[i];
701  }  }
702    
703  void IntArrayVariable::assignIntElement(uint i, int value) {  void IntArrayVariable::assignIntElement(vmuint i, vmint value) {
704      if (i >= values.size()) return;      if (i >= values.size()) return;
705      values[i] = value;      values[i] = value;
706  }  }
# Line 491  void IntArrayVariable::assignIntElement( Line 708  void IntArrayVariable::assignIntElement(
708  void IntArrayVariable::dump(int level) {  void IntArrayVariable::dump(int level) {
709      printIndents(level);      printIndents(level);
710      printf("IntArray(");      printf("IntArray(");
711      for (int i = 0; i < values.size(); ++i) {      for (vmint i = 0; i < values.size(); ++i) {
712          if (i % 12 == 0) {          if (i % 12 == 0) {
713              printf("\n");              printf("\n");
714              printIndents(level+1);              printIndents(level+1);
715          }          }
716          printf("%d, ", values[i]);          printf("%lld, ", values[i]);
717        }
718        printIndents(level);
719        printf(")\n");
720    }
721    
722    RealArrayVariable::RealArrayVariable(ParserContext* ctx, vmint size)
723        : Variable(ctx, 0, false)
724    {
725        values.resize(size);
726        memset(&values[0], 0, size * sizeof(vmfloat));
727    }
728    
729    RealArrayVariable::RealArrayVariable(ParserContext* ctx, vmint size, ArgsRef values, bool _bConst)
730        : Variable(ctx, 0, _bConst)
731    {
732        this->values.resize(size);
733        for (vmint i = 0; i < values->argsCount(); ++i) {
734            VMRealExpr* expr = dynamic_cast<VMRealExpr*>(values->arg(i));
735            if (expr) this->values[i] = expr->evalReal();
736        }
737    }
738    
739    RealArrayVariable::RealArrayVariable(ParserContext* ctx, bool bConst)
740        : Variable(ctx, 0, bConst)
741    {
742    }
743    
744    vmfloat RealArrayVariable::evalRealElement(vmuint i) {
745        if (i >= values.size()) return 0;
746        return values[i];
747    }
748    
749    void RealArrayVariable::assignRealElement(vmuint i, vmfloat value) {
750        if (i >= values.size()) return;
751        values[i] = value;
752    }
753    
754    void RealArrayVariable::dump(int level) {
755        printIndents(level);
756        printf("RealArray(");
757        for (vmint i = 0; i < values.size(); ++i) {
758            if (i % 12 == 0) {
759                printf("\n");
760                printIndents(level+1);
761            }
762            printf("%f, ", values[i]);
763      }      }
764      printIndents(level);      printIndents(level);
765      printf(")\n");      printf(")\n");
# Line 507  BuiltInIntArrayVariable::BuiltInIntArray Line 770  BuiltInIntArrayVariable::BuiltInIntArray
770  {  {
771  }  }
772    
773  int BuiltInIntArrayVariable::evalIntElement(uint i) {  vmint BuiltInIntArrayVariable::evalIntElement(vmuint i) {
774      return i >= array->size ? 0 : array->data[i];      return i >= array->size ? 0 : array->data[i];
775  }  }
776    
777  void BuiltInIntArrayVariable::assignIntElement(uint i, int value) {  void BuiltInIntArrayVariable::assignIntElement(vmuint i, vmint value) {
778      if (i >= array->size) return;      if (i >= array->size) return;
779      array->data[i] = value;      array->data[i] = value;
780  }  }
# Line 521  void BuiltInIntArrayVariable::dump(int l Line 784  void BuiltInIntArrayVariable::dump(int l
784      printf("Built-In Int Array Variable '%s'\n", name.c_str());      printf("Built-In Int Array Variable '%s'\n", name.c_str());
785  }  }
786    
787  IntArrayElement::IntArrayElement(IntArrayVariableRef array, IntExprRef arrayIndex)  IntArrayElement::IntArrayElement(IntArrayExprRef array, IntExprRef arrayIndex)
788      : IntVariable(NULL, false, false, 0), array(array), index(arrayIndex)      : IntVariable(NULL, false, false, 0), array(array), index(arrayIndex)
789  {      {    
790  }  }
# Line 529  IntArrayElement::IntArrayElement(IntArra Line 792  IntArrayElement::IntArrayElement(IntArra
792  void IntArrayElement::assign(Expression* expr) {  void IntArrayElement::assign(Expression* expr) {
793      IntExpr* valueExpr = dynamic_cast<IntExpr*>(expr);      IntExpr* valueExpr = dynamic_cast<IntExpr*>(expr);
794      if (!valueExpr) return;      if (!valueExpr) return;
795      int value = valueExpr->evalInt();      vmint value = valueExpr->evalInt();
796    
797      if (!index) return;      if (!index) return;
798      int idx = index->evalInt();      vmint idx = index->evalInt();
799      if (idx < 0 || idx >= array->arraySize()) return;      if (idx < 0 || idx >= array->arraySize()) return;
800    
801      array->assignIntElement(idx, value);      array->assignIntElement(idx, value);
802  }  }
803    
804  int IntArrayElement::evalInt() {  vmint IntArrayElement::evalInt() {
805      if (!index) return 0;      if (!index) return 0;
806      int idx = index->evalInt();      vmint idx = index->evalInt();
807      if (idx < 0 || idx >= array->arraySize()) return 0;      if (idx < 0 || idx >= array->arraySize()) return 0;
808    
809      return array->evalIntElement(idx);      return array->evalIntElement(idx);
# Line 551  void IntArrayElement::dump(int level) { Line 814  void IntArrayElement::dump(int level) {
814      printf("IntArrayElement\n");      printf("IntArrayElement\n");
815  }  }
816    
817    RealArrayElement::RealArrayElement(RealArrayExprRef array, IntExprRef arrayIndex)
818        : RealVariable(NULL, false, false, 0), array(array), index(arrayIndex)
819    {
820    }
821    
822    void RealArrayElement::assign(Expression* expr) {
823        RealExpr* valueExpr = dynamic_cast<RealExpr*>(expr);
824        if (!valueExpr) return;
825        vmfloat value = valueExpr->evalReal();
826    
827        if (!index) return;
828        vmint idx = index->evalInt();
829        if (idx < 0 || idx >= array->arraySize()) return;
830    
831        array->assignRealElement(idx, value);
832    }
833    
834    vmfloat RealArrayElement::evalReal() {
835        if (!index) return 0;
836        vmint idx = index->evalInt();
837        if (idx < 0 || idx >= array->arraySize()) return 0;
838    
839        return array->evalRealElement(idx);
840    }
841    
842    void RealArrayElement::dump(int level) {
843        printIndents(level);
844        printf("RealArrayElement\n");
845    }
846    
847  StringVariable::StringVariable(ParserContext* ctx)  StringVariable::StringVariable(ParserContext* ctx)
848      : Variable(ctx,ctx->globalStrVarCount++,false)      : Variable(ctx,ctx->globalStrVarCount++,false)
849  {  {
# Line 573  String StringVariable::evalStr() { Line 866  String StringVariable::evalStr() {
866    
867  void StringVariable::dump(int level) {  void StringVariable::dump(int level) {
868      printIndents(level);      printIndents(level);
869      printf("StringVariable memPos=%d\n", memPos);      printf("StringVariable memPos=%lld\n", memPos);
870  }  }
871    
872  ConstStringVariable::ConstStringVariable(ParserContext* ctx, String _value)  ConstStringVariable::ConstStringVariable(ParserContext* ctx, String _value)
# Line 596  void ConstStringVariable::dump(int level Line 889  void ConstStringVariable::dump(int level
889      printf("ConstStringVariable val='%s'\n", value.c_str());      printf("ConstStringVariable val='%s'\n", value.c_str());
890  }  }
891    
892    MetricPrefix_t ScalarNumberBinaryOp::unitPrefix(vmuint i) const {
893        ScalarNumberExprRef l = (ScalarNumberExprRef) lhs;
894        ScalarNumberExprRef r = (ScalarNumberExprRef) rhs;
895        return (r->unitFactor() < l->unitFactor()) ? r->unitPrefix(i) : l->unitPrefix(i);
896    }
897    
898    StdUnit_t ScalarNumberBinaryOp::unitType() const {
899        ScalarNumberExprRef l = (ScalarNumberExprRef) lhs;
900        ScalarNumberExprRef r = (ScalarNumberExprRef) rhs;
901        return (l->unitType()) ? l->unitType() : r->unitType();
902    }
903    
904    bool ScalarNumberBinaryOp::isFinal() const {
905        ScalarNumberExprRef l = (ScalarNumberExprRef) lhs;
906        ScalarNumberExprRef r = (ScalarNumberExprRef) rhs;
907        return l->isFinal() || r->isFinal();
908    }
909    
910    ExprType_t VaritypeScalarBinaryOp::exprType() const {
911        return (lhs->exprType() == REAL_EXPR || rhs->exprType() == REAL_EXPR) ? REAL_EXPR : INT_EXPR;
912    }
913    
914    String VaritypeScalarBinaryOp::evalCastToStr() {
915        return (exprType() == REAL_EXPR) ?
916            RealExpr::evalCastToStr() : IntExpr::evalCastToStr();
917    }
918    
919  void If::dump(int level) {  void If::dump(int level) {
920      printIndents(level);      printIndents(level);
921      if (ifStatements && elseStatements)      if (ifStatements && elseStatements)
# Line 606  void If::dump(int level) { Line 926  void If::dump(int level) {
926          printf("if [INVALID]\n");          printf("if [INVALID]\n");
927  }  }
928    
929  int If::evalBranch() {  vmint If::evalBranch() {
930      if (condition->evalInt()) return 0;      if (condition->evalInt()) return 0;
931      if (elseStatements) return 1;      if (elseStatements) return 1;
932      return -1;      return -1;
933  }  }
934    
935  Statements* If::branch(uint i) const {  Statements* If::branch(vmuint i) const {
936      if (i == 0) return (Statements*) &*ifStatements;      if (i == 0) return (Statements*) &*ifStatements;
937      if (i == 1) return (elseStatements) ? (Statements*) &*elseStatements : NULL;      if (i == 1) return (elseStatements) ? (Statements*) &*elseStatements : NULL;
938      return NULL;      return NULL;
# Line 628  void SelectCase::dump(int level) { Line 948  void SelectCase::dump(int level) {
948      printIndents(level);      printIndents(level);
949      if (select)      if (select)
950          if (select->isConstExpr())          if (select->isConstExpr())
951              printf("Case select %d\n", select->evalInt());              printf("Case select %lld\n", select->evalInt());
952          else          else
953              printf("Case select [runtime expr]\n");              printf("Case select [runtime expr]\n");
954      else      else
955          printf("Case select NULL\n");          printf("Case select NULL\n");
956      for (int i = 0; i < branches.size(); ++i) {      for (vmint i = 0; i < branches.size(); ++i) {
957          printIndents(level+1);          printIndents(level+1);
958          CaseBranch& branch = branches[i];          CaseBranch& branch = branches[i];
959          if (branch.from && branch.to)          if (branch.from && branch.to)
960              if (branch.from->isConstExpr() && branch.to->isConstExpr())              if (branch.from->isConstExpr() && branch.to->isConstExpr())
961                  printf("case %d to %d\n", branch.from->evalInt(), branch.to->evalInt());                  printf("case %lld to %lld\n", branch.from->evalInt(), branch.to->evalInt());
962              else if (branch.from->isConstExpr() && !branch.to->isConstExpr())              else if (branch.from->isConstExpr() && !branch.to->isConstExpr())
963                  printf("case %d to [runtime expr]\n", branch.from->evalInt());                  printf("case %lld to [runtime expr]\n", branch.from->evalInt());
964              else if (!branch.from->isConstExpr() && branch.to->isConstExpr())              else if (!branch.from->isConstExpr() && branch.to->isConstExpr())
965                  printf("case [runtime expr] to %d\n", branch.to->evalInt());                  printf("case [runtime expr] to %lld\n", branch.to->evalInt());
966              else              else
967                  printf("case [runtime expr] to [runtime expr]\n");                  printf("case [runtime expr] to [runtime expr]\n");
968          else if (branch.from)          else if (branch.from)
969              if (branch.from->isConstExpr())              if (branch.from->isConstExpr())
970                  printf("case %d\n", branch.from->evalInt());                  printf("case %lld\n", branch.from->evalInt());
971              else              else
972                  printf("case [runtime expr]\n");                  printf("case [runtime expr]\n");
973          else          else
# Line 655  void SelectCase::dump(int level) { Line 975  void SelectCase::dump(int level) {
975      }      }
976  }  }
977    
978  int SelectCase::evalBranch() {  vmint SelectCase::evalBranch() {
979      int value = select->evalInt();      vmint value = select->evalInt();
980      for (int i = 0; i < branches.size(); ++i) {      for (vmint i = 0; i < branches.size(); ++i) {
981          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" ...
982              if (branches.at(i).from->evalInt() <= value &&              if (branches.at(i).from->evalInt() <= value &&
983                  branches.at(i).to->evalInt() >= value) return i;                  branches.at(i).to->evalInt() >= value) return i;
# Line 668  int SelectCase::evalBranch() { Line 988  int SelectCase::evalBranch() {
988      return -1;      return -1;
989  }  }
990    
991  Statements* SelectCase::branch(uint i) const {  Statements* SelectCase::branch(vmuint i) const {
992      if (i < branches.size())      if (i < branches.size())
993          return const_cast<Statements*>( &*branches[i].statements );          return const_cast<Statements*>( &*branches[i].statements );
994      return NULL;      return NULL;
# Line 676  Statements* SelectCase::branch(uint i) c Line 996  Statements* SelectCase::branch(uint i) c
996    
997  bool SelectCase::isPolyphonic() const {  bool SelectCase::isPolyphonic() const {
998      if (select->isPolyphonic()) return true;      if (select->isPolyphonic()) return true;
999      for (int i = 0; i < branches.size(); ++i)      for (vmint i = 0; i < branches.size(); ++i)
1000          if (branches[i].statements->isPolyphonic())          if (branches[i].statements->isPolyphonic())
1001              return true;              return true;
1002      return false;      return false;
# Line 705  void While::dump(int level) { Line 1025  void While::dump(int level) {
1025      printIndents(level);      printIndents(level);
1026      if (m_condition)      if (m_condition)
1027          if (m_condition->isConstExpr())          if (m_condition->isConstExpr())
1028              printf("while (%d) {\n", m_condition->evalInt());              printf("while (%lld) {\n", m_condition->evalInt());
1029          else          else
1030              printf("while ([runtime expr]) {\n");              printf("while ([runtime expr]) {\n");
1031      else      else
# Line 724  bool While::evalLoopStartCondition() { Line 1044  bool While::evalLoopStartCondition() {
1044      return m_condition->evalInt();      return m_condition->evalInt();
1045  }  }
1046    
1047    void SyncBlock::dump(int level) {
1048        printIndents(level);
1049        printf("sync {\n");
1050        m_statements->dump(level+1);
1051        printIndents(level);
1052        printf("}\n");
1053    }
1054    
1055    Statements* SyncBlock::statements() const {
1056        return (m_statements) ? const_cast<Statements*>( &*m_statements ) : NULL;
1057    }
1058    
1059  void Neg::dump(int level) {  void Neg::dump(int level) {
1060      printIndents(level);      printIndents(level);
1061      printf("Negative Expr\n");      printf("Negative Expr\n");
# Line 757  bool ConcatString::isConstExpr() const { Line 1089  bool ConcatString::isConstExpr() const {
1089      return lhs->isConstExpr() && rhs->isConstExpr();      return lhs->isConstExpr() && rhs->isConstExpr();
1090  }  }
1091    
1092  int Relation::evalInt() {  template<class T_LHS, class T_RHS>
1093    static inline vmint _evalRelation(Relation::Type type, T_LHS lhs, T_RHS rhs) {
1094      switch (type) {      switch (type) {
1095          case LESS_THAN:          case Relation::LESS_THAN:
1096              return lhs->evalInt() < rhs->evalInt();              return lhs < rhs;
1097          case GREATER_THAN:          case Relation::GREATER_THAN:
1098              return lhs->evalInt() > rhs->evalInt();              return lhs > rhs;
1099          case LESS_OR_EQUAL:          case Relation::LESS_OR_EQUAL:
1100              return lhs->evalInt() <= rhs->evalInt();              return lhs <= rhs;
1101          case GREATER_OR_EQUAL:          case Relation::GREATER_OR_EQUAL:
1102              return lhs->evalInt() >= rhs->evalInt();              return lhs >= rhs;
1103          case EQUAL:          case Relation::EQUAL:
1104              if (lhs->exprType() == STRING_EXPR || rhs->exprType() == STRING_EXPR)              return lhs == rhs;
1105            case Relation::NOT_EQUAL:
1106                return lhs != rhs;
1107        }
1108        return 0;
1109    }
1110    
1111    vmint Relation::evalInt() {
1112        const ExprType_t lType = lhs->exprType();
1113        const ExprType_t rType = rhs->exprType();
1114        if (lType == STRING_EXPR || rType == STRING_EXPR) {
1115            switch (type) {
1116                case EQUAL:
1117                  return lhs->evalCastToStr() == rhs->evalCastToStr();                  return lhs->evalCastToStr() == rhs->evalCastToStr();
1118              else              case NOT_EQUAL:
                 return lhs->evalInt() == rhs->evalInt();  
         case NOT_EQUAL:  
             if (lhs->exprType() == STRING_EXPR || rhs->exprType() == STRING_EXPR)  
1119                  return lhs->evalCastToStr() != rhs->evalCastToStr();                  return lhs->evalCastToStr() != rhs->evalCastToStr();
1120              else              default:
1121                  return lhs->evalInt() != rhs->evalInt();                  return 0;
1122            }
1123        } else if (lType == REAL_EXPR && rType == REAL_EXPR) {
1124            return _evalRelation(
1125                type, lhs->asReal()->evalReal(), rhs->asReal()->evalReal()
1126            );
1127        } else if (lType == REAL_EXPR && rType == INT_EXPR) {
1128            return _evalRelation(
1129                type, lhs->asReal()->evalReal(), rhs->asInt()->evalInt()
1130            );
1131        } else if (lType == INT_EXPR && rType == REAL_EXPR) {
1132            return _evalRelation(
1133                type, lhs->asInt()->evalInt(), rhs->asReal()->evalReal()
1134            );
1135        } else {
1136            return _evalRelation(
1137                type, lhs->asInt()->evalInt(), rhs->asInt()->evalInt()
1138            );
1139      }      }
     return 0;  
1140  }  }
1141    
1142  void Relation::dump(int level) {  void Relation::dump(int level) {
# Line 815  bool Relation::isConstExpr() const { Line 1173  bool Relation::isConstExpr() const {
1173      return lhs->isConstExpr() && rhs->isConstExpr();      return lhs->isConstExpr() && rhs->isConstExpr();
1174  }  }
1175    
1176  int Or::evalInt() {  vmint Or::evalInt() {
1177      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
1178      if (pLHS->evalInt()) return 1;      if (pLHS->evalInt()) return 1;
1179      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);;      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);;
# Line 833  void Or::dump(int level) { Line 1191  void Or::dump(int level) {
1191      printf(")\n");      printf(")\n");
1192  }  }
1193    
1194  int BitwiseOr::evalInt() {  vmint BitwiseOr::evalInt() {
1195      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
1196      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);
1197      return pLHS->evalInt() | pRHS->evalInt();      return pLHS->evalInt() | pRHS->evalInt();
# Line 850  void BitwiseOr::dump(int level) { Line 1208  void BitwiseOr::dump(int level) {
1208      printf(")\n");      printf(")\n");
1209  }  }
1210    
1211  int And::evalInt() {  vmint And::evalInt() {
1212      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
1213      if (!pLHS->evalInt()) return 0;      if (!pLHS->evalInt()) return 0;
1214      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);
# Line 868  void And::dump(int level) { Line 1226  void And::dump(int level) {
1226      printf(")\n");      printf(")\n");
1227  }  }
1228    
1229  int BitwiseAnd::evalInt() {  vmint BitwiseAnd::evalInt() {
1230      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
1231      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);
1232      return pLHS->evalInt() & pRHS->evalInt();      return pLHS->evalInt() & pRHS->evalInt();
# Line 901  void BitwiseNot::dump(int level) { Line 1259  void BitwiseNot::dump(int level) {
1259      printf(")\n");      printf(")\n");
1260  }  }
1261    
1262    String Final::evalCastToStr() {
1263        if (exprType() == REAL_EXPR)
1264            return ToString(evalReal());
1265        else
1266            return ToString(evalInt());
1267    }
1268    
1269    void Final::dump(int level) {
1270        printIndents(level);
1271        printf("Final(\n");
1272        expr->dump(level+1);
1273        printIndents(level);
1274        printf(")\n");
1275    }
1276    
1277  StatementsRef ParserContext::userFunctionByName(const String& name) {  StatementsRef ParserContext::userFunctionByName(const String& name) {
1278      if (!userFnTable.count(name)) {      if (!userFnTable.count(name)) {
1279          return StatementsRef();          return StatementsRef();
# Line 929  IntVariableRef ParserContext::globalIntV Line 1302  IntVariableRef ParserContext::globalIntV
1302      return globalVar(name);      return globalVar(name);
1303  }  }
1304    
1305    RealVariableRef ParserContext::globalRealVar(const String& name) {
1306        return globalVar(name);
1307    }
1308    
1309  StringVariableRef ParserContext::globalStrVar(const String& name) {  StringVariableRef ParserContext::globalStrVar(const String& name) {
1310      return globalVar(name);      return globalVar(name);
1311  }  }
# Line 939  ParserContext::~ParserContext() { Line 1316  ParserContext::~ParserContext() {
1316          delete globalIntMemory;          delete globalIntMemory;
1317          globalIntMemory = NULL;          globalIntMemory = NULL;
1318      }      }
1319        if (globalRealMemory) {
1320            delete globalRealMemory;
1321            globalRealMemory = NULL;
1322        }
1323  }  }
1324    
1325  void ParserContext::addErr(int firstLine, int lastLine, int firstColumn, int lastColumn, const char* txt) {  void ParserContext::addErr(int firstLine, int lastLine, int firstColumn, int lastColumn, const char* txt) {
# Line 965  void ParserContext::addWrn(int firstLine Line 1346  void ParserContext::addWrn(int firstLine
1346      vIssues.push_back(w);      vIssues.push_back(w);
1347  }  }
1348    
1349    void ParserContext::addPreprocessorComment(int firstLine, int lastLine, int firstColumn, int lastColumn) {
1350        CodeBlock block;
1351        block.firstLine = firstLine;
1352        block.lastLine = lastLine;
1353        block.firstColumn = firstColumn;
1354        block.lastColumn = lastColumn;
1355        vPreprocessorComments.push_back(block);
1356    }
1357    
1358  bool ParserContext::setPreprocessorCondition(const char* name) {  bool ParserContext::setPreprocessorCondition(const char* name) {
1359      if (builtinPreprocessorConditions.count(name)) return false;      if (builtinPreprocessorConditions.count(name)) return false;
1360      if (userPreprocessorConditions.count(name)) return false;      if (userPreprocessorConditions.count(name)) return false;
# Line 996  std::vector<ParserIssue> ParserContext:: Line 1386  std::vector<ParserIssue> ParserContext::
1386      return vWarnings;      return vWarnings;
1387  }  }
1388    
1389    std::vector<CodeBlock> ParserContext::preprocessorComments() const {
1390        return vPreprocessorComments;
1391    }
1392    
1393  VMEventHandler* ParserContext::eventHandler(uint index) {  VMEventHandler* ParserContext::eventHandler(uint index) {
1394      if (!handlers) return NULL;      if (!handlers) return NULL;
1395      return handlers->eventHandler(index);      return handlers->eventHandler(index);
# Line 1006  VMEventHandler* ParserContext::eventHand Line 1400  VMEventHandler* ParserContext::eventHand
1400      return handlers->eventHandlerByName(name);      return handlers->eventHandlerByName(name);
1401  }  }
1402    
1403  void ParserContext::registerBuiltInConstIntVariables(const std::map<String,int>& vars) {  void ParserContext::registerBuiltInConstIntVariables(const std::map<String,vmint>& vars) {
1404      for (std::map<String,int>::const_iterator it = vars.begin();      for (std::map<String,vmint>::const_iterator it = vars.begin();
1405           it != vars.end(); ++it)           it != vars.end(); ++it)
1406      {      {
1407          ConstIntVariableRef ref = new ConstIntVariable(it->second);          ConstIntVariableRef ref = new ConstIntVariable(it->second);
# Line 1015  void ParserContext::registerBuiltInConst Line 1409  void ParserContext::registerBuiltInConst
1409      }      }
1410  }  }
1411    
1412  void ParserContext::registerBuiltInIntVariables(const std::map<String,VMIntRelPtr*>& vars) {  void ParserContext::registerBuiltInIntVariables(const std::map<String,VMIntPtr*>& vars) {
1413      for (std::map<String,VMIntRelPtr*>::const_iterator it = vars.begin();      for (std::map<String,VMIntPtr*>::const_iterator it = vars.begin();
1414           it != vars.end(); ++it)           it != vars.end(); ++it)
1415      {      {
1416          BuiltInIntVariableRef ref = new BuiltInIntVariable(it->first, it->second);          BuiltInIntVariableRef ref = new BuiltInIntVariable(it->first, it->second);
# Line 1042  void ParserContext::registerBuiltInDynVa Line 1436  void ParserContext::registerBuiltInDynVa
1436      }      }
1437  }  }
1438    
1439    ExecContext::ExecContext() :
1440        status(VM_EXEC_NOT_RUNNING), flags(STMT_SUCCESS), stackFrame(-1),
1441        suspendMicroseconds(0), instructionsCount(0)
1442    {
1443        exitRes.value = NULL;
1444    }
1445    
1446    void ExecContext::forkTo(VMExecContext* ectx) const {
1447        ExecContext* child = dynamic_cast<ExecContext*>(ectx);
1448    
1449        child->polyphonicIntMemory.copyFlatFrom(polyphonicIntMemory);
1450        child->polyphonicRealMemory.copyFlatFrom(polyphonicRealMemory);
1451        child->status = VM_EXEC_SUSPENDED;
1452        child->flags = STMT_SUCCESS;
1453        child->stack.copyFlatFrom(stack);
1454        child->stackFrame = stackFrame;
1455        child->suspendMicroseconds = 0;
1456        child->instructionsCount = 0;
1457    }
1458    
1459  } // namespace LinuxSampler  } // namespace LinuxSampler

Legend:
Removed from v.3056  
changed lines
  Added in v.3573

  ViewVC Help
Powered by ViewVC