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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 3584 - (show annotations) (download)
Fri Aug 30 13:33:32 2019 UTC (4 years, 6 months ago) by schoenebeck
File size: 48007 byte(s)
* NKSP VM API: Added 4 overridden methods to class VMNumberExpr:
  evalCastInt(MetricPrefix_t), evalCastInt(MetricPrefix_t,MetricPrefix_t),
  evalCastReal(MetricPrefix_t), evalCastReal(MetricPrefix_t,MetricPrefix_t)
  as convenient methods for automatically converting values to expected
  metric value basis.

* NKSP built-in function "wait()" accepts now both integers and real numbers
  as argument.

* Bumped version (2.1.1.svn9).

1 /*
2 * Copyright (c) 2014-2019 Christian Schoenebeck
3 *
4 * http://www.linuxsampler.org
5 *
6 * This file is part of LinuxSampler and released under the same terms.
7 * See README file for details.
8 */
9
10 #include "CoreVMFunctions.h"
11
12 #include <iostream>
13 #include <algorithm> // for std::sort()
14 #include <math.h>
15 #include <stdlib.h>
16 #include "tree.h"
17 #include "ScriptVM.h"
18 #include "../common/RTMath.h"
19
20 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
31
32 VMFnResult* VMEmptyResultFunction::errorResult() {
33 result.flags = StmtFlags_t(STMT_ABORT_SIGNALLED | STMT_ERROR_OCCURRED);
34 return &result;
35 }
36
37 VMFnResult* VMEmptyResultFunction::successResult() {
38 result.flags = STMT_SUCCESS;
39 return &result;
40 }
41
42 ///////////////////////////////////////////////////////////////////////////
43 // class VMIntResultFunction
44
45 VMFnResult* VMIntResultFunction::errorResult(vmint i) {
46 result.flags = StmtFlags_t(STMT_ABORT_SIGNALLED | STMT_ERROR_OCCURRED);
47 result.value = i;
48 result.unitPrefixFactor = VM_NO_FACTOR;
49 return &result;
50 }
51
52 VMFnResult* VMIntResultFunction::successResult(vmint i) {
53 result.flags = STMT_SUCCESS;
54 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;
102 }
103
104 ///////////////////////////////////////////////////////////////////////////
105 // class VMStringResultFunction
106
107 VMFnResult* VMStringResultFunction::errorResult(const String& s) {
108 result.flags = StmtFlags_t(STMT_ABORT_SIGNALLED | STMT_ERROR_OCCURRED);
109 result.value = s;
110 return &result;
111 }
112
113 VMFnResult* VMStringResultFunction::successResult(const String& s) {
114 result.flags = STMT_SUCCESS;
115 result.value = s;
116 return &result;
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()
180
181 bool CoreVMFunction_message::acceptsArgType(vmint iArg, ExprType_t type) const {
182 return type == INT_EXPR || type == REAL_EXPR || type == STRING_EXPR;
183 }
184
185 VMFnResult* CoreVMFunction_message::exec(VMFnArgs* args) {
186 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));
191 if (strExpr) {
192 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();
200 }
201
202 VMIntExpr* intExpr = dynamic_cast<VMIntExpr*>(args->arg(0));
203 if (intExpr) {
204 printf("[ScriptVM %.3f] %lld\n", usecs/1000000.f, (int64_t)intExpr->evalInt());
205 return successResult();
206 }
207
208 return errorResult();
209 }
210
211 ///////////////////////////////////////////////////////////////////////////
212 // 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) {
238 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;
275 }
276
277 ///////////////////////////////////////////////////////////////////////////
278 // 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) {
293 ExecContext* ctx = dynamic_cast<ExecContext*>(vm->currentVMExecContext());
294 VMNumberExpr* expr = args->arg(0)->asNumber();
295 StdUnit_t unit = expr->unitType();
296 vmint us = (unit) ? expr->evalCastInt(VM_MICRO) : expr->evalCastInt();
297 if (us < 0) {
298 wrnMsg("wait(): argument may not be negative! Aborting script!");
299 this->result.flags = STMT_ABORT_SIGNALLED;
300 } else if (us == 0) {
301 wrnMsg("wait(): argument may not be zero! Aborting script!");
302 this->result.flags = STMT_ABORT_SIGNALLED;
303 } else {
304 ctx->suspendMicroseconds = us;
305 this->result.flags = STMT_SUSPEND_SIGNALLED;
306 }
307 return &result;
308 }
309
310 ///////////////////////////////////////////////////////////////////////////
311 // built-in script function: abs()
312
313 ExprType_t CoreVMFunction_abs::returnType(VMFnArgs* args) {
314 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) {
330 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()
348
349 ExprType_t CoreVMFunction_random::returnType(VMFnArgs* args) {
350 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) {
395 float f = float(::rand()) / float(RAND_MAX);
396
397 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()
447
448 bool CoreVMFunction_num_elements::acceptsArgType(vmint iArg, ExprType_t type) const {
449 return isArray(type);
450 }
451
452 VMFnResult* CoreVMFunction_num_elements::exec(VMFnArgs* args) {
453 return successResult( args->arg(0)->asArray()->arraySize() );
454 }
455
456 ///////////////////////////////////////////////////////////////////////////
457 // 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) {
482 VMExpr* arg = args->arg(0);
483 VMIntExpr* in = dynamic_cast<VMIntExpr*>(arg);
484 VMVariable* out = dynamic_cast<VMVariable*>(arg);
485 vmint i = in->evalInt() + 1;
486 IntLiteral tmp({
487 .value = i,
488 .unitFactor = in->unitFactor()
489 });
490 out->assignExpr(&tmp);
491 return successResult({
492 .value = i,
493 .unitFactor = in->unitFactor()
494 });
495 }
496
497 ///////////////////////////////////////////////////////////////////////////
498 // 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) {
523 VMExpr* arg = args->arg(0);
524 VMIntExpr* in = dynamic_cast<VMIntExpr*>(arg);
525 VMVariable* out = dynamic_cast<VMVariable*>(arg);
526 vmint i = in->evalInt() - 1;
527 IntLiteral tmp({
528 .value = i,
529 .unitFactor = in->unitFactor()
530 });
531 out->assignExpr(&tmp);
532 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()
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) {
610 vmint i = args->arg(0)->asInt()->evalInt();
611 vmint n = args->arg(1)->asInt()->evalInt();
612 return successResult(i << n);
613 }
614
615 ///////////////////////////////////////////////////////////////////////////
616 // 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) {
623 vmint i = args->arg(0)->asInt()->evalInt();
624 vmint n = args->arg(1)->asInt()->evalInt();
625 return successResult(i >> n);
626 }
627
628 ///////////////////////////////////////////////////////////////////////////
629 // 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) {
682 VMNumberExpr* lhs = args->arg(0)->asNumber();
683 VMNumberExpr* rhs = args->arg(1)->asNumber();
684 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()
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) {
777 VMNumberExpr* lhs = args->arg(0)->asNumber();
778 VMNumberExpr* rhs = args->arg(1)->asNumber();
779 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

  ViewVC Help
Powered by ViewVC