/[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 3557 - (show annotations) (download) (as text)
Sun Aug 18 00:06:04 2019 UTC (4 years, 8 months ago) by schoenebeck
File MIME type: text/x-c++hdr
File size: 23569 byte(s) 
* NKSP: Introducing 64 bit support for NKSP integer scripts
  variables (declare $foo).
* Require C++11 compiler support.
* Autoconf: Added m4/ax_cxx_compile_stdcxx.m4 macro which is used
  for checking in configure for C++11 support (as mandatory
  requirement) and automatically adds compiler argument if required
  (e.g. -std=C++11).
* Bumped version (2.1.1.svn3).
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() 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 ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
142 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
143 protected:
144 InstrumentScriptVM* m_vm;
145 };
146
147 class InstrumentScriptVMFunction_change_tune : public VMEmptyResultFunction {
148 public:
149 InstrumentScriptVMFunction_change_tune(InstrumentScriptVM* parent);
150 vmint minRequiredArgs() const OVERRIDE { return 2; }
151 vmint maxAllowedArgs() const OVERRIDE { return 3; }
152 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
153 ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
154 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
155 protected:
156 InstrumentScriptVM* m_vm;
157 };
158
159 class InstrumentScriptVMFunction_change_pan : public VMEmptyResultFunction {
160 public:
161 InstrumentScriptVMFunction_change_pan(InstrumentScriptVM* parent);
162 vmint minRequiredArgs() const OVERRIDE { return 2; }
163 vmint maxAllowedArgs() const OVERRIDE { return 3; }
164 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
165 ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
166 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
167 protected:
168 InstrumentScriptVM* m_vm;
169 };
170
171 class InstrumentScriptVMFunction_change_cutoff : public VMEmptyResultFunction {
172 public:
173 InstrumentScriptVMFunction_change_cutoff(InstrumentScriptVM* parent);
174 vmint minRequiredArgs() const OVERRIDE { return 2; }
175 vmint maxAllowedArgs() const OVERRIDE { return 2; }
176 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
177 ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
178 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
179 protected:
180 InstrumentScriptVM* m_vm;
181 };
182
183 class InstrumentScriptVMFunction_change_reso : public VMEmptyResultFunction {
184 public:
185 InstrumentScriptVMFunction_change_reso(InstrumentScriptVM* parent);
186 vmint minRequiredArgs() const OVERRIDE { return 2; }
187 vmint maxAllowedArgs() const OVERRIDE { return 2; }
188 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
189 ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
190 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
191 protected:
192 InstrumentScriptVM* m_vm;
193 };
194
195 class InstrumentScriptVMFunction_change_attack : public VMEmptyResultFunction {
196 public:
197 InstrumentScriptVMFunction_change_attack(InstrumentScriptVM* parent);
198 vmint minRequiredArgs() const OVERRIDE { return 2; }
199 vmint maxAllowedArgs() const OVERRIDE { return 2; }
200 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
201 ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
202 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
203 protected:
204 InstrumentScriptVM* m_vm;
205 };
206
207 class InstrumentScriptVMFunction_change_decay : public VMEmptyResultFunction {
208 public:
209 InstrumentScriptVMFunction_change_decay(InstrumentScriptVM* parent);
210 vmint minRequiredArgs() const OVERRIDE { return 2; }
211 vmint maxAllowedArgs() const OVERRIDE { return 2; }
212 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
213 ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
214 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
215 protected:
216 InstrumentScriptVM* m_vm;
217 };
218
219 class InstrumentScriptVMFunction_change_release : public VMEmptyResultFunction {
220 public:
221 InstrumentScriptVMFunction_change_release(InstrumentScriptVM* parent);
222 vmint minRequiredArgs() const OVERRIDE { return 2; }
223 vmint maxAllowedArgs() const OVERRIDE { return 2; }
224 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
225 ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
226 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
227 protected:
228 InstrumentScriptVM* m_vm;
229 };
230
231 class VMChangeSynthParamFunction : public VMEmptyResultFunction {
232 public:
233 VMChangeSynthParamFunction(InstrumentScriptVM* parent) : m_vm(parent) {}
234 vmint minRequiredArgs() const OVERRIDE { return 2; }
235 vmint maxAllowedArgs() const OVERRIDE { return 2; }
236 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
237 ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
238
239 template<float NoteBase::_Override::*T_noteParam, vmint T_synthParam,
240 bool T_isNormalizedParam, vmint T_maxValue, vmint T_minValue>
241 VMFnResult* execTemplate(VMFnArgs* args, const char* functionName);
242 protected:
243 InstrumentScriptVM* m_vm;
244 };
245
246 class InstrumentScriptVMFunction_change_sustain : public VMChangeSynthParamFunction {
247 public:
248 InstrumentScriptVMFunction_change_sustain(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent) {}
249 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
250 };
251
252 class InstrumentScriptVMFunction_change_cutoff_attack : public VMChangeSynthParamFunction {
253 public:
254 InstrumentScriptVMFunction_change_cutoff_attack(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent) {}
255 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
256 };
257
258 class InstrumentScriptVMFunction_change_cutoff_decay : public VMChangeSynthParamFunction {
259 public:
260 InstrumentScriptVMFunction_change_cutoff_decay(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent) {}
261 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
262 };
263
264 class InstrumentScriptVMFunction_change_cutoff_sustain : public VMChangeSynthParamFunction {
265 public:
266 InstrumentScriptVMFunction_change_cutoff_sustain(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent) {}
267 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
268 };
269
270 class InstrumentScriptVMFunction_change_cutoff_release : public VMChangeSynthParamFunction {
271 public:
272 InstrumentScriptVMFunction_change_cutoff_release(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent) {}
273 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
274 };
275
276 class InstrumentScriptVMFunction_change_amp_lfo_depth : public VMChangeSynthParamFunction {
277 public:
278 InstrumentScriptVMFunction_change_amp_lfo_depth(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent) {}
279 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
280 };
281
282 class InstrumentScriptVMFunction_change_amp_lfo_freq : public VMChangeSynthParamFunction {
283 public:
284 InstrumentScriptVMFunction_change_amp_lfo_freq(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent) {}
285 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
286 };
287
288 class InstrumentScriptVMFunction_change_cutoff_lfo_depth : public VMChangeSynthParamFunction {
289 public:
290 InstrumentScriptVMFunction_change_cutoff_lfo_depth(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent) {}
291 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
292 };
293
294 class InstrumentScriptVMFunction_change_cutoff_lfo_freq : public VMChangeSynthParamFunction {
295 public:
296 InstrumentScriptVMFunction_change_cutoff_lfo_freq(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent) {}
297 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
298 };
299
300 class InstrumentScriptVMFunction_change_pitch_lfo_depth : public VMChangeSynthParamFunction {
301 public:
302 InstrumentScriptVMFunction_change_pitch_lfo_depth(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent) {}
303 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
304 };
305
306 class InstrumentScriptVMFunction_change_pitch_lfo_freq : public VMChangeSynthParamFunction {
307 public:
308 InstrumentScriptVMFunction_change_pitch_lfo_freq(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent) {}
309 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
310 };
311
312 class InstrumentScriptVMFunction_change_vol_time : public VMChangeSynthParamFunction {
313 public:
314 InstrumentScriptVMFunction_change_vol_time(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent) {}
315 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
316 };
317
318 class InstrumentScriptVMFunction_change_tune_time : public VMChangeSynthParamFunction {
319 public:
320 InstrumentScriptVMFunction_change_tune_time(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent) {}
321 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
322 };
323
324 class InstrumentScriptVMFunction_change_pan_time : public VMChangeSynthParamFunction {
325 public:
326 InstrumentScriptVMFunction_change_pan_time(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent) {}
327 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
328 };
329
330 class VMChangeFadeCurveFunction : public VMEmptyResultFunction {
331 public:
332 VMChangeFadeCurveFunction(InstrumentScriptVM* parent) : m_vm(parent) {}
333 vmint minRequiredArgs() const OVERRIDE { return 2; }
334 vmint maxAllowedArgs() const OVERRIDE { return 2; }
335 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
336 ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
337
338 template<fade_curve_t NoteBase::_Override::*T_noteParam, vmint T_synthParam>
339 VMFnResult* execTemplate(VMFnArgs* args, const char* functionName);
340 protected:
341 InstrumentScriptVM* m_vm;
342 };
343
344 class InstrumentScriptVMFunction_change_vol_curve : public VMChangeFadeCurveFunction {
345 public:
346 InstrumentScriptVMFunction_change_vol_curve(InstrumentScriptVM* parent) : VMChangeFadeCurveFunction(parent) {}
347 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
348 };
349
350 class InstrumentScriptVMFunction_change_tune_curve : public VMChangeFadeCurveFunction {
351 public:
352 InstrumentScriptVMFunction_change_tune_curve(InstrumentScriptVM* parent) : VMChangeFadeCurveFunction(parent) {}
353 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
354 };
355
356 class InstrumentScriptVMFunction_change_pan_curve : public VMChangeFadeCurveFunction {
357 public:
358 InstrumentScriptVMFunction_change_pan_curve(InstrumentScriptVM* parent) : VMChangeFadeCurveFunction(parent) {}
359 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
360 };
361
362 class InstrumentScriptVMFunction_fade_in : public VMEmptyResultFunction {
363 public:
364 InstrumentScriptVMFunction_fade_in(InstrumentScriptVM* parent);
365 vmint minRequiredArgs() const OVERRIDE { return 2; }
366 vmint maxAllowedArgs() const OVERRIDE { return 2; }
367 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
368 ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
369 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
370 protected:
371 InstrumentScriptVM* m_vm;
372 };
373
374 class InstrumentScriptVMFunction_fade_out : public VMEmptyResultFunction {
375 public:
376 InstrumentScriptVMFunction_fade_out(InstrumentScriptVM* parent);
377 vmint minRequiredArgs() const OVERRIDE { return 2; }
378 vmint maxAllowedArgs() const OVERRIDE { return 3; }
379 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
380 ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
381 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
382 protected:
383 InstrumentScriptVM* m_vm;
384 };
385
386 class InstrumentScriptVMFunction_get_event_par : public VMIntResultFunction {
387 public:
388 InstrumentScriptVMFunction_get_event_par(InstrumentScriptVM* parent);
389 vmint minRequiredArgs() const OVERRIDE { return 2; }
390 vmint maxAllowedArgs() const OVERRIDE { return 2; }
391 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR;}
392 ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
393 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
394 protected:
395 InstrumentScriptVM* m_vm;
396 };
397
398 class InstrumentScriptVMFunction_set_event_par : public VMEmptyResultFunction {
399 public:
400 InstrumentScriptVMFunction_set_event_par(InstrumentScriptVM* parent);
401 vmint minRequiredArgs() const OVERRIDE { return 3; }
402 vmint maxAllowedArgs() const OVERRIDE { return 3; }
403 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR;}
404 ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
405 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
406 protected:
407 InstrumentScriptVM* m_vm;
408 };
409
410 class InstrumentScriptVMFunction_change_note : public VMEmptyResultFunction {
411 public:
412 InstrumentScriptVMFunction_change_note(InstrumentScriptVM* parent);
413 vmint minRequiredArgs() const OVERRIDE { return 2; }
414 vmint maxAllowedArgs() const OVERRIDE { return 2; }
415 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR;}
416 ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
417 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
418 protected:
419 InstrumentScriptVM* m_vm;
420 };
421
422 class InstrumentScriptVMFunction_change_velo : public VMEmptyResultFunction {
423 public:
424 InstrumentScriptVMFunction_change_velo(InstrumentScriptVM* parent);
425 vmint minRequiredArgs() const OVERRIDE { return 2; }
426 vmint maxAllowedArgs() const OVERRIDE { return 2; }
427 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR;}
428 ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
429 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
430 protected:
431 InstrumentScriptVM* m_vm;
432 };
433
434 class InstrumentScriptVMFunction_change_play_pos : public VMEmptyResultFunction {
435 public:
436 InstrumentScriptVMFunction_change_play_pos(InstrumentScriptVM* parent);
437 vmint minRequiredArgs() const OVERRIDE { return 2; }
438 vmint maxAllowedArgs() const OVERRIDE { return 2; }
439 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR; }
440 ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
441 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
442 protected:
443 InstrumentScriptVM* m_vm;
444 };
445
446 class InstrumentScriptVMFunction_event_status : public VMIntResultFunction {
447 public:
448 InstrumentScriptVMFunction_event_status(InstrumentScriptVM* parent);
449 vmint minRequiredArgs() const OVERRIDE { return 1; }
450 vmint maxAllowedArgs() const OVERRIDE { return 1; }
451 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR;}
452 ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
453 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
454 protected:
455 InstrumentScriptVM* m_vm;
456 };
457
458 class InstrumentScriptVMFunction_callback_status : public VMIntResultFunction {
459 public:
460 InstrumentScriptVMFunction_callback_status(InstrumentScriptVM* parent);
461 vmint minRequiredArgs() const OVERRIDE { return 1; }
462 vmint maxAllowedArgs() const OVERRIDE { return 1; }
463 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR;}
464 ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
465 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
466 protected:
467 InstrumentScriptVM* m_vm;
468 };
469
470 // overrides core wait() implementation
471 class InstrumentScriptVMFunction_wait : public CoreVMFunction_wait {
472 public:
473 InstrumentScriptVMFunction_wait(InstrumentScriptVM* parent);
474 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
475 };
476
477 class InstrumentScriptVMFunction_stop_wait : public VMEmptyResultFunction {
478 public:
479 InstrumentScriptVMFunction_stop_wait(InstrumentScriptVM* parent);
480 vmint minRequiredArgs() const OVERRIDE { return 1; }
481 vmint maxAllowedArgs() const OVERRIDE { return 2; }
482 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR;}
483 ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
484 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
485 protected:
486 InstrumentScriptVM* m_vm;
487 };
488
489 class InstrumentScriptVMFunction_abort : public VMEmptyResultFunction {
490 public:
491 InstrumentScriptVMFunction_abort(InstrumentScriptVM* parent);
492 vmint minRequiredArgs() const OVERRIDE { return 1; }
493 vmint maxAllowedArgs() const OVERRIDE { return 1; }
494 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR; }
495 ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
496 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
497 protected:
498 InstrumentScriptVM* m_vm;
499 };
500
501 class InstrumentScriptVMFunction_fork : public VMIntResultFunction {
502 public:
503 InstrumentScriptVMFunction_fork(InstrumentScriptVM* parent);
504 vmint minRequiredArgs() const OVERRIDE { return 0; }
505 vmint maxAllowedArgs() const OVERRIDE { return 2; }
506 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR;}
507 ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
508 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
509 protected:
510 InstrumentScriptVM* m_vm;
511 };
512
513 } // namespace LinuxSampler
514
515 #endif // LS_INSTRSCRIPTVMFUNCTIONS_H
  ViewVC Help
Powered by ViewVC