/[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 3316 by schoenebeck, Thu Jul 20 12:05:53 2017 UTC revision 3561 by schoenebeck, Fri Aug 23 11:44:00 2019 UTC
# Line 1  Line 1 
1  /*  /*
2   * Copyright (c) 2014 - 2017 Christian Schoenebeck   * Copyright (c) 2014 - 2019 Christian Schoenebeck
3   *   *
4   * http://www.linuxsampler.org   * http://www.linuxsampler.org
5   *   *
# Line 22  namespace LinuxSampler { Line 22  namespace LinuxSampler {
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:      protected:
31          InstrumentScriptVM* m_vm;          InstrumentScriptVM* m_vm;
32      };      };
# Line 34  namespace LinuxSampler { Line 34  namespace LinuxSampler {
34      class InstrumentScriptVMFunction_set_controller : public VMIntResultFunction {      class InstrumentScriptVMFunction_set_controller : public VMIntResultFunction {
35      public:      public:
36          InstrumentScriptVMFunction_set_controller(InstrumentScriptVM* parent);          InstrumentScriptVMFunction_set_controller(InstrumentScriptVM* parent);
37          int minRequiredArgs() const { return 2; }          vmint minRequiredArgs() const OVERRIDE { return 2; }
38          int maxAllowedArgs() const { return 2; }          vmint maxAllowedArgs() const OVERRIDE { return 2; }
39          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;}
40          ExprType_t argType(int iArg) const { return INT_EXPR; }          ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
41          VMFnResult* exec(VMFnArgs* args);          VMFnResult* exec(VMFnArgs* args) OVERRIDE;
42      protected:      protected:
43          InstrumentScriptVM* m_vm;          InstrumentScriptVM* m_vm;
44      };      };
# Line 46  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 0; }          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;          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 58  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:      protected:
67          InstrumentScriptVM* m_vm;          InstrumentScriptVM* m_vm;
68      };      };
# Line 70  namespace LinuxSampler { Line 70  namespace LinuxSampler {
70      class InstrumentScriptVMFunction_note_off : public VMEmptyResultFunction {      class InstrumentScriptVMFunction_note_off : public VMEmptyResultFunction {
71      public:      public:
72          InstrumentScriptVMFunction_note_off(InstrumentScriptVM* parent);          InstrumentScriptVMFunction_note_off(InstrumentScriptVM* parent);
73          int minRequiredArgs() const { return 1; }          vmint minRequiredArgs() const OVERRIDE { return 1; }
74          int maxAllowedArgs() const { return 2; }          vmint maxAllowedArgs() const OVERRIDE { return 2; }
75          bool acceptsArgType(int iArg, ExprType_t type) const;          bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
76          ExprType_t argType(int iArg) const { return INT_EXPR; }          ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
77          VMFnResult* exec(VMFnArgs* args);          VMFnResult* exec(VMFnArgs* args) OVERRIDE;
78      protected:      protected:
79          InstrumentScriptVM* m_vm;          InstrumentScriptVM* m_vm;
80      };      };
# Line 82  namespace LinuxSampler { Line 82  namespace LinuxSampler {
82      class InstrumentScriptVMFunction_set_event_mark : public VMEmptyResultFunction {      class InstrumentScriptVMFunction_set_event_mark : public VMEmptyResultFunction {
83      public:      public:
84          InstrumentScriptVMFunction_set_event_mark(InstrumentScriptVM* parent);          InstrumentScriptVMFunction_set_event_mark(InstrumentScriptVM* parent);
85          int minRequiredArgs() const { return 2; }          vmint minRequiredArgs() const OVERRIDE { return 2; }
86          int maxAllowedArgs() const { return 2; }          vmint maxAllowedArgs() const OVERRIDE { return 2; }
87          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;}
88          ExprType_t argType(int iArg) const { return INT_EXPR; }          ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
89          VMFnResult* exec(VMFnArgs* args);          VMFnResult* exec(VMFnArgs* args) OVERRIDE;
90      protected:      protected:
91          InstrumentScriptVM* m_vm;          InstrumentScriptVM* m_vm;
92      };      };
# Line 94  namespace LinuxSampler { Line 94  namespace LinuxSampler {
94      class InstrumentScriptVMFunction_delete_event_mark : public VMEmptyResultFunction {      class InstrumentScriptVMFunction_delete_event_mark : public VMEmptyResultFunction {
95      public:      public:
96          InstrumentScriptVMFunction_delete_event_mark(InstrumentScriptVM* parent);          InstrumentScriptVMFunction_delete_event_mark(InstrumentScriptVM* parent);
97          int minRequiredArgs() const { return 2; }          vmint minRequiredArgs() const OVERRIDE { return 2; }
98          int maxAllowedArgs() const { return 2; }          vmint maxAllowedArgs() const OVERRIDE { return 2; }
99          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;}
100          ExprType_t argType(int iArg) const { return INT_EXPR; }          ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
101          VMFnResult* exec(VMFnArgs* args);          VMFnResult* exec(VMFnArgs* args) OVERRIDE;
102      protected:      protected:
103          InstrumentScriptVM* m_vm;          InstrumentScriptVM* m_vm;
104      };      };
# Line 106  namespace LinuxSampler { Line 106  namespace LinuxSampler {
106      class InstrumentScriptVMFunction_by_marks : public VMFunction {      class InstrumentScriptVMFunction_by_marks : public VMFunction {
107      public:      public:
108          InstrumentScriptVMFunction_by_marks(InstrumentScriptVM* parent);          InstrumentScriptVMFunction_by_marks(InstrumentScriptVM* parent);
109          int minRequiredArgs() const OVERRIDE { return 1; }          vmint minRequiredArgs() const OVERRIDE { return 1; }
110          int maxAllowedArgs() const OVERRIDE { return 1; }          vmint maxAllowedArgs() const OVERRIDE { return 1; }
111          bool acceptsArgType(int iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR;}          bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR;}
112          bool modifiesArg(int iArg) const OVERRIDE { return false; }          bool modifiesArg(vmint iArg) const OVERRIDE { return false; }
113          ExprType_t argType(int iArg) const OVERRIDE { return INT_EXPR; }          ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
114          ExprType_t returnType() OVERRIDE { return INT_ARR_EXPR; }          ExprType_t returnType() OVERRIDE { return INT_ARR_EXPR; }
115          VMFnResult* exec(VMFnArgs* args) OVERRIDE;          VMFnResult* exec(VMFnArgs* args) OVERRIDE;
116      protected:      protected:
# Line 120  namespace LinuxSampler { Line 120  namespace LinuxSampler {
120              StmtFlags_t flags;              StmtFlags_t flags;
121              EventGroup* eventGroup;              EventGroup* eventGroup;
122    
123              int arraySize() const OVERRIDE;              vmint arraySize() const OVERRIDE;
124              int evalIntElement(uint i) OVERRIDE;              vmint evalIntElement(vmuint i) OVERRIDE;
125              void assignIntElement(uint i, int value) OVERRIDE {} // ignore assignment              void assignIntElement(vmuint i, vmint value) OVERRIDE {} // ignore assignment
126              VMExpr* resultValue() OVERRIDE { return this; }              VMExpr* resultValue() OVERRIDE { return this; }
127              StmtFlags_t resultFlags() OVERRIDE { return flags; }              StmtFlags_t resultFlags() OVERRIDE { return flags; }
128              bool isConstExpr() const OVERRIDE { return false; }              bool isConstExpr() const OVERRIDE { return false; }
# Line 135  namespace LinuxSampler { Line 135  namespace LinuxSampler {
135      class InstrumentScriptVMFunction_change_vol : public VMEmptyResultFunction {      class InstrumentScriptVMFunction_change_vol : public VMEmptyResultFunction {
136      public:      public:
137          InstrumentScriptVMFunction_change_vol(InstrumentScriptVM* parent);          InstrumentScriptVMFunction_change_vol(InstrumentScriptVM* parent);
138          int minRequiredArgs() const { return 2; }          vmint minRequiredArgs() const OVERRIDE { return 2; }
139          int maxAllowedArgs() const { return 3; }          vmint maxAllowedArgs() const OVERRIDE { return 3; }
140          bool acceptsArgType(int iArg, ExprType_t type) const;          bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
141          ExprType_t argType(int iArg) const { return INT_EXPR; }          bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE;
142          VMFnResult* exec(VMFnArgs* args);          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:      protected:
147          InstrumentScriptVM* m_vm;          InstrumentScriptVM* m_vm;
148      };      };
# Line 147  namespace LinuxSampler { Line 150  namespace LinuxSampler {
150      class InstrumentScriptVMFunction_change_tune : public VMEmptyResultFunction {      class InstrumentScriptVMFunction_change_tune : public VMEmptyResultFunction {
151      public:      public:
152          InstrumentScriptVMFunction_change_tune(InstrumentScriptVM* parent);          InstrumentScriptVMFunction_change_tune(InstrumentScriptVM* parent);
153          int minRequiredArgs() const { return 2; }          vmint minRequiredArgs() const OVERRIDE { return 2; }
154          int maxAllowedArgs() const { return 3; }          vmint maxAllowedArgs() const OVERRIDE { return 3; }
155          bool acceptsArgType(int iArg, ExprType_t type) const;          bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
156          ExprType_t argType(int iArg) const { return INT_EXPR; }          bool acceptsArgUnitPrefix(vmint iArg) const OVERRIDE;
157          VMFnResult* exec(VMFnArgs* args);          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:      protected:
161          InstrumentScriptVM* m_vm;          InstrumentScriptVM* m_vm;
162      };      };
# Line 159  namespace LinuxSampler { Line 164  namespace LinuxSampler {
164      class InstrumentScriptVMFunction_change_pan : public VMEmptyResultFunction {      class InstrumentScriptVMFunction_change_pan : public VMEmptyResultFunction {
165      public:      public:
166          InstrumentScriptVMFunction_change_pan(InstrumentScriptVM* parent);          InstrumentScriptVMFunction_change_pan(InstrumentScriptVM* parent);
167          int minRequiredArgs() const { return 2; }          vmint minRequiredArgs() const OVERRIDE { return 2; }
168          int maxAllowedArgs() const { return 3; }          vmint maxAllowedArgs() const OVERRIDE { return 3; }
169          bool acceptsArgType(int iArg, ExprType_t type) const;          bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
170          ExprType_t argType(int iArg) const { return INT_EXPR; }          bool acceptsArgFinal(vmint iArg) const OVERRIDE;
171          VMFnResult* exec(VMFnArgs* args);          ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
172            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
173      protected:      protected:
174          InstrumentScriptVM* m_vm;          InstrumentScriptVM* m_vm;
175      };      };
# Line 171  namespace LinuxSampler { Line 177  namespace LinuxSampler {
177      class InstrumentScriptVMFunction_change_cutoff : public VMEmptyResultFunction {      class InstrumentScriptVMFunction_change_cutoff : public VMEmptyResultFunction {
178      public:      public:
179          InstrumentScriptVMFunction_change_cutoff(InstrumentScriptVM* parent);          InstrumentScriptVMFunction_change_cutoff(InstrumentScriptVM* parent);
180          int minRequiredArgs() const { return 2; }          vmint minRequiredArgs() const OVERRIDE { return 2; }
181          int maxAllowedArgs() const { return 2; }          vmint maxAllowedArgs() const OVERRIDE { return 2; }
182          bool acceptsArgType(int iArg, ExprType_t type) const;          bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
183          ExprType_t argType(int iArg) const { return INT_EXPR; }          bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE;
184          VMFnResult* exec(VMFnArgs* args);          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:      protected:
189          InstrumentScriptVM* m_vm;          InstrumentScriptVM* m_vm;
190      };      };
# Line 183  namespace LinuxSampler { Line 192  namespace LinuxSampler {
192      class InstrumentScriptVMFunction_change_reso : public VMEmptyResultFunction {      class InstrumentScriptVMFunction_change_reso : public VMEmptyResultFunction {
193      public:      public:
194          InstrumentScriptVMFunction_change_reso(InstrumentScriptVM* parent);          InstrumentScriptVMFunction_change_reso(InstrumentScriptVM* parent);
195          int minRequiredArgs() const { return 2; }          vmint minRequiredArgs() const OVERRIDE { return 2; }
196          int maxAllowedArgs() const { return 2; }          vmint maxAllowedArgs() const OVERRIDE { return 2; }
197          bool acceptsArgType(int iArg, ExprType_t type) const;          bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
198          ExprType_t argType(int iArg) const { return INT_EXPR; }          bool acceptsArgFinal(vmint iArg) const OVERRIDE;
199          VMFnResult* exec(VMFnArgs* args);          ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
200            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
201      protected:      protected:
202          InstrumentScriptVM* m_vm;          InstrumentScriptVM* m_vm;
203      };      };
# Line 195  namespace LinuxSampler { Line 205  namespace LinuxSampler {
205      class InstrumentScriptVMFunction_change_attack : public VMEmptyResultFunction {      class InstrumentScriptVMFunction_change_attack : public VMEmptyResultFunction {
206      public:      public:
207          InstrumentScriptVMFunction_change_attack(InstrumentScriptVM* parent);          InstrumentScriptVMFunction_change_attack(InstrumentScriptVM* parent);
208          int minRequiredArgs() const { return 2; }          vmint minRequiredArgs() const OVERRIDE { return 2; }
209          int maxAllowedArgs() const { return 2; }          vmint maxAllowedArgs() const OVERRIDE { return 2; }
210          bool acceptsArgType(int iArg, ExprType_t type) const;          bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
211          ExprType_t argType(int iArg) const { return INT_EXPR; }          bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE;
212          VMFnResult* exec(VMFnArgs* args);          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:      protected:
217          InstrumentScriptVM* m_vm;          InstrumentScriptVM* m_vm;
218      };      };
# Line 207  namespace LinuxSampler { Line 220  namespace LinuxSampler {
220      class InstrumentScriptVMFunction_change_decay : public VMEmptyResultFunction {      class InstrumentScriptVMFunction_change_decay : public VMEmptyResultFunction {
221      public:      public:
222          InstrumentScriptVMFunction_change_decay(InstrumentScriptVM* parent);          InstrumentScriptVMFunction_change_decay(InstrumentScriptVM* parent);
223          int minRequiredArgs() const { return 2; }          vmint minRequiredArgs() const OVERRIDE { return 2; }
224          int maxAllowedArgs() const { return 2; }          vmint maxAllowedArgs() const OVERRIDE { return 2; }
225          bool acceptsArgType(int iArg, ExprType_t type) const;          bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
226          ExprType_t argType(int iArg) const { return INT_EXPR; }          bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE;
227          VMFnResult* exec(VMFnArgs* args);          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:      protected:
232          InstrumentScriptVM* m_vm;          InstrumentScriptVM* m_vm;
233      };      };
# Line 219  namespace LinuxSampler { Line 235  namespace LinuxSampler {
235      class InstrumentScriptVMFunction_change_release : public VMEmptyResultFunction {      class InstrumentScriptVMFunction_change_release : public VMEmptyResultFunction {
236      public:      public:
237          InstrumentScriptVMFunction_change_release(InstrumentScriptVM* parent);          InstrumentScriptVMFunction_change_release(InstrumentScriptVM* parent);
238          int minRequiredArgs() const { return 2; }          vmint minRequiredArgs() const OVERRIDE { return 2; }
239          int maxAllowedArgs() const { return 2; }          vmint maxAllowedArgs() const OVERRIDE { return 2; }
240          bool acceptsArgType(int iArg, ExprType_t type) const;          bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
241          ExprType_t argType(int iArg) const { return INT_EXPR; }          bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE;
242          VMFnResult* exec(VMFnArgs* args);          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:      protected:
247          InstrumentScriptVM* m_vm;          InstrumentScriptVM* m_vm;
248      };      };
249    
250      class VMChangeSynthParamFunction : public VMEmptyResultFunction {      class VMChangeSynthParamFunction : public VMEmptyResultFunction {
251      public:      public:
252          VMChangeSynthParamFunction(InstrumentScriptVM* parent) : m_vm(parent) {}          VMChangeSynthParamFunction(InstrumentScriptVM* parent, bool acceptFinal, StdUnit_t unit)
253          int minRequiredArgs() const { return 2; }              : m_vm(parent), m_acceptFinal(acceptFinal), m_unit(unit) {}
254          int maxAllowedArgs() const { return 2; }          vmint minRequiredArgs() const OVERRIDE { return 2; }
255          bool acceptsArgType(int iArg, ExprType_t type) const;          vmint maxAllowedArgs() const OVERRIDE { return 2; }
256          ExprType_t argType(int iArg) const { return INT_EXPR; }          bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
257            bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE;
258          template<float NoteBase::_Override::*T_noteParam, int T_synthParam,          bool acceptsArgUnitPrefix(vmint iArg) const OVERRIDE;
259                   bool T_isNormalizedParam, int T_maxValue, int T_minValue>          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);          VMFnResult* execTemplate(VMFnArgs* args, const char* functionName);
268      protected:      protected:
269          InstrumentScriptVM* m_vm;          InstrumentScriptVM* m_vm;
270            const bool m_acceptFinal;
271            const StdUnit_t m_unit;
272      };      };
273    
274      class InstrumentScriptVMFunction_change_sustain : public VMChangeSynthParamFunction {      class InstrumentScriptVMFunction_change_sustain : public VMChangeSynthParamFunction {
275      public:      public:
276          InstrumentScriptVMFunction_change_sustain(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent) {}          InstrumentScriptVMFunction_change_sustain(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent,true,VM_BEL) {}
277          VMFnResult* exec(VMFnArgs* args);          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 {      class InstrumentScriptVMFunction_change_amp_lfo_depth : public VMChangeSynthParamFunction {
305      public:      public:
306          InstrumentScriptVMFunction_change_amp_lfo_depth(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent) {}          InstrumentScriptVMFunction_change_amp_lfo_depth(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent,true,VM_NO_UNIT) {}
307          VMFnResult* exec(VMFnArgs* args);          VMFnResult* exec(VMFnArgs* args) OVERRIDE;
308      };      };
309    
310      class InstrumentScriptVMFunction_change_amp_lfo_freq : public VMChangeSynthParamFunction {      class InstrumentScriptVMFunction_change_amp_lfo_freq : public VMChangeSynthParamFunction {
311      public:      public:
312          InstrumentScriptVMFunction_change_amp_lfo_freq(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent) {}          InstrumentScriptVMFunction_change_amp_lfo_freq(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent,true,VM_HERTZ) {}
313          VMFnResult* exec(VMFnArgs* args);          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 {      class InstrumentScriptVMFunction_change_pitch_lfo_depth : public VMChangeSynthParamFunction {
329      public:      public:
330          InstrumentScriptVMFunction_change_pitch_lfo_depth(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent) {}          InstrumentScriptVMFunction_change_pitch_lfo_depth(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent,true,VM_NO_UNIT) {}
331          VMFnResult* exec(VMFnArgs* args);          VMFnResult* exec(VMFnArgs* args) OVERRIDE;
332      };      };
333    
334      class InstrumentScriptVMFunction_change_pitch_lfo_freq : public VMChangeSynthParamFunction {      class InstrumentScriptVMFunction_change_pitch_lfo_freq : public VMChangeSynthParamFunction {
335      public:      public:
336          InstrumentScriptVMFunction_change_pitch_lfo_freq(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent) {}          InstrumentScriptVMFunction_change_pitch_lfo_freq(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent,true,VM_HERTZ) {}
337          VMFnResult* exec(VMFnArgs* args);          VMFnResult* exec(VMFnArgs* args) OVERRIDE;
338      };      };
339    
340      class InstrumentScriptVMFunction_change_vol_time : public VMChangeSynthParamFunction {      class InstrumentScriptVMFunction_change_vol_time : public VMChangeSynthParamFunction {
341      public:      public:
342          InstrumentScriptVMFunction_change_vol_time(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent) {}          InstrumentScriptVMFunction_change_vol_time(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent,false,VM_SECOND) {}
343          VMFnResult* exec(VMFnArgs* args);          VMFnResult* exec(VMFnArgs* args) OVERRIDE;
344      };      };
345    
346      class InstrumentScriptVMFunction_change_tune_time : public VMChangeSynthParamFunction {      class InstrumentScriptVMFunction_change_tune_time : public VMChangeSynthParamFunction {
347      public:      public:
348          InstrumentScriptVMFunction_change_tune_time(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent) {}          InstrumentScriptVMFunction_change_tune_time(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent,false,VM_SECOND) {}
349          VMFnResult* exec(VMFnArgs* args);          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 {      class VMChangeFadeCurveFunction : public VMEmptyResultFunction {
359      public:      public:
360          VMChangeFadeCurveFunction(InstrumentScriptVM* parent) : m_vm(parent) {}          VMChangeFadeCurveFunction(InstrumentScriptVM* parent) : m_vm(parent) {}
361          int minRequiredArgs() const { return 2; }          vmint minRequiredArgs() const OVERRIDE { return 2; }
362          int maxAllowedArgs() const { return 2; }          vmint maxAllowedArgs() const OVERRIDE { return 2; }
363          bool acceptsArgType(int iArg, ExprType_t type) const;          bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
364          ExprType_t argType(int iArg) const { return INT_EXPR; }          ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
365    
366          template<fade_curve_t NoteBase::_Override::*T_noteParam, int T_synthParam>          template<fade_curve_t NoteBase::_Override::*T_noteParam, vmint T_synthParam>
367          VMFnResult* execTemplate(VMFnArgs* args, const char* functionName);          VMFnResult* execTemplate(VMFnArgs* args, const char* functionName);
368      protected:      protected:
369          InstrumentScriptVM* m_vm;          InstrumentScriptVM* m_vm;
# Line 302  namespace LinuxSampler { Line 372  namespace LinuxSampler {
372      class InstrumentScriptVMFunction_change_vol_curve : public VMChangeFadeCurveFunction {      class InstrumentScriptVMFunction_change_vol_curve : public VMChangeFadeCurveFunction {
373      public:      public:
374          InstrumentScriptVMFunction_change_vol_curve(InstrumentScriptVM* parent) : VMChangeFadeCurveFunction(parent) {}          InstrumentScriptVMFunction_change_vol_curve(InstrumentScriptVM* parent) : VMChangeFadeCurveFunction(parent) {}
375          VMFnResult* exec(VMFnArgs* args);          VMFnResult* exec(VMFnArgs* args) OVERRIDE;
376      };      };
377    
378      class InstrumentScriptVMFunction_change_tune_curve : public VMChangeFadeCurveFunction {      class InstrumentScriptVMFunction_change_tune_curve : public VMChangeFadeCurveFunction {
379      public:      public:
380          InstrumentScriptVMFunction_change_tune_curve(InstrumentScriptVM* parent) : VMChangeFadeCurveFunction(parent) {}          InstrumentScriptVMFunction_change_tune_curve(InstrumentScriptVM* parent) : VMChangeFadeCurveFunction(parent) {}
381          VMFnResult* exec(VMFnArgs* args);          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 {      class InstrumentScriptVMFunction_fade_in : public VMEmptyResultFunction {
391      public:      public:
392          InstrumentScriptVMFunction_fade_in(InstrumentScriptVM* parent);          InstrumentScriptVMFunction_fade_in(InstrumentScriptVM* parent);
393          int minRequiredArgs() const { return 2; }          vmint minRequiredArgs() const OVERRIDE { return 2; }
394          int maxAllowedArgs() const { return 2; }          vmint maxAllowedArgs() const OVERRIDE { return 2; }
395          bool acceptsArgType(int iArg, ExprType_t type) const;          bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
396          ExprType_t argType(int iArg) const { return INT_EXPR; }          bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE;
397          VMFnResult* exec(VMFnArgs* args);          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:      protected:
401          InstrumentScriptVM* m_vm;          InstrumentScriptVM* m_vm;
402      };      };
# Line 326  namespace LinuxSampler { Line 404  namespace LinuxSampler {
404      class InstrumentScriptVMFunction_fade_out : public VMEmptyResultFunction {      class InstrumentScriptVMFunction_fade_out : public VMEmptyResultFunction {
405      public:      public:
406          InstrumentScriptVMFunction_fade_out(InstrumentScriptVM* parent);          InstrumentScriptVMFunction_fade_out(InstrumentScriptVM* parent);
407          int minRequiredArgs() const { return 2; }          vmint minRequiredArgs() const OVERRIDE { return 2; }
408          int maxAllowedArgs() const { return 3; }          vmint maxAllowedArgs() const OVERRIDE { return 3; }
409          bool acceptsArgType(int iArg, ExprType_t type) const;          bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
410          ExprType_t argType(int iArg) const { return INT_EXPR; }          bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE;
411          VMFnResult* exec(VMFnArgs* args);          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:      protected:
415          InstrumentScriptVM* m_vm;          InstrumentScriptVM* m_vm;
416      };      };
# Line 338  namespace LinuxSampler { Line 418  namespace LinuxSampler {
418      class InstrumentScriptVMFunction_get_event_par : public VMIntResultFunction {      class InstrumentScriptVMFunction_get_event_par : public VMIntResultFunction {
419      public:      public:
420          InstrumentScriptVMFunction_get_event_par(InstrumentScriptVM* parent);          InstrumentScriptVMFunction_get_event_par(InstrumentScriptVM* parent);
421          int minRequiredArgs() const { return 2; }          vmint minRequiredArgs() const OVERRIDE { return 2; }
422          int maxAllowedArgs() const { return 2; }          vmint maxAllowedArgs() const OVERRIDE { return 2; }
423          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;}
424          ExprType_t argType(int iArg) const { return INT_EXPR; }          ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
425          VMFnResult* exec(VMFnArgs* args);          VMFnResult* exec(VMFnArgs* args) OVERRIDE;
426      protected:      protected:
427          InstrumentScriptVM* m_vm;          InstrumentScriptVM* m_vm;
428      };      };
# Line 350  namespace LinuxSampler { Line 430  namespace LinuxSampler {
430      class InstrumentScriptVMFunction_set_event_par : public VMEmptyResultFunction {      class InstrumentScriptVMFunction_set_event_par : public VMEmptyResultFunction {
431      public:      public:
432          InstrumentScriptVMFunction_set_event_par(InstrumentScriptVM* parent);          InstrumentScriptVMFunction_set_event_par(InstrumentScriptVM* parent);
433          int minRequiredArgs() const { return 3; }          vmint minRequiredArgs() const OVERRIDE { return 3; }
434          int maxAllowedArgs() const { return 3; }          vmint maxAllowedArgs() const OVERRIDE { return 3; }
435          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;}
436          ExprType_t argType(int iArg) const { return INT_EXPR; }          ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
437          VMFnResult* exec(VMFnArgs* args);          VMFnResult* exec(VMFnArgs* args) OVERRIDE;
438      protected:      protected:
439          InstrumentScriptVM* m_vm;          InstrumentScriptVM* m_vm;
440      };      };
# Line 362  namespace LinuxSampler { Line 442  namespace LinuxSampler {
442      class InstrumentScriptVMFunction_change_note : public VMEmptyResultFunction {      class InstrumentScriptVMFunction_change_note : public VMEmptyResultFunction {
443      public:      public:
444          InstrumentScriptVMFunction_change_note(InstrumentScriptVM* parent);          InstrumentScriptVMFunction_change_note(InstrumentScriptVM* parent);
445          int minRequiredArgs() const { return 2; }          vmint minRequiredArgs() const OVERRIDE { return 2; }
446          int maxAllowedArgs() const { return 2; }          vmint maxAllowedArgs() const OVERRIDE { return 2; }
447          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;}
448          ExprType_t argType(int iArg) const { return INT_EXPR; }          ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
449          VMFnResult* exec(VMFnArgs* args);          VMFnResult* exec(VMFnArgs* args) OVERRIDE;
450      protected:      protected:
451          InstrumentScriptVM* m_vm;          InstrumentScriptVM* m_vm;
452      };      };
# Line 374  namespace LinuxSampler { Line 454  namespace LinuxSampler {
454      class InstrumentScriptVMFunction_change_velo : public VMEmptyResultFunction {      class InstrumentScriptVMFunction_change_velo : public VMEmptyResultFunction {
455      public:      public:
456          InstrumentScriptVMFunction_change_velo(InstrumentScriptVM* parent);          InstrumentScriptVMFunction_change_velo(InstrumentScriptVM* parent);
457          int minRequiredArgs() const { return 2; }          vmint minRequiredArgs() const OVERRIDE { return 2; }
458          int maxAllowedArgs() const { return 2; }          vmint maxAllowedArgs() const OVERRIDE { return 2; }
459          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;}
460          ExprType_t argType(int iArg) const { return INT_EXPR; }          ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
461          VMFnResult* exec(VMFnArgs* args);          VMFnResult* exec(VMFnArgs* args) OVERRIDE;
462      protected:      protected:
463          InstrumentScriptVM* m_vm;          InstrumentScriptVM* m_vm;
464      };      };
# Line 386  namespace LinuxSampler { Line 466  namespace LinuxSampler {
466      class InstrumentScriptVMFunction_change_play_pos : public VMEmptyResultFunction {      class InstrumentScriptVMFunction_change_play_pos : public VMEmptyResultFunction {
467      public:      public:
468          InstrumentScriptVMFunction_change_play_pos(InstrumentScriptVM* parent);          InstrumentScriptVMFunction_change_play_pos(InstrumentScriptVM* parent);
469          int minRequiredArgs() const { return 2; }          vmint minRequiredArgs() const OVERRIDE { return 2; }
470          int maxAllowedArgs() const { return 2; }          vmint maxAllowedArgs() const OVERRIDE { return 2; }
471          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; }
472          ExprType_t argType(int iArg) const { return INT_EXPR; }          bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE;
473          VMFnResult* exec(VMFnArgs* args);          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:      protected:
477          InstrumentScriptVM* m_vm;          InstrumentScriptVM* m_vm;
478      };      };
# Line 398  namespace LinuxSampler { Line 480  namespace LinuxSampler {
480      class InstrumentScriptVMFunction_event_status : public VMIntResultFunction {      class InstrumentScriptVMFunction_event_status : public VMIntResultFunction {
481      public:      public:
482          InstrumentScriptVMFunction_event_status(InstrumentScriptVM* parent);          InstrumentScriptVMFunction_event_status(InstrumentScriptVM* parent);
483          int minRequiredArgs() const { return 1; }          vmint minRequiredArgs() const OVERRIDE { return 1; }
484          int maxAllowedArgs() const { return 1; }          vmint maxAllowedArgs() const OVERRIDE { return 1; }
485          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;}
486          ExprType_t argType(int iArg) const { return INT_EXPR; }          ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
487          VMFnResult* exec(VMFnArgs* args);          VMFnResult* exec(VMFnArgs* args) OVERRIDE;
488      protected:      protected:
489          InstrumentScriptVM* m_vm;          InstrumentScriptVM* m_vm;
490      };      };
# Line 410  namespace LinuxSampler { Line 492  namespace LinuxSampler {
492      class InstrumentScriptVMFunction_callback_status : public VMIntResultFunction {      class InstrumentScriptVMFunction_callback_status : public VMIntResultFunction {
493      public:      public:
494          InstrumentScriptVMFunction_callback_status(InstrumentScriptVM* parent);          InstrumentScriptVMFunction_callback_status(InstrumentScriptVM* parent);
495          int minRequiredArgs() const { return 1; }          vmint minRequiredArgs() const OVERRIDE { return 1; }
496          int maxAllowedArgs() const { return 1; }          vmint maxAllowedArgs() const OVERRIDE { return 1; }
497          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;}
498          ExprType_t argType(int iArg) const { return INT_EXPR; }          ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
499          VMFnResult* exec(VMFnArgs* args);          VMFnResult* exec(VMFnArgs* args) OVERRIDE;
500      protected:      protected:
501          InstrumentScriptVM* m_vm;          InstrumentScriptVM* m_vm;
502      };      };
# Line 423  namespace LinuxSampler { Line 505  namespace LinuxSampler {
505      class InstrumentScriptVMFunction_wait : public CoreVMFunction_wait {      class InstrumentScriptVMFunction_wait : public CoreVMFunction_wait {
506      public:      public:
507          InstrumentScriptVMFunction_wait(InstrumentScriptVM* parent);          InstrumentScriptVMFunction_wait(InstrumentScriptVM* parent);
508          VMFnResult* exec(VMFnArgs* args);          VMFnResult* exec(VMFnArgs* args) OVERRIDE;
509      };      };
510    
511      class InstrumentScriptVMFunction_stop_wait : public VMEmptyResultFunction {      class InstrumentScriptVMFunction_stop_wait : public VMEmptyResultFunction {
512      public:      public:
513          InstrumentScriptVMFunction_stop_wait(InstrumentScriptVM* parent);          InstrumentScriptVMFunction_stop_wait(InstrumentScriptVM* parent);
514          int minRequiredArgs() const { return 1; }          vmint minRequiredArgs() const OVERRIDE { return 1; }
515          int maxAllowedArgs() const { return 2; }          vmint maxAllowedArgs() const OVERRIDE { return 2; }
516          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;}
517          ExprType_t argType(int iArg) const { return INT_EXPR; }          ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
518          VMFnResult* exec(VMFnArgs* args);          VMFnResult* exec(VMFnArgs* args) OVERRIDE;
519      protected:      protected:
520          InstrumentScriptVM* m_vm;          InstrumentScriptVM* m_vm;
521      };      };
# Line 441  namespace LinuxSampler { Line 523  namespace LinuxSampler {
523      class InstrumentScriptVMFunction_abort : public VMEmptyResultFunction {      class InstrumentScriptVMFunction_abort : public VMEmptyResultFunction {
524      public:      public:
525          InstrumentScriptVMFunction_abort(InstrumentScriptVM* parent);          InstrumentScriptVMFunction_abort(InstrumentScriptVM* parent);
526          int minRequiredArgs() const { return 1; }          vmint minRequiredArgs() const OVERRIDE { return 1; }
527          int maxAllowedArgs() const { return 1; }          vmint maxAllowedArgs() const OVERRIDE { return 1; }
528          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; }
529          ExprType_t argType(int iArg) const { return INT_EXPR; }          ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
530          VMFnResult* exec(VMFnArgs* args) OVERRIDE;          VMFnResult* exec(VMFnArgs* args) OVERRIDE;
531      protected:      protected:
532          InstrumentScriptVM* m_vm;          InstrumentScriptVM* m_vm;
# Line 453  namespace LinuxSampler { Line 535  namespace LinuxSampler {
535      class InstrumentScriptVMFunction_fork : public VMIntResultFunction {      class InstrumentScriptVMFunction_fork : public VMIntResultFunction {
536      public:      public:
537          InstrumentScriptVMFunction_fork(InstrumentScriptVM* parent);          InstrumentScriptVMFunction_fork(InstrumentScriptVM* parent);
538          int minRequiredArgs() const { return 0; }          vmint minRequiredArgs() const OVERRIDE { return 0; }
539          int maxAllowedArgs() const { return 2; }          vmint maxAllowedArgs() const OVERRIDE { return 2; }
540          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;}
541          ExprType_t argType(int iArg) const { return INT_EXPR; }          ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
542          VMFnResult* exec(VMFnArgs* args);          VMFnResult* exec(VMFnArgs* args) OVERRIDE;
543      protected:      protected:
544          InstrumentScriptVM* m_vm;          InstrumentScriptVM* m_vm;
545      };      };
Legend:
Removed from v.3316  
changed lines
  Added in v.3561
  ViewVC Help
Powered by ViewVC