src/network/lscp.y

/***************************************************************************
 *                                                                         *
 *   LinuxSampler - modular, streaming capable sampler                     *
 *                                                                         *
 *   Copyright (C) 2003 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 SP LF CR
%token ADD GET LOAD REMOVE SET SUBSCRIBE UNSUBSCRIBE RESET QUIT
%token CHANNEL NOTIFICATION
%token AVAILABLE_ENGINES CHANNELS INFO BUFFER_FILL STREAM_COUNT VOICE_COUNT
%token INSTRUMENT ENGINE
%token AUDIO_OUTPUT_CHANNEL AUDIO_OUTPUT_TYPE MIDI_INPUT_PORT MIDI_INPUT_CHANNEL MIDI_INPUT_TYPE VOLUME
%token BYTES PERCENTAGE
%token ALSA JACK

%type <Dotnum> volume
%type <Number> sampler_channel instrument_index udp_port audio_output_channel midi_input_channel midi_input_type
%type <String> string alpha_num_string filename engine_name session_id midi_input_port command get_instruction load_instruction set_chan_instruction load_instr_args load_engine_args
%type <FillResponse> buffer_size_type
%type <AudioOutput> audio_output_type

%start input

%%

//TODO: return more meaningful error messages

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

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

command               :  ADD SP CHANNEL                             { $$ = LSCPSERVER->AddChannel();                  }
                      |  GET SP get_instruction                     { $$ = $3;                                        }
                      |  LOAD SP load_instruction                   { $$ = $3;                                        }
                      |  REMOVE SP CHANNEL SP sampler_channel       { $$ = LSCPSERVER->RemoveChannel($5);             }
                      |  SET SP CHANNEL SP set_chan_instruction     { $$ = $5;                                        }
                      |  SUBSCRIBE SP NOTIFICATION SP udp_port      { $$ = LSCPSERVER->SubscribeNotification($5);     }
                      |  UNSUBSCRIBE SP NOTIFICATION SP session_id  { $$ = LSCPSERVER->UnsubscribeNotification($5);   }
                      |  RESET SP CHANNEL SP sampler_channel        { $$ = LSCPSERVER->ResetChannel($5);              }
                      |  QUIT                                       { LSCPSERVER->AnswerClient("Bye!\r\n"); return 0; }
                      ;

get_instruction       :  AVAILABLE_ENGINES                                              { $$ = LSCPSERVER->GetAvailableEngines(); }
                      |  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);     }
                      ;

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

set_chan_instruction  :  AUDIO_OUTPUT_CHANNEL SP sampler_channel SP audio_output_channel  { $$ = LSCPSERVER->SetAudioOutputChannel($5, $3); }
                      |  AUDIO_OUTPUT_TYPE SP sampler_channel SP audio_output_type        { $$ = LSCPSERVER->SetAudioOutputType($5, $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            { $$ = "Err:0:Not implemented yet\r\n";           }
                      |  VOLUME SP sampler_channel SP volume                              { $$ = LSCPSERVER->SetVolume($5, $3);             }
                      ;

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

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

audio_output_type     :  ALSA  { $$ = audio_output_type_alsa; }
                      |  JACK  { $$ = audio_output_type_jack; }
                      ;

midi_input_type       :  ALSA  { $$ = ALSA; }
                      ;

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

sampler_channel       :  NUMBER
                      ;

instrument_index      :  NUMBER
                      ;

udp_port              :  NUMBER
                      ;

audio_output_channel  :  NUMBER
                      ;

midi_input_channel    :  NUMBER
                      ;

session_id            :  alpha_num_string
                      ;

engine_name           :  string
                      ;

midi_input_port       :  alpha_num_string
                      ;

filename              :  alpha_num_string
                      |  filename SP alpha_num_string  { $$ = $1 + ' ' + $3; }
                      ;

alpha_num_string      :  string                   { $$ = $1;                                             }
                      |  NUMBER                   { std::stringstream ss; ss << $1; $$ = ss.str();       }
                      |  alpha_num_string string  { $$ = $1 + $2;                                        }
                      |  alpha_num_string NUMBER  { std::stringstream ss; ss << $1 << $2; $$ = 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			* Copyright (C) 2003 by Benno Senoner and Christian Schoenebeck *
6			* *
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			%token SP LF CR
56			%token ADD GET LOAD REMOVE SET SUBSCRIBE UNSUBSCRIBE RESET QUIT
57			%token CHANNEL NOTIFICATION
58			%token AVAILABLE_ENGINES CHANNELS INFO BUFFER_FILL STREAM_COUNT VOICE_COUNT
59			%token INSTRUMENT ENGINE
60			%token AUDIO_OUTPUT_CHANNEL AUDIO_OUTPUT_TYPE MIDI_INPUT_PORT MIDI_INPUT_CHANNEL MIDI_INPUT_TYPE VOLUME
61			%token BYTES PERCENTAGE
62			%token ALSA JACK
63
64			%type <Dotnum> volume
65			%type <Number> sampler_channel instrument_index udp_port audio_output_channel midi_input_channel midi_input_type
66			%type <String> string alpha_num_string filename engine_name session_id midi_input_port command get_instruction load_instruction set_chan_instruction load_instr_args load_engine_args
67			%type <FillResponse> buffer_size_type
68			%type <AudioOutput> audio_output_type
69
70			%start input
71
72			%%
73
74			//TODO: return more meaningful error messages
75
76			input : line
77			\| input LF line
78			\| input CR LF line
79			;
80
81			line : /* epsilon (empty line ignored) */
82			\| command { LSCPSERVER->AnswerClient($1); }
83			\| error { LSCPSERVER->AnswerClient("Err:0:Unknown command.\r\n"); RESTART; return LSCP_SYNTAX_ERROR; }
84			;
85
86			command : ADD SP CHANNEL { $$ = LSCPSERVER->AddChannel(); }
87			\| GET SP get_instruction { $$ = $3; }
88			\| LOAD SP load_instruction { $$ = $3; }
89			\| REMOVE SP CHANNEL SP sampler_channel { $$ = LSCPSERVER->RemoveChannel($5); }
90			\| SET SP CHANNEL SP set_chan_instruction { $$ = $5; }
91			\| SUBSCRIBE SP NOTIFICATION SP udp_port { $$ = LSCPSERVER->SubscribeNotification($5); }
92			\| UNSUBSCRIBE SP NOTIFICATION SP session_id { $$ = LSCPSERVER->UnsubscribeNotification($5); }
93			\| RESET SP CHANNEL SP sampler_channel { $$ = LSCPSERVER->ResetChannel($5); }
94			\| QUIT { LSCPSERVER->AnswerClient("Bye!\r\n"); return 0; }
95			;
96
97			get_instruction : AVAILABLE_ENGINES { $$ = LSCPSERVER->GetAvailableEngines(); }
98			\| CHANNELS { $$ = LSCPSERVER->GetChannels(); }
99			\| CHANNEL SP INFO SP sampler_channel { $$ = LSCPSERVER->GetChannelInfo($5); }
100			\| CHANNEL SP BUFFER_FILL SP buffer_size_type SP sampler_channel { $$ = LSCPSERVER->GetBufferFill($5, $7); }
101			\| CHANNEL SP STREAM_COUNT SP sampler_channel { $$ = LSCPSERVER->GetStreamCount($5); }
102			\| CHANNEL SP VOICE_COUNT SP sampler_channel { $$ = LSCPSERVER->GetVoiceCount($5); }
103			\| ENGINE SP INFO SP engine_name { $$ = LSCPSERVER->GetEngineInfo($5); }
104			;
105
106			load_instruction : INSTRUMENT SP load_instr_args { $$ = $3; }
107			\| ENGINE SP load_engine_args { $$ = $3; }
108			;
109
110			set_chan_instruction : AUDIO_OUTPUT_CHANNEL SP sampler_channel SP audio_output_channel { $$ = LSCPSERVER->SetAudioOutputChannel($5, $3); }
111			\| AUDIO_OUTPUT_TYPE SP sampler_channel SP audio_output_type { $$ = LSCPSERVER->SetAudioOutputType($5, $3); }
112			\| MIDI_INPUT_PORT SP sampler_channel SP midi_input_port { $$ = LSCPSERVER->SetMIDIInputPort($5, $3); }
113			\| MIDI_INPUT_CHANNEL SP sampler_channel SP midi_input_channel { $$ = LSCPSERVER->SetMIDIInputChannel($5, $3); }
114			\| MIDI_INPUT_TYPE SP sampler_channel SP midi_input_type { $$ = "Err:0:Not implemented yet\r\n"; }
115			\| VOLUME SP sampler_channel SP volume { $$ = LSCPSERVER->SetVolume($5, $3); }
116			;
117
118			buffer_size_type : BYTES { $$ = fill_response_bytes; }
119			\| PERCENTAGE { $$ = fill_response_percentage; }
120			;
121
122			load_instr_args : filename SP instrument_index SP sampler_channel { $$ = LSCPSERVER->LoadInstrument($1, $3, $5); }
123			;
124
125			load_engine_args : engine_name SP sampler_channel { $$ = LSCPSERVER->LoadEngine($1, $3); }
126			;
127
128			audio_output_type : ALSA { $$ = audio_output_type_alsa; }
129			\| JACK { $$ = audio_output_type_jack; }
130			;
131
132			midi_input_type : ALSA { $$ = ALSA; }
133			;
134
135			volume : DOTNUM
136			\| NUMBER { $$ = $1; }
137			;
138
139			sampler_channel : NUMBER
140			;
141
142			instrument_index : NUMBER
143			;
144
145			udp_port : NUMBER
146			;
147
148			audio_output_channel : NUMBER
149			;
150
151			midi_input_channel : NUMBER
152			;
153
154			session_id : alpha_num_string
155			;
156
157			engine_name : string
158			;
159
160			midi_input_port : alpha_num_string
161			;
162
163			filename : alpha_num_string
164			\| filename SP alpha_num_string { $$ = $1 + ' ' + $3; }
165			;
166
167			alpha_num_string : string { $$ = $1; }
168			\| NUMBER { std::stringstream ss; ss << $1; $$ = ss.str(); }
169			\| alpha_num_string string { $$ = $1 + $2; }
170			\| alpha_num_string NUMBER { std::stringstream ss; ss << $1 << $2; $$ = ss.str(); }
171			;
172
173			string : CHAR { std::string s; s = $1; $$ = s; }
174			\| string CHAR { $$ = $1 + $2; }
175			;
176
177			%%
178
179			/**
180			* Will be called when an error occured (usually syntax error).
181			*/
182			void yyerror(const char* s) {
183			dmsg(2,("LSCPParser: %s\n", s));
184			}
185
186			/**
187			* Clears input buffer and restarts scanner.
188			*/
189			void restart(yyparse_param_t* pparam, int& yychar) {
190			// restart scanner
191			yyrestart(stdin, pparam->pScanner);
192			// flush input buffer
193			static char buf[1024];
194			while(recv(hSession, buf, 1024, MSG_DONTWAIT) > 0);
195			// reset lookahead symbol
196			yyclearin;
197			}