/[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 2581 by schoenebeck, Fri May 30 12:48:05 2014 UTC revision 3573 by schoenebeck, Tue Aug 27 21:36:53 2019 UTC
# Line 1  Line 1 
1  /*  /*
2   * Copyright (c) 2014 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 11  Line 11 
11  #include <string.h>  #include <string.h>
12  #include "tree.h"  #include "tree.h"
13  #include "../common/global_private.h"  #include "../common/global_private.h"
14    #include <assert.h>
15    
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 34  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 48  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 65  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 82  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 99  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      return (pLHS && pRHS) ? pRHS->evalInt() == 0 ? 0 : pLHS->evalInt() / pRHS->evalInt() : 0;      if (!pLHS || !pRHS) return 0;
203        vmint l = pLHS->evalInt();
204        vmint r = pRHS->evalInt();
205        if (r == 0) return 0;
206        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) {
# Line 116  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 143  void Args::dump(int level) { Line 270  void Args::dump(int level) {
270      printf(")\n");      printf(")\n");
271  }  }
272    
273    bool Args::isPolyphonic() const {
274        for (vmint i = 0; i < args.size(); ++i)
275            if (args[i]->isPolyphonic())
276                return true;
277        return false;
278    }
279    
280  EventHandlers::EventHandlers() {  EventHandlers::EventHandlers() {
281      //printf("EventHandlers::Constructor 0x%lx\n", (long long)this);      //printf("EventHandlers::Constructor 0x%lx\n", (long long)this);
282  }  }
# Line 165  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 176  EventHandler* EventHandlers::eventHandle Line 310  EventHandler* EventHandlers::eventHandle
310      return const_cast<EventHandler*>(&*args.at(index));      return const_cast<EventHandler*>(&*args.at(index));
311  }  }
312    
313    bool EventHandlers::isPolyphonic() const {
314        for (vmint i = 0; i < args.size(); ++i)
315            if (args[i]->isPolyphonic())
316                return true;
317        return false;
318    }
319    
320  Assignment::Assignment(VariableRef variable, ExpressionRef value)  Assignment::Assignment(VariableRef variable, ExpressionRef value)
321     : variable(variable), value(value)     : variable(variable), value(value)
322  {  {
# Line 193  StmtFlags_t Assignment::exec() { Line 334  StmtFlags_t Assignment::exec() {
334      return STMT_SUCCESS;      return STMT_SUCCESS;
335  }  }
336    
337    EventHandler::EventHandler(StatementsRef statements) {
338        this->statements = statements;
339        usingPolyphonics = statements->isPolyphonic();
340    }
341    
342  void EventHandler::dump(int level) {  void EventHandler::dump(int level) {
343      printIndents(level);      printIndents(level);
344      printf("EventHandler {\n");      printf("EventHandler {\n");
# Line 216  Statement* Statements::statement(uint i) Line 362  Statement* Statements::statement(uint i)
362      return &*args.at(i);      return &*args.at(i);
363  }  }
364    
365    bool Statements::isPolyphonic() const {
366        for (vmint i = 0; i < args.size(); ++i)
367            if (args[i]->isPolyphonic())
368                return true;
369        return false;
370    }
371    
372    DynamicVariableCall::DynamicVariableCall(const String& name, ParserContext* ctx, VMDynVar* v)
373        : Variable(ctx, 0, false), dynVar(v), varName(name)
374    {
375    }
376    
377    vmint DynamicVariableCall::evalInt() {
378        VMIntExpr* expr = dynamic_cast<VMIntExpr*>(dynVar);
379        if (!expr) return 0;
380        return expr->evalInt();
381    }
382    
383    String DynamicVariableCall::evalStr() {
384        VMStringExpr* expr = dynamic_cast<VMStringExpr*>(dynVar);
385        if (!expr) return "";
386        return expr->evalStr();
387    }
388    
389    String DynamicVariableCall::evalCastToStr() {
390        if (dynVar->exprType() == STRING_EXPR) {
391            return evalStr();
392        } else {
393            VMIntExpr* intExpr = dynamic_cast<VMIntExpr*>(dynVar);
394            return intExpr ? ToString(intExpr->evalInt()) : "";
395        }
396    }
397    
398    void DynamicVariableCall::dump(int level) {
399        printIndents(level);
400        printf("Dynamic Variable '%s'\n", varName.c_str());
401    }
402    
403  void FunctionCall::dump(int level) {  void FunctionCall::dump(int level) {
404      printIndents(level);      printIndents(level);
405      printf("FunctionCall '%s' args={\n", functionName.c_str());      printf("FunctionCall '%s' args={\n", functionName.c_str());
# Line 243  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 251  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 {
447        VMFnResult* result = const_cast<FunctionCall*>(this)->execVMFn();
448        if (!result) return 0;
449        VMIntArrayExpr* intArrExpr = dynamic_cast<VMIntArrayExpr*>(result->resultValue());
450        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 262  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);
497        assert(ctx);
498  }  }
499    
500  IntVariable::IntVariable(ParserContext* ctx, bool polyphonic, bool bConst, int size)  inline static vmint postfixInc(vmint& object, vmint incBy) {
501      : Variable(ctx, !ctx ? 0 : polyphonic ? ctx->polyphonicIntVarCount += size : ctx->globalIntVarCount += size, bConst),      const vmint i = object;
502        polyphonic(polyphonic)      object += incBy;
503        return i;
504    }
505    
506    IntVariable::IntVariable(ParserContext* ctx, bool bPolyphonic, bool bConst, vmint size)
507        : ScalarNumberVariable(
508              ctx,
509              !ctx ? 0 : bPolyphonic ? postfixInc(ctx->polyphonicIntVarCount, size) :
510                                       postfixInc(ctx->globalIntVarCount, size),
511              bConst, bPolyphonic
512          )
513  {  {
514        //printf("IntVar size=%d parserCtx=0x%lx\n", size, (uint64_t)ctx);
515        if (bPolyphonic) {
516            //printf("polyIntVar memPOS=%d\n", memPos);
517            assert(ctx);
518        }
519  }  }
520    
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);
535          return context->execContext->polyphonicIntMemory[memPos];          return context->execContext->polyphonicIntMemory[memPos];
536        }
537      return (*context->globalIntMemory)[memPos];      return (*context->globalIntMemory)[memPos];
538  }  }
539    
540  void IntVariable::dump(int level) {  void IntVariable::dump(int level) {
541      printIndents(level);      printIndents(level);
542      printf("IntVariable memPos=%d\n", memPos);      printf("IntVariable\n");
543        //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 320  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, VMIntPtr* ptr)
637        : IntVariable(NULL,false,false), name(name), ptr(ptr)
638    {
639    }
640    
641    void BuiltInIntVariable::assign(Expression* expr) {
642        IntExpr* valueExpr = dynamic_cast<IntExpr*>(expr);
643        if (!valueExpr) return;
644        ptr->assign(valueExpr->evalInt());
645    }
646    
647    vmint BuiltInIntVariable::evalInt() {
648        return ptr->evalInt();
649    }
650    
651    void BuiltInIntVariable::dump(int level) {
652        printIndents(level);
653        printf("Built-in IntVar '%s'\n", name.c_str());
654  }  }
655    
656  PolyphonicIntVariable::PolyphonicIntVariable(ParserContext* ctx)  PolyphonicIntVariable::PolyphonicIntVariable(ParserContext* ctx)
# Line 339  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      }      }
691  }  }
692    
693  int IntArrayVariable::evalIntElement(uint i) {  IntArrayVariable::IntArrayVariable(ParserContext* ctx, bool bConst)
694        : Variable(ctx, 0, bConst)
695    {
696    }
697    
698    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 369  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);      printIndents(level);
719      printf(")\n");      printf(")\n");
720  }  }
721    
722  IntArrayElement::IntArrayElement(IntArrayVariableRef array, IntExprRef arrayIndex)  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);
765        printf(")\n");
766    }
767    
768    BuiltInIntArrayVariable::BuiltInIntArrayVariable(const String& name, VMInt8Array* array)
769        : IntArrayVariable(NULL, false), name(name), array(array)
770    {
771    }
772    
773    vmint BuiltInIntArrayVariable::evalIntElement(vmuint i) {
774        return i >= array->size ? 0 : array->data[i];
775    }
776    
777    void BuiltInIntArrayVariable::assignIntElement(vmuint i, vmint value) {
778        if (i >= array->size) return;
779        array->data[i] = value;
780    }
781    
782    void BuiltInIntArrayVariable::dump(int level) {
783        printIndents(level);
784        printf("Built-In Int Array Variable '%s'\n", name.c_str());
785    }
786    
787    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 388  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 410  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 432  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 455  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 465  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;
939  }  }
940    
941    bool If::isPolyphonic() const {
942        if (condition->isPolyphonic() || ifStatements->isPolyphonic())
943            return true;
944        return elseStatements ? elseStatements->isPolyphonic() : false;
945    }
946    
947  void SelectCase::dump(int level) {  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 508  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 521  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;
995  }  }
996    
997    bool SelectCase::isPolyphonic() const {
998        if (select->isPolyphonic()) return true;
999        for (vmint i = 0; i < branches.size(); ++i)
1000            if (branches[i].statements->isPolyphonic())
1001                return true;
1002        return false;
1003    }
1004    
1005  // void Case::addBranch(IntExprRef condition, StatementsRef statements) {  // void Case::addBranch(IntExprRef condition, StatementsRef statements) {
1006  //     CaseBranchRef b = new CaseBranchRef;  //     CaseBranchRef b = new CaseBranchRef;
1007  //     b->from = condition;  //     b->from = condition;
# Line 550  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 569  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");
1062  }  }
1063    
1064  String ConcatString::evalStr() {  String ConcatString::evalStr() {
1065      return lhs->evalCastToStr() + rhs->evalCastToStr();      // temporaries required here to enforce the associative left (to right) order
1066        // ( required for GCC and Visual Studio, see:
1067        //   http://stackoverflow.com/questions/25842902/why-stdstring-concatenation-operator-works-like-right-associative-one
1068        //   Personally I am not convinced that this is "not a bug" of the
1069        //   compiler/STL implementation and the allegedly underlying "function call"
1070        //   nature causing this is IMO no profound reason that the C++ language's
1071        //   "+" operator's left associativity is ignored. -- Christian, 2016-07-14 )
1072        String l = lhs->evalCastToStr();
1073        String r = rhs->evalCastToStr();
1074        return l + r;
1075  }  }
1076    
1077  void ConcatString::dump(int level) {  void ConcatString::dump(int level) {
# Line 593  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 651  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;
1179      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);;      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);;
1180      return pLHS->evalInt() || pRHS->evalInt();      return (pRHS->evalInt()) ? 1 : 0;
1181  }  }
1182    
1183  void Or::dump(int level) {  void Or::dump(int level) {
# Line 668  void Or::dump(int level) { Line 1191  void Or::dump(int level) {
1191      printf(")\n");      printf(")\n");
1192  }  }
1193    
1194  int And::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();
1198    }
1199    
1200    void BitwiseOr::dump(int level) {
1201        printIndents(level);
1202        printf("BitwiseOr(\n");
1203        lhs->dump(level+1);
1204        printIndents(level);
1205        printf(",\n");
1206        rhs->dump(level+1);
1207        printIndents(level);
1208        printf(")\n");
1209    }
1210    
1211    vmint And::evalInt() {
1212        IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
1213        if (!pLHS->evalInt()) return 0;
1214        IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);
1215        return (pRHS->evalInt()) ? 1 : 0;
1216  }  }
1217    
1218  void And::dump(int level) {  void And::dump(int level) {
# Line 685  void And::dump(int level) { Line 1226  void And::dump(int level) {
1226      printf(")\n");      printf(")\n");
1227  }  }
1228    
1229    vmint BitwiseAnd::evalInt() {
1230        IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
1231        IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);
1232        return pLHS->evalInt() & pRHS->evalInt();
1233    }
1234    
1235    void BitwiseAnd::dump(int level) {
1236        printIndents(level);
1237        printf("BitwiseAnd(\n");
1238        lhs->dump(level+1);
1239        printIndents(level);
1240        printf(",\n");
1241        rhs->dump(level+1);
1242        printIndents(level);
1243        printf(")\n");
1244    }
1245    
1246  void Not::dump(int level) {  void Not::dump(int level) {
1247      printIndents(level);      printIndents(level);
1248      printf("Not(\n");      printf("Not(\n");
# Line 693  void Not::dump(int level) { Line 1251  void Not::dump(int level) {
1251      printf(")\n");      printf(")\n");
1252  }  }
1253    
1254    void BitwiseNot::dump(int level) {
1255        printIndents(level);
1256        printf("BitwiseNot(\n");
1257        expr->dump(level+1);
1258        printIndents(level);
1259        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) {
1278        if (!userFnTable.count(name)) {
1279            return StatementsRef();
1280        }
1281        return userFnTable.find(name)->second;
1282    }
1283    
1284  VariableRef ParserContext::variableByName(const String& name) {  VariableRef ParserContext::variableByName(const String& name) {
1285      if (!vartable.count(name)) {      if (!vartable.count(name)) {
1286          return VariableRef();          return VariableRef();
# Line 714  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  }  }
1312    
1313  void ParserContext::addErr(int line, const char* txt) {  ParserContext::~ParserContext() {
1314        destroyScanner();
1315        if (globalIntMemory) {
1316            delete globalIntMemory;
1317            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) {
1326      ParserIssue e;      ParserIssue e;
1327      e.type = PARSER_ERROR;      e.type = PARSER_ERROR;
1328      e.txt = txt;      e.txt = txt;
1329      e.line = line;      e.firstLine = firstLine;
1330      errors.push_back(e);      e.lastLine = lastLine;
1331      issues.push_back(e);      e.firstColumn = firstColumn;
1332        e.lastColumn = lastColumn;
1333        vErrors.push_back(e);
1334        vIssues.push_back(e);
1335  }  }
1336    
1337  void ParserContext::addWrn(int line, const char* txt) {  void ParserContext::addWrn(int firstLine, int lastLine, int firstColumn, int lastColumn, const char* txt) {
1338      ParserIssue w;      ParserIssue w;
1339      w.type = PARSER_WARNING;      w.type = PARSER_WARNING;
1340      w.txt = txt;      w.txt = txt;
1341      w.line = line;      w.firstLine = firstLine;
1342      warnings.push_back(w);      w.lastLine = lastLine;
1343      issues.push_back(w);      w.firstColumn = firstColumn;
1344        w.lastColumn = lastColumn;
1345        vWarnings.push_back(w);
1346        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) {
# Line 755  bool ParserContext::isPreprocessorCondit Line 1374  bool ParserContext::isPreprocessorCondit
1374      return userPreprocessorConditions.count(name);      return userPreprocessorConditions.count(name);
1375  }  }
1376    
1377    std::vector<ParserIssue> ParserContext::issues() const {
1378        return vIssues;
1379    }
1380    
1381    std::vector<ParserIssue> ParserContext::errors() const {
1382        return vErrors;
1383    }
1384    
1385    std::vector<ParserIssue> ParserContext::warnings() const {
1386        return vWarnings;
1387    }
1388    
1389    std::vector<CodeBlock> ParserContext::preprocessorComments() const {
1390        return vPreprocessorComments;
1391    }
1392    
1393    VMEventHandler* ParserContext::eventHandler(uint index) {
1394        if (!handlers) return NULL;
1395        return handlers->eventHandler(index);
1396    }
1397    
1398    VMEventHandler* ParserContext::eventHandlerByName(const String& name) {
1399        if (!handlers) return NULL;
1400        return handlers->eventHandlerByName(name);
1401    }
1402    
1403    void ParserContext::registerBuiltInConstIntVariables(const std::map<String,vmint>& vars) {
1404        for (std::map<String,vmint>::const_iterator it = vars.begin();
1405             it != vars.end(); ++it)
1406        {
1407            ConstIntVariableRef ref = new ConstIntVariable(it->second);
1408            vartable[it->first] = ref;
1409        }
1410    }
1411    
1412    void ParserContext::registerBuiltInIntVariables(const std::map<String,VMIntPtr*>& vars) {
1413        for (std::map<String,VMIntPtr*>::const_iterator it = vars.begin();
1414             it != vars.end(); ++it)
1415        {
1416            BuiltInIntVariableRef ref = new BuiltInIntVariable(it->first, it->second);
1417            vartable[it->first] = ref;
1418        }
1419    }
1420    
1421    void ParserContext::registerBuiltInIntArrayVariables(const std::map<String,VMInt8Array*>& vars) {
1422        for (std::map<String,VMInt8Array*>::const_iterator it = vars.begin();
1423             it != vars.end(); ++it)
1424        {
1425            BuiltInIntArrayVariableRef ref = new BuiltInIntArrayVariable(it->first, it->second);
1426            vartable[it->first] = ref;
1427        }
1428    }
1429    
1430    void ParserContext::registerBuiltInDynVariables(const std::map<String,VMDynVar*>& vars) {
1431        for (std::map<String,VMDynVar*>::const_iterator it = vars.begin();
1432             it != vars.end(); ++it)
1433        {
1434            DynamicVariableCallRef ref = new DynamicVariableCall(it->first, this, it->second);
1435            vartable[it->first] = ref;
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.2581  
changed lines
  Added in v.3573

  ViewVC Help
Powered by ViewVC