/[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 2935 by schoenebeck, Sun Jul 10 14:24:13 2016 UTC revision 3691 by schoenebeck, Fri Jan 3 12:35:20 2020 UTC
# Line 1  Line 1 
1  /*  /*
2   * Copyright (c) 2014 - 2016 Christian Schoenebeck   * Copyright (c) 2014 - 2020 Christian Schoenebeck
3   *   *
4   * http://www.linuxsampler.org   * http://www.linuxsampler.org
5   *   *
# Line 12  Line 12 
12    
13  #include "../../common/global.h"  #include "../../common/global.h"
14  #include "../../scriptvm/CoreVMFunctions.h"  #include "../../scriptvm/CoreVMFunctions.h"
15    #include "Note.h"
16    
17  namespace LinuxSampler {  namespace LinuxSampler {
18    
19      class EventGroup;      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:      protected:
50          InstrumentScriptVM* m_vm;          InstrumentScriptVM* m_vm;
51      };      };
52    
53      class InstrumentScriptVMFunction_ignore_event : public VMEmptyResultFunction {      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:
63            InstrumentScriptVM* m_vm;
64        };
65    
66        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 1; }          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 { return 1; }          StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE { return VM_NO_UNIT; }
148          int maxAllowedArgs() const { return 1; }          bool returnsFinal(VMFnArgs* args) OVERRIDE { return false; }
149          bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR;}          vmint minRequiredArgs() const OVERRIDE { return 1; }
150          ExprType_t argType(int iArg) const { return INT_EXPR; }          vmint maxAllowedArgs() const OVERRIDE { return 1; }
151          ExprType_t returnType() { return INT_ARR_EXPR; }          bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR;}
152          VMFnResult* exec(VMFnArgs* args);          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;
157      protected:      protected:
158          InstrumentScriptVM* m_vm;          InstrumentScriptVM* m_vm;
159          class Result : public VMFnResult, public VMIntArrayExpr {          class Result : public VMFnResult, public VMIntArrayExpr {
# Line 118  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() { return flags; }              StmtFlags_t resultFlags() OVERRIDE { return flags; }
171                bool isConstExpr() const OVERRIDE { return false; }
172          } m_result;          } m_result;
173    
174          VMFnResult* errorResult();          VMFnResult* errorResult();
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:
243            InstrumentScriptVM* m_vm;
244        };
245        
246        class InstrumentScriptVMFunction_change_attack FINAL : public VMEmptyResultFunction {
247            using Super = VMEmptyResultFunction; // just an alias for the super class
248        public:
249            InstrumentScriptVMFunction_change_attack(InstrumentScriptVM* parent);
250            vmint minRequiredArgs() const OVERRIDE { return 2; }
251            vmint maxAllowedArgs() const OVERRIDE { return 2; }
252            bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
253            bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE;
254            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:
260            InstrumentScriptVM* m_vm;
261        };
262    
263        class InstrumentScriptVMFunction_change_decay FINAL : public VMEmptyResultFunction {
264            using Super = VMEmptyResultFunction; // just an alias for the super class
265        public:
266            InstrumentScriptVMFunction_change_decay(InstrumentScriptVM* parent);
267            vmint minRequiredArgs() const OVERRIDE { return 2; }
268            vmint maxAllowedArgs() const OVERRIDE { return 2; }
269            bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
270            bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE;
271            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:
277            InstrumentScriptVM* m_vm;
278        };
279        
280        class InstrumentScriptVMFunction_change_release FINAL : public VMEmptyResultFunction {
281            using Super = VMEmptyResultFunction; // just an alias for the super class
282        public:
283            InstrumentScriptVMFunction_change_release(InstrumentScriptVM* parent);
284            vmint minRequiredArgs() const OVERRIDE { return 2; }
285            vmint maxAllowedArgs() const OVERRIDE { return 2; }
286            bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
287            bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE;
288            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 InstrumentScriptVMFunction_event_status : public VMIntResultFunction {      class VMChangeSynthParamFunction : public VMEmptyResultFunction {
298            using Super = VMEmptyResultFunction; // just an alias for the super class
299        public:
300            struct Opt_t {
301                InstrumentScriptVM* vm = NULL; ///< Parent object owning the built-in function implementation object.
302                bool acceptFinal = false; ///< Whether built-in function allows 'final' operator for its 2nd function argument.
303                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                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            };
307            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);
326        protected:
327            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_tune_time FINAL : public VMChangeSynthParamFunction {
479        public:
480            InstrumentScriptVMFunction_change_tune_time(InstrumentScriptVM* parent) : VMChangeSynthParamFunction({
481                .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_pan_time FINAL : public VMChangeSynthParamFunction {
491        public:
492            InstrumentScriptVMFunction_change_pan_time(InstrumentScriptVM* parent) : VMChangeSynthParamFunction({
493                .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 VMChangeFadeCurveFunction : public VMEmptyResultFunction {
503        public:
504            VMChangeFadeCurveFunction(InstrumentScriptVM* parent) : m_vm(parent) {}
505            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_vol_curve FINAL : public VMChangeFadeCurveFunction {
516        public:
517            InstrumentScriptVMFunction_change_vol_curve(InstrumentScriptVM* parent) : VMChangeFadeCurveFunction(parent) {}
518            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
519        };
520    
521        class InstrumentScriptVMFunction_change_tune_curve FINAL : public VMChangeFadeCurveFunction {
522        public:
523            InstrumentScriptVMFunction_change_tune_curve(InstrumentScriptVM* parent) : VMChangeFadeCurveFunction(parent) {}
524            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
525        };
526    
527        class InstrumentScriptVMFunction_change_pan_curve FINAL : public VMChangeFadeCurveFunction {
528        public:
529            InstrumentScriptVMFunction_change_pan_curve(InstrumentScriptVM* parent) : VMChangeFadeCurveFunction(parent) {}
530            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
531        };
532    
533        class InstrumentScriptVMFunction_fade_in FINAL : public VMEmptyResultFunction {
534        public:
535            InstrumentScriptVMFunction_fade_in(InstrumentScriptVM* parent);
536            vmint minRequiredArgs() const OVERRIDE { return 2; }
537            vmint maxAllowedArgs() const OVERRIDE { return 2; }
538            bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
539            bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE;
540            bool acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const OVERRIDE;
541            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
542        protected:
543            InstrumentScriptVM* m_vm;
544        };
545    
546        class InstrumentScriptVMFunction_fade_out FINAL : public VMEmptyResultFunction {
547        public:
548            InstrumentScriptVMFunction_fade_out(InstrumentScriptVM* parent);
549            vmint minRequiredArgs() const OVERRIDE { return 2; }
550            vmint maxAllowedArgs() const OVERRIDE { return 3; }
551            bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
552            bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE;
553            bool acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const OVERRIDE;
554            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
555        protected:
556            InstrumentScriptVM* m_vm;
557        };
558    
559        class InstrumentScriptVMFunction_get_event_par FINAL : public VMIntResultFunction {
560        public:
561            InstrumentScriptVMFunction_get_event_par(InstrumentScriptVM* parent);
562            StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE { return VM_NO_UNIT; }
563            bool returnsFinal(VMFnArgs* args) OVERRIDE { return false; }
564            vmint minRequiredArgs() const OVERRIDE { return 2; }
565            vmint maxAllowedArgs() const OVERRIDE { return 2; }
566            bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR;}
567            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
568        protected:
569            InstrumentScriptVM* m_vm;
570        };
571    
572        class InstrumentScriptVMFunction_set_event_par FINAL : public VMEmptyResultFunction {
573        public:
574            InstrumentScriptVMFunction_set_event_par(InstrumentScriptVM* parent);
575            vmint minRequiredArgs() const OVERRIDE { return 3; }
576            vmint maxAllowedArgs() const OVERRIDE { return 3; }
577            bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR;}
578            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
579        protected:
580            InstrumentScriptVM* m_vm;
581        };
582    
583        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:
641            InstrumentScriptVM* m_vm;
642        };
643    
644        // overrides core wait() implementation
645        class InstrumentScriptVMFunction_wait FINAL : public CoreVMFunction_wait {
646        public:
647            InstrumentScriptVMFunction_wait(InstrumentScriptVM* parent);
648            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
649        };
650    
651        class InstrumentScriptVMFunction_stop_wait FINAL : public VMEmptyResultFunction {
652        public:
653            InstrumentScriptVMFunction_stop_wait(InstrumentScriptVM* parent);
654            vmint minRequiredArgs() const OVERRIDE { return 1; }
655            vmint maxAllowedArgs() const OVERRIDE { return 2; }
656            bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR;}
657            VMFnResult* exec(VMFnArgs* args) OVERRIDE;
658        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.2935  
changed lines
  Added in v.3691
  ViewVC Help
Powered by ViewVC