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

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

Parent Directory Parent Directory | Revision Log Revision Log

Revision 3678 - (show annotations) (download) (as text)
Fri Dec 27 22:46:08 2019 UTC (4 years, 3 months ago) by schoenebeck
File MIME type: text/x-c++hdr
File size: 34131 byte(s) 
* NKSP: Added built-in script functions "msb()" and "lsb()".

* Bumped version (2.1.1.svn26).
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 #ifndef LS_COREVMFUNCTIONS_H
11 #define LS_COREVMFUNCTIONS_H
12
13 #include "../common/global.h"
14 #include "common.h"
15
16 namespace LinuxSampler {
17
18 class ScriptVM;
19
20 ///////////////////////////////////////////////////////////////////////////
21 // convenience base classes for built-in script functions ...
22
23 /**
24 * An instance of this class is returned by built-in function implementations
25 * which do not return a function return value.
26 */
27 class VMEmptyResult FINAL : public VMFnResult, public VMExpr {
28 public:
29 StmtFlags_t flags; ///< general completion status (i.e. success or failure) of the function call
30
31 VMEmptyResult() : flags(STMT_SUCCESS) {}
32 ExprType_t exprType() const OVERRIDE { return EMPTY_EXPR; }
33 VMExpr* resultValue() OVERRIDE { return this; }
34 StmtFlags_t resultFlags() OVERRIDE { return flags; }
35 bool isConstExpr() const OVERRIDE { return false; }
36 };
37
38 /**
39 * An instance of this class is returned by built-in function implementations
40 * which return an integer value as function return value.
41 */
42 class VMIntResult FINAL : public VMFnResult, public VMIntExpr {
43 public:
44 StmtFlags_t flags; ///< general completion status (i.e. success or failure) of the function call
45 vmint value; ///< result value of the function call
46 vmfloat unitPrefixFactor; ///< unit factor of result value of the function call
47
48 VMIntResult() : flags(STMT_SUCCESS), value(0), unitPrefixFactor(VM_NO_FACTOR) {}
49 vmint evalInt() OVERRIDE { return value; }
50 VMExpr* resultValue() OVERRIDE { return this; }
51 StmtFlags_t resultFlags() OVERRIDE { return flags; }
52 bool isConstExpr() const OVERRIDE { return false; }
53 vmfloat unitFactor() const OVERRIDE { return unitPrefixFactor; }
54 StdUnit_t unitType() const OVERRIDE { return VM_NO_UNIT; } // actually never called, VMFunction::returnUnitType() is always used instead
55 bool isFinal() const OVERRIDE { return false; } // actually never called, VMFunction::returnsFinal() is always used instead
56 };
57
58 /**
59 * An instance of this class is returned by built-in function implementations
60 * which return a real number (floating point) value as function return value.
61 */
62 class VMRealResult FINAL : public VMFnResult, public VMRealExpr {
63 public:
64 StmtFlags_t flags; ///< general completion status (i.e. success or failure) of the function call
65 vmfloat value; ///< result value of the function call
66 vmfloat unitPrefixFactor; ///< unit factor of result value of the function call
67
68 VMRealResult() : flags(STMT_SUCCESS), value(0), unitPrefixFactor(VM_NO_FACTOR) {}
69 vmfloat evalReal() OVERRIDE { return value; }
70 VMExpr* resultValue() OVERRIDE { return this; }
71 StmtFlags_t resultFlags() OVERRIDE { return flags; }
72 bool isConstExpr() const OVERRIDE { return false; }
73 vmfloat unitFactor() const OVERRIDE { return unitPrefixFactor; }
74 StdUnit_t unitType() const OVERRIDE { return VM_NO_UNIT; } // actually never called, VMFunction::returnUnitType() is always used instead
75 bool isFinal() const OVERRIDE { return false; } // actually never called, VMFunction::returnsFinal() is always used instead
76 };
77
78 /**
79 * An instance of this class is returned by built-in function implementations
80 * which return a string value as function return value.
81 */
82 class VMStringResult FINAL : public VMFnResult, public VMStringExpr {
83 public:
84 StmtFlags_t flags; ///< general completion status (i.e. success or failure) of the function call
85 String value; ///< result value of the function call
86
87 VMStringResult() : flags(STMT_SUCCESS) {}
88 String evalStr() OVERRIDE { return value; }
89 VMExpr* resultValue() OVERRIDE { return this; }
90 StmtFlags_t resultFlags() OVERRIDE { return flags; }
91 bool isConstExpr() const OVERRIDE { return false; }
92 };
93
94 /**
95 * Abstract base class for built-in script functions which do not return any
96 * function return value (void).
97 */
98 class VMEmptyResultFunction : public VMFunction {
99 protected:
100 virtual ~VMEmptyResultFunction() {}
101 ExprType_t returnType(VMFnArgs* args) OVERRIDE { return EMPTY_EXPR; }
102 StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE { return VM_NO_UNIT; }
103 bool returnsFinal(VMFnArgs* args) OVERRIDE { return false; }
104 VMFnResult* errorResult();
105 VMFnResult* successResult();
106 bool modifiesArg(vmint iArg) const OVERRIDE { return false; }
107 protected:
108 VMEmptyResult result;
109 };
110
111 struct VMIntFnResDef {
112 vmint value = 0; //NOTE: sequence matters! Since this is usually initialized with VMIntExpr::evalInt() it should be before member unitFactor, since the latter is usually initialized with VMIntExpr::unitFactor() which does not evaluate the expression.
113 vmfloat unitFactor = VM_NO_FACTOR;
114 };
115
116 struct VMRealFnResDef {
117 vmfloat value = vmfloat(0); //NOTE: sequence matters! Since this is usually initialized with VMRealExpr::evalReal() it should be before member unitFactor, since the latter is usually initialized with VMRealExpr::unitFactor() which does not evaluate the expression.
118 vmfloat unitFactor = VM_NO_FACTOR;
119 };
120
121 /**
122 * Abstract base class for built-in script functions which return an integer
123 * (scalar) as their function return value.
124 */
125 class VMIntResultFunction : public VMFunction {
126 protected:
127 virtual ~VMIntResultFunction() {}
128 ExprType_t returnType(VMFnArgs* args) OVERRIDE { return INT_EXPR; }
129 VMFnResult* errorResult(vmint i = 0);
130 VMFnResult* errorResult(VMIntFnResDef res);
131 VMFnResult* successResult(vmint i = 0);
132 VMFnResult* successResult(VMIntFnResDef res);
133 bool modifiesArg(vmint iArg) const OVERRIDE { return false; }
134 protected:
135 VMIntResult result;
136 };
137
138 /**
139 * Abstract base class for built-in script functions which return a real number
140 * (floating point scalar) as their function return value.
141 */
142 class VMRealResultFunction : public VMFunction {
143 protected:
144 virtual ~VMRealResultFunction() {}
145 ExprType_t returnType(VMFnArgs* args) OVERRIDE { return REAL_EXPR; }
146 VMFnResult* errorResult(vmfloat f = 0);
147 VMFnResult* errorResult(VMRealFnResDef res);
148 VMFnResult* successResult(vmfloat f = 0);
149 VMFnResult* successResult(VMRealFnResDef res);
150 bool modifiesArg(vmint iArg) const OVERRIDE { return false; }
151 protected:
152 VMRealResult result;
153 };
154
155 /**
156 * Abstract base class for built-in script functions which return a string as
157 * their function return value.
158 */
159 class VMStringResultFunction : public VMFunction {
160 protected:
161 virtual ~VMStringResultFunction() {}
162 ExprType_t returnType(VMFnArgs* args) OVERRIDE { return STRING_EXPR; }
163 VMFnResult* errorResult(const String& s = "");
164 VMFnResult* successResult(const String& s = "");
165 bool modifiesArg(vmint iArg) const OVERRIDE { return false; }
166 protected:
167 VMStringResult result;
168 };
169
170 /**
171 * Abstract base class for built-in script functions which either return an
172 * integer or a real number (floating point scalar) as their function return
173 * value. The actual return type is determined at parse time once after
174 * potential arguments were associated with the respective function call.
175 */
176 class VMNumberResultFunction : public VMFunction {
177 protected:
178 virtual ~VMNumberResultFunction() {}
179 VMFnResult* errorResult(vmint i);
180 VMFnResult* errorResult(vmfloat f);
181 VMFnResult* successResult(vmint i);
182 VMFnResult* successResult(vmfloat f);
183 VMFnResult* errorIntResult(VMIntFnResDef res);
184 VMFnResult* errorRealResult(VMRealFnResDef res);
185 VMFnResult* successIntResult(VMIntFnResDef res);
186 VMFnResult* successRealResult(VMRealFnResDef res);
187 bool modifiesArg(vmint iArg) const OVERRIDE { return false; }
188 protected:
189 VMIntResult intResult;
190 VMRealResult realResult;
191 };
192
193
194 ///////////////////////////////////////////////////////////////////////////
195 // implementations of core built-in script functions ...
196
197 /**
198 * Implements the built-in message() script function.
199 */
200 class CoreVMFunction_message FINAL : public VMEmptyResultFunction {
201 public:
202 vmint minRequiredArgs() const OVERRIDE { return 1; }
203 vmint maxAllowedArgs() const OVERRIDE { return 1; }
204 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
205 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
206 };
207
208 /**
209 * Implements the built-in exit() script function.
210 */
211 class CoreVMFunction_exit FINAL : public VMEmptyResultFunction {
212 public:
213 CoreVMFunction_exit(ScriptVM* vm) : vm(vm) {}
214 vmint minRequiredArgs() const OVERRIDE { return 0; }
215 vmint maxAllowedArgs() const OVERRIDE;
216 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
217 bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE;
218 bool acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const OVERRIDE;
219 bool acceptsArgFinal(vmint iArg) const OVERRIDE;
220 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
221 protected:
222 ScriptVM* vm;
223 };
224
225 /**
226 * Implements the built-in wait() script function.
227 */
228 class CoreVMFunction_wait : public VMEmptyResultFunction {
229 public:
230 CoreVMFunction_wait(ScriptVM* vm) : vm(vm) {}
231 vmint minRequiredArgs() const OVERRIDE { return 1; }
232 vmint maxAllowedArgs() const OVERRIDE { return 1; }
233 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
234 bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE;
235 bool acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const OVERRIDE;
236 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
237 protected:
238 ScriptVM* vm;
239 };
240
241 /**
242 * Implements the built-in abs() script function.
243 */
244 class CoreVMFunction_abs FINAL : public VMNumberResultFunction {
245 public:
246 ExprType_t returnType(VMFnArgs* args) OVERRIDE;
247 StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE;
248 bool returnsFinal(VMFnArgs* args) OVERRIDE;
249 vmint minRequiredArgs() const OVERRIDE { return 1; }
250 vmint maxAllowedArgs() const OVERRIDE { return 1; }
251 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
252 bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE { return true; }
253 bool acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const OVERRIDE { return true; }
254 bool acceptsArgFinal(vmint iArg) const OVERRIDE { return true; }
255 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
256 };
257
258 /**
259 * Implements the built-in random() script function.
260 */
261 class CoreVMFunction_random FINAL : public VMNumberResultFunction {
262 using Super = VMNumberResultFunction; // just an alias for the super class
263 public:
264 ExprType_t returnType(VMFnArgs* args) OVERRIDE;
265 StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE;
266 bool returnsFinal(VMFnArgs* args) OVERRIDE;
267 vmint minRequiredArgs() const OVERRIDE { return 2; }
268 vmint maxAllowedArgs() const OVERRIDE { return 2; }
269 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
270 bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE { return true; }
271 bool acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const OVERRIDE { return true; }
272 bool acceptsArgFinal(vmint iArg) const OVERRIDE { return true; }
273 void checkArgs(VMFnArgs* args, std::function<void(String)> err,
274 std::function<void(String)> wrn) OVERRIDE;
275 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
276 };
277
278 /**
279 * Implements the built-in num_elements() script function.
280 */
281 class CoreVMFunction_num_elements FINAL : public VMIntResultFunction {
282 public:
283 StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE { return VM_NO_UNIT; }
284 bool returnsFinal(VMFnArgs* args) OVERRIDE { return false; }
285 vmint minRequiredArgs() const OVERRIDE { return 1; }
286 vmint maxAllowedArgs() const OVERRIDE { return 1; }
287 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
288 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
289 };
290
291 /**
292 * Implements the built-in inc() script function.
293 */
294 class CoreVMFunction_inc FINAL : public VMIntResultFunction {
295 using Super = VMIntResultFunction; // just an alias for the super class
296 public:
297 StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE;
298 bool returnsFinal(VMFnArgs* args) OVERRIDE;
299 vmint minRequiredArgs() const OVERRIDE { return 1; }
300 vmint maxAllowedArgs() const OVERRIDE { return 1; }
301 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR; }
302 bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE { return true; }
303 bool acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const OVERRIDE { return true; }
304 bool acceptsArgFinal(vmint iArg) const OVERRIDE { return true; }
305 bool modifiesArg(vmint iArg) const OVERRIDE { return true; }
306 void checkArgs(VMFnArgs* args, std::function<void(String)> err,
307 std::function<void(String)> wrn) OVERRIDE;
308 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
309 };
310
311 /**
312 * Implements the built-in dec() script function.
313 */
314 class CoreVMFunction_dec FINAL : public VMIntResultFunction {
315 using Super = VMIntResultFunction; // just an alias for the super class
316 public:
317 StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE;
318 bool returnsFinal(VMFnArgs* args) OVERRIDE;
319 vmint minRequiredArgs() const OVERRIDE { return 1; }
320 vmint maxAllowedArgs() const OVERRIDE { return 1; }
321 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR; }
322 bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE { return true; }
323 bool acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const OVERRIDE { return true; }
324 bool acceptsArgFinal(vmint iArg) const OVERRIDE { return true; }
325 bool modifiesArg(vmint iArg) const OVERRIDE { return true; }
326 void checkArgs(VMFnArgs* args, std::function<void(String)> err,
327 std::function<void(String)> wrn) OVERRIDE;
328 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
329 };
330
331 /**
332 * Implements the built-in in_range() script function.
333 */
334 class CoreVMFunction_in_range FINAL : public VMIntResultFunction {
335 using Super = VMIntResultFunction; // just an alias for the super class
336 public:
337 StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE { return VM_NO_UNIT; }
338 bool returnsFinal(VMFnArgs* args) OVERRIDE { return false; }
339 vmint minRequiredArgs() const OVERRIDE { return 3; }
340 vmint maxAllowedArgs() const OVERRIDE { return 3; }
341 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
342 bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE { return true; }
343 bool acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const OVERRIDE { return true; }
344 bool acceptsArgFinal(vmint iArg) const OVERRIDE { return true; }
345 void checkArgs(VMFnArgs* args, std::function<void(String)> err,
346 std::function<void(String)> wrn) OVERRIDE;
347 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
348 };
349
350 /**
351 * Implements the built-in sh_left() script function.
352 */
353 class CoreVMFunction_sh_left FINAL : public VMIntResultFunction {
354 public:
355 StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE { return VM_NO_UNIT; }
356 bool returnsFinal(VMFnArgs* args) OVERRIDE;
357 vmint minRequiredArgs() const OVERRIDE { return 2; }
358 vmint maxAllowedArgs() const OVERRIDE { return 2; }
359 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR; }
360 bool acceptsArgFinal(vmint iArg) const OVERRIDE { return true; }
361 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
362 };
363
364 /**
365 * Implements the built-in sh_right() script function.
366 */
367 class CoreVMFunction_sh_right FINAL : public VMIntResultFunction {
368 public:
369 StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE { return VM_NO_UNIT; }
370 bool returnsFinal(VMFnArgs* args) OVERRIDE;
371 vmint minRequiredArgs() const OVERRIDE { return 2; }
372 vmint maxAllowedArgs() const OVERRIDE { return 2; }
373 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR; }
374 bool acceptsArgFinal(vmint iArg) const OVERRIDE { return true; }
375 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
376 };
377
378 /**
379 * Implements the built-in msb() script function.
380 */
381 class CoreVMFunction_msb FINAL : public VMIntResultFunction {
382 public:
383 StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE { return VM_NO_UNIT; }
384 bool returnsFinal(VMFnArgs* args) OVERRIDE { return false; }
385 vmint minRequiredArgs() const OVERRIDE { return 1; }
386 vmint maxAllowedArgs() const OVERRIDE { return 1; }
387 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR; }
388 bool acceptsArgFinal(vmint iArg) const OVERRIDE { return false; }
389 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
390 };
391
392 /**
393 * Implements the built-in lsb() script function.
394 */
395 class CoreVMFunction_lsb FINAL : public VMIntResultFunction {
396 public:
397 StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE { return VM_NO_UNIT; }
398 bool returnsFinal(VMFnArgs* args) OVERRIDE { return false; }
399 vmint minRequiredArgs() const OVERRIDE { return 1; }
400 vmint maxAllowedArgs() const OVERRIDE { return 1; }
401 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR; }
402 bool acceptsArgFinal(vmint iArg) const OVERRIDE { return false; }
403 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
404 };
405
406 /**
407 * Implements the built-in min() script function.
408 */
409 class CoreVMFunction_min FINAL : public VMNumberResultFunction {
410 using Super = VMNumberResultFunction; // just an alias for the super class
411 public:
412 ExprType_t returnType(VMFnArgs* args) OVERRIDE;
413 StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE;
414 bool returnsFinal(VMFnArgs* args) OVERRIDE;
415 vmint minRequiredArgs() const OVERRIDE { return 2; }
416 vmint maxAllowedArgs() const OVERRIDE { return 2; }
417 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
418 bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE { return true; }
419 bool acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const OVERRIDE { return true; }
420 bool acceptsArgFinal(vmint iArg) const OVERRIDE { return true; }
421 void checkArgs(VMFnArgs* args, std::function<void(String)> err,
422 std::function<void(String)> wrn) OVERRIDE;
423 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
424 };
425
426 /**
427 * Implements the built-in max() script function.
428 */
429 class CoreVMFunction_max FINAL : public VMNumberResultFunction {
430 using Super = VMNumberResultFunction; // just an alias for the super class
431 public:
432 ExprType_t returnType(VMFnArgs* args) OVERRIDE;
433 StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE;
434 bool returnsFinal(VMFnArgs* args) OVERRIDE;
435 vmint minRequiredArgs() const OVERRIDE { return 2; }
436 vmint maxAllowedArgs() const OVERRIDE { return 2; }
437 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
438 bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE { return true; }
439 bool acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const OVERRIDE { return true; }
440 bool acceptsArgFinal(vmint iArg) const OVERRIDE { return true; }
441 void checkArgs(VMFnArgs* args, std::function<void(String)> err,
442 std::function<void(String)> wrn) OVERRIDE;
443 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
444 };
445
446 /**
447 * Implements the built-in array_equal() script function.
448 */
449 class CoreVMFunction_array_equal FINAL : public VMIntResultFunction {
450 using Super = VMIntResultFunction; // just an alias for the super class
451 public:
452 StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE { return VM_NO_UNIT; }
453 bool returnsFinal(VMFnArgs* args) OVERRIDE { return false; }
454 vmint minRequiredArgs() const OVERRIDE { return 2; }
455 vmint maxAllowedArgs() const OVERRIDE { return 2; }
456 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
457 void checkArgs(VMFnArgs* args, std::function<void(String)> err,
458 std::function<void(String)> wrn) OVERRIDE;
459 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
460 };
461
462 /**
463 * Implements the built-in search() script function.
464 */
465 class CoreVMFunction_search FINAL : public VMIntResultFunction {
466 using Super = VMIntResultFunction; // just an alias for the super class
467 public:
468 StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE { return VM_NO_UNIT; }
469 bool returnsFinal(VMFnArgs* args) OVERRIDE { return false; }
470 vmint minRequiredArgs() const OVERRIDE { return 2; }
471 vmint maxAllowedArgs() const OVERRIDE { return 2; }
472 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
473 void checkArgs(VMFnArgs* args, std::function<void(String)> err,
474 std::function<void(String)> wrn) OVERRIDE;
475 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
476 };
477
478 /**
479 * Implements the built-in sort() script function.
480 */
481 class CoreVMFunction_sort FINAL : public VMEmptyResultFunction {
482 public:
483 vmint minRequiredArgs() const OVERRIDE { return 1; }
484 vmint maxAllowedArgs() const OVERRIDE { return 2; }
485 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
486 bool modifiesArg(vmint iArg) const OVERRIDE { return iArg == 0; }
487 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
488 };
489
490 /**
491 * Implements the built-in real_to_int() script function and its short hand
492 * variant int(). The behaviour of the two built-in script functions are
493 * identical ATM.
494 */
495 class CoreVMFunction_real_to_int FINAL : public VMIntResultFunction {
496 public:
497 StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE;
498 bool returnsFinal(VMFnArgs* args) OVERRIDE;
499 vmint minRequiredArgs() const OVERRIDE { return 1; }
500 vmint maxAllowedArgs() const OVERRIDE { return 1; }
501 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == REAL_EXPR; }
502 bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE { return true; }
503 bool acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const OVERRIDE { return true; }
504 bool acceptsArgFinal(vmint iArg) const OVERRIDE { return true; }
505 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
506 };
507
508 /**
509 * Implements the built-in int_to_real() script function and its short hand
510 * variant real(). The behaviour of the two built-in script functions are
511 * identical ATM.
512 */
513 class CoreVMFunction_int_to_real FINAL : public VMRealResultFunction {
514 public:
515 StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE;
516 bool returnsFinal(VMFnArgs* args) OVERRIDE;
517 vmint minRequiredArgs() const OVERRIDE { return 1; }
518 vmint maxAllowedArgs() const OVERRIDE { return 1; }
519 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR; }
520 bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE { return true; }
521 bool acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const OVERRIDE { return true; }
522 bool acceptsArgFinal(vmint iArg) const OVERRIDE { return true; }
523 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
524 };
525
526 /**
527 * Implements the built-in round() script function.
528 */
529 class CoreVMFunction_round FINAL : public VMRealResultFunction {
530 public:
531 StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE;
532 bool returnsFinal(VMFnArgs* args) OVERRIDE;
533 vmint minRequiredArgs() const OVERRIDE { return 1; }
534 vmint maxAllowedArgs() const OVERRIDE { return 1; }
535 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == REAL_EXPR; }
536 bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE { return true; }
537 bool acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const OVERRIDE { return true; }
538 bool acceptsArgFinal(vmint iArg) const OVERRIDE { return true; }
539 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
540 };
541
542 /**
543 * Implements the built-in ceil() script function.
544 */
545 class CoreVMFunction_ceil FINAL : public VMRealResultFunction {
546 public:
547 StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE;
548 bool returnsFinal(VMFnArgs* args) OVERRIDE;
549 vmint minRequiredArgs() const OVERRIDE { return 1; }
550 vmint maxAllowedArgs() const OVERRIDE { return 1; }
551 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == REAL_EXPR; }
552 bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE { return true; }
553 bool acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const OVERRIDE { return true; }
554 bool acceptsArgFinal(vmint iArg) const OVERRIDE { return true; }
555 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
556 };
557
558 /**
559 * Implements the built-in floor() script function.
560 */
561 class CoreVMFunction_floor FINAL : public VMRealResultFunction {
562 public:
563 StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE;
564 bool returnsFinal(VMFnArgs* args) OVERRIDE;
565 vmint minRequiredArgs() const OVERRIDE { return 1; }
566 vmint maxAllowedArgs() const OVERRIDE { return 1; }
567 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == REAL_EXPR; }
568 bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE { return true; }
569 bool acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const OVERRIDE { return true; }
570 bool acceptsArgFinal(vmint iArg) const OVERRIDE { return true; }
571 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
572 };
573
574 /**
575 * Implements the built-in sqrt() script function.
576 */
577 class CoreVMFunction_sqrt FINAL : public VMRealResultFunction {
578 public:
579 StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE;
580 bool returnsFinal(VMFnArgs* args) OVERRIDE;
581 vmint minRequiredArgs() const OVERRIDE { return 1; }
582 vmint maxAllowedArgs() const OVERRIDE { return 1; }
583 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == REAL_EXPR; }
584 bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE { return true; }
585 bool acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const OVERRIDE { return true; }
586 bool acceptsArgFinal(vmint iArg) const OVERRIDE { return true; }
587 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
588 };
589
590 /**
591 * Implements the built-in log() script function.
592 */
593 class CoreVMFunction_log FINAL : public VMRealResultFunction {
594 public:
595 StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE;
596 bool returnsFinal(VMFnArgs* args) OVERRIDE;
597 vmint minRequiredArgs() const OVERRIDE { return 1; }
598 vmint maxAllowedArgs() const OVERRIDE { return 1; }
599 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == REAL_EXPR; }
600 bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE { return true; }
601 bool acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const OVERRIDE { return true; }
602 bool acceptsArgFinal(vmint iArg) const OVERRIDE { return true; }
603 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
604 };
605
606 /**
607 * Implements the built-in log2() script function.
608 */
609 class CoreVMFunction_log2 FINAL : public VMRealResultFunction {
610 public:
611 StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE;
612 bool returnsFinal(VMFnArgs* args) OVERRIDE;
613 vmint minRequiredArgs() const OVERRIDE { return 1; }
614 vmint maxAllowedArgs() const OVERRIDE { return 1; }
615 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == REAL_EXPR; }
616 bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE { return true; }
617 bool acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const OVERRIDE { return true; }
618 bool acceptsArgFinal(vmint iArg) const OVERRIDE { return true; }
619 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
620 };
621
622 /**
623 * Implements the built-in log10() script function.
624 */
625 class CoreVMFunction_log10 FINAL : public VMRealResultFunction {
626 public:
627 StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE;
628 bool returnsFinal(VMFnArgs* args) OVERRIDE;
629 vmint minRequiredArgs() const OVERRIDE { return 1; }
630 vmint maxAllowedArgs() const OVERRIDE { return 1; }
631 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == REAL_EXPR; }
632 bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE { return true; }
633 bool acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const OVERRIDE { return true; }
634 bool acceptsArgFinal(vmint iArg) const OVERRIDE { return true; }
635 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
636 };
637
638 /**
639 * Implements the built-in exp() script function.
640 */
641 class CoreVMFunction_exp FINAL : public VMRealResultFunction {
642 public:
643 StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE;
644 bool returnsFinal(VMFnArgs* args) OVERRIDE;
645 vmint minRequiredArgs() const OVERRIDE { return 1; }
646 vmint maxAllowedArgs() const OVERRIDE { return 1; }
647 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == REAL_EXPR; }
648 bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE { return true; }
649 bool acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const OVERRIDE { return true; }
650 bool acceptsArgFinal(vmint iArg) const OVERRIDE { return true; }
651 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
652 };
653
654 /**
655 * Implements the built-in pow() script function.
656 */
657 class CoreVMFunction_pow FINAL : public VMRealResultFunction {
658 using Super = VMRealResultFunction; // just an alias for the super class
659 public:
660 StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE;
661 bool returnsFinal(VMFnArgs* args) OVERRIDE;
662 vmint minRequiredArgs() const OVERRIDE { return 2; }
663 vmint maxAllowedArgs() const OVERRIDE { return 2; }
664 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == REAL_EXPR; }
665 bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE;
666 bool acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const OVERRIDE;
667 bool acceptsArgFinal(vmint iArg) const OVERRIDE { return iArg == 0; }
668 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
669 };
670
671 /**
672 * Implements the built-in sin() script function.
673 */
674 class CoreVMFunction_sin FINAL : public VMRealResultFunction {
675 public:
676 StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE;
677 bool returnsFinal(VMFnArgs* args) OVERRIDE;
678 vmint minRequiredArgs() const OVERRIDE { return 1; }
679 vmint maxAllowedArgs() const OVERRIDE { return 1; }
680 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == REAL_EXPR; }
681 bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE { return true; }
682 bool acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const OVERRIDE { return true; }
683 bool acceptsArgFinal(vmint iArg) const OVERRIDE { return true; }
684 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
685 };
686
687 /**
688 * Implements the built-in cos() script function.
689 */
690 class CoreVMFunction_cos FINAL : public VMRealResultFunction {
691 public:
692 StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE;
693 bool returnsFinal(VMFnArgs* args) OVERRIDE;
694 vmint minRequiredArgs() const OVERRIDE { return 1; }
695 vmint maxAllowedArgs() const OVERRIDE { return 1; }
696 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == REAL_EXPR; }
697 bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE { return true; }
698 bool acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const OVERRIDE { return true; }
699 bool acceptsArgFinal(vmint iArg) const OVERRIDE { return true; }
700 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
701 };
702
703 /**
704 * Implements the built-in tan() script function.
705 */
706 class CoreVMFunction_tan FINAL : public VMRealResultFunction {
707 public:
708 StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE;
709 bool returnsFinal(VMFnArgs* args) OVERRIDE;
710 vmint minRequiredArgs() const OVERRIDE { return 1; }
711 vmint maxAllowedArgs() const OVERRIDE { return 1; }
712 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == REAL_EXPR; }
713 bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE { return true; }
714 bool acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const OVERRIDE { return true; }
715 bool acceptsArgFinal(vmint iArg) const OVERRIDE { return true; }
716 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
717 };
718
719 /**
720 * Implements the built-in asin() script function.
721 */
722 class CoreVMFunction_asin FINAL : public VMRealResultFunction {
723 public:
724 StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE;
725 bool returnsFinal(VMFnArgs* args) OVERRIDE;
726 vmint minRequiredArgs() const OVERRIDE { return 1; }
727 vmint maxAllowedArgs() const OVERRIDE { return 1; }
728 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == REAL_EXPR; }
729 bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE { return true; }
730 bool acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const OVERRIDE { return true; }
731 bool acceptsArgFinal(vmint iArg) const OVERRIDE { return true; }
732 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
733 };
734
735 /**
736 * Implements the built-in acos() script function.
737 */
738 class CoreVMFunction_acos FINAL : public VMRealResultFunction {
739 public:
740 StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE;
741 bool returnsFinal(VMFnArgs* args) OVERRIDE;
742 vmint minRequiredArgs() const OVERRIDE { return 1; }
743 vmint maxAllowedArgs() const OVERRIDE { return 1; }
744 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == REAL_EXPR; }
745 bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE { return true; }
746 bool acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const OVERRIDE { return true; }
747 bool acceptsArgFinal(vmint iArg) const OVERRIDE { return true; }
748 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
749 };
750
751 /**
752 * Implements the built-in atan() script function.
753 */
754 class CoreVMFunction_atan FINAL : public VMRealResultFunction {
755 public:
756 StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE;
757 bool returnsFinal(VMFnArgs* args) OVERRIDE;
758 vmint minRequiredArgs() const OVERRIDE { return 1; }
759 vmint maxAllowedArgs() const OVERRIDE { return 1; }
760 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == REAL_EXPR; }
761 bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE { return true; }
762 bool acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const OVERRIDE { return true; }
763 bool acceptsArgFinal(vmint iArg) const OVERRIDE { return true; }
764 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
765 };
766
767 } // namespace LinuxSampler
768
769 #endif // LS_COREVMFUNCTIONS_H
  ViewVC Help
Powered by ViewVC