/[svn]/linuxsampler/trunk/src/scriptvm/CoreVMFunctions.cpp
ViewVC logotype

Diff of /linuxsampler/trunk/src/scriptvm/CoreVMFunctions.cpp

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 3581 by schoenebeck, Fri Aug 30 11:40:25 2019 UTC revision 3596 by persson, Wed Sep 4 15:10:06 2019 UTC
# Line 117  VMFnResult* VMStringResultFunction::succ Line 117  VMFnResult* VMStringResultFunction::succ
117  }  }
118    
119  ///////////////////////////////////////////////////////////////////////////  ///////////////////////////////////////////////////////////////////////////
120  // class VMScalarNumberResultFunction  // class VMNumberResultFunction
121    
122  VMFnResult* VMScalarNumberResultFunction::errorResult(vmint i) {  VMFnResult* VMNumberResultFunction::errorResult(vmint i) {
123      intResult.flags = StmtFlags_t(STMT_ABORT_SIGNALLED | STMT_ERROR_OCCURRED);      intResult.flags = StmtFlags_t(STMT_ABORT_SIGNALLED | STMT_ERROR_OCCURRED);
124      intResult.value = i;      intResult.value = i;
125      intResult.unitPrefixFactor = VM_NO_FACTOR;      intResult.unitPrefixFactor = VM_NO_FACTOR;
126      return &intResult;      return &intResult;
127  }  }
128    
129  VMFnResult* VMScalarNumberResultFunction::errorResult(vmfloat f) {  VMFnResult* VMNumberResultFunction::errorResult(vmfloat f) {
130      realResult.flags = StmtFlags_t(STMT_ABORT_SIGNALLED | STMT_ERROR_OCCURRED);      realResult.flags = StmtFlags_t(STMT_ABORT_SIGNALLED | STMT_ERROR_OCCURRED);
131      realResult.value = f;      realResult.value = f;
132      realResult.unitPrefixFactor = VM_NO_FACTOR;      realResult.unitPrefixFactor = VM_NO_FACTOR;
133      return &realResult;      return &realResult;
134  }  }
135    
136  VMFnResult* VMScalarNumberResultFunction::successResult(vmint i) {  VMFnResult* VMNumberResultFunction::successResult(vmint i) {
137      intResult.flags = STMT_SUCCESS;      intResult.flags = STMT_SUCCESS;
138      intResult.value = i;      intResult.value = i;
139      intResult.unitPrefixFactor = VM_NO_FACTOR;      intResult.unitPrefixFactor = VM_NO_FACTOR;
140      return &intResult;      return &intResult;
141  }  }
142    
143  VMFnResult* VMScalarNumberResultFunction::successResult(vmfloat f) {  VMFnResult* VMNumberResultFunction::successResult(vmfloat f) {
144      realResult.flags = STMT_SUCCESS;      realResult.flags = STMT_SUCCESS;
145      realResult.value = f;      realResult.value = f;
146      realResult.unitPrefixFactor = VM_NO_FACTOR;      realResult.unitPrefixFactor = VM_NO_FACTOR;
147      return &realResult;      return &realResult;
148  }  }
149    
150  VMFnResult* VMScalarNumberResultFunction::errorIntResult(VMIntFnResDef res) {  VMFnResult* VMNumberResultFunction::errorIntResult(VMIntFnResDef res) {
151      intResult.flags = StmtFlags_t(STMT_ABORT_SIGNALLED | STMT_ERROR_OCCURRED);      intResult.flags = StmtFlags_t(STMT_ABORT_SIGNALLED | STMT_ERROR_OCCURRED);
152      intResult.value = res.value;      intResult.value = res.value;
153      intResult.unitPrefixFactor = res.unitFactor;      intResult.unitPrefixFactor = res.unitFactor;
154      return &intResult;      return &intResult;
155  }  }
156    
157  VMFnResult* VMScalarNumberResultFunction::errorRealResult(VMRealFnResDef res) {  VMFnResult* VMNumberResultFunction::errorRealResult(VMRealFnResDef res) {
158      realResult.flags = StmtFlags_t(STMT_ABORT_SIGNALLED | STMT_ERROR_OCCURRED);      realResult.flags = StmtFlags_t(STMT_ABORT_SIGNALLED | STMT_ERROR_OCCURRED);
159      realResult.value = res.value;      realResult.value = res.value;
160      realResult.unitPrefixFactor = res.unitFactor;      realResult.unitPrefixFactor = res.unitFactor;
161      return &realResult;      return &realResult;
162  }  }
163    
164  VMFnResult* VMScalarNumberResultFunction::successIntResult(VMIntFnResDef res) {  VMFnResult* VMNumberResultFunction::successIntResult(VMIntFnResDef res) {
165      intResult.flags = STMT_SUCCESS;      intResult.flags = STMT_SUCCESS;
166      intResult.value = res.value;      intResult.value = res.value;
167      intResult.unitPrefixFactor = res.unitFactor;      intResult.unitPrefixFactor = res.unitFactor;
168      return &intResult;      return &intResult;
169  }  }
170    
171  VMFnResult* VMScalarNumberResultFunction::successRealResult(VMRealFnResDef res) {  VMFnResult* VMNumberResultFunction::successRealResult(VMRealFnResDef res) {
172      realResult.flags = STMT_SUCCESS;      realResult.flags = STMT_SUCCESS;
173      realResult.value = res.value;      realResult.value = res.value;
174      realResult.unitPrefixFactor = res.unitFactor;      realResult.unitPrefixFactor = res.unitFactor;
# Line 277  VMFnResult* CoreVMFunction_exit::exec(VM Line 277  VMFnResult* CoreVMFunction_exit::exec(VM
277  ///////////////////////////////////////////////////////////////////////////  ///////////////////////////////////////////////////////////////////////////
278  // built-in script function:  wait()  // built-in script function:  wait()
279    
280    bool CoreVMFunction_wait::acceptsArgType(vmint iArg, ExprType_t type) const {
281        return type == INT_EXPR || type == REAL_EXPR;
282    }
283    
284  bool CoreVMFunction_wait::acceptsArgUnitType(vmint iArg, StdUnit_t type) const {  bool CoreVMFunction_wait::acceptsArgUnitType(vmint iArg, StdUnit_t type) const {
285      if (iArg == 0)      return type == VM_NO_UNIT || type == VM_SECOND;
         return type == VM_NO_UNIT || type == VM_SECOND;  
     else  
         return type == VM_NO_UNIT;  
286  }  }
287    
288  bool CoreVMFunction_wait::acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const {  bool CoreVMFunction_wait::acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const {
289      return iArg == 0 && type == VM_SECOND;      return type == VM_SECOND; // only allow metric prefix(es) if 'seconds' is used as unit type
290  }  }
291    
292  VMFnResult* CoreVMFunction_wait::exec(VMFnArgs* args) {  VMFnResult* CoreVMFunction_wait::exec(VMFnArgs* args) {
293      ExecContext* ctx = dynamic_cast<ExecContext*>(vm->currentVMExecContext());      ExecContext* ctx = dynamic_cast<ExecContext*>(vm->currentVMExecContext());
294      VMIntExpr* expr = dynamic_cast<VMIntExpr*>(args->arg(0));      VMNumberExpr* expr = args->arg(0)->asNumber();
295      StdUnit_t unit = expr->unitType();      StdUnit_t unit = expr->unitType();
296      vmint us = (unit) ? expr->evalInt(VM_MICRO) : expr->evalInt();      vmint us = (unit) ? expr->evalCastInt(VM_MICRO) : expr->evalCastInt();
297      if (us < 0) {      if (us < 0) {
298          wrnMsg("wait(): argument may not be negative! Aborting script!");          wrnMsg("wait(): argument may not be negative! Aborting script!");
299          this->result.flags = STMT_ABORT_SIGNALLED;          this->result.flags = STMT_ABORT_SIGNALLED;
# Line 314  ExprType_t CoreVMFunction_abs::returnTyp Line 315  ExprType_t CoreVMFunction_abs::returnTyp
315  }  }
316    
317  StdUnit_t CoreVMFunction_abs::returnUnitType(VMFnArgs* args) {  StdUnit_t CoreVMFunction_abs::returnUnitType(VMFnArgs* args) {
318      return args->arg(0)->asScalarNumberExpr()->unitType();      return args->arg(0)->asNumber()->unitType();
319  }  }
320    
321  bool CoreVMFunction_abs::returnsFinal(VMFnArgs* args) {  bool CoreVMFunction_abs::returnsFinal(VMFnArgs* args) {
322      return args->arg(0)->asScalarNumberExpr()->isFinal();      return args->arg(0)->asNumber()->isFinal();
323  }  }
324    
325  bool CoreVMFunction_abs::acceptsArgType(vmint iArg, ExprType_t type) const {  bool CoreVMFunction_abs::acceptsArgType(vmint iArg, ExprType_t type) const {
# Line 330  VMFnResult* CoreVMFunction_abs::exec(VMF Line 331  VMFnResult* CoreVMFunction_abs::exec(VMF
331      if (arg->exprType() == REAL_EXPR) {      if (arg->exprType() == REAL_EXPR) {
332          VMRealExpr* expr = arg->asReal();          VMRealExpr* expr = arg->asReal();
333          return successRealResult({          return successRealResult({
334              .value = ::fabs(expr->evalReal()),              .value = static_cast<vmfloat>(::fabs(expr->evalReal())),
335              .unitFactor = expr->unitFactor()              .unitFactor = expr->unitFactor()
336          });          });
337      } else {      } else {
338          VMIntExpr* expr = arg->asInt();          VMIntExpr* expr = arg->asInt();
339          return successIntResult({          return successIntResult({
340              .value = ::abs(expr->evalInt()),              .value = std::abs(expr->evalInt()),
341              .unitFactor = expr->unitFactor()              .unitFactor = expr->unitFactor()
342          });          });
343      }      }
# Line 353  ExprType_t CoreVMFunction_random::return Line 354  ExprType_t CoreVMFunction_random::return
354  StdUnit_t CoreVMFunction_random::returnUnitType(VMFnArgs* args) {  StdUnit_t CoreVMFunction_random::returnUnitType(VMFnArgs* args) {
355      // we ensure in checkArgs() below (which is called before this method here)      // we ensure in checkArgs() below (which is called before this method here)
356      // that both arguments must be of same unit type, so either one is fine here      // that both arguments must be of same unit type, so either one is fine here
357      return args->arg(0)->asScalarNumberExpr()->unitType();      return args->arg(0)->asNumber()->unitType();
358  }  }
359    
360  bool CoreVMFunction_random::returnsFinal(VMFnArgs* args) {  bool CoreVMFunction_random::returnsFinal(VMFnArgs* args) {
361      return args->arg(0)->asScalarNumberExpr()->isFinal() ||      return args->arg(0)->asNumber()->isFinal() ||
362             args->arg(1)->asScalarNumberExpr()->isFinal();             args->arg(1)->asNumber()->isFinal();
363  }  }
364    
365  bool CoreVMFunction_random::acceptsArgType(vmint iArg, ExprType_t type) const {  bool CoreVMFunction_random::acceptsArgType(vmint iArg, ExprType_t type) const {
# Line 373  void CoreVMFunction_random::checkArgs(VM Line 374  void CoreVMFunction_random::checkArgs(VM
374      Super::checkArgs(args, err, wrn);      Super::checkArgs(args, err, wrn);
375    
376      // own checks ...      // own checks ...
377      if (args->arg(0)->asScalarNumberExpr()->unitType() !=      if (args->arg(0)->asNumber()->unitType() !=
378          args->arg(1)->asScalarNumberExpr()->unitType())          args->arg(1)->asNumber()->unitType())
379      {      {
380          String a = unitTypeStr(args->arg(0)->asScalarNumberExpr()->unitType());          String a = unitTypeStr(args->arg(0)->asNumber()->unitType());
381          String b = unitTypeStr(args->arg(1)->asScalarNumberExpr()->unitType());          String b = unitTypeStr(args->arg(1)->asNumber()->unitType());
382          err("Argument 1 has unit type " + a + ", whereas argument 2 has unit type " + b + ".");          err("Argument 1 has unit type " + a + ", whereas argument 2 has unit type " + b + ".");
383          return;          return;
384      }      }
385      if (args->arg(0)->asScalarNumberExpr()->isFinal() !=      if (args->arg(0)->asNumber()->isFinal() !=
386          args->arg(1)->asScalarNumberExpr()->isFinal())          args->arg(1)->asNumber()->isFinal())
387      {      {
388          String a = args->arg(0)->asScalarNumberExpr()->isFinal() ? "'final'" : "not 'final'";          String a = args->arg(0)->asNumber()->isFinal() ? "'final'" : "not 'final'";
389          String b = args->arg(1)->asScalarNumberExpr()->isFinal() ? "'final'" : "not 'final'";          String b = args->arg(1)->asNumber()->isFinal() ? "'final'" : "not 'final'";
390          wrn("Argument 1 is " + a + ", whereas argument 2 is " + b + ", function result will be final.");          wrn("Argument 1 is " + a + ", whereas argument 2 is " + b + ", function result will be final.");
391      }      }
392  }  }
# Line 393  void CoreVMFunction_random::checkArgs(VM Line 394  void CoreVMFunction_random::checkArgs(VM
394  VMFnResult* CoreVMFunction_random::exec(VMFnArgs* args) {  VMFnResult* CoreVMFunction_random::exec(VMFnArgs* args) {
395      float f = float(::rand()) / float(RAND_MAX);      float f = float(::rand()) / float(RAND_MAX);
396    
397      VMScalarNumberExpr* arg0 = args->arg(0)->asScalarNumberExpr();      VMNumberExpr* arg0 = args->arg(0)->asNumber();
398      VMScalarNumberExpr* arg1 = args->arg(1)->asScalarNumberExpr();      VMNumberExpr* arg1 = args->arg(1)->asNumber();
399    
400      if (arg0->exprType() == INT_EXPR && arg1->exprType() == INT_EXPR) {      if (arg0->exprType() == INT_EXPR && arg1->exprType() == INT_EXPR) {
401          vmint iMin = args->arg(0)->asInt()->evalInt();          vmint iMin = args->arg(0)->asInt()->evalInt();
# Line 456  VMFnResult* CoreVMFunction_num_elements: Line 457  VMFnResult* CoreVMFunction_num_elements:
457  // built-in script function:  inc()  // built-in script function:  inc()
458    
459  StdUnit_t CoreVMFunction_inc::returnUnitType(VMFnArgs* args) {  StdUnit_t CoreVMFunction_inc::returnUnitType(VMFnArgs* args) {
460      return args->arg(0)->asScalarNumberExpr()->unitType();      return args->arg(0)->asNumber()->unitType();
461  }  }
462    
463  bool CoreVMFunction_inc::returnsFinal(VMFnArgs* args) {  bool CoreVMFunction_inc::returnsFinal(VMFnArgs* args) {
464      return args->arg(0)->asScalarNumberExpr()->isFinal();      return args->arg(0)->asNumber()->isFinal();
465  }  }
466    
467  void CoreVMFunction_inc::checkArgs(VMFnArgs* args,  void CoreVMFunction_inc::checkArgs(VMFnArgs* args,
# Line 471  void CoreVMFunction_inc::checkArgs(VMFnA Line 472  void CoreVMFunction_inc::checkArgs(VMFnA
472      Super::checkArgs(args, err, wrn);      Super::checkArgs(args, err, wrn);
473    
474      // own checks ...      // own checks ...
475      if (args->arg(0)->asScalarNumberExpr()->unitType()) {      if (args->arg(0)->asNumber()->unitType()) {
476          String unitType = unitTypeStr(args->arg(0)->asScalarNumberExpr()->unitType());          String unitType = unitTypeStr(args->arg(0)->asNumber()->unitType());
477          wrn("Argument has a unit type (" + unitType + "), only the number before the unit will be incremented by one.");          wrn("Argument has a unit type (" + unitType + "), only the number before the unit will be incremented by one.");
478      }      }
479  }  }
# Line 497  VMFnResult* CoreVMFunction_inc::exec(VMF Line 498  VMFnResult* CoreVMFunction_inc::exec(VMF
498  // built-in script function:  dec()  // built-in script function:  dec()
499    
500  StdUnit_t CoreVMFunction_dec::returnUnitType(VMFnArgs* args) {  StdUnit_t CoreVMFunction_dec::returnUnitType(VMFnArgs* args) {
501      return args->arg(0)->asScalarNumberExpr()->unitType();      return args->arg(0)->asNumber()->unitType();
502  }  }
503    
504  bool CoreVMFunction_dec::returnsFinal(VMFnArgs* args) {  bool CoreVMFunction_dec::returnsFinal(VMFnArgs* args) {
505      return args->arg(0)->asScalarNumberExpr()->isFinal();      return args->arg(0)->asNumber()->isFinal();
506  }  }
507    
508  void CoreVMFunction_dec::checkArgs(VMFnArgs* args,  void CoreVMFunction_dec::checkArgs(VMFnArgs* args,
# Line 512  void CoreVMFunction_dec::checkArgs(VMFnA Line 513  void CoreVMFunction_dec::checkArgs(VMFnA
513      Super::checkArgs(args, err, wrn);      Super::checkArgs(args, err, wrn);
514    
515      // own checks ...      // own checks ...
516      if (args->arg(0)->asScalarNumberExpr()->unitType()) {      if (args->arg(0)->asNumber()->unitType()) {
517          String unitType = unitTypeStr(args->arg(0)->asScalarNumberExpr()->unitType());          String unitType = unitTypeStr(args->arg(0)->asNumber()->unitType());
518          wrn("Argument has a unit type (" + unitType + "), only the number before the unit will be decremented by one.");          wrn("Argument has a unit type (" + unitType + "), only the number before the unit will be decremented by one.");
519      }      }
520  }  }
# Line 549  void CoreVMFunction_in_range::checkArgs( Line 550  void CoreVMFunction_in_range::checkArgs(
550      Super::checkArgs(args, err, wrn);      Super::checkArgs(args, err, wrn);
551    
552      // own checks ...      // own checks ...
553      if (args->arg(0)->asScalarNumberExpr()->unitType() !=      if (args->arg(0)->asNumber()->unitType() !=
554          args->arg(1)->asScalarNumberExpr()->unitType() ||          args->arg(1)->asNumber()->unitType() ||
555          args->arg(1)->asScalarNumberExpr()->unitType() !=          args->arg(1)->asNumber()->unitType() !=
556          args->arg(2)->asScalarNumberExpr()->unitType())          args->arg(2)->asNumber()->unitType())
557      {      {
558          String a = unitTypeStr(args->arg(0)->asScalarNumberExpr()->unitType());          String a = unitTypeStr(args->arg(0)->asNumber()->unitType());
559          String b = unitTypeStr(args->arg(1)->asScalarNumberExpr()->unitType());          String b = unitTypeStr(args->arg(1)->asNumber()->unitType());
560          String c = unitTypeStr(args->arg(2)->asScalarNumberExpr()->unitType());          String c = unitTypeStr(args->arg(2)->asNumber()->unitType());
561          err("Arguments must all have same unit, however argument 1 is " + a +          err("Arguments must all have same unit, however argument 1 is " + a +
562              ", argument 2 is " + b + ", argument 3 is " + c + ".");              ", argument 2 is " + b + ", argument 3 is " + c + ".");
563          return;          return;
# Line 581  inline void _swapByValue(T& a, T& b) { Line 582  inline void _swapByValue(T& a, T& b) {
582  }  }
583    
584  VMFnResult* CoreVMFunction_in_range::exec(VMFnArgs* args) {  VMFnResult* CoreVMFunction_in_range::exec(VMFnArgs* args) {
585      VMScalarNumberExpr* argNeedle = args->arg(0)->asScalarNumberExpr();      VMNumberExpr* argNeedle = args->arg(0)->asNumber();
586      VMScalarNumberExpr* argLo = args->arg(1)->asScalarNumberExpr();      VMNumberExpr* argLo = args->arg(1)->asNumber();
587      VMScalarNumberExpr* argHi = args->arg(2)->asScalarNumberExpr();      VMNumberExpr* argHi = args->arg(2)->asNumber();
588    
589      vmfloat needle = argNeedle->evalCastReal();      vmfloat needle = argNeedle->evalCastReal();
590      vmfloat lo = argLo->evalCastReal();      vmfloat lo = argLo->evalCastReal();
# Line 602  VMFnResult* CoreVMFunction_in_range::exe Line 603  VMFnResult* CoreVMFunction_in_range::exe
603  // built-in script function:  sh_left()  // built-in script function:  sh_left()
604    
605  bool CoreVMFunction_sh_left::returnsFinal(VMFnArgs* args) {  bool CoreVMFunction_sh_left::returnsFinal(VMFnArgs* args) {
606      return args->arg(0)->asScalarNumberExpr()->isFinal();      return args->arg(0)->asNumber()->isFinal();
607  }  }
608    
609  VMFnResult* CoreVMFunction_sh_left::exec(VMFnArgs* args) {  VMFnResult* CoreVMFunction_sh_left::exec(VMFnArgs* args) {
# Line 615  VMFnResult* CoreVMFunction_sh_left::exec Line 616  VMFnResult* CoreVMFunction_sh_left::exec
616  // built-in script function:  sh_right()  // built-in script function:  sh_right()
617    
618  bool CoreVMFunction_sh_right::returnsFinal(VMFnArgs* args) {  bool CoreVMFunction_sh_right::returnsFinal(VMFnArgs* args) {
619      return args->arg(0)->asScalarNumberExpr()->isFinal();      return args->arg(0)->asNumber()->isFinal();
620  }  }
621    
622  VMFnResult* CoreVMFunction_sh_right::exec(VMFnArgs* args) {  VMFnResult* CoreVMFunction_sh_right::exec(VMFnArgs* args) {
# Line 633  ExprType_t CoreVMFunction_min::returnTyp Line 634  ExprType_t CoreVMFunction_min::returnTyp
634  }  }
635    
636  StdUnit_t CoreVMFunction_min::returnUnitType(VMFnArgs* args) {  StdUnit_t CoreVMFunction_min::returnUnitType(VMFnArgs* args) {
637      return args->arg(0)->asScalarNumberExpr()->unitType();      return args->arg(0)->asNumber()->unitType();
638  }  }
639    
640  bool CoreVMFunction_min::returnsFinal(VMFnArgs* args) {  bool CoreVMFunction_min::returnsFinal(VMFnArgs* args) {
641      return args->arg(0)->asScalarNumberExpr()->isFinal() ||      return args->arg(0)->asNumber()->isFinal() ||
642             args->arg(1)->asScalarNumberExpr()->isFinal();             args->arg(1)->asNumber()->isFinal();
643  }  }
644    
645  bool CoreVMFunction_min::acceptsArgType(vmint iArg, ExprType_t type) const {  bool CoreVMFunction_min::acceptsArgType(vmint iArg, ExprType_t type) const {
# Line 653  void CoreVMFunction_min::checkArgs(VMFnA Line 654  void CoreVMFunction_min::checkArgs(VMFnA
654      Super::checkArgs(args, err, wrn);      Super::checkArgs(args, err, wrn);
655    
656      // own checks ...      // own checks ...
657      if (args->arg(0)->asScalarNumberExpr()->unitType() !=      if (args->arg(0)->asNumber()->unitType() !=
658          args->arg(1)->asScalarNumberExpr()->unitType())          args->arg(1)->asNumber()->unitType())
659      {      {
660          String a = unitTypeStr(args->arg(0)->asScalarNumberExpr()->unitType());          String a = unitTypeStr(args->arg(0)->asNumber()->unitType());
661          String b = unitTypeStr(args->arg(1)->asScalarNumberExpr()->unitType());          String b = unitTypeStr(args->arg(1)->asNumber()->unitType());
662          err("Argument 1 has unit type " + a + ", whereas argument 2 has unit type " + b + ".");          err("Argument 1 has unit type " + a + ", whereas argument 2 has unit type " + b + ".");
663          return;          return;
664      }      }
# Line 668  void CoreVMFunction_min::checkArgs(VMFnA Line 669  void CoreVMFunction_min::checkArgs(VMFnA
669          wrn("Argument 1 is " + a + ", whereas argument 2 is " + b + ", function result will be " + c + ".");          wrn("Argument 1 is " + a + ", whereas argument 2 is " + b + ", function result will be " + c + ".");
670          return;          return;
671      }      }
672      if (args->arg(0)->asScalarNumberExpr()->isFinal() !=      if (args->arg(0)->asNumber()->isFinal() !=
673          args->arg(1)->asScalarNumberExpr()->isFinal())          args->arg(1)->asNumber()->isFinal())
674      {      {
675          String a = args->arg(0)->asScalarNumberExpr()->isFinal() ? "'final'" : "not 'final'";          String a = args->arg(0)->asNumber()->isFinal() ? "'final'" : "not 'final'";
676          String b = args->arg(1)->asScalarNumberExpr()->isFinal() ? "'final'" : "not 'final'";          String b = args->arg(1)->asNumber()->isFinal() ? "'final'" : "not 'final'";
677          wrn("Argument 1 is " + a + ", whereas argument 2 is " + b + ", function result will be final.");          wrn("Argument 1 is " + a + ", whereas argument 2 is " + b + ", function result will be final.");
678      }      }
679  }  }
680    
681  VMFnResult* CoreVMFunction_min::exec(VMFnArgs* args) {  VMFnResult* CoreVMFunction_min::exec(VMFnArgs* args) {
682      VMScalarNumberExpr* lhs = args->arg(0)->asScalarNumberExpr();      VMNumberExpr* lhs = args->arg(0)->asNumber();
683      VMScalarNumberExpr* rhs = args->arg(1)->asScalarNumberExpr();      VMNumberExpr* rhs = args->arg(1)->asNumber();
684      if (lhs->exprType() == REAL_EXPR && rhs->exprType() == REAL_EXPR) {      if (lhs->exprType() == REAL_EXPR && rhs->exprType() == REAL_EXPR) {
685          vmfloat lm = lhs->asReal()->evalReal();          vmfloat lm = lhs->asReal()->evalReal();
686          vmfloat rm = rhs->asReal()->evalReal();          vmfloat rm = rhs->asReal()->evalReal();
# Line 728  ExprType_t CoreVMFunction_max::returnTyp Line 729  ExprType_t CoreVMFunction_max::returnTyp
729  }  }
730    
731  StdUnit_t CoreVMFunction_max::returnUnitType(VMFnArgs* args) {  StdUnit_t CoreVMFunction_max::returnUnitType(VMFnArgs* args) {
732      return args->arg(0)->asScalarNumberExpr()->unitType();      return args->arg(0)->asNumber()->unitType();
733  }  }
734    
735  bool CoreVMFunction_max::returnsFinal(VMFnArgs* args) {  bool CoreVMFunction_max::returnsFinal(VMFnArgs* args) {
736      return args->arg(0)->asScalarNumberExpr()->isFinal() ||      return args->arg(0)->asNumber()->isFinal() ||
737             args->arg(1)->asScalarNumberExpr()->isFinal();             args->arg(1)->asNumber()->isFinal();
738  }  }
739    
740  bool CoreVMFunction_max::acceptsArgType(vmint iArg, ExprType_t type) const {  bool CoreVMFunction_max::acceptsArgType(vmint iArg, ExprType_t type) const {
# Line 748  void CoreVMFunction_max::checkArgs(VMFnA Line 749  void CoreVMFunction_max::checkArgs(VMFnA
749      Super::checkArgs(args, err, wrn);      Super::checkArgs(args, err, wrn);
750    
751      // own checks ...      // own checks ...
752      if (args->arg(0)->asScalarNumberExpr()->unitType() !=      if (args->arg(0)->asNumber()->unitType() !=
753          args->arg(1)->asScalarNumberExpr()->unitType())          args->arg(1)->asNumber()->unitType())
754      {      {
755          String a = unitTypeStr(args->arg(0)->asScalarNumberExpr()->unitType());          String a = unitTypeStr(args->arg(0)->asNumber()->unitType());
756          String b = unitTypeStr(args->arg(1)->asScalarNumberExpr()->unitType());          String b = unitTypeStr(args->arg(1)->asNumber()->unitType());
757          err("Argument 1 has unit type " + a + ", whereas argument 2 has unit type " + b + ".");          err("Argument 1 has unit type " + a + ", whereas argument 2 has unit type " + b + ".");
758          return;          return;
759      }      }
# Line 763  void CoreVMFunction_max::checkArgs(VMFnA Line 764  void CoreVMFunction_max::checkArgs(VMFnA
764          wrn("Argument 1 is " + a + ", whereas argument 2 is " + b + ", function result will be " + c + ".");          wrn("Argument 1 is " + a + ", whereas argument 2 is " + b + ", function result will be " + c + ".");
765          return;          return;
766      }      }
767      if (args->arg(0)->asScalarNumberExpr()->isFinal() !=      if (args->arg(0)->asNumber()->isFinal() !=
768          args->arg(1)->asScalarNumberExpr()->isFinal())          args->arg(1)->asNumber()->isFinal())
769      {      {
770          String a = args->arg(0)->asScalarNumberExpr()->isFinal() ? "'final'" : "not 'final'";          String a = args->arg(0)->asNumber()->isFinal() ? "'final'" : "not 'final'";
771          String b = args->arg(1)->asScalarNumberExpr()->isFinal() ? "'final'" : "not 'final'";          String b = args->arg(1)->asNumber()->isFinal() ? "'final'" : "not 'final'";
772          wrn("Argument 1 is " + a + ", whereas argument 2 is " + b + ", function result will be final.");          wrn("Argument 1 is " + a + ", whereas argument 2 is " + b + ", function result will be final.");
773      }      }
774  }  }
775    
776  VMFnResult* CoreVMFunction_max::exec(VMFnArgs* args) {  VMFnResult* CoreVMFunction_max::exec(VMFnArgs* args) {
777      VMScalarNumberExpr* lhs = args->arg(0)->asScalarNumberExpr();      VMNumberExpr* lhs = args->arg(0)->asNumber();
778      VMScalarNumberExpr* rhs = args->arg(1)->asScalarNumberExpr();      VMNumberExpr* rhs = args->arg(1)->asNumber();
779      if (lhs->exprType() == REAL_EXPR && rhs->exprType() == REAL_EXPR) {      if (lhs->exprType() == REAL_EXPR && rhs->exprType() == REAL_EXPR) {
780          vmfloat lm = lhs->asReal()->evalReal();          vmfloat lm = lhs->asReal()->evalReal();
781          vmfloat rm = rhs->asReal()->evalReal();          vmfloat rm = rhs->asReal()->evalReal();
# Line 911  VMFnResult* CoreVMFunction_array_equal:: Line 912  VMFnResult* CoreVMFunction_array_equal::
912  ///////////////////////////////////////////////////////////////////////////  ///////////////////////////////////////////////////////////////////////////
913  // built-in script function:  search()  // built-in script function:  search()
914    
 ExprType_t CoreVMFunction_search::argType(vmint iArg) const {  
     return (iArg == 0) ? INT_ARR_EXPR : INT_EXPR;  
 }  
   
915  bool CoreVMFunction_search::acceptsArgType(vmint iArg, ExprType_t type) const {  bool CoreVMFunction_search::acceptsArgType(vmint iArg, ExprType_t type) const {
916      if (iArg == 0)      if (iArg == 0)
917          return isArray(type);          return isArray(type);
# Line 974  VMFnResult* CoreVMFunction_search::exec( Line 971  VMFnResult* CoreVMFunction_search::exec(
971  ///////////////////////////////////////////////////////////////////////////  ///////////////////////////////////////////////////////////////////////////
972  // built-in script function:  sort()  // built-in script function:  sort()
973    
 ExprType_t CoreVMFunction_sort::argType(vmint iArg) const {  
     return (iArg == 0) ? INT_ARR_EXPR : INT_EXPR;  
 }  
   
974  bool CoreVMFunction_sort::acceptsArgType(vmint iArg, ExprType_t type) const {  bool CoreVMFunction_sort::acceptsArgType(vmint iArg, ExprType_t type) const {
975      if (iArg == 0)      if (iArg == 0)
976          return isArray(type);          return isArray(type);
# Line 989  bool CoreVMFunction_sort::acceptsArgType Line 982  bool CoreVMFunction_sort::acceptsArgType
982  // use std sort algorithms on our arrays. It might look a bit more complicated  // use std sort algorithms on our arrays. It might look a bit more complicated
983  // than it ought to be, but there is one reason for the large amount of  // than it ought to be, but there is one reason for the large amount of
984  // 'adapter' code below: the STL std algorithms rely on 'lvalues' to do their  // 'adapter' code below: the STL std algorithms rely on 'lvalues' to do their
985  // e.g. sorting) jobs, that is they expect containers to have 'localizeable'  // (e.g. sorting) jobs, that is they expect containers to have 'localizeable'
986  // data which essentially means their data should reside somewhere in memory and  // data which essentially means their data should reside somewhere in memory and
987  // directly be accessible (readable and writable) there, which is not the case  // directly be accessible (readable and writable) there, which is not the case
988  // with our VM interfaces which actually always require virtual getter and  // with our VM interfaces which actually always require virtual getter and
# Line 1045  template<class T_array, // T_array is ei Line 1038  template<class T_array, // T_array is ei
1038           class T_accessor> // T_accessor is either IntArrayAccessor or RealArrayAccessor           class T_accessor> // T_accessor is either IntArrayAccessor or RealArrayAccessor
1039  class ArrElemRef : protected ArrElemPOD<T_array> {  class ArrElemRef : protected ArrElemPOD<T_array> {
1040  public:  public:
1041      typedef ScalarNmbrVal<T_value> ScalarNmbrVal;      typedef ::LinuxSampler::ScalarNmbrVal<T_value> ScalarNmbrVal; // GCC 8.x requires this very detailed form of typedef (that is ::LinuxSampler:: as prefix), IMO a GCC bug
1042    
1043      inline ArrElemRef(T_array* a, vmint index) {      inline ArrElemRef(T_array* a, vmint index) {
1044          this->m_array = a;          this->m_array = a;
# Line 1138  class ArrExprIter : public ArrElemPOD<T_ Line 1131  class ArrExprIter : public ArrElemPOD<T_
1131  public:  public:
1132      typedef std::random_access_iterator_tag iterator_category;      typedef std::random_access_iterator_tag iterator_category;
1133      typedef ssize_t difference_type;      typedef ssize_t difference_type;
1134      typedef ArrElemRef<T_array, T_value, T_accessor> ArrElemRef;      typedef ::LinuxSampler::ArrElemRef<T_array, T_value, T_accessor> ArrElemRef; // GCC 8.x requires this very detailed form of typedef (that is ::LinuxSampler:: as prefix), IMO a GCC bug
1135      typedef ArrElemRef reference; // type used by STL for access by reference      typedef ArrElemRef reference; // type used by STL for access by reference
1136      typedef void pointer; // type used by STL for -> operator result, we don't use that operator at all so just void it      typedef void pointer; // type used by STL for -> operator result, we don't use that operator at all so just void it
1137      typedef ScalarNmbrVal<T_value> value_type; // type used by STL for temporary values      typedef ScalarNmbrVal<T_value> value_type; // type used by STL for temporary values
# Line 1219  typedef ArrExprIter<VMIntArrayExpr,vmint Line 1212  typedef ArrExprIter<VMIntArrayExpr,vmint
1212  typedef ArrExprIter<VMRealArrayExpr,vmfloat,RealArrayAccessor> RealArrExprIter;  typedef ArrExprIter<VMRealArrayExpr,vmfloat,RealArrayAccessor> RealArrExprIter;
1213    
1214  // intentionally not a template function to avoid potential clashes with other (i.e. system's) swap() functions  // intentionally not a template function to avoid potential clashes with other (i.e. system's) swap() functions
1215  static inline void swap(IntArrExprIter::ArrElemRef a,  inline void swap(IntArrExprIter::ArrElemRef a,
1216                          IntArrExprIter::ArrElemRef b)                   IntArrExprIter::ArrElemRef b)
1217  {  {
1218      vmint valueA = a.getPrimValue();      vmint valueA = a.getPrimValue();
1219      vmint valueB = b.getPrimValue();      vmint valueB = b.getPrimValue();
# Line 1233  static inline void swap(IntArrExprIter:: Line 1226  static inline void swap(IntArrExprIter::
1226  }  }
1227    
1228  // intentionally not a template function to avoid potential clashes with other (i.e. system's) swap() functions  // intentionally not a template function to avoid potential clashes with other (i.e. system's) swap() functions
1229  static inline void swap(RealArrExprIter::ArrElemRef a,  inline void swap(RealArrExprIter::ArrElemRef a,
1230                          RealArrExprIter::ArrElemRef b)                   RealArrExprIter::ArrElemRef b)
1231  {  {
1232      vmfloat valueA = a.getPrimValue();      vmfloat valueA = a.getPrimValue();
1233      vmfloat valueB = b.getPrimValue();      vmfloat valueB = b.getPrimValue();
# Line 1289  VMFnResult* CoreVMFunction_sort::exec(VM Line 1282  VMFnResult* CoreVMFunction_sort::exec(VM
1282  // built-in script function:  real_to_int()  and  int()  // built-in script function:  real_to_int()  and  int()
1283    
1284  StdUnit_t CoreVMFunction_real_to_int::returnUnitType(VMFnArgs* args) {  StdUnit_t CoreVMFunction_real_to_int::returnUnitType(VMFnArgs* args) {
1285      return args->arg(0)->asScalarNumberExpr()->unitType();      return args->arg(0)->asNumber()->unitType();
1286  }  }
1287    
1288  bool CoreVMFunction_real_to_int::returnsFinal(VMFnArgs* args) {  bool CoreVMFunction_real_to_int::returnsFinal(VMFnArgs* args) {
1289      return args->arg(0)->asScalarNumberExpr()->isFinal();      return args->arg(0)->asNumber()->isFinal();
1290  }  }
1291    
1292  VMFnResult* CoreVMFunction_real_to_int::exec(VMFnArgs* args) {  VMFnResult* CoreVMFunction_real_to_int::exec(VMFnArgs* args) {
# Line 1309  VMFnResult* CoreVMFunction_real_to_int:: Line 1302  VMFnResult* CoreVMFunction_real_to_int::
1302  // built-in script function:  int_to_real()  and  real()  // built-in script function:  int_to_real()  and  real()
1303    
1304  StdUnit_t CoreVMFunction_int_to_real::returnUnitType(VMFnArgs* args) {  StdUnit_t CoreVMFunction_int_to_real::returnUnitType(VMFnArgs* args) {
1305      return args->arg(0)->asScalarNumberExpr()->unitType();      return args->arg(0)->asNumber()->unitType();
1306  }  }
1307    
1308  bool CoreVMFunction_int_to_real::returnsFinal(VMFnArgs* args) {  bool CoreVMFunction_int_to_real::returnsFinal(VMFnArgs* args) {
1309      return args->arg(0)->asScalarNumberExpr()->isFinal();      return args->arg(0)->asNumber()->isFinal();
1310  }  }
1311    
1312  VMFnResult* CoreVMFunction_int_to_real::exec(VMFnArgs* args) {  VMFnResult* CoreVMFunction_int_to_real::exec(VMFnArgs* args) {
# Line 1325  VMFnResult* CoreVMFunction_int_to_real:: Line 1318  VMFnResult* CoreVMFunction_int_to_real::
1318      });      });
1319  }  }
1320    
1321    ///////////////////////////////////////////////////////////////////////////
1322    // built-in script function:  round()
1323    
1324    StdUnit_t CoreVMFunction_round::returnUnitType(VMFnArgs* args) {
1325        return args->arg(0)->asNumber()->unitType();
1326    }
1327    
1328    bool CoreVMFunction_round::returnsFinal(VMFnArgs* args) {
1329        return args->arg(0)->asNumber()->isFinal();
1330    }
1331    
1332    VMFnResult* CoreVMFunction_round::exec(VMFnArgs* args) {
1333        VMRealExpr* realExpr = args->arg(0)->asReal();
1334        vmfloat f = realExpr->evalReal();
1335        if (sizeof(vmfloat) == sizeof(float))
1336            f = ::roundf(f);
1337        else
1338            f = ::round(f);
1339        return successResult({
1340            .value = f,
1341            .unitFactor = realExpr->unitFactor()
1342        });
1343    }
1344    
1345    ///////////////////////////////////////////////////////////////////////////
1346    // built-in script function:  ceil()
1347    
1348    StdUnit_t CoreVMFunction_ceil::returnUnitType(VMFnArgs* args) {
1349        return args->arg(0)->asNumber()->unitType();
1350    }
1351    
1352    bool CoreVMFunction_ceil::returnsFinal(VMFnArgs* args) {
1353        return args->arg(0)->asNumber()->isFinal();
1354    }
1355    
1356    VMFnResult* CoreVMFunction_ceil::exec(VMFnArgs* args) {
1357        VMRealExpr* realExpr = args->arg(0)->asReal();
1358        vmfloat f = realExpr->evalReal();
1359        if (sizeof(vmfloat) == sizeof(float))
1360            f = ::ceilf(f);
1361        else
1362            f = ::ceil(f);
1363        return successResult({
1364            .value = f,
1365            .unitFactor = realExpr->unitFactor()
1366        });
1367    }
1368    
1369    ///////////////////////////////////////////////////////////////////////////
1370    // built-in script function:  floor()
1371    
1372    StdUnit_t CoreVMFunction_floor::returnUnitType(VMFnArgs* args) {
1373        return args->arg(0)->asNumber()->unitType();
1374    }
1375    
1376    bool CoreVMFunction_floor::returnsFinal(VMFnArgs* args) {
1377        return args->arg(0)->asNumber()->isFinal();
1378    }
1379    
1380    VMFnResult* CoreVMFunction_floor::exec(VMFnArgs* args) {
1381        VMRealExpr* realExpr = args->arg(0)->asReal();
1382        vmfloat f = realExpr->evalReal();
1383        if (sizeof(vmfloat) == sizeof(float))
1384            f = ::floorf(f);
1385        else
1386            f = ::floor(f);
1387        return successResult({
1388            .value = f,
1389            .unitFactor = realExpr->unitFactor()
1390        });
1391    }
1392    
1393    ///////////////////////////////////////////////////////////////////////////
1394    // built-in script function:  sqrt()
1395    
1396    StdUnit_t CoreVMFunction_sqrt::returnUnitType(VMFnArgs* args) {
1397        return args->arg(0)->asNumber()->unitType();
1398    }
1399    
1400    bool CoreVMFunction_sqrt::returnsFinal(VMFnArgs* args) {
1401        return args->arg(0)->asNumber()->isFinal();
1402    }
1403    
1404    VMFnResult* CoreVMFunction_sqrt::exec(VMFnArgs* args) {
1405        VMRealExpr* realExpr = args->arg(0)->asReal();
1406        vmfloat f = realExpr->evalReal();
1407        if (sizeof(vmfloat) == sizeof(float))
1408            f = ::sqrtf(f);
1409        else
1410            f = ::sqrt(f);
1411        return successResult({
1412            .value = f,
1413            .unitFactor = realExpr->unitFactor()
1414        });
1415    }
1416    
1417    ///////////////////////////////////////////////////////////////////////////
1418    // built-in script function:  log()
1419    
1420    StdUnit_t CoreVMFunction_log::returnUnitType(VMFnArgs* args) {
1421        return args->arg(0)->asNumber()->unitType();
1422    }
1423    
1424    bool CoreVMFunction_log::returnsFinal(VMFnArgs* args) {
1425        return args->arg(0)->asNumber()->isFinal();
1426    }
1427    
1428    VMFnResult* CoreVMFunction_log::exec(VMFnArgs* args) {
1429        VMRealExpr* realExpr = args->arg(0)->asReal();
1430        vmfloat f = realExpr->evalReal();
1431        if (sizeof(vmfloat) == sizeof(float))
1432            f = ::logf(f);
1433        else
1434            f = ::log(f);
1435        return successResult({
1436            .value = f,
1437            .unitFactor = realExpr->unitFactor()
1438        });
1439    }
1440    
1441    ///////////////////////////////////////////////////////////////////////////
1442    // built-in script function:  log2()
1443    
1444    StdUnit_t CoreVMFunction_log2::returnUnitType(VMFnArgs* args) {
1445        return args->arg(0)->asNumber()->unitType();
1446    }
1447    
1448    bool CoreVMFunction_log2::returnsFinal(VMFnArgs* args) {
1449        return args->arg(0)->asNumber()->isFinal();
1450    }
1451    
1452    VMFnResult* CoreVMFunction_log2::exec(VMFnArgs* args) {
1453        VMRealExpr* realExpr = args->arg(0)->asReal();
1454        vmfloat f = realExpr->evalReal();
1455        if (sizeof(vmfloat) == sizeof(float))
1456            f = ::log2f(f);
1457        else
1458            f = ::log2(f);
1459        return successResult({
1460            .value = f,
1461            .unitFactor = realExpr->unitFactor()
1462        });
1463    }
1464    
1465    ///////////////////////////////////////////////////////////////////////////
1466    // built-in script function:  log10()
1467    
1468    StdUnit_t CoreVMFunction_log10::returnUnitType(VMFnArgs* args) {
1469        return args->arg(0)->asNumber()->unitType();
1470    }
1471    
1472    bool CoreVMFunction_log10::returnsFinal(VMFnArgs* args) {
1473        return args->arg(0)->asNumber()->isFinal();
1474    }
1475    
1476    VMFnResult* CoreVMFunction_log10::exec(VMFnArgs* args) {
1477        VMRealExpr* realExpr = args->arg(0)->asReal();
1478        vmfloat f = realExpr->evalReal();
1479        if (sizeof(vmfloat) == sizeof(float))
1480            f = ::log10f(f);
1481        else
1482            f = ::log10(f);
1483        return successResult({
1484            .value = f,
1485            .unitFactor = realExpr->unitFactor()
1486        });
1487    }
1488    
1489    ///////////////////////////////////////////////////////////////////////////
1490    // built-in script function:  exp()
1491    
1492    StdUnit_t CoreVMFunction_exp::returnUnitType(VMFnArgs* args) {
1493        return args->arg(0)->asNumber()->unitType();
1494    }
1495    
1496    bool CoreVMFunction_exp::returnsFinal(VMFnArgs* args) {
1497        return args->arg(0)->asNumber()->isFinal();
1498    }
1499    
1500    VMFnResult* CoreVMFunction_exp::exec(VMFnArgs* args) {
1501        VMRealExpr* realExpr = args->arg(0)->asReal();
1502        vmfloat f = realExpr->evalReal();
1503        if (sizeof(vmfloat) == sizeof(float))
1504            f = ::expf(f);
1505        else
1506            f = ::exp(f);
1507        return successResult({
1508            .value = f,
1509            .unitFactor = realExpr->unitFactor()
1510        });
1511    }
1512    
1513    ///////////////////////////////////////////////////////////////////////////
1514    // built-in script function:  pow()
1515    
1516    bool CoreVMFunction_pow::acceptsArgUnitType(vmint iArg, StdUnit_t type) const {
1517        if (iArg == 0)
1518            return true;
1519        else
1520            return type == VM_NO_UNIT;
1521    }
1522    
1523    bool CoreVMFunction_pow::acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const {
1524        return iArg == 0;
1525    }
1526    
1527    StdUnit_t CoreVMFunction_pow::returnUnitType(VMFnArgs* args) {
1528        // pow() only allows unit for its 1st argument
1529        return args->arg(0)->asNumber()->unitType();
1530    }
1531    
1532    bool CoreVMFunction_pow::returnsFinal(VMFnArgs* args) {
1533        // pow() only allows 'final'ness for its 1st argument
1534        return args->arg(0)->asNumber()->isFinal();
1535    }
1536    
1537    VMFnResult* CoreVMFunction_pow::exec(VMFnArgs* args) {
1538        VMRealExpr* arg0 = args->arg(0)->asReal();
1539        VMRealExpr* arg1 = args->arg(1)->asReal();
1540        vmfloat a = arg0->evalReal();
1541        vmfloat b = arg1->evalReal();
1542        if (sizeof(vmfloat) == sizeof(float)) {
1543            return successResult({
1544                .value = ::powf(a,b),
1545                .unitFactor = arg0->unitFactor()
1546            });
1547        } else {
1548            return successResult({
1549                .value = static_cast<vmfloat>(::pow(a,b)),
1550                .unitFactor = arg0->unitFactor()
1551            });
1552        }
1553    }
1554    
1555    ///////////////////////////////////////////////////////////////////////////
1556    // built-in script function:  sin()
1557    
1558    StdUnit_t CoreVMFunction_sin::returnUnitType(VMFnArgs* args) {
1559        return args->arg(0)->asNumber()->unitType();
1560    }
1561    
1562    bool CoreVMFunction_sin::returnsFinal(VMFnArgs* args) {
1563        return args->arg(0)->asNumber()->isFinal();
1564    }
1565    
1566    VMFnResult* CoreVMFunction_sin::exec(VMFnArgs* args) {
1567        VMRealExpr* realExpr = args->arg(0)->asReal();
1568        vmfloat f = realExpr->evalReal();
1569        if (sizeof(vmfloat) == sizeof(float))
1570            f = ::sinf(f);
1571        else
1572            f = ::sin(f);
1573        return successResult({
1574            .value = f,
1575            .unitFactor = realExpr->unitFactor()
1576        });
1577    }
1578    
1579    ///////////////////////////////////////////////////////////////////////////
1580    // built-in script function:  cos()
1581    
1582    StdUnit_t CoreVMFunction_cos::returnUnitType(VMFnArgs* args) {
1583        return args->arg(0)->asNumber()->unitType();
1584    }
1585    
1586    bool CoreVMFunction_cos::returnsFinal(VMFnArgs* args) {
1587        return args->arg(0)->asNumber()->isFinal();
1588    }
1589    
1590    VMFnResult* CoreVMFunction_cos::exec(VMFnArgs* args) {
1591        VMRealExpr* realExpr = args->arg(0)->asReal();
1592        vmfloat f = realExpr->evalReal();
1593        if (sizeof(vmfloat) == sizeof(float))
1594            f = ::cosf(f);
1595        else
1596            f = ::cos(f);
1597        return successResult({
1598            .value = f,
1599            .unitFactor = realExpr->unitFactor()
1600        });
1601    }
1602    
1603    ///////////////////////////////////////////////////////////////////////////
1604    // built-in script function:  tan()
1605    
1606    StdUnit_t CoreVMFunction_tan::returnUnitType(VMFnArgs* args) {
1607        return args->arg(0)->asNumber()->unitType();
1608    }
1609    
1610    bool CoreVMFunction_tan::returnsFinal(VMFnArgs* args) {
1611        return args->arg(0)->asNumber()->isFinal();
1612    }
1613    
1614    VMFnResult* CoreVMFunction_tan::exec(VMFnArgs* args) {
1615        VMRealExpr* realExpr = args->arg(0)->asReal();
1616        vmfloat f = realExpr->evalReal();
1617        if (sizeof(vmfloat) == sizeof(float))
1618            f = ::tanf(f);
1619        else
1620            f = ::tan(f);
1621        return successResult({
1622            .value = f,
1623            .unitFactor = realExpr->unitFactor()
1624        });
1625    }
1626    
1627    ///////////////////////////////////////////////////////////////////////////
1628    // built-in script function:  asin()
1629    
1630    StdUnit_t CoreVMFunction_asin::returnUnitType(VMFnArgs* args) {
1631        return args->arg(0)->asNumber()->unitType();
1632    }
1633    
1634    bool CoreVMFunction_asin::returnsFinal(VMFnArgs* args) {
1635        return args->arg(0)->asNumber()->isFinal();
1636    }
1637    
1638    VMFnResult* CoreVMFunction_asin::exec(VMFnArgs* args) {
1639        VMRealExpr* realExpr = args->arg(0)->asReal();
1640        vmfloat f = realExpr->evalReal();
1641        if (sizeof(vmfloat) == sizeof(float))
1642            f = ::asinf(f);
1643        else
1644            f = ::asin(f);
1645        return successResult({
1646            .value = f,
1647            .unitFactor = realExpr->unitFactor()
1648        });
1649    }
1650    
1651    ///////////////////////////////////////////////////////////////////////////
1652    // built-in script function:  acos()
1653    
1654    StdUnit_t CoreVMFunction_acos::returnUnitType(VMFnArgs* args) {
1655        return args->arg(0)->asNumber()->unitType();
1656    }
1657    
1658    bool CoreVMFunction_acos::returnsFinal(VMFnArgs* args) {
1659        return args->arg(0)->asNumber()->isFinal();
1660    }
1661    
1662    VMFnResult* CoreVMFunction_acos::exec(VMFnArgs* args) {
1663        VMRealExpr* realExpr = args->arg(0)->asReal();
1664        vmfloat f = realExpr->evalReal();
1665        if (sizeof(vmfloat) == sizeof(float))
1666            f = ::acosf(f);
1667        else
1668            f = ::acos(f);
1669        return successResult({
1670            .value = f,
1671            .unitFactor = realExpr->unitFactor()
1672        });
1673    }
1674    
1675    ///////////////////////////////////////////////////////////////////////////
1676    // built-in script function:  atan()
1677    
1678    StdUnit_t CoreVMFunction_atan::returnUnitType(VMFnArgs* args) {
1679        return args->arg(0)->asNumber()->unitType();
1680    }
1681    
1682    bool CoreVMFunction_atan::returnsFinal(VMFnArgs* args) {
1683        return args->arg(0)->asNumber()->isFinal();
1684    }
1685    
1686    VMFnResult* CoreVMFunction_atan::exec(VMFnArgs* args) {
1687        VMRealExpr* realExpr = args->arg(0)->asReal();
1688        vmfloat f = realExpr->evalReal();
1689        if (sizeof(vmfloat) == sizeof(float))
1690            f = ::atanf(f);
1691        else
1692            f = ::atan(f);
1693        return successResult({
1694            .value = f,
1695            .unitFactor = realExpr->unitFactor()
1696        });
1697    }
1698    
1699  } // namespace LinuxSampler  } // namespace LinuxSampler
Legend:
Removed from v.3581  
changed lines
  Added in v.3596
  ViewVC Help
Powered by ViewVC