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

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

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 2598 by schoenebeck, Fri Jun 6 12:38:54 2014 UTC revision 3561 by schoenebeck, Fri Aug 23 11:44:00 2019 UTC
# Line 1  Line 1 
1  /*  /*
2   * Copyright (c) 2014 Christian Schoenebeck   * Copyright (c) 2014 - 2019 Christian Schoenebeck
3   *   *
4   * http://www.linuxsampler.org   * http://www.linuxsampler.org
5   *   *
# Line 12  Line 12 
12    
13  #include "../../common/global.h"  #include "../../common/global.h"
14  #include "../../scriptvm/CoreVMFunctions.h"  #include "../../scriptvm/CoreVMFunctions.h"
15    #include "Note.h"
16    
17  namespace LinuxSampler {  namespace LinuxSampler {
18    
19        class EventGroup;
20      class InstrumentScriptVM;      class InstrumentScriptVM;
21    
22      class InstrumentScriptVMFunction_play_note : public VMIntResultFunction {      class InstrumentScriptVMFunction_play_note : public VMIntResultFunction {
23      public:      public:
24          InstrumentScriptVMFunction_play_note(InstrumentScriptVM* parent);          InstrumentScriptVMFunction_play_note(InstrumentScriptVM* parent);
25          int minRequiredArgs() const { return 1; }          vmint minRequiredArgs() const OVERRIDE { return 1; }
26          int maxAllowedArgs() const { return 4; }          vmint maxAllowedArgs() const OVERRIDE { return 4; }
27          bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR;}          bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR;}
28          ExprType_t argType(int iArg) const { return INT_EXPR; }          ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
29          VMFnResult* exec(VMFnArgs* args);          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:      protected:
43          InstrumentScriptVM* m_vm;          InstrumentScriptVM* m_vm;
44      };      };
# Line 32  namespace LinuxSampler { Line 46  namespace LinuxSampler {
46      class InstrumentScriptVMFunction_ignore_event : public VMEmptyResultFunction {      class InstrumentScriptVMFunction_ignore_event : public VMEmptyResultFunction {
47      public:      public:
48          InstrumentScriptVMFunction_ignore_event(InstrumentScriptVM* parent);          InstrumentScriptVMFunction_ignore_event(InstrumentScriptVM* parent);
49          int minRequiredArgs() const { return 1; }          vmint minRequiredArgs() const OVERRIDE { return 0; }
50          int maxAllowedArgs() const { return 1; }          vmint maxAllowedArgs() const OVERRIDE { return 1; }
51          bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR;}          bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
52          ExprType_t argType(int iArg) const { return INT_EXPR; }          ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
53          VMFnResult* exec(VMFnArgs* args);          VMFnResult* exec(VMFnArgs* args) OVERRIDE;
54      protected:      protected:
55          InstrumentScriptVM* m_vm;          InstrumentScriptVM* m_vm;
56      };      };
# Line 44  namespace LinuxSampler { Line 58  namespace LinuxSampler {
58      class InstrumentScriptVMFunction_ignore_controller : public VMEmptyResultFunction {      class InstrumentScriptVMFunction_ignore_controller : public VMEmptyResultFunction {
59      public:      public:
60          InstrumentScriptVMFunction_ignore_controller(InstrumentScriptVM* parent);          InstrumentScriptVMFunction_ignore_controller(InstrumentScriptVM* parent);
61          int minRequiredArgs() const { return 0; }          vmint minRequiredArgs() const OVERRIDE { return 0; }
62          int maxAllowedArgs() const { return 1; }          vmint maxAllowedArgs() const OVERRIDE { return 1; }
63          bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR;}          bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR;}
64          ExprType_t argType(int iArg) const { return INT_EXPR; }          ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
65          VMFnResult* exec(VMFnArgs* args);          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            bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE;
142            bool acceptsArgUnitPrefix(vmint iArg) 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) 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) 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) 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) 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) 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)
253                : m_vm(parent), m_acceptFinal(acceptFinal), 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) 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 StdUnit_t m_unit;
272        };
273    
274        class InstrumentScriptVMFunction_change_sustain : public VMChangeSynthParamFunction {
275        public:
276            InstrumentScriptVMFunction_change_sustain(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent,true,VM_BEL) {}
277            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
278        };
279    
280        class InstrumentScriptVMFunction_change_cutoff_attack : public VMChangeSynthParamFunction {
281        public:
282            InstrumentScriptVMFunction_change_cutoff_attack(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent,true,VM_SECOND) {}
283            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
284        };
285    
286        class InstrumentScriptVMFunction_change_cutoff_decay : public VMChangeSynthParamFunction {
287        public:
288            InstrumentScriptVMFunction_change_cutoff_decay(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent,true,VM_SECOND) {}
289            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
290        };
291    
292        class InstrumentScriptVMFunction_change_cutoff_sustain : public VMChangeSynthParamFunction {
293        public:
294            InstrumentScriptVMFunction_change_cutoff_sustain(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent,true,VM_BEL) {}
295            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
296        };
297    
298        class InstrumentScriptVMFunction_change_cutoff_release : public VMChangeSynthParamFunction {
299        public:
300            InstrumentScriptVMFunction_change_cutoff_release(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent,true,VM_SECOND) {}
301            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
302        };
303    
304        class InstrumentScriptVMFunction_change_amp_lfo_depth : public VMChangeSynthParamFunction {
305        public:
306            InstrumentScriptVMFunction_change_amp_lfo_depth(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent,true,VM_NO_UNIT) {}
307            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
308        };
309    
310        class InstrumentScriptVMFunction_change_amp_lfo_freq : public VMChangeSynthParamFunction {
311        public:
312            InstrumentScriptVMFunction_change_amp_lfo_freq(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent,true,VM_HERTZ) {}
313            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
314        };
315    
316        class InstrumentScriptVMFunction_change_cutoff_lfo_depth : public VMChangeSynthParamFunction {
317        public:
318            InstrumentScriptVMFunction_change_cutoff_lfo_depth(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent,true,VM_NO_UNIT) {}
319            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
320        };
321    
322        class InstrumentScriptVMFunction_change_cutoff_lfo_freq : public VMChangeSynthParamFunction {
323        public:
324            InstrumentScriptVMFunction_change_cutoff_lfo_freq(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent,true,VM_HERTZ) {}
325            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
326        };
327    
328        class InstrumentScriptVMFunction_change_pitch_lfo_depth : public VMChangeSynthParamFunction {
329        public:
330            InstrumentScriptVMFunction_change_pitch_lfo_depth(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent,true,VM_NO_UNIT) {}
331            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
332        };
333    
334        class InstrumentScriptVMFunction_change_pitch_lfo_freq : public VMChangeSynthParamFunction {
335        public:
336            InstrumentScriptVMFunction_change_pitch_lfo_freq(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent,true,VM_HERTZ) {}
337            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
338        };
339    
340        class InstrumentScriptVMFunction_change_vol_time : public VMChangeSynthParamFunction {
341        public:
342            InstrumentScriptVMFunction_change_vol_time(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent,false,VM_SECOND) {}
343            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
344        };
345    
346        class InstrumentScriptVMFunction_change_tune_time : public VMChangeSynthParamFunction {
347        public:
348            InstrumentScriptVMFunction_change_tune_time(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent,false,VM_SECOND) {}
349            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
350        };
351    
352        class InstrumentScriptVMFunction_change_pan_time : public VMChangeSynthParamFunction {
353        public:
354            InstrumentScriptVMFunction_change_pan_time(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent,false,VM_SECOND) {}
355            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
356        };
357    
358        class VMChangeFadeCurveFunction : public VMEmptyResultFunction {
359        public:
360            VMChangeFadeCurveFunction(InstrumentScriptVM* parent) : m_vm(parent) {}
361            vmint minRequiredArgs() const OVERRIDE { return 2; }
362            vmint maxAllowedArgs() const OVERRIDE { return 2; }
363            bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
364            ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
365    
366            template<fade_curve_t NoteBase::_Override::*T_noteParam, vmint T_synthParam>
367            VMFnResult* execTemplate(VMFnArgs* args, const char* functionName);
368        protected:
369            InstrumentScriptVM* m_vm;
370        };
371    
372        class InstrumentScriptVMFunction_change_vol_curve : public VMChangeFadeCurveFunction {
373        public:
374            InstrumentScriptVMFunction_change_vol_curve(InstrumentScriptVM* parent) : VMChangeFadeCurveFunction(parent) {}
375            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
376        };
377    
378        class InstrumentScriptVMFunction_change_tune_curve : public VMChangeFadeCurveFunction {
379        public:
380            InstrumentScriptVMFunction_change_tune_curve(InstrumentScriptVM* parent) : VMChangeFadeCurveFunction(parent) {}
381            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
382        };
383    
384        class InstrumentScriptVMFunction_change_pan_curve : public VMChangeFadeCurveFunction {
385        public:
386            InstrumentScriptVMFunction_change_pan_curve(InstrumentScriptVM* parent) : VMChangeFadeCurveFunction(parent) {}
387            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
388        };
389    
390        class InstrumentScriptVMFunction_fade_in : public VMEmptyResultFunction {
391        public:
392            InstrumentScriptVMFunction_fade_in(InstrumentScriptVM* parent);
393            vmint minRequiredArgs() const OVERRIDE { return 2; }
394            vmint maxAllowedArgs() const OVERRIDE { return 2; }
395            bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
396            bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE;
397            bool acceptsArgUnitPrefix(vmint iArg) const OVERRIDE;
398            ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
399            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
400        protected:
401            InstrumentScriptVM* m_vm;
402        };
403    
404        class InstrumentScriptVMFunction_fade_out : public VMEmptyResultFunction {
405        public:
406            InstrumentScriptVMFunction_fade_out(InstrumentScriptVM* parent);
407            vmint minRequiredArgs() const OVERRIDE { return 2; }
408            vmint maxAllowedArgs() const OVERRIDE { return 3; }
409            bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
410            bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE;
411            bool acceptsArgUnitPrefix(vmint iArg) const OVERRIDE;
412            ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
413            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
414        protected:
415            InstrumentScriptVM* m_vm;
416        };
417    
418        class InstrumentScriptVMFunction_get_event_par : public VMIntResultFunction {
419        public:
420            InstrumentScriptVMFunction_get_event_par(InstrumentScriptVM* parent);
421            vmint minRequiredArgs() const OVERRIDE { return 2; }
422            vmint maxAllowedArgs() const OVERRIDE { return 2; }
423            bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR;}
424            ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
425            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
426        protected:
427            InstrumentScriptVM* m_vm;
428        };
429    
430        class InstrumentScriptVMFunction_set_event_par : public VMEmptyResultFunction {
431        public:
432            InstrumentScriptVMFunction_set_event_par(InstrumentScriptVM* parent);
433            vmint minRequiredArgs() const OVERRIDE { return 3; }
434            vmint maxAllowedArgs() const OVERRIDE { return 3; }
435            bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR;}
436            ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
437            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
438        protected:
439            InstrumentScriptVM* m_vm;
440        };
441    
442        class InstrumentScriptVMFunction_change_note : public VMEmptyResultFunction {
443        public:
444            InstrumentScriptVMFunction_change_note(InstrumentScriptVM* parent);
445            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            ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
449            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
450        protected:
451            InstrumentScriptVM* m_vm;
452        };
453    
454        class InstrumentScriptVMFunction_change_velo : public VMEmptyResultFunction {
455        public:
456            InstrumentScriptVMFunction_change_velo(InstrumentScriptVM* parent);
457            vmint minRequiredArgs() const OVERRIDE { return 2; }
458            vmint maxAllowedArgs() const OVERRIDE { return 2; }
459            bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR;}
460            ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
461            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
462        protected:
463            InstrumentScriptVM* m_vm;
464        };
465    
466        class InstrumentScriptVMFunction_change_play_pos : public VMEmptyResultFunction {
467        public:
468            InstrumentScriptVMFunction_change_play_pos(InstrumentScriptVM* parent);
469            vmint minRequiredArgs() const OVERRIDE { return 2; }
470            vmint maxAllowedArgs() const OVERRIDE { return 2; }
471            bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR; }
472            bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE;
473            bool acceptsArgUnitPrefix(vmint iArg) const OVERRIDE;
474            ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
475            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
476        protected:
477            InstrumentScriptVM* m_vm;
478        };
479    
480        class InstrumentScriptVMFunction_event_status : public VMIntResultFunction {
481        public:
482            InstrumentScriptVMFunction_event_status(InstrumentScriptVM* parent);
483            vmint minRequiredArgs() const OVERRIDE { return 1; }
484            vmint maxAllowedArgs() const OVERRIDE { return 1; }
485            bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR;}
486            ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
487            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
488        protected:
489            InstrumentScriptVM* m_vm;
490        };
491    
492        class InstrumentScriptVMFunction_callback_status : public VMIntResultFunction {
493        public:
494            InstrumentScriptVMFunction_callback_status(InstrumentScriptVM* parent);
495            vmint minRequiredArgs() const OVERRIDE { return 1; }
496            vmint maxAllowedArgs() const OVERRIDE { return 1; }
497            bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR;}
498            ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
499            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
500        protected:
501            InstrumentScriptVM* m_vm;
502        };
503    
504        // overrides core wait() implementation
505        class InstrumentScriptVMFunction_wait : public CoreVMFunction_wait {
506        public:
507            InstrumentScriptVMFunction_wait(InstrumentScriptVM* parent);
508            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
509        };
510    
511        class InstrumentScriptVMFunction_stop_wait : public VMEmptyResultFunction {
512        public:
513            InstrumentScriptVMFunction_stop_wait(InstrumentScriptVM* parent);
514            vmint minRequiredArgs() const OVERRIDE { return 1; }
515            vmint maxAllowedArgs() const OVERRIDE { return 2; }
516            bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR;}
517            ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
518            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
519        protected:
520            InstrumentScriptVM* m_vm;
521        };
522    
523        class InstrumentScriptVMFunction_abort : public VMEmptyResultFunction {
524        public:
525            InstrumentScriptVMFunction_abort(InstrumentScriptVM* parent);
526            vmint minRequiredArgs() const OVERRIDE { return 1; }
527            vmint maxAllowedArgs() const OVERRIDE { return 1; }
528            bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR; }
529            ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
530            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
531        protected:
532            InstrumentScriptVM* m_vm;
533        };
534    
535        class InstrumentScriptVMFunction_fork : public VMIntResultFunction {
536        public:
537            InstrumentScriptVMFunction_fork(InstrumentScriptVM* parent);
538            vmint minRequiredArgs() const OVERRIDE { return 0; }
539            vmint maxAllowedArgs() const OVERRIDE { return 2; }
540            bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR;}
541            ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
542            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
543      protected:      protected:
544          InstrumentScriptVM* m_vm;          InstrumentScriptVM* m_vm;
545      };      };
Legend:
Removed from v.2598  
changed lines
  Added in v.3561
  ViewVC Help
Powered by ViewVC