/[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 2972 by schoenebeck, Fri Jul 22 14:37:34 2016 UTC revision 3584 by schoenebeck, Fri Aug 30 13:33:32 2019 UTC
# Line 1  Line 1 
1  /*  /*
2   * Copyright (c) 2014-2015 Christian Schoenebeck   * Copyright (c) 2014-2019 Christian Schoenebeck
3   *   *
4   * http://www.linuxsampler.org   * http://www.linuxsampler.org
5   *   *
# Line 10  Line 10 
10  #include "CoreVMFunctions.h"  #include "CoreVMFunctions.h"
11    
12  #include <iostream>  #include <iostream>
13    #include <algorithm> // for std::sort()
14  #include <math.h>  #include <math.h>
15  #include <stdlib.h>  #include <stdlib.h>
16  #include "tree.h"  #include "tree.h"
17  #include "ScriptVM.h"  #include "ScriptVM.h"
18    #include "../common/RTMath.h"
19    
20  namespace LinuxSampler {  namespace LinuxSampler {
21    
22    inline bool _fEqualX(vmfloat a, vmfloat b) {
23        if (sizeof(vmfloat) == sizeof(float))
24            return RTMath::fEqual32(a, b);
25        else
26            return RTMath::fEqual64(a, b);
27    }
28    
29  ///////////////////////////////////////////////////////////////////////////  ///////////////////////////////////////////////////////////////////////////
30  // class VMEmptyResultFunction  // class VMEmptyResultFunction
31    
# Line 33  VMFnResult* VMEmptyResultFunction::succe Line 42  VMFnResult* VMEmptyResultFunction::succe
42  ///////////////////////////////////////////////////////////////////////////  ///////////////////////////////////////////////////////////////////////////
43  // class VMIntResultFunction  // class VMIntResultFunction
44    
45  VMFnResult* VMIntResultFunction::errorResult(int i) {  VMFnResult* VMIntResultFunction::errorResult(vmint i) {
46      result.flags = StmtFlags_t(STMT_ABORT_SIGNALLED | STMT_ERROR_OCCURRED);      result.flags = StmtFlags_t(STMT_ABORT_SIGNALLED | STMT_ERROR_OCCURRED);
47      result.value = i;      result.value = i;
48        result.unitPrefixFactor = VM_NO_FACTOR;
49      return &result;      return &result;
50  }  }
51    
52  VMFnResult* VMIntResultFunction::successResult(int i) {  VMFnResult* VMIntResultFunction::successResult(vmint i) {
53      result.flags = STMT_SUCCESS;      result.flags = STMT_SUCCESS;
54      result.value = i;      result.value = i;
55        result.unitPrefixFactor = VM_NO_FACTOR;
56        return &result;
57    }
58    
59    VMFnResult* VMIntResultFunction::errorResult(VMIntFnResDef res) {
60        result.flags = StmtFlags_t(STMT_ABORT_SIGNALLED | STMT_ERROR_OCCURRED);
61        result.value = res.value;
62        result.unitPrefixFactor = res.unitFactor;
63        return &result;
64    }
65    
66    VMFnResult* VMIntResultFunction::successResult(VMIntFnResDef res) {
67        result.flags = STMT_SUCCESS;
68        result.value = res.value;
69        result.unitPrefixFactor = res.unitFactor;
70        return &result;
71    }
72    
73    ///////////////////////////////////////////////////////////////////////////
74    // class VMRealResultFunction
75    
76    VMFnResult* VMRealResultFunction::errorResult(vmfloat f) {
77        result.flags = StmtFlags_t(STMT_ABORT_SIGNALLED | STMT_ERROR_OCCURRED);
78        result.value = f;
79        result.unitPrefixFactor = VM_NO_FACTOR;
80        return &result;
81    }
82    
83    VMFnResult* VMRealResultFunction::errorResult(VMRealFnResDef res) {
84        result.flags = StmtFlags_t(STMT_ABORT_SIGNALLED | STMT_ERROR_OCCURRED);
85        result.value = res.value;
86        result.unitPrefixFactor = res.unitFactor;
87        return &result;
88    }
89    
90    VMFnResult* VMRealResultFunction::successResult(vmfloat f) {
91        result.flags = STMT_SUCCESS;
92        result.value = f;
93        result.unitPrefixFactor = VM_NO_FACTOR;
94        return &result;
95    }
96    
97    VMFnResult* VMRealResultFunction::successResult(VMRealFnResDef res) {
98        result.flags = STMT_SUCCESS;
99        result.value = res.value;
100        result.unitPrefixFactor = res.unitFactor;
101      return &result;      return &result;
102  }  }
103    
# Line 61  VMFnResult* VMStringResultFunction::succ Line 117  VMFnResult* VMStringResultFunction::succ
117  }  }
118    
119  ///////////////////////////////////////////////////////////////////////////  ///////////////////////////////////////////////////////////////////////////
120    // class VMNumberResultFunction
121    
122    VMFnResult* VMNumberResultFunction::errorResult(vmint i) {
123        intResult.flags = StmtFlags_t(STMT_ABORT_SIGNALLED | STMT_ERROR_OCCURRED);
124        intResult.value = i;
125        intResult.unitPrefixFactor = VM_NO_FACTOR;
126        return &intResult;
127    }
128    
129    VMFnResult* VMNumberResultFunction::errorResult(vmfloat f) {
130        realResult.flags = StmtFlags_t(STMT_ABORT_SIGNALLED | STMT_ERROR_OCCURRED);
131        realResult.value = f;
132        realResult.unitPrefixFactor = VM_NO_FACTOR;
133        return &realResult;
134    }
135    
136    VMFnResult* VMNumberResultFunction::successResult(vmint i) {
137        intResult.flags = STMT_SUCCESS;
138        intResult.value = i;
139        intResult.unitPrefixFactor = VM_NO_FACTOR;
140        return &intResult;
141    }
142    
143    VMFnResult* VMNumberResultFunction::successResult(vmfloat f) {
144        realResult.flags = STMT_SUCCESS;
145        realResult.value = f;
146        realResult.unitPrefixFactor = VM_NO_FACTOR;
147        return &realResult;
148    }
149    
150    VMFnResult* VMNumberResultFunction::errorIntResult(VMIntFnResDef res) {
151        intResult.flags = StmtFlags_t(STMT_ABORT_SIGNALLED | STMT_ERROR_OCCURRED);
152        intResult.value = res.value;
153        intResult.unitPrefixFactor = res.unitFactor;
154        return &intResult;
155    }
156    
157    VMFnResult* VMNumberResultFunction::errorRealResult(VMRealFnResDef res) {
158        realResult.flags = StmtFlags_t(STMT_ABORT_SIGNALLED | STMT_ERROR_OCCURRED);
159        realResult.value = res.value;
160        realResult.unitPrefixFactor = res.unitFactor;
161        return &realResult;
162    }
163    
164    VMFnResult* VMNumberResultFunction::successIntResult(VMIntFnResDef res) {
165        intResult.flags = STMT_SUCCESS;
166        intResult.value = res.value;
167        intResult.unitPrefixFactor = res.unitFactor;
168        return &intResult;
169    }
170    
171    VMFnResult* VMNumberResultFunction::successRealResult(VMRealFnResDef res) {
172        realResult.flags = STMT_SUCCESS;
173        realResult.value = res.value;
174        realResult.unitPrefixFactor = res.unitFactor;
175        return &realResult;
176    }
177    
178    ///////////////////////////////////////////////////////////////////////////
179  // built-in script function:  message()  // built-in script function:  message()
180    
181  bool CoreVMFunction_message::acceptsArgType(int iArg, ExprType_t type) const {  bool CoreVMFunction_message::acceptsArgType(vmint iArg, ExprType_t type) const {
182      return type == INT_EXPR || type == STRING_EXPR;      return type == INT_EXPR || type == REAL_EXPR || type == STRING_EXPR;
183  }  }
184    
185  VMFnResult* CoreVMFunction_message::exec(VMFnArgs* args) {  VMFnResult* CoreVMFunction_message::exec(VMFnArgs* args) {
186      if (!args->argsCount()) return errorResult();      if (!args->argsCount()) return errorResult();
187    
188        uint64_t usecs = RTMath::unsafeMicroSeconds(RTMath::real_clock);
189    
190      VMStringExpr* strExpr = dynamic_cast<VMStringExpr*>(args->arg(0));      VMStringExpr* strExpr = dynamic_cast<VMStringExpr*>(args->arg(0));
191      if (strExpr) {      if (strExpr) {
192          std::cout << "[ScriptVM] " << strExpr->evalStr() << "\n";          printf("[ScriptVM %.3f] %s\n", usecs/1000000.f, strExpr->evalStr().c_str());
193            return successResult();
194        }
195    
196        VMRealExpr* realExpr = dynamic_cast<VMRealExpr*>(args->arg(0));
197        if (realExpr) {
198            printf("[ScriptVM %.3f] %f\n", usecs/1000000.f, realExpr->evalReal());
199          return successResult();          return successResult();
200      }      }
201    
202      VMIntExpr* intExpr = dynamic_cast<VMIntExpr*>(args->arg(0));      VMIntExpr* intExpr = dynamic_cast<VMIntExpr*>(args->arg(0));
203      if (intExpr) {      if (intExpr) {
204          std::cout << "[ScriptVM] " << intExpr->evalInt() << "\n";          printf("[ScriptVM %.3f] %lld\n", usecs/1000000.f, (int64_t)intExpr->evalInt());
205          return successResult();          return successResult();
206      }      }
207    
# Line 88  VMFnResult* CoreVMFunction_message::exec Line 211  VMFnResult* CoreVMFunction_message::exec
211  ///////////////////////////////////////////////////////////////////////////  ///////////////////////////////////////////////////////////////////////////
212  // built-in script function:  exit()  // built-in script function:  exit()
213    
214    vmint CoreVMFunction_exit::maxAllowedArgs() const {
215        return (vm->isExitResultEnabled()) ? 1 : 0;
216    }
217    
218    bool CoreVMFunction_exit::acceptsArgType(vmint iArg, ExprType_t type) const {
219        if (!vm->isExitResultEnabled()) return false;
220        return type == INT_EXPR || type == REAL_EXPR || type == STRING_EXPR;
221    }
222    
223    bool CoreVMFunction_exit::acceptsArgUnitType(vmint iArg, StdUnit_t type) const {
224        if (!vm->isExitResultEnabled()) return false;
225        return true;
226    }
227    
228    bool CoreVMFunction_exit::acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const {
229        if (!vm->isExitResultEnabled()) return false;
230        return true;
231    }
232    bool CoreVMFunction_exit::acceptsArgFinal(vmint iArg) const {
233        if (!vm->isExitResultEnabled()) return false;
234        return true;
235    }
236    
237  VMFnResult* CoreVMFunction_exit::exec(VMFnArgs* args) {  VMFnResult* CoreVMFunction_exit::exec(VMFnArgs* args) {
238      this->result.flags = STMT_ABORT_SIGNALLED;      this->result.flags = STMT_ABORT_SIGNALLED;
239        if (vm->isExitResultEnabled() && args->argsCount()) {
240            ExecContext* ctx = dynamic_cast<ExecContext*>(vm->currentVMExecContext());
241            switch (args->arg(0)->exprType()) {
242                case INT_EXPR: {
243                    VMIntExpr* expr = args->arg(0)->asInt();
244                    ctx->exitRes.intLiteral = IntLiteral({
245                        .value = expr->evalInt(),
246                        .unitFactor = expr->unitFactor(),
247                        .unitType = expr->unitType(),
248                        .isFinal = expr->isFinal()
249                    });
250                    ctx->exitRes.value = &ctx->exitRes.intLiteral;
251                    break;
252                }
253                case REAL_EXPR: {
254                    VMRealExpr* expr = args->arg(0)->asReal();
255                    ctx->exitRes.realLiteral = RealLiteral({
256                        .value = expr->evalReal(),
257                        .unitFactor = expr->unitFactor(),
258                        .unitType = expr->unitType(),
259                        .isFinal = expr->isFinal()
260                    });
261                    ctx->exitRes.value = &ctx->exitRes.realLiteral;
262                    break;
263                }
264                case STRING_EXPR:
265                    ctx->exitRes.stringLiteral = StringLiteral(
266                        args->arg(0)->asString()->evalStr()
267                    );
268                    ctx->exitRes.value = &ctx->exitRes.stringLiteral;
269                    break;
270                default:
271                    ; // noop - just to shut up the compiler
272            }
273        }
274      return &result;      return &result;
275  }  }
276    
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 {
285        return type == VM_NO_UNIT || type == VM_SECOND;
286    }
287    
288    bool CoreVMFunction_wait::acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const {
289        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      int us = expr->evalInt();      StdUnit_t unit = expr->unitType();
296        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 116  VMFnResult* CoreVMFunction_wait::exec(VM Line 310  VMFnResult* CoreVMFunction_wait::exec(VM
310  ///////////////////////////////////////////////////////////////////////////  ///////////////////////////////////////////////////////////////////////////
311  // built-in script function:  abs()  // built-in script function:  abs()
312    
313  bool CoreVMFunction_abs::acceptsArgType(int iArg, ExprType_t type) const {  ExprType_t CoreVMFunction_abs::returnType(VMFnArgs* args) {
314      return type == INT_EXPR;      return args->arg(0)->exprType();
315    }
316    
317    StdUnit_t CoreVMFunction_abs::returnUnitType(VMFnArgs* args) {
318        return args->arg(0)->asNumber()->unitType();
319    }
320    
321    bool CoreVMFunction_abs::returnsFinal(VMFnArgs* args) {
322        return args->arg(0)->asNumber()->isFinal();
323    }
324    
325    bool CoreVMFunction_abs::acceptsArgType(vmint iArg, ExprType_t type) const {
326        return type == INT_EXPR || type == REAL_EXPR;
327  }  }
328    
329  VMFnResult* CoreVMFunction_abs::exec(VMFnArgs* args) {  VMFnResult* CoreVMFunction_abs::exec(VMFnArgs* args) {
330      return successResult( ::abs(args->arg(0)->asInt()->evalInt()) );      VMExpr* arg = args->arg(0);
331        if (arg->exprType() == REAL_EXPR) {
332            VMRealExpr* expr = arg->asReal();
333            return successRealResult({
334                .value = ::fabs(expr->evalReal()),
335                .unitFactor = expr->unitFactor()
336            });
337        } else {
338            VMIntExpr* expr = arg->asInt();
339            return successIntResult({
340                .value = ::abs(expr->evalInt()),
341                .unitFactor = expr->unitFactor()
342            });
343        }
344  }  }
345    
346  ///////////////////////////////////////////////////////////////////////////  ///////////////////////////////////////////////////////////////////////////
347  // built-in script function:  random()  // built-in script function:  random()
348    
349  bool CoreVMFunction_random::acceptsArgType(int iArg, ExprType_t type) const {  ExprType_t CoreVMFunction_random::returnType(VMFnArgs* args) {
350      return type == INT_EXPR;      return (args->arg(0)->exprType() == INT_EXPR &&
351                args->arg(1)->exprType() == INT_EXPR) ? INT_EXPR : REAL_EXPR;
352    }
353    
354    StdUnit_t CoreVMFunction_random::returnUnitType(VMFnArgs* args) {
355        // 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
357        return args->arg(0)->asNumber()->unitType();
358    }
359    
360    bool CoreVMFunction_random::returnsFinal(VMFnArgs* args) {
361        return args->arg(0)->asNumber()->isFinal() ||
362               args->arg(1)->asNumber()->isFinal();
363    }
364    
365    bool CoreVMFunction_random::acceptsArgType(vmint iArg, ExprType_t type) const {
366        return type == INT_EXPR || type == REAL_EXPR;
367    }
368    
369    void CoreVMFunction_random::checkArgs(VMFnArgs* args,
370                                          std::function<void(String)> err,
371                                          std::function<void(String)> wrn)
372    {
373        // super class checks
374        Super::checkArgs(args, err, wrn);
375    
376        // own checks ...
377        if (args->arg(0)->asNumber()->unitType() !=
378            args->arg(1)->asNumber()->unitType())
379        {
380            String a = unitTypeStr(args->arg(0)->asNumber()->unitType());
381            String b = unitTypeStr(args->arg(1)->asNumber()->unitType());
382            err("Argument 1 has unit type " + a + ", whereas argument 2 has unit type " + b + ".");
383            return;
384        }
385        if (args->arg(0)->asNumber()->isFinal() !=
386            args->arg(1)->asNumber()->isFinal())
387        {
388            String a = args->arg(0)->asNumber()->isFinal() ? "'final'" : "not 'final'";
389            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.");
391        }
392  }  }
393    
394  VMFnResult* CoreVMFunction_random::exec(VMFnArgs* args) {  VMFnResult* CoreVMFunction_random::exec(VMFnArgs* args) {
     int iMin = args->arg(0)->asInt()->evalInt();  
     int iMax = args->arg(1)->asInt()->evalInt();  
395      float f = float(::rand()) / float(RAND_MAX);      float f = float(::rand()) / float(RAND_MAX);
396      return successResult(  
397          iMin + roundf( f * float(iMax - iMin) )      VMNumberExpr* arg0 = args->arg(0)->asNumber();
398      );      VMNumberExpr* arg1 = args->arg(1)->asNumber();
399    
400        if (arg0->exprType() == INT_EXPR && arg1->exprType() == INT_EXPR) {
401            vmint iMin = args->arg(0)->asInt()->evalInt();
402            vmint iMax = args->arg(1)->asInt()->evalInt();
403            if (arg0->unitFactor() == arg1->unitFactor()) {
404                return successIntResult({
405                    .value = vmint( iMin + roundf( f * float(iMax - iMin) ) ),
406                    .unitFactor = arg0->unitFactor()
407                });
408            } else if (arg0->unitFactor() < arg1->unitFactor()) {
409                iMax = Unit::convIntToUnitFactor(iMax, arg1, arg0);
410                return successIntResult({
411                    .value = vmint( iMin + roundf( f * float(iMax - iMin) ) ),
412                    .unitFactor = arg0->unitFactor()
413                });
414            } else { // arg0->unitFactor() > arg1->unitFactor() ...
415                iMin = Unit::convIntToUnitFactor(iMin, arg0, arg1);
416                return successIntResult({
417                    .value = vmint( iMin + roundf( f * float(iMax - iMin) ) ),
418                    .unitFactor = arg1->unitFactor()
419                });
420            }
421        } else {
422            vmfloat fMin = arg0->evalCastReal();
423            vmfloat fMax = arg1->evalCastReal();
424            if (arg0->unitFactor() == arg1->unitFactor()) {
425                return successRealResult({
426                    .value = fMin + f * (fMax - fMin),
427                    .unitFactor = arg0->unitFactor()
428                });
429            } else if (arg0->unitFactor() < arg1->unitFactor()) {
430                fMax = Unit::convRealToUnitFactor(fMax, arg1, arg0);
431                return successRealResult({
432                    .value = fMin + f * (fMax - fMin),
433                    .unitFactor = arg0->unitFactor()
434                });
435            } else { // arg0->unitFactor() > arg1->unitFactor() ...
436                fMin = Unit::convRealToUnitFactor(fMin, arg0, arg1);
437                return successRealResult({
438                    .value = fMin + f * (fMax - fMin),
439                    .unitFactor = arg1->unitFactor()
440                });
441            }
442        }
443  }  }
444    
445  ///////////////////////////////////////////////////////////////////////////  ///////////////////////////////////////////////////////////////////////////
446  // built-in script function:  num_elements()  // built-in script function:  num_elements()
447    
448  bool CoreVMFunction_num_elements::acceptsArgType(int iArg, ExprType_t type) const {  bool CoreVMFunction_num_elements::acceptsArgType(vmint iArg, ExprType_t type) const {
449      return type == INT_ARR_EXPR;      return isArray(type);
450  }  }
451    
452  VMFnResult* CoreVMFunction_num_elements::exec(VMFnArgs* args) {  VMFnResult* CoreVMFunction_num_elements::exec(VMFnArgs* args) {
453      return successResult( args->arg(0)->asIntArray()->arraySize() );      return successResult( args->arg(0)->asArray()->arraySize() );
454  }  }
455    
456  ///////////////////////////////////////////////////////////////////////////  ///////////////////////////////////////////////////////////////////////////
457  // built-in script function:  inc()  // built-in script function:  inc()
458    
459    StdUnit_t CoreVMFunction_inc::returnUnitType(VMFnArgs* args) {
460        return args->arg(0)->asNumber()->unitType();
461    }
462    
463    bool CoreVMFunction_inc::returnsFinal(VMFnArgs* args) {
464        return args->arg(0)->asNumber()->isFinal();
465    }
466    
467    void CoreVMFunction_inc::checkArgs(VMFnArgs* args,
468                                       std::function<void(String)> err,
469                                       std::function<void(String)> wrn)
470    {
471        // super class checks
472        Super::checkArgs(args, err, wrn);
473    
474        // own checks ...
475        if (args->arg(0)->asNumber()->unitType()) {
476            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.");
478        }
479    }
480    
481  VMFnResult* CoreVMFunction_inc::exec(VMFnArgs* args) {  VMFnResult* CoreVMFunction_inc::exec(VMFnArgs* args) {
482      VMExpr* arg = args->arg(0);      VMExpr* arg = args->arg(0);
483      VMIntExpr* in = dynamic_cast<VMIntExpr*>(arg);      VMIntExpr* in = dynamic_cast<VMIntExpr*>(arg);
484      VMVariable* out = dynamic_cast<VMVariable*>(arg);      VMVariable* out = dynamic_cast<VMVariable*>(arg);
485      if (!in || !out) successResult(0);      vmint i = in->evalInt() + 1;
486      int i = in->evalInt() + 1;      IntLiteral tmp({
487      IntLiteral tmp(i);          .value = i,
488            .unitFactor = in->unitFactor()
489        });
490      out->assignExpr(&tmp);      out->assignExpr(&tmp);
491      return successResult(i);      return successResult({
492            .value = i,
493            .unitFactor = in->unitFactor()
494        });
495  }  }
496    
497  ///////////////////////////////////////////////////////////////////////////  ///////////////////////////////////////////////////////////////////////////
498  // built-in script function:  dec()  // built-in script function:  dec()
499    
500    StdUnit_t CoreVMFunction_dec::returnUnitType(VMFnArgs* args) {
501        return args->arg(0)->asNumber()->unitType();
502    }
503    
504    bool CoreVMFunction_dec::returnsFinal(VMFnArgs* args) {
505        return args->arg(0)->asNumber()->isFinal();
506    }
507    
508    void CoreVMFunction_dec::checkArgs(VMFnArgs* args,
509                                       std::function<void(String)> err,
510                                       std::function<void(String)> wrn)
511    {
512        // super class checks
513        Super::checkArgs(args, err, wrn);
514    
515        // own checks ...
516        if (args->arg(0)->asNumber()->unitType()) {
517            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.");
519        }
520    }
521    
522  VMFnResult* CoreVMFunction_dec::exec(VMFnArgs* args) {  VMFnResult* CoreVMFunction_dec::exec(VMFnArgs* args) {
523      VMExpr* arg = args->arg(0);      VMExpr* arg = args->arg(0);
524      VMIntExpr* in = dynamic_cast<VMIntExpr*>(arg);      VMIntExpr* in = dynamic_cast<VMIntExpr*>(arg);
525      VMVariable* out = dynamic_cast<VMVariable*>(arg);      VMVariable* out = dynamic_cast<VMVariable*>(arg);
526      if (!in || !out) successResult(0);      vmint i = in->evalInt() - 1;
527      int i = in->evalInt() - 1;      IntLiteral tmp({
528      IntLiteral tmp(i);          .value = i,
529            .unitFactor = in->unitFactor()
530        });
531      out->assignExpr(&tmp);      out->assignExpr(&tmp);
532      return successResult(i);      return successResult({
533            .value = i,
534            .unitFactor = in->unitFactor()
535        });
536    }
537    
538    ///////////////////////////////////////////////////////////////////////////
539    // built-in script function:  in_range()
540    
541    bool CoreVMFunction_in_range::acceptsArgType(vmint iArg, ExprType_t type) const {
542        return type == INT_EXPR || type == REAL_EXPR;
543    }
544    
545    void CoreVMFunction_in_range::checkArgs(VMFnArgs* args,
546                                            std::function<void(String)> err,
547                                            std::function<void(String)> wrn)
548    {
549        // super class checks
550        Super::checkArgs(args, err, wrn);
551    
552        // own checks ...
553        if (args->arg(0)->asNumber()->unitType() !=
554            args->arg(1)->asNumber()->unitType() ||
555            args->arg(1)->asNumber()->unitType() !=
556            args->arg(2)->asNumber()->unitType())
557        {
558            String a = unitTypeStr(args->arg(0)->asNumber()->unitType());
559            String b = unitTypeStr(args->arg(1)->asNumber()->unitType());
560            String c = unitTypeStr(args->arg(2)->asNumber()->unitType());
561            err("Arguments must all have same unit, however argument 1 is " + a +
562                ", argument 2 is " + b + ", argument 3 is " + c + ".");
563            return;
564        }
565        if (args->arg(0)->exprType() != args->arg(1)->exprType() ||
566            args->arg(1)->exprType() != args->arg(2)->exprType())
567        {
568            String a = typeStr(args->arg(0)->exprType());
569            String b = typeStr(args->arg(1)->exprType());
570            String c = typeStr(args->arg(2)->exprType());
571            String r = typeStr(REAL_EXPR);
572            wrn("Argument 1 is " + a + ", argument 2 is " + b +
573                ", argument 3 is " + c + ", function result will be " + r + ".");
574        }
575    }
576    
577    template<class T>
578    inline void _swapByValue(T& a, T& b) {
579        T tmp = a;
580        a = b;
581        b = tmp;
582    }
583    
584    VMFnResult* CoreVMFunction_in_range::exec(VMFnArgs* args) {
585        VMNumberExpr* argNeedle = args->arg(0)->asNumber();
586        VMNumberExpr* argLo = args->arg(1)->asNumber();
587        VMNumberExpr* argHi = args->arg(2)->asNumber();
588    
589        vmfloat needle = argNeedle->evalCastReal();
590        vmfloat lo = argLo->evalCastReal();
591        vmfloat hi = argHi->evalCastReal();
592    
593        needle *= argNeedle->unitFactor();
594        lo *= argLo->unitFactor();
595        hi *= argHi->unitFactor();
596    
597        if (lo > hi) _swapByValue(lo, hi);
598    
599        return successResult(needle >= lo && needle <= hi);
600  }  }
601    
602  ///////////////////////////////////////////////////////////////////////////  ///////////////////////////////////////////////////////////////////////////
603  // built-in script function:  sh_left()  // built-in script function:  sh_left()
604    
605    bool CoreVMFunction_sh_left::returnsFinal(VMFnArgs* args) {
606        return args->arg(0)->asNumber()->isFinal();
607    }
608    
609  VMFnResult* CoreVMFunction_sh_left::exec(VMFnArgs* args) {  VMFnResult* CoreVMFunction_sh_left::exec(VMFnArgs* args) {
610      int i = args->arg(0)->asInt()->evalInt();      vmint i = args->arg(0)->asInt()->evalInt();
611      int n = args->arg(1)->asInt()->evalInt();      vmint n = args->arg(1)->asInt()->evalInt();
612      return successResult(i << n);      return successResult(i << n);
613  }  }
614    
615  ///////////////////////////////////////////////////////////////////////////  ///////////////////////////////////////////////////////////////////////////
616  // built-in script function:  sh_right()  // built-in script function:  sh_right()
617    
618    bool CoreVMFunction_sh_right::returnsFinal(VMFnArgs* args) {
619        return args->arg(0)->asNumber()->isFinal();
620    }
621    
622  VMFnResult* CoreVMFunction_sh_right::exec(VMFnArgs* args) {  VMFnResult* CoreVMFunction_sh_right::exec(VMFnArgs* args) {
623      int i = args->arg(0)->asInt()->evalInt();      vmint i = args->arg(0)->asInt()->evalInt();
624      int n = args->arg(1)->asInt()->evalInt();      vmint n = args->arg(1)->asInt()->evalInt();
625      return successResult(i >> n);      return successResult(i >> n);
626  }  }
627    
628  ///////////////////////////////////////////////////////////////////////////  ///////////////////////////////////////////////////////////////////////////
629  // built-in script function:  min()  // built-in script function:  min()
630    
631    ExprType_t CoreVMFunction_min::returnType(VMFnArgs* args) {
632        return (args->arg(0)->exprType() == REAL_EXPR ||
633                args->arg(1)->exprType() == REAL_EXPR) ? REAL_EXPR : INT_EXPR;
634    }
635    
636    StdUnit_t CoreVMFunction_min::returnUnitType(VMFnArgs* args) {
637        return args->arg(0)->asNumber()->unitType();
638    }
639    
640    bool CoreVMFunction_min::returnsFinal(VMFnArgs* args) {
641        return args->arg(0)->asNumber()->isFinal() ||
642               args->arg(1)->asNumber()->isFinal();
643    }
644    
645    bool CoreVMFunction_min::acceptsArgType(vmint iArg, ExprType_t type) const {
646        return type == INT_EXPR || type == REAL_EXPR;
647    }
648    
649    void CoreVMFunction_min::checkArgs(VMFnArgs* args,
650                                       std::function<void(String)> err,
651                                       std::function<void(String)> wrn)
652    {
653        // super class checks
654        Super::checkArgs(args, err, wrn);
655    
656        // own checks ...
657        if (args->arg(0)->asNumber()->unitType() !=
658            args->arg(1)->asNumber()->unitType())
659        {
660            String a = unitTypeStr(args->arg(0)->asNumber()->unitType());
661            String b = unitTypeStr(args->arg(1)->asNumber()->unitType());
662            err("Argument 1 has unit type " + a + ", whereas argument 2 has unit type " + b + ".");
663            return;
664        }
665        if (args->arg(0)->exprType() != args->arg(1)->exprType()) {
666            String a = typeStr(args->arg(0)->exprType());
667            String b = typeStr(args->arg(1)->exprType());
668            String c = typeStr(REAL_EXPR);
669            wrn("Argument 1 is " + a + ", whereas argument 2 is " + b + ", function result will be " + c + ".");
670            return;
671        }
672        if (args->arg(0)->asNumber()->isFinal() !=
673            args->arg(1)->asNumber()->isFinal())
674        {
675            String a = args->arg(0)->asNumber()->isFinal() ? "'final'" : "not 'final'";
676            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.");
678        }
679    }
680    
681  VMFnResult* CoreVMFunction_min::exec(VMFnArgs* args) {  VMFnResult* CoreVMFunction_min::exec(VMFnArgs* args) {
682      int l = args->arg(0)->asInt()->evalInt();      VMNumberExpr* lhs = args->arg(0)->asNumber();
683      int r = args->arg(1)->asInt()->evalInt();      VMNumberExpr* rhs = args->arg(1)->asNumber();
684      return successResult(l < r ? l : r);      if (lhs->exprType() == REAL_EXPR && rhs->exprType() == REAL_EXPR) {
685            vmfloat lm = lhs->asReal()->evalReal();
686            vmfloat rm = rhs->asReal()->evalReal();
687            vmfloat lprod = lm * lhs->unitFactor();
688            vmfloat rprod = rm * rhs->unitFactor();
689            return successRealResult({
690                .value = (lprod < rprod) ? lm : rm,
691                .unitFactor = (lprod < rprod) ? lhs->unitFactor() : rhs->unitFactor()
692            });
693        } else if (lhs->exprType() == REAL_EXPR && rhs->exprType() == INT_EXPR) {
694            vmfloat lm = lhs->asReal()->evalReal();
695            vmint   rm = rhs->asInt()->evalInt();
696            vmfloat lprod = lm * lhs->unitFactor();
697            vmfloat rprod = rm * rhs->unitFactor();
698            return successRealResult({
699                .value = (lprod < rprod) ? lm : rm,
700                .unitFactor = (lprod < rprod) ? lhs->unitFactor() : rhs->unitFactor()
701            });
702        } else if (lhs->exprType() == INT_EXPR && rhs->exprType() == REAL_EXPR) {
703            vmint   lm = lhs->asInt()->evalInt();
704            vmfloat rm = rhs->asReal()->evalReal();
705            vmfloat lprod = lm * lhs->unitFactor();
706            vmfloat rprod = rm * rhs->unitFactor();
707            return successRealResult({
708                .value = (lprod < rprod) ? lm : rm,
709                .unitFactor = (lprod < rprod) ? lhs->unitFactor() : rhs->unitFactor()
710            });
711        } else {
712            vmint lm = lhs->asInt()->evalInt();
713            vmint rm = rhs->asInt()->evalInt();
714            vmfloat lprod = lm * lhs->unitFactor();
715            vmfloat rprod = rm * rhs->unitFactor();
716            return successIntResult({
717                .value = (lprod < rprod) ? lm : rm,
718                .unitFactor = (lprod < rprod) ? lhs->unitFactor() : rhs->unitFactor()
719            });
720        }
721  }  }
722    
723  ///////////////////////////////////////////////////////////////////////////  ///////////////////////////////////////////////////////////////////////////
724  // built-in script function:  max()  // built-in script function:  max()
725    
726    ExprType_t CoreVMFunction_max::returnType(VMFnArgs* args) {
727        return (args->arg(0)->exprType() == REAL_EXPR ||
728                args->arg(1)->exprType() == REAL_EXPR) ? REAL_EXPR : INT_EXPR;
729    }
730    
731    StdUnit_t CoreVMFunction_max::returnUnitType(VMFnArgs* args) {
732        return args->arg(0)->asNumber()->unitType();
733    }
734    
735    bool CoreVMFunction_max::returnsFinal(VMFnArgs* args) {
736        return args->arg(0)->asNumber()->isFinal() ||
737               args->arg(1)->asNumber()->isFinal();
738    }
739    
740    bool CoreVMFunction_max::acceptsArgType(vmint iArg, ExprType_t type) const {
741        return type == INT_EXPR || type == REAL_EXPR;
742    }
743    
744    void CoreVMFunction_max::checkArgs(VMFnArgs* args,
745                                       std::function<void(String)> err,
746                                       std::function<void(String)> wrn)
747    {
748        // super class checks
749        Super::checkArgs(args, err, wrn);
750    
751        // own checks ...
752        if (args->arg(0)->asNumber()->unitType() !=
753            args->arg(1)->asNumber()->unitType())
754        {
755            String a = unitTypeStr(args->arg(0)->asNumber()->unitType());
756            String b = unitTypeStr(args->arg(1)->asNumber()->unitType());
757            err("Argument 1 has unit type " + a + ", whereas argument 2 has unit type " + b + ".");
758            return;
759        }
760        if (args->arg(0)->exprType() != args->arg(1)->exprType()) {
761            String a = typeStr(args->arg(0)->exprType());
762            String b = typeStr(args->arg(1)->exprType());
763            String c = typeStr(REAL_EXPR);
764            wrn("Argument 1 is " + a + ", whereas argument 2 is " + b + ", function result will be " + c + ".");
765            return;
766        }
767        if (args->arg(0)->asNumber()->isFinal() !=
768            args->arg(1)->asNumber()->isFinal())
769        {
770            String a = args->arg(0)->asNumber()->isFinal() ? "'final'" : "not 'final'";
771            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.");
773        }
774    }
775    
776  VMFnResult* CoreVMFunction_max::exec(VMFnArgs* args) {  VMFnResult* CoreVMFunction_max::exec(VMFnArgs* args) {
777      int l = args->arg(0)->asInt()->evalInt();      VMNumberExpr* lhs = args->arg(0)->asNumber();
778      int r = args->arg(1)->asInt()->evalInt();      VMNumberExpr* rhs = args->arg(1)->asNumber();
779      return successResult(l > r ? l : r);      if (lhs->exprType() == REAL_EXPR && rhs->exprType() == REAL_EXPR) {
780            vmfloat lm = lhs->asReal()->evalReal();
781            vmfloat rm = rhs->asReal()->evalReal();
782            vmfloat lprod = lm * lhs->unitFactor();
783            vmfloat rprod = rm * rhs->unitFactor();
784            return successRealResult({
785                .value = (lprod > rprod) ? lm : rm,
786                .unitFactor = (lprod > rprod) ? lhs->unitFactor() : rhs->unitFactor()
787            });
788        } else if (lhs->exprType() == REAL_EXPR && rhs->exprType() == INT_EXPR) {
789            vmfloat lm = lhs->asReal()->evalReal();
790            vmint   rm = rhs->asInt()->evalInt();
791            vmfloat lprod = lm * lhs->unitFactor();
792            vmfloat rprod = rm * rhs->unitFactor();
793            return successRealResult({
794                .value = (lprod > rprod) ? lm : rm,
795                .unitFactor = (lprod > rprod) ? lhs->unitFactor() : rhs->unitFactor()
796            });
797        } else if (lhs->exprType() == INT_EXPR && rhs->exprType() == REAL_EXPR) {
798            vmint   lm = lhs->asInt()->evalInt();
799            vmfloat rm = rhs->asReal()->evalReal();
800            vmfloat lprod = lm * lhs->unitFactor();
801            vmfloat rprod = rm * rhs->unitFactor();
802            return successRealResult({
803                .value = (lprod > rprod) ? lm : rm,
804                .unitFactor = (lprod > rprod) ? lhs->unitFactor() : rhs->unitFactor()
805            });
806        } else {
807            vmint lm = lhs->asInt()->evalInt();
808            vmint rm = rhs->asInt()->evalInt();
809            vmfloat lprod = lm * lhs->unitFactor();
810            vmfloat rprod = rm * rhs->unitFactor();
811            return successIntResult({
812                .value = (lprod > rprod) ? lm : rm,
813                .unitFactor = (lprod > rprod) ? lhs->unitFactor() : rhs->unitFactor()
814            });
815        }
816    }
817    
818    ///////////////////////////////////////////////////////////////////////////
819    // built-in script function:  array_equal()
820    
821    bool CoreVMFunction_array_equal::acceptsArgType(vmint iArg, ExprType_t type) const {
822        return isArray(type);
823    }
824    
825    void CoreVMFunction_array_equal::checkArgs(VMFnArgs* args,
826                                               std::function<void(String)> err,
827                                               std::function<void(String)> wrn)
828    {
829        // super class checks
830        Super::checkArgs(args, err, wrn);
831    
832        // own checks ...
833        if (args->arg(0)->exprType() != args->arg(1)->exprType()) {
834            String a = typeStr(args->arg(0)->exprType());
835            String b = typeStr(args->arg(1)->exprType());
836            err("Argument 1 is " + a + ", whereas argument 2 is " + b + ".");
837            return;
838        }
839        if (args->arg(0)->asArray()->arraySize() !=
840            args->arg(1)->asArray()->arraySize())
841        {
842            wrn("Result of function call is always false, since the passed two arrays were declared with different array sizes.");
843        }
844    }
845    
846    VMFnResult* CoreVMFunction_array_equal::exec(VMFnArgs* args) {
847        VMArrayExpr* l = args->arg(0)->asArray();
848        VMArrayExpr* r = args->arg(1)->asArray();
849        if (l->arraySize() != r->arraySize()) {
850            //wrnMsg("array_equal(): the two arrays differ in size");
851            return successResult(0); // false
852        }
853        const vmint n = l->arraySize();
854        // checkArgs() above ensured that we either have INT_ARR_EXPR on both sides
855        // or REAL_ARR_EXPR on both sides, so we can simplify here (a bit)
856        if (l->exprType() == INT_ARR_EXPR) {
857            VMIntArrayExpr* lia = l->asIntArray();
858            VMIntArrayExpr* ria = r->asIntArray();
859            for (vmint i = 0; i < n; ++i) {
860                vmint lvalue = lia->evalIntElement(i);
861                vmint rvalue = ria->evalIntElement(i);
862                vmfloat lfactor = lia->unitFactorOfElement(i);
863                vmfloat rfactor = ria->unitFactorOfElement(i);
864                if (lfactor == rfactor) {
865                    if (lvalue != rvalue)
866                        return successResult(0); // false
867                    else
868                        continue;
869                }
870                if (lfactor < rfactor) {
871                    if (lvalue != Unit::convIntToUnitFactor(rvalue, rfactor, lfactor))
872                        return successResult(0); // false
873                    else
874                        continue;
875                } else {
876                    if (rvalue != Unit::convIntToUnitFactor(lvalue, lfactor, rfactor))
877                        return successResult(0); // false
878                    else
879                        continue;
880                }
881            }
882        } else {
883            VMRealArrayExpr* lra = l->asRealArray();
884            VMRealArrayExpr* rra = r->asRealArray();
885            for (vmint i = 0; i < n; ++i) {
886                vmfloat lvalue = lra->evalRealElement(i);
887                vmfloat rvalue = rra->evalRealElement(i);
888                vmfloat lfactor = lra->unitFactorOfElement(i);
889                vmfloat rfactor = rra->unitFactorOfElement(i);
890                if (lfactor == rfactor) {
891                    if (!_fEqualX(lvalue, rvalue))
892                        return successResult(0); // false
893                    else
894                        continue;
895                }
896                if (lfactor < rfactor) {
897                    if (!_fEqualX(lvalue, Unit::convRealToUnitFactor(rvalue, rfactor, lfactor)))
898                        return successResult(0); // false
899                    else
900                        continue;
901                } else {
902                    if (!_fEqualX(rvalue, Unit::convRealToUnitFactor(lvalue, lfactor, rfactor)))
903                        return successResult(0); // false
904                    else
905                        continue;
906                }
907            }
908        }
909        return successResult(1); // true
910    }
911    
912    ///////////////////////////////////////////////////////////////////////////
913    // built-in script function:  search()
914    
915    ExprType_t CoreVMFunction_search::argType(vmint iArg) const {
916        return (iArg == 0) ? INT_ARR_EXPR : INT_EXPR;
917    }
918    
919    bool CoreVMFunction_search::acceptsArgType(vmint iArg, ExprType_t type) const {
920        if (iArg == 0)
921            return isArray(type);
922        else
923            return type == INT_EXPR || type == REAL_EXPR;
924    }
925    
926    void CoreVMFunction_search::checkArgs(VMFnArgs* args,
927                                          std::function<void(String)> err,
928                                          std::function<void(String)> wrn)
929    {
930        // super class checks
931        Super::checkArgs(args, err, wrn);
932    
933        // own checks ...
934        if (args->arg(0)->exprType() == INT_ARR_EXPR &&
935            args->arg(1)->exprType() != INT_EXPR)
936        {
937            String a = typeStr(INT_ARR_EXPR);
938            String bIs = typeStr(args->arg(1)->exprType());
939            String bShould = typeStr(INT_EXPR);
940            err("Argument 1 is " + a + ", hence argument 2 should be " + bShould + ", is " + bIs + " though.");
941            return;
942        }
943        if (args->arg(0)->exprType() == REAL_ARR_EXPR &&
944            args->arg(1)->exprType() != REAL_EXPR)
945        {
946            String a = typeStr(REAL_ARR_EXPR);
947            String bIs = typeStr(args->arg(1)->exprType());
948            String bShould = typeStr(REAL_EXPR);
949            err("Argument 1 is " + a + ", hence argument 2 should be " + bShould + ", is " + bIs + " though.");
950            return;
951        }
952    }
953    
954    VMFnResult* CoreVMFunction_search::exec(VMFnArgs* args) {
955        VMArrayExpr* a = args->arg(0)->asArray();
956        const vmint n = a->arraySize();
957        if (a->exprType() == INT_ARR_EXPR) {
958            const vmint needle = args->arg(1)->asInt()->evalInt();
959            VMIntArrayExpr* intArray = a->asIntArray();
960            for (vmint i = 0; i < n; ++i)
961                if (intArray->evalIntElement(i) == needle)
962                    return successResult(i);
963        } else { // real array ...
964            const vmfloat needle = args->arg(1)->asReal()->evalReal();
965            VMRealArrayExpr* realArray = a->asRealArray();
966            for (vmint i = 0; i < n; ++i) {
967                const vmfloat value = realArray->evalRealElement(i);
968                if (_fEqualX(value, needle))
969                    return successResult(i);
970            }
971        }
972        return successResult(-1); // not found
973    }
974    
975    ///////////////////////////////////////////////////////////////////////////
976    // built-in script function:  sort()
977    
978    ExprType_t CoreVMFunction_sort::argType(vmint iArg) const {
979        return (iArg == 0) ? INT_ARR_EXPR : INT_EXPR;
980    }
981    
982    bool CoreVMFunction_sort::acceptsArgType(vmint iArg, ExprType_t type) const {
983        if (iArg == 0)
984            return isArray(type);
985        else
986            return type == INT_EXPR;
987    }
988    
989    // The following structs and template classes act as adapters for allowing to
990    // use std sort algorithms on our arrays. It might look a bit more complicated
991    // than it ought to be, but there is one reason for the large amount of
992    // 'adapter' code below: the STL std algorithms rely on 'lvalues' to do their
993    // e.g. sorting) jobs, that is they expect containers to have 'localizeable'
994    // data which essentially means their data should reside somewhere in memory and
995    // directly be accessible (readable and writable) there, which is not the case
996    // with our VM interfaces which actually always require virtual getter and
997    // setter methods to be called instead. So we must emulate lvalues by custom
998    // classes/structs which forward between our getters/setters and the lvalue
999    // access operators used by the STL std algorithms.
1000    
1001    struct IntArrayAccessor {
1002        static inline vmint getPrimaryValue(VMIntArrayExpr* arr, vmint index) {
1003            return arr->evalIntElement(index);
1004        }
1005        static inline void setPrimaryValue(VMIntArrayExpr* arr, vmint index, vmint value) {
1006            arr->assignIntElement(index, value);
1007        }
1008    };
1009    
1010    struct RealArrayAccessor {
1011        static inline vmfloat getPrimaryValue(VMRealArrayExpr* arr, vmint index) {
1012            return arr->evalRealElement(index);
1013        }
1014        static inline void setPrimaryValue(VMRealArrayExpr* arr, vmint index, vmfloat value) {
1015            arr->assignRealElement(index, value);
1016        }
1017    };
1018    
1019    template<class T_array> // i.e. T_array is either VMIntArrayExpr or VMRealArrayExpr
1020    struct ArrElemPOD {
1021        T_array* m_array;
1022        vmint m_index;
1023    };
1024    
1025    // This class is used for temporary values by std::sort().
1026    template<class T_value> // i.e. T_value is either vmint or vmfloat
1027    struct ScalarNmbrVal {
1028        T_value primValue;
1029        vmfloat unitFactor;
1030    
1031        inline bool operator<(const ScalarNmbrVal& other) const {
1032            return getProdValue() < other.getProdValue();
1033        }
1034        inline bool operator>(const ScalarNmbrVal& other) const {
1035            return getProdValue() > other.getProdValue();
1036        }
1037        inline vmfloat getProdValue() const {
1038            // simple solution for both vmint and vmfloat, should be fine for just sorting
1039            return primValue * unitFactor;
1040        }
1041    };
1042    
1043    // This class emulates lvalue access (access by reference) which is used by ArrExprIter::operator*() below.
1044    template<class T_array, // T_array is either VMIntArrayExpr or VMRealArrayExpr
1045             class T_value, // T_value is either vmint or vmfloat
1046             class T_accessor> // T_accessor is either IntArrayAccessor or RealArrayAccessor
1047    class ArrElemRef : protected ArrElemPOD<T_array> {
1048    public:
1049        typedef ScalarNmbrVal<T_value> ScalarNmbrVal;
1050    
1051        inline ArrElemRef(T_array* a, vmint index) {
1052            this->m_array = a;
1053            this->m_index = index;
1054        }
1055        inline ArrElemRef(const ArrElemRef& ref) {
1056            this->m_array = ref.m_array;
1057            this->m_index = ref.m_index;
1058        }
1059        inline ArrElemRef& operator=(const ArrElemRef& e) {
1060            setPrimValue(e.getPrimValue());
1061            setUnitFactor(e.getUnitFactor());
1062            return *this;
1063        }
1064        inline ArrElemRef& operator=(ScalarNmbrVal value) {
1065            setPrimValue(value.primValue);
1066            setUnitFactor(value.unitFactor);
1067            return *this;
1068        }
1069        inline bool operator==(const ArrElemRef& e) const {
1070            return getProdValue() == e.getProdValue();
1071        }
1072        inline bool operator!=(const ArrElemRef& e) const {
1073            return !(operator==(e));
1074        }
1075        inline bool operator<(const ArrElemRef& e) const {
1076            return getProdValue() < e.getProdValue();
1077        }
1078        inline bool operator>(const ArrElemRef& e) const {
1079            return getProdValue() > e.getProdValue();
1080        }
1081        inline bool operator<=(const ArrElemRef& e) const {
1082            return getProdValue() <= e.getProdValue();
1083        }
1084        inline bool operator>=(const ArrElemRef& e) const {
1085            return getProdValue() >= e.getProdValue();
1086        }
1087        inline bool operator==(const ScalarNmbrVal& s) const {
1088            return getProdValue() == s.getProdValue();
1089        }
1090        inline bool operator!=(const ScalarNmbrVal& s) const {
1091            return !(operator==(s));
1092        }
1093        inline bool operator<(const ScalarNmbrVal& s) const {
1094            return getProdValue() < s.getProdValue();
1095        }
1096        inline bool operator>(const ScalarNmbrVal& s) const {
1097            return getProdValue() > s.getProdValue();
1098        }
1099        inline bool operator<=(const ScalarNmbrVal& s) const {
1100            return getProdValue() <= s.getProdValue();
1101        }
1102        inline bool operator>=(const ScalarNmbrVal& s) const {
1103            return getProdValue() >= s.getProdValue();
1104        }
1105        inline operator ScalarNmbrVal() {
1106            return {
1107                .primValue = getPrimValue() ,
1108                .unitFactor = getUnitFactor()
1109            };
1110        }
1111    protected:
1112        inline T_value getPrimValue() const {
1113            return T_accessor::getPrimaryValue( this->m_array, this->m_index );
1114        }
1115        inline void setPrimValue(T_value value) {
1116            T_accessor::setPrimaryValue( this->m_array, this->m_index, value );
1117        }
1118        inline vmfloat getUnitFactor() const {
1119            return this->m_array->unitFactorOfElement(this->m_index);
1120        }
1121        inline void setUnitFactor(vmfloat factor) {
1122            this->m_array->assignElementUnitFactor(this->m_index, factor);
1123        }
1124        inline vmfloat getProdValue() const {
1125            // simple solution for both vmint and vmfloat, should be fine for just sorting
1126            vmfloat primary = (vmfloat) getPrimValue();
1127            vmfloat factor  = getUnitFactor();
1128            return primary * factor;
1129        }
1130    
1131        // allow swap() functions below to access protected methods here
1132        friend void swap(class ArrElemRef<T_array,T_value,T_accessor> a,
1133                         class ArrElemRef<T_array,T_value,T_accessor> b);
1134    };
1135    
1136    // custom iterator class to be used by std:sort() on our VM arrays
1137    template<class T_array, class T_value, class T_accessor>
1138    class ArrExprIter : public ArrElemPOD<T_array> {
1139    public:
1140        typedef std::random_access_iterator_tag iterator_category;
1141        typedef ssize_t difference_type;
1142        typedef ArrElemRef<T_array, T_value, T_accessor> ArrElemRef;
1143        typedef ArrElemRef reference; // type used by STL for access by reference
1144        typedef void pointer; // type used by STL for -> operator result, we don't use that operator at all so just void it
1145        typedef ScalarNmbrVal<T_value> value_type; // type used by STL for temporary values
1146    
1147        ArrExprIter(T_array* a, vmint index) {
1148            this->m_array = a;
1149            this->m_index = index;
1150        }
1151        ArrExprIter(const ArrElemRef& ref) {
1152            this->m_array = ref.m_array;
1153            this->m_index = ref.m_index;
1154        }
1155        inline ArrElemRef operator*() {
1156            return ArrElemRef(this->m_array, this->m_index);
1157        }
1158        inline ArrExprIter& operator++() { // prefix increment
1159            ++(this->m_index);
1160            return *this;
1161        }
1162        inline ArrExprIter& operator--() { // prefix decrement
1163            --(this->m_index);
1164            return *this;
1165        }
1166        inline ArrExprIter operator++(int) { // postfix increment
1167            ArrExprIter it = *this;
1168            ++(this->m_index);
1169            return it;
1170        }
1171        inline ArrExprIter operator--(int) { // postfix decrement
1172            ArrExprIter it = *this;
1173            --(this->m_index);
1174            return it;
1175        }
1176        inline ArrExprIter& operator+=(difference_type d) {
1177            this->m_index += d;
1178            return *this;
1179        }
1180        inline ArrExprIter& operator-=(difference_type d) {
1181            this->m_index -= d;
1182            return *this;
1183        }
1184        inline bool operator==(const ArrExprIter& other) const {
1185            return this->m_index == other.m_index;
1186        }
1187        inline bool operator!=(const ArrExprIter& other) const {
1188            return this->m_index != other.m_index;
1189        }
1190        inline bool operator<(const ArrExprIter& other) const {
1191            return this->m_index < other.m_index;
1192        }
1193        inline bool operator>(const ArrExprIter& other) const {
1194            return this->m_index > other.m_index;
1195        }
1196        inline bool operator<=(const ArrExprIter& other) const {
1197            return this->m_index <= other.m_index;
1198        }
1199        inline bool operator>=(const ArrExprIter& other) const {
1200            return this->m_index >= other.m_index;
1201        }
1202        inline difference_type operator+(const ArrExprIter& other) const {
1203            return this->m_index + other.m_index;
1204        }
1205        inline difference_type operator-(const ArrExprIter& other) const {
1206            return this->m_index - other.m_index;
1207        }
1208        inline ArrExprIter operator-(difference_type d) const {
1209            return ArrExprIter(this->m_array, this->m_index - d);
1210        }
1211        inline ArrExprIter operator+(difference_type d) const {
1212            return ArrExprIter(this->m_array, this->m_index + d);
1213        }
1214        inline ArrExprIter operator*(difference_type factor) const {
1215            return ArrExprIter(this->m_array, this->m_index * factor);
1216        }
1217    };
1218    
1219    typedef ArrExprIter<VMIntArrayExpr,vmint,IntArrayAccessor> IntArrExprIter;
1220    typedef ArrExprIter<VMRealArrayExpr,vmfloat,RealArrayAccessor> RealArrExprIter;
1221    
1222    // intentionally not a template function to avoid potential clashes with other (i.e. system's) swap() functions
1223    static inline void swap(IntArrExprIter::ArrElemRef a,
1224                            IntArrExprIter::ArrElemRef b)
1225    {
1226        vmint valueA = a.getPrimValue();
1227        vmint valueB = b.getPrimValue();
1228        vmfloat factorA = a.getUnitFactor();
1229        vmfloat factorB = b.getUnitFactor();
1230        a.setPrimValue(valueB);
1231        a.setUnitFactor(factorB);
1232        b.setPrimValue(valueA);
1233        b.setUnitFactor(factorA);
1234    }
1235    
1236    // intentionally not a template function to avoid potential clashes with other (i.e. system's) swap() functions
1237    static inline void swap(RealArrExprIter::ArrElemRef a,
1238                            RealArrExprIter::ArrElemRef b)
1239    {
1240        vmfloat valueA = a.getPrimValue();
1241        vmfloat valueB = b.getPrimValue();
1242        vmfloat factorA = a.getUnitFactor();
1243        vmfloat factorB = b.getUnitFactor();
1244        a.setPrimValue(valueB);
1245        a.setUnitFactor(factorB);
1246        b.setPrimValue(valueA);
1247        b.setUnitFactor(factorA);
1248    }
1249    
1250    // used to sort in descending order (unlike the default behaviour of std::sort() which is ascending order)
1251    template<class T> // T is either IntArrExprIter or RealArrExprIter
1252    struct DescArrExprSorter {
1253        inline bool operator()(const typename T::value_type a, const typename T::value_type b) const {
1254            return a > b;
1255        }
1256    };
1257    
1258    VMFnResult* CoreVMFunction_sort::exec(VMFnArgs* args) {
1259        const bool bAscending =
1260            (args->argsCount() < 2) ? true : !args->arg(1)->asInt()->evalInt();
1261    
1262        if (args->arg(0)->exprType() == INT_ARR_EXPR) {
1263            VMIntArrayExpr* a = args->arg(0)->asIntArray();
1264            vmint n = a->arraySize();
1265            IntArrExprIter itBegin(a, 0);
1266            IntArrExprIter itEnd(a, n);
1267            if (bAscending) {
1268                std::sort(itBegin, itEnd);
1269            } else {
1270                DescArrExprSorter<IntArrExprIter> sorter;
1271                std::sort(itBegin, itEnd, sorter);
1272            }
1273        } else {
1274            VMRealArrayExpr* a = args->arg(0)->asRealArray();
1275            vmint n = a->arraySize();
1276            RealArrExprIter itBegin(a, 0);
1277            RealArrExprIter itEnd(a, n);
1278            if (bAscending) {
1279                std::sort(itBegin, itEnd);
1280            } else {
1281                DescArrExprSorter<RealArrExprIter> sorter;
1282                std::sort(itBegin, itEnd, sorter);
1283            }
1284        }
1285    
1286        return successResult();
1287    }
1288    
1289    ///////////////////////////////////////////////////////////////////////////
1290    // built-in script function:  real_to_int()  and  int()
1291    
1292    StdUnit_t CoreVMFunction_real_to_int::returnUnitType(VMFnArgs* args) {
1293        return args->arg(0)->asNumber()->unitType();
1294    }
1295    
1296    bool CoreVMFunction_real_to_int::returnsFinal(VMFnArgs* args) {
1297        return args->arg(0)->asNumber()->isFinal();
1298    }
1299    
1300    VMFnResult* CoreVMFunction_real_to_int::exec(VMFnArgs* args) {
1301        VMRealExpr* realExpr = args->arg(0)->asReal();
1302        vmfloat f = realExpr->evalReal();
1303        return successResult({
1304            .value = vmint(f),
1305            .unitFactor = realExpr->unitFactor()
1306        });
1307    }
1308    
1309    ///////////////////////////////////////////////////////////////////////////
1310    // built-in script function:  int_to_real()  and  real()
1311    
1312    StdUnit_t CoreVMFunction_int_to_real::returnUnitType(VMFnArgs* args) {
1313        return args->arg(0)->asNumber()->unitType();
1314    }
1315    
1316    bool CoreVMFunction_int_to_real::returnsFinal(VMFnArgs* args) {
1317        return args->arg(0)->asNumber()->isFinal();
1318    }
1319    
1320    VMFnResult* CoreVMFunction_int_to_real::exec(VMFnArgs* args) {
1321        VMIntExpr* intExpr = args->arg(0)->asInt();
1322        vmint i = intExpr->evalInt();
1323        return successResult({
1324            .value = vmfloat(i),
1325            .unitFactor = intExpr->unitFactor()
1326        });
1327  }  }
1328    
1329  } // namespace LinuxSampler  } // namespace LinuxSampler
Legend:
Removed from v.2972  
changed lines
  Added in v.3584
  ViewVC Help
Powered by ViewVC