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 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 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;
};

} // namespace LinuxSampler

#endif // LS_COREVMFUNCTIONS_H
1	/*
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	class VMStringResult : public VMFnResult, public VMStringExpr {
31	public:
32	StmtFlags_t flags;
33	String value;
34
35	VMStringResult() : flags(STMT_SUCCESS) {}
36	String evalStr() { return value; }
37	VMExpr* resultValue() { return this; }
38	StmtFlags_t resultFlags() { return flags; }
39	};
40
41	class VMEmptyResultFunction : public VMFunction {
42	protected:
43	ExprType_t returnType() { return EMPTY_EXPR; }
44	VMFnResult* errorResult();
45	VMFnResult* successResult();
46	protected:
47	VMEmptyResult result;
48	};
49
50	class VMStringResultFunction : public VMFunction {
51	protected:
52	ExprType_t returnType() { return STRING_EXPR; }
53	VMFnResult* errorResult(const String& s = "");
54	VMFnResult* successResult(const String& s = "");
55	protected:
56	VMStringResult result;
57	};
58
59	class CoreVMFunction_message : public VMEmptyResultFunction {
60	public:
61	int minRequiredArgs() const { return 1; }
62	int maxAllowedArgs() const { return 1; }
63	bool acceptsArgType(int iArg, ExprType_t type) const;
64	ExprType_t argType(int iArg) const { return STRING_EXPR; }
65	VMFnResult* exec(VMFnArgs* args);
66	};
67
68	class CoreVMFunction_exit : public VMEmptyResultFunction {
69	public:
70	int minRequiredArgs() const { return 0; }
71	int maxAllowedArgs() const { return 0; }
72	bool acceptsArgType(int iArg, ExprType_t type) const { return false; }
73	ExprType_t argType(int iArg) const { return INT_EXPR; /whatever/ }
74	VMFnResult* exec(VMFnArgs* args);
75	};
76
77	class CoreVMFunction_wait : public VMEmptyResultFunction {
78	public:
79	CoreVMFunction_wait(ScriptVM* vm) : vm(vm) {}
80	int minRequiredArgs() const { return 1; }
81	int maxAllowedArgs() const { return 1; }
82	bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR; }
83	ExprType_t argType(int iArg) const { return INT_EXPR; }
84	VMFnResult* exec(VMFnArgs* args);
85	protected:
86	ScriptVM* vm;
87	};
88
89	} // namespace LinuxSampler
90
91	#endif // LS_COREVMFUNCTIONS_H