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

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