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

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

Parent Directory Parent Directory | Revision Log Revision Log

Revision 3678 - (hide annotations) (download) (as text)
Fri Dec 27 22:46:08 2019 UTC (4 years, 4 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 schoenebeck 2581 /*
2 schoenebeck 3551 * Copyright (c) 2014-2019 Christian Schoenebeck
3 schoenebeck 2581 *
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 schoenebeck 2727
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 schoenebeck 3581 class VMEmptyResult FINAL : public VMFnResult, public VMExpr {
28 schoenebeck 2581 public:
29 schoenebeck 2727 StmtFlags_t flags; ///< general completion status (i.e. success or failure) of the function call
30 schoenebeck 2581
31     VMEmptyResult() : flags(STMT_SUCCESS) {}
32 schoenebeck 3054 ExprType_t exprType() const OVERRIDE { return EMPTY_EXPR; }
33     VMExpr* resultValue() OVERRIDE { return this; }
34     StmtFlags_t resultFlags() OVERRIDE { return flags; }
35 schoenebeck 2945 bool isConstExpr() const OVERRIDE { return false; }
36 schoenebeck 2581 };
37    
38 schoenebeck 2727 /**
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 schoenebeck 3581 class VMIntResult FINAL : public VMFnResult, public VMIntExpr {
43 schoenebeck 2598 public:
44 schoenebeck 2727 StmtFlags_t flags; ///< general completion status (i.e. success or failure) of the function call
45 schoenebeck 3557 vmint value; ///< result value of the function call
46 schoenebeck 3581 vmfloat unitPrefixFactor; ///< unit factor of result value of the function call
47 schoenebeck 2598
48 schoenebeck 3581 VMIntResult() : flags(STMT_SUCCESS), value(0), unitPrefixFactor(VM_NO_FACTOR) {}
49 schoenebeck 3557 vmint evalInt() OVERRIDE { return value; }
50 schoenebeck 3054 VMExpr* resultValue() OVERRIDE { return this; }
51     StmtFlags_t resultFlags() OVERRIDE { return flags; }
52 schoenebeck 2945 bool isConstExpr() const OVERRIDE { return false; }
53 schoenebeck 3581 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 schoenebeck 2598 };
57    
58 schoenebeck 2727 /**
59     * An instance of this class is returned by built-in function implementations
60 schoenebeck 3573 * which return a real number (floating point) value as function return value.
61     */
62 schoenebeck 3581 class VMRealResult FINAL : public VMFnResult, public VMRealExpr {
63 schoenebeck 3573 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 schoenebeck 3581 vmfloat unitPrefixFactor; ///< unit factor of result value of the function call
67 schoenebeck 3573
68 schoenebeck 3581 VMRealResult() : flags(STMT_SUCCESS), value(0), unitPrefixFactor(VM_NO_FACTOR) {}
69 schoenebeck 3573 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 schoenebeck 3581 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 schoenebeck 3573 };
77    
78     /**
79     * An instance of this class is returned by built-in function implementations
80 schoenebeck 2727 * which return a string value as function return value.
81     */
82 schoenebeck 3581 class VMStringResult FINAL : public VMFnResult, public VMStringExpr {
83 schoenebeck 2581 public:
84 schoenebeck 2727 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 schoenebeck 2581
87     VMStringResult() : flags(STMT_SUCCESS) {}
88 schoenebeck 3054 String evalStr() OVERRIDE { return value; }
89     VMExpr* resultValue() OVERRIDE { return this; }
90     StmtFlags_t resultFlags() OVERRIDE { return flags; }
91 schoenebeck 2945 bool isConstExpr() const OVERRIDE { return false; }
92 schoenebeck 2581 };
93    
94 schoenebeck 2727 /**
95     * Abstract base class for built-in script functions which do not return any
96     * function return value (void).
97     */
98 schoenebeck 2581 class VMEmptyResultFunction : public VMFunction {
99     protected:
100 schoenebeck 3034 virtual ~VMEmptyResultFunction() {}
101 schoenebeck 3577 ExprType_t returnType(VMFnArgs* args) OVERRIDE { return EMPTY_EXPR; }
102 schoenebeck 3581 StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE { return VM_NO_UNIT; }
103     bool returnsFinal(VMFnArgs* args) OVERRIDE { return false; }
104 schoenebeck 2581 VMFnResult* errorResult();
105     VMFnResult* successResult();
106 schoenebeck 3557 bool modifiesArg(vmint iArg) const OVERRIDE { return false; }
107 schoenebeck 2581 protected:
108     VMEmptyResult result;
109     };
110    
111 schoenebeck 3581 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 schoenebeck 2727 /**
122     * Abstract base class for built-in script functions which return an integer
123     * (scalar) as their function return value.
124     */
125 schoenebeck 2598 class VMIntResultFunction : public VMFunction {
126     protected:
127 schoenebeck 3034 virtual ~VMIntResultFunction() {}
128 schoenebeck 3577 ExprType_t returnType(VMFnArgs* args) OVERRIDE { return INT_EXPR; }
129 schoenebeck 3557 VMFnResult* errorResult(vmint i = 0);
130 schoenebeck 3581 VMFnResult* errorResult(VMIntFnResDef res);
131 schoenebeck 3557 VMFnResult* successResult(vmint i = 0);
132 schoenebeck 3581 VMFnResult* successResult(VMIntFnResDef res);
133 schoenebeck 3557 bool modifiesArg(vmint iArg) const OVERRIDE { return false; }
134 schoenebeck 2598 protected:
135     VMIntResult result;
136     };
137    
138 schoenebeck 2727 /**
139 schoenebeck 3573 * 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 schoenebeck 3577 ExprType_t returnType(VMFnArgs* args) OVERRIDE { return REAL_EXPR; }
146 schoenebeck 3573 VMFnResult* errorResult(vmfloat f = 0);
147 schoenebeck 3581 VMFnResult* errorResult(VMRealFnResDef res);
148 schoenebeck 3573 VMFnResult* successResult(vmfloat f = 0);
149 schoenebeck 3581 VMFnResult* successResult(VMRealFnResDef res);
150 schoenebeck 3573 bool modifiesArg(vmint iArg) const OVERRIDE { return false; }
151     protected:
152     VMRealResult result;
153     };
154    
155     /**
156 schoenebeck 2727 * Abstract base class for built-in script functions which return a string as
157     * their function return value.
158     */
159 schoenebeck 2581 class VMStringResultFunction : public VMFunction {
160     protected:
161 schoenebeck 3034 virtual ~VMStringResultFunction() {}
162 schoenebeck 3577 ExprType_t returnType(VMFnArgs* args) OVERRIDE { return STRING_EXPR; }
163 schoenebeck 2581 VMFnResult* errorResult(const String& s = "");
164     VMFnResult* successResult(const String& s = "");
165 schoenebeck 3557 bool modifiesArg(vmint iArg) const OVERRIDE { return false; }
166 schoenebeck 2581 protected:
167     VMStringResult result;
168     };
169    
170 schoenebeck 3577 /**
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 schoenebeck 3582 class VMNumberResultFunction : public VMFunction {
177 schoenebeck 3577 protected:
178 schoenebeck 3582 virtual ~VMNumberResultFunction() {}
179 schoenebeck 3577 VMFnResult* errorResult(vmint i);
180     VMFnResult* errorResult(vmfloat f);
181     VMFnResult* successResult(vmint i);
182     VMFnResult* successResult(vmfloat f);
183 schoenebeck 3581 VMFnResult* errorIntResult(VMIntFnResDef res);
184     VMFnResult* errorRealResult(VMRealFnResDef res);
185     VMFnResult* successIntResult(VMIntFnResDef res);
186     VMFnResult* successRealResult(VMRealFnResDef res);
187 schoenebeck 3577 bool modifiesArg(vmint iArg) const OVERRIDE { return false; }
188     protected:
189     VMIntResult intResult;
190     VMRealResult realResult;
191     };
192 schoenebeck 2727
193 schoenebeck 3577
194 schoenebeck 2727 ///////////////////////////////////////////////////////////////////////////
195     // implementations of core built-in script functions ...
196    
197     /**
198     * Implements the built-in message() script function.
199     */
200 schoenebeck 3581 class CoreVMFunction_message FINAL : public VMEmptyResultFunction {
201 schoenebeck 2581 public:
202 schoenebeck 3557 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 schoenebeck 2581 };
207    
208 schoenebeck 2727 /**
209     * Implements the built-in exit() script function.
210     */
211 schoenebeck 3581 class CoreVMFunction_exit FINAL : public VMEmptyResultFunction {
212 schoenebeck 2581 public:
213 schoenebeck 3551 CoreVMFunction_exit(ScriptVM* vm) : vm(vm) {}
214 schoenebeck 3557 vmint minRequiredArgs() const OVERRIDE { return 0; }
215     vmint maxAllowedArgs() const OVERRIDE;
216     bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
217 schoenebeck 3581 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 schoenebeck 3557 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
221 schoenebeck 3551 protected:
222     ScriptVM* vm;
223 schoenebeck 2581 };
224    
225 schoenebeck 2727 /**
226     * Implements the built-in wait() script function.
227     */
228 schoenebeck 2581 class CoreVMFunction_wait : public VMEmptyResultFunction {
229     public:
230     CoreVMFunction_wait(ScriptVM* vm) : vm(vm) {}
231 schoenebeck 3557 vmint minRequiredArgs() const OVERRIDE { return 1; }
232     vmint maxAllowedArgs() const OVERRIDE { return 1; }
233 schoenebeck 3584 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
234 schoenebeck 3561 bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE;
235 schoenebeck 3564 bool acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const OVERRIDE;
236 schoenebeck 3557 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
237 schoenebeck 2581 protected:
238     ScriptVM* vm;
239     };
240    
241 schoenebeck 2727 /**
242     * Implements the built-in abs() script function.
243     */
244 schoenebeck 3582 class CoreVMFunction_abs FINAL : public VMNumberResultFunction {
245 schoenebeck 2619 public:
246 schoenebeck 3577 ExprType_t returnType(VMFnArgs* args) OVERRIDE;
247 schoenebeck 3581 StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE;
248     bool returnsFinal(VMFnArgs* args) OVERRIDE;
249 schoenebeck 3557 vmint minRequiredArgs() const OVERRIDE { return 1; }
250     vmint maxAllowedArgs() const OVERRIDE { return 1; }
251     bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
252 schoenebeck 3581 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 schoenebeck 3557 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
256 schoenebeck 2619 };
257    
258 schoenebeck 2727 /**
259     * Implements the built-in random() script function.
260     */
261 schoenebeck 3582 class CoreVMFunction_random FINAL : public VMNumberResultFunction {
262     using Super = VMNumberResultFunction; // just an alias for the super class
263 schoenebeck 2619 public:
264 schoenebeck 3581 ExprType_t returnType(VMFnArgs* args) OVERRIDE;
265     StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE;
266     bool returnsFinal(VMFnArgs* args) OVERRIDE;
267 schoenebeck 3557 vmint minRequiredArgs() const OVERRIDE { return 2; }
268     vmint maxAllowedArgs() const OVERRIDE { return 2; }
269     bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
270 schoenebeck 3581 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 schoenebeck 3557 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
276 schoenebeck 2619 };
277    
278 schoenebeck 2727 /**
279     * Implements the built-in num_elements() script function.
280     */
281 schoenebeck 3581 class CoreVMFunction_num_elements FINAL : public VMIntResultFunction {
282 schoenebeck 2619 public:
283 schoenebeck 3581 StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE { return VM_NO_UNIT; }
284     bool returnsFinal(VMFnArgs* args) OVERRIDE { return false; }
285 schoenebeck 3557 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 schoenebeck 2619 };
290    
291 schoenebeck 2945 /**
292     * Implements the built-in inc() script function.
293     */
294 schoenebeck 3581 class CoreVMFunction_inc FINAL : public VMIntResultFunction {
295     using Super = VMIntResultFunction; // just an alias for the super class
296 schoenebeck 2945 public:
297 schoenebeck 3581 StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE;
298     bool returnsFinal(VMFnArgs* args) OVERRIDE;
299 schoenebeck 3557 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 schoenebeck 3581 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 schoenebeck 3557 bool modifiesArg(vmint iArg) const OVERRIDE { return true; }
306 schoenebeck 3581 void checkArgs(VMFnArgs* args, std::function<void(String)> err,
307     std::function<void(String)> wrn) OVERRIDE;
308 schoenebeck 3557 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
309 schoenebeck 2945 };
310    
311     /**
312     * Implements the built-in dec() script function.
313     */
314 schoenebeck 3581 class CoreVMFunction_dec FINAL : public VMIntResultFunction {
315     using Super = VMIntResultFunction; // just an alias for the super class
316 schoenebeck 2945 public:
317 schoenebeck 3581 StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE;
318     bool returnsFinal(VMFnArgs* args) OVERRIDE;
319 schoenebeck 3557 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 schoenebeck 3581 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 schoenebeck 3557 bool modifiesArg(vmint iArg) const OVERRIDE { return true; }
326 schoenebeck 3581 void checkArgs(VMFnArgs* args, std::function<void(String)> err,
327     std::function<void(String)> wrn) OVERRIDE;
328 schoenebeck 3557 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
329 schoenebeck 2945 };
330    
331 schoenebeck 2965 /**
332 schoenebeck 3076 * Implements the built-in in_range() script function.
333     */
334 schoenebeck 3581 class CoreVMFunction_in_range FINAL : public VMIntResultFunction {
335     using Super = VMIntResultFunction; // just an alias for the super class
336 schoenebeck 3076 public:
337 schoenebeck 3581 StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE { return VM_NO_UNIT; }
338     bool returnsFinal(VMFnArgs* args) OVERRIDE { return false; }
339 schoenebeck 3557 vmint minRequiredArgs() const OVERRIDE { return 3; }
340     vmint maxAllowedArgs() const OVERRIDE { return 3; }
341 schoenebeck 3581 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 schoenebeck 3557 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
348 schoenebeck 3076 };
349    
350     /**
351 schoenebeck 2965 * Implements the built-in sh_left() script function.
352     */
353 schoenebeck 3581 class CoreVMFunction_sh_left FINAL : public VMIntResultFunction {
354 schoenebeck 2965 public:
355 schoenebeck 3581 StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE { return VM_NO_UNIT; }
356     bool returnsFinal(VMFnArgs* args) OVERRIDE;
357 schoenebeck 3557 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 schoenebeck 3581 bool acceptsArgFinal(vmint iArg) const OVERRIDE { return true; }
361 schoenebeck 3557 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
362 schoenebeck 2965 };
363    
364     /**
365     * Implements the built-in sh_right() script function.
366     */
367 schoenebeck 3581 class CoreVMFunction_sh_right FINAL : public VMIntResultFunction {
368 schoenebeck 2965 public:
369 schoenebeck 3581 StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE { return VM_NO_UNIT; }
370     bool returnsFinal(VMFnArgs* args) OVERRIDE;
371 schoenebeck 3557 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 schoenebeck 3581 bool acceptsArgFinal(vmint iArg) const OVERRIDE { return true; }
375 schoenebeck 3557 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
376 schoenebeck 2965 };
377    
378 schoenebeck 2970 /**
379 schoenebeck 3678 * 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 schoenebeck 2970 * Implements the built-in min() script function.
408     */
409 schoenebeck 3582 class CoreVMFunction_min FINAL : public VMNumberResultFunction {
410     using Super = VMNumberResultFunction; // just an alias for the super class
411 schoenebeck 2970 public:
412 schoenebeck 3577 ExprType_t returnType(VMFnArgs* args) OVERRIDE;
413 schoenebeck 3581 StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE;
414     bool returnsFinal(VMFnArgs* args) OVERRIDE;
415 schoenebeck 3557 vmint minRequiredArgs() const OVERRIDE { return 2; }
416     vmint maxAllowedArgs() const OVERRIDE { return 2; }
417 schoenebeck 3577 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
418 schoenebeck 3581 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 schoenebeck 3557 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
424 schoenebeck 2970 };
425    
426     /**
427     * Implements the built-in max() script function.
428     */
429 schoenebeck 3582 class CoreVMFunction_max FINAL : public VMNumberResultFunction {
430     using Super = VMNumberResultFunction; // just an alias for the super class
431 schoenebeck 2970 public:
432 schoenebeck 3577 ExprType_t returnType(VMFnArgs* args) OVERRIDE;
433 schoenebeck 3581 StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE;
434     bool returnsFinal(VMFnArgs* args) OVERRIDE;
435 schoenebeck 3557 vmint minRequiredArgs() const OVERRIDE { return 2; }
436     vmint maxAllowedArgs() const OVERRIDE { return 2; }
437 schoenebeck 3577 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
438 schoenebeck 3581 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 schoenebeck 3557 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
444 schoenebeck 2970 };
445    
446 schoenebeck 3221 /**
447     * Implements the built-in array_equal() script function.
448     */
449 schoenebeck 3581 class CoreVMFunction_array_equal FINAL : public VMIntResultFunction {
450     using Super = VMIntResultFunction; // just an alias for the super class
451 schoenebeck 3221 public:
452 schoenebeck 3581 StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE { return VM_NO_UNIT; }
453     bool returnsFinal(VMFnArgs* args) OVERRIDE { return false; }
454 schoenebeck 3557 vmint minRequiredArgs() const OVERRIDE { return 2; }
455     vmint maxAllowedArgs() const OVERRIDE { return 2; }
456 schoenebeck 3581 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 schoenebeck 3557 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
460 schoenebeck 3221 };
461    
462     /**
463     * Implements the built-in search() script function.
464     */
465 schoenebeck 3581 class CoreVMFunction_search FINAL : public VMIntResultFunction {
466     using Super = VMIntResultFunction; // just an alias for the super class
467 schoenebeck 3221 public:
468 schoenebeck 3581 StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE { return VM_NO_UNIT; }
469     bool returnsFinal(VMFnArgs* args) OVERRIDE { return false; }
470 schoenebeck 3557 vmint minRequiredArgs() const OVERRIDE { return 2; }
471     vmint maxAllowedArgs() const OVERRIDE { return 2; }
472     bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
473 schoenebeck 3581 void checkArgs(VMFnArgs* args, std::function<void(String)> err,
474     std::function<void(String)> wrn) OVERRIDE;
475 schoenebeck 3557 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
476 schoenebeck 3221 };
477    
478     /**
479     * Implements the built-in sort() script function.
480     */
481 schoenebeck 3581 class CoreVMFunction_sort FINAL : public VMEmptyResultFunction {
482 schoenebeck 3221 public:
483 schoenebeck 3557 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 schoenebeck 3221 };
489    
490 schoenebeck 3573 /**
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 schoenebeck 3581 class CoreVMFunction_real_to_int FINAL : public VMIntResultFunction {
496 schoenebeck 3573 public:
497 schoenebeck 3581 StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE;
498     bool returnsFinal(VMFnArgs* args) OVERRIDE;
499 schoenebeck 3573 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 schoenebeck 3581 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 schoenebeck 3573 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 schoenebeck 3581 class CoreVMFunction_int_to_real FINAL : public VMRealResultFunction {
514 schoenebeck 3573 public:
515 schoenebeck 3581 StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE;
516     bool returnsFinal(VMFnArgs* args) OVERRIDE;
517 schoenebeck 3573 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 schoenebeck 3581 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 schoenebeck 3573 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
524     };
525    
526 schoenebeck 3590 /**
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 schoenebeck 2581 } // namespace LinuxSampler
768    
769     #endif // LS_COREVMFUNCTIONS_H
  ViewVC Help
Powered by ViewVC