/[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 3585 - (hide annotations) (download) (as text)
Fri Aug 30 17:51:24 2019 UTC (4 years, 8 months ago) by schoenebeck
File MIME type: text/x-c++hdr
File size: 21740 byte(s) 
NKSP: Cleanup regarding multiple data types for built-in function args.

* NKSP VM API cleanup: Get rid of legacy method
  VMFunction::argType(vmint iArg) which was already superseded by its new
  replacement VMFunction::acceptsArgType(vmint iArg, ExprType_t type).

* NKSP parser: if wrong argument type was passed to a built-in function and
  that built-in function accepts more than one data type for the argument,
  then show all supported data types as parser error message.

* Bumped version (2.1.1.svn10).
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     * Implements the built-in min() script function.
380     */
381 schoenebeck 3582 class CoreVMFunction_min FINAL : public VMNumberResultFunction {
382     using Super = VMNumberResultFunction; // just an alias for the super class
383 schoenebeck 2970 public:
384 schoenebeck 3577 ExprType_t returnType(VMFnArgs* args) OVERRIDE;
385 schoenebeck 3581 StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE;
386     bool returnsFinal(VMFnArgs* args) OVERRIDE;
387 schoenebeck 3557 vmint minRequiredArgs() const OVERRIDE { return 2; }
388     vmint maxAllowedArgs() const OVERRIDE { return 2; }
389 schoenebeck 3577 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
390 schoenebeck 3581 bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE { return true; }
391     bool acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const OVERRIDE { return true; }
392     bool acceptsArgFinal(vmint iArg) const OVERRIDE { return true; }
393     void checkArgs(VMFnArgs* args, std::function<void(String)> err,
394     std::function<void(String)> wrn) OVERRIDE;
395 schoenebeck 3557 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
396 schoenebeck 2970 };
397    
398     /**
399     * Implements the built-in max() script function.
400     */
401 schoenebeck 3582 class CoreVMFunction_max FINAL : public VMNumberResultFunction {
402     using Super = VMNumberResultFunction; // just an alias for the super class
403 schoenebeck 2970 public:
404 schoenebeck 3577 ExprType_t returnType(VMFnArgs* args) OVERRIDE;
405 schoenebeck 3581 StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE;
406     bool returnsFinal(VMFnArgs* args) OVERRIDE;
407 schoenebeck 3557 vmint minRequiredArgs() const OVERRIDE { return 2; }
408     vmint maxAllowedArgs() const OVERRIDE { return 2; }
409 schoenebeck 3577 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
410 schoenebeck 3581 bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE { return true; }
411     bool acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const OVERRIDE { return true; }
412     bool acceptsArgFinal(vmint iArg) const OVERRIDE { return true; }
413     void checkArgs(VMFnArgs* args, std::function<void(String)> err,
414     std::function<void(String)> wrn) OVERRIDE;
415 schoenebeck 3557 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
416 schoenebeck 2970 };
417    
418 schoenebeck 3221 /**
419     * Implements the built-in array_equal() script function.
420     */
421 schoenebeck 3581 class CoreVMFunction_array_equal FINAL : public VMIntResultFunction {
422     using Super = VMIntResultFunction; // just an alias for the super class
423 schoenebeck 3221 public:
424 schoenebeck 3581 StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE { return VM_NO_UNIT; }
425     bool returnsFinal(VMFnArgs* args) OVERRIDE { return false; }
426 schoenebeck 3557 vmint minRequiredArgs() const OVERRIDE { return 2; }
427     vmint maxAllowedArgs() const OVERRIDE { return 2; }
428 schoenebeck 3581 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
429     void checkArgs(VMFnArgs* args, std::function<void(String)> err,
430     std::function<void(String)> wrn) OVERRIDE;
431 schoenebeck 3557 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
432 schoenebeck 3221 };
433    
434     /**
435     * Implements the built-in search() script function.
436     */
437 schoenebeck 3581 class CoreVMFunction_search FINAL : public VMIntResultFunction {
438     using Super = VMIntResultFunction; // just an alias for the super class
439 schoenebeck 3221 public:
440 schoenebeck 3581 StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE { return VM_NO_UNIT; }
441     bool returnsFinal(VMFnArgs* args) OVERRIDE { return false; }
442 schoenebeck 3557 vmint minRequiredArgs() const OVERRIDE { return 2; }
443     vmint maxAllowedArgs() const OVERRIDE { return 2; }
444     bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
445 schoenebeck 3581 void checkArgs(VMFnArgs* args, std::function<void(String)> err,
446     std::function<void(String)> wrn) OVERRIDE;
447 schoenebeck 3557 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
448 schoenebeck 3221 };
449    
450     /**
451     * Implements the built-in sort() script function.
452     */
453 schoenebeck 3581 class CoreVMFunction_sort FINAL : public VMEmptyResultFunction {
454 schoenebeck 3221 public:
455 schoenebeck 3557 vmint minRequiredArgs() const OVERRIDE { return 1; }
456     vmint maxAllowedArgs() const OVERRIDE { return 2; }
457     bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
458     bool modifiesArg(vmint iArg) const OVERRIDE { return iArg == 0; }
459     VMFnResult* exec(VMFnArgs* args) OVERRIDE;
460 schoenebeck 3221 };
461    
462 schoenebeck 3573 /**
463     * Implements the built-in real_to_int() script function and its short hand
464     * variant int(). The behaviour of the two built-in script functions are
465     * identical ATM.
466     */
467 schoenebeck 3581 class CoreVMFunction_real_to_int FINAL : public VMIntResultFunction {
468 schoenebeck 3573 public:
469 schoenebeck 3581 StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE;
470     bool returnsFinal(VMFnArgs* args) OVERRIDE;
471 schoenebeck 3573 vmint minRequiredArgs() const OVERRIDE { return 1; }
472     vmint maxAllowedArgs() const OVERRIDE { return 1; }
473     bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == REAL_EXPR; }
474 schoenebeck 3581 bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE { return true; }
475     bool acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const OVERRIDE { return true; }
476     bool acceptsArgFinal(vmint iArg) const OVERRIDE { return true; }
477 schoenebeck 3573 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
478     };
479    
480     /**
481     * Implements the built-in int_to_real() script function and its short hand
482     * variant real(). The behaviour of the two built-in script functions are
483     * identical ATM.
484     */
485 schoenebeck 3581 class CoreVMFunction_int_to_real FINAL : public VMRealResultFunction {
486 schoenebeck 3573 public:
487 schoenebeck 3581 StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE;
488     bool returnsFinal(VMFnArgs* args) OVERRIDE;
489 schoenebeck 3573 vmint minRequiredArgs() const OVERRIDE { return 1; }
490     vmint maxAllowedArgs() const OVERRIDE { return 1; }
491     bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR; }
492 schoenebeck 3581 bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE { return true; }
493     bool acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const OVERRIDE { return true; }
494     bool acceptsArgFinal(vmint iArg) const OVERRIDE { return true; }
495 schoenebeck 3573 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
496     };
497    
498 schoenebeck 2581 } // namespace LinuxSampler
499    
500     #endif // LS_COREVMFUNCTIONS_H
  ViewVC Help
Powered by ViewVC