scriptvm/editor/nksp.l

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

/* Token scanner used for generating syntax highlighting for NKSP instrument
   script language code (this is not used by the sampler itself, but rather
   provided for external script editor applications). */

%{

#include "NkspScanner.h"
// reentrant scanner data context
#define YY_EXTRA_TYPE NkspScanner*
// custom (f)lex input for reading from std::istream object
#define YY_INPUT(buf,result,max_size)   \
{                                       \
    char c = yyextra->is->get();        \
    if (yyextra->is->eof())             \
        result = YY_NULL;               \
    else {                              \
        buf[0] = c;                     \
        result = 1;                     \
    }                                   \
}
// handle position (line, column) for each recognized token
#define YY_USER_ACTION               \
    yyextra->line   = yylineno - 1;  \
    yyextra->column = yycolumn;      \
    yycolumn += yyleng;

using namespace LinuxSampler;

static int countNewLineChars(const char* txt) {
    int n = 0;
    for (int i = 0; txt[i]; ++i)
        if (txt[i] == '\n') ++n;
    return n;
}

// shut up warning that 'register' keyword is deprecated as of C++11
#if defined(__cplusplus) && __cplusplus >= 201103L
# define register
#endif

// if compiled for debugging, throw an exception instead of exiting on fatal
// lexer errors (so the debugger may pause with the appropriate back trace)
#if DEBUG
# include <stdexcept>
# define YY_FATAL_ERROR(msg) throw std::runtime_error(msg)
#endif

%}

/* generate a reentrant safe scanner */
%option reentrant
/* avoid symbol collision with ones of other scanners */
%option prefix="Nksp_"
/* yywrap() would be called at EOF, we don't need it */
%option noyywrap
/* enable functions yy_push_state(), yy_pop_state(), yy_top_state() */
%option stack

/* inclusive scanner conditions */
%s PREPROC_BODY_USE
/* exclusive scanner conditions */
%x PREPROC_SET_COND PREPROC_RESET_COND PREPROC_IF PREPROC_IF_NOT PREPROC_BODY_EAT PREPROC_PRE_BODY_USE PREPROC_PRE_BODY_EAT PREPROC_EVENT_NAME PREPROC_END_NAME

DIGIT    [0-9]
ID       [a-zA-Z0-9_]+
END_ID   on|while|if|select|function|synchronized

%%

\"[^"]*\" {
    yyextra->token = StringLiteralToken(yytext);
    return yyextra->token.baseType;
}

{DIGIT}+ {
    yyextra->token = NumberLiteralToken(yytext);
    return yyextra->token.baseType;
}

 /* there is currently no support for floating point numbers in NKSP yet */
 /*{DIGIT}+"."{DIGIT}* {
    yyextra->token = NumberLiteralToken(yytext);
    return yyextra->token.baseType;
 }*/


 /* Preprocessor statement:  SET_CONDITION(name) */

<*>"SET_CONDITION"[ \t]*"(" {
    //printf("SET_CONDITION\n");
    yy_push_state(PREPROC_SET_COND, yyscanner);
    yyextra->token = PreprocessorToken(yytext);
    return yyextra->token.baseType;
}
<PREPROC_SET_COND>{ID} {
    //printf("preproc set condition '%s'\n", yytext);
    yyextra->token = PreprocessorToken(yytext);
    return yyextra->token.baseType;
}
<PREPROC_SET_COND>[ \t]*")" {
    //printf("End of PREPROC_SET_COND\n");
    yy_pop_state(yyscanner);
    yyextra->token = PreprocessorToken(yytext);
    return yyextra->token.baseType;
}


 /* Preprocessor statement:  RESET_CONDITION(name) */

<*>"RESET_CONDITION"[ \t]*"(" {
    //printf("RESET_CONDITION\n");
    yy_push_state(PREPROC_RESET_COND, yyscanner);
    yyextra->token = PreprocessorToken(yytext);
    return yyextra->token.baseType;
}
<PREPROC_RESET_COND>{ID} {
    //printf("preproc reset condition '%s'\n", yytext);
    yyextra->token = PreprocessorToken(yytext);
    return yyextra->token.baseType;
}
<PREPROC_RESET_COND>[ \t]*")" {
    //printf("End of RESET_CONDITION\n");
    yy_pop_state(yyscanner);
    yyextra->token = PreprocessorToken(yytext);
    return yyextra->token.baseType;
}


 /* Preprocessor conditional statements:

    USE_CODE_IF(name)
      ...
    END_USE_CODE

    and:

    USE_CODE_IF_NOT(name)
      ...
    END_USE_CODE    
 */

<*>"USE_CODE_IF"[ \t]*"(" {
    //printf("USE_CODE_IF\n");
    yy_push_state(PREPROC_IF, yyscanner);
    yyextra->token = PreprocessorToken(yytext);
    return yyextra->token.baseType;
}
<*>"USE_CODE_IF_NOT"[ \t]*"(" {
    //printf("USE_CODE_IF_NOT\n");
    yy_push_state(PREPROC_IF_NOT, yyscanner);
    yyextra->token = PreprocessorToken(yytext);
    return yyextra->token.baseType;
}
<PREPROC_IF>{ID} {
    //printf("preproc use code if '%s'\n", yytext);
    yy_pop_state(yyscanner);
    yy_push_state(PREPROC_PRE_BODY_USE, yyscanner);
    //yy_push_state(PREPROC_PRE_BODY_EAT, yyscanner);
    yyextra->token = PreprocessorToken(yytext);
    return yyextra->token.baseType;
}
<PREPROC_IF_NOT>{ID} {
    //printf("preproc use code if not '%s'\n", yytext);
    yy_pop_state(yyscanner);
    yy_push_state(PREPROC_PRE_BODY_USE, yyscanner);
    //yy_push_state(PREPROC_PRE_BODY_EAT, yyscanner);
    yyextra->token = PreprocessorToken(yytext);
    return yyextra->token.baseType;
}
<PREPROC_PRE_BODY_USE>[ \t]*")" {
    yy_pop_state(yyscanner);
    yy_push_state(PREPROC_BODY_USE, yyscanner);
    yyextra->token = PreprocessorToken(yytext);
    return yyextra->token.baseType;
}
<PREPROC_PRE_BODY_EAT>[ \t]*")" {
    //printf("PREPROCESSOR EAT : \n");
    yy_pop_state(yyscanner);
    yy_push_state(PREPROC_BODY_EAT, yyscanner);
    yyextra->token = PreprocessorToken(yytext);
    return yyextra->token.baseType;
}
<*>.*"END_USE_CODE" {
    //printf("-->END_USE_CODE\n");
    yy_pop_state(yyscanner);
    yyextra->token = PreprocessorToken(yytext);
    return yyextra->token.baseType;
}
<PREPROC_BODY_EAT>[ \t\r\n]* /* eat up code block filtered out by preprocessor */
<PREPROC_BODY_EAT>.* /* eat up code block filtered out by preprocessor */


 /* Event Handler Names (only if they occur alone in a document!) */
 
^\s*(init|note|release|controller) {
    yyextra->token = EventHandlerNameToken(yytext);
    return yyextra->token.baseType;
}


 /* Language keywords */

on {
    yy_push_state(PREPROC_EVENT_NAME, yyscanner);
    yyextra->token = KeywordToken(yytext);
    return yyextra->token.baseType;
}

<PREPROC_EVENT_NAME>[ \t]*{ID} {
    yy_pop_state(yyscanner);
    yyextra->token = EventHandlerNameToken(yytext);
    return yyextra->token.baseType;
}

end {
    yy_push_state(PREPROC_END_NAME, yyscanner);
    yyextra->token = KeywordToken(yytext);
    return yyextra->token.baseType;
}

<PREPROC_END_NAME>[ \t]*{END_ID}? {
    yy_pop_state(yyscanner);
    yyextra->token = KeywordToken(yytext);
    return yyextra->token.baseType;
}

".or."|".and."|".not." {
    yyextra->token = KeywordToken(yytext);
    return yyextra->token.baseType;
}

declare|while|if|or|and|not|else|case|select|to|mod|const|polyphonic|function|call|synchronized {
    yyextra->token = KeywordToken(yytext);
    return yyextra->token.baseType;
}


 /* Variables */
 
"$"{ID} {
    yyextra->token = IntegerVariableToken(yytext);
    return yyextra->token.baseType;
}

"@"{ID} {
    yyextra->token = StringVariableToken(yytext);
    return yyextra->token.baseType;
}

"%"{ID} {
    yyextra->token = ArrayVariableToken(yytext);
    return yyextra->token.baseType;
}

{ID} {
    yyextra->token = IdentifierToken(yytext);
    return yyextra->token.baseType;
}


 /* other */

<*>\n {
    yyextra->token = NewLineToken();
    ++yylineno;
    yycolumn = 0;
    return yyextra->token.baseType;
}

"{"[^}]*"}" {
    yyextra->token = CommentToken(yytext);
    yylineno += countNewLineChars(yytext);
    return yyextra->token.baseType;
}

<*>\t {
    yyextra->token = OtherToken("    ");
    return yyextra->token.baseType;
}

\r+ /* eat up \r */

<<EOF>> {
    yyextra->token = EofToken();
    yyterminate();
}

<*>. {
    yyextra->token = OtherToken(yytext);
    return yyextra->token.baseType;
}


%%

namespace LinuxSampler {

int NkspScanner::processScanner() {
    return Nksp_lex(scanner);
}

void NkspScanner::createScanner(std::istream* is) {
    if (scanner) destroyScanner();
    this->is = is;
    Nksp_lex_init(&scanner);
    Nksp_set_extra(this, scanner);
}

void NkspScanner::destroyScanner() {
    if (!scanner) return;
    Nksp_lex_destroy(scanner);
    scanner = NULL;
}

} // namespace LinuxSampler
1	/*
2	* Copyright (c) 2015-2017 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	/* Token scanner used for generating syntax highlighting for NKSP instrument
11	script language code (this is not used by the sampler itself, but rather
12	provided for external script editor applications). */
13
14	%{
15
16	#include "NkspScanner.h"
17	// reentrant scanner data context
18	#define YY_EXTRA_TYPE NkspScanner*
19	// custom (f)lex input for reading from std::istream object
20	#define YY_INPUT(buf,result,max_size) \
21	{ \
22	char c = yyextra->is->get(); \
23	if (yyextra->is->eof()) \
24	result = YY_NULL; \
25	else { \
26	buf[0] = c; \
27	result = 1; \
28	} \
29	}
30	// handle position (line, column) for each recognized token
31	#define YY_USER_ACTION \
32	yyextra->line = yylineno - 1; \
33	yyextra->column = yycolumn; \
34	yycolumn += yyleng;
35
36	using namespace LinuxSampler;
37
38	static int countNewLineChars(const char* txt) {
39	int n = 0;
40	for (int i = 0; txt[i]; ++i)
41	if (txt[i] == '\n') ++n;
42	return n;
43	}
44
45	// shut up warning that 'register' keyword is deprecated as of C++11
46	#if defined(__cplusplus) && __cplusplus >= 201103L
47	# define register
48	#endif
49
50	// if compiled for debugging, throw an exception instead of exiting on fatal
51	// lexer errors (so the debugger may pause with the appropriate back trace)
52	#if DEBUG
53	# include <stdexcept>
54	# define YY_FATAL_ERROR(msg) throw std::runtime_error(msg)
55	#endif
56
57	%}
58
59	/* generate a reentrant safe scanner */
60	%option reentrant
61	/* avoid symbol collision with ones of other scanners */
62	%option prefix="Nksp_"
63	/* yywrap() would be called at EOF, we don't need it */
64	%option noyywrap
65	/* enable functions yy_push_state(), yy_pop_state(), yy_top_state() */
66	%option stack
67
68	/* inclusive scanner conditions */
69	%s PREPROC_BODY_USE
70	/* exclusive scanner conditions */
71	%x PREPROC_SET_COND PREPROC_RESET_COND PREPROC_IF PREPROC_IF_NOT PREPROC_BODY_EAT PREPROC_PRE_BODY_USE PREPROC_PRE_BODY_EAT PREPROC_EVENT_NAME PREPROC_END_NAME
72
73	DIGIT [0-9]
74	ID [a-zA-Z0-9_]+
75	END_ID on\|while\|if\|select\|function\|synchronized
76
77	%%
78
79	\"[^"]*\" {
80	yyextra->token = StringLiteralToken(yytext);
81	return yyextra->token.baseType;
82	}
83
84	{DIGIT}+ {
85	yyextra->token = NumberLiteralToken(yytext);
86	return yyextra->token.baseType;
87	}
88
89	/* there is currently no support for floating point numbers in NKSP yet */
90	/{DIGIT}+"."{DIGIT} {
91	yyextra->token = NumberLiteralToken(yytext);
92	return yyextra->token.baseType;
93	}*/
94
95
96	/* Preprocessor statement: SET_CONDITION(name) */
97
98	<>"SET_CONDITION"[ \t]"(" {
99	//printf("SET_CONDITION\n");
100	yy_push_state(PREPROC_SET_COND, yyscanner);
101	yyextra->token = PreprocessorToken(yytext);
102	return yyextra->token.baseType;
103	}
104	<PREPROC_SET_COND>{ID} {
105	//printf("preproc set condition '%s'\n", yytext);
106	yyextra->token = PreprocessorToken(yytext);
107	return yyextra->token.baseType;
108	}
109	<PREPROC_SET_COND>[ \t]*")" {
110	//printf("End of PREPROC_SET_COND\n");
111	yy_pop_state(yyscanner);
112	yyextra->token = PreprocessorToken(yytext);
113	return yyextra->token.baseType;
114	}
115
116
117	/* Preprocessor statement: RESET_CONDITION(name) */
118
119	<>"RESET_CONDITION"[ \t]"(" {
120	//printf("RESET_CONDITION\n");
121	yy_push_state(PREPROC_RESET_COND, yyscanner);
122	yyextra->token = PreprocessorToken(yytext);
123	return yyextra->token.baseType;
124	}
125	<PREPROC_RESET_COND>{ID} {
126	//printf("preproc reset condition '%s'\n", yytext);
127	yyextra->token = PreprocessorToken(yytext);
128	return yyextra->token.baseType;
129	}
130	<PREPROC_RESET_COND>[ \t]*")" {
131	//printf("End of RESET_CONDITION\n");
132	yy_pop_state(yyscanner);
133	yyextra->token = PreprocessorToken(yytext);
134	return yyextra->token.baseType;
135	}
136
137
138	/* Preprocessor conditional statements:
139
140	USE_CODE_IF(name)
141	...
142	END_USE_CODE
143
144	and:
145
146	USE_CODE_IF_NOT(name)
147	...
148	END_USE_CODE
149	*/
150
151	<>"USE_CODE_IF"[ \t]"(" {
152	//printf("USE_CODE_IF\n");
153	yy_push_state(PREPROC_IF, yyscanner);
154	yyextra->token = PreprocessorToken(yytext);
155	return yyextra->token.baseType;
156	}
157	<>"USE_CODE_IF_NOT"[ \t]"(" {
158	//printf("USE_CODE_IF_NOT\n");
159	yy_push_state(PREPROC_IF_NOT, yyscanner);
160	yyextra->token = PreprocessorToken(yytext);
161	return yyextra->token.baseType;
162	}
163	<PREPROC_IF>{ID} {
164	//printf("preproc use code if '%s'\n", yytext);
165	yy_pop_state(yyscanner);
166	yy_push_state(PREPROC_PRE_BODY_USE, yyscanner);
167	//yy_push_state(PREPROC_PRE_BODY_EAT, yyscanner);
168	yyextra->token = PreprocessorToken(yytext);
169	return yyextra->token.baseType;
170	}
171	<PREPROC_IF_NOT>{ID} {
172	//printf("preproc use code if not '%s'\n", yytext);
173	yy_pop_state(yyscanner);
174	yy_push_state(PREPROC_PRE_BODY_USE, yyscanner);
175	//yy_push_state(PREPROC_PRE_BODY_EAT, yyscanner);
176	yyextra->token = PreprocessorToken(yytext);
177	return yyextra->token.baseType;
178	}
179	<PREPROC_PRE_BODY_USE>[ \t]*")" {
180	yy_pop_state(yyscanner);
181	yy_push_state(PREPROC_BODY_USE, yyscanner);
182	yyextra->token = PreprocessorToken(yytext);
183	return yyextra->token.baseType;
184	}
185	<PREPROC_PRE_BODY_EAT>[ \t]*")" {
186	//printf("PREPROCESSOR EAT : \n");
187	yy_pop_state(yyscanner);
188	yy_push_state(PREPROC_BODY_EAT, yyscanner);
189	yyextra->token = PreprocessorToken(yytext);
190	return yyextra->token.baseType;
191	}
192	<>."END_USE_CODE" {
193	//printf("-->END_USE_CODE\n");
194	yy_pop_state(yyscanner);
195	yyextra->token = PreprocessorToken(yytext);
196	return yyextra->token.baseType;
197	}
198	<PREPROC_BODY_EAT>[ \t\r\n]* /* eat up code block filtered out by preprocessor */
199	<PREPROC_BODY_EAT>.* /* eat up code block filtered out by preprocessor */
200
201
202	/* Event Handler Names (only if they occur alone in a document!) */
203
204	^\s*(init\|note\|release\|controller) {
205	yyextra->token = EventHandlerNameToken(yytext);
206	return yyextra->token.baseType;
207	}
208
209
210	/* Language keywords */
211
212	on {
213	yy_push_state(PREPROC_EVENT_NAME, yyscanner);
214	yyextra->token = KeywordToken(yytext);
215	return yyextra->token.baseType;
216	}
217
218	<PREPROC_EVENT_NAME>[ \t]*{ID} {
219	yy_pop_state(yyscanner);
220	yyextra->token = EventHandlerNameToken(yytext);
221	return yyextra->token.baseType;
222	}
223
224	end {
225	yy_push_state(PREPROC_END_NAME, yyscanner);
226	yyextra->token = KeywordToken(yytext);
227	return yyextra->token.baseType;
228	}
229
230	<PREPROC_END_NAME>[ \t]*{END_ID}? {
231	yy_pop_state(yyscanner);
232	yyextra->token = KeywordToken(yytext);
233	return yyextra->token.baseType;
234	}
235
236	".or."\|".and."\|".not." {
237	yyextra->token = KeywordToken(yytext);
238	return yyextra->token.baseType;
239	}
240
241	declare\|while\|if\|or\|and\|not\|else\|case\|select\|to\|mod\|const\|polyphonic\|function\|call\|synchronized {
242	yyextra->token = KeywordToken(yytext);
243	return yyextra->token.baseType;
244	}
245
246
247	/* Variables */
248
249	"$"{ID} {
250	yyextra->token = IntegerVariableToken(yytext);
251	return yyextra->token.baseType;
252	}
253
254	"@"{ID} {
255	yyextra->token = StringVariableToken(yytext);
256	return yyextra->token.baseType;
257	}
258
259	"%"{ID} {
260	yyextra->token = ArrayVariableToken(yytext);
261	return yyextra->token.baseType;
262	}
263
264	{ID} {
265	yyextra->token = IdentifierToken(yytext);
266	return yyextra->token.baseType;
267	}
268
269
270	/* other */
271
272	<*>\n {
273	yyextra->token = NewLineToken();
274	++yylineno;
275	yycolumn = 0;
276	return yyextra->token.baseType;
277	}
278
279	"{"[^}]*"}" {
280	yyextra->token = CommentToken(yytext);
281	yylineno += countNewLineChars(yytext);
282	return yyextra->token.baseType;
283	}
284
285	<*>\t {
286	yyextra->token = OtherToken(" ");
287	return yyextra->token.baseType;
288	}
289
290	\r+ /* eat up \r */
291
292	<<EOF>> {
293	yyextra->token = EofToken();
294	yyterminate();
295	}
296
297	<*>. {
298	yyextra->token = OtherToken(yytext);
299	return yyextra->token.baseType;
300	}
301
302
303	%%
304
305	namespace LinuxSampler {
306
307	int NkspScanner::processScanner() {
308	return Nksp_lex(scanner);
309	}
310
311	void NkspScanner::createScanner(std::istream* is) {
312	if (scanner) destroyScanner();
313	this->is = is;
314	Nksp_lex_init(&scanner);
315	Nksp_set_extra(this, scanner);
316	}
317
318	void NkspScanner::destroyScanner() {
319	if (!scanner) return;
320	Nksp_lex_destroy(scanner);
321	scanner = NULL;
322	}
323
324	} // namespace LinuxSampler