/[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 3557 by schoenebeck, Sun Aug 18 00:06:04 2019 UTC revision 3573 by schoenebeck, Tue Aug 27 21:36:53 2019 UTC
# Line 34  String IntExpr::evalCastToStr() { Line 34  String IntExpr::evalCastToStr() {
34      return ToString(evalInt());      return ToString(evalInt());
35  }  }
36    
37    String RealExpr::evalCastToStr() {
38        return ToString(evalReal());
39    }
40    
41  String IntArrayExpr::evalCastToStr() {  String IntArrayExpr::evalCastToStr() {
42      String s = "{";      String s = "{";
43      for (vmint i = 0; i < arraySize(); ++i) {      for (vmint i = 0; i < arraySize(); ++i) {
# Line 45  String IntArrayExpr::evalCastToStr() { Line 49  String IntArrayExpr::evalCastToStr() {
49      return s;      return s;
50  }  }
51    
52    String RealArrayExpr::evalCastToStr() {
53        String s = "{";
54        for (vmint i = 0; i < arraySize(); ++i) {
55            vmfloat val = evalRealElement(i);
56            if (i) s += ",";
57            s += ToString(val);
58        }
59        s += "}";
60        return s;
61    }
62    
63    MetricPrefix_t Unit::unitPrefix(vmuint i) const {
64        if (i >= prefix.size()) return VM_NO_PREFIX;
65        return prefix[i];
66    }
67    
68    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() {  vmint IntLiteral::evalInt() {
94      return value;      return value;
95  }  }
# Line 54  void IntLiteral::dump(int level) { Line 99  void IntLiteral::dump(int level) {
99      printf("IntLiteral %lld\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) {
112      printIndents(level);      printIndents(level);
113      printf("StringLiteral: '%s'\n", value.c_str());      printf("StringLiteral: '%s'\n", value.c_str());
# Line 65  vmint Add::evalInt() { Line 119  vmint Add::evalInt() {
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 82  vmint Sub::evalInt() { Line 142  vmint Sub::evalInt() {
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 99  vmint Mul::evalInt() { Line 165  vmint Mul::evalInt() {
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 110  void Mul::dump(int level) { Line 182  void Mul::dump(int level) {
182      printf(")\n");      printf(")\n");
183  }  }
184    
185    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() {  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);
# Line 120  vmint Div::evalInt() { Line 206  vmint Div::evalInt() {
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 131  void Div::dump(int level) { Line 227  void Div::dump(int level) {
227      printf(")\n");      printf(")\n");
228  }  }
229    
230    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() {  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);;
# Line 323  vmint FunctionCall::evalInt() { Line 435  vmint FunctionCall::evalInt() {
435      return intExpr->evalInt();      return intExpr->evalInt();
436  }  }
437    
438    vmfloat FunctionCall::evalReal() {
439        VMFnResult* result = execVMFn();
440        if (!result) return 0;
441        VMRealExpr* realExpr = dynamic_cast<VMRealExpr*>(result->resultValue());
442        if (!realExpr) return 0;
443        return realExpr->evalReal();
444    }
445    
446  VMIntArrayExpr* FunctionCall::asIntArray() const {  VMIntArrayExpr* FunctionCall::asIntArray() const {
447      VMFnResult* result = const_cast<FunctionCall*>(this)->execVMFn();      VMFnResult* result = const_cast<FunctionCall*>(this)->execVMFn();
448      if (!result) return 0;      if (!result) return 0;
# Line 330  VMIntArrayExpr* FunctionCall::asIntArray Line 450  VMIntArrayExpr* FunctionCall::asIntArray
450      return intArrExpr;      return intArrExpr;
451  }  }
452    
453    VMRealArrayExpr* FunctionCall::asRealArray() const {
454        VMFnResult* result = const_cast<FunctionCall*>(this)->execVMFn();
455        if (!result) return 0;
456        VMRealArrayExpr* realArrExpr = dynamic_cast<VMRealArrayExpr*>(result->resultValue());
457        return realArrExpr;
458    }
459    
460  String FunctionCall::evalStr() {  String FunctionCall::evalStr() {
461      VMFnResult* result = execVMFn();      VMFnResult* result = execVMFn();
462      if (!result) return "";      if (!result) return "";
# Line 341  String FunctionCall::evalStr() { Line 468  String FunctionCall::evalStr() {
468  String FunctionCall::evalCastToStr() {  String FunctionCall::evalCastToStr() {
469      VMFnResult* result = execVMFn();      VMFnResult* result = execVMFn();
470      if (!result) return "";      if (!result) return "";
471      if (result->resultValue()->exprType() == STRING_EXPR) {      const ExprType_t resultType = result->resultValue()->exprType();
472        if (resultType == STRING_EXPR) {
473          VMStringExpr* strExpr = dynamic_cast<VMStringExpr*>(result->resultValue());          VMStringExpr* strExpr = dynamic_cast<VMStringExpr*>(result->resultValue());
474          return strExpr ? strExpr->evalStr() : "";          return strExpr ? strExpr->evalStr() : "";
475        } else if (resultType == REAL_EXPR) {
476            VMRealExpr* realExpr = dynamic_cast<VMRealExpr*>(result->resultValue());
477            return realExpr ? ToString(realExpr->evalReal()) : "";
478      } else {      } else {
479          VMIntExpr* intExpr = dynamic_cast<VMIntExpr*>(result->resultValue());          VMIntExpr* intExpr = dynamic_cast<VMIntExpr*>(result->resultValue());
480          return intExpr ? ToString(intExpr->evalInt()) : "";          return intExpr ? ToString(intExpr->evalInt()) : "";
481      }      }
482  }  }
483    
484    ScalarNumberVariable::ScalarNumberVariable(ParserContext* ctx, vmint _memPos,
485                                               bool _bConst, bool _bPolyphonic,
486                                               bool _bFinal)
487        : Variable(ctx, _memPos, _bConst),
488          Unit(),
489          polyphonic(_bPolyphonic), finalVal(_bFinal)
490    {
491    }
492    
493  IntVariable::IntVariable(ParserContext* ctx)  IntVariable::IntVariable(ParserContext* ctx)
494      : Variable(ctx, ctx ? ctx->globalIntVarCount++ : 0, false), polyphonic(false)      : ScalarNumberVariable(ctx, ctx ? ctx->globalIntVarCount++ : 0)
495  {  {
496      //printf("globalIntVar parserctx=0x%lx memPOS=%d\n", ctx, memPos);      //printf("globalIntVar parserctx=0x%lx memPOS=%d\n", ctx, memPos);
497      assert(ctx);      assert(ctx);
# Line 363  inline static vmint postfixInc(vmint& ob Line 503  inline static vmint postfixInc(vmint& ob
503      return i;      return i;
504  }  }
505    
506  IntVariable::IntVariable(ParserContext* ctx, bool polyphonic, bool bConst, vmint size)  IntVariable::IntVariable(ParserContext* ctx, bool bPolyphonic, bool bConst, vmint size)
507      : Variable(ctx, !ctx ? 0 : polyphonic ? postfixInc(ctx->polyphonicIntVarCount, size) : postfixInc(ctx->globalIntVarCount, size), bConst),      : ScalarNumberVariable(
508        polyphonic(polyphonic)            ctx,
509              !ctx ? 0 : bPolyphonic ? postfixInc(ctx->polyphonicIntVarCount, size) :
510                                       postfixInc(ctx->globalIntVarCount, size),
511              bConst, bPolyphonic
512          )
513  {  {
514      //printf("InvVar size=%d parserCtx=0x%lx\n", size, (uint64_t)ctx);      //printf("IntVar size=%d parserCtx=0x%lx\n", size, (uint64_t)ctx);
515      if (polyphonic) {      if (bPolyphonic) {
516          //printf("polyIntVar memPOS=%d\n", memPos);          //printf("polyIntVar memPOS=%d\n", memPos);
517          assert(ctx);          assert(ctx);
518      }      }
# Line 377  IntVariable::IntVariable(ParserContext* Line 521  IntVariable::IntVariable(ParserContext*
521  void IntVariable::assign(Expression* expr) {  void IntVariable::assign(Expression* expr) {
522      IntExpr* intExpr = dynamic_cast<IntExpr*>(expr);      IntExpr* intExpr = dynamic_cast<IntExpr*>(expr);
523      if (intExpr) {      if (intExpr) {
524          if (polyphonic)          if (isPolyphonic())
525              context->execContext->polyphonicIntMemory[memPos] = intExpr->evalInt();              context->execContext->polyphonicIntMemory[memPos] = intExpr->evalInt();
526          else          else
527              (*context->globalIntMemory)[memPos] = intExpr->evalInt();              (*context->globalIntMemory)[memPos] = intExpr->evalInt();
# Line 386  void IntVariable::assign(Expression* exp Line 530  void IntVariable::assign(Expression* exp
530    
531  vmint IntVariable::evalInt() {  vmint IntVariable::evalInt() {
532      //printf("IntVariable::eval pos=%d\n", memPos);      //printf("IntVariable::eval pos=%d\n", memPos);
533      if (polyphonic) {      if (isPolyphonic()) {
534          //printf("evalInt() poly memPos=%d execCtx=0x%lx\n", memPos, (uint64_t)context->execContext);          //printf("evalInt() poly memPos=%d execCtx=0x%lx\n", memPos, (uint64_t)context->execContext);
535          return context->execContext->polyphonicIntMemory[memPos];          return context->execContext->polyphonicIntMemory[memPos];
536      }      }
# Line 399  void IntVariable::dump(int level) { Line 543  void IntVariable::dump(int level) {
543      //printf("IntVariable memPos=%d\n", memPos);      //printf("IntVariable memPos=%d\n", memPos);
544  }  }
545    
546  //ConstIntVariable::ConstIntVariable(ParserContext* ctx, int value)  RealVariable::RealVariable(ParserContext* ctx)
547        : 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)  ConstIntVariable::ConstIntVariable(vmint value)
594      : IntVariable(NULL,false,true), value(value)      : IntVariable(NULL,false,true), value(value)
595  {  {
# Line 425  void ConstIntVariable::dump(int level) { Line 615  void ConstIntVariable::dump(int level) {
615      printf("ConstIntVariable val=%lld\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)  BuiltInIntVariable::BuiltInIntVariable(const String& name, VMIntPtr* ptr)
637      : IntVariable(NULL,false,false), name(name), ptr(ptr)      : IntVariable(NULL,false,false), name(name), ptr(ptr)
638  {  {
# Line 455  void PolyphonicIntVariable::dump(int lev Line 663  void PolyphonicIntVariable::dump(int lev
663      printf("PolyphonicIntVariable\n");      printf("PolyphonicIntVariable\n");
664  }  }
665    
666    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)  IntArrayVariable::IntArrayVariable(ParserContext* ctx, vmint size)
677      : Variable(ctx, 0, false)      : Variable(ctx, 0, false)
678  {  {
# Line 501  void IntArrayVariable::dump(int level) { Line 719  void IntArrayVariable::dump(int level) {
719      printf(")\n");      printf(")\n");
720  }  }
721    
722    RealArrayVariable::RealArrayVariable(ParserContext* ctx, vmint size)
723        : Variable(ctx, 0, false)
724    {
725        values.resize(size);
726        memset(&values[0], 0, size * sizeof(vmfloat));
727    }
728    
729    RealArrayVariable::RealArrayVariable(ParserContext* ctx, vmint size, ArgsRef values, bool _bConst)
730        : Variable(ctx, 0, _bConst)
731    {
732        this->values.resize(size);
733        for (vmint i = 0; i < values->argsCount(); ++i) {
734            VMRealExpr* expr = dynamic_cast<VMRealExpr*>(values->arg(i));
735            if (expr) this->values[i] = expr->evalReal();
736        }
737    }
738    
739    RealArrayVariable::RealArrayVariable(ParserContext* ctx, bool bConst)
740        : Variable(ctx, 0, bConst)
741    {
742    }
743    
744    vmfloat RealArrayVariable::evalRealElement(vmuint i) {
745        if (i >= values.size()) return 0;
746        return values[i];
747    }
748    
749    void RealArrayVariable::assignRealElement(vmuint i, vmfloat value) {
750        if (i >= values.size()) return;
751        values[i] = value;
752    }
753    
754    void RealArrayVariable::dump(int level) {
755        printIndents(level);
756        printf("RealArray(");
757        for (vmint i = 0; i < values.size(); ++i) {
758            if (i % 12 == 0) {
759                printf("\n");
760                printIndents(level+1);
761            }
762            printf("%f, ", values[i]);
763        }
764        printIndents(level);
765        printf(")\n");
766    }
767    
768  BuiltInIntArrayVariable::BuiltInIntArrayVariable(const String& name, VMInt8Array* array)  BuiltInIntArrayVariable::BuiltInIntArrayVariable(const String& name, VMInt8Array* array)
769      : IntArrayVariable(NULL, false), name(name), array(array)      : IntArrayVariable(NULL, false), name(name), array(array)
770  {  {
# Line 550  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 595  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 768  bool ConcatString::isConstExpr() const { Line 1089  bool ConcatString::isConstExpr() const {
1089      return lhs->isConstExpr() && rhs->isConstExpr();      return lhs->isConstExpr() && rhs->isConstExpr();
1090  }  }
1091    
1092  vmint 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 912  void BitwiseNot::dump(int level) { Line 1259  void BitwiseNot::dump(int level) {
1259      printf(")\n");      printf(")\n");
1260  }  }
1261    
1262    String Final::evalCastToStr() {
1263        if (exprType() == REAL_EXPR)
1264            return ToString(evalReal());
1265        else
1266            return ToString(evalInt());
1267    }
1268    
1269    void Final::dump(int level) {
1270        printIndents(level);
1271        printf("Final(\n");
1272        expr->dump(level+1);
1273        printIndents(level);
1274        printf(")\n");
1275    }
1276    
1277  StatementsRef ParserContext::userFunctionByName(const String& name) {  StatementsRef ParserContext::userFunctionByName(const String& name) {
1278      if (!userFnTable.count(name)) {      if (!userFnTable.count(name)) {
1279          return StatementsRef();          return StatementsRef();
# Line 940  IntVariableRef ParserContext::globalIntV Line 1302  IntVariableRef ParserContext::globalIntV
1302      return globalVar(name);      return globalVar(name);
1303  }  }
1304    
1305    RealVariableRef ParserContext::globalRealVar(const String& name) {
1306        return globalVar(name);
1307    }
1308    
1309  StringVariableRef ParserContext::globalStrVar(const String& name) {  StringVariableRef ParserContext::globalStrVar(const String& name) {
1310      return globalVar(name);      return globalVar(name);
1311  }  }
# Line 950  ParserContext::~ParserContext() { Line 1316  ParserContext::~ParserContext() {
1316          delete globalIntMemory;          delete globalIntMemory;
1317          globalIntMemory = NULL;          globalIntMemory = NULL;
1318      }      }
1319        if (globalRealMemory) {
1320            delete globalRealMemory;
1321            globalRealMemory = NULL;
1322        }
1323  }  }
1324    
1325  void ParserContext::addErr(int firstLine, int lastLine, int firstColumn, int lastColumn, const char* txt) {  void ParserContext::addErr(int firstLine, int lastLine, int firstColumn, int lastColumn, const char* txt) {
# Line 1077  void ExecContext::forkTo(VMExecContext* Line 1447  void ExecContext::forkTo(VMExecContext*
1447      ExecContext* child = dynamic_cast<ExecContext*>(ectx);      ExecContext* child = dynamic_cast<ExecContext*>(ectx);
1448    
1449      child->polyphonicIntMemory.copyFlatFrom(polyphonicIntMemory);      child->polyphonicIntMemory.copyFlatFrom(polyphonicIntMemory);
1450        child->polyphonicRealMemory.copyFlatFrom(polyphonicRealMemory);
1451      child->status = VM_EXEC_SUSPENDED;      child->status = VM_EXEC_SUSPENDED;
1452      child->flags = STMT_SUCCESS;      child->flags = STMT_SUCCESS;
1453      child->stack.copyFlatFrom(stack);      child->stack.copyFlatFrom(stack);
Legend:
Removed from v.3557  
changed lines
  Added in v.3573
  ViewVC Help
Powered by ViewVC