engines/common/InstrumentScriptVMFunctions.h

/*
 * Copyright (c) 2014 - 2017 Christian Schoenebeck
 *
 * http://www.linuxsampler.org
 *
 * This file is part of LinuxSampler and released under the same terms.
 * See README file for details.
 */

#ifndef LS_INSTRSCRIPTVMFUNCTIONS_H
#define LS_INSTRSCRIPTVMFUNCTIONS_H

#include "../../common/global.h"
#include "../../scriptvm/CoreVMFunctions.h"
#include "Note.h"

namespace LinuxSampler {

    class EventGroup;
    class InstrumentScriptVM;

    class InstrumentScriptVMFunction_play_note : public VMIntResultFunction {
    public:
        InstrumentScriptVMFunction_play_note(InstrumentScriptVM* parent);
        int minRequiredArgs() const { return 1; }
        int maxAllowedArgs() const { return 4; }
        bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR;}
        ExprType_t argType(int iArg) const { return INT_EXPR; }
        VMFnResult* exec(VMFnArgs* args);
    protected:
        InstrumentScriptVM* m_vm;
    };

    class InstrumentScriptVMFunction_set_controller : public VMIntResultFunction {
    public:
        InstrumentScriptVMFunction_set_controller(InstrumentScriptVM* parent);
        int minRequiredArgs() const { return 2; }
        int maxAllowedArgs() const { return 2; }
        bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR;}
        ExprType_t argType(int iArg) const { return INT_EXPR; }
        VMFnResult* exec(VMFnArgs* args);
    protected:
        InstrumentScriptVM* m_vm;
    };

    class InstrumentScriptVMFunction_ignore_event : public VMEmptyResultFunction {
    public:
        InstrumentScriptVMFunction_ignore_event(InstrumentScriptVM* parent);
        int minRequiredArgs() const { return 0; }
        int maxAllowedArgs() const { return 1; }
        bool acceptsArgType(int iArg, ExprType_t type) const;
        ExprType_t argType(int iArg) const { return INT_EXPR; }
        VMFnResult* exec(VMFnArgs* args);
    protected:
        InstrumentScriptVM* m_vm;
    };

    class InstrumentScriptVMFunction_ignore_controller : public VMEmptyResultFunction {
    public:
        InstrumentScriptVMFunction_ignore_controller(InstrumentScriptVM* parent);
        int minRequiredArgs() const { return 0; }
        int maxAllowedArgs() const { return 1; }
        bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR;}
        ExprType_t argType(int iArg) const { return INT_EXPR; }
        VMFnResult* exec(VMFnArgs* args);
    protected:
        InstrumentScriptVM* m_vm;
    };

    class InstrumentScriptVMFunction_note_off : public VMEmptyResultFunction {
    public:
        InstrumentScriptVMFunction_note_off(InstrumentScriptVM* parent);
        int minRequiredArgs() const { return 1; }
        int maxAllowedArgs() const { return 2; }
        bool acceptsArgType(int iArg, ExprType_t type) const;
        ExprType_t argType(int iArg) const { return INT_EXPR; }
        VMFnResult* exec(VMFnArgs* args);
    protected:
        InstrumentScriptVM* m_vm;
    };

    class InstrumentScriptVMFunction_set_event_mark : public VMEmptyResultFunction {
    public:
        InstrumentScriptVMFunction_set_event_mark(InstrumentScriptVM* parent);
        int minRequiredArgs() const { return 2; }
        int maxAllowedArgs() const { return 2; }
        bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR;}
        ExprType_t argType(int iArg) const { return INT_EXPR; }
        VMFnResult* exec(VMFnArgs* args);
    protected:
        InstrumentScriptVM* m_vm;
    };

    class InstrumentScriptVMFunction_delete_event_mark : public VMEmptyResultFunction {
    public:
        InstrumentScriptVMFunction_delete_event_mark(InstrumentScriptVM* parent);
        int minRequiredArgs() const { return 2; }
        int maxAllowedArgs() const { return 2; }
        bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR;}
        ExprType_t argType(int iArg) const { return INT_EXPR; }
        VMFnResult* exec(VMFnArgs* args);
    protected:
        InstrumentScriptVM* m_vm;
    };

    class InstrumentScriptVMFunction_by_marks : public VMFunction {
    public:
        InstrumentScriptVMFunction_by_marks(InstrumentScriptVM* parent);
        int minRequiredArgs() const OVERRIDE { return 1; }
        int maxAllowedArgs() const OVERRIDE { return 1; }
        bool acceptsArgType(int iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR;}
        bool modifiesArg(int iArg) const OVERRIDE { return false; }
        ExprType_t argType(int iArg) const OVERRIDE { return INT_EXPR; }
        ExprType_t returnType() OVERRIDE { return INT_ARR_EXPR; }
        VMFnResult* exec(VMFnArgs* args) OVERRIDE;
    protected:
        InstrumentScriptVM* m_vm;
        class Result : public VMFnResult, public VMIntArrayExpr {
        public:
            StmtFlags_t flags;
            EventGroup* eventGroup;

            int arraySize() const OVERRIDE;
            int evalIntElement(uint i) OVERRIDE;
            void assignIntElement(uint i, int value) OVERRIDE {} // ignore assignment
            VMExpr* resultValue() OVERRIDE { return this; }
            StmtFlags_t resultFlags() OVERRIDE { return flags; }
            bool isConstExpr() const OVERRIDE { return false; }
        } m_result;

        VMFnResult* errorResult();
        VMFnResult* successResult(EventGroup* eventGroup);
    };

    class InstrumentScriptVMFunction_change_vol : public VMEmptyResultFunction {
    public:
        InstrumentScriptVMFunction_change_vol(InstrumentScriptVM* parent);
        int minRequiredArgs() const { return 2; }
        int maxAllowedArgs() const { return 3; }
        bool acceptsArgType(int iArg, ExprType_t type) const;
        ExprType_t argType(int iArg) const { return INT_EXPR; }
        VMFnResult* exec(VMFnArgs* args);
    protected:
        InstrumentScriptVM* m_vm;
    };

    class InstrumentScriptVMFunction_change_tune : public VMEmptyResultFunction {
    public:
        InstrumentScriptVMFunction_change_tune(InstrumentScriptVM* parent);
        int minRequiredArgs() const { return 2; }
        int maxAllowedArgs() const { return 3; }
        bool acceptsArgType(int iArg, ExprType_t type) const;
        ExprType_t argType(int iArg) const { return INT_EXPR; }
        VMFnResult* exec(VMFnArgs* args);
    protected:
        InstrumentScriptVM* m_vm;
    };

    class InstrumentScriptVMFunction_change_pan : public VMEmptyResultFunction {
    public:
        InstrumentScriptVMFunction_change_pan(InstrumentScriptVM* parent);
        int minRequiredArgs() const { return 2; }
        int maxAllowedArgs() const { return 3; }
        bool acceptsArgType(int iArg, ExprType_t type) const;
        ExprType_t argType(int iArg) const { return INT_EXPR; }
        VMFnResult* exec(VMFnArgs* args);
    protected:
        InstrumentScriptVM* m_vm;
    };

    class InstrumentScriptVMFunction_change_cutoff : public VMEmptyResultFunction {
    public:
        InstrumentScriptVMFunction_change_cutoff(InstrumentScriptVM* parent);
        int minRequiredArgs() const { return 2; }
        int maxAllowedArgs() const { return 2; }
        bool acceptsArgType(int iArg, ExprType_t type) const;
        ExprType_t argType(int iArg) const { return INT_EXPR; }
        VMFnResult* exec(VMFnArgs* args);
    protected:
        InstrumentScriptVM* m_vm;
    };

    class InstrumentScriptVMFunction_change_reso : public VMEmptyResultFunction {
    public:
        InstrumentScriptVMFunction_change_reso(InstrumentScriptVM* parent);
        int minRequiredArgs() const { return 2; }
        int maxAllowedArgs() const { return 2; }
        bool acceptsArgType(int iArg, ExprType_t type) const;
        ExprType_t argType(int iArg) const { return INT_EXPR; }
        VMFnResult* exec(VMFnArgs* args);
    protected:
        InstrumentScriptVM* m_vm;
    };
    
    class InstrumentScriptVMFunction_change_attack : public VMEmptyResultFunction {
    public:
        InstrumentScriptVMFunction_change_attack(InstrumentScriptVM* parent);
        int minRequiredArgs() const { return 2; }
        int maxAllowedArgs() const { return 2; }
        bool acceptsArgType(int iArg, ExprType_t type) const;
        ExprType_t argType(int iArg) const { return INT_EXPR; }
        VMFnResult* exec(VMFnArgs* args);
    protected:
        InstrumentScriptVM* m_vm;
    };

    class InstrumentScriptVMFunction_change_decay : public VMEmptyResultFunction {
    public:
        InstrumentScriptVMFunction_change_decay(InstrumentScriptVM* parent);
        int minRequiredArgs() const { return 2; }
        int maxAllowedArgs() const { return 2; }
        bool acceptsArgType(int iArg, ExprType_t type) const;
        ExprType_t argType(int iArg) const { return INT_EXPR; }
        VMFnResult* exec(VMFnArgs* args);
    protected:
        InstrumentScriptVM* m_vm;
    };
    
    class InstrumentScriptVMFunction_change_release : public VMEmptyResultFunction {
    public:
        InstrumentScriptVMFunction_change_release(InstrumentScriptVM* parent);
        int minRequiredArgs() const { return 2; }
        int maxAllowedArgs() const { return 2; }
        bool acceptsArgType(int iArg, ExprType_t type) const;
        ExprType_t argType(int iArg) const { return INT_EXPR; }
        VMFnResult* exec(VMFnArgs* args);
    protected:
        InstrumentScriptVM* m_vm;
    };

    class VMChangeSynthParamFunction : public VMEmptyResultFunction {
    public:
        VMChangeSynthParamFunction(InstrumentScriptVM* parent) : m_vm(parent) {}
        int minRequiredArgs() const { return 2; }
        int maxAllowedArgs() const { return 2; }
        bool acceptsArgType(int iArg, ExprType_t type) const;
        ExprType_t argType(int iArg) const { return INT_EXPR; }

        template<float NoteBase::_Override::*T_noteParam, int T_synthParam,
                 bool T_isNormalizedParam, int T_maxValue, int T_minValue>
        VMFnResult* execTemplate(VMFnArgs* args, const char* functionName);
    protected:
        InstrumentScriptVM* m_vm;
    };

    class InstrumentScriptVMFunction_change_sustain : public VMChangeSynthParamFunction {
    public:
        InstrumentScriptVMFunction_change_sustain(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent) {}
        VMFnResult* exec(VMFnArgs* args);
    };

    class InstrumentScriptVMFunction_change_amp_lfo_depth : public VMChangeSynthParamFunction {
    public:
        InstrumentScriptVMFunction_change_amp_lfo_depth(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent) {}
        VMFnResult* exec(VMFnArgs* args);
    };

    class InstrumentScriptVMFunction_change_amp_lfo_freq : public VMChangeSynthParamFunction {
    public:
        InstrumentScriptVMFunction_change_amp_lfo_freq(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent) {}
        VMFnResult* exec(VMFnArgs* args);
    };

    class InstrumentScriptVMFunction_change_pitch_lfo_depth : public VMChangeSynthParamFunction {
    public:
        InstrumentScriptVMFunction_change_pitch_lfo_depth(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent) {}
        VMFnResult* exec(VMFnArgs* args);
    };

    class InstrumentScriptVMFunction_change_pitch_lfo_freq : public VMChangeSynthParamFunction {
    public:
        InstrumentScriptVMFunction_change_pitch_lfo_freq(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent) {}
        VMFnResult* exec(VMFnArgs* args);
    };

    class InstrumentScriptVMFunction_change_vol_time : public VMChangeSynthParamFunction {
    public:
        InstrumentScriptVMFunction_change_vol_time(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent) {}
        VMFnResult* exec(VMFnArgs* args);
    };

    class InstrumentScriptVMFunction_change_tune_time : public VMChangeSynthParamFunction {
    public:
        InstrumentScriptVMFunction_change_tune_time(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent) {}
        VMFnResult* exec(VMFnArgs* args);
    };

    class VMChangeFadeCurveFunction : public VMEmptyResultFunction {
    public:
        VMChangeFadeCurveFunction(InstrumentScriptVM* parent) : m_vm(parent) {}
        int minRequiredArgs() const { return 2; }
        int maxAllowedArgs() const { return 2; }
        bool acceptsArgType(int iArg, ExprType_t type) const;
        ExprType_t argType(int iArg) const { return INT_EXPR; }

        template<fade_curve_t NoteBase::_Override::*T_noteParam, int T_synthParam>
        VMFnResult* execTemplate(VMFnArgs* args, const char* functionName);
    protected:
        InstrumentScriptVM* m_vm;
    };

    class InstrumentScriptVMFunction_change_vol_curve : public VMChangeFadeCurveFunction {
    public:
        InstrumentScriptVMFunction_change_vol_curve(InstrumentScriptVM* parent) : VMChangeFadeCurveFunction(parent) {}
        VMFnResult* exec(VMFnArgs* args);
    };

    class InstrumentScriptVMFunction_change_tune_curve : public VMChangeFadeCurveFunction {
    public:
        InstrumentScriptVMFunction_change_tune_curve(InstrumentScriptVM* parent) : VMChangeFadeCurveFunction(parent) {}
        VMFnResult* exec(VMFnArgs* args);
    };

    class InstrumentScriptVMFunction_fade_in : public VMEmptyResultFunction {
    public:
        InstrumentScriptVMFunction_fade_in(InstrumentScriptVM* parent);
        int minRequiredArgs() const { return 2; }
        int maxAllowedArgs() const { return 2; }
        bool acceptsArgType(int iArg, ExprType_t type) const;
        ExprType_t argType(int iArg) const { return INT_EXPR; }
        VMFnResult* exec(VMFnArgs* args);
    protected:
        InstrumentScriptVM* m_vm;
    };

    class InstrumentScriptVMFunction_fade_out : public VMEmptyResultFunction {
    public:
        InstrumentScriptVMFunction_fade_out(InstrumentScriptVM* parent);
        int minRequiredArgs() const { return 2; }
        int maxAllowedArgs() const { return 3; }
        bool acceptsArgType(int iArg, ExprType_t type) const;
        ExprType_t argType(int iArg) const { return INT_EXPR; }
        VMFnResult* exec(VMFnArgs* args);
    protected:
        InstrumentScriptVM* m_vm;
    };

    class InstrumentScriptVMFunction_get_event_par : public VMIntResultFunction {
    public:
        InstrumentScriptVMFunction_get_event_par(InstrumentScriptVM* parent);
        int minRequiredArgs() const { return 2; }
        int maxAllowedArgs() const { return 2; }
        bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR;}
        ExprType_t argType(int iArg) const { return INT_EXPR; }
        VMFnResult* exec(VMFnArgs* args);
    protected:
        InstrumentScriptVM* m_vm;
    };

    class InstrumentScriptVMFunction_set_event_par : public VMEmptyResultFunction {
    public:
        InstrumentScriptVMFunction_set_event_par(InstrumentScriptVM* parent);
        int minRequiredArgs() const { return 3; }
        int maxAllowedArgs() const { return 3; }
        bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR;}
        ExprType_t argType(int iArg) const { return INT_EXPR; }
        VMFnResult* exec(VMFnArgs* args);
    protected:
        InstrumentScriptVM* m_vm;
    };

    class InstrumentScriptVMFunction_change_note : public VMEmptyResultFunction {
    public:
        InstrumentScriptVMFunction_change_note(InstrumentScriptVM* parent);
        int minRequiredArgs() const { return 2; }
        int maxAllowedArgs() const { return 2; }
        bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR;}
        ExprType_t argType(int iArg) const { return INT_EXPR; }
        VMFnResult* exec(VMFnArgs* args);
    protected:
        InstrumentScriptVM* m_vm;
    };

    class InstrumentScriptVMFunction_change_velo : public VMEmptyResultFunction {
    public:
        InstrumentScriptVMFunction_change_velo(InstrumentScriptVM* parent);
        int minRequiredArgs() const { return 2; }
        int maxAllowedArgs() const { return 2; }
        bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR;}
        ExprType_t argType(int iArg) const { return INT_EXPR; }
        VMFnResult* exec(VMFnArgs* args);
    protected:
        InstrumentScriptVM* m_vm;
    };

    class InstrumentScriptVMFunction_change_play_pos : public VMEmptyResultFunction {
    public:
        InstrumentScriptVMFunction_change_play_pos(InstrumentScriptVM* parent);
        int minRequiredArgs() const { return 2; }
        int maxAllowedArgs() const { return 2; }
        bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR; }
        ExprType_t argType(int iArg) const { return INT_EXPR; }
        VMFnResult* exec(VMFnArgs* args);
    protected:
        InstrumentScriptVM* m_vm;
    };

    class InstrumentScriptVMFunction_event_status : public VMIntResultFunction {
    public:
        InstrumentScriptVMFunction_event_status(InstrumentScriptVM* parent);
        int minRequiredArgs() const { return 1; }
        int maxAllowedArgs() const { return 1; }
        bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR;}
        ExprType_t argType(int iArg) const { return INT_EXPR; }
        VMFnResult* exec(VMFnArgs* args);
    protected:
        InstrumentScriptVM* m_vm;
    };

    class InstrumentScriptVMFunction_callback_status : public VMIntResultFunction {
    public:
        InstrumentScriptVMFunction_callback_status(InstrumentScriptVM* parent);
        int minRequiredArgs() const { return 1; }
        int maxAllowedArgs() const { return 1; }
        bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR;}
        ExprType_t argType(int iArg) const { return INT_EXPR; }
        VMFnResult* exec(VMFnArgs* args);
    protected:
        InstrumentScriptVM* m_vm;
    };

    // overrides core wait() implementation
    class InstrumentScriptVMFunction_wait : public CoreVMFunction_wait {
    public:
        InstrumentScriptVMFunction_wait(InstrumentScriptVM* parent);
        VMFnResult* exec(VMFnArgs* args);
    };

    class InstrumentScriptVMFunction_stop_wait : public VMEmptyResultFunction {
    public:
        InstrumentScriptVMFunction_stop_wait(InstrumentScriptVM* parent);
        int minRequiredArgs() const { return 1; }
        int maxAllowedArgs() const { return 2; }
        bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR;}
        ExprType_t argType(int iArg) const { return INT_EXPR; }
        VMFnResult* exec(VMFnArgs* args);
    protected:
        InstrumentScriptVM* m_vm;
    };

    class InstrumentScriptVMFunction_abort : public VMEmptyResultFunction {
    public:
        InstrumentScriptVMFunction_abort(InstrumentScriptVM* parent);
        int minRequiredArgs() const { return 1; }
        int maxAllowedArgs() const { return 1; }
        bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR; }
        ExprType_t argType(int iArg) const { return INT_EXPR; }
        VMFnResult* exec(VMFnArgs* args) OVERRIDE;
    protected:
        InstrumentScriptVM* m_vm;
    };

    class InstrumentScriptVMFunction_fork : public VMIntResultFunction {
    public:
        InstrumentScriptVMFunction_fork(InstrumentScriptVM* parent);
        int minRequiredArgs() const { return 0; }
        int maxAllowedArgs() const { return 2; }
        bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR;}
        ExprType_t argType(int iArg) const { return INT_EXPR; }
        VMFnResult* exec(VMFnArgs* args);
    protected:
        InstrumentScriptVM* m_vm;
    };

} // namespace LinuxSampler

#endif // LS_INSTRSCRIPTVMFUNCTIONS_H
1	schoenebeck	2596	/*
2	schoenebeck	3118	* Copyright (c) 2014 - 2017 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	2598	class InstrumentScriptVMFunction_play_note : public VMIntResultFunction {
23	schoenebeck	2596	public:
24			InstrumentScriptVMFunction_play_note(InstrumentScriptVM* parent);
25			int minRequiredArgs() const { return 1; }
26			int maxAllowedArgs() const { return 4; }
27			bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR;}
28			ExprType_t argType(int iArg) const { return INT_EXPR; }
29			VMFnResult* exec(VMFnArgs* args);
30			protected:
31			InstrumentScriptVM* m_vm;
32			};
33
34	schoenebeck	2600	class InstrumentScriptVMFunction_set_controller : public VMIntResultFunction {
35			public:
36			InstrumentScriptVMFunction_set_controller(InstrumentScriptVM* parent);
37			int minRequiredArgs() const { return 2; }
38			int maxAllowedArgs() const { return 2; }
39			bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR;}
40			ExprType_t argType(int iArg) const { return INT_EXPR; }
41			VMFnResult* exec(VMFnArgs* args);
42			protected:
43			InstrumentScriptVM* m_vm;
44			};
45
46	schoenebeck	2598	class InstrumentScriptVMFunction_ignore_event : public VMEmptyResultFunction {
47			public:
48			InstrumentScriptVMFunction_ignore_event(InstrumentScriptVM* parent);
49	schoenebeck	3212	int minRequiredArgs() const { return 0; }
50	schoenebeck	2598	int maxAllowedArgs() const { return 1; }
51	schoenebeck	2630	bool acceptsArgType(int iArg, ExprType_t type) const;
52	schoenebeck	2598	ExprType_t argType(int iArg) const { return INT_EXPR; }
53			VMFnResult* exec(VMFnArgs* args);
54			protected:
55			InstrumentScriptVM* m_vm;
56			};
57
58			class InstrumentScriptVMFunction_ignore_controller : public VMEmptyResultFunction {
59			public:
60			InstrumentScriptVMFunction_ignore_controller(InstrumentScriptVM* parent);
61			int minRequiredArgs() const { return 0; }
62			int maxAllowedArgs() const { return 1; }
63			bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR;}
64			ExprType_t argType(int iArg) const { return INT_EXPR; }
65			VMFnResult* exec(VMFnArgs* args);
66			protected:
67			InstrumentScriptVM* m_vm;
68			};
69
70	schoenebeck	2629	class InstrumentScriptVMFunction_note_off : public VMEmptyResultFunction {
71			public:
72			InstrumentScriptVMFunction_note_off(InstrumentScriptVM* parent);
73			int minRequiredArgs() const { return 1; }
74			int maxAllowedArgs() const { return 2; }
75	schoenebeck	2630	bool acceptsArgType(int iArg, ExprType_t type) const;
76			ExprType_t argType(int iArg) const { return INT_EXPR; }
77			VMFnResult* exec(VMFnArgs* args);
78			protected:
79			InstrumentScriptVM* m_vm;
80			};
81
82			class InstrumentScriptVMFunction_set_event_mark : public VMEmptyResultFunction {
83			public:
84			InstrumentScriptVMFunction_set_event_mark(InstrumentScriptVM* parent);
85			int minRequiredArgs() const { return 2; }
86			int maxAllowedArgs() const { return 2; }
87	schoenebeck	2629	bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR;}
88			ExprType_t argType(int iArg) const { return INT_EXPR; }
89			VMFnResult* exec(VMFnArgs* args);
90			protected:
91			InstrumentScriptVM* m_vm;
92			};
93
94	schoenebeck	2630	class InstrumentScriptVMFunction_delete_event_mark : public VMEmptyResultFunction {
95			public:
96			InstrumentScriptVMFunction_delete_event_mark(InstrumentScriptVM* parent);
97			int minRequiredArgs() const { return 2; }
98			int maxAllowedArgs() const { return 2; }
99			bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR;}
100			ExprType_t argType(int iArg) const { return INT_EXPR; }
101			VMFnResult* exec(VMFnArgs* args);
102			protected:
103			InstrumentScriptVM* m_vm;
104			};
105
106			class InstrumentScriptVMFunction_by_marks : public VMFunction {
107			public:
108			InstrumentScriptVMFunction_by_marks(InstrumentScriptVM* parent);
109	schoenebeck	3054	int minRequiredArgs() const OVERRIDE { return 1; }
110			int maxAllowedArgs() const OVERRIDE { return 1; }
111			bool acceptsArgType(int iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR;}
112	schoenebeck	2945	bool modifiesArg(int iArg) const OVERRIDE { return false; }
113	schoenebeck	3054	ExprType_t argType(int iArg) const OVERRIDE { return INT_EXPR; }
114			ExprType_t returnType() OVERRIDE { return INT_ARR_EXPR; }
115			VMFnResult* exec(VMFnArgs* args) OVERRIDE;
116	schoenebeck	2630	protected:
117			InstrumentScriptVM* m_vm;
118			class Result : public VMFnResult, public VMIntArrayExpr {
119			public:
120			StmtFlags_t flags;
121			EventGroup* eventGroup;
122
123			int arraySize() const OVERRIDE;
124			int evalIntElement(uint i) OVERRIDE;
125			void assignIntElement(uint i, int value) OVERRIDE {} // ignore assignment
126			VMExpr* resultValue() OVERRIDE { return this; }
127	schoenebeck	3054	StmtFlags_t resultFlags() OVERRIDE { return flags; }
128	schoenebeck	2945	bool isConstExpr() const OVERRIDE { return false; }
129	schoenebeck	2630	} m_result;
130
131			VMFnResult* errorResult();
132			VMFnResult* successResult(EventGroup* eventGroup);
133			};
134
135	schoenebeck	2931	class InstrumentScriptVMFunction_change_vol : public VMEmptyResultFunction {
136			public:
137			InstrumentScriptVMFunction_change_vol(InstrumentScriptVM* parent);
138			int minRequiredArgs() const { return 2; }
139			int maxAllowedArgs() const { return 3; }
140			bool acceptsArgType(int iArg, ExprType_t type) const;
141			ExprType_t argType(int iArg) const { return INT_EXPR; }
142			VMFnResult* exec(VMFnArgs* args);
143			protected:
144			InstrumentScriptVM* m_vm;
145			};
146
147			class InstrumentScriptVMFunction_change_tune : public VMEmptyResultFunction {
148			public:
149			InstrumentScriptVMFunction_change_tune(InstrumentScriptVM* parent);
150			int minRequiredArgs() const { return 2; }
151			int maxAllowedArgs() const { return 3; }
152			bool acceptsArgType(int iArg, ExprType_t type) const;
153			ExprType_t argType(int iArg) const { return INT_EXPR; }
154			VMFnResult* exec(VMFnArgs* args);
155			protected:
156			InstrumentScriptVM* m_vm;
157			};
158
159			class InstrumentScriptVMFunction_change_pan : public VMEmptyResultFunction {
160			public:
161			InstrumentScriptVMFunction_change_pan(InstrumentScriptVM* parent);
162			int minRequiredArgs() const { return 2; }
163			int maxAllowedArgs() const { return 3; }
164			bool acceptsArgType(int iArg, ExprType_t type) const;
165			ExprType_t argType(int iArg) const { return INT_EXPR; }
166			VMFnResult* exec(VMFnArgs* args);
167			protected:
168			InstrumentScriptVM* m_vm;
169			};
170
171	schoenebeck	2935	class InstrumentScriptVMFunction_change_cutoff : public VMEmptyResultFunction {
172			public:
173			InstrumentScriptVMFunction_change_cutoff(InstrumentScriptVM* parent);
174			int minRequiredArgs() const { return 2; }
175			int maxAllowedArgs() const { return 2; }
176			bool acceptsArgType(int iArg, ExprType_t type) const;
177			ExprType_t argType(int iArg) const { return INT_EXPR; }
178			VMFnResult* exec(VMFnArgs* args);
179			protected:
180			InstrumentScriptVM* m_vm;
181			};
182
183			class InstrumentScriptVMFunction_change_reso : public VMEmptyResultFunction {
184			public:
185			InstrumentScriptVMFunction_change_reso(InstrumentScriptVM* parent);
186			int minRequiredArgs() const { return 2; }
187			int maxAllowedArgs() const { return 2; }
188			bool acceptsArgType(int iArg, ExprType_t type) const;
189			ExprType_t argType(int iArg) const { return INT_EXPR; }
190			VMFnResult* exec(VMFnArgs* args);
191			protected:
192			InstrumentScriptVM* m_vm;
193			};
194	schoenebeck	2953
195			class InstrumentScriptVMFunction_change_attack : public VMEmptyResultFunction {
196			public:
197			InstrumentScriptVMFunction_change_attack(InstrumentScriptVM* parent);
198			int minRequiredArgs() const { return 2; }
199			int maxAllowedArgs() const { return 2; }
200			bool acceptsArgType(int iArg, ExprType_t type) const;
201			ExprType_t argType(int iArg) const { return INT_EXPR; }
202			VMFnResult* exec(VMFnArgs* args);
203			protected:
204			InstrumentScriptVM* m_vm;
205			};
206	schoenebeck	2935
207	schoenebeck	2953	class InstrumentScriptVMFunction_change_decay : public VMEmptyResultFunction {
208			public:
209			InstrumentScriptVMFunction_change_decay(InstrumentScriptVM* parent);
210			int minRequiredArgs() const { return 2; }
211			int maxAllowedArgs() const { return 2; }
212			bool acceptsArgType(int iArg, ExprType_t type) const;
213			ExprType_t argType(int iArg) const { return INT_EXPR; }
214			VMFnResult* exec(VMFnArgs* args);
215			protected:
216			InstrumentScriptVM* m_vm;
217			};
218
219			class InstrumentScriptVMFunction_change_release : public VMEmptyResultFunction {
220			public:
221			InstrumentScriptVMFunction_change_release(InstrumentScriptVM* parent);
222			int minRequiredArgs() const { return 2; }
223			int maxAllowedArgs() const { return 2; }
224			bool acceptsArgType(int iArg, ExprType_t type) const;
225			ExprType_t argType(int iArg) const { return INT_EXPR; }
226			VMFnResult* exec(VMFnArgs* args);
227			protected:
228			InstrumentScriptVM* m_vm;
229			};
230
231	schoenebeck	3118	class VMChangeSynthParamFunction : public VMEmptyResultFunction {
232			public:
233			VMChangeSynthParamFunction(InstrumentScriptVM* parent) : m_vm(parent) {}
234			int minRequiredArgs() const { return 2; }
235			int maxAllowedArgs() const { return 2; }
236			bool acceptsArgType(int iArg, ExprType_t type) const;
237			ExprType_t argType(int iArg) const { return INT_EXPR; }
238
239	schoenebeck	3188	template<float NoteBase::_Override::*T_noteParam, int T_synthParam,
240	schoenebeck	3193	bool T_isNormalizedParam, int T_maxValue, int T_minValue>
241	schoenebeck	3118	VMFnResult* execTemplate(VMFnArgs* args, const char* functionName);
242			protected:
243			InstrumentScriptVM* m_vm;
244			};
245
246	schoenebeck	3316	class InstrumentScriptVMFunction_change_sustain : public VMChangeSynthParamFunction {
247			public:
248			InstrumentScriptVMFunction_change_sustain(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent) {}
249			VMFnResult* exec(VMFnArgs* args);
250			};
251
252	schoenebeck	3118	class InstrumentScriptVMFunction_change_amp_lfo_depth : public VMChangeSynthParamFunction {
253			public:
254			InstrumentScriptVMFunction_change_amp_lfo_depth(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent) {}
255			VMFnResult* exec(VMFnArgs* args);
256			};
257
258			class InstrumentScriptVMFunction_change_amp_lfo_freq : public VMChangeSynthParamFunction {
259			public:
260			InstrumentScriptVMFunction_change_amp_lfo_freq(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent) {}
261			VMFnResult* exec(VMFnArgs* args);
262			};
263
264			class InstrumentScriptVMFunction_change_pitch_lfo_depth : public VMChangeSynthParamFunction {
265			public:
266			InstrumentScriptVMFunction_change_pitch_lfo_depth(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent) {}
267			VMFnResult* exec(VMFnArgs* args);
268			};
269
270			class InstrumentScriptVMFunction_change_pitch_lfo_freq : public VMChangeSynthParamFunction {
271			public:
272			InstrumentScriptVMFunction_change_pitch_lfo_freq(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent) {}
273			VMFnResult* exec(VMFnArgs* args);
274			};
275
276	schoenebeck	3188	class InstrumentScriptVMFunction_change_vol_time : public VMChangeSynthParamFunction {
277			public:
278			InstrumentScriptVMFunction_change_vol_time(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent) {}
279			VMFnResult* exec(VMFnArgs* args);
280			};
281
282			class InstrumentScriptVMFunction_change_tune_time : public VMChangeSynthParamFunction {
283			public:
284			InstrumentScriptVMFunction_change_tune_time(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent) {}
285			VMFnResult* exec(VMFnArgs* args);
286			};
287
288	schoenebeck	3246	class VMChangeFadeCurveFunction : public VMEmptyResultFunction {
289			public:
290			VMChangeFadeCurveFunction(InstrumentScriptVM* parent) : m_vm(parent) {}
291			int minRequiredArgs() const { return 2; }
292			int maxAllowedArgs() const { return 2; }
293			bool acceptsArgType(int iArg, ExprType_t type) const;
294			ExprType_t argType(int iArg) const { return INT_EXPR; }
295
296			template<fade_curve_t NoteBase::_Override::*T_noteParam, int T_synthParam>
297			VMFnResult* execTemplate(VMFnArgs* args, const char* functionName);
298			protected:
299			InstrumentScriptVM* m_vm;
300			};
301
302			class InstrumentScriptVMFunction_change_vol_curve : public VMChangeFadeCurveFunction {
303			public:
304			InstrumentScriptVMFunction_change_vol_curve(InstrumentScriptVM* parent) : VMChangeFadeCurveFunction(parent) {}
305			VMFnResult* exec(VMFnArgs* args);
306			};
307
308			class InstrumentScriptVMFunction_change_tune_curve : public VMChangeFadeCurveFunction {
309			public:
310			InstrumentScriptVMFunction_change_tune_curve(InstrumentScriptVM* parent) : VMChangeFadeCurveFunction(parent) {}
311			VMFnResult* exec(VMFnArgs* args);
312			};
313
314	schoenebeck	3188	class InstrumentScriptVMFunction_fade_in : public VMEmptyResultFunction {
315			public:
316			InstrumentScriptVMFunction_fade_in(InstrumentScriptVM* parent);
317			int minRequiredArgs() const { return 2; }
318			int maxAllowedArgs() const { return 2; }
319			bool acceptsArgType(int iArg, ExprType_t type) const;
320			ExprType_t argType(int iArg) const { return INT_EXPR; }
321			VMFnResult* exec(VMFnArgs* args);
322			protected:
323			InstrumentScriptVM* m_vm;
324			};
325
326			class InstrumentScriptVMFunction_fade_out : public VMEmptyResultFunction {
327			public:
328			InstrumentScriptVMFunction_fade_out(InstrumentScriptVM* parent);
329			int minRequiredArgs() const { return 2; }
330			int maxAllowedArgs() const { return 3; }
331			bool acceptsArgType(int iArg, ExprType_t type) const;
332			ExprType_t argType(int iArg) const { return INT_EXPR; }
333			VMFnResult* exec(VMFnArgs* args);
334			protected:
335			InstrumentScriptVM* m_vm;
336			};
337
338	schoenebeck	3193	class InstrumentScriptVMFunction_get_event_par : public VMIntResultFunction {
339			public:
340			InstrumentScriptVMFunction_get_event_par(InstrumentScriptVM* parent);
341			int minRequiredArgs() const { return 2; }
342			int maxAllowedArgs() const { return 2; }
343			bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR;}
344			ExprType_t argType(int iArg) const { return INT_EXPR; }
345			VMFnResult* exec(VMFnArgs* args);
346			protected:
347			InstrumentScriptVM* m_vm;
348			};
349
350			class InstrumentScriptVMFunction_set_event_par : public VMEmptyResultFunction {
351			public:
352			InstrumentScriptVMFunction_set_event_par(InstrumentScriptVM* parent);
353			int minRequiredArgs() const { return 3; }
354			int maxAllowedArgs() const { return 3; }
355			bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR;}
356			ExprType_t argType(int iArg) const { return INT_EXPR; }
357			VMFnResult* exec(VMFnArgs* args);
358			protected:
359			InstrumentScriptVM* m_vm;
360			};
361
362	schoenebeck	3214	class InstrumentScriptVMFunction_change_note : public VMEmptyResultFunction {
363			public:
364			InstrumentScriptVMFunction_change_note(InstrumentScriptVM* parent);
365			int minRequiredArgs() const { return 2; }
366			int maxAllowedArgs() const { return 2; }
367			bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR;}
368			ExprType_t argType(int iArg) const { return INT_EXPR; }
369			VMFnResult* exec(VMFnArgs* args);
370			protected:
371			InstrumentScriptVM* m_vm;
372			};
373
374			class InstrumentScriptVMFunction_change_velo : public VMEmptyResultFunction {
375			public:
376			InstrumentScriptVMFunction_change_velo(InstrumentScriptVM* parent);
377			int minRequiredArgs() const { return 2; }
378			int maxAllowedArgs() const { return 2; }
379			bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR;}
380			ExprType_t argType(int iArg) const { return INT_EXPR; }
381			VMFnResult* exec(VMFnArgs* args);
382			protected:
383			InstrumentScriptVM* m_vm;
384			};
385
386	schoenebeck	3255	class InstrumentScriptVMFunction_change_play_pos : public VMEmptyResultFunction {
387			public:
388			InstrumentScriptVMFunction_change_play_pos(InstrumentScriptVM* parent);
389			int minRequiredArgs() const { return 2; }
390			int maxAllowedArgs() const { return 2; }
391			bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR; }
392			ExprType_t argType(int iArg) const { return INT_EXPR; }
393			VMFnResult* exec(VMFnArgs* args);
394			protected:
395			InstrumentScriptVM* m_vm;
396			};
397
398	schoenebeck	2935	class InstrumentScriptVMFunction_event_status : public VMIntResultFunction {
399			public:
400			InstrumentScriptVMFunction_event_status(InstrumentScriptVM* parent);
401			int minRequiredArgs() const { return 1; }
402			int maxAllowedArgs() const { return 1; }
403			bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR;}
404			ExprType_t argType(int iArg) const { return INT_EXPR; }
405			VMFnResult* exec(VMFnArgs* args);
406			protected:
407			InstrumentScriptVM* m_vm;
408			};
409
410	schoenebeck	3296	class InstrumentScriptVMFunction_callback_status : public VMIntResultFunction {
411			public:
412			InstrumentScriptVMFunction_callback_status(InstrumentScriptVM* parent);
413			int minRequiredArgs() const { return 1; }
414			int maxAllowedArgs() const { return 1; }
415			bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR;}
416			ExprType_t argType(int iArg) const { return INT_EXPR; }
417			VMFnResult* exec(VMFnArgs* args);
418			protected:
419			InstrumentScriptVM* m_vm;
420			};
421
422	schoenebeck	2948	// overrides core wait() implementation
423			class InstrumentScriptVMFunction_wait : public CoreVMFunction_wait {
424			public:
425			InstrumentScriptVMFunction_wait(InstrumentScriptVM* parent);
426			VMFnResult* exec(VMFnArgs* args);
427			};
428
429			class InstrumentScriptVMFunction_stop_wait : public VMEmptyResultFunction {
430			public:
431			InstrumentScriptVMFunction_stop_wait(InstrumentScriptVM* parent);
432			int minRequiredArgs() const { return 1; }
433			int maxAllowedArgs() const { return 2; }
434			bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR;}
435			ExprType_t argType(int iArg) const { return INT_EXPR; }
436			VMFnResult* exec(VMFnArgs* args);
437			protected:
438			InstrumentScriptVM* m_vm;
439			};
440
441	schoenebeck	3277	class InstrumentScriptVMFunction_abort : public VMEmptyResultFunction {
442			public:
443			InstrumentScriptVMFunction_abort(InstrumentScriptVM* parent);
444			int minRequiredArgs() const { return 1; }
445			int maxAllowedArgs() const { return 1; }
446			bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR; }
447			ExprType_t argType(int iArg) const { return INT_EXPR; }
448			VMFnResult* exec(VMFnArgs* args) OVERRIDE;
449			protected:
450			InstrumentScriptVM* m_vm;
451			};
452
453	schoenebeck	3293	class InstrumentScriptVMFunction_fork : public VMIntResultFunction {
454			public:
455			InstrumentScriptVMFunction_fork(InstrumentScriptVM* parent);
456			int minRequiredArgs() const { return 0; }
457			int maxAllowedArgs() const { return 2; }
458			bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR;}
459			ExprType_t argType(int iArg) const { return INT_EXPR; }
460			VMFnResult* exec(VMFnArgs* args);
461			protected:
462			InstrumentScriptVM* m_vm;
463			};
464
465	schoenebeck	2596	} // namespace LinuxSampler
466
467			#endif // LS_INSTRSCRIPTVMFUNCTIONS_H