/[svn]/linuxsampler/trunk/src/engines/common/InstrumentScriptVMFunctions.h
ViewVC logotype

Contents of /linuxsampler/trunk/src/engines/common/InstrumentScriptVMFunctions.h

Parent Directory Parent Directory | Revision Log Revision Log


Revision 3577 - (show annotations) (download) (as text)
Wed Aug 28 15:23:23 2019 UTC (4 years, 7 months ago) by schoenebeck
File MIME type: text/x-c++hdr
File size: 26286 byte(s)
NKSP: Introducing variable return type for built-in functions.

* Changed method signature VMFunction::returnType() ->
  VMFunction::returnType(VMFnArgs* args) to allow built-in
  functions to proclaim a different result value type depending
  on the arguments to be passed to the function.

* Built-in script function abs() optionally accepts and returns
  real number.

* Built-in script functions min() and max() optionally accept
  real number arguments and return real number as result in that
  case.

* Added real number test cases for the built-in abs(), min() and
  max() functions.

* Bumped version (2.1.1.svn7).

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_INSTRSCRIPTVMFUNCTIONS_H
11 #define LS_INSTRSCRIPTVMFUNCTIONS_H
12
13 #include "../../common/global.h"
14 #include "../../scriptvm/CoreVMFunctions.h"
15 #include "Note.h"
16
17 namespace LinuxSampler {
18
19 class EventGroup;
20 class InstrumentScriptVM;
21
22 class InstrumentScriptVMFunction_play_note : public VMIntResultFunction {
23 public:
24 InstrumentScriptVMFunction_play_note(InstrumentScriptVM* parent);
25 vmint minRequiredArgs() const OVERRIDE { return 1; }
26 vmint maxAllowedArgs() const OVERRIDE { return 4; }
27 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR;}
28 ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
29 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
30 protected:
31 InstrumentScriptVM* m_vm;
32 };
33
34 class InstrumentScriptVMFunction_set_controller : public VMIntResultFunction {
35 public:
36 InstrumentScriptVMFunction_set_controller(InstrumentScriptVM* parent);
37 vmint minRequiredArgs() const OVERRIDE { return 2; }
38 vmint maxAllowedArgs() const OVERRIDE { return 2; }
39 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR;}
40 ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
41 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
42 protected:
43 InstrumentScriptVM* m_vm;
44 };
45
46 class InstrumentScriptVMFunction_ignore_event : public VMEmptyResultFunction {
47 public:
48 InstrumentScriptVMFunction_ignore_event(InstrumentScriptVM* parent);
49 vmint minRequiredArgs() const OVERRIDE { return 0; }
50 vmint maxAllowedArgs() const OVERRIDE { return 1; }
51 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
52 ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
53 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
54 protected:
55 InstrumentScriptVM* m_vm;
56 };
57
58 class InstrumentScriptVMFunction_ignore_controller : public VMEmptyResultFunction {
59 public:
60 InstrumentScriptVMFunction_ignore_controller(InstrumentScriptVM* parent);
61 vmint minRequiredArgs() const OVERRIDE { return 0; }
62 vmint maxAllowedArgs() const OVERRIDE { return 1; }
63 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR;}
64 ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
65 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
66 protected:
67 InstrumentScriptVM* m_vm;
68 };
69
70 class InstrumentScriptVMFunction_note_off : public VMEmptyResultFunction {
71 public:
72 InstrumentScriptVMFunction_note_off(InstrumentScriptVM* parent);
73 vmint minRequiredArgs() const OVERRIDE { return 1; }
74 vmint maxAllowedArgs() const OVERRIDE { return 2; }
75 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
76 ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
77 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
78 protected:
79 InstrumentScriptVM* m_vm;
80 };
81
82 class InstrumentScriptVMFunction_set_event_mark : public VMEmptyResultFunction {
83 public:
84 InstrumentScriptVMFunction_set_event_mark(InstrumentScriptVM* parent);
85 vmint minRequiredArgs() const OVERRIDE { return 2; }
86 vmint maxAllowedArgs() const OVERRIDE { return 2; }
87 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR;}
88 ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
89 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
90 protected:
91 InstrumentScriptVM* m_vm;
92 };
93
94 class InstrumentScriptVMFunction_delete_event_mark : public VMEmptyResultFunction {
95 public:
96 InstrumentScriptVMFunction_delete_event_mark(InstrumentScriptVM* parent);
97 vmint minRequiredArgs() const OVERRIDE { return 2; }
98 vmint maxAllowedArgs() const OVERRIDE { return 2; }
99 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR;}
100 ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
101 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
102 protected:
103 InstrumentScriptVM* m_vm;
104 };
105
106 class InstrumentScriptVMFunction_by_marks : public VMFunction {
107 public:
108 InstrumentScriptVMFunction_by_marks(InstrumentScriptVM* parent);
109 vmint minRequiredArgs() const OVERRIDE { return 1; }
110 vmint maxAllowedArgs() const OVERRIDE { return 1; }
111 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR;}
112 bool modifiesArg(vmint iArg) const OVERRIDE { return false; }
113 ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
114 ExprType_t returnType(VMFnArgs* args) OVERRIDE { return INT_ARR_EXPR; }
115 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
116 protected:
117 InstrumentScriptVM* m_vm;
118 class Result : public VMFnResult, public VMIntArrayExpr {
119 public:
120 StmtFlags_t flags;
121 EventGroup* eventGroup;
122
123 vmint arraySize() const OVERRIDE;
124 vmint evalIntElement(vmuint i) OVERRIDE;
125 void assignIntElement(vmuint i, vmint value) OVERRIDE {} // ignore assignment
126 VMExpr* resultValue() OVERRIDE { return this; }
127 StmtFlags_t resultFlags() OVERRIDE { return flags; }
128 bool isConstExpr() const OVERRIDE { return false; }
129 } m_result;
130
131 VMFnResult* errorResult();
132 VMFnResult* successResult(EventGroup* eventGroup);
133 };
134
135 class InstrumentScriptVMFunction_change_vol : public VMEmptyResultFunction {
136 public:
137 InstrumentScriptVMFunction_change_vol(InstrumentScriptVM* parent);
138 vmint minRequiredArgs() const OVERRIDE { return 2; }
139 vmint maxAllowedArgs() const OVERRIDE { return 3; }
140 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
141 bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE;
142 bool acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const OVERRIDE;
143 bool acceptsArgFinal(vmint iArg) const OVERRIDE;
144 ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
145 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
146 protected:
147 InstrumentScriptVM* m_vm;
148 };
149
150 class InstrumentScriptVMFunction_change_tune : public VMEmptyResultFunction {
151 public:
152 InstrumentScriptVMFunction_change_tune(InstrumentScriptVM* parent);
153 vmint minRequiredArgs() const OVERRIDE { return 2; }
154 vmint maxAllowedArgs() const OVERRIDE { return 3; }
155 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
156 bool acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const OVERRIDE;
157 bool acceptsArgFinal(vmint iArg) const OVERRIDE;
158 ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
159 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
160 protected:
161 InstrumentScriptVM* m_vm;
162 };
163
164 class InstrumentScriptVMFunction_change_pan : public VMEmptyResultFunction {
165 public:
166 InstrumentScriptVMFunction_change_pan(InstrumentScriptVM* parent);
167 vmint minRequiredArgs() const OVERRIDE { return 2; }
168 vmint maxAllowedArgs() const OVERRIDE { return 3; }
169 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
170 bool acceptsArgFinal(vmint iArg) const OVERRIDE;
171 ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
172 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
173 protected:
174 InstrumentScriptVM* m_vm;
175 };
176
177 class InstrumentScriptVMFunction_change_cutoff : public VMEmptyResultFunction {
178 public:
179 InstrumentScriptVMFunction_change_cutoff(InstrumentScriptVM* parent);
180 vmint minRequiredArgs() const OVERRIDE { return 2; }
181 vmint maxAllowedArgs() const OVERRIDE { return 2; }
182 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
183 bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE;
184 bool acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const OVERRIDE;
185 bool acceptsArgFinal(vmint iArg) const OVERRIDE;
186 ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
187 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
188 protected:
189 InstrumentScriptVM* m_vm;
190 };
191
192 class InstrumentScriptVMFunction_change_reso : public VMEmptyResultFunction {
193 public:
194 InstrumentScriptVMFunction_change_reso(InstrumentScriptVM* parent);
195 vmint minRequiredArgs() const OVERRIDE { return 2; }
196 vmint maxAllowedArgs() const OVERRIDE { return 2; }
197 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
198 bool acceptsArgFinal(vmint iArg) const OVERRIDE;
199 ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
200 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
201 protected:
202 InstrumentScriptVM* m_vm;
203 };
204
205 class InstrumentScriptVMFunction_change_attack : public VMEmptyResultFunction {
206 public:
207 InstrumentScriptVMFunction_change_attack(InstrumentScriptVM* parent);
208 vmint minRequiredArgs() const OVERRIDE { return 2; }
209 vmint maxAllowedArgs() const OVERRIDE { return 2; }
210 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
211 bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE;
212 bool acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const OVERRIDE;
213 bool acceptsArgFinal(vmint iArg) const OVERRIDE;
214 ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
215 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
216 protected:
217 InstrumentScriptVM* m_vm;
218 };
219
220 class InstrumentScriptVMFunction_change_decay : public VMEmptyResultFunction {
221 public:
222 InstrumentScriptVMFunction_change_decay(InstrumentScriptVM* parent);
223 vmint minRequiredArgs() const OVERRIDE { return 2; }
224 vmint maxAllowedArgs() const OVERRIDE { return 2; }
225 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
226 bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE;
227 bool acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const OVERRIDE;
228 bool acceptsArgFinal(vmint iArg) const OVERRIDE;
229 ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
230 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
231 protected:
232 InstrumentScriptVM* m_vm;
233 };
234
235 class InstrumentScriptVMFunction_change_release : public VMEmptyResultFunction {
236 public:
237 InstrumentScriptVMFunction_change_release(InstrumentScriptVM* parent);
238 vmint minRequiredArgs() const OVERRIDE { return 2; }
239 vmint maxAllowedArgs() const OVERRIDE { return 2; }
240 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
241 bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE;
242 bool acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const OVERRIDE;
243 bool acceptsArgFinal(vmint iArg) const OVERRIDE;
244 ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
245 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
246 protected:
247 InstrumentScriptVM* m_vm;
248 };
249
250 class VMChangeSynthParamFunction : public VMEmptyResultFunction {
251 public:
252 VMChangeSynthParamFunction(InstrumentScriptVM* parent, bool acceptFinal, StdUnit_t unit, bool acceptUnitPrefix)
253 : m_vm(parent), m_acceptFinal(acceptFinal), m_acceptUnitPrefix(acceptUnitPrefix), m_unit(unit) {}
254 vmint minRequiredArgs() const OVERRIDE { return 2; }
255 vmint maxAllowedArgs() const OVERRIDE { return 2; }
256 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
257 bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE;
258 bool acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const OVERRIDE;
259 bool acceptsArgFinal(vmint iArg) const OVERRIDE;
260 ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
261
262 template<class T_NoteParamType, T_NoteParamType NoteBase::_Override::*T_noteParam,
263 vmint T_synthParam,
264 vmint T_minValueNorm, vmint T_maxValueNorm, bool T_normalizeNorm,
265 vmint T_minValueUnit, vmint T_maxValueUnit,
266 MetricPrefix_t T_unitPrefix0, MetricPrefix_t ... T_unitPrefixN>
267 VMFnResult* execTemplate(VMFnArgs* args, const char* functionName);
268 protected:
269 InstrumentScriptVM* m_vm;
270 const bool m_acceptFinal;
271 const bool m_acceptUnitPrefix;
272 const StdUnit_t m_unit;
273 };
274
275 class InstrumentScriptVMFunction_change_sustain : public VMChangeSynthParamFunction {
276 public:
277 InstrumentScriptVMFunction_change_sustain(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent,true,VM_BEL,true) {}
278 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
279 };
280
281 class InstrumentScriptVMFunction_change_cutoff_attack : public VMChangeSynthParamFunction {
282 public:
283 InstrumentScriptVMFunction_change_cutoff_attack(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent,true,VM_SECOND,true) {}
284 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
285 };
286
287 class InstrumentScriptVMFunction_change_cutoff_decay : public VMChangeSynthParamFunction {
288 public:
289 InstrumentScriptVMFunction_change_cutoff_decay(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent,true,VM_SECOND,true) {}
290 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
291 };
292
293 class InstrumentScriptVMFunction_change_cutoff_sustain : public VMChangeSynthParamFunction {
294 public:
295 InstrumentScriptVMFunction_change_cutoff_sustain(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent,true,VM_BEL,true) {}
296 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
297 };
298
299 class InstrumentScriptVMFunction_change_cutoff_release : public VMChangeSynthParamFunction {
300 public:
301 InstrumentScriptVMFunction_change_cutoff_release(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent,true,VM_SECOND,true) {}
302 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
303 };
304
305 class InstrumentScriptVMFunction_change_amp_lfo_depth : public VMChangeSynthParamFunction {
306 public:
307 InstrumentScriptVMFunction_change_amp_lfo_depth(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent,true,VM_NO_UNIT,false) {}
308 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
309 };
310
311 class InstrumentScriptVMFunction_change_amp_lfo_freq : public VMChangeSynthParamFunction {
312 public:
313 InstrumentScriptVMFunction_change_amp_lfo_freq(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent,true,VM_HERTZ,true) {}
314 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
315 };
316
317 class InstrumentScriptVMFunction_change_cutoff_lfo_depth : public VMChangeSynthParamFunction {
318 public:
319 InstrumentScriptVMFunction_change_cutoff_lfo_depth(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent,true,VM_NO_UNIT,false) {}
320 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
321 };
322
323 class InstrumentScriptVMFunction_change_cutoff_lfo_freq : public VMChangeSynthParamFunction {
324 public:
325 InstrumentScriptVMFunction_change_cutoff_lfo_freq(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent,true,VM_HERTZ,true) {}
326 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
327 };
328
329 class InstrumentScriptVMFunction_change_pitch_lfo_depth : public VMChangeSynthParamFunction {
330 public:
331 InstrumentScriptVMFunction_change_pitch_lfo_depth(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent,true,VM_NO_UNIT,false) {}
332 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
333 };
334
335 class InstrumentScriptVMFunction_change_pitch_lfo_freq : public VMChangeSynthParamFunction {
336 public:
337 InstrumentScriptVMFunction_change_pitch_lfo_freq(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent,true,VM_HERTZ,true) {}
338 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
339 };
340
341 class InstrumentScriptVMFunction_change_vol_time : public VMChangeSynthParamFunction {
342 public:
343 InstrumentScriptVMFunction_change_vol_time(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent,false,VM_SECOND,true) {}
344 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
345 };
346
347 class InstrumentScriptVMFunction_change_tune_time : public VMChangeSynthParamFunction {
348 public:
349 InstrumentScriptVMFunction_change_tune_time(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent,false,VM_SECOND,true) {}
350 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
351 };
352
353 class InstrumentScriptVMFunction_change_pan_time : public VMChangeSynthParamFunction {
354 public:
355 InstrumentScriptVMFunction_change_pan_time(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent,false,VM_SECOND,true) {}
356 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
357 };
358
359 class VMChangeFadeCurveFunction : public VMEmptyResultFunction {
360 public:
361 VMChangeFadeCurveFunction(InstrumentScriptVM* parent) : m_vm(parent) {}
362 vmint minRequiredArgs() const OVERRIDE { return 2; }
363 vmint maxAllowedArgs() const OVERRIDE { return 2; }
364 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
365 ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
366
367 template<fade_curve_t NoteBase::_Override::*T_noteParam, vmint T_synthParam>
368 VMFnResult* execTemplate(VMFnArgs* args, const char* functionName);
369 protected:
370 InstrumentScriptVM* m_vm;
371 };
372
373 class InstrumentScriptVMFunction_change_vol_curve : public VMChangeFadeCurveFunction {
374 public:
375 InstrumentScriptVMFunction_change_vol_curve(InstrumentScriptVM* parent) : VMChangeFadeCurveFunction(parent) {}
376 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
377 };
378
379 class InstrumentScriptVMFunction_change_tune_curve : public VMChangeFadeCurveFunction {
380 public:
381 InstrumentScriptVMFunction_change_tune_curve(InstrumentScriptVM* parent) : VMChangeFadeCurveFunction(parent) {}
382 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
383 };
384
385 class InstrumentScriptVMFunction_change_pan_curve : public VMChangeFadeCurveFunction {
386 public:
387 InstrumentScriptVMFunction_change_pan_curve(InstrumentScriptVM* parent) : VMChangeFadeCurveFunction(parent) {}
388 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
389 };
390
391 class InstrumentScriptVMFunction_fade_in : public VMEmptyResultFunction {
392 public:
393 InstrumentScriptVMFunction_fade_in(InstrumentScriptVM* parent);
394 vmint minRequiredArgs() const OVERRIDE { return 2; }
395 vmint maxAllowedArgs() const OVERRIDE { return 2; }
396 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
397 bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE;
398 bool acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const OVERRIDE;
399 ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
400 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
401 protected:
402 InstrumentScriptVM* m_vm;
403 };
404
405 class InstrumentScriptVMFunction_fade_out : public VMEmptyResultFunction {
406 public:
407 InstrumentScriptVMFunction_fade_out(InstrumentScriptVM* parent);
408 vmint minRequiredArgs() const OVERRIDE { return 2; }
409 vmint maxAllowedArgs() const OVERRIDE { return 3; }
410 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
411 bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE;
412 bool acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const OVERRIDE;
413 ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
414 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
415 protected:
416 InstrumentScriptVM* m_vm;
417 };
418
419 class InstrumentScriptVMFunction_get_event_par : public VMIntResultFunction {
420 public:
421 InstrumentScriptVMFunction_get_event_par(InstrumentScriptVM* parent);
422 vmint minRequiredArgs() const OVERRIDE { return 2; }
423 vmint maxAllowedArgs() const OVERRIDE { return 2; }
424 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR;}
425 ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
426 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
427 protected:
428 InstrumentScriptVM* m_vm;
429 };
430
431 class InstrumentScriptVMFunction_set_event_par : public VMEmptyResultFunction {
432 public:
433 InstrumentScriptVMFunction_set_event_par(InstrumentScriptVM* parent);
434 vmint minRequiredArgs() const OVERRIDE { return 3; }
435 vmint maxAllowedArgs() const OVERRIDE { return 3; }
436 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR;}
437 ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
438 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
439 protected:
440 InstrumentScriptVM* m_vm;
441 };
442
443 class InstrumentScriptVMFunction_change_note : public VMEmptyResultFunction {
444 public:
445 InstrumentScriptVMFunction_change_note(InstrumentScriptVM* parent);
446 vmint minRequiredArgs() const OVERRIDE { return 2; }
447 vmint maxAllowedArgs() const OVERRIDE { return 2; }
448 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR;}
449 ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
450 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
451 protected:
452 InstrumentScriptVM* m_vm;
453 };
454
455 class InstrumentScriptVMFunction_change_velo : public VMEmptyResultFunction {
456 public:
457 InstrumentScriptVMFunction_change_velo(InstrumentScriptVM* parent);
458 vmint minRequiredArgs() const OVERRIDE { return 2; }
459 vmint maxAllowedArgs() const OVERRIDE { return 2; }
460 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR;}
461 ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
462 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
463 protected:
464 InstrumentScriptVM* m_vm;
465 };
466
467 class InstrumentScriptVMFunction_change_play_pos : public VMEmptyResultFunction {
468 public:
469 InstrumentScriptVMFunction_change_play_pos(InstrumentScriptVM* parent);
470 vmint minRequiredArgs() const OVERRIDE { return 2; }
471 vmint maxAllowedArgs() const OVERRIDE { return 2; }
472 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR; }
473 bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE;
474 bool acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const OVERRIDE;
475 ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
476 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
477 protected:
478 InstrumentScriptVM* m_vm;
479 };
480
481 class InstrumentScriptVMFunction_event_status : public VMIntResultFunction {
482 public:
483 InstrumentScriptVMFunction_event_status(InstrumentScriptVM* parent);
484 vmint minRequiredArgs() const OVERRIDE { return 1; }
485 vmint maxAllowedArgs() const OVERRIDE { return 1; }
486 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR;}
487 ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
488 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
489 protected:
490 InstrumentScriptVM* m_vm;
491 };
492
493 class InstrumentScriptVMFunction_callback_status : public VMIntResultFunction {
494 public:
495 InstrumentScriptVMFunction_callback_status(InstrumentScriptVM* parent);
496 vmint minRequiredArgs() const OVERRIDE { return 1; }
497 vmint maxAllowedArgs() const OVERRIDE { return 1; }
498 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR;}
499 ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
500 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
501 protected:
502 InstrumentScriptVM* m_vm;
503 };
504
505 // overrides core wait() implementation
506 class InstrumentScriptVMFunction_wait : public CoreVMFunction_wait {
507 public:
508 InstrumentScriptVMFunction_wait(InstrumentScriptVM* parent);
509 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
510 };
511
512 class InstrumentScriptVMFunction_stop_wait : public VMEmptyResultFunction {
513 public:
514 InstrumentScriptVMFunction_stop_wait(InstrumentScriptVM* parent);
515 vmint minRequiredArgs() const OVERRIDE { return 1; }
516 vmint maxAllowedArgs() const OVERRIDE { return 2; }
517 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR;}
518 ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
519 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
520 protected:
521 InstrumentScriptVM* m_vm;
522 };
523
524 class InstrumentScriptVMFunction_abort : public VMEmptyResultFunction {
525 public:
526 InstrumentScriptVMFunction_abort(InstrumentScriptVM* parent);
527 vmint minRequiredArgs() const OVERRIDE { return 1; }
528 vmint maxAllowedArgs() const OVERRIDE { return 1; }
529 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR; }
530 ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
531 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
532 protected:
533 InstrumentScriptVM* m_vm;
534 };
535
536 class InstrumentScriptVMFunction_fork : public VMIntResultFunction {
537 public:
538 InstrumentScriptVMFunction_fork(InstrumentScriptVM* parent);
539 vmint minRequiredArgs() const OVERRIDE { return 0; }
540 vmint maxAllowedArgs() const OVERRIDE { return 2; }
541 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR;}
542 ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
543 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
544 protected:
545 InstrumentScriptVM* m_vm;
546 };
547
548 } // namespace LinuxSampler
549
550 #endif // LS_INSTRSCRIPTVMFUNCTIONS_H

  ViewVC Help
Powered by ViewVC