src/network/lscp.y

/***************************************************************************
 *                                                                         *
 *   LinuxSampler - modular, streaming capable sampler                     *
 *                                                                         *
 *   Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck   *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the Free Software           *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 ***************************************************************************/

%{

#include "lscpparser.h"
#include "lscpserver.h"

// as we need an reentrant scanner, we have to pass the pointer to the scanner with each yylex() call
#define YYLEX_PARAM ((yyparse_param_t*) yyparse_param)->pScanner

// to save us typing work in the rules action definitions
#define LSCPSERVER ((yyparse_param_t*) yyparse_param)->pServer

// clears input buffer and restarts scanner.
void restart(yyparse_param_t* pparam, int& yychar);
#define RESTART restart((yyparse_param_t*) YYPARSE_PARAM, yychar)

// external reference to the main scanner function yylex()
extern YY_DECL;

// external reference to restart the lex scanner
extern void yyrestart(FILE* input_file, yyscan_t yyscanner);

// we provide our own version of yyerror() so we don't have to link against the yacc library
void yyerror(const char* s);

bool background;
%}

// reentrant parser
%pure_parser

%token <Char>   CHAR
%token <Dotnum> DOTNUM
%token <Number> NUMBER
%token <String> STRINGVAL
%token SP LF CR HASH EQ
%token ADD GET CREATE DESTROY LIST LOAD LOAD_BACKGROUND REMOVE SET SUBSCRIBE UNSUBSCRIBE RESET QUIT
%token CHANNEL NOTIFICATION
%token AVAILABLE_ENGINES AVAILABLE_AUDIO_OUTPUT_DRIVERS CHANNELS INFO BUFFER_FILL STREAM_COUNT VOICE_COUNT
%token INSTRUMENT ENGINE
%token AUDIO_OUTPUT_CHANNEL AUDIO_OUTPUT_CHANNEL_PARAMETER AUDIO_OUTPUT_DEVICE AUDIO_OUTPUT_DEVICES AUDIO_OUTPUT_DEVICE_PARAMETER AUDIO_OUTPUT_DRIVER AUDIO_OUTPUT_DRIVER_PARAMETER MIDI_INPUT_PORT MIDI_INPUT_CHANNEL MIDI_INPUT_TYPE VOLUME
%token BYTES PERCENTAGE
%token MISCELLANEOUS

%type <Dotnum> volume
%type <Number> sampler_channel instrument_index audio_output_channel midi_input_channel
%type <String> string param_val filename engine_name midi_input_port command create_instruction destroy_instruction get_instruction list_instruction load_instruction set_chan_instruction load_instr_args load_engine_args midi_input_type set_instruction subscribe_event unsubscribe_event
%type <FillResponse> buffer_size_type
%type <KeyValList> key_val_list

%start input

%%

//TODO: return more meaningful error messages

input                 :  line
                      |  input LF line
                      |  input CR LF line
                      ;

line                  :  /* epsilon (empty line ignored) */
                      |  comment
                      |  command  { LSCPSERVER->AnswerClient($1); }
                      |  error    { LSCPSERVER->AnswerClient("Err:0:Unknown command.\r\n"); RESTART; return LSCP_SYNTAX_ERROR; }
                      ;

comment               :  HASH
                      |  comment HASH
                      |  comment SP
                      |  comment NUMBER
                      |  comment string
                      ;

command               :  ADD SP CHANNEL                             { $$ = LSCPSERVER->AddChannel();                  }
                      |  GET SP get_instruction                     { $$ = $3;                                        }
                      |  CREATE SP create_instruction               { $$ = $3;                                        }
                      |  DESTROY SP destroy_instruction             { $$ = $3;                                        }
                      |  LIST SP list_instruction                   { $$ = $3;                                        }
                      |  LOAD SP load_instruction                   { $$ = $3; background = false;                    }
                      |  LOAD_BACKGROUND SP load_instruction        { $$ = $3; background = true;                     }
                      |  REMOVE SP CHANNEL SP sampler_channel       { $$ = LSCPSERVER->RemoveChannel($5);             }
                      |  SET SP set_instruction                     { $$ = $3;                                        }
                      |  SUBSCRIBE SP subscribe_event               { $$ = $3;                                        }
                      |  UNSUBSCRIBE SP unsubscribe_event           { $$ = $3;                                        }
                      |  RESET SP CHANNEL SP sampler_channel        { $$ = LSCPSERVER->ResetChannel($5);              }
                      |  QUIT                                       { LSCPSERVER->AnswerClient("Bye!\r\n"); return 0; }
                      ;

subscribe_event       :  CHANNELS                                   { $$ = LSCPSERVER->SubscribeNotification(event_channels); }
                      |  VOICE_COUNT                                { $$ = LSCPSERVER->SubscribeNotification(event_voice_count); }
                      |  STREAM_COUNT                               { $$ = LSCPSERVER->SubscribeNotification(event_stream_count); }
                      |  BUFFER_FILL                                { $$ = LSCPSERVER->SubscribeNotification(event_channel_buffer_fill); }
                      |  INFO                                       { $$ = LSCPSERVER->SubscribeNotification(event_channel_info); }
                      |  MISCELLANEOUS                              { $$ = LSCPSERVER->SubscribeNotification(event_misc); }
                      ;

unsubscribe_event     :  CHANNELS                                   { $$ = LSCPSERVER->UnsubscribeNotification(event_channels); }
                      |  VOICE_COUNT                                { $$ = LSCPSERVER->UnsubscribeNotification(event_voice_count); }
                      |  STREAM_COUNT                               { $$ = LSCPSERVER->UnsubscribeNotification(event_stream_count); }
                      |  BUFFER_FILL                                { $$ = LSCPSERVER->UnsubscribeNotification(event_channel_buffer_fill); }
                      |  INFO                                       { $$ = LSCPSERVER->UnsubscribeNotification(event_channel_info); }
                      |  MISCELLANEOUS                              { $$ = LSCPSERVER->UnsubscribeNotification(event_misc); }
                      ;

get_instruction       :  AVAILABLE_ENGINES                                                          { $$ = LSCPSERVER->GetAvailableEngines();                          }
                      |  AVAILABLE_AUDIO_OUTPUT_DRIVERS                                             { $$ = LSCPSERVER->GetAvailableAudioOutputDrivers();               }
                      |  AUDIO_OUTPUT_DRIVER SP INFO SP string                                      { $$ = LSCPSERVER->GetAudioOutputDriverInfo($5);                   }
                      |  AUDIO_OUTPUT_DRIVER_PARAMETER SP INFO SP string SP string                  { $$ = LSCPSERVER->GetAudioOutputDriverParameterInfo($5, $7);      }
                      |  AUDIO_OUTPUT_DRIVER_PARAMETER SP INFO SP string SP string SP key_val_list  { $$ = LSCPSERVER->GetAudioOutputDriverParameterInfo($5, $7, $9);  }
                      |  AUDIO_OUTPUT_DEVICES                                                       { $$ = LSCPSERVER->GetAudioOutputDeviceCount();                    }
                      |  AUDIO_OUTPUT_DEVICE SP INFO SP NUMBER                                      { $$ = LSCPSERVER->GetAudioOutputDeviceInfo($5);                   }
                      |  AUDIO_OUTPUT_CHANNEL SP INFO SP NUMBER SP NUMBER                           { $$ = LSCPSERVER->GetAudioOutputChannelInfo($5, $7);              }
                      |  AUDIO_OUTPUT_CHANNEL_PARAMETER SP INFO SP NUMBER SP NUMBER SP string       { $$ = LSCPSERVER->GetAudioOutputChannelParameterInfo($5, $7, $9); }
                      |  CHANNELS                                                                   { $$ = LSCPSERVER->GetChannels();                                  }
                      |  CHANNEL SP INFO SP sampler_channel                                         { $$ = LSCPSERVER->GetChannelInfo($5);                             }
                      |  CHANNEL SP BUFFER_FILL SP buffer_size_type SP sampler_channel              { $$ = LSCPSERVER->GetBufferFill($5, $7);                          }
                      |  CHANNEL SP STREAM_COUNT SP sampler_channel                                 { $$ = LSCPSERVER->GetStreamCount($5);                             }
                      |  CHANNEL SP VOICE_COUNT SP sampler_channel                                  { $$ = LSCPSERVER->GetVoiceCount($5);                              }
                      |  ENGINE SP INFO SP engine_name                                              { $$ = LSCPSERVER->GetEngineInfo($5);                              }
                      ;

set_instruction       :  AUDIO_OUTPUT_DEVICE_PARAMETER SP NUMBER SP string EQ param_val             { $$ = LSCPSERVER->SetAudioOutputDeviceParameter($3, $5, $7);      }
                      |  AUDIO_OUTPUT_CHANNEL_PARAMETER SP NUMBER SP NUMBER SP string EQ param_val  { $$ = LSCPSERVER->SetAudioOutputChannelParameter($3, $5, $7, $9); }
                      |  CHANNEL SP set_chan_instruction                                                   { $$ = $3;                                                         }
                      ;

create_instruction    :  AUDIO_OUTPUT_DEVICE SP string SP key_val_list { $$ = LSCPSERVER->CreateAudioOutputDevice($3,$5); }
                      |  AUDIO_OUTPUT_DEVICE SP string                 { $$ = LSCPSERVER->CreateAudioOutputDevice($3); }
                      ;

destroy_instruction   :  AUDIO_OUTPUT_DEVICE SP NUMBER  { $$ = LSCPSERVER->DestroyAudioOutputDevice($3); }
                      ;

load_instruction      :  INSTRUMENT SP load_instr_args  { $$ = $3; }
                      |  ENGINE SP load_engine_args     { $$ = $3; }
                      ;

set_chan_instruction  :  AUDIO_OUTPUT_DEVICE SP sampler_channel SP NUMBER                                         { $$ = LSCPSERVER->SetAudioOutputDevice($5, $3);      }
                      |  AUDIO_OUTPUT_CHANNEL SP sampler_channel SP audio_output_channel SP audio_output_channel  { $$ = LSCPSERVER->SetAudioOutputChannel($5, $7, $3); }
                      |  MIDI_INPUT_PORT SP sampler_channel SP midi_input_port                                    { $$ = LSCPSERVER->SetMIDIInputPort($5, $3);          }
                      |  MIDI_INPUT_CHANNEL SP sampler_channel SP midi_input_channel                              { $$ = LSCPSERVER->SetMIDIInputChannel($5, $3);       }
                      |  MIDI_INPUT_TYPE SP sampler_channel SP midi_input_type                                    { $$ = LSCPSERVER->SetMIDIInputType($5, $3);          }
                      |  VOLUME SP sampler_channel SP volume                                                      { $$ = LSCPSERVER->SetVolume($5, $3);                 }
                      ;

key_val_list          :  string EQ param_val                  { $$[$1] = $3;          }
                      |  key_val_list SP string EQ param_val  { $$ = $1; $$[$3] = $5; }
                      ;

buffer_size_type      :  BYTES       { $$ = fill_response_bytes;      }
                      |  PERCENTAGE  { $$ = fill_response_percentage; }
                      ;

list_instruction      :  AUDIO_OUTPUT_DEVICES  { $$ = LSCPSERVER->GetAudioOutputDevices(); }
                      ;

load_instr_args       :  filename SP instrument_index SP sampler_channel  { $$ = LSCPSERVER->LoadInstrument($1, $3, $5, background); }
                      ;

load_engine_args      :  engine_name SP sampler_channel  { $$ = LSCPSERVER->LoadEngine($1, $3); }
                      ;

midi_input_type       :  string
                      ;

volume                :  DOTNUM
                      |  NUMBER  { $$ = $1; }
                      ;

sampler_channel       :  NUMBER
                      ;

instrument_index      :  NUMBER
                      ;

audio_output_channel  :  NUMBER
                      ;

midi_input_channel    :  NUMBER
                      ;

engine_name           :  string
                      ;

midi_input_port       :  STRINGVAL
                      ;

filename              :  STRINGVAL
                      ;

param_val             :  STRINGVAL                { $$ = $1;                                             }
                      |  NUMBER                   { std::stringstream ss; ss << $1; $$ = ss.str();       }
                      |  DOTNUM                   { std::stringstream ss; ss << $1; $$ = ss.str();       }
                      ;

string                :  CHAR          { std::string s; s = $1; $$ = s; }
                      |  string CHAR   { $$ = $1 + $2;                  }
                      ;

%%

/**
 * Will be called when an error occured (usually syntax error).
 */
void yyerror(const char* s) {
    dmsg(2,("LSCPParser: %s\n", s));
}

/**
 * Clears input buffer and restarts scanner.
 */
void restart(yyparse_param_t* pparam, int& yychar) {
    // restart scanner
    yyrestart(stdin, pparam->pScanner);
    // flush input buffer
    static char buf[1024];
    while(recv(hSession, buf, 1024, MSG_DONTWAIT) > 0);
    // reset lookahead symbol
    yyclearin;
}
1	schoenebeck	35	/***************************************************************************
2			* *
3			* LinuxSampler - modular, streaming capable sampler *
4			* *
5	schoenebeck	56	* Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck *
6	schoenebeck	35	* *
7			* This program is free software; you can redistribute it and/or modify *
8			* it under the terms of the GNU General Public License as published by *
9			* the Free Software Foundation; either version 2 of the License, or *
10			* (at your option) any later version. *
11			* *
12			* This program is distributed in the hope that it will be useful, *
13			* but WITHOUT ANY WARRANTY; without even the implied warranty of *
14			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
15			* GNU General Public License for more details. *
16			* *
17			* You should have received a copy of the GNU General Public License *
18			* along with this program; if not, write to the Free Software *
19			* Foundation, Inc., 59 Temple Place, Suite 330, Boston, *
20			* MA 02111-1307 USA *
21			***************************************************************************/
22
23			%{
24
25			#include "lscpparser.h"
26			#include "lscpserver.h"
27
28			// as we need an reentrant scanner, we have to pass the pointer to the scanner with each yylex() call
29			#define YYLEX_PARAM ((yyparse_param_t*) yyparse_param)->pScanner
30
31			// to save us typing work in the rules action definitions
32			#define LSCPSERVER ((yyparse_param_t*) yyparse_param)->pServer
33
34			// clears input buffer and restarts scanner.
35			void restart(yyparse_param_t* pparam, int& yychar);
36			#define RESTART restart((yyparse_param_t*) YYPARSE_PARAM, yychar)
37
38			// external reference to the main scanner function yylex()
39			extern YY_DECL;
40
41			// external reference to restart the lex scanner
42			extern void yyrestart(FILE* input_file, yyscan_t yyscanner);
43
44			// we provide our own version of yyerror() so we don't have to link against the yacc library
45			void yyerror(const char* s);
46
47	senkov	138	bool background;
48	schoenebeck	35	%}
49
50			// reentrant parser
51			%pure_parser
52
53			%token <Char> CHAR
54			%token <Dotnum> DOTNUM
55			%token <Number> NUMBER
56	senkov	135	%token <String> STRINGVAL
57	schoenebeck	123	%token SP LF CR HASH EQ
58	senkov	135	%token ADD GET CREATE DESTROY LIST LOAD LOAD_BACKGROUND REMOVE SET SUBSCRIBE UNSUBSCRIBE RESET QUIT
59	schoenebeck	35	%token CHANNEL NOTIFICATION
60	schoenebeck	123	%token AVAILABLE_ENGINES AVAILABLE_AUDIO_OUTPUT_DRIVERS CHANNELS INFO BUFFER_FILL STREAM_COUNT VOICE_COUNT
61	schoenebeck	35	%token INSTRUMENT ENGINE
62	schoenebeck	123	%token AUDIO_OUTPUT_CHANNEL AUDIO_OUTPUT_CHANNEL_PARAMETER AUDIO_OUTPUT_DEVICE AUDIO_OUTPUT_DEVICES AUDIO_OUTPUT_DEVICE_PARAMETER AUDIO_OUTPUT_DRIVER AUDIO_OUTPUT_DRIVER_PARAMETER MIDI_INPUT_PORT MIDI_INPUT_CHANNEL MIDI_INPUT_TYPE VOLUME
63	schoenebeck	35	%token BYTES PERCENTAGE
64	senkov	135	%token MISCELLANEOUS
65	schoenebeck	35
66			%type <Dotnum> volume
67	senkov	135	%type <Number> sampler_channel instrument_index audio_output_channel midi_input_channel
68			%type <String> string param_val filename engine_name midi_input_port command create_instruction destroy_instruction get_instruction list_instruction load_instruction set_chan_instruction load_instr_args load_engine_args midi_input_type set_instruction subscribe_event unsubscribe_event
69	schoenebeck	35	%type <FillResponse> buffer_size_type
70	schoenebeck	123	%type <KeyValList> key_val_list
71	schoenebeck	35
72			%start input
73
74			%%
75
76			//TODO: return more meaningful error messages
77
78			input : line
79			\| input LF line
80			\| input CR LF line
81			;
82
83			line : /* epsilon (empty line ignored) */
84	schoenebeck	111	\| comment
85	schoenebeck	35	\| command { LSCPSERVER->AnswerClient($1); }
86			\| error { LSCPSERVER->AnswerClient("Err:0:Unknown command.\r\n"); RESTART; return LSCP_SYNTAX_ERROR; }
87			;
88
89	schoenebeck	111	comment : HASH
90			\| comment HASH
91			\| comment SP
92			\| comment NUMBER
93			\| comment string
94			;
95
96	schoenebeck	35	command : ADD SP CHANNEL { $$ = LSCPSERVER->AddChannel(); }
97			\| GET SP get_instruction { $$ = $3; }
98	schoenebeck	123	\| CREATE SP create_instruction { $$ = $3; }
99			\| DESTROY SP destroy_instruction { $$ = $3; }
100			\| LIST SP list_instruction { $$ = $3; }
101	senkov	138	\| LOAD SP load_instruction { $$ = $3; background = false; }
102			\| LOAD_BACKGROUND SP load_instruction { $$ = $3; background = true; }
103	schoenebeck	35	\| REMOVE SP CHANNEL SP sampler_channel { $$ = LSCPSERVER->RemoveChannel($5); }
104	schoenebeck	123	\| SET SP set_instruction { $$ = $3; }
105	senkov	135	\| SUBSCRIBE SP subscribe_event { $$ = $3; }
106			\| UNSUBSCRIBE SP unsubscribe_event { $$ = $3; }
107	schoenebeck	35	\| RESET SP CHANNEL SP sampler_channel { $$ = LSCPSERVER->ResetChannel($5); }
108			\| QUIT { LSCPSERVER->AnswerClient("Bye!\r\n"); return 0; }
109			;
110
111	senkov	135	subscribe_event : CHANNELS { $$ = LSCPSERVER->SubscribeNotification(event_channels); }
112			\| VOICE_COUNT { $$ = LSCPSERVER->SubscribeNotification(event_voice_count); }
113			\| STREAM_COUNT { $$ = LSCPSERVER->SubscribeNotification(event_stream_count); }
114			\| BUFFER_FILL { $$ = LSCPSERVER->SubscribeNotification(event_channel_buffer_fill); }
115			\| INFO { $$ = LSCPSERVER->SubscribeNotification(event_channel_info); }
116			\| MISCELLANEOUS { $$ = LSCPSERVER->SubscribeNotification(event_misc); }
117			;
118
119			unsubscribe_event : CHANNELS { $$ = LSCPSERVER->UnsubscribeNotification(event_channels); }
120			\| VOICE_COUNT { $$ = LSCPSERVER->UnsubscribeNotification(event_voice_count); }
121			\| STREAM_COUNT { $$ = LSCPSERVER->UnsubscribeNotification(event_stream_count); }
122			\| BUFFER_FILL { $$ = LSCPSERVER->UnsubscribeNotification(event_channel_buffer_fill); }
123			\| INFO { $$ = LSCPSERVER->UnsubscribeNotification(event_channel_info); }
124			\| MISCELLANEOUS { $$ = LSCPSERVER->UnsubscribeNotification(event_misc); }
125			;
126
127	schoenebeck	123	get_instruction : AVAILABLE_ENGINES { $$ = LSCPSERVER->GetAvailableEngines(); }
128			\| AVAILABLE_AUDIO_OUTPUT_DRIVERS { $$ = LSCPSERVER->GetAvailableAudioOutputDrivers(); }
129			\| AUDIO_OUTPUT_DRIVER SP INFO SP string { $$ = LSCPSERVER->GetAudioOutputDriverInfo($5); }
130			\| AUDIO_OUTPUT_DRIVER_PARAMETER SP INFO SP string SP string { $$ = LSCPSERVER->GetAudioOutputDriverParameterInfo($5, $7); }
131			\| AUDIO_OUTPUT_DRIVER_PARAMETER SP INFO SP string SP string SP key_val_list { $$ = LSCPSERVER->GetAudioOutputDriverParameterInfo($5, $7, $9); }
132			\| AUDIO_OUTPUT_DEVICES { $$ = LSCPSERVER->GetAudioOutputDeviceCount(); }
133			\| AUDIO_OUTPUT_DEVICE SP INFO SP NUMBER { $$ = LSCPSERVER->GetAudioOutputDeviceInfo($5); }
134			\| AUDIO_OUTPUT_CHANNEL SP INFO SP NUMBER SP NUMBER { $$ = LSCPSERVER->GetAudioOutputChannelInfo($5, $7); }
135			\| AUDIO_OUTPUT_CHANNEL_PARAMETER SP INFO SP NUMBER SP NUMBER SP string { $$ = LSCPSERVER->GetAudioOutputChannelParameterInfo($5, $7, $9); }
136			\| CHANNELS { $$ = LSCPSERVER->GetChannels(); }
137			\| CHANNEL SP INFO SP sampler_channel { $$ = LSCPSERVER->GetChannelInfo($5); }
138			\| CHANNEL SP BUFFER_FILL SP buffer_size_type SP sampler_channel { $$ = LSCPSERVER->GetBufferFill($5, $7); }
139			\| CHANNEL SP STREAM_COUNT SP sampler_channel { $$ = LSCPSERVER->GetStreamCount($5); }
140			\| CHANNEL SP VOICE_COUNT SP sampler_channel { $$ = LSCPSERVER->GetVoiceCount($5); }
141			\| ENGINE SP INFO SP engine_name { $$ = LSCPSERVER->GetEngineInfo($5); }
142	schoenebeck	35	;
143
144	senkov	135	set_instruction : AUDIO_OUTPUT_DEVICE_PARAMETER SP NUMBER SP string EQ param_val { $$ = LSCPSERVER->SetAudioOutputDeviceParameter($3, $5, $7); }
145			\| AUDIO_OUTPUT_CHANNEL_PARAMETER SP NUMBER SP NUMBER SP string EQ param_val { $$ = LSCPSERVER->SetAudioOutputChannelParameter($3, $5, $7, $9); }
146	schoenebeck	123	\| CHANNEL SP set_chan_instruction { $$ = $3; }
147			;
148
149	senkov	135	create_instruction : AUDIO_OUTPUT_DEVICE SP string SP key_val_list { $$ = LSCPSERVER->CreateAudioOutputDevice($3,$5); }
150	senkov	138	\| AUDIO_OUTPUT_DEVICE SP string { $$ = LSCPSERVER->CreateAudioOutputDevice($3); }
151	schoenebeck	123	;
152
153			destroy_instruction : AUDIO_OUTPUT_DEVICE SP NUMBER { $$ = LSCPSERVER->DestroyAudioOutputDevice($3); }
154			;
155
156	schoenebeck	35	load_instruction : INSTRUMENT SP load_instr_args { $$ = $3; }
157			\| ENGINE SP load_engine_args { $$ = $3; }
158			;
159
160	schoenebeck	123	set_chan_instruction : AUDIO_OUTPUT_DEVICE SP sampler_channel SP NUMBER { $$ = LSCPSERVER->SetAudioOutputDevice($5, $3); }
161			\| AUDIO_OUTPUT_CHANNEL SP sampler_channel SP audio_output_channel SP audio_output_channel { $$ = LSCPSERVER->SetAudioOutputChannel($5, $7, $3); }
162			\| MIDI_INPUT_PORT SP sampler_channel SP midi_input_port { $$ = LSCPSERVER->SetMIDIInputPort($5, $3); }
163			\| MIDI_INPUT_CHANNEL SP sampler_channel SP midi_input_channel { $$ = LSCPSERVER->SetMIDIInputChannel($5, $3); }
164			\| MIDI_INPUT_TYPE SP sampler_channel SP midi_input_type { $$ = LSCPSERVER->SetMIDIInputType($5, $3); }
165			\| VOLUME SP sampler_channel SP volume { $$ = LSCPSERVER->SetVolume($5, $3); }
166	schoenebeck	35	;
167
168	senkov	135	key_val_list : string EQ param_val { $$[$1] = $3; }
169			\| key_val_list SP string EQ param_val { $$ = $1; $$[$3] = $5; }
170			;
171	schoenebeck	123
172	schoenebeck	35	buffer_size_type : BYTES { $$ = fill_response_bytes; }
173			\| PERCENTAGE { $$ = fill_response_percentage; }
174			;
175
176	schoenebeck	123	list_instruction : AUDIO_OUTPUT_DEVICES { $$ = LSCPSERVER->GetAudioOutputDevices(); }
177			;
178
179	senkov	138	load_instr_args : filename SP instrument_index SP sampler_channel { $$ = LSCPSERVER->LoadInstrument($1, $3, $5, background); }
180	schoenebeck	35	;
181
182			load_engine_args : engine_name SP sampler_channel { $$ = LSCPSERVER->LoadEngine($1, $3); }
183			;
184
185	schoenebeck	123	midi_input_type : string
186	schoenebeck	35	;
187
188			volume : DOTNUM
189			\| NUMBER { $$ = $1; }
190			;
191
192			sampler_channel : NUMBER
193			;
194
195			instrument_index : NUMBER
196			;
197
198			audio_output_channel : NUMBER
199			;
200
201			midi_input_channel : NUMBER
202			;
203
204			engine_name : string
205			;
206
207	senkov	135	midi_input_port : STRINGVAL
208	schoenebeck	35	;
209
210	senkov	135	filename : STRINGVAL
211	schoenebeck	35	;
212
213	senkov	135	param_val : STRINGVAL { $$ = $1; }
214	schoenebeck	35	\| NUMBER { std::stringstream ss; ss << $1; $$ = ss.str(); }
215	senkov	135	\| DOTNUM { std::stringstream ss; ss << $1; $$ = ss.str(); }
216	schoenebeck	35	;
217
218			string : CHAR { std::string s; s = $1; $$ = s; }
219			\| string CHAR { $$ = $1 + $2; }
220			;
221
222			%%
223
224			/**
225			* Will be called when an error occured (usually syntax error).
226			*/
227			void yyerror(const char* s) {
228			dmsg(2,("LSCPParser: %s\n", s));
229			}
230
231			/**
232			* Clears input buffer and restarts scanner.
233			*/
234			void restart(yyparse_param_t* pparam, int& yychar) {
235			// restart scanner
236			yyrestart(stdin, pparam->pScanner);
237			// flush input buffer
238			static char buf[1024];
239			while(recv(hSession, buf, 1024, MSG_DONTWAIT) > 0);
240			// reset lookahead symbol
241			yyclearin;
242			}