/[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 2948 by schoenebeck, Fri Jul 15 15:29:04 2016 UTC revision 3577 by schoenebeck, Wed Aug 28 15:23:23 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  int IntLiteral::evalInt() {  String RealExpr::evalCastToStr() {
38        return ToString(evalReal());
39    }
40    
41    String IntArrayExpr::evalCastToStr() {
42        String s = "{";
43        for (vmint i = 0; i < arraySize(); ++i) {
44            vmint val = evalIntElement(i);
45            if (i) s += ",";
46            s += ToString(val);
47        }
48        s += "}";
49        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    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 49  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 66  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 83  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 100  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 121  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 149  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 177  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 189  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 241  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 252  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 288  void FunctionCall::dump(int level) { Line 410  void FunctionCall::dump(int level) {
410    
411  ExprType_t FunctionCall::exprType() const {  ExprType_t FunctionCall::exprType() const {
412      if (!fn) return EMPTY_EXPR;      if (!fn) return EMPTY_EXPR;
413      return fn->returnType();      FunctionCall* self = const_cast<FunctionCall*>(this);
414        return fn->returnType(dynamic_cast<VMFnArgs*>(&*self->args));
415  }  }
416    
417  VMFnResult* FunctionCall::execVMFn() {  VMFnResult* FunctionCall::execVMFn() {
# Line 305  StmtFlags_t FunctionCall::exec() { Line 428  StmtFlags_t FunctionCall::exec() {
428      return result->resultFlags();      return result->resultFlags();
429  }  }
430    
431  int FunctionCall::evalInt() {  vmint FunctionCall::evalInt() {
432      VMFnResult* result = execVMFn();      VMFnResult* result = execVMFn();
433      if (!result) return 0;      if (!result) return 0;
434      VMIntExpr* intExpr = dynamic_cast<VMIntExpr*>(result->resultValue());      VMIntExpr* intExpr = dynamic_cast<VMIntExpr*>(result->resultValue());
# Line 313  int FunctionCall::evalInt() { Line 436  int FunctionCall::evalInt() {
436      return intExpr->evalInt();      return intExpr->evalInt();
437  }  }
438    
439    vmfloat FunctionCall::evalReal() {
440        VMFnResult* result = execVMFn();
441        if (!result) return 0;
442        VMRealExpr* realExpr = dynamic_cast<VMRealExpr*>(result->resultValue());
443        if (!realExpr) return 0;
444        return realExpr->evalReal();
445    }
446    
447    VMIntArrayExpr* FunctionCall::asIntArray() const {
448        VMFnResult* result = const_cast<FunctionCall*>(this)->execVMFn();
449        if (!result) return 0;
450        VMIntArrayExpr* intArrExpr = dynamic_cast<VMIntArrayExpr*>(result->resultValue());
451        return intArrExpr;
452    }
453    
454    VMRealArrayExpr* FunctionCall::asRealArray() const {
455        VMFnResult* result = const_cast<FunctionCall*>(this)->execVMFn();
456        if (!result) return 0;
457        VMRealArrayExpr* realArrExpr = dynamic_cast<VMRealArrayExpr*>(result->resultValue());
458        return realArrExpr;
459    }
460    
461  String FunctionCall::evalStr() {  String FunctionCall::evalStr() {
462      VMFnResult* result = execVMFn();      VMFnResult* result = execVMFn();
463      if (!result) return "";      if (!result) return "";
# Line 324  String FunctionCall::evalStr() { Line 469  String FunctionCall::evalStr() {
469  String FunctionCall::evalCastToStr() {  String FunctionCall::evalCastToStr() {
470      VMFnResult* result = execVMFn();      VMFnResult* result = execVMFn();
471      if (!result) return "";      if (!result) return "";
472      if (result->resultValue()->exprType() == STRING_EXPR) {      const ExprType_t resultType = result->resultValue()->exprType();
473        if (resultType == STRING_EXPR) {
474          VMStringExpr* strExpr = dynamic_cast<VMStringExpr*>(result->resultValue());          VMStringExpr* strExpr = dynamic_cast<VMStringExpr*>(result->resultValue());
475          return strExpr ? strExpr->evalStr() : "";          return strExpr ? strExpr->evalStr() : "";
476        } else if (resultType == REAL_EXPR) {
477            VMRealExpr* realExpr = dynamic_cast<VMRealExpr*>(result->resultValue());
478            return realExpr ? ToString(realExpr->evalReal()) : "";
479      } else {      } else {
480          VMIntExpr* intExpr = dynamic_cast<VMIntExpr*>(result->resultValue());          VMIntExpr* intExpr = dynamic_cast<VMIntExpr*>(result->resultValue());
481          return intExpr ? ToString(intExpr->evalInt()) : "";          return intExpr ? ToString(intExpr->evalInt()) : "";
482      }      }
483  }  }
484    
485    ScalarNumberVariable::ScalarNumberVariable(ParserContext* ctx, vmint _memPos,
486                                               bool _bConst, bool _bPolyphonic,
487                                               bool _bFinal)
488        : Variable(ctx, _memPos, _bConst),
489          Unit(),
490          polyphonic(_bPolyphonic), finalVal(_bFinal)
491    {
492    }
493    
494  IntVariable::IntVariable(ParserContext* ctx)  IntVariable::IntVariable(ParserContext* ctx)
495      : Variable(ctx, ctx ? ctx->globalIntVarCount++ : 0, false), polyphonic(false)      : ScalarNumberVariable(ctx, ctx ? ctx->globalIntVarCount++ : 0)
496  {  {
497      //printf("globalIntVar parserctx=0x%lx memPOS=%d\n", ctx, memPos);      //printf("globalIntVar parserctx=0x%lx memPOS=%d\n", ctx, memPos);
498      assert(ctx);      assert(ctx);
499  }  }
500    
501  inline static int postfixInc(int& object, int incBy) {  inline static vmint postfixInc(vmint& object, vmint incBy) {
502      const int i = object;      const vmint i = object;
503      object += incBy;      object += incBy;
504      return i;      return i;
505  }  }
506    
507  IntVariable::IntVariable(ParserContext* ctx, bool polyphonic, bool bConst, int size)  IntVariable::IntVariable(ParserContext* ctx, bool bPolyphonic, bool bConst, vmint size)
508      : Variable(ctx, !ctx ? 0 : polyphonic ? postfixInc(ctx->polyphonicIntVarCount, size) : postfixInc(ctx->globalIntVarCount, size), bConst),      : ScalarNumberVariable(
509        polyphonic(polyphonic)            ctx,
510              !ctx ? 0 : bPolyphonic ? postfixInc(ctx->polyphonicIntVarCount, size) :
511                                       postfixInc(ctx->globalIntVarCount, size),
512              bConst, bPolyphonic
513          )
514  {  {
515      //printf("InvVar size=%d parserCtx=0x%lx\n", size, (uint64_t)ctx);      //printf("IntVar size=%d parserCtx=0x%lx\n", size, (uint64_t)ctx);
516      if (polyphonic) {      if (bPolyphonic) {
517          //printf("polyIntVar memPOS=%d\n", memPos);          //printf("polyIntVar memPOS=%d\n", memPos);
518          assert(ctx);          assert(ctx);
519      }      }
# Line 359  IntVariable::IntVariable(ParserContext* Line 521  IntVariable::IntVariable(ParserContext*
521    
522  void IntVariable::assign(Expression* expr) {  void IntVariable::assign(Expression* expr) {
523      IntExpr* intExpr = dynamic_cast<IntExpr*>(expr);      IntExpr* intExpr = dynamic_cast<IntExpr*>(expr);
524      if (intExpr)      if (intExpr) {
525          if (polyphonic)          if (isPolyphonic())
526              context->execContext->polyphonicIntMemory[memPos] = intExpr->evalInt();              context->execContext->polyphonicIntMemory[memPos] = intExpr->evalInt();
527          else          else
528              (*context->globalIntMemory)[memPos] = intExpr->evalInt();              (*context->globalIntMemory)[memPos] = intExpr->evalInt();
529        }
530  }  }
531    
532  int IntVariable::evalInt() {  vmint IntVariable::evalInt() {
533      //printf("IntVariable::eval pos=%d\n", memPos);      //printf("IntVariable::eval pos=%d\n", memPos);
534      if (polyphonic) {      if (isPolyphonic()) {
535          //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);
536          return context->execContext->polyphonicIntMemory[memPos];          return context->execContext->polyphonicIntMemory[memPos];
537      }      }
# Line 381  void IntVariable::dump(int level) { Line 544  void IntVariable::dump(int level) {
544      //printf("IntVariable memPos=%d\n", memPos);      //printf("IntVariable memPos=%d\n", memPos);
545  }  }
546    
547  //ConstIntVariable::ConstIntVariable(ParserContext* ctx, int value)  RealVariable::RealVariable(ParserContext* ctx)
548  ConstIntVariable::ConstIntVariable(int value)      : ScalarNumberVariable(ctx, ctx ? ctx->globalRealVarCount++ : 0)
549    {
550        //printf("globalRealVar parserctx=0x%lx memPOS=%d\n", ctx, memPos);
551        assert(ctx);
552    }
553    
554    RealVariable::RealVariable(ParserContext* ctx, bool bPolyphonic, bool bConst, vmint size)
555        : ScalarNumberVariable(
556              ctx,
557              !ctx ? 0 : bPolyphonic ? postfixInc(ctx->polyphonicRealVarCount, size) :
558                                       postfixInc(ctx->globalRealVarCount, size),
559              bConst, bPolyphonic
560          )
561    {
562        //printf("RealVar size=%d parserCtx=0x%lx\n", size, (uint64_t)ctx);
563        if (bPolyphonic) {
564            //printf("polyRealVar memPOS=%d\n", memPos);
565            assert(ctx);
566        }
567    }
568    
569    void RealVariable::assign(Expression* expr) {
570        RealExpr* realExpr = dynamic_cast<RealExpr*>(expr);
571        if (realExpr) {
572            if (isPolyphonic())
573                context->execContext->polyphonicRealMemory[memPos] = realExpr->evalReal();
574            else
575                (*context->globalRealMemory)[memPos] = realExpr->evalReal();
576        }
577    }
578    
579    vmfloat RealVariable::evalReal() {
580        //printf("RealVariable::eval pos=%d\n", memPos);
581        if (isPolyphonic()) {
582            //printf("evalReal() poly memPos=%d execCtx=0x%lx\n", memPos, (uint64_t)context->execContext);
583            return context->execContext->polyphonicRealMemory[memPos];
584        }
585        return (*context->globalRealMemory)[memPos];
586    }
587    
588    void RealVariable::dump(int level) {
589        printIndents(level);
590        printf("RealVariable\n");
591        //printf("RealVariable memPos=%d\n", memPos);
592    }
593    
594    ConstIntVariable::ConstIntVariable(vmint value)
595      : IntVariable(NULL,false,true), value(value)      : IntVariable(NULL,false,true), value(value)
596  {  {
597  }  }
# Line 398  void ConstIntVariable::assign(Expression Line 607  void ConstIntVariable::assign(Expression
607  */  */
608  }  }
609    
610  int ConstIntVariable::evalInt() {  vmint ConstIntVariable::evalInt() {
611      return value;      return value;
612  }  }
613    
614  void ConstIntVariable::dump(int level) {  void ConstIntVariable::dump(int level) {
615      printIndents(level);      printIndents(level);
616      printf("ConstIntVariable val=%d\n", value);      printf("ConstIntVariable val=%lld\n", value);
617    }
618    
619    ConstRealVariable::ConstRealVariable(vmfloat value)
620        : RealVariable(NULL,false,true), value(value)
621    {
622  }  }
623    
624  BuiltInIntVariable::BuiltInIntVariable(const String& name, VMIntRelPtr* ptr)  void ConstRealVariable::assign(Expression* expr) {
625        // ignore assignment
626    }
627    
628    vmfloat ConstRealVariable::evalReal() {
629        return value;
630    }
631    
632    void ConstRealVariable::dump(int level) {
633        printIndents(level);
634        printf("ConstRealVariable val=%f\n", value);
635    }
636    
637    BuiltInIntVariable::BuiltInIntVariable(const String& name, VMIntPtr* ptr)
638      : IntVariable(NULL,false,false), name(name), ptr(ptr)      : IntVariable(NULL,false,false), name(name), ptr(ptr)
639  {  {
640  }  }
# Line 418  void BuiltInIntVariable::assign(Expressi Line 645  void BuiltInIntVariable::assign(Expressi
645      ptr->assign(valueExpr->evalInt());      ptr->assign(valueExpr->evalInt());
646  }  }
647    
648  int BuiltInIntVariable::evalInt() {  vmint BuiltInIntVariable::evalInt() {
649      return ptr->evalInt();      return ptr->evalInt();
650  }  }
651    
# Line 437  void PolyphonicIntVariable::dump(int lev Line 664  void PolyphonicIntVariable::dump(int lev
664      printf("PolyphonicIntVariable\n");      printf("PolyphonicIntVariable\n");
665  }  }
666    
667  IntArrayVariable::IntArrayVariable(ParserContext* ctx, int size)  PolyphonicRealVariable::PolyphonicRealVariable(ParserContext* ctx)
668        : RealVariable(ctx,true,false)
669    {
670    }
671    
672    void PolyphonicRealVariable::dump(int level) {
673        printIndents(level);
674        printf("PolyphonicRealVariable\n");
675    }
676    
677    IntArrayVariable::IntArrayVariable(ParserContext* ctx, vmint size)
678      : Variable(ctx, 0, false)      : Variable(ctx, 0, false)
679  {  {
680      values.resize(size);      values.resize(size);
681      memset(&values[0], 0, size * sizeof(int));      memset(&values[0], 0, size * sizeof(vmint));
682  }  }
683    
684  IntArrayVariable::IntArrayVariable(ParserContext* ctx, int size, ArgsRef values)  IntArrayVariable::IntArrayVariable(ParserContext* ctx, vmint size, ArgsRef values, bool _bConst)
685      : Variable(ctx, 0, false)      : Variable(ctx, 0, _bConst)
686  {  {
687      this->values.resize(size);      this->values.resize(size);
688      for (int i = 0; i < values->argsCount(); ++i) {      for (vmint i = 0; i < values->argsCount(); ++i) {
689          VMIntExpr* expr = dynamic_cast<VMIntExpr*>(values->arg(i));          VMIntExpr* expr = dynamic_cast<VMIntExpr*>(values->arg(i));
690          if (expr) this->values[i] = expr->evalInt();          if (expr) this->values[i] = expr->evalInt();
691      }      }
# Line 459  IntArrayVariable::IntArrayVariable(Parse Line 696  IntArrayVariable::IntArrayVariable(Parse
696  {  {
697  }  }
698    
699  int IntArrayVariable::evalIntElement(uint i) {  vmint IntArrayVariable::evalIntElement(vmuint i) {
700      if (i >= values.size()) return 0;      if (i >= values.size()) return 0;
701      return values[i];      return values[i];
702  }  }
703    
704  void IntArrayVariable::assignIntElement(uint i, int value) {  void IntArrayVariable::assignIntElement(vmuint i, vmint value) {
705      if (i >= values.size()) return;      if (i >= values.size()) return;
706      values[i] = value;      values[i] = value;
707  }  }
# Line 472  void IntArrayVariable::assignIntElement( Line 709  void IntArrayVariable::assignIntElement(
709  void IntArrayVariable::dump(int level) {  void IntArrayVariable::dump(int level) {
710      printIndents(level);      printIndents(level);
711      printf("IntArray(");      printf("IntArray(");
712      for (int i = 0; i < values.size(); ++i) {      for (vmint i = 0; i < values.size(); ++i) {
713          if (i % 12 == 0) {          if (i % 12 == 0) {
714              printf("\n");              printf("\n");
715              printIndents(level+1);              printIndents(level+1);
716          }          }
717          printf("%d, ", values[i]);          printf("%lld, ", values[i]);
718        }
719        printIndents(level);
720        printf(")\n");
721    }
722    
723    RealArrayVariable::RealArrayVariable(ParserContext* ctx, vmint size)
724        : Variable(ctx, 0, false)
725    {
726        values.resize(size);
727        memset(&values[0], 0, size * sizeof(vmfloat));
728    }
729    
730    RealArrayVariable::RealArrayVariable(ParserContext* ctx, vmint size, ArgsRef values, bool _bConst)
731        : Variable(ctx, 0, _bConst)
732    {
733        this->values.resize(size);
734        for (vmint i = 0; i < values->argsCount(); ++i) {
735            VMRealExpr* expr = dynamic_cast<VMRealExpr*>(values->arg(i));
736            if (expr) this->values[i] = expr->evalReal();
737        }
738    }
739    
740    RealArrayVariable::RealArrayVariable(ParserContext* ctx, bool bConst)
741        : Variable(ctx, 0, bConst)
742    {
743    }
744    
745    vmfloat RealArrayVariable::evalRealElement(vmuint i) {
746        if (i >= values.size()) return 0;
747        return values[i];
748    }
749    
750    void RealArrayVariable::assignRealElement(vmuint i, vmfloat value) {
751        if (i >= values.size()) return;
752        values[i] = value;
753    }
754    
755    void RealArrayVariable::dump(int level) {
756        printIndents(level);
757        printf("RealArray(");
758        for (vmint i = 0; i < values.size(); ++i) {
759            if (i % 12 == 0) {
760                printf("\n");
761                printIndents(level+1);
762            }
763            printf("%f, ", values[i]);
764      }      }
765      printIndents(level);      printIndents(level);
766      printf(")\n");      printf(")\n");
# Line 488  BuiltInIntArrayVariable::BuiltInIntArray Line 771  BuiltInIntArrayVariable::BuiltInIntArray
771  {  {
772  }  }
773    
774  int BuiltInIntArrayVariable::evalIntElement(uint i) {  vmint BuiltInIntArrayVariable::evalIntElement(vmuint i) {
775      return i >= array->size ? 0 : array->data[i];      return i >= array->size ? 0 : array->data[i];
776  }  }
777    
778  void BuiltInIntArrayVariable::assignIntElement(uint i, int value) {  void BuiltInIntArrayVariable::assignIntElement(vmuint i, vmint value) {
779      if (i >= array->size) return;      if (i >= array->size) return;
780      array->data[i] = value;      array->data[i] = value;
781  }  }
# Line 502  void BuiltInIntArrayVariable::dump(int l Line 785  void BuiltInIntArrayVariable::dump(int l
785      printf("Built-In Int Array Variable '%s'\n", name.c_str());      printf("Built-In Int Array Variable '%s'\n", name.c_str());
786  }  }
787    
788  IntArrayElement::IntArrayElement(IntArrayVariableRef array, IntExprRef arrayIndex)  IntArrayElement::IntArrayElement(IntArrayExprRef array, IntExprRef arrayIndex)
789      : IntVariable(NULL, false, false, 0), array(array), index(arrayIndex)      : IntVariable(NULL, false, false, 0), array(array), index(arrayIndex)
790  {      {    
791  }  }
# Line 510  IntArrayElement::IntArrayElement(IntArra Line 793  IntArrayElement::IntArrayElement(IntArra
793  void IntArrayElement::assign(Expression* expr) {  void IntArrayElement::assign(Expression* expr) {
794      IntExpr* valueExpr = dynamic_cast<IntExpr*>(expr);      IntExpr* valueExpr = dynamic_cast<IntExpr*>(expr);
795      if (!valueExpr) return;      if (!valueExpr) return;
796      int value = valueExpr->evalInt();      vmint value = valueExpr->evalInt();
797    
798      if (!index) return;      if (!index) return;
799      int idx = index->evalInt();      vmint idx = index->evalInt();
800      if (idx < 0 || idx >= array->arraySize()) return;      if (idx < 0 || idx >= array->arraySize()) return;
801    
802      array->assignIntElement(idx, value);      array->assignIntElement(idx, value);
803  }  }
804    
805  int IntArrayElement::evalInt() {  vmint IntArrayElement::evalInt() {
806      if (!index) return 0;      if (!index) return 0;
807      int idx = index->evalInt();      vmint idx = index->evalInt();
808      if (idx < 0 || idx >= array->arraySize()) return 0;      if (idx < 0 || idx >= array->arraySize()) return 0;
809    
810      return array->evalIntElement(idx);      return array->evalIntElement(idx);
# Line 532  void IntArrayElement::dump(int level) { Line 815  void IntArrayElement::dump(int level) {
815      printf("IntArrayElement\n");      printf("IntArrayElement\n");
816  }  }
817    
818    RealArrayElement::RealArrayElement(RealArrayExprRef array, IntExprRef arrayIndex)
819        : RealVariable(NULL, false, false, 0), array(array), index(arrayIndex)
820    {
821    }
822    
823    void RealArrayElement::assign(Expression* expr) {
824        RealExpr* valueExpr = dynamic_cast<RealExpr*>(expr);
825        if (!valueExpr) return;
826        vmfloat value = valueExpr->evalReal();
827    
828        if (!index) return;
829        vmint idx = index->evalInt();
830        if (idx < 0 || idx >= array->arraySize()) return;
831    
832        array->assignRealElement(idx, value);
833    }
834    
835    vmfloat RealArrayElement::evalReal() {
836        if (!index) return 0;
837        vmint idx = index->evalInt();
838        if (idx < 0 || idx >= array->arraySize()) return 0;
839    
840        return array->evalRealElement(idx);
841    }
842    
843    void RealArrayElement::dump(int level) {
844        printIndents(level);
845        printf("RealArrayElement\n");
846    }
847    
848  StringVariable::StringVariable(ParserContext* ctx)  StringVariable::StringVariable(ParserContext* ctx)
849      : Variable(ctx,ctx->globalStrVarCount++,false)      : Variable(ctx,ctx->globalStrVarCount++,false)
850  {  {
# Line 554  String StringVariable::evalStr() { Line 867  String StringVariable::evalStr() {
867    
868  void StringVariable::dump(int level) {  void StringVariable::dump(int level) {
869      printIndents(level);      printIndents(level);
870      printf("StringVariable memPos=%d\n", memPos);      printf("StringVariable memPos=%lld\n", memPos);
871  }  }
872    
873  ConstStringVariable::ConstStringVariable(ParserContext* ctx, String _value)  ConstStringVariable::ConstStringVariable(ParserContext* ctx, String _value)
# Line 577  void ConstStringVariable::dump(int level Line 890  void ConstStringVariable::dump(int level
890      printf("ConstStringVariable val='%s'\n", value.c_str());      printf("ConstStringVariable val='%s'\n", value.c_str());
891  }  }
892    
893    MetricPrefix_t ScalarNumberBinaryOp::unitPrefix(vmuint i) const {
894        ScalarNumberExprRef l = (ScalarNumberExprRef) lhs;
895        ScalarNumberExprRef r = (ScalarNumberExprRef) rhs;
896        return (r->unitFactor() < l->unitFactor()) ? r->unitPrefix(i) : l->unitPrefix(i);
897    }
898    
899    StdUnit_t ScalarNumberBinaryOp::unitType() const {
900        ScalarNumberExprRef l = (ScalarNumberExprRef) lhs;
901        ScalarNumberExprRef r = (ScalarNumberExprRef) rhs;
902        return (l->unitType()) ? l->unitType() : r->unitType();
903    }
904    
905    bool ScalarNumberBinaryOp::isFinal() const {
906        ScalarNumberExprRef l = (ScalarNumberExprRef) lhs;
907        ScalarNumberExprRef r = (ScalarNumberExprRef) rhs;
908        return l->isFinal() || r->isFinal();
909    }
910    
911    ExprType_t VaritypeScalarBinaryOp::exprType() const {
912        return (lhs->exprType() == REAL_EXPR || rhs->exprType() == REAL_EXPR) ? REAL_EXPR : INT_EXPR;
913    }
914    
915    String VaritypeScalarBinaryOp::evalCastToStr() {
916        return (exprType() == REAL_EXPR) ?
917            RealExpr::evalCastToStr() : IntExpr::evalCastToStr();
918    }
919    
920  void If::dump(int level) {  void If::dump(int level) {
921      printIndents(level);      printIndents(level);
922      if (ifStatements && elseStatements)      if (ifStatements && elseStatements)
# Line 587  void If::dump(int level) { Line 927  void If::dump(int level) {
927          printf("if [INVALID]\n");          printf("if [INVALID]\n");
928  }  }
929    
930  int If::evalBranch() {  vmint If::evalBranch() {
931      if (condition->evalInt()) return 0;      if (condition->evalInt()) return 0;
932      if (elseStatements) return 1;      if (elseStatements) return 1;
933      return -1;      return -1;
934  }  }
935    
936  Statements* If::branch(uint i) const {  Statements* If::branch(vmuint i) const {
937      if (i == 0) return (Statements*) &*ifStatements;      if (i == 0) return (Statements*) &*ifStatements;
938      if (i == 1) return (elseStatements) ? (Statements*) &*elseStatements : NULL;      if (i == 1) return (elseStatements) ? (Statements*) &*elseStatements : NULL;
939      return NULL;      return NULL;
# Line 609  void SelectCase::dump(int level) { Line 949  void SelectCase::dump(int level) {
949      printIndents(level);      printIndents(level);
950      if (select)      if (select)
951          if (select->isConstExpr())          if (select->isConstExpr())
952              printf("Case select %d\n", select->evalInt());              printf("Case select %lld\n", select->evalInt());
953          else          else
954              printf("Case select [runtime expr]\n");              printf("Case select [runtime expr]\n");
955      else      else
956          printf("Case select NULL\n");          printf("Case select NULL\n");
957      for (int i = 0; i < branches.size(); ++i) {      for (vmint i = 0; i < branches.size(); ++i) {
958          printIndents(level+1);          printIndents(level+1);
959          CaseBranch& branch = branches[i];          CaseBranch& branch = branches[i];
960          if (branch.from && branch.to)          if (branch.from && branch.to)
961              if (branch.from->isConstExpr() && branch.to->isConstExpr())              if (branch.from->isConstExpr() && branch.to->isConstExpr())
962                  printf("case %d to %d\n", branch.from->evalInt(), branch.to->evalInt());                  printf("case %lld to %lld\n", branch.from->evalInt(), branch.to->evalInt());
963              else if (branch.from->isConstExpr() && !branch.to->isConstExpr())              else if (branch.from->isConstExpr() && !branch.to->isConstExpr())
964                  printf("case %d to [runtime expr]\n", branch.from->evalInt());                  printf("case %lld to [runtime expr]\n", branch.from->evalInt());
965              else if (!branch.from->isConstExpr() && branch.to->isConstExpr())              else if (!branch.from->isConstExpr() && branch.to->isConstExpr())
966                  printf("case [runtime expr] to %d\n", branch.to->evalInt());                  printf("case [runtime expr] to %lld\n", branch.to->evalInt());
967              else              else
968                  printf("case [runtime expr] to [runtime expr]\n");                  printf("case [runtime expr] to [runtime expr]\n");
969          else if (branch.from)          else if (branch.from)
970              if (branch.from->isConstExpr())              if (branch.from->isConstExpr())
971                  printf("case %d\n", branch.from->evalInt());                  printf("case %lld\n", branch.from->evalInt());
972              else              else
973                  printf("case [runtime expr]\n");                  printf("case [runtime expr]\n");
974          else          else
# Line 636  void SelectCase::dump(int level) { Line 976  void SelectCase::dump(int level) {
976      }      }
977  }  }
978    
979  int SelectCase::evalBranch() {  vmint SelectCase::evalBranch() {
980      int value = select->evalInt();      vmint value = select->evalInt();
981      for (int i = 0; i < branches.size(); ++i) {      for (vmint i = 0; i < branches.size(); ++i) {
982          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" ...
983              if (branches.at(i).from->evalInt() <= value &&              if (branches.at(i).from->evalInt() <= value &&
984                  branches.at(i).to->evalInt() >= value) return i;                  branches.at(i).to->evalInt() >= value) return i;
# Line 649  int SelectCase::evalBranch() { Line 989  int SelectCase::evalBranch() {
989      return -1;      return -1;
990  }  }
991    
992  Statements* SelectCase::branch(uint i) const {  Statements* SelectCase::branch(vmuint i) const {
993      if (i < branches.size())      if (i < branches.size())
994          return const_cast<Statements*>( &*branches[i].statements );          return const_cast<Statements*>( &*branches[i].statements );
995      return NULL;      return NULL;
# Line 657  Statements* SelectCase::branch(uint i) c Line 997  Statements* SelectCase::branch(uint i) c
997    
998  bool SelectCase::isPolyphonic() const {  bool SelectCase::isPolyphonic() const {
999      if (select->isPolyphonic()) return true;      if (select->isPolyphonic()) return true;
1000      for (int i = 0; i < branches.size(); ++i)      for (vmint i = 0; i < branches.size(); ++i)
1001          if (branches[i].statements->isPolyphonic())          if (branches[i].statements->isPolyphonic())
1002              return true;              return true;
1003      return false;      return false;
# Line 686  void While::dump(int level) { Line 1026  void While::dump(int level) {
1026      printIndents(level);      printIndents(level);
1027      if (m_condition)      if (m_condition)
1028          if (m_condition->isConstExpr())          if (m_condition->isConstExpr())
1029              printf("while (%d) {\n", m_condition->evalInt());              printf("while (%lld) {\n", m_condition->evalInt());
1030          else          else
1031              printf("while ([runtime expr]) {\n");              printf("while ([runtime expr]) {\n");
1032      else      else
# Line 705  bool While::evalLoopStartCondition() { Line 1045  bool While::evalLoopStartCondition() {
1045      return m_condition->evalInt();      return m_condition->evalInt();
1046  }  }
1047    
1048    void SyncBlock::dump(int level) {
1049        printIndents(level);
1050        printf("sync {\n");
1051        m_statements->dump(level+1);
1052        printIndents(level);
1053        printf("}\n");
1054    }
1055    
1056    Statements* SyncBlock::statements() const {
1057        return (m_statements) ? const_cast<Statements*>( &*m_statements ) : NULL;
1058    }
1059    
1060    String Neg::evalCastToStr() {
1061        return expr->evalCastToStr();
1062    }
1063    
1064  void Neg::dump(int level) {  void Neg::dump(int level) {
1065      printIndents(level);      printIndents(level);
1066      printf("Negative Expr\n");      printf("Negative Expr\n");
# Line 738  bool ConcatString::isConstExpr() const { Line 1094  bool ConcatString::isConstExpr() const {
1094      return lhs->isConstExpr() && rhs->isConstExpr();      return lhs->isConstExpr() && rhs->isConstExpr();
1095  }  }
1096    
1097  int Relation::evalInt() {  template<class T_LHS, class T_RHS>
1098    static inline vmint _evalRelation(Relation::Type type, T_LHS lhs, T_RHS rhs) {
1099      switch (type) {      switch (type) {
1100          case LESS_THAN:          case Relation::LESS_THAN:
1101              return lhs->evalInt() < rhs->evalInt();              return lhs < rhs;
1102          case GREATER_THAN:          case Relation::GREATER_THAN:
1103              return lhs->evalInt() > rhs->evalInt();              return lhs > rhs;
1104          case LESS_OR_EQUAL:          case Relation::LESS_OR_EQUAL:
1105              return lhs->evalInt() <= rhs->evalInt();              return lhs <= rhs;
1106          case GREATER_OR_EQUAL:          case Relation::GREATER_OR_EQUAL:
1107              return lhs->evalInt() >= rhs->evalInt();              return lhs >= rhs;
1108          case EQUAL:          case Relation::EQUAL:
1109              if (lhs->exprType() == STRING_EXPR || rhs->exprType() == STRING_EXPR)              return lhs == rhs;
1110            case Relation::NOT_EQUAL:
1111                return lhs != rhs;
1112        }
1113        return 0;
1114    }
1115    
1116    vmint Relation::evalInt() {
1117        const ExprType_t lType = lhs->exprType();
1118        const ExprType_t rType = rhs->exprType();
1119        if (lType == STRING_EXPR || rType == STRING_EXPR) {
1120            switch (type) {
1121                case EQUAL:
1122                  return lhs->evalCastToStr() == rhs->evalCastToStr();                  return lhs->evalCastToStr() == rhs->evalCastToStr();
1123              else              case NOT_EQUAL:
                 return lhs->evalInt() == rhs->evalInt();  
         case NOT_EQUAL:  
             if (lhs->exprType() == STRING_EXPR || rhs->exprType() == STRING_EXPR)  
1124                  return lhs->evalCastToStr() != rhs->evalCastToStr();                  return lhs->evalCastToStr() != rhs->evalCastToStr();
1125              else              default:
1126                  return lhs->evalInt() != rhs->evalInt();                  return 0;
1127            }
1128        } else if (lType == REAL_EXPR && rType == REAL_EXPR) {
1129            return _evalRelation(
1130                type, lhs->asReal()->evalReal(), rhs->asReal()->evalReal()
1131            );
1132        } else if (lType == REAL_EXPR && rType == INT_EXPR) {
1133            return _evalRelation(
1134                type, lhs->asReal()->evalReal(), rhs->asInt()->evalInt()
1135            );
1136        } else if (lType == INT_EXPR && rType == REAL_EXPR) {
1137            return _evalRelation(
1138                type, lhs->asInt()->evalInt(), rhs->asReal()->evalReal()
1139            );
1140        } else {
1141            return _evalRelation(
1142                type, lhs->asInt()->evalInt(), rhs->asInt()->evalInt()
1143            );
1144      }      }
     return 0;  
1145  }  }
1146    
1147  void Relation::dump(int level) {  void Relation::dump(int level) {
# Line 796  bool Relation::isConstExpr() const { Line 1178  bool Relation::isConstExpr() const {
1178      return lhs->isConstExpr() && rhs->isConstExpr();      return lhs->isConstExpr() && rhs->isConstExpr();
1179  }  }
1180    
1181  int Or::evalInt() {  vmint Or::evalInt() {
1182      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
1183      if (pLHS->evalInt()) return 1;      if (pLHS->evalInt()) return 1;
1184      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);;      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);;
# Line 814  void Or::dump(int level) { Line 1196  void Or::dump(int level) {
1196      printf(")\n");      printf(")\n");
1197  }  }
1198    
1199  int BitwiseOr::evalInt() {  vmint BitwiseOr::evalInt() {
1200      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
1201      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);
1202      return pLHS->evalInt() | pRHS->evalInt();      return pLHS->evalInt() | pRHS->evalInt();
# Line 831  void BitwiseOr::dump(int level) { Line 1213  void BitwiseOr::dump(int level) {
1213      printf(")\n");      printf(")\n");
1214  }  }
1215    
1216  int And::evalInt() {  vmint And::evalInt() {
1217      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
1218      if (!pLHS->evalInt()) return 0;      if (!pLHS->evalInt()) return 0;
1219      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);
# Line 849  void And::dump(int level) { Line 1231  void And::dump(int level) {
1231      printf(")\n");      printf(")\n");
1232  }  }
1233    
1234  int BitwiseAnd::evalInt() {  vmint BitwiseAnd::evalInt() {
1235      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
1236      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);
1237      return pLHS->evalInt() & pRHS->evalInt();      return pLHS->evalInt() & pRHS->evalInt();
# Line 882  void BitwiseNot::dump(int level) { Line 1264  void BitwiseNot::dump(int level) {
1264      printf(")\n");      printf(")\n");
1265  }  }
1266    
1267    String Final::evalCastToStr() {
1268        if (exprType() == REAL_EXPR)
1269            return ToString(evalReal());
1270        else
1271            return ToString(evalInt());
1272    }
1273    
1274    void Final::dump(int level) {
1275        printIndents(level);
1276        printf("Final(\n");
1277        expr->dump(level+1);
1278        printIndents(level);
1279        printf(")\n");
1280    }
1281    
1282    StatementsRef ParserContext::userFunctionByName(const String& name) {
1283        if (!userFnTable.count(name)) {
1284            return StatementsRef();
1285        }
1286        return userFnTable.find(name)->second;
1287    }
1288    
1289  VariableRef ParserContext::variableByName(const String& name) {  VariableRef ParserContext::variableByName(const String& name) {
1290      if (!vartable.count(name)) {      if (!vartable.count(name)) {
1291          return VariableRef();          return VariableRef();
# Line 903  IntVariableRef ParserContext::globalIntV Line 1307  IntVariableRef ParserContext::globalIntV
1307      return globalVar(name);      return globalVar(name);
1308  }  }
1309    
1310    RealVariableRef ParserContext::globalRealVar(const String& name) {
1311        return globalVar(name);
1312    }
1313    
1314  StringVariableRef ParserContext::globalStrVar(const String& name) {  StringVariableRef ParserContext::globalStrVar(const String& name) {
1315      return globalVar(name);      return globalVar(name);
1316  }  }
# Line 913  ParserContext::~ParserContext() { Line 1321  ParserContext::~ParserContext() {
1321          delete globalIntMemory;          delete globalIntMemory;
1322          globalIntMemory = NULL;          globalIntMemory = NULL;
1323      }      }
1324        if (globalRealMemory) {
1325            delete globalRealMemory;
1326            globalRealMemory = NULL;
1327        }
1328  }  }
1329    
1330  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 939  void ParserContext::addWrn(int firstLine Line 1351  void ParserContext::addWrn(int firstLine
1351      vIssues.push_back(w);      vIssues.push_back(w);
1352  }  }
1353    
1354    void ParserContext::addPreprocessorComment(int firstLine, int lastLine, int firstColumn, int lastColumn) {
1355        CodeBlock block;
1356        block.firstLine = firstLine;
1357        block.lastLine = lastLine;
1358        block.firstColumn = firstColumn;
1359        block.lastColumn = lastColumn;
1360        vPreprocessorComments.push_back(block);
1361    }
1362    
1363  bool ParserContext::setPreprocessorCondition(const char* name) {  bool ParserContext::setPreprocessorCondition(const char* name) {
1364      if (builtinPreprocessorConditions.count(name)) return false;      if (builtinPreprocessorConditions.count(name)) return false;
1365      if (userPreprocessorConditions.count(name)) return false;      if (userPreprocessorConditions.count(name)) return false;
# Line 970  std::vector<ParserIssue> ParserContext:: Line 1391  std::vector<ParserIssue> ParserContext::
1391      return vWarnings;      return vWarnings;
1392  }  }
1393    
1394    std::vector<CodeBlock> ParserContext::preprocessorComments() const {
1395        return vPreprocessorComments;
1396    }
1397    
1398  VMEventHandler* ParserContext::eventHandler(uint index) {  VMEventHandler* ParserContext::eventHandler(uint index) {
1399      if (!handlers) return NULL;      if (!handlers) return NULL;
1400      return handlers->eventHandler(index);      return handlers->eventHandler(index);
# Line 980  VMEventHandler* ParserContext::eventHand Line 1405  VMEventHandler* ParserContext::eventHand
1405      return handlers->eventHandlerByName(name);      return handlers->eventHandlerByName(name);
1406  }  }
1407    
1408  void ParserContext::registerBuiltInConstIntVariables(const std::map<String,int>& vars) {  void ParserContext::registerBuiltInConstIntVariables(const std::map<String,vmint>& vars) {
1409      for (std::map<String,int>::const_iterator it = vars.begin();      for (std::map<String,vmint>::const_iterator it = vars.begin();
1410           it != vars.end(); ++it)           it != vars.end(); ++it)
1411      {      {
1412          ConstIntVariableRef ref = new ConstIntVariable(it->second);          ConstIntVariableRef ref = new ConstIntVariable(it->second);
# Line 989  void ParserContext::registerBuiltInConst Line 1414  void ParserContext::registerBuiltInConst
1414      }      }
1415  }  }
1416    
1417  void ParserContext::registerBuiltInIntVariables(const std::map<String,VMIntRelPtr*>& vars) {  void ParserContext::registerBuiltInIntVariables(const std::map<String,VMIntPtr*>& vars) {
1418      for (std::map<String,VMIntRelPtr*>::const_iterator it = vars.begin();      for (std::map<String,VMIntPtr*>::const_iterator it = vars.begin();
1419           it != vars.end(); ++it)           it != vars.end(); ++it)
1420      {      {
1421          BuiltInIntVariableRef ref = new BuiltInIntVariable(it->first, it->second);          BuiltInIntVariableRef ref = new BuiltInIntVariable(it->first, it->second);
# Line 1016  void ParserContext::registerBuiltInDynVa Line 1441  void ParserContext::registerBuiltInDynVa
1441      }      }
1442  }  }
1443    
1444    ExecContext::ExecContext() :
1445        status(VM_EXEC_NOT_RUNNING), flags(STMT_SUCCESS), stackFrame(-1),
1446        suspendMicroseconds(0), instructionsCount(0)
1447    {
1448        exitRes.value = NULL;
1449    }
1450    
1451    void ExecContext::forkTo(VMExecContext* ectx) const {
1452        ExecContext* child = dynamic_cast<ExecContext*>(ectx);
1453    
1454        child->polyphonicIntMemory.copyFlatFrom(polyphonicIntMemory);
1455        child->polyphonicRealMemory.copyFlatFrom(polyphonicRealMemory);
1456        child->status = VM_EXEC_SUSPENDED;
1457        child->flags = STMT_SUCCESS;
1458        child->stack.copyFlatFrom(stack);
1459        child->stackFrame = stackFrame;
1460        child->suspendMicroseconds = 0;
1461        child->instructionsCount = 0;
1462    }
1463    
1464  } // namespace LinuxSampler  } // namespace LinuxSampler
Legend:
Removed from v.2948  
changed lines
  Added in v.3577
  ViewVC Help
Powered by ViewVC