/[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 3212 by schoenebeck, Thu May 25 13:17:47 2017 UTC revision 3691 by schoenebeck, Fri Jan 3 12:35:20 2020 UTC
# Line 1  Line 1 
1  /*  /*
2   * Copyright (c) 2014 - 2017 Christian Schoenebeck   * Copyright (c) 2014 - 2020 Christian Schoenebeck
3   *   *
4   * http://www.linuxsampler.org   * http://www.linuxsampler.org
5   *   *
# Line 19  namespace LinuxSampler { Line 19  namespace LinuxSampler {
19      class EventGroup;      class EventGroup;
20      class InstrumentScriptVM;      class InstrumentScriptVM;
21    
22      class InstrumentScriptVMFunction_play_note : public VMIntResultFunction {      class InstrumentScriptVMFunction_play_note FINAL : public VMIntResultFunction {
23            using Super = VMIntResultFunction; // just an alias for the super class
24      public:      public:
25          InstrumentScriptVMFunction_play_note(InstrumentScriptVM* parent);          InstrumentScriptVMFunction_play_note(InstrumentScriptVM* parent);
26          int minRequiredArgs() const { return 1; }          StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE { return VM_NO_UNIT; }
27          int maxAllowedArgs() const { return 4; }          bool returnsFinal(VMFnArgs* args) OVERRIDE { return false; }
28          bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR;}          vmint minRequiredArgs() const OVERRIDE { return 1; }
29          ExprType_t argType(int iArg) const { return INT_EXPR; }          vmint maxAllowedArgs() const OVERRIDE { return 4; }
30          VMFnResult* exec(VMFnArgs* args);          bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
31            bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE;
32            bool acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const OVERRIDE;
33            void checkArgs(VMFnArgs* args, std::function<void(String)> err,
34                           std::function<void(String)> wrn) OVERRIDE;
35            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
36      protected:      protected:
37          InstrumentScriptVM* m_vm;          InstrumentScriptVM* m_vm;
38      };      };
39    
40      class InstrumentScriptVMFunction_set_controller : public VMIntResultFunction {      class InstrumentScriptVMFunction_set_controller FINAL : public VMIntResultFunction {
41      public:      public:
42          InstrumentScriptVMFunction_set_controller(InstrumentScriptVM* parent);          InstrumentScriptVMFunction_set_controller(InstrumentScriptVM* parent);
43          int minRequiredArgs() const { return 2; }          StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE { return VM_NO_UNIT; }
44          int maxAllowedArgs() const { return 2; }          bool returnsFinal(VMFnArgs* args) OVERRIDE { return false; }
45          bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR;}          vmint minRequiredArgs() const OVERRIDE { return 2; }
46          ExprType_t argType(int iArg) const { return INT_EXPR; }          vmint maxAllowedArgs() const OVERRIDE { return 2; }
47          VMFnResult* exec(VMFnArgs* args);          bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR;}
48            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
49        protected:
50            InstrumentScriptVM* m_vm;
51        };
52    
53        class InstrumentScriptVMFunction_set_rpn FINAL : public VMIntResultFunction {
54        public:
55            InstrumentScriptVMFunction_set_rpn(InstrumentScriptVM* parent);
56            StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE { return VM_NO_UNIT; }
57            bool returnsFinal(VMFnArgs* args) OVERRIDE { return false; }
58            vmint minRequiredArgs() const OVERRIDE { return 2; }
59            vmint maxAllowedArgs() const OVERRIDE { return 2; }
60            bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR;}
61            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
62      protected:      protected:
63          InstrumentScriptVM* m_vm;          InstrumentScriptVM* m_vm;
64      };      };
65    
66      class InstrumentScriptVMFunction_ignore_event : public VMEmptyResultFunction {      class InstrumentScriptVMFunction_set_nrpn FINAL : public VMIntResultFunction {
67        public:
68            InstrumentScriptVMFunction_set_nrpn(InstrumentScriptVM* parent);
69            StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE { return VM_NO_UNIT; }
70            bool returnsFinal(VMFnArgs* args) OVERRIDE { return false; }
71            vmint minRequiredArgs() const OVERRIDE { return 2; }
72            vmint maxAllowedArgs() const OVERRIDE { return 2; }
73            bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR;}
74            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
75        protected:
76            InstrumentScriptVM* m_vm;
77        };
78    
79        class InstrumentScriptVMFunction_ignore_event FINAL : public VMEmptyResultFunction {
80      public:      public:
81          InstrumentScriptVMFunction_ignore_event(InstrumentScriptVM* parent);          InstrumentScriptVMFunction_ignore_event(InstrumentScriptVM* parent);
82          int minRequiredArgs() const { return 0; }          vmint minRequiredArgs() const OVERRIDE { return 0; }
83          int maxAllowedArgs() const { return 1; }          vmint maxAllowedArgs() const OVERRIDE { return 1; }
84          bool acceptsArgType(int iArg, ExprType_t type) const;          bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
85          ExprType_t argType(int iArg) const { return INT_EXPR; }          VMFnResult* exec(VMFnArgs* args) OVERRIDE;
         VMFnResult* exec(VMFnArgs* args);  
86      protected:      protected:
87          InstrumentScriptVM* m_vm;          InstrumentScriptVM* m_vm;
88      };      };
89    
90      class InstrumentScriptVMFunction_ignore_controller : public VMEmptyResultFunction {      class InstrumentScriptVMFunction_ignore_controller FINAL : public VMEmptyResultFunction {
91      public:      public:
92          InstrumentScriptVMFunction_ignore_controller(InstrumentScriptVM* parent);          InstrumentScriptVMFunction_ignore_controller(InstrumentScriptVM* parent);
93          int minRequiredArgs() const { return 0; }          vmint minRequiredArgs() const OVERRIDE { return 0; }
94          int maxAllowedArgs() const { return 1; }          vmint maxAllowedArgs() const OVERRIDE { return 1; }
95          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;}
96          ExprType_t argType(int iArg) const { return INT_EXPR; }          VMFnResult* exec(VMFnArgs* args) OVERRIDE;
         VMFnResult* exec(VMFnArgs* args);  
97      protected:      protected:
98          InstrumentScriptVM* m_vm;          InstrumentScriptVM* m_vm;
99      };      };
100    
101      class InstrumentScriptVMFunction_note_off : public VMEmptyResultFunction {      class InstrumentScriptVMFunction_note_off FINAL : public VMEmptyResultFunction {
102            using Super = VMEmptyResultFunction; // just an alias for the super class
103      public:      public:
104          InstrumentScriptVMFunction_note_off(InstrumentScriptVM* parent);          InstrumentScriptVMFunction_note_off(InstrumentScriptVM* parent);
105          int minRequiredArgs() const { return 1; }          vmint minRequiredArgs() const OVERRIDE { return 1; }
106          int maxAllowedArgs() const { return 2; }          vmint maxAllowedArgs() const OVERRIDE { return 2; }
107          bool acceptsArgType(int iArg, ExprType_t type) const;          bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
108          ExprType_t argType(int iArg) const { return INT_EXPR; }          void checkArgs(VMFnArgs* args, std::function<void(String)> err,
109          VMFnResult* exec(VMFnArgs* args);                         std::function<void(String)> wrn) OVERRIDE;
110            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
111      protected:      protected:
112          InstrumentScriptVM* m_vm;          InstrumentScriptVM* m_vm;
113      };      };
114    
115      class InstrumentScriptVMFunction_set_event_mark : public VMEmptyResultFunction {      class InstrumentScriptVMFunction_set_event_mark FINAL : public VMEmptyResultFunction {
116            using Super = VMEmptyResultFunction; // just an alias for the super class
117      public:      public:
118          InstrumentScriptVMFunction_set_event_mark(InstrumentScriptVM* parent);          InstrumentScriptVMFunction_set_event_mark(InstrumentScriptVM* parent);
119          int minRequiredArgs() const { return 2; }          vmint minRequiredArgs() const OVERRIDE { return 2; }
120          int maxAllowedArgs() const { return 2; }          vmint maxAllowedArgs() const OVERRIDE { return 2; }
121          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;}
122          ExprType_t argType(int iArg) const { return INT_EXPR; }          void checkArgs(VMFnArgs* args, std::function<void(String)> err,
123          VMFnResult* exec(VMFnArgs* args);                         std::function<void(String)> wrn) OVERRIDE;
124            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
125      protected:      protected:
126          InstrumentScriptVM* m_vm;          InstrumentScriptVM* m_vm;
127      };      };
128    
129      class InstrumentScriptVMFunction_delete_event_mark : public VMEmptyResultFunction {      class InstrumentScriptVMFunction_delete_event_mark FINAL : public VMEmptyResultFunction {
130            using Super = VMEmptyResultFunction; // just an alias for the super class
131      public:      public:
132          InstrumentScriptVMFunction_delete_event_mark(InstrumentScriptVM* parent);          InstrumentScriptVMFunction_delete_event_mark(InstrumentScriptVM* parent);
133          int minRequiredArgs() const { return 2; }          vmint minRequiredArgs() const OVERRIDE { return 2; }
134          int maxAllowedArgs() const { return 2; }          vmint maxAllowedArgs() const OVERRIDE { return 2; }
135          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;}
136          ExprType_t argType(int iArg) const { return INT_EXPR; }          void checkArgs(VMFnArgs* args, std::function<void(String)> err,
137          VMFnResult* exec(VMFnArgs* args);                         std::function<void(String)> wrn) OVERRIDE;
138            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
139      protected:      protected:
140          InstrumentScriptVM* m_vm;          InstrumentScriptVM* m_vm;
141      };      };
142    
143      class InstrumentScriptVMFunction_by_marks : public VMFunction {      class InstrumentScriptVMFunction_by_marks FINAL : public VMFunction {
144            using Super = VMFunction; // just an alias for the super class
145      public:      public:
146          InstrumentScriptVMFunction_by_marks(InstrumentScriptVM* parent);          InstrumentScriptVMFunction_by_marks(InstrumentScriptVM* parent);
147          int minRequiredArgs() const OVERRIDE { return 1; }          StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE { return VM_NO_UNIT; }
148          int maxAllowedArgs() const OVERRIDE { return 1; }          bool returnsFinal(VMFnArgs* args) OVERRIDE { return false; }
149          bool acceptsArgType(int iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR;}          vmint minRequiredArgs() const OVERRIDE { return 1; }
150          bool modifiesArg(int iArg) const OVERRIDE { return false; }          vmint maxAllowedArgs() const OVERRIDE { return 1; }
151          ExprType_t argType(int iArg) const OVERRIDE { return INT_EXPR; }          bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR;}
152          ExprType_t returnType() OVERRIDE { return INT_ARR_EXPR; }          bool modifiesArg(vmint iArg) const OVERRIDE { return false; }
153            ExprType_t returnType(VMFnArgs* args) OVERRIDE { return INT_ARR_EXPR; }
154            void checkArgs(VMFnArgs* args, std::function<void(String)> err,
155                           std::function<void(String)> wrn) OVERRIDE;
156          VMFnResult* exec(VMFnArgs* args) OVERRIDE;          VMFnResult* exec(VMFnArgs* args) OVERRIDE;
157      protected:      protected:
158          InstrumentScriptVM* m_vm;          InstrumentScriptVM* m_vm;
# Line 120  namespace LinuxSampler { Line 161  namespace LinuxSampler {
161              StmtFlags_t flags;              StmtFlags_t flags;
162              EventGroup* eventGroup;              EventGroup* eventGroup;
163    
164              int arraySize() const OVERRIDE;              vmint arraySize() const OVERRIDE;
165              int evalIntElement(uint i) OVERRIDE;              vmint evalIntElement(vmuint i) OVERRIDE;
166              void assignIntElement(uint i, int value) OVERRIDE {} // ignore assignment              void assignIntElement(vmuint i, vmint value) OVERRIDE {} // ignore assignment
167                vmfloat unitFactorOfElement(vmuint i) const OVERRIDE { return VM_NO_FACTOR; }
168                void assignElementUnitFactor(vmuint i, vmfloat factor) OVERRIDE {} // ignore assignment
169              VMExpr* resultValue() OVERRIDE { return this; }              VMExpr* resultValue() OVERRIDE { return this; }
170              StmtFlags_t resultFlags() OVERRIDE { return flags; }              StmtFlags_t resultFlags() OVERRIDE { return flags; }
171              bool isConstExpr() const OVERRIDE { return false; }              bool isConstExpr() const OVERRIDE { return false; }
# Line 132  namespace LinuxSampler { Line 175  namespace LinuxSampler {
175          VMFnResult* successResult(EventGroup* eventGroup);          VMFnResult* successResult(EventGroup* eventGroup);
176      };      };
177    
178      class InstrumentScriptVMFunction_change_vol : public VMEmptyResultFunction {      class InstrumentScriptVMFunction_change_vol FINAL : public VMEmptyResultFunction {
179      public:      public:
180          InstrumentScriptVMFunction_change_vol(InstrumentScriptVM* parent);          InstrumentScriptVMFunction_change_vol(InstrumentScriptVM* parent);
181          int minRequiredArgs() const { return 2; }          vmint minRequiredArgs() const OVERRIDE { return 2; }
182          int maxAllowedArgs() const { return 3; }          vmint maxAllowedArgs() const OVERRIDE { return 3; }
183          bool acceptsArgType(int iArg, ExprType_t type) const;          bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
184          ExprType_t argType(int iArg) const { return INT_EXPR; }          bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE;
185          VMFnResult* exec(VMFnArgs* args);          bool acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const OVERRIDE;
186            bool acceptsArgFinal(vmint iArg) const OVERRIDE;
187            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
188      protected:      protected:
189          InstrumentScriptVM* m_vm;          InstrumentScriptVM* m_vm;
190      };      };
191    
192      class InstrumentScriptVMFunction_change_tune : public VMEmptyResultFunction {      class InstrumentScriptVMFunction_change_tune FINAL : public VMEmptyResultFunction {
193      public:      public:
194          InstrumentScriptVMFunction_change_tune(InstrumentScriptVM* parent);          InstrumentScriptVMFunction_change_tune(InstrumentScriptVM* parent);
195          int minRequiredArgs() const { return 2; }          vmint minRequiredArgs() const OVERRIDE { return 2; }
196          int maxAllowedArgs() const { return 3; }          vmint maxAllowedArgs() const OVERRIDE { return 3; }
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 acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const OVERRIDE;
199          VMFnResult* exec(VMFnArgs* args);          bool acceptsArgFinal(vmint iArg) const OVERRIDE;
200            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
201      protected:      protected:
202          InstrumentScriptVM* m_vm;          InstrumentScriptVM* m_vm;
203      };      };
204    
205      class InstrumentScriptVMFunction_change_pan : public VMEmptyResultFunction {      class InstrumentScriptVMFunction_change_pan FINAL : public VMEmptyResultFunction {
206      public:      public:
207          InstrumentScriptVMFunction_change_pan(InstrumentScriptVM* parent);          InstrumentScriptVMFunction_change_pan(InstrumentScriptVM* parent);
208          int minRequiredArgs() const { return 2; }          vmint minRequiredArgs() const OVERRIDE { return 2; }
209          int maxAllowedArgs() const { return 3; }          vmint maxAllowedArgs() const OVERRIDE { return 3; }
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 acceptsArgFinal(vmint iArg) const OVERRIDE;
212          VMFnResult* exec(VMFnArgs* args);          VMFnResult* exec(VMFnArgs* args) OVERRIDE;
213      protected:      protected:
214          InstrumentScriptVM* m_vm;          InstrumentScriptVM* m_vm;
215      };      };
216    
217      class InstrumentScriptVMFunction_change_cutoff : public VMEmptyResultFunction {      class InstrumentScriptVMFunction_change_cutoff FINAL : public VMEmptyResultFunction {
218            using Super = VMEmptyResultFunction; // just an alias for the super class
219      public:      public:
220          InstrumentScriptVMFunction_change_cutoff(InstrumentScriptVM* parent);          InstrumentScriptVMFunction_change_cutoff(InstrumentScriptVM* parent);
221          int minRequiredArgs() const { return 2; }          vmint minRequiredArgs() const OVERRIDE { return 2; }
222          int maxAllowedArgs() const { return 2; }          vmint maxAllowedArgs() const OVERRIDE { return 2; }
223          bool acceptsArgType(int iArg, ExprType_t type) const;          bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
224          ExprType_t argType(int iArg) const { return INT_EXPR; }          bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE;
225          VMFnResult* exec(VMFnArgs* args);          bool acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const OVERRIDE;
226            bool acceptsArgFinal(vmint iArg) const OVERRIDE;
227            void checkArgs(VMFnArgs* args, std::function<void(String)> err,
228                           std::function<void(String)> wrn) OVERRIDE;
229            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
230      protected:      protected:
231          InstrumentScriptVM* m_vm;          InstrumentScriptVM* m_vm;
232      };      };
233    
234      class InstrumentScriptVMFunction_change_reso : public VMEmptyResultFunction {      class InstrumentScriptVMFunction_change_reso FINAL : public VMEmptyResultFunction {
235      public:      public:
236          InstrumentScriptVMFunction_change_reso(InstrumentScriptVM* parent);          InstrumentScriptVMFunction_change_reso(InstrumentScriptVM* parent);
237          int minRequiredArgs() const { return 2; }          vmint minRequiredArgs() const OVERRIDE { return 2; }
238          int maxAllowedArgs() const { return 2; }          vmint maxAllowedArgs() const OVERRIDE { return 2; }
239          bool acceptsArgType(int iArg, ExprType_t type) const;          bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
240          ExprType_t argType(int iArg) const { return INT_EXPR; }          bool acceptsArgFinal(vmint iArg) const OVERRIDE;
241          VMFnResult* exec(VMFnArgs* args);          VMFnResult* exec(VMFnArgs* args) OVERRIDE;
242      protected:      protected:
243          InstrumentScriptVM* m_vm;          InstrumentScriptVM* m_vm;
244      };      };
245            
246      class InstrumentScriptVMFunction_change_attack : public VMEmptyResultFunction {      class InstrumentScriptVMFunction_change_attack FINAL : public VMEmptyResultFunction {
247            using Super = VMEmptyResultFunction; // just an alias for the super class
248      public:      public:
249          InstrumentScriptVMFunction_change_attack(InstrumentScriptVM* parent);          InstrumentScriptVMFunction_change_attack(InstrumentScriptVM* parent);
250          int minRequiredArgs() const { return 2; }          vmint minRequiredArgs() const OVERRIDE { return 2; }
251          int maxAllowedArgs() const { return 2; }          vmint maxAllowedArgs() const OVERRIDE { return 2; }
252          bool acceptsArgType(int iArg, ExprType_t type) const;          bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
253          ExprType_t argType(int iArg) const { return INT_EXPR; }          bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE;
254          VMFnResult* exec(VMFnArgs* args);          bool acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const OVERRIDE;
255            bool acceptsArgFinal(vmint iArg) const OVERRIDE;
256            void checkArgs(VMFnArgs* args, std::function<void(String)> err,
257                           std::function<void(String)> wrn) OVERRIDE;
258            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
259      protected:      protected:
260          InstrumentScriptVM* m_vm;          InstrumentScriptVM* m_vm;
261      };      };
262    
263      class InstrumentScriptVMFunction_change_decay : public VMEmptyResultFunction {      class InstrumentScriptVMFunction_change_decay FINAL : public VMEmptyResultFunction {
264            using Super = VMEmptyResultFunction; // just an alias for the super class
265      public:      public:
266          InstrumentScriptVMFunction_change_decay(InstrumentScriptVM* parent);          InstrumentScriptVMFunction_change_decay(InstrumentScriptVM* parent);
267          int minRequiredArgs() const { return 2; }          vmint minRequiredArgs() const OVERRIDE { return 2; }
268          int maxAllowedArgs() const { return 2; }          vmint maxAllowedArgs() const OVERRIDE { return 2; }
269          bool acceptsArgType(int iArg, ExprType_t type) const;          bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
270          ExprType_t argType(int iArg) const { return INT_EXPR; }          bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE;
271          VMFnResult* exec(VMFnArgs* args);          bool acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const OVERRIDE;
272            bool acceptsArgFinal(vmint iArg) const OVERRIDE;
273            void checkArgs(VMFnArgs* args, std::function<void(String)> err,
274                           std::function<void(String)> wrn) OVERRIDE;
275            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
276      protected:      protected:
277          InstrumentScriptVM* m_vm;          InstrumentScriptVM* m_vm;
278      };      };
279            
280      class InstrumentScriptVMFunction_change_release : public VMEmptyResultFunction {      class InstrumentScriptVMFunction_change_release FINAL : public VMEmptyResultFunction {
281            using Super = VMEmptyResultFunction; // just an alias for the super class
282      public:      public:
283          InstrumentScriptVMFunction_change_release(InstrumentScriptVM* parent);          InstrumentScriptVMFunction_change_release(InstrumentScriptVM* parent);
284          int minRequiredArgs() const { return 2; }          vmint minRequiredArgs() const OVERRIDE { return 2; }
285          int maxAllowedArgs() const { return 2; }          vmint maxAllowedArgs() const OVERRIDE { return 2; }
286          bool acceptsArgType(int iArg, ExprType_t type) const;          bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
287          ExprType_t argType(int iArg) const { return INT_EXPR; }          bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE;
288          VMFnResult* exec(VMFnArgs* args);          bool acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const OVERRIDE;
289            bool acceptsArgFinal(vmint iArg) const OVERRIDE;
290            void checkArgs(VMFnArgs* args, std::function<void(String)> err,
291                           std::function<void(String)> wrn) OVERRIDE;
292            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
293      protected:      protected:
294          InstrumentScriptVM* m_vm;          InstrumentScriptVM* m_vm;
295      };      };
296    
297      class VMChangeSynthParamFunction : public VMEmptyResultFunction {      class VMChangeSynthParamFunction : public VMEmptyResultFunction {
298            using Super = VMEmptyResultFunction; // just an alias for the super class
299      public:      public:
300          VMChangeSynthParamFunction(InstrumentScriptVM* parent) : m_vm(parent) {}          struct Opt_t {
301          int minRequiredArgs() const { return 2; }              InstrumentScriptVM* vm = NULL; ///< Parent object owning the built-in function implementation object.
302          int maxAllowedArgs() const { return 2; }              bool acceptFinal = false; ///< Whether built-in function allows 'final' operator for its 2nd function argument.
303          bool acceptsArgType(int iArg, ExprType_t type) const;              StdUnit_t unit = VM_NO_UNIT; ///< Whether built-in functions accepts a unit type for its 2nd function argument and if yes which one.
304          ExprType_t argType(int iArg) const { return INT_EXPR; }              bool acceptUnitPrefix = false; ///< Whether built-in function accepts metric unit prefix(es) for its 2nd function argument.
305                bool acceptReal = false; ///< Whether the built-in function accepts both int and real number as data type for its 2nd function argument (otherwise its int only if false).
306          template<float NoteBase::_Override::*T_noteParam, int T_synthParam,          };
307                   bool T_isNormalizedParam, int T_maxValue, int T_minValue>          VMChangeSynthParamFunction(const Opt_t& opt)
308                : m_vm(opt.vm), m_acceptReal(opt.acceptReal),
309                  m_acceptFinal(opt.acceptFinal),
310                  m_acceptUnitPrefix(opt.acceptUnitPrefix), m_unit(opt.unit) {}
311            vmint minRequiredArgs() const OVERRIDE { return 2; }
312            vmint maxAllowedArgs() const OVERRIDE { return 2; }
313            bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
314            bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE;
315            bool acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const OVERRIDE;
316            bool acceptsArgFinal(vmint iArg) const OVERRIDE;
317            void checkArgs(VMFnArgs* args, std::function<void(String)> err,
318                           std::function<void(String)> wrn) OVERRIDE;
319    
320            template<class T_NoteParamType, T_NoteParamType NoteBase::_Override::*T_noteParam,
321                    vmint T_synthParam,
322                    vmint T_minValueNorm, vmint T_maxValueNorm, bool T_normalizeNorm,
323                    vmint T_minValueUnit, vmint T_maxValueUnit,
324                    MetricPrefix_t T_unitPrefix0, MetricPrefix_t ... T_unitPrefixN>
325          VMFnResult* execTemplate(VMFnArgs* args, const char* functionName);          VMFnResult* execTemplate(VMFnArgs* args, const char* functionName);
326      protected:      protected:
327          InstrumentScriptVM* m_vm;          InstrumentScriptVM* const m_vm;
328            const bool m_acceptReal;
329            const bool m_acceptFinal;
330            const bool m_acceptUnitPrefix;
331            const StdUnit_t m_unit;
332        };
333    
334        class InstrumentScriptVMFunction_change_sustain FINAL : public VMChangeSynthParamFunction {
335        public:
336            InstrumentScriptVMFunction_change_sustain(InstrumentScriptVM* parent) : VMChangeSynthParamFunction({
337                .vm = parent,
338                .acceptFinal = true,
339                .unit = VM_BEL,
340                .acceptUnitPrefix = true,
341                .acceptReal = true,
342            }) {}
343            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
344        };
345    
346        class InstrumentScriptVMFunction_change_cutoff_attack FINAL : public VMChangeSynthParamFunction {
347        public:
348            InstrumentScriptVMFunction_change_cutoff_attack(InstrumentScriptVM* parent) : VMChangeSynthParamFunction({
349                .vm = parent,
350                .acceptFinal = true,
351                .unit = VM_SECOND,
352                .acceptUnitPrefix = true,
353                .acceptReal = true,
354            }) {}
355            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
356        };
357    
358        class InstrumentScriptVMFunction_change_cutoff_decay FINAL : public VMChangeSynthParamFunction {
359        public:
360            InstrumentScriptVMFunction_change_cutoff_decay(InstrumentScriptVM* parent) : VMChangeSynthParamFunction({
361                .vm = parent,
362                .acceptFinal = true,
363                .unit = VM_SECOND,
364                .acceptUnitPrefix = true,
365                .acceptReal = true,
366            }) {}
367            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
368        };
369    
370        class InstrumentScriptVMFunction_change_cutoff_sustain FINAL : public VMChangeSynthParamFunction {
371        public:
372            InstrumentScriptVMFunction_change_cutoff_sustain(InstrumentScriptVM* parent) : VMChangeSynthParamFunction({
373                .vm = parent,
374                .acceptFinal = true,
375                .unit = VM_BEL,
376                .acceptUnitPrefix = true,
377                .acceptReal = true,
378            }) {}
379            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
380        };
381    
382        class InstrumentScriptVMFunction_change_cutoff_release FINAL : public VMChangeSynthParamFunction {
383        public:
384            InstrumentScriptVMFunction_change_cutoff_release(InstrumentScriptVM* parent) : VMChangeSynthParamFunction({
385                .vm = parent,
386                .acceptFinal = true,
387                .unit = VM_SECOND,
388                .acceptUnitPrefix = true,
389                .acceptReal = true,
390            }) {}
391            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
392        };
393    
394        class InstrumentScriptVMFunction_change_amp_lfo_depth FINAL : public VMChangeSynthParamFunction {
395        public:
396            InstrumentScriptVMFunction_change_amp_lfo_depth(InstrumentScriptVM* parent) : VMChangeSynthParamFunction({
397                .vm = parent,
398                .acceptFinal = true,
399                .unit = VM_NO_UNIT,
400                .acceptUnitPrefix = false,
401                .acceptReal = false,
402            }) {}
403            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
404        };
405    
406        class InstrumentScriptVMFunction_change_amp_lfo_freq FINAL : public VMChangeSynthParamFunction {
407        public:
408            InstrumentScriptVMFunction_change_amp_lfo_freq(InstrumentScriptVM* parent) : VMChangeSynthParamFunction({
409                .vm = parent,
410                .acceptFinal = true,
411                .unit = VM_HERTZ,
412                .acceptUnitPrefix = true,
413                .acceptReal = true,
414            }) {}
415            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
416        };
417    
418        class InstrumentScriptVMFunction_change_cutoff_lfo_depth FINAL : public VMChangeSynthParamFunction {
419        public:
420            InstrumentScriptVMFunction_change_cutoff_lfo_depth(InstrumentScriptVM* parent) : VMChangeSynthParamFunction({
421                .vm = parent,
422                .acceptFinal = true,
423                .unit = VM_NO_UNIT,
424                .acceptUnitPrefix = false,
425                .acceptReal = false,
426            }) {}
427            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
428        };
429    
430        class InstrumentScriptVMFunction_change_cutoff_lfo_freq FINAL : public VMChangeSynthParamFunction {
431        public:
432            InstrumentScriptVMFunction_change_cutoff_lfo_freq(InstrumentScriptVM* parent) : VMChangeSynthParamFunction({
433                .vm = parent,
434                .acceptFinal = true,
435                .unit = VM_HERTZ,
436                .acceptUnitPrefix = true,
437                .acceptReal = true,
438            }) {}
439            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
440        };
441    
442        class InstrumentScriptVMFunction_change_pitch_lfo_depth FINAL : public VMChangeSynthParamFunction {
443        public:
444            InstrumentScriptVMFunction_change_pitch_lfo_depth(InstrumentScriptVM* parent) : VMChangeSynthParamFunction({
445                .vm = parent,
446                .acceptFinal = true,
447                .unit = VM_NO_UNIT,
448                .acceptUnitPrefix = false,
449                .acceptReal = false,
450            }) {}
451            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
452        };
453    
454        class InstrumentScriptVMFunction_change_pitch_lfo_freq FINAL : public VMChangeSynthParamFunction {
455        public:
456            InstrumentScriptVMFunction_change_pitch_lfo_freq(InstrumentScriptVM* parent) : VMChangeSynthParamFunction({
457                .vm = parent,
458                .acceptFinal = true,
459                .unit = VM_HERTZ,
460                .acceptUnitPrefix = true,
461                .acceptReal = true,
462            }) {}
463            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
464        };
465    
466        class InstrumentScriptVMFunction_change_vol_time FINAL : public VMChangeSynthParamFunction {
467        public:
468            InstrumentScriptVMFunction_change_vol_time(InstrumentScriptVM* parent) : VMChangeSynthParamFunction({
469                .vm = parent,
470                .acceptFinal = false,
471                .unit = VM_SECOND,
472                .acceptUnitPrefix = true,
473                .acceptReal = true,
474            }) {}
475            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
476      };      };
477    
478      class InstrumentScriptVMFunction_change_amp_lfo_depth : public VMChangeSynthParamFunction {      class InstrumentScriptVMFunction_change_tune_time FINAL : public VMChangeSynthParamFunction {
479      public:      public:
480          InstrumentScriptVMFunction_change_amp_lfo_depth(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent) {}          InstrumentScriptVMFunction_change_tune_time(InstrumentScriptVM* parent) : VMChangeSynthParamFunction({
481          VMFnResult* exec(VMFnArgs* args);              .vm = parent,
482                .acceptFinal = false,
483                .unit = VM_SECOND,
484                .acceptUnitPrefix = true,
485                .acceptReal = true,
486            }) {}
487            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
488      };      };
489    
490      class InstrumentScriptVMFunction_change_amp_lfo_freq : public VMChangeSynthParamFunction {      class InstrumentScriptVMFunction_change_pan_time FINAL : public VMChangeSynthParamFunction {
491      public:      public:
492          InstrumentScriptVMFunction_change_amp_lfo_freq(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent) {}          InstrumentScriptVMFunction_change_pan_time(InstrumentScriptVM* parent) : VMChangeSynthParamFunction({
493          VMFnResult* exec(VMFnArgs* args);              .vm = parent,
494                .acceptFinal = false,
495                .unit = VM_SECOND,
496                .acceptUnitPrefix = true,
497                .acceptReal = true,
498            }) {}
499            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
500      };      };
501    
502      class InstrumentScriptVMFunction_change_pitch_lfo_depth : public VMChangeSynthParamFunction {      class VMChangeFadeCurveFunction : public VMEmptyResultFunction {
503      public:      public:
504          InstrumentScriptVMFunction_change_pitch_lfo_depth(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent) {}          VMChangeFadeCurveFunction(InstrumentScriptVM* parent) : m_vm(parent) {}
505          VMFnResult* exec(VMFnArgs* args);          vmint minRequiredArgs() const OVERRIDE { return 2; }
506            vmint maxAllowedArgs() const OVERRIDE { return 2; }
507            bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
508    
509            template<fade_curve_t NoteBase::_Override::*T_noteParam, vmint T_synthParam>
510            VMFnResult* execTemplate(VMFnArgs* args, const char* functionName);
511        protected:
512            InstrumentScriptVM* m_vm;
513      };      };
514    
515      class InstrumentScriptVMFunction_change_pitch_lfo_freq : public VMChangeSynthParamFunction {      class InstrumentScriptVMFunction_change_vol_curve FINAL : public VMChangeFadeCurveFunction {
516      public:      public:
517          InstrumentScriptVMFunction_change_pitch_lfo_freq(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent) {}          InstrumentScriptVMFunction_change_vol_curve(InstrumentScriptVM* parent) : VMChangeFadeCurveFunction(parent) {}
518          VMFnResult* exec(VMFnArgs* args);          VMFnResult* exec(VMFnArgs* args) OVERRIDE;
519      };      };
520    
521      class InstrumentScriptVMFunction_change_vol_time : public VMChangeSynthParamFunction {      class InstrumentScriptVMFunction_change_tune_curve FINAL : public VMChangeFadeCurveFunction {
522      public:      public:
523          InstrumentScriptVMFunction_change_vol_time(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent) {}          InstrumentScriptVMFunction_change_tune_curve(InstrumentScriptVM* parent) : VMChangeFadeCurveFunction(parent) {}
524          VMFnResult* exec(VMFnArgs* args);          VMFnResult* exec(VMFnArgs* args) OVERRIDE;
525      };      };
526    
527      class InstrumentScriptVMFunction_change_tune_time : public VMChangeSynthParamFunction {      class InstrumentScriptVMFunction_change_pan_curve FINAL : public VMChangeFadeCurveFunction {
528      public:      public:
529          InstrumentScriptVMFunction_change_tune_time(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent) {}          InstrumentScriptVMFunction_change_pan_curve(InstrumentScriptVM* parent) : VMChangeFadeCurveFunction(parent) {}
530          VMFnResult* exec(VMFnArgs* args);          VMFnResult* exec(VMFnArgs* args) OVERRIDE;
531      };      };
532    
533      class InstrumentScriptVMFunction_fade_in : public VMEmptyResultFunction {      class InstrumentScriptVMFunction_fade_in FINAL : public VMEmptyResultFunction {
534      public:      public:
535          InstrumentScriptVMFunction_fade_in(InstrumentScriptVM* parent);          InstrumentScriptVMFunction_fade_in(InstrumentScriptVM* parent);
536          int minRequiredArgs() const { return 2; }          vmint minRequiredArgs() const OVERRIDE { return 2; }
537          int maxAllowedArgs() const { return 2; }          vmint maxAllowedArgs() const OVERRIDE { return 2; }
538          bool acceptsArgType(int iArg, ExprType_t type) const;          bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
539          ExprType_t argType(int iArg) const { return INT_EXPR; }          bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE;
540          VMFnResult* exec(VMFnArgs* args);          bool acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const OVERRIDE;
541            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
542      protected:      protected:
543          InstrumentScriptVM* m_vm;          InstrumentScriptVM* m_vm;
544      };      };
545    
546      class InstrumentScriptVMFunction_fade_out : public VMEmptyResultFunction {      class InstrumentScriptVMFunction_fade_out FINAL : public VMEmptyResultFunction {
547      public:      public:
548          InstrumentScriptVMFunction_fade_out(InstrumentScriptVM* parent);          InstrumentScriptVMFunction_fade_out(InstrumentScriptVM* parent);
549          int minRequiredArgs() const { return 2; }          vmint minRequiredArgs() const OVERRIDE { return 2; }
550          int maxAllowedArgs() const { return 3; }          vmint maxAllowedArgs() const OVERRIDE { return 3; }
551          bool acceptsArgType(int iArg, ExprType_t type) const;          bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
552          ExprType_t argType(int iArg) const { return INT_EXPR; }          bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE;
553          VMFnResult* exec(VMFnArgs* args);          bool acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const OVERRIDE;
554            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
555      protected:      protected:
556          InstrumentScriptVM* m_vm;          InstrumentScriptVM* m_vm;
557      };      };
558    
559      class InstrumentScriptVMFunction_get_event_par : public VMIntResultFunction {      class InstrumentScriptVMFunction_get_event_par FINAL : public VMIntResultFunction {
560      public:      public:
561          InstrumentScriptVMFunction_get_event_par(InstrumentScriptVM* parent);          InstrumentScriptVMFunction_get_event_par(InstrumentScriptVM* parent);
562          int minRequiredArgs() const { return 2; }          StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE { return VM_NO_UNIT; }
563          int maxAllowedArgs() const { return 2; }          bool returnsFinal(VMFnArgs* args) OVERRIDE { return false; }
564          bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR;}          vmint minRequiredArgs() const OVERRIDE { return 2; }
565          ExprType_t argType(int iArg) const { return INT_EXPR; }          vmint maxAllowedArgs() const OVERRIDE { return 2; }
566          VMFnResult* exec(VMFnArgs* args);          bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR;}
567            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
568      protected:      protected:
569          InstrumentScriptVM* m_vm;          InstrumentScriptVM* m_vm;
570      };      };
571    
572      class InstrumentScriptVMFunction_set_event_par : public VMEmptyResultFunction {      class InstrumentScriptVMFunction_set_event_par FINAL : public VMEmptyResultFunction {
573      public:      public:
574          InstrumentScriptVMFunction_set_event_par(InstrumentScriptVM* parent);          InstrumentScriptVMFunction_set_event_par(InstrumentScriptVM* parent);
575          int minRequiredArgs() const { return 3; }          vmint minRequiredArgs() const OVERRIDE { return 3; }
576          int maxAllowedArgs() const { return 3; }          vmint maxAllowedArgs() const OVERRIDE { return 3; }
577          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;}
578          ExprType_t argType(int iArg) const { return INT_EXPR; }          VMFnResult* exec(VMFnArgs* args) OVERRIDE;
         VMFnResult* exec(VMFnArgs* args);  
579      protected:      protected:
580          InstrumentScriptVM* m_vm;          InstrumentScriptVM* m_vm;
581      };      };
582    
583      class InstrumentScriptVMFunction_event_status : public VMIntResultFunction {      class InstrumentScriptVMFunction_change_note FINAL : public VMEmptyResultFunction {
584        public:
585            InstrumentScriptVMFunction_change_note(InstrumentScriptVM* parent);
586            vmint minRequiredArgs() const OVERRIDE { return 2; }
587            vmint maxAllowedArgs() const OVERRIDE { return 2; }
588            bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR;}
589            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
590        protected:
591            InstrumentScriptVM* m_vm;
592        };
593    
594        class InstrumentScriptVMFunction_change_velo FINAL : public VMEmptyResultFunction {
595        public:
596            InstrumentScriptVMFunction_change_velo(InstrumentScriptVM* parent);
597            vmint minRequiredArgs() const OVERRIDE { return 2; }
598            vmint maxAllowedArgs() const OVERRIDE { return 2; }
599            bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR;}
600            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
601        protected:
602            InstrumentScriptVM* m_vm;
603        };
604    
605        class InstrumentScriptVMFunction_change_play_pos FINAL : public VMEmptyResultFunction {
606        public:
607            InstrumentScriptVMFunction_change_play_pos(InstrumentScriptVM* parent);
608            vmint minRequiredArgs() const OVERRIDE { return 2; }
609            vmint maxAllowedArgs() const OVERRIDE { return 2; }
610            bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
611            bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE;
612            bool acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const OVERRIDE;
613            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
614        protected:
615            InstrumentScriptVM* m_vm;
616        };
617    
618        class InstrumentScriptVMFunction_event_status FINAL : public VMIntResultFunction {
619      public:      public:
620          InstrumentScriptVMFunction_event_status(InstrumentScriptVM* parent);          InstrumentScriptVMFunction_event_status(InstrumentScriptVM* parent);
621          int minRequiredArgs() const { return 1; }          StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE { return VM_NO_UNIT; }
622          int maxAllowedArgs() const { return 1; }          bool returnsFinal(VMFnArgs* args) OVERRIDE { return false; }
623          bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR;}          vmint minRequiredArgs() const OVERRIDE { return 1; }
624          ExprType_t argType(int iArg) const { return INT_EXPR; }          vmint maxAllowedArgs() const OVERRIDE { return 1; }
625          VMFnResult* exec(VMFnArgs* args);          bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR;}
626            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
627        protected:
628            InstrumentScriptVM* m_vm;
629        };
630    
631        class InstrumentScriptVMFunction_callback_status FINAL : public VMIntResultFunction {
632        public:
633            InstrumentScriptVMFunction_callback_status(InstrumentScriptVM* parent);
634            StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE { return VM_NO_UNIT; }
635            bool returnsFinal(VMFnArgs* args) OVERRIDE { return false; }
636            vmint minRequiredArgs() const OVERRIDE { return 1; }
637            vmint maxAllowedArgs() const OVERRIDE { return 1; }
638            bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR;}
639            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
640      protected:      protected:
641          InstrumentScriptVM* m_vm;          InstrumentScriptVM* m_vm;
642      };      };
643    
644      // overrides core wait() implementation      // overrides core wait() implementation
645      class InstrumentScriptVMFunction_wait : public CoreVMFunction_wait {      class InstrumentScriptVMFunction_wait FINAL : public CoreVMFunction_wait {
646      public:      public:
647          InstrumentScriptVMFunction_wait(InstrumentScriptVM* parent);          InstrumentScriptVMFunction_wait(InstrumentScriptVM* parent);
648          VMFnResult* exec(VMFnArgs* args);          VMFnResult* exec(VMFnArgs* args) OVERRIDE;
649      };      };
650    
651      class InstrumentScriptVMFunction_stop_wait : public VMEmptyResultFunction {      class InstrumentScriptVMFunction_stop_wait FINAL : public VMEmptyResultFunction {
652      public:      public:
653          InstrumentScriptVMFunction_stop_wait(InstrumentScriptVM* parent);          InstrumentScriptVMFunction_stop_wait(InstrumentScriptVM* parent);
654          int minRequiredArgs() const { return 1; }          vmint minRequiredArgs() const OVERRIDE { return 1; }
655          int maxAllowedArgs() const { return 2; }          vmint maxAllowedArgs() const OVERRIDE { return 2; }
656          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;}
657          ExprType_t argType(int iArg) const { return INT_EXPR; }          VMFnResult* exec(VMFnArgs* args) OVERRIDE;
658          VMFnResult* exec(VMFnArgs* args);      protected:
659            InstrumentScriptVM* m_vm;
660        };
661    
662        class InstrumentScriptVMFunction_abort FINAL : public VMEmptyResultFunction {
663        public:
664            InstrumentScriptVMFunction_abort(InstrumentScriptVM* parent);
665            vmint minRequiredArgs() const OVERRIDE { return 1; }
666            vmint maxAllowedArgs() const OVERRIDE { return 1; }
667            bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR; }
668            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
669        protected:
670            InstrumentScriptVM* m_vm;
671        };
672    
673        class InstrumentScriptVMFunction_fork FINAL : public VMIntResultFunction {
674        public:
675            InstrumentScriptVMFunction_fork(InstrumentScriptVM* parent);
676            StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE { return VM_NO_UNIT; }
677            bool returnsFinal(VMFnArgs* args) OVERRIDE { return false; }
678            vmint minRequiredArgs() const OVERRIDE { return 0; }
679            vmint maxAllowedArgs() const OVERRIDE { return 2; }
680            bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR;}
681            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
682      protected:      protected:
683          InstrumentScriptVM* m_vm;          InstrumentScriptVM* m_vm;
684      };      };
Legend:
Removed from v.3212  
changed lines
  Added in v.3691
  ViewVC Help
Powered by ViewVC