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);

%}

// 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;                                        }
                      |  LOAD_BACKGROUND SP load_instruction        { $$ = $3;                                        }
                      |  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); }
                      ;

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); }
                      ;

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			%}
48
49			// reentrant parser
50			%pure_parser
51
52			%token <Char> CHAR
53			%token <Dotnum> DOTNUM
54			%token <Number> NUMBER
55	senkov	135	%token <String> STRINGVAL
56	schoenebeck	123	%token SP LF CR HASH EQ
57	senkov	135	%token ADD GET CREATE DESTROY LIST LOAD LOAD_BACKGROUND REMOVE SET SUBSCRIBE UNSUBSCRIBE RESET QUIT
58	schoenebeck	35	%token CHANNEL NOTIFICATION
59	schoenebeck	123	%token AVAILABLE_ENGINES AVAILABLE_AUDIO_OUTPUT_DRIVERS CHANNELS INFO BUFFER_FILL STREAM_COUNT VOICE_COUNT
60	schoenebeck	35	%token INSTRUMENT ENGINE
61	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
62	schoenebeck	35	%token BYTES PERCENTAGE
63	senkov	135	%token MISCELLANEOUS
64	schoenebeck	35
65			%type <Dotnum> volume
66	senkov	135	%type <Number> sampler_channel instrument_index audio_output_channel midi_input_channel
67			%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
68	schoenebeck	35	%type <FillResponse> buffer_size_type
69	schoenebeck	123	%type <KeyValList> key_val_list
70	schoenebeck	35
71			%start input
72
73			%%
74
75			//TODO: return more meaningful error messages
76
77			input : line
78			\| input LF line
79			\| input CR LF line
80			;
81
82			line : /* epsilon (empty line ignored) */
83	schoenebeck	111	\| comment
84	schoenebeck	35	\| command { LSCPSERVER->AnswerClient($1); }
85			\| error { LSCPSERVER->AnswerClient("Err:0:Unknown command.\r\n"); RESTART; return LSCP_SYNTAX_ERROR; }
86			;
87
88	schoenebeck	111	comment : HASH
89			\| comment HASH
90			\| comment SP
91			\| comment NUMBER
92			\| comment string
93			;
94
95	schoenebeck	35	command : ADD SP CHANNEL { $$ = LSCPSERVER->AddChannel(); }
96			\| GET SP get_instruction { $$ = $3; }
97	schoenebeck	123	\| CREATE SP create_instruction { $$ = $3; }
98			\| DESTROY SP destroy_instruction { $$ = $3; }
99			\| LIST SP list_instruction { $$ = $3; }
100	schoenebeck	35	\| LOAD SP load_instruction { $$ = $3; }
101	senkov	135	\| LOAD_BACKGROUND SP load_instruction { $$ = $3; }
102	schoenebeck	35	\| REMOVE SP CHANNEL SP sampler_channel { $$ = LSCPSERVER->RemoveChannel($5); }
103	schoenebeck	123	\| SET SP set_instruction { $$ = $3; }
104	senkov	135	\| SUBSCRIBE SP subscribe_event { $$ = $3; }
105			\| UNSUBSCRIBE SP unsubscribe_event { $$ = $3; }
106	schoenebeck	35	\| RESET SP CHANNEL SP sampler_channel { $$ = LSCPSERVER->ResetChannel($5); }
107			\| QUIT { LSCPSERVER->AnswerClient("Bye!\r\n"); return 0; }
108			;
109
110	senkov	135	subscribe_event : CHANNELS { $$ = LSCPSERVER->SubscribeNotification(event_channels); }
111			\| VOICE_COUNT { $$ = LSCPSERVER->SubscribeNotification(event_voice_count); }
112			\| STREAM_COUNT { $$ = LSCPSERVER->SubscribeNotification(event_stream_count); }
113			\| BUFFER_FILL { $$ = LSCPSERVER->SubscribeNotification(event_channel_buffer_fill); }
114			\| INFO { $$ = LSCPSERVER->SubscribeNotification(event_channel_info); }
115			\| MISCELLANEOUS { $$ = LSCPSERVER->SubscribeNotification(event_misc); }
116			;
117
118			unsubscribe_event : CHANNELS { $$ = LSCPSERVER->UnsubscribeNotification(event_channels); }
119			\| VOICE_COUNT { $$ = LSCPSERVER->UnsubscribeNotification(event_voice_count); }
120			\| STREAM_COUNT { $$ = LSCPSERVER->UnsubscribeNotification(event_stream_count); }
121			\| BUFFER_FILL { $$ = LSCPSERVER->UnsubscribeNotification(event_channel_buffer_fill); }
122			\| INFO { $$ = LSCPSERVER->UnsubscribeNotification(event_channel_info); }
123			\| MISCELLANEOUS { $$ = LSCPSERVER->UnsubscribeNotification(event_misc); }
124			;
125
126	schoenebeck	123	get_instruction : AVAILABLE_ENGINES { $$ = LSCPSERVER->GetAvailableEngines(); }
127			\| AVAILABLE_AUDIO_OUTPUT_DRIVERS { $$ = LSCPSERVER->GetAvailableAudioOutputDrivers(); }
128			\| AUDIO_OUTPUT_DRIVER SP INFO SP string { $$ = LSCPSERVER->GetAudioOutputDriverInfo($5); }
129			\| AUDIO_OUTPUT_DRIVER_PARAMETER SP INFO SP string SP string { $$ = LSCPSERVER->GetAudioOutputDriverParameterInfo($5, $7); }
130			\| AUDIO_OUTPUT_DRIVER_PARAMETER SP INFO SP string SP string SP key_val_list { $$ = LSCPSERVER->GetAudioOutputDriverParameterInfo($5, $7, $9); }
131			\| AUDIO_OUTPUT_DEVICES { $$ = LSCPSERVER->GetAudioOutputDeviceCount(); }
132			\| AUDIO_OUTPUT_DEVICE SP INFO SP NUMBER { $$ = LSCPSERVER->GetAudioOutputDeviceInfo($5); }
133			\| AUDIO_OUTPUT_CHANNEL SP INFO SP NUMBER SP NUMBER { $$ = LSCPSERVER->GetAudioOutputChannelInfo($5, $7); }
134			\| AUDIO_OUTPUT_CHANNEL_PARAMETER SP INFO SP NUMBER SP NUMBER SP string { $$ = LSCPSERVER->GetAudioOutputChannelParameterInfo($5, $7, $9); }
135			\| CHANNELS { $$ = LSCPSERVER->GetChannels(); }
136			\| CHANNEL SP INFO SP sampler_channel { $$ = LSCPSERVER->GetChannelInfo($5); }
137			\| CHANNEL SP BUFFER_FILL SP buffer_size_type SP sampler_channel { $$ = LSCPSERVER->GetBufferFill($5, $7); }
138			\| CHANNEL SP STREAM_COUNT SP sampler_channel { $$ = LSCPSERVER->GetStreamCount($5); }
139			\| CHANNEL SP VOICE_COUNT SP sampler_channel { $$ = LSCPSERVER->GetVoiceCount($5); }
140			\| ENGINE SP INFO SP engine_name { $$ = LSCPSERVER->GetEngineInfo($5); }
141	schoenebeck	35	;
142
143	senkov	135	set_instruction : AUDIO_OUTPUT_DEVICE_PARAMETER SP NUMBER SP string EQ param_val { $$ = LSCPSERVER->SetAudioOutputDeviceParameter($3, $5, $7); }
144			\| AUDIO_OUTPUT_CHANNEL_PARAMETER SP NUMBER SP NUMBER SP string EQ param_val { $$ = LSCPSERVER->SetAudioOutputChannelParameter($3, $5, $7, $9); }
145	schoenebeck	123	\| CHANNEL SP set_chan_instruction { $$ = $3; }
146			;
147
148	senkov	135	create_instruction : AUDIO_OUTPUT_DEVICE SP string SP key_val_list { $$ = LSCPSERVER->CreateAudioOutputDevice($3,$5); }
149	schoenebeck	123	;
150
151			destroy_instruction : AUDIO_OUTPUT_DEVICE SP NUMBER { $$ = LSCPSERVER->DestroyAudioOutputDevice($3); }
152			;
153
154	schoenebeck	35	load_instruction : INSTRUMENT SP load_instr_args { $$ = $3; }
155			\| ENGINE SP load_engine_args { $$ = $3; }
156			;
157
158	schoenebeck	123	set_chan_instruction : AUDIO_OUTPUT_DEVICE SP sampler_channel SP NUMBER { $$ = LSCPSERVER->SetAudioOutputDevice($5, $3); }
159			\| AUDIO_OUTPUT_CHANNEL SP sampler_channel SP audio_output_channel SP audio_output_channel { $$ = LSCPSERVER->SetAudioOutputChannel($5, $7, $3); }
160			\| MIDI_INPUT_PORT SP sampler_channel SP midi_input_port { $$ = LSCPSERVER->SetMIDIInputPort($5, $3); }
161			\| MIDI_INPUT_CHANNEL SP sampler_channel SP midi_input_channel { $$ = LSCPSERVER->SetMIDIInputChannel($5, $3); }
162			\| MIDI_INPUT_TYPE SP sampler_channel SP midi_input_type { $$ = LSCPSERVER->SetMIDIInputType($5, $3); }
163			\| VOLUME SP sampler_channel SP volume { $$ = LSCPSERVER->SetVolume($5, $3); }
164	schoenebeck	35	;
165
166	senkov	135	key_val_list : string EQ param_val { $$[$1] = $3; }
167			\| key_val_list SP string EQ param_val { $$ = $1; $$[$3] = $5; }
168			;
169	schoenebeck	123
170	schoenebeck	35	buffer_size_type : BYTES { $$ = fill_response_bytes; }
171			\| PERCENTAGE { $$ = fill_response_percentage; }
172			;
173
174	schoenebeck	123	list_instruction : AUDIO_OUTPUT_DEVICES { $$ = LSCPSERVER->GetAudioOutputDevices(); }
175			;
176
177	schoenebeck	35	load_instr_args : filename SP instrument_index SP sampler_channel { $$ = LSCPSERVER->LoadInstrument($1, $3, $5); }
178			;
179
180			load_engine_args : engine_name SP sampler_channel { $$ = LSCPSERVER->LoadEngine($1, $3); }
181			;
182
183	schoenebeck	123	midi_input_type : string
184	schoenebeck	35	;
185
186			volume : DOTNUM
187			\| NUMBER { $$ = $1; }
188			;
189
190			sampler_channel : NUMBER
191			;
192
193			instrument_index : NUMBER
194			;
195
196			audio_output_channel : NUMBER
197			;
198
199			midi_input_channel : NUMBER
200			;
201
202			engine_name : string
203			;
204
205	senkov	135	midi_input_port : STRINGVAL
206	schoenebeck	35	;
207
208	senkov	135	filename : STRINGVAL
209	schoenebeck	35	;
210
211	senkov	135	param_val : STRINGVAL { $$ = $1; }
212	schoenebeck	35	\| NUMBER { std::stringstream ss; ss << $1; $$ = ss.str(); }
213	senkov	135	\| DOTNUM { std::stringstream ss; ss << $1; $$ = ss.str(); }
214	schoenebeck	35	;
215
216			string : CHAR { std::string s; s = $1; $$ = s; }
217			\| string CHAR { $$ = $1 + $2; }
218			;
219
220			%%
221
222			/**
223			* Will be called when an error occured (usually syntax error).
224			*/
225			void yyerror(const char* s) {
226			dmsg(2,("LSCPParser: %s\n", s));
227			}
228
229			/**
230			* Clears input buffer and restarts scanner.
231			*/
232			void restart(yyparse_param_t* pparam, int& yychar) {
233			// restart scanner
234			yyrestart(stdin, pparam->pScanner);
235			// flush input buffer
236			static char buf[1024];
237			while(recv(hSession, buf, 1024, MSG_DONTWAIT) > 0);
238			// reset lookahead symbol
239			yyclearin;
240			}