src/scriptvm/CoreVMFunctions.h

/*
 * Copyright (c) 2014 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_COREVMFUNCTIONS_H
#define LS_COREVMFUNCTIONS_H

#include "../common/global.h"
#include "common.h"

namespace LinuxSampler {
    
class ScriptVM;
    
class VMEmptyResult : public VMFnResult, public VMExpr {
public:
    StmtFlags_t flags;

    VMEmptyResult() : flags(STMT_SUCCESS) {}
    ExprType_t exprType() const { return EMPTY_EXPR; }
    VMExpr* resultValue() { return this; }
    StmtFlags_t resultFlags() { return flags; }
};

class VMIntResult : public VMFnResult, public VMIntExpr {
public:
    StmtFlags_t flags;
    int value;

    VMIntResult() : flags(STMT_SUCCESS) {}
    int evalInt() { return value; }
    VMExpr* resultValue() { return this; }
    StmtFlags_t resultFlags() { return flags; }
};

class VMStringResult : public VMFnResult, public VMStringExpr {
public:
    StmtFlags_t flags;
    String value;

    VMStringResult() : flags(STMT_SUCCESS) {}
    String evalStr() { return value; }
    VMExpr* resultValue() { return this; }
    StmtFlags_t resultFlags() { return flags; }
};

class VMEmptyResultFunction : public VMFunction {
protected:
    ExprType_t returnType() { return EMPTY_EXPR; }
    VMFnResult* errorResult();
    VMFnResult* successResult();
protected:
    VMEmptyResult result;
};

class VMIntResultFunction : public VMFunction {
protected:
    ExprType_t returnType() { return INT_EXPR; }
    VMFnResult* errorResult(int i = 0);
    VMFnResult* successResult(int i = 0);
protected:
    VMIntResult result;
};

class VMStringResultFunction : public VMFunction {
protected:
    ExprType_t returnType() { return STRING_EXPR; }
    VMFnResult* errorResult(const String& s = "");
    VMFnResult* successResult(const String& s = "");
protected:
    VMStringResult result;
};

class CoreVMFunction_message : public VMEmptyResultFunction {
public:
    int minRequiredArgs() const { return 1; }
    int maxAllowedArgs() const { return 1; }
    bool acceptsArgType(int iArg, ExprType_t type) const;
    ExprType_t argType(int iArg) const { return STRING_EXPR; }
    VMFnResult* exec(VMFnArgs* args);
};

class CoreVMFunction_exit : public VMEmptyResultFunction {
public:
    int minRequiredArgs() const { return 0; }
    int maxAllowedArgs() const { return 0; }
    bool acceptsArgType(int iArg, ExprType_t type) const { return false; }
    ExprType_t argType(int iArg) const { return INT_EXPR; /*whatever*/ }
    VMFnResult* exec(VMFnArgs* args);
};

class CoreVMFunction_wait : public VMEmptyResultFunction {
public:
    CoreVMFunction_wait(ScriptVM* vm) : vm(vm) {}
    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:
    ScriptVM* vm;
};

class CoreVMFunction_abs : public VMIntResultFunction {
public:
    int minRequiredArgs() const { return 1; }
    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);
};

class CoreVMFunction_random : public VMIntResultFunction {
public:
    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);
};

class CoreVMFunction_num_elements : public VMIntResultFunction {
public:
    int minRequiredArgs() const { return 1; }
    int maxAllowedArgs() const { return 1; }
    bool acceptsArgType(int iArg, ExprType_t type) const;
    ExprType_t argType(int iArg) const { return INT_ARR_EXPR; }
    VMFnResult* exec(VMFnArgs* args);
};

} // namespace LinuxSampler

#endif // LS_COREVMFUNCTIONS_H
1	schoenebeck	2581	/*
2			* Copyright (c) 2014 Christian Schoenebeck
3			*
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_COREVMFUNCTIONS_H
11			#define LS_COREVMFUNCTIONS_H
12
13			#include "../common/global.h"
14			#include "common.h"
15
16			namespace LinuxSampler {
17
18			class ScriptVM;
19
20			class VMEmptyResult : public VMFnResult, public VMExpr {
21			public:
22			StmtFlags_t flags;
23
24			VMEmptyResult() : flags(STMT_SUCCESS) {}
25			ExprType_t exprType() const { return EMPTY_EXPR; }
26			VMExpr* resultValue() { return this; }
27			StmtFlags_t resultFlags() { return flags; }
28			};
29
30	schoenebeck	2598	class VMIntResult : public VMFnResult, public VMIntExpr {
31			public:
32			StmtFlags_t flags;
33			int value;
34
35			VMIntResult() : flags(STMT_SUCCESS) {}
36			int evalInt() { return value; }
37			VMExpr* resultValue() { return this; }
38			StmtFlags_t resultFlags() { return flags; }
39			};
40
41	schoenebeck	2581	class VMStringResult : public VMFnResult, public VMStringExpr {
42			public:
43			StmtFlags_t flags;
44			String value;
45
46			VMStringResult() : flags(STMT_SUCCESS) {}
47			String evalStr() { return value; }
48			VMExpr* resultValue() { return this; }
49			StmtFlags_t resultFlags() { return flags; }
50			};
51
52			class VMEmptyResultFunction : public VMFunction {
53			protected:
54			ExprType_t returnType() { return EMPTY_EXPR; }
55			VMFnResult* errorResult();
56			VMFnResult* successResult();
57			protected:
58			VMEmptyResult result;
59			};
60
61	schoenebeck	2598	class VMIntResultFunction : public VMFunction {
62			protected:
63			ExprType_t returnType() { return INT_EXPR; }
64			VMFnResult* errorResult(int i = 0);
65			VMFnResult* successResult(int i = 0);
66			protected:
67			VMIntResult result;
68			};
69
70	schoenebeck	2581	class VMStringResultFunction : public VMFunction {
71			protected:
72			ExprType_t returnType() { return STRING_EXPR; }
73			VMFnResult* errorResult(const String& s = "");
74			VMFnResult* successResult(const String& s = "");
75			protected:
76			VMStringResult result;
77			};
78
79			class CoreVMFunction_message : public VMEmptyResultFunction {
80			public:
81			int minRequiredArgs() const { return 1; }
82			int maxAllowedArgs() const { return 1; }
83			bool acceptsArgType(int iArg, ExprType_t type) const;
84			ExprType_t argType(int iArg) const { return STRING_EXPR; }
85			VMFnResult* exec(VMFnArgs* args);
86			};
87
88			class CoreVMFunction_exit : public VMEmptyResultFunction {
89			public:
90			int minRequiredArgs() const { return 0; }
91			int maxAllowedArgs() const { return 0; }
92			bool acceptsArgType(int iArg, ExprType_t type) const { return false; }
93			ExprType_t argType(int iArg) const { return INT_EXPR; /whatever/ }
94			VMFnResult* exec(VMFnArgs* args);
95			};
96
97			class CoreVMFunction_wait : public VMEmptyResultFunction {
98			public:
99			CoreVMFunction_wait(ScriptVM* vm) : vm(vm) {}
100			int minRequiredArgs() const { return 1; }
101			int maxAllowedArgs() const { return 1; }
102			bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR; }
103			ExprType_t argType(int iArg) const { return INT_EXPR; }
104			VMFnResult* exec(VMFnArgs* args);
105			protected:
106			ScriptVM* vm;
107			};
108
109	schoenebeck	2619	class CoreVMFunction_abs : public VMIntResultFunction {
110			public:
111			int minRequiredArgs() const { return 1; }
112			int maxAllowedArgs() const { return 1; }
113			bool acceptsArgType(int iArg, ExprType_t type) const;
114			ExprType_t argType(int iArg) const { return INT_EXPR; }
115			VMFnResult* exec(VMFnArgs* args);
116			};
117
118			class CoreVMFunction_random : public VMIntResultFunction {
119			public:
120			int minRequiredArgs() const { return 2; }
121			int maxAllowedArgs() const { return 2; }
122			bool acceptsArgType(int iArg, ExprType_t type) const;
123			ExprType_t argType(int iArg) const { return INT_EXPR; }
124			VMFnResult* exec(VMFnArgs* args);
125			};
126
127			class CoreVMFunction_num_elements : public VMIntResultFunction {
128			public:
129			int minRequiredArgs() const { return 1; }
130			int maxAllowedArgs() const { return 1; }
131			bool acceptsArgType(int iArg, ExprType_t type) const;
132			ExprType_t argType(int iArg) const { return INT_ARR_EXPR; }
133			VMFnResult* exec(VMFnArgs* args);
134			};
135
136	schoenebeck	2581	} // namespace LinuxSampler
137
138			#endif // LS_COREVMFUNCTIONS_H