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

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

Parent Directory Parent Directory | Revision Log Revision Log

Revision 3581 - (hide annotations) (download) (as text)
Fri Aug 30 11:40:25 2019 UTC (4 years, 7 months ago) by schoenebeck
File MIME type: text/x-c++hdr
File size: 27802 byte(s) 
NKSP: Allow more wider support of standard measuring units & 'final'ness.

* Raised compiler requirement to be C++14 compliant (due to severe
  restrictions regarding C-style aggregate initializer lists in C++11
  which are now massively used throughout the code base).

* NKSP VM API: Allow units and 'final'ness to be returned as result from
  built-in functions (added methods VMFunction::returnUnitType() and
  VMFunction::returnsFinal() for that purpose which must be implemented by
  built-in function implementations).

* NKSP language: Allow metric unit prefixes of numeric scalar and array
  variables to be changed freely at runtime (unlike unit types like Hz etc.
  which are still sticky parse-time features of variables which cannot be
  changed at runtime for the intentional sake of determinism).

* NKSP language: 'final' values are prohibited for array variables for now
  (attempt causes a parsers error).

* NKSP language: expressions with unit types (e.g. Hz) are prohibited for
  conditions of runtime control structures like if(), while(), select()
  (attempt causes a parser error).

* NKSP VM API: Allow built-in functions to perform their own, individual
  parse time checks of arguments going to be passed to the function at
  runtime (added method VMFunction::checkArgs() for that purpose).

* NKSP language: raise parser warning if only one operand of binary
  operators (like logical 'or' comparison) contain a 'final' value (because
  it would always yield in a 'final' result in such cases).

* NKSP language: Allow comparison (=, #, <, >, <=, >=) of values with
  different metric unit prefixes, which will behave as expected (e.g.
  result of expression '1000us < 2ms' is true).

* NKSP language: Allow adding values with different metric unit prefixes
  (e.g. result of expression '100Hz + 5kHz' is '5100Hz').

* NKSP language: Allow subtracting values with different metric unit
  prefixes (e.g. result of expression '1ms - 20us' is '980us').

* NKSP language: Allow multiplying with any metric unit prefixes
  (e.g. result of expression '2k * 3ms' is '6s'), however multiplications
  with unit types on both sides (e.g. '2s * 2s') is still prohibited since
  we don't have any considerable practical use for a term like '4s^2'
  (hence any attempt multiplying two unit types still causes parser error).

* NKSP language: Allow dividing by any metric unit prefixes and allow
  division of same unit type on both sides (e.g. expression '8kHz / 1000Hz'
  yields in unit free result '8'). So this is now a way to cast units away
  e.g. for passing the result to other expressions, certain function calls
  or variables which are not accepting any units (or that specific unit).

* NKSP language: integer arrays and real number arrays can now be converted
  to strings (e.g. for dumping their content with message() calls for
  script debugging purposes).

* NKSP language: expressions and variables with units are now correctly
  casted to strings (e.g. with message() calls).

* NKSP language: comparing real numbers for equalness (e.g. '~foo = 3.1') or
  unequalness (e.g. '~foo # 3.1') is now less strict and takes the expected
  floating point tolerances into account.

* NKSP VM API: Added methods VMScalarNumberExpr::evalCastInt() and
  VMScalarNumberExpr::evalCastReal().

* NKSP VM API: Added base class 'VMNumberArrayExpr' for classes
  'VMIntArrayExpr' and 'VMRealArrayExpr'.

* NKSP VM API: replaced all unitPrefix() (parse time) methods by
  unitFactor() (runtime) methods.

* Built-in function "exit()" supports now returning units and 'final'ness
  exclusively for test cases.

* The following built-in functions support now units as well: "abs()",
  "random()", "inc()", "dec()", "in_range()", "min()", "max()",
  "real_to_int()", "int()", "int_to_real()" and "real()".

* Built-in functions "array_equal()", "search()" and "sort()" support now
  real number arrays (correctly) as well.

* Added individual parse time checks of arguments to be passed to built-in
  functions "random()", "inc()", "dec()", "in_range()", "min()", "max()",
  "array_equal()" and "search()" specific for their individual purposes.

* Test cases: Added massive amount of NKSP test cases for standard
  measuring units and 'final' operator usage cases.

* Test cases: Added NKSP test cases for (floating point tolerance aware)
  real number equalness / unequalness comparison.

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