trunk/src/ls_instr_script.cpp

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

#include "common/global.h"
#include "scriptvm/ScriptVM.h"
#include "shell/CFmt.h"
#include "engines/common/InstrumentScriptVM.h"
#include "engines/gig/InstrumentScriptVM.h"
#include <iostream>
#include <fstream>

/*
  This command line tool is currently merely for development and testing
  purposes, regarding the real-time instrument script feature of the sampler.
  You can use this command line application like this:

  ls_instr_script core < src/scriptvm/examples/helloworld.txt

  Which will peform 3 things:

  1. Parses the given instrument script and prints any parser errors or
     warnings.
  2. It dumps the parsed VM tree (only interesting for LS developers).
  3. If there were not parser errors, it will run each event handler defined in
     the script.
 */

using namespace LinuxSampler;
using namespace std;

static void printUsage() {
    cout << "ls_instr_script - Parse real-time instrument script from stdin." << endl;
    cout << endl;
    cout << "Usage: ls_instr_script ENGINE [OPTIONS]" << endl;
    cout << endl;
    cout << "    ENGINE\n";
    cout << "        Either \"core\", \"gig\", \"sf2\" or \"sfz\"." << endl;
    cout << endl;
    cout << "    OPTIONS" << endl;
    cout << "        --file FILE | -f FILE" << endl;
    cout << "            Read from this file instead from stdin." << endl;
    cout << endl;
    cout << "        --syntax | -s" << endl;
    cout << "            Prints the script to stdout with colored syntax highlighting" << endl;
    cout << "            and exits immediately." << endl;
    cout << endl;
    cout << "        --debug-syntax | -ds" << endl;
    cout << "            Prints a debugging representation (of the syntax" << endl;
    cout << "            highlighting backend) of the parsed script to stdout and exits" << endl;
    cout << "            immediately." << endl;
    cout << endl;
    cout << "        --auto-suspend" << endl;
    cout << "            In contrast to the real sampler, this command line program " << endl;
    cout << "            disables automatic suspension by the VM by default to ease " << endl;
    cout << "            i.e. bench marking tasks and the like. By providing this " << endl;
    cout << "            argument auto suspension will be enabled." << endl;
    cout << endl;
    cout << "If you pass \"core\" as argument, only the core language built-in" << endl;
    cout << "variables and functions are available. However in this particular" << endl;
    cout << "mode the program will not just parse the given script, but also" << endl;
    cout << "execute the event handlers. All other arguments for ENGINE provide" << endl;
    cout << "the sampler engine / sampler format specific additional built-in" << endl;
    cout << "variables and functions, however they wil not be executed by this" << endl;
    cout << "program." << endl;
    cout << endl;
}

static void printCodeWithSyntaxHighlighting(ScriptVM* vm);
static void dumpSyntaxHighlighting(ScriptVM* vm);
static String readTxtFromFile(String path);

int main(int argc, char *argv[]) {
    if (argc < 2) {
        printUsage();
        return -1;
    }
    String engine = argv[1];
    String path;
    bool runScript = false;

    ScriptVM* vm;
    if (engine == "core") {
        vm = new ScriptVM;
        runScript = true;
    } else if (engine == "sf2" || engine == "sfz") {
        vm = new InstrumentScriptVM;
    } else if (engine == "gig") {
        vm = new gig::InstrumentScriptVM;
    } else {
        std::cerr << "Unknown ENGINE '" << engine << "'\n\n";
        printUsage();
        return -1;
    }
    vm->setAutoSuspendEnabled(false);

    // validate & parse arguments provided to this program
    for (int iArg = 2; iArg < argc; ++iArg) {
        const string opt = argv[iArg];
        if (opt == "--") { // common for all command line tools: separator between initial option arguments and i.e. subsequent file arguments
            iArg++;
            break;
        }
        if (opt.substr(0, 1) != "-") break;

        if (opt == "-s" || opt == "--syntax") {
            printCodeWithSyntaxHighlighting(vm);
            return 0;
        } else if (opt == "-ds" || opt == "--debug-syntax") {
            dumpSyntaxHighlighting(vm);
            return 0;
        } else if (opt == "--auto-suspend") {
            vm->setAutoSuspendEnabled(true);
        } else if (opt == "-f" || opt == "--file") {
            if (++iArg < argc)
                path = argv[iArg];
        } else {
            cerr << "Unknown option '" << opt << "'" << endl;
            cerr << endl;
            printUsage();
            return -1;
        }
    }

    VMParserContext* parserContext;
    if (path.empty())
        parserContext = vm->loadScript(&std::cin);
    else {
        String txt = readTxtFromFile(path);
        parserContext = vm->loadScript(txt);
    }

    std::vector<ParserIssue> errors = parserContext->errors();
    std::vector<ParserIssue> warnings = parserContext->warnings();
    std::vector<ParserIssue> issues = parserContext->issues();
    if (warnings.empty() && errors.empty()) {
        CFmt fmt; fmt.green();
        printf("EOF. Script parse completed successfully (no errors, no warnings).\n");
    } else if (!errors.empty()) {
        CFmt fmt; fmt.red();
        printf("EOF. Script parse completed with issues (%d errors, %d warnings):\n",
               int(errors.size()), int(warnings.size()));
    } else {
        CFmt fmt; fmt.yellow();
        printf("EOF. Script parse completed with issues (%d errors, %d warnings):\n",
               int(errors.size()), int(warnings.size()));
    }
    for (int i = 0; i < issues.size(); ++i) {
        CFmt fmt;
        if (issues[i].isWrn()) fmt.yellow();
        else if (issues[i].isErr()) fmt.red();
        issues[i].dump();
    }

    printf("[Dumping parsed VM tree]\n");
    vm->dumpParsedScript(parserContext);
    printf("[End of parsed VM tree]\n");

    if (!errors.empty()) {
        if (parserContext) delete parserContext;
        return -1;
    }

    if (!runScript) {
        return 0;
    }

    if (!parserContext->eventHandler(0)) {
        printf("No event handler exists. So nothing to execute.\n");
        if (parserContext) delete parserContext;
        return 0;
    }

    printf("Preparing execution of script.\n");
    VMExecContext* execContext = vm->createExecContext(parserContext);
    for (int i = 0; parserContext->eventHandler(i); ++i) {
        VMEventHandler* handler = parserContext->eventHandler(i);
        printf("[Running event handler '%s']\n", handler->eventHandlerName().c_str());
        VMExecStatus_t result = vm->exec(parserContext, execContext, handler);
        CFmt fmt;
        if (result & VM_EXEC_ERROR) {
            fmt.red();
            printf("[Event handler '%s' finished with ERROR status]\n", handler->eventHandlerName().c_str());
        } else if (result & VM_EXEC_SUSPENDED) {
            fmt.yellow();
            printf("[Event handler '%s' returned with SUSPENDED status: %d microseconds]\n",
                   handler->eventHandlerName().c_str(), execContext->suspensionTimeMicroseconds());
        } else if (!(result & VM_EXEC_RUNNING)) {
            fmt.green();
            printf("[Event handler '%s' finished with SUCCESS status]\n", handler->eventHandlerName().c_str());
        } else if (result & VM_EXEC_RUNNING) {
            fmt.cyan();
            printf("[Event handler '%s' finished with RUNNING status]\n", handler->eventHandlerName().c_str());
        } else {
            fmt.red();
            printf("[Event handler '%s' finished with UNKNOWN status]\n", handler->eventHandlerName().c_str());
        }
    }

    if (parserContext) delete parserContext;
    if (execContext) delete execContext;
    if (vm) delete vm;

    return 0;
}

static void printCodeWithSyntaxHighlighting(ScriptVM* vm) {
    vector<VMSourceToken> tokens = vm->syntaxHighlighting(&std::cin);

    for (int i = 0; i < tokens.size(); ++i) {
        const VMSourceToken& token = tokens[i];

        CFmt fmt;
        if (token.isKeyword()) {
            fmt.bold();
        } else if (token.isVariableName()) {
            fmt.magenta();
        } else if (token.isIdentifier()) {
            if (token.isEventHandlerName()) {
                fmt.bold();
                fmt.cyan();
            } else { // a function ...
                fmt.cyan();
            }
        } else if (token.isNumberLiteral()) {
            fmt.yellow();
        } else if (token.isStringLiteral()) {
            fmt.red();
        } else if (token.isComment()) {
            fmt.blue();
        } else if (token.isPreprocessor()) {
            fmt.green();
        } else if (token.isNewLine()) {
        }

        printf("%s", token.text().c_str());
        fflush(stdout);
    }
}

static void dumpSyntaxHighlighting(ScriptVM* vm) {
    vector<VMSourceToken> tokens = vm->syntaxHighlighting(&std::cin);

    for (int i = 0; i < tokens.size(); ++i) {
        const VMSourceToken& token = tokens[i];
        const char* type = "OTHER";
        if (token.isKeyword()) {
            type = "KEYWORD";
        } else if (token.isVariableName()) {
            type = "VARIABLE";
        } else if (token.isIdentifier()) {
            if (token.isEventHandlerName()) {
                type = "HANDLER_NAME";
            } else { // a function ...
                type = "FUNCTION";
            }
        } else if (token.isNumberLiteral()) {
            type = "NUMBER";
        } else if (token.isStringLiteral()) {
            type = "STRING";
        } else if (token.isComment()) {
            type = "COMMENT";
        } else if (token.isPreprocessor()) {
            type = "PREPROC";
        } else if (token.isNewLine()) {
            type = "NL";
        }
        printf("L%d,C%d: %s \"%s\"\n", token.firstLine(), token.firstColumn(), type, token.text().c_str());
    }
}

static String readTxtFromFile(String path) {
    std::ifstream f(path.c_str(), std::ifstream::in);
    String s;
    s += (char) f.get();
    while (f.good()) {
        char c = f.get();
        if (c == EOF) break;
        s += c;
    }
    f.close();
    return s;
}
1	/*
2	* Copyright (c) 2014-2016 Christian Schoenebeck
3	*
4	* http://www.linuxsampler.org
5	*
6	* This program is part of LinuxSampler and released under the same terms.
7	* See README file for details.
8	*/
9
10	#include "common/global.h"
11	#include "scriptvm/ScriptVM.h"
12	#include "shell/CFmt.h"
13	#include "engines/common/InstrumentScriptVM.h"
14	#include "engines/gig/InstrumentScriptVM.h"
15	#include <iostream>
16	#include <fstream>
17
18	/*
19	This command line tool is currently merely for development and testing
20	purposes, regarding the real-time instrument script feature of the sampler.
21	You can use this command line application like this:
22
23	ls_instr_script core < src/scriptvm/examples/helloworld.txt
24
25	Which will peform 3 things:
26
27	1. Parses the given instrument script and prints any parser errors or
28	warnings.
29	2. It dumps the parsed VM tree (only interesting for LS developers).
30	3. If there were not parser errors, it will run each event handler defined in
31	the script.
32	*/
33
34	using namespace LinuxSampler;
35	using namespace std;
36
37	static void printUsage() {
38	cout << "ls_instr_script - Parse real-time instrument script from stdin." << endl;
39	cout << endl;
40	cout << "Usage: ls_instr_script ENGINE [OPTIONS]" << endl;
41	cout << endl;
42	cout << " ENGINE\n";
43	cout << " Either \"core\", \"gig\", \"sf2\" or \"sfz\"." << endl;
44	cout << endl;
45	cout << " OPTIONS" << endl;
46	cout << " --file FILE \| -f FILE" << endl;
47	cout << " Read from this file instead from stdin." << endl;
48	cout << endl;
49	cout << " --syntax \| -s" << endl;
50	cout << " Prints the script to stdout with colored syntax highlighting" << endl;
51	cout << " and exits immediately." << endl;
52	cout << endl;
53	cout << " --debug-syntax \| -ds" << endl;
54	cout << " Prints a debugging representation (of the syntax" << endl;
55	cout << " highlighting backend) of the parsed script to stdout and exits" << endl;
56	cout << " immediately." << endl;
57	cout << endl;
58	cout << " --auto-suspend" << endl;
59	cout << " In contrast to the real sampler, this command line program " << endl;
60	cout << " disables automatic suspension by the VM by default to ease " << endl;
61	cout << " i.e. bench marking tasks and the like. By providing this " << endl;
62	cout << " argument auto suspension will be enabled." << endl;
63	cout << endl;
64	cout << "If you pass \"core\" as argument, only the core language built-in" << endl;
65	cout << "variables and functions are available. However in this particular" << endl;
66	cout << "mode the program will not just parse the given script, but also" << endl;
67	cout << "execute the event handlers. All other arguments for ENGINE provide" << endl;
68	cout << "the sampler engine / sampler format specific additional built-in" << endl;
69	cout << "variables and functions, however they wil not be executed by this" << endl;
70	cout << "program." << endl;
71	cout << endl;
72	}
73
74	static void printCodeWithSyntaxHighlighting(ScriptVM* vm);
75	static void dumpSyntaxHighlighting(ScriptVM* vm);
76	static String readTxtFromFile(String path);
77
78	int main(int argc, char *argv[]) {
79	if (argc < 2) {
80	printUsage();
81	return -1;
82	}
83	String engine = argv[1];
84	String path;
85	bool runScript = false;
86
87	ScriptVM* vm;
88	if (engine == "core") {
89	vm = new ScriptVM;
90	runScript = true;
91	} else if (engine == "sf2" \|\| engine == "sfz") {
92	vm = new InstrumentScriptVM;
93	} else if (engine == "gig") {
94	vm = new gig::InstrumentScriptVM;
95	} else {
96	std::cerr << "Unknown ENGINE '" << engine << "'\n\n";
97	printUsage();
98	return -1;
99	}
100	vm->setAutoSuspendEnabled(false);
101
102	// validate & parse arguments provided to this program
103	for (int iArg = 2; iArg < argc; ++iArg) {
104	const string opt = argv[iArg];
105	if (opt == "--") { // common for all command line tools: separator between initial option arguments and i.e. subsequent file arguments
106	iArg++;
107	break;
108	}
109	if (opt.substr(0, 1) != "-") break;
110
111	if (opt == "-s" \|\| opt == "--syntax") {
112	printCodeWithSyntaxHighlighting(vm);
113	return 0;
114	} else if (opt == "-ds" \|\| opt == "--debug-syntax") {
115	dumpSyntaxHighlighting(vm);
116	return 0;
117	} else if (opt == "--auto-suspend") {
118	vm->setAutoSuspendEnabled(true);
119	} else if (opt == "-f" \|\| opt == "--file") {
120	if (++iArg < argc)
121	path = argv[iArg];
122	} else {
123	cerr << "Unknown option '" << opt << "'" << endl;
124	cerr << endl;
125	printUsage();
126	return -1;
127	}
128	}
129
130	VMParserContext* parserContext;
131	if (path.empty())
132	parserContext = vm->loadScript(&std::cin);
133	else {
134	String txt = readTxtFromFile(path);
135	parserContext = vm->loadScript(txt);
136	}
137
138	std::vector<ParserIssue> errors = parserContext->errors();
139	std::vector<ParserIssue> warnings = parserContext->warnings();
140	std::vector<ParserIssue> issues = parserContext->issues();
141	if (warnings.empty() && errors.empty()) {
142	CFmt fmt; fmt.green();
143	printf("EOF. Script parse completed successfully (no errors, no warnings).\n");
144	} else if (!errors.empty()) {
145	CFmt fmt; fmt.red();
146	printf("EOF. Script parse completed with issues (%d errors, %d warnings):\n",
147	int(errors.size()), int(warnings.size()));
148	} else {
149	CFmt fmt; fmt.yellow();
150	printf("EOF. Script parse completed with issues (%d errors, %d warnings):\n",
151	int(errors.size()), int(warnings.size()));
152	}
153	for (int i = 0; i < issues.size(); ++i) {
154	CFmt fmt;
155	if (issues[i].isWrn()) fmt.yellow();
156	else if (issues[i].isErr()) fmt.red();
157	issues[i].dump();
158	}
159
160	printf("[Dumping parsed VM tree]\n");
161	vm->dumpParsedScript(parserContext);
162	printf("[End of parsed VM tree]\n");
163
164	if (!errors.empty()) {
165	if (parserContext) delete parserContext;
166	return -1;
167	}
168
169	if (!runScript) {
170	return 0;
171	}
172
173	if (!parserContext->eventHandler(0)) {
174	printf("No event handler exists. So nothing to execute.\n");
175	if (parserContext) delete parserContext;
176	return 0;
177	}
178
179	printf("Preparing execution of script.\n");
180	VMExecContext* execContext = vm->createExecContext(parserContext);
181	for (int i = 0; parserContext->eventHandler(i); ++i) {
182	VMEventHandler* handler = parserContext->eventHandler(i);
183	printf("[Running event handler '%s']\n", handler->eventHandlerName().c_str());
184	VMExecStatus_t result = vm->exec(parserContext, execContext, handler);
185	CFmt fmt;
186	if (result & VM_EXEC_ERROR) {
187	fmt.red();
188	printf("[Event handler '%s' finished with ERROR status]\n", handler->eventHandlerName().c_str());
189	} else if (result & VM_EXEC_SUSPENDED) {
190	fmt.yellow();
191	printf("[Event handler '%s' returned with SUSPENDED status: %d microseconds]\n",
192	handler->eventHandlerName().c_str(), execContext->suspensionTimeMicroseconds());
193	} else if (!(result & VM_EXEC_RUNNING)) {
194	fmt.green();
195	printf("[Event handler '%s' finished with SUCCESS status]\n", handler->eventHandlerName().c_str());
196	} else if (result & VM_EXEC_RUNNING) {
197	fmt.cyan();
198	printf("[Event handler '%s' finished with RUNNING status]\n", handler->eventHandlerName().c_str());
199	} else {
200	fmt.red();
201	printf("[Event handler '%s' finished with UNKNOWN status]\n", handler->eventHandlerName().c_str());
202	}
203	}
204
205	if (parserContext) delete parserContext;
206	if (execContext) delete execContext;
207	if (vm) delete vm;
208
209	return 0;
210	}
211
212	static void printCodeWithSyntaxHighlighting(ScriptVM* vm) {
213	vector<VMSourceToken> tokens = vm->syntaxHighlighting(&std::cin);
214
215	for (int i = 0; i < tokens.size(); ++i) {
216	const VMSourceToken& token = tokens[i];
217
218	CFmt fmt;
219	if (token.isKeyword()) {
220	fmt.bold();
221	} else if (token.isVariableName()) {
222	fmt.magenta();
223	} else if (token.isIdentifier()) {
224	if (token.isEventHandlerName()) {
225	fmt.bold();
226	fmt.cyan();
227	} else { // a function ...
228	fmt.cyan();
229	}
230	} else if (token.isNumberLiteral()) {
231	fmt.yellow();
232	} else if (token.isStringLiteral()) {
233	fmt.red();
234	} else if (token.isComment()) {
235	fmt.blue();
236	} else if (token.isPreprocessor()) {
237	fmt.green();
238	} else if (token.isNewLine()) {
239	}
240
241	printf("%s", token.text().c_str());
242	fflush(stdout);
243	}
244	}
245
246	static void dumpSyntaxHighlighting(ScriptVM* vm) {
247	vector<VMSourceToken> tokens = vm->syntaxHighlighting(&std::cin);
248
249	for (int i = 0; i < tokens.size(); ++i) {
250	const VMSourceToken& token = tokens[i];
251	const char* type = "OTHER";
252	if (token.isKeyword()) {
253	type = "KEYWORD";
254	} else if (token.isVariableName()) {
255	type = "VARIABLE";
256	} else if (token.isIdentifier()) {
257	if (token.isEventHandlerName()) {
258	type = "HANDLER_NAME";
259	} else { // a function ...
260	type = "FUNCTION";
261	}
262	} else if (token.isNumberLiteral()) {
263	type = "NUMBER";
264	} else if (token.isStringLiteral()) {
265	type = "STRING";
266	} else if (token.isComment()) {
267	type = "COMMENT";
268	} else if (token.isPreprocessor()) {
269	type = "PREPROC";
270	} else if (token.isNewLine()) {
271	type = "NL";
272	}
273	printf("L%d,C%d: %s \"%s\"\n", token.firstLine(), token.firstColumn(), type, token.text().c_str());
274	}
275	}
276
277	static String readTxtFromFile(String path) {
278	std::ifstream f(path.c_str(), std::ifstream::in);
279	String s;
280	s += (char) f.get();
281	while (f.good()) {
282	char c = f.get();
283	if (c == EOF) break;
284	s += c;
285	}
286	f.close();
287	return s;
288	}