/[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 3572 by schoenebeck, Fri Aug 23 11:44:00 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 {  MetricPrefix_t Unit::unitPrefix(vmuint i) const {
64      if (i >= prefix.size()) return VM_NO_PREFIX;      if (i >= prefix.size()) return VM_NO_PREFIX;
65      return prefix[i];      return prefix[i];
# Line 65  void Unit::setUnit(const MetricPrefix_t* Line 80  void Unit::setUnit(const MetricPrefix_t*
80          prefix.add(prefixes[i]);          prefix.add(prefixes[i]);
81  }  }
82    
83  void Unit::copyUnitFrom(const IntExprRef& src) {  void Unit::copyUnitFrom(const UnitRef& src) {
84      unit = src->unitType();      unit = src->unitType();
85      prefix.clear();      prefix.clear();
86      for (int i = 0; true; ++i) {      for (int i = 0; true; ++i) {
# Line 84  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 95  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 112  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 129  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 141  void Mul::dump(int level) { Line 183  void Mul::dump(int level) {
183  }  }
184    
185  MetricPrefix_t Mul::unitPrefix(vmuint i) const {  MetricPrefix_t Mul::unitPrefix(vmuint i) const {
186      const IntExpr* pLHS = dynamic_cast<const IntExpr*>(&*lhs);      const ScalarNumberExpr* pLHS = dynamic_cast<const ScalarNumberExpr*>(&*lhs);
187      const IntExpr* pRHS = dynamic_cast<const IntExpr*>(&*rhs);      const ScalarNumberExpr* pRHS = dynamic_cast<const ScalarNumberExpr*>(&*rhs);
188      // currently the NKSP parser only allows a unit prefix on either side      // currently the NKSP parser only allows a unit prefix on either side
189      return (pLHS->unitPrefix(0)) ? pLHS->unitPrefix(i) : pRHS->unitPrefix(i);      return (pLHS->unitPrefix(0)) ? pLHS->unitPrefix(i) : pRHS->unitPrefix(i);
190  }  }
191    
192  StdUnit_t Mul::unitType() const {  StdUnit_t Mul::unitType() const {
193      const IntExpr* pLHS = dynamic_cast<const IntExpr*>(&*lhs);      const ScalarNumberExpr* pLHS = dynamic_cast<const ScalarNumberExpr*>(&*lhs);
194      const IntExpr* pRHS = dynamic_cast<const IntExpr*>(&*rhs);      const ScalarNumberExpr* pRHS = dynamic_cast<const ScalarNumberExpr*>(&*rhs);
195      // currently the NKSP parser only allows a unit type on either side      // currently the NKSP parser only allows a unit type on either side
196      return (pLHS->unitType()) ? pLHS->unitType() : pRHS->unitType();      return (pLHS->unitType()) ? pLHS->unitType() : pRHS->unitType();
197  }  }
# Line 164  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 176  void Div::dump(int level) { Line 228  void Div::dump(int level) {
228  }  }
229    
230  MetricPrefix_t Div::unitPrefix(vmuint i) const {  MetricPrefix_t Div::unitPrefix(vmuint i) const {
231      const IntExpr* pLHS = dynamic_cast<const IntExpr*>(&*lhs);      const ScalarNumberExpr* pLHS = dynamic_cast<const ScalarNumberExpr*>(&*lhs);
232      const IntExpr* pRHS = dynamic_cast<const IntExpr*>(&*rhs);      const ScalarNumberExpr* pRHS = dynamic_cast<const ScalarNumberExpr*>(&*rhs);
233      // currently the NKSP parser only allows either A) a unit prefix on left      // 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      // 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);      return (pLHS->unitPrefix(0) && pRHS->unitPrefix(0)) ? VM_NO_PREFIX : pLHS->unitPrefix(i);
236  }  }
237    
238  StdUnit_t Div::unitType() const {  StdUnit_t Div::unitType() const {
239      const IntExpr* pLHS = dynamic_cast<const IntExpr*>(&*lhs);      const ScalarNumberExpr* pLHS = dynamic_cast<const ScalarNumberExpr*>(&*lhs);
240      const IntExpr* pRHS = dynamic_cast<const IntExpr*>(&*rhs);      const ScalarNumberExpr* pRHS = dynamic_cast<const ScalarNumberExpr*>(&*rhs);
241      // the NKSP parser only allows either A) a unit type on left side and none      // 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      // on right side or B) an identical unit type on both sides
243      return (pLHS->unitType() && pRHS->unitType()) ? VM_NO_UNIT : pLHS->unitType();      return (pLHS->unitType() && pRHS->unitType()) ? VM_NO_UNIT : pLHS->unitType();
# Line 383  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 390  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 401  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  IntVariable::IntVariable(ParserContext* ctx)  ScalarNumberVariable::ScalarNumberVariable(ParserContext* ctx, vmint _memPos,
485      : Variable(ctx, ctx ? ctx->globalIntVarCount++ : 0, false),                                             bool _bConst, bool _bPolyphonic,
486                                               bool _bFinal)
487        : Variable(ctx, _memPos, _bConst),
488        Unit(),        Unit(),
489        polyphonic(false), finalVal(false)        polyphonic(_bPolyphonic), finalVal(_bFinal)
490    {
491    }
492    
493    IntVariable::IntVariable(ParserContext* ctx)
494        : 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 425  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        Unit(),            ctx,
509        polyphonic(polyphonic), finalVal(false)            !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 440  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 449  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 462  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 488  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 518  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 564  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 613  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 658  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 IntBinaryOp::unitPrefix(vmuint i) const {  MetricPrefix_t ScalarNumberBinaryOp::unitPrefix(vmuint i) const {
893      IntExprRef l = (IntExprRef) lhs;      ScalarNumberExprRef l = (ScalarNumberExprRef) lhs;
894      IntExprRef r = (IntExprRef) rhs;      ScalarNumberExprRef r = (ScalarNumberExprRef) rhs;
895      return (r->unitFactor() < l->unitFactor()) ? r->unitPrefix(i) : l->unitPrefix(i);      return (r->unitFactor() < l->unitFactor()) ? r->unitPrefix(i) : l->unitPrefix(i);
896  }  }
897    
898  StdUnit_t IntBinaryOp::unitType() const {  StdUnit_t ScalarNumberBinaryOp::unitType() const {
899      IntExprRef l = (IntExprRef) lhs;      ScalarNumberExprRef l = (ScalarNumberExprRef) lhs;
900      IntExprRef r = (IntExprRef) rhs;      ScalarNumberExprRef r = (ScalarNumberExprRef) rhs;
901      return (l->unitType()) ? l->unitType() : r->unitType();      return (l->unitType()) ? l->unitType() : r->unitType();
902  }  }
903    
904  bool IntBinaryOp::isFinal() const {  bool ScalarNumberBinaryOp::isFinal() const {
905      IntExprRef l = (IntExprRef) lhs;      ScalarNumberExprRef l = (ScalarNumberExprRef) lhs;
906      IntExprRef r = (IntExprRef) rhs;      ScalarNumberExprRef r = (ScalarNumberExprRef) rhs;
907      return l->isFinal() || r->isFinal();      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 849  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 993  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) {  void Final::dump(int level) {
1270      printIndents(level);      printIndents(level);
1271      printf("Final(\n");      printf("Final(\n");
# Line 1029  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 1039  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 1166  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.3572  
changed lines
  Added in v.3573

  ViewVC Help
Powered by ViewVC