scriptvm/editor/nksp.l

/*
 * Copyright (c) 2015-2016 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;
}

%}

/* 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_]*

%%

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

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

{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]*{ID} {
    yy_pop_state(yyscanner);
    yyextra->token = KeywordToken(yytext);
    return yyextra->token.baseType;
}

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