scriptvm/editor/nksp.l

/*
 * Copyright (c) 2015-2019 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

// Since this parser is solely used by script code editors, thus not used in a
// real-time context, always throw an exception instead of exiting on fatal
// lexer errors (so the debugger may pause with the appropriate back trace)
#include <stdexcept>
#define YY_FATAL_ERROR(msg) throw std::runtime_error(msg)

%}

/* 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-Z][a-zA-Z0-9_]*
METRIC   (k|h|(da)|d|c|m|u)
UNIT     (s|(Hz)|B)
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;
}

{DIGIT}+({METRIC}{1,2}|({METRIC}{0,2}{UNIT}?)) {
    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	schoenebeck	2885	/*
2	schoenebeck	3561	* Copyright (c) 2015-2019 Christian Schoenebeck
3	schoenebeck	2885	*
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	schoenebeck	3054	// 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	schoenebeck	3332	// Since this parser is solely used by script code editors, thus not used in a
51			// real-time context, always throw an exception instead of exiting on fatal
52	schoenebeck	3308	// lexer errors (so the debugger may pause with the appropriate back trace)
53	schoenebeck	3332	#include <stdexcept>
54			#define YY_FATAL_ERROR(msg) throw std::runtime_error(msg)
55	schoenebeck	3308
56	schoenebeck	2885	%}
57
58			/* generate a reentrant safe scanner */
59			%option reentrant
60			/* avoid symbol collision with ones of other scanners */
61			%option prefix="Nksp_"
62			/* yywrap() would be called at EOF, we don't need it */
63			%option noyywrap
64			/* enable functions yy_push_state(), yy_pop_state(), yy_top_state() */
65			%option stack
66
67			/* inclusive scanner conditions */
68			%s PREPROC_BODY_USE
69			/* exclusive scanner conditions */
70			%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
71
72			DIGIT [0-9]
73	schoenebeck	3561	ID [a-zA-Z][a-zA-Z0-9_]*
74			METRIC (k\|h\|(da)\|d\|c\|m\|u)
75			UNIT (s\|(Hz)\|B)
76	schoenebeck	3308	END_ID on\|while\|if\|select\|function\|synchronized
77	schoenebeck	2885
78			%%
79
80			\"[^"]*\" {
81			yyextra->token = StringLiteralToken(yytext);
82			return yyextra->token.baseType;
83			}
84
85			{DIGIT}+ {
86			yyextra->token = NumberLiteralToken(yytext);
87			return yyextra->token.baseType;
88			}
89
90	schoenebeck	3561	{DIGIT}+({METRIC}{1,2}\|({METRIC}{0,2}{UNIT}?)) {
91			yyextra->token = NumberLiteralToken(yytext);
92			return yyextra->token.baseType;
93			}
94
95	schoenebeck	2935	/* there is currently no support for floating point numbers in NKSP yet */
96			/{DIGIT}+"."{DIGIT} {
97	schoenebeck	2885	yyextra->token = NumberLiteralToken(yytext);
98			return yyextra->token.baseType;
99	schoenebeck	2935	}*/
100	schoenebeck	2885
101
102			/* Preprocessor statement: SET_CONDITION(name) */
103
104			<>"SET_CONDITION"[ \t]"(" {
105			//printf("SET_CONDITION\n");
106			yy_push_state(PREPROC_SET_COND, yyscanner);
107			yyextra->token = PreprocessorToken(yytext);
108			return yyextra->token.baseType;
109			}
110			<PREPROC_SET_COND>{ID} {
111			//printf("preproc set condition '%s'\n", yytext);
112			yyextra->token = PreprocessorToken(yytext);
113			return yyextra->token.baseType;
114			}
115			<PREPROC_SET_COND>[ \t]*")" {
116			//printf("End of PREPROC_SET_COND\n");
117			yy_pop_state(yyscanner);
118			yyextra->token = PreprocessorToken(yytext);
119			return yyextra->token.baseType;
120			}
121
122
123			/* Preprocessor statement: RESET_CONDITION(name) */
124
125			<>"RESET_CONDITION"[ \t]"(" {
126			//printf("RESET_CONDITION\n");
127			yy_push_state(PREPROC_RESET_COND, yyscanner);
128			yyextra->token = PreprocessorToken(yytext);
129			return yyextra->token.baseType;
130			}
131			<PREPROC_RESET_COND>{ID} {
132			//printf("preproc reset condition '%s'\n", yytext);
133			yyextra->token = PreprocessorToken(yytext);
134			return yyextra->token.baseType;
135			}
136			<PREPROC_RESET_COND>[ \t]*")" {
137			//printf("End of RESET_CONDITION\n");
138			yy_pop_state(yyscanner);
139			yyextra->token = PreprocessorToken(yytext);
140			return yyextra->token.baseType;
141			}
142
143
144			/* Preprocessor conditional statements:
145
146			USE_CODE_IF(name)
147			...
148			END_USE_CODE
149
150			and:
151
152			USE_CODE_IF_NOT(name)
153			...
154			END_USE_CODE
155			*/
156
157			<>"USE_CODE_IF"[ \t]"(" {
158			//printf("USE_CODE_IF\n");
159			yy_push_state(PREPROC_IF, yyscanner);
160			yyextra->token = PreprocessorToken(yytext);
161			return yyextra->token.baseType;
162			}
163			<>"USE_CODE_IF_NOT"[ \t]"(" {
164			//printf("USE_CODE_IF_NOT\n");
165			yy_push_state(PREPROC_IF_NOT, yyscanner);
166			yyextra->token = PreprocessorToken(yytext);
167			return yyextra->token.baseType;
168			}
169			<PREPROC_IF>{ID} {
170			//printf("preproc use code if '%s'\n", yytext);
171			yy_pop_state(yyscanner);
172			yy_push_state(PREPROC_PRE_BODY_USE, yyscanner);
173			//yy_push_state(PREPROC_PRE_BODY_EAT, yyscanner);
174			yyextra->token = PreprocessorToken(yytext);
175			return yyextra->token.baseType;
176			}
177			<PREPROC_IF_NOT>{ID} {
178			//printf("preproc use code if not '%s'\n", yytext);
179			yy_pop_state(yyscanner);
180			yy_push_state(PREPROC_PRE_BODY_USE, yyscanner);
181			//yy_push_state(PREPROC_PRE_BODY_EAT, yyscanner);
182			yyextra->token = PreprocessorToken(yytext);
183			return yyextra->token.baseType;
184			}
185			<PREPROC_PRE_BODY_USE>[ \t]*")" {
186			yy_pop_state(yyscanner);
187			yy_push_state(PREPROC_BODY_USE, yyscanner);
188			yyextra->token = PreprocessorToken(yytext);
189			return yyextra->token.baseType;
190			}
191			<PREPROC_PRE_BODY_EAT>[ \t]*")" {
192			//printf("PREPROCESSOR EAT : \n");
193			yy_pop_state(yyscanner);
194			yy_push_state(PREPROC_BODY_EAT, yyscanner);
195			yyextra->token = PreprocessorToken(yytext);
196			return yyextra->token.baseType;
197			}
198			<>."END_USE_CODE" {
199			//printf("-->END_USE_CODE\n");
200			yy_pop_state(yyscanner);
201			yyextra->token = PreprocessorToken(yytext);
202			return yyextra->token.baseType;
203			}
204			<PREPROC_BODY_EAT>[ \t\r\n]* /* eat up code block filtered out by preprocessor */
205			<PREPROC_BODY_EAT>.* /* eat up code block filtered out by preprocessor */
206
207
208			/* Event Handler Names (only if they occur alone in a document!) */
209
210			^\s*(init\|note\|release\|controller) {
211			yyextra->token = EventHandlerNameToken(yytext);
212			return yyextra->token.baseType;
213			}
214
215
216			/* Language keywords */
217
218			on {
219			yy_push_state(PREPROC_EVENT_NAME, yyscanner);
220			yyextra->token = KeywordToken(yytext);
221			return yyextra->token.baseType;
222			}
223
224			<PREPROC_EVENT_NAME>[ \t]*{ID} {
225			yy_pop_state(yyscanner);
226			yyextra->token = EventHandlerNameToken(yytext);
227			return yyextra->token.baseType;
228			}
229
230			end {
231			yy_push_state(PREPROC_END_NAME, yyscanner);
232			yyextra->token = KeywordToken(yytext);
233			return yyextra->token.baseType;
234			}
235
236	schoenebeck	3308	<PREPROC_END_NAME>[ \t]*{END_ID}? {
237	schoenebeck	2885	yy_pop_state(yyscanner);
238			yyextra->token = KeywordToken(yytext);
239			return yyextra->token.baseType;
240			}
241
242	schoenebeck	2935	".or."\|".and."\|".not." {
243			yyextra->token = KeywordToken(yytext);
244			return yyextra->token.baseType;
245			}
246
247	schoenebeck	3260	declare\|while\|if\|or\|and\|not\|else\|case\|select\|to\|mod\|const\|polyphonic\|function\|call\|synchronized {
248	schoenebeck	2885	yyextra->token = KeywordToken(yytext);
249			return yyextra->token.baseType;
250			}
251
252
253			/* Variables */
254
255			"$"{ID} {
256			yyextra->token = IntegerVariableToken(yytext);
257			return yyextra->token.baseType;
258			}
259
260			"@"{ID} {
261			yyextra->token = StringVariableToken(yytext);
262			return yyextra->token.baseType;
263			}
264
265			"%"{ID} {
266			yyextra->token = ArrayVariableToken(yytext);
267			return yyextra->token.baseType;
268			}
269
270			{ID} {
271			yyextra->token = IdentifierToken(yytext);
272			return yyextra->token.baseType;
273			}
274
275
276			/* other */
277
278			<*>\n {
279			yyextra->token = NewLineToken();
280			++yylineno;
281			yycolumn = 0;
282			return yyextra->token.baseType;
283			}
284
285			"{"[^}]*"}" {
286			yyextra->token = CommentToken(yytext);
287			yylineno += countNewLineChars(yytext);
288			return yyextra->token.baseType;
289			}
290
291			<*>\t {
292			yyextra->token = OtherToken(" ");
293			return yyextra->token.baseType;
294			}
295
296			\r+ /* eat up \r */
297
298			<<EOF>> {
299			yyextra->token = EofToken();
300			yyterminate();
301			}
302
303			<*>. {
304			yyextra->token = OtherToken(yytext);
305			return yyextra->token.baseType;
306			}
307
308
309			%%
310
311			namespace LinuxSampler {
312
313			int NkspScanner::processScanner() {
314			return Nksp_lex(scanner);
315			}
316
317			void NkspScanner::createScanner(std::istream* is) {
318			if (scanner) destroyScanner();
319			this->is = is;
320			Nksp_lex_init(&scanner);
321			Nksp_set_extra(this, scanner);
322			}
323
324			void NkspScanner::destroyScanner() {
325			if (!scanner) return;
326			Nksp_lex_destroy(scanner);
327			scanner = NULL;
328			}
329
330			} // namespace LinuxSampler