/[svn]/linuxsampler/trunk/src/network/lscpscanner.cpp
ViewVC logotype

Contents of /linuxsampler/trunk/src/network/lscpscanner.cpp

Parent Directory Parent Directory | Revision Log Revision Log

Revision 123 - (show annotations) (download)
Mon Jun 14 19:33:16 2004 UTC (19 years, 10 months ago) by schoenebeck
File size: 77875 byte(s) 
* src/common: added template class 'optional<>' which can be used e.g. as
  return type whenever a value might be returned, but don't has to; this
  template class pretty much acts like a pointer of the given type, but is
  much more safer than a simple pointer
* src/audiodriver: added static class AudioDeviceFactory to create audio
  devices at runtime by using a string and to obtain driver informations
  of drivers at runtime, driver classes should simply use the macro
  REGISTER_AUDIO_OUTPUT_DRIVER(DriverName,DriverClass) in their cpp file
  to register the driver to LinuxSampler (no changes needed anymore in the
  LS code to add a new audio output driver)
* src/drivers: added classes to dynamically manage driver parameters; there
  are two different kinds of parameters: parameters which are need to
  create a new device (DeviceCreationParameterX) used to e.g. create an
  audio output device or a MIDI input device and parameters which are only
  available at runtime, means when a device is already created
  (DeviceRuntimeParameterX) which will be e.g. used as audio channel
  parameters and MIDI port parameters
* src/linuxsampler.cpp: all registered audio output drivers will be shown
  on the console on startup
* src/network: implemented configuration of audio output devices via LSCP
1
2 #line 3 "lex.yy.c"
3
4 #define YY_INT_ALIGNED short int
5
6 /* A lexical scanner generated by flex */
7
8 #define FLEX_SCANNER
9 #define YY_FLEX_MAJOR_VERSION 2
10 #define YY_FLEX_MINOR_VERSION 5
11 #define YY_FLEX_SUBMINOR_VERSION 31
12 #if YY_FLEX_SUBMINOR_VERSION > 0
13 #define FLEX_BETA
14 #endif
15
16 /* First, we deal with platform-specific or compiler-specific issues. */
17
18 /* begin standard C headers. */
19 #include <stdio.h>
20 #include <string.h>
21 #include <errno.h>
22 #include <stdlib.h>
23
24 /* end standard C headers. */
25
26 /* flex integer type definitions */
27
28 #ifndef FLEXINT_H
29 #define FLEXINT_H
30
31 /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
32
33 #if defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L
34 #include <inttypes.h>
35 typedef int8_t flex_int8_t;
36 typedef uint8_t flex_uint8_t;
37 typedef int16_t flex_int16_t;
38 typedef uint16_t flex_uint16_t;
39 typedef int32_t flex_int32_t;
40 typedef uint32_t flex_uint32_t;
41 #else
42 typedef signed char flex_int8_t;
43 typedef short int flex_int16_t;
44 typedef int flex_int32_t;
45 typedef unsigned char flex_uint8_t;
46 typedef unsigned short int flex_uint16_t;
47 typedef unsigned int flex_uint32_t;
48 #endif /* ! C99 */
49
50 /* Limits of integral types. */
51 #ifndef INT8_MIN
52 #define INT8_MIN (-128)
53 #endif
54 #ifndef INT16_MIN
55 #define INT16_MIN (-32767-1)
56 #endif
57 #ifndef INT32_MIN
58 #define INT32_MIN (-2147483647-1)
59 #endif
60 #ifndef INT8_MAX
61 #define INT8_MAX (127)
62 #endif
63 #ifndef INT16_MAX
64 #define INT16_MAX (32767)
65 #endif
66 #ifndef INT32_MAX
67 #define INT32_MAX (2147483647)
68 #endif
69 #ifndef UINT8_MAX
70 #define UINT8_MAX (255U)
71 #endif
72 #ifndef UINT16_MAX
73 #define UINT16_MAX (65535U)
74 #endif
75 #ifndef UINT32_MAX
76 #define UINT32_MAX (4294967295U)
77 #endif
78
79 #endif /* ! FLEXINT_H */
80
81 #ifdef __cplusplus
82
83 /* The "const" storage-class-modifier is valid. */
84 #define YY_USE_CONST
85
86 #else /* ! __cplusplus */
87
88 #if __STDC__
89
90 #define YY_USE_CONST
91
92 #endif /* __STDC__ */
93 #endif /* ! __cplusplus */
94
95 #ifdef YY_USE_CONST
96 #define yyconst const
97 #else
98 #define yyconst
99 #endif
100
101 /* Returned upon end-of-file. */
102 #define YY_NULL 0
103
104 /* Promotes a possibly negative, possibly signed char to an unsigned
105 * integer for use as an array index. If the signed char is negative,
106 * we want to instead treat it as an 8-bit unsigned char, hence the
107 * double cast.
108 */
109 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
110
111 /* An opaque pointer. */
112 #ifndef YY_TYPEDEF_YY_SCANNER_T
113 #define YY_TYPEDEF_YY_SCANNER_T
114 typedef void* yyscan_t;
115 #endif
116
117 /* For convenience, these vars (plus the bison vars far below)
118 are macros in the reentrant scanner. */
119 #define yyin yyg->yyin_r
120 #define yyout yyg->yyout_r
121 #define yyextra yyg->yyextra_r
122 #define yyleng yyg->yyleng_r
123 #define yytext yyg->yytext_r
124 #define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
125 #define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
126 #define yy_flex_debug yyg->yy_flex_debug_r
127
128 int yylex_init (yyscan_t* scanner);
129
130 /* Enter a start condition. This macro really ought to take a parameter,
131 * but we do it the disgusting crufty way forced on us by the ()-less
132 * definition of BEGIN.
133 */
134 #define BEGIN yyg->yy_start = 1 + 2 *
135
136 /* Translate the current start state into a value that can be later handed
137 * to BEGIN to return to the state. The YYSTATE alias is for lex
138 * compatibility.
139 */
140 #define YY_START ((yyg->yy_start - 1) / 2)
141 #define YYSTATE YY_START
142
143 /* Action number for EOF rule of a given start state. */
144 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
145
146 /* Special action meaning "start processing a new file". */
147 #define YY_NEW_FILE yyrestart(yyin ,yyscanner )
148
149 #define YY_END_OF_BUFFER_CHAR 0
150
151 /* Size of default input buffer. */
152 #ifndef YY_BUF_SIZE
153 #define YY_BUF_SIZE 16384
154 #endif
155
156 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
157 #define YY_TYPEDEF_YY_BUFFER_STATE
158 typedef struct yy_buffer_state *YY_BUFFER_STATE;
159 #endif
160
161 #define EOB_ACT_CONTINUE_SCAN 0
162 #define EOB_ACT_END_OF_FILE 1
163 #define EOB_ACT_LAST_MATCH 2
164
165 #define YY_LESS_LINENO(n)
166
167 /* Return all but the first "n" matched characters back to the input stream. */
168 #define yyless(n) \
169 do \
170 { \
171 /* Undo effects of setting up yytext. */ \
172 int yyless_macro_arg = (n); \
173 YY_LESS_LINENO(yyless_macro_arg);\
174 *yy_cp = yyg->yy_hold_char; \
175 YY_RESTORE_YY_MORE_OFFSET \
176 yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
177 YY_DO_BEFORE_ACTION; /* set up yytext again */ \
178 } \
179 while ( 0 )
180
181 #define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner )
182
183 /* The following is because we cannot portably get our hands on size_t
184 * (without autoconf's help, which isn't available because we want
185 * flex-generated scanners to compile on their own).
186 */
187
188 #ifndef YY_TYPEDEF_YY_SIZE_T
189 #define YY_TYPEDEF_YY_SIZE_T
190 typedef unsigned int yy_size_t;
191 #endif
192
193 #ifndef YY_STRUCT_YY_BUFFER_STATE
194 #define YY_STRUCT_YY_BUFFER_STATE
195 struct yy_buffer_state
196 {
197 FILE *yy_input_file;
198
199 char *yy_ch_buf; /* input buffer */
200 char *yy_buf_pos; /* current position in input buffer */
201
202 /* Size of input buffer in bytes, not including room for EOB
203 * characters.
204 */
205 yy_size_t yy_buf_size;
206
207 /* Number of characters read into yy_ch_buf, not including EOB
208 * characters.
209 */
210 int yy_n_chars;
211
212 /* Whether we "own" the buffer - i.e., we know we created it,
213 * and can realloc() it to grow it, and should free() it to
214 * delete it.
215 */
216 int yy_is_our_buffer;
217
218 /* Whether this is an "interactive" input source; if so, and
219 * if we're using stdio for input, then we want to use getc()
220 * instead of fread(), to make sure we stop fetching input after
221 * each newline.
222 */
223 int yy_is_interactive;
224
225 /* Whether we're considered to be at the beginning of a line.
226 * If so, '^' rules will be active on the next match, otherwise
227 * not.
228 */
229 int yy_at_bol;
230
231 int yy_bs_lineno; /**< The line count. */
232 int yy_bs_column; /**< The column count. */
233
234 /* Whether to try to fill the input buffer when we reach the
235 * end of it.
236 */
237 int yy_fill_buffer;
238
239 int yy_buffer_status;
240
241 #define YY_BUFFER_NEW 0
242 #define YY_BUFFER_NORMAL 1
243 /* When an EOF's been seen but there's still some text to process
244 * then we mark the buffer as YY_EOF_PENDING, to indicate that we
245 * shouldn't try reading from the input source any more. We might
246 * still have a bunch of tokens to match, though, because of
247 * possible backing-up.
248 *
249 * When we actually see the EOF, we change the status to "new"
250 * (via yyrestart()), so that the user can continue scanning by
251 * just pointing yyin at a new input file.
252 */
253 #define YY_BUFFER_EOF_PENDING 2
254
255 };
256 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
257
258 /* We provide macros for accessing buffer states in case in the
259 * future we want to put the buffer states in a more general
260 * "scanner state".
261 *
262 * Returns the top of the stack, or NULL.
263 */
264 #define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
265 ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
266 : NULL)
267
268 /* Same as previous macro, but useful when we know that the buffer stack is not
269 * NULL or when we need an lvalue. For internal use only.
270 */
271 #define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
272
273 void yyrestart (FILE *input_file ,yyscan_t yyscanner );
274 void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
275 YY_BUFFER_STATE yy_create_buffer (FILE *file,int size ,yyscan_t yyscanner );
276 void yy_delete_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
277 void yy_flush_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
278 void yypush_buffer_state (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
279 void yypop_buffer_state (yyscan_t yyscanner );
280
281 static void yyensure_buffer_stack (yyscan_t yyscanner );
282 static void yy_load_buffer_state (yyscan_t yyscanner );
283 static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file ,yyscan_t yyscanner );
284
285 #define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER ,yyscanner)
286
287 YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size ,yyscan_t yyscanner );
288 YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str ,yyscan_t yyscanner );
289 YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,int len ,yyscan_t yyscanner );
290
291 void *yyalloc (yy_size_t ,yyscan_t yyscanner );
292 void *yyrealloc (void *,yy_size_t ,yyscan_t yyscanner );
293 void yyfree (void * ,yyscan_t yyscanner );
294
295 #define yy_new_buffer yy_create_buffer
296
297 #define yy_set_interactive(is_interactive) \
298 { \
299 if ( ! YY_CURRENT_BUFFER ){ \
300 yyensure_buffer_stack (yyscanner); \
301 YY_CURRENT_BUFFER_LVALUE = \
302 yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \
303 } \
304 YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
305 }
306
307 #define yy_set_bol(at_bol) \
308 { \
309 if ( ! YY_CURRENT_BUFFER ){\
310 yyensure_buffer_stack (yyscanner); \
311 YY_CURRENT_BUFFER_LVALUE = \
312 yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \
313 } \
314 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
315 }
316
317 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
318
319 /* Begin user sect3 */
320
321 typedef unsigned char YY_CHAR;
322
323 typedef yyconst struct yy_trans_info *yy_state_type;
324
325 #define yytext_ptr yytext_r
326
327 static yy_state_type yy_get_previous_state (yyscan_t yyscanner );
328 static yy_state_type yy_try_NUL_trans (yy_state_type current_state ,yyscan_t yyscanner);
329 static int yy_get_next_buffer (yyscan_t yyscanner );
330 static void yy_fatal_error (yyconst char msg[] ,yyscan_t yyscanner );
331
332 /* Done after the current pattern has been matched and before the
333 * corresponding action - sets up yytext.
334 */
335 #define YY_DO_BEFORE_ACTION \
336 yyg->yytext_ptr = yy_bp; \
337 yyleng = (size_t) (yy_cp - yy_bp); \
338 yyg->yy_hold_char = *yy_cp; \
339 *yy_cp = '\0'; \
340 yyg->yy_c_buf_p = yy_cp;
341
342 #define YY_NUM_RULES 45
343 #define YY_END_OF_BUFFER 46
344 struct yy_trans_info
345 {
346 flex_int16_t yy_verify;
347 flex_int16_t yy_nxt;
348 };
349 static yyconst struct yy_trans_info yy_transition[2068] =
350 {
351 { 0, 0 }, { 0,1812 }, { 0, 0 }, { 0,1810 }, { 1, 516 },
352 { 2, 516 }, { 3, 516 }, { 4, 516 }, { 5, 516 }, { 6, 516 },
353 { 7, 516 }, { 8, 516 }, { 9, 516 }, { 10, 518 }, { 11, 516 },
354 { 12, 516 }, { 13, 520 }, { 14, 516 }, { 15, 516 }, { 16, 516 },
355 { 17, 516 }, { 18, 516 }, { 19, 516 }, { 20, 516 }, { 21, 516 },
356 { 22, 516 }, { 23, 516 }, { 24, 516 }, { 25, 516 }, { 26, 516 },
357 { 27, 516 }, { 28, 516 }, { 29, 516 }, { 30, 516 }, { 31, 516 },
358 { 32, 522 }, { 33, 516 }, { 34, 516 }, { 35, 524 }, { 36, 516 },
359 { 37, 516 }, { 38, 516 }, { 39, 516 }, { 40, 516 }, { 41, 516 },
360 { 42, 516 }, { 43, 526 }, { 44, 516 }, { 45, 526 }, { 46, 516 },
361
362 { 47, 516 }, { 48, 538 }, { 49, 550 }, { 50, 550 }, { 51, 550 },
363 { 52, 550 }, { 53, 550 }, { 54, 550 }, { 55, 550 }, { 56, 550 },
364 { 57, 550 }, { 58, 516 }, { 59, 516 }, { 60, 516 }, { 61, 528 },
365 { 62, 516 }, { 63, 516 }, { 64, 516 }, { 65, 540 }, { 66, 542 },
366 { 67, 546 }, { 68, 548 }, { 69, 552 }, { 70, 516 }, { 71, 554 },
367 { 72, 516 }, { 73, 556 }, { 74, 516 }, { 75, 516 }, { 76, 559 },
368 { 77, 562 }, { 78, 564 }, { 79, 516 }, { 80, 567 }, { 81, 569 },
369 { 82, 571 }, { 83, 573 }, { 84, 516 }, { 85, 610 }, { 86, 612 },
370 { 87, 516 }, { 88, 516 }, { 89, 516 }, { 90, 516 }, { 91, 516 },
371 { 92, 516 }, { 93, 516 }, { 94, 516 }, { 95, 516 }, { 96, 516 },
372
373 { 97, 516 }, { 98, 516 }, { 99, 516 }, { 100, 516 }, { 101, 516 },
374 { 102, 516 }, { 103, 516 }, { 104, 516 }, { 105, 516 }, { 106, 516 },
375 { 107, 516 }, { 108, 516 }, { 109, 516 }, { 110, 516 }, { 111, 516 },
376 { 112, 516 }, { 113, 516 }, { 114, 516 }, { 115, 516 }, { 116, 516 },
377 { 117, 516 }, { 118, 516 }, { 119, 516 }, { 120, 516 }, { 121, 516 },
378 { 122, 516 }, { 123, 516 }, { 124, 516 }, { 125, 516 }, { 126, 516 },
379 { 127, 516 }, { 128, 516 }, { 129, 516 }, { 130, 516 }, { 131, 516 },
380 { 132, 516 }, { 133, 516 }, { 134, 516 }, { 135, 516 }, { 136, 516 },
381 { 137, 516 }, { 138, 516 }, { 139, 516 }, { 140, 516 }, { 141, 516 },
382 { 142, 516 }, { 143, 516 }, { 144, 516 }, { 145, 516 }, { 146, 516 },
383
384 { 147, 516 }, { 148, 516 }, { 149, 516 }, { 150, 516 }, { 151, 516 },
385 { 152, 516 }, { 153, 516 }, { 154, 516 }, { 155, 516 }, { 156, 516 },
386 { 157, 516 }, { 158, 516 }, { 159, 516 }, { 160, 516 }, { 161, 516 },
387 { 162, 516 }, { 163, 516 }, { 164, 516 }, { 165, 516 }, { 166, 516 },
388 { 167, 516 }, { 168, 516 }, { 169, 516 }, { 170, 516 }, { 171, 516 },
389 { 172, 516 }, { 173, 516 }, { 174, 516 }, { 175, 516 }, { 176, 516 },
390 { 177, 516 }, { 178, 516 }, { 179, 516 }, { 180, 516 }, { 181, 516 },
391 { 182, 516 }, { 183, 516 }, { 184, 516 }, { 185, 516 }, { 186, 516 },
392 { 187, 516 }, { 188, 516 }, { 189, 516 }, { 190, 516 }, { 191, 516 },
393 { 192, 516 }, { 193, 516 }, { 194, 516 }, { 195, 516 }, { 196, 516 },
394
395 { 197, 516 }, { 198, 516 }, { 199, 516 }, { 200, 516 }, { 201, 516 },
396 { 202, 516 }, { 203, 516 }, { 204, 516 }, { 205, 516 }, { 206, 516 },
397 { 207, 516 }, { 208, 516 }, { 209, 516 }, { 210, 516 }, { 211, 516 },
398 { 212, 516 }, { 213, 516 }, { 214, 516 }, { 215, 516 }, { 216, 516 },
399 { 217, 516 }, { 218, 516 }, { 219, 516 }, { 220, 516 }, { 221, 516 },
400 { 222, 516 }, { 223, 516 }, { 224, 516 }, { 225, 516 }, { 226, 516 },
401 { 227, 516 }, { 228, 516 }, { 229, 516 }, { 230, 516 }, { 231, 516 },
402 { 232, 516 }, { 233, 516 }, { 234, 516 }, { 235, 516 }, { 236, 516 },
403 { 237, 516 }, { 238, 516 }, { 239, 516 }, { 240, 516 }, { 241, 516 },
404 { 242, 516 }, { 243, 516 }, { 244, 516 }, { 245, 516 }, { 246, 516 },
405
406 { 247, 516 }, { 248, 516 }, { 249, 516 }, { 250, 516 }, { 251, 516 },
407 { 252, 516 }, { 253, 516 }, { 254, 516 }, { 255, 516 }, { 256, 516 },
408 { 0, 0 }, { 0,1552 }, { 1, 258 }, { 2, 258 }, { 3, 258 },
409 { 4, 258 }, { 5, 258 }, { 6, 258 }, { 7, 258 }, { 8, 258 },
410 { 9, 258 }, { 10, 260 }, { 11, 258 }, { 12, 258 }, { 13, 262 },
411 { 14, 258 }, { 15, 258 }, { 16, 258 }, { 17, 258 }, { 18, 258 },
412 { 19, 258 }, { 20, 258 }, { 21, 258 }, { 22, 258 }, { 23, 258 },
413 { 24, 258 }, { 25, 258 }, { 26, 258 }, { 27, 258 }, { 28, 258 },
414 { 29, 258 }, { 30, 258 }, { 31, 258 }, { 32, 264 }, { 33, 258 },
415 { 34, 258 }, { 35, 266 }, { 36, 258 }, { 37, 258 }, { 38, 258 },
416
417 { 39, 258 }, { 40, 258 }, { 41, 258 }, { 42, 258 }, { 43, 268 },
418 { 44, 258 }, { 45, 268 }, { 46, 258 }, { 47, 258 }, { 48, 280 },
419 { 49, 292 }, { 50, 292 }, { 51, 292 }, { 52, 292 }, { 53, 292 },
420 { 54, 292 }, { 55, 292 }, { 56, 292 }, { 57, 292 }, { 58, 258 },
421 { 59, 258 }, { 60, 258 }, { 61, 270 }, { 62, 258 }, { 63, 258 },
422 { 64, 258 }, { 65, 282 }, { 66, 284 }, { 67, 288 }, { 68, 290 },
423 { 69, 294 }, { 70, 258 }, { 71, 296 }, { 72, 258 }, { 73, 298 },
424 { 74, 258 }, { 75, 258 }, { 76, 301 }, { 77, 304 }, { 78, 306 },
425 { 79, 258 }, { 80, 309 }, { 81, 311 }, { 82, 313 }, { 83, 315 },
426 { 84, 258 }, { 85, 352 }, { 86, 354 }, { 87, 258 }, { 88, 258 },
427
428 { 89, 258 }, { 90, 258 }, { 91, 258 }, { 92, 258 }, { 93, 258 },
429 { 94, 258 }, { 95, 258 }, { 96, 258 }, { 97, 258 }, { 98, 258 },
430 { 99, 258 }, { 100, 258 }, { 101, 258 }, { 102, 258 }, { 103, 258 },
431 { 104, 258 }, { 105, 258 }, { 106, 258 }, { 107, 258 }, { 108, 258 },
432 { 109, 258 }, { 110, 258 }, { 111, 258 }, { 112, 258 }, { 113, 258 },
433 { 114, 258 }, { 115, 258 }, { 116, 258 }, { 117, 258 }, { 118, 258 },
434 { 119, 258 }, { 120, 258 }, { 121, 258 }, { 122, 258 }, { 123, 258 },
435 { 124, 258 }, { 125, 258 }, { 126, 258 }, { 127, 258 }, { 128, 258 },
436 { 129, 258 }, { 130, 258 }, { 131, 258 }, { 132, 258 }, { 133, 258 },
437 { 134, 258 }, { 135, 258 }, { 136, 258 }, { 137, 258 }, { 138, 258 },
438
439 { 139, 258 }, { 140, 258 }, { 141, 258 }, { 142, 258 }, { 143, 258 },
440 { 144, 258 }, { 145, 258 }, { 146, 258 }, { 147, 258 }, { 148, 258 },
441 { 149, 258 }, { 150, 258 }, { 151, 258 }, { 152, 258 }, { 153, 258 },
442 { 154, 258 }, { 155, 258 }, { 156, 258 }, { 157, 258 }, { 158, 258 },
443 { 159, 258 }, { 160, 258 }, { 161, 258 }, { 162, 258 }, { 163, 258 },
444 { 164, 258 }, { 165, 258 }, { 166, 258 }, { 167, 258 }, { 168, 258 },
445 { 169, 258 }, { 170, 258 }, { 171, 258 }, { 172, 258 }, { 173, 258 },
446 { 174, 258 }, { 175, 258 }, { 176, 258 }, { 177, 258 }, { 178, 258 },
447 { 179, 258 }, { 180, 258 }, { 181, 258 }, { 182, 258 }, { 183, 258 },
448 { 184, 258 }, { 185, 258 }, { 186, 258 }, { 187, 258 }, { 188, 258 },
449
450 { 189, 258 }, { 190, 258 }, { 191, 258 }, { 192, 258 }, { 193, 258 },
451 { 194, 258 }, { 195, 258 }, { 196, 258 }, { 197, 258 }, { 198, 258 },
452 { 199, 258 }, { 200, 258 }, { 201, 258 }, { 202, 258 }, { 203, 258 },
453 { 204, 258 }, { 205, 258 }, { 206, 258 }, { 207, 258 }, { 208, 258 },
454 { 209, 258 }, { 210, 258 }, { 211, 258 }, { 212, 258 }, { 213, 258 },
455 { 214, 258 }, { 215, 258 }, { 216, 258 }, { 217, 258 }, { 218, 258 },
456 { 219, 258 }, { 220, 258 }, { 221, 258 }, { 222, 258 }, { 223, 258 },
457 { 224, 258 }, { 225, 258 }, { 226, 258 }, { 227, 258 }, { 228, 258 },
458 { 229, 258 }, { 230, 258 }, { 231, 258 }, { 232, 258 }, { 233, 258 },
459 { 234, 258 }, { 235, 258 }, { 236, 258 }, { 237, 258 }, { 238, 258 },
460
461 { 239, 258 }, { 240, 258 }, { 241, 258 }, { 242, 258 }, { 243, 258 },
462 { 244, 258 }, { 245, 258 }, { 246, 258 }, { 247, 258 }, { 248, 258 },
463 { 249, 258 }, { 250, 258 }, { 251, 258 }, { 252, 258 }, { 253, 258 },
464 { 254, 258 }, { 255, 258 }, { 256, 258 }, { 0, 44 }, { 0,1294 },
465 { 0, 2 }, { 0,1292 }, { 0, 3 }, { 0,1290 }, { 0, 1 },
466 { 0,1288 }, { 0, 4 }, { 0,1286 }, { 0, 44 }, { 0,1284 },
467 { 0, 5 }, { 0,1282 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
468 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
469 { 0, 43 }, { 0,1272 }, { 0, 44 }, { 0,1270 }, { 0, 44 },
470 { 0,1268 }, { 0, 0 }, { 0, 0 }, { 0, 44 }, { 0,1264 },
471
472 { 0, 44 }, { 0,1262 }, { 0, 43 }, { 0,1260 }, { 0, 44 },
473 { 0,1258 }, { 0, 44 }, { 0,1256 }, { 0, 44 }, { 0,1254 },
474 { 0, 0 }, { 0, 44 }, { 0,1251 }, { 0, 0 }, { 0, 44 },
475 { 0,1248 }, { 0, 44 }, { 0,1246 }, { 0, 0 }, { 0, 44 },
476 { 0,1243 }, { 0, 44 }, { 0,1241 }, { 0, 44 }, { 0,1239 },
477 { 0, 44 }, { 0,1237 }, { 48, 88 }, { 49, 88 }, { 50, 88 },
478 { 51, 88 }, { 52, 88 }, { 53, 88 }, { 54, 88 }, { 55, 88 },
479 { 56, 88 }, { 57, 88 }, { 46, 107 }, { 0, 0 }, { 48, 76 },
480 { 49, 76 }, { 50, 76 }, { 51, 76 }, { 52, 76 }, { 53, 76 },
481 { 54, 76 }, { 55, 76 }, { 56, 76 }, { 57, 76 }, { 46, 95 },
482
483 { 0, 0 }, { 48, 123 }, { 49, 123 }, { 50, 123 }, { 51, 123 },
484 { 52, 123 }, { 53, 123 }, { 54, 123 }, { 55, 123 }, { 56, 123 },
485 { 57, 123 }, { 68, 76 }, { 0, 44 }, { 0,1200 }, { 0, 44 },
486 { 0,1198 }, { 0, 0 }, { 0,1196 }, { 0, 0 }, { 0,1194 },
487 { 69, 131 }, { 72, 129 }, { 0, 0 }, { 0, 0 }, { 0,1189 },
488 { 0, 0 }, { 69, 129 }, { 0, 0 }, { 85, 81 }, { 86, 107 },
489 { 85, 108 }, { 82, 131 }, { 0, 0 }, { 78, 129 }, { 89, 110 },
490 { 73, 145 }, { 0, 0 }, { 78, 130 }, { 73, 146 }, { 69, 147 },
491 { 0, 0 }, { 79, 147 }, { 0, 0 }, { 69, 147 }, { 0, 0 },
492 { 69, 159 }, { 79, 146 }, { 0, 0 }, { 0,1165 }, { 0, 0 },
493
494 { 0,1163 }, { 0, 0 }, { 0, 0 }, { 0,1160 }, { 0, 0 },
495 { 0,1158 }, { 0, 0 }, { 85, 147 }, { 0, 0 }, { 0, 0 },
496 { 84, 162 }, { 85, 165 }, { 0, 0 }, { 46, 31 }, { 0, 0 },
497 { 48, 0 }, { 49, 0 }, { 50, 0 }, { 51, 0 }, { 52, 0 },
498 { 53, 0 }, { 54, 0 }, { 55, 0 }, { 56, 0 }, { 57, 0 },
499 { 0, 43 }, { 0,1137 }, { 0, 0 }, { 0,1135 }, { 0, 0 },
500 { 0,1133 }, { 0, 0 }, { 0,1131 }, { 0, 0 }, { 0,1129 },
501 { 0, 0 }, { 0,1127 }, { 68, 132 }, { 0, 0 }, { 0,1124 },
502 { 0, 0 }, { 78, 132 }, { 68, 129 }, { 0, 0 }, { 79, 133 },
503 { 0, 0 }, { 48, 113 }, { 49, 113 }, { 50, 113 }, { 51, 113 },
504
505 { 52, 113 }, { 53, 113 }, { 54, 113 }, { 55, 113 }, { 56, 113 },
506 { 57, 113 }, { 0, 0 }, { 0,1106 }, { 0, 0 }, { 0,1104 },
507 { 0, 0 }, { 0,1102 }, { 0, 0 }, { 0,1100 }, { 0, 0 },
508 { 65, 107 }, { 0, 0 }, { 0,1096 }, { 0, 0 }, { 0,1094 },
509 { 0, 0 }, { 0,1092 }, { 46, -28 }, { 70, 110 }, { 48, 0 },
510 { 49, 0 }, { 50, 0 }, { 51, 0 }, { 52, 0 }, { 53, 0 },
511 { 54, 0 }, { 55, 0 }, { 56, 0 }, { 57, 0 }, { 0, 0 },
512 { 0,1078 }, { 0, 0 }, { 0, 0 }, { 0,1075 }, { 84, 112 },
513 { 0, 0 }, { 0,1072 }, { 0, 0 }, { 65, 91 }, { 0, 0 },
514 { 0,1068 }, { 0, 0 }, { 0, 0 }, { 0,1065 }, { 69, 96 },
515
516 { 0, 7 }, { 0,1062 }, { 0, 0 }, { 0,1060 }, { 0, 0 },
517 { 71, 97 }, { 0, 0 }, { 0,1056 }, { 0, 0 }, { 70, 96 },
518 { 0, 6 }, { 0,1052 }, { 0, 0 }, { 0,1050 }, { 0, 0 },
519 { 83, 96 }, { 0, 0 }, { 0,1046 }, { 0, 0 }, { 0,1044 },
520 { 84, 97 }, { 0, 0 }, { 83, 98 }, { 0, 0 }, { 65, 86 },
521 { 0, 0 }, { 0,1037 }, { 0, 0 }, { 0,1035 }, { 68, 90 },
522 { 0, 0 }, { 0,1032 }, { 0, 8 }, { 0,1030 }, { 0, 0 },
523 { 0,1028 }, { 0, 0 }, { 0,1026 }, { 0, 0 }, { 0,1024 },
524 { 83, 82 }, { 0, 0 }, { 73, 113 }, { 0, 0 }, { 0, 0 },
525 { 0,1018 }, { 0, 0 }, { 84, 90 }, { 77, 114 }, { 82, 106 },
526
527 { 0, 0 }, { 0,1012 }, { 0, 0 }, { 0,1010 }, { 83, 117 },
528 { 0, 0 }, { 0, 0 }, { 66, 104 }, { 0, 0 }, { 48, 0 },
529 { 49, 0 }, { 50, 0 }, { 51, 0 }, { 52, 0 }, { 53, 0 },
530 { 54, 0 }, { 55, 0 }, { 56, 0 }, { 57, 0 }, { 84, 105 },
531 { 82, 105 }, { 73, 103 }, { 0, 0 }, { 0, 990 }, { 76, 105 },
532 { 0, 0 }, { 73, 103 }, { 0, 0 }, { 83, 104 }, { 0, 0 },
533 { 73, 103 }, { 0, 0 }, { 0, 981 }, { 70, 105 }, { 0, 0 },
534 { 0, 978 }, { 69, 103 }, { 0, 0 }, { 0, 975 }, { 0, 14 },
535 { 0, 973 }, { 65, 104 }, { 0, 0 }, { 0, 970 }, { 0, 0 },
536 { 0, 968 }, { 0, 0 }, { 78, 109 }, { 0, 0 }, { 0, 964 },
537
538 { 0, 0 }, { 0, 962 }, { 0, 0 }, { 0, 960 }, { 73, 104 },
539 { 0, 0 }, { 0, 957 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
540 { 0, 953 }, { 0, 0 }, { 84, 105 }, { 68, 99 }, { 79, 102 },
541 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 945 }, { 0, 0 },
542 { 0, 943 }, { 84, 102 }, { 0, 0 }, { 84, 103 }, { 73, 95 },
543 { 0, 0 }, { 73, 95 }, { 0, 0 }, { 0, 935 }, { 0, 0 },
544 { 0, 933 }, { 0, 0 }, { 0, 0 }, { 0, 930 }, { 0, 0 },
545 { 0, 928 }, { 0, 22 }, { 0, 926 }, { 0, 0 }, { 0, 924 },
546 { 67, 77 }, { 0, 11 }, { 0, 921 }, { 0, 12 }, { 0, 919 },
547 { 0, 0 }, { 0, 917 }, { 0, 0 }, { 0, 915 }, { 0, 0 },
548
549 { 0, 913 }, { 0, 42 }, { 0, 911 }, { 0, 0 }, { 0, 909 },
550 { 0, 0 }, { 0, 0 }, { 69, 71 }, { 0, 0 }, { 0, 904 },
551 { 0, 0 }, { 0, 902 }, { 69, 68 }, { 0, 0 }, { 79, 69 },
552 { 0, 0 }, { 84, 70 }, { 0, 0 }, { 67, 74 }, { 0, 0 },
553 { 0, 893 }, { 0, 0 }, { 0, 891 }, { 0, 0 }, { 0, 0 },
554 { 0, 888 }, { 0, 0 }, { 0, 886 }, { 83, 75 }, { 0, 0 },
555 { 0, 883 }, { 0, 0 }, { 0, 881 }, { 0, 0 }, { 85, 73 },
556 { 79, 74 }, { 76, 72 }, { 69, 72 }, { 85, 74 }, { 0, 0 },
557 { 0, 873 }, { 0, 39 }, { 0, 871 }, { 0, 0 }, { 0, 869 },
558 { 0, 0 }, { 0, 867 }, { 0, 0 }, { 0, 865 }, { 0, 0 },
559
560 { 0, 863 }, { 0, 0 }, { 0, 861 }, { 83, 72 }, { 0, 0 },
561 { 0, 858 }, { 78, 66 }, { 0, 0 }, { 0, 855 }, { 0, 0 },
562 { 0, 853 }, { 0, 0 }, { 0, 0 }, { 78, 65 }, { 84, 66 },
563 { 82, 65 }, { 0, 0 }, { 0, 846 }, { 70, 60 }, { 69, 60 },
564 { 0, 0 }, { 82, 63 }, { 0, 41 }, { 0, 840 }, { 0, 0 },
565 { 0, 838 }, { 65, 64 }, { 0, 0 }, { 0, 835 }, { 0, 0 },
566 { 0, 833 }, { 0, 0 }, { 0, 831 }, { 0, 0 }, { 0, 829 },
567 { 0, 0 }, { 0, 827 }, { 67, 58 }, { 66, 58 }, { 0, 0 },
568 { 86, 63 }, { 95, 59 }, { 0, 0 }, { 84, 64 }, { 69, 57 },
569 { 0, 0 }, { 0, 817 }, { 65, 64 }, { 0, 0 }, { 0, 814 },
570
571 { 0, 0 }, { 0, 0 }, { 0, 811 }, { 0, 0 }, { 77, 57 },
572 { 0, 9 }, { 0, 807 }, { 0, 0 }, { 0, 805 }, { 0, 27 },
573 { 0, 803 }, { 0, 0 }, { 0, 801 }, { 69, 58 }, { 0, 0 },
574 { 69, 60 }, { 0, 0 }, { 0, 796 }, { 0, 0 }, { 69, 60 },
575 { 0, 0 }, { 0, 792 }, { 82, 59 }, { 0, 0 }, { 0, 789 },
576 { 95, 56 }, { 0, 0 }, { 79, 60 }, { 73, 62 }, { 0, 13 },
577 { 0, 783 }, { 73, 63 }, { 0, 0 }, { 0, 780 }, { 0, 0 },
578 { 0, 0 }, { 69, 63 }, { 85, 60 }, { 78, 64 }, { 0, 0 },
579 { 0, 773 }, { 0, 0 }, { 0, 771 }, { 0, 0 }, { 0, 769 },
580 { 0, 38 }, { 0, 767 }, { 0, 0 }, { 0, 765 }, { 0, 0 },
581
582 { 0, 763 }, { 0, 0 }, { 77, 58 }, { 69, 62 }, { 0, 0 },
583 { 0, 758 }, { 0, 17 }, { 0, 756 }, { 0, 10 }, { 0, 754 },
584 { 82, 62 }, { 0, 0 }, { 66, 54 }, { 83, 62 }, { 0, 0 },
585 { 79, 62 }, { 0, 0 }, { 0, 746 }, { 0, 0 }, { 0, 744 },
586 { 0, 0 }, { 0, 0 }, { 0, 741 }, { 0, 0 }, { 0, 739 },
587 { 0, 0 }, { 0, 737 }, { 95, 62 }, { 76, 55 }, { 0, 0 },
588 { 0, 733 }, { 0, 0 }, { 0, 731 }, { 0, 0 }, { 0, 729 },
589 { 0, 0 }, { 0, 727 }, { 0, 0 }, { 67, 51 }, { 77, 55 },
590 { 0, 0 }, { 0, 722 }, { 0, 0 }, { 0, 720 }, { 95, 56 },
591 { 78, 52 }, { 0, 0 }, { 89, 51 }, { 0, 21 }, { 0, 714 },
592
593 { 0, 0 }, { 0, 712 }, { 0, 0 }, { 0, 710 }, { 0, 0 },
594 { 0, 708 }, { 0, 0 }, { 0, 706 }, { 84, 50 }, { 67, 40 },
595 { 0, 0 }, { 67, 40 }, { 0, 0 }, { 73, 40 }, { 0, 0 },
596 { 0, 698 }, { 0, 0 }, { 0, 696 }, { 0, 0 }, { 0, 694 },
597 { 0, 0 }, { 0, 692 }, { 0, 0 }, { 0, 690 }, { 0, 0 },
598 { 70, 38 }, { 76, 41 }, { 0, 0 }, { 95, 43 }, { 0, 0 },
599 { 0, 683 }, { 0, 0 }, { 0, 681 }, { 85, 38 }, { 0, 0 },
600 { 0, 678 }, { 69, 34 }, { 65, 33 }, { 0, 0 }, { 65, 33 },
601 { 83, 42 }, { 0, 0 }, { 0, 671 }, { 67, 39 }, { 0, 0 },
602 { 0, 668 }, { 66, 37 }, { 0, 0 }, { 0, 665 }, { 80, 34 },
603
604 { 0, 0 }, { 0, 662 }, { 0, 15 }, { 0, 660 }, { 0, 0 },
605 { 0, 658 }, { 0, 0 }, { 0, 656 }, { 0, 0 }, { 0, 654 },
606 { 69, 39 }, { 0, 0 }, { 0, 651 }, { 79, 37 }, { 82, 37 },
607 { 0, 0 }, { 73, 39 }, { 0, 0 }, { 0, 0 }, { 0, 644 },
608 { 84, 37 }, { 0, 26 }, { 0, 641 }, { 0, 0 }, { 0, 639 },
609 { 0, 0 }, { 0, 637 }, { 0, 0 }, { 71, 41 }, { 78, 34 },
610 { 0, 40 }, { 0, 632 }, { 0, 0 }, { 0, 630 }, { 0, 0 },
611 { 0, 628 }, { 69, 36 }, { 0, 0 }, { 85, 39 }, { 84, 40 },
612 { 0, 0 }, { 0, 622 }, { 73, 36 }, { 0, 0 }, { 79, 36 },
613 { 0, 0 }, { 0, 617 }, { 0, 0 }, { 0, 615 }, { 0, 0 },
614
615 { 0, 613 }, { 0, 23 }, { 0, 611 }, { 80, 36 }, { 0, 0 },
616 { 0, 608 }, { 85, 36 }, { 0, 0 }, { 76, 37 }, { 0, 0 },
617 { 0, 603 }, { 0, 0 }, { 0, 601 }, { 0, 16 }, { 0, 599 },
618 { 0, 25 }, { 0, 597 }, { 69, 33 }, { 73, 31 }, { 84, 37 },
619 { 0, 0 }, { 66, 30 }, { 0, 0 }, { 0, 590 }, { 0, 0 },
620 { 95, 32 }, { 84, 32 }, { 65, 36 }, { 0, 0 }, { 0, 584 },
621 { 0, 0 }, { 69, 38 }, { 0, 0 }, { 0, 580 }, { 0, 0 },
622 { 78, 34 }, { 85, 32 }, { 0, 0 }, { 0, 575 }, { 0, 0 },
623 { 0, 573 }, { 0, 0 }, { 0, 571 }, { 0, 0 }, { 85, 37 },
624 { 76, 33 }, { 0, 18 }, { 0, 566 }, { 0, 24 }, { 0, 564 },
625
626 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 560 }, { 69, 29 },
627 { 79, 34 }, { 0, 0 }, { 0, 556 }, { 0, 0 }, { 0, 554 },
628 { 0, 0 }, { 78, 29 }, { 0, 0 }, { 0, 550 }, { 0, 0 },
629 { 0, 548 }, { 0, 0 }, { 0, 0 }, { 0, 545 }, { 95, 31 },
630 { 0, 0 }, { 0, 542 }, { 67, 33 }, { 0, 0 }, { 0, 0 },
631 { 84, 25 }, { 0, 0 }, { 0, 536 }, { 78, 33 }, { 0, 0 },
632 { 84, 27 }, { 0, 0 }, { 0, 531 }, { 85, 31 }, { 0, 0 },
633 { 80, 35 }, { 0, 0 }, { 0, 526 }, { 78, 37 }, { 84, 37 },
634 { 0, 0 }, { 0, 522 }, { 0, 0 }, { 0, 520 }, { 0, 0 },
635 { 0, 518 }, { 84, 37 }, { 68, 28 }, { 0, 0 }, { 0, 0 },
636
637 { 0, 0 }, { 0, 512 }, { 0, 0 }, { 0, 510 }, { 71, 26 },
638 { 0, 0 }, { 0, 507 }, { 0, 0 }, { 0, 505 }, { 0, 0 },
639 { 72, 25 }, { 0, 0 }, { 0, 501 }, { 0, 0 }, { 0, 499 },
640 { 0, 35 }, { 0, 497 }, { 0, 0 }, { 95, 30 }, { 79, 25 },
641 { 67, 18 }, { 68, 24 }, { 0, 37 }, { 0, 490 }, { 0, 0 },
642 { 0, 0 }, { 0, 487 }, { 0, 0 }, { 65, 28 }, { 0, 0 },
643 { 73, 25 }, { 89, 26 }, { 73, 28 }, { 0, 0 }, { 0, 479 },
644 { 0, 0 }, { 0, 477 }, { 0, 0 }, { 0, 475 }, { 0, 0 },
645 { 0, 473 }, { 0, 0 }, { 0, 471 }, { 72, 30 }, { 0, 0 },
646 { 0, 0 }, { 69, 26 }, { 82, 28 }, { 80, 27 }, { 0, 0 },
647
648 { 0, 463 }, { 0, 0 }, { 0, 461 }, { 0, 0 }, { 0, 0 },
649 { 0, 458 }, { 0, 0 }, { 0, 456 }, { 0, 0 }, { 82, 29 },
650 { 0, 0 }, { 79, 26 }, { 0, 19 }, { 0, 450 }, { 69, 28 },
651 { 78, 25 }, { 65, 25 }, { 0, 0 }, { 0, 445 }, { 78, 23 },
652 { 0, 0 }, { 0, 442 }, { 0, 0 }, { 0, 0 }, { 0, 439 },
653 { 0, 0 }, { 0, 437 }, { 84, 23 }, { 0, 0 }, { 73, 30 },
654 { 0, 0 }, { 69, 28 }, { 0, 0 }, { 0, 430 }, { 0, 36 },
655 { 0, 428 }, { 0, 0 }, { 0, 426 }, { 0, 0 }, { 86, 31 },
656 { 0, 28 }, { 0, 422 }, { 78, 28 }, { 0, 31 }, { 0, 419 },
657 { 0, 0 }, { 0, 417 }, { 0, 33 }, { 0, 415 }, { 0, 29 },
658
659 { 0, 413 }, { 0, 0 }, { 0, 411 }, { 95, 30 }, { 78, 24 },
660 { 0, 0 }, { 0, 0 }, { 73, 18 }, { 0, 0 }, { 0, 0 },
661 { 0, 403 }, { 69, 26 }, { 0, 0 }, { 0, 400 }, { 0, 0 },
662 { 0, 398 }, { 0, 0 }, { 79, 19 }, { 0, 0 }, { 67, 22 },
663 { 0, 0 }, { 0, 0 }, { 86, 19 }, { 83, 23 }, { 69, 21 },
664 { 0, 0 }, { 0, 387 }, { 0, 0 }, { 78, 21 }, { 0, 0 },
665 { 0, 0 }, { 0, 382 }, { 0, 0 }, { 0, 380 }, { 0, 0 },
666 { 0, 378 }, { 0, 0 }, { 0, 376 }, { 0, 0 }, { 0, 374 },
667 { 69, 16 }, { 0, 0 }, { 85, 26 }, { 69, 17 }, { 76, 17 },
668 { 0, 0 }, { 0, 367 }, { 0, 0 }, { 0, 365 }, { 0, 0 },
669
670 { 0, 363 }, { 0, 0 }, { 0, 0 }, { 0, 360 }, { 0, 0 },
671 { 0, 358 }, { 0, 0 }, { 0, 356 }, { 82, 18 }, { 0, 0 },
672 { 0, 353 }, { 0, 0 }, { 0, 351 }, { 76, 11 }, { 0, 0 },
673 { 0, 348 }, { 0, 0 }, { 84, 13 }, { 0, 0 }, { 0, 344 },
674 { 0, 0 }, { 0, 342 }, { 0, 0 }, { 0, 340 }, { 83, 9 },
675 { 0, 0 }, { 80, 17 }, { 0, 0 }, { 0, 335 }, { 0, 0 },
676 { 0, 333 }, { 0, 0 }, { 80, 24 }, { 0, 0 }, { 0, 329 },
677 { 0, 0 }, { 95, 11 }, { 0, 0 }, { 0, 325 }, { 95, 16 },
678 { 80, 21 }, { 65, 11 }, { 0, 0 }, { 95, 17 }, { 0, 0 },
679 { 80, 20 }, { 65, 8 }, { 0, 0 }, { 85, 20 }, { 0, 0 },
680
681 { 65, 13 }, { 0, 0 }, { 0, 311 }, { 0, 0 }, { 0, 0 },
682 { 0, 308 }, { 0, 0 }, { 0, 306 }, { 0, 0 }, { 0, 304 },
683 { 0, 0 }, { 0, 302 }, { 0, 0 }, { 0, 300 }, { 0, 0 },
684 { 65, 10 }, { 0, 0 }, { 84, 13 }, { 65, 9 }, { 82, 13 },
685 { 0, 0 }, { 82, 14 }, { 65, 12 }, { 68, 10 }, { 0, 0 },
686 { 0, 288 }, { 0, 0 }, { 0, 286 }, { 0, 0 }, { 0, 284 },
687 { 82, 9 }, { 0, 0 }, { 0, 281 }, { 0, 30 }, { 0, 279 },
688 { 0, 32 }, { 0, 277 }, { 77, 11 }, { 0, 0 }, { 77, 11 },
689 { 69, 13 }, { 95, 9 }, { 69, 15 }, { 0, 0 }, { 0, 269 },
690 { 0, 0 }, { 77, 11 }, { 82, 13 }, { 0, 0 }, { 69, 25 },
691
692 { 0, 0 }, { 73, 24 }, { 0, 34 }, { 0, 260 }, { 0, 20 },
693 { 0, 258 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
694 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
695 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 84, 23 }, { 0, 0 },
696 { 0, 0 }, { 0, 0 }, { 84, 21 }, { 0, 0 }, { 0, 0 },
697 { 0, 0 }, { 69, 18 }, { 0, 0 }, { 69, 18 }, { 0, 0 },
698 { 69, 18 }, { 0, 0 }, { 69, 19 }, { 0, 0 }, { 0, 0 },
699 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 86, 9 }, { 84, 8 },
700 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
701 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
702
703 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
704 { 0, 0 }, { 0, 0 }, { 82, 9 }, { 0, 0 }, { 82, 9 },
705 { 0, 0 }, { 82, 15 }, { 0, 0 }, { 0, 0 }, { 82, 21 },
706 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
707 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
708 { 0, 0 }, { 0, 0 }, { 83, 11 }, { 0, 0 }, { 0, 0 },
709 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
710 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
711 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
712 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
713
714 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
715 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
716 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
717 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
718 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
719 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
720 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
721 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
722 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
723 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
724
725 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
726 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
727 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
728 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
729 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
730 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
731 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
732 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
733 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
734 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
735
736 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
737 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
738 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
739 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
740 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
741 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
742 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
743 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
744 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
745 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
746
747 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
748 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
749 { 0, 0 }, { 0, 0 }, { 257, 46 }, { 1, 0 }, };
750
751 static yyconst struct yy_trans_info *yy_start_state_list[3] =
752 {
753 &yy_transition[1],
754 &yy_transition[3],
755 &yy_transition[261],
756
757 } ;
758
759 /* The intent behind this definition is that it'll catch
760 * any uses of REJECT which flex missed.
761 */
762 #define REJECT reject_used_but_not_detected
763 #define yymore() yymore_used_but_not_detected
764 #define YY_MORE_ADJ 0
765 #define YY_RESTORE_YY_MORE_OFFSET
766 #line 1 "lscp.l"
767 /***************************************************************************
768 * *
769 * LinuxSampler - modular, streaming capable sampler *
770 * *
771 * Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck *
772 * *
773 * This program is free software; you can redistribute it and/or modify *
774 * it under the terms of the GNU General Public License as published by *
775 * the Free Software Foundation; either version 2 of the License, or *
776 * (at your option) any later version. *
777 * *
778 * This program is distributed in the hope that it will be useful, *
779 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
780 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
781 * GNU General Public License for more details. *
782 * *
783 * You should have received a copy of the GNU General Public License *
784 * along with this program; if not, write to the Free Software *
785 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, *
786 * MA 02111-1307 USA *
787 ***************************************************************************/
788 #line 24 "lscp.l"
789
790 #include "lscpparser.h"
791 #include "lscpsymbols.h"
792
793 /// handle for a client connection (FIXME: doesn't work for more than one network connections of course)
794 int hSession;
795
796 #line 797 "lex.yy.c"
797
798 #define INITIAL 0
799
800 #ifndef YY_NO_UNISTD_H
801 /* Special case for "unistd.h", since it is non-ANSI. We include it way
802 * down here because we want the user's section 1 to have been scanned first.
803 * The user has a chance to override it with an option.
804 */
805 #include <unistd.h>
806 #endif
807
808 #ifndef YY_EXTRA_TYPE
809 #define YY_EXTRA_TYPE void *
810 #endif
811
812 /* Holds the entire state of the reentrant scanner. */
813 struct yyguts_t
814 {
815
816 /* User-defined. Not touched by flex. */
817 YY_EXTRA_TYPE yyextra_r;
818
819 /* The rest are the same as the globals declared in the non-reentrant scanner. */
820 FILE *yyin_r, *yyout_r;
821 size_t yy_buffer_stack_top; /**< index of top of stack. */
822 size_t yy_buffer_stack_max; /**< capacity of stack. */
823 YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */
824 char yy_hold_char;
825 int yy_n_chars;
826 int yyleng_r;
827 char *yy_c_buf_p;
828 int yy_init;
829 int yy_start;
830 int yy_did_buffer_switch_on_eof;
831 int yy_start_stack_ptr;
832 int yy_start_stack_depth;
833 int *yy_start_stack;
834 yy_state_type yy_last_accepting_state;
835 char* yy_last_accepting_cpos;
836
837 int yylineno_r;
838 int yy_flex_debug_r;
839
840 char *yytext_r;
841 int yy_more_flag;
842 int yy_more_len;
843
844 }; /* end struct yyguts_t */
845
846 /* Accessor methods to globals.
847 These are made visible to non-reentrant scanners for convenience. */
848
849 int yylex_destroy (yyscan_t yyscanner );
850
851 int yyget_debug (yyscan_t yyscanner );
852
853 void yyset_debug (int debug_flag ,yyscan_t yyscanner );
854
855 YY_EXTRA_TYPE yyget_extra (yyscan_t yyscanner );
856
857 void yyset_extra (YY_EXTRA_TYPE user_defined ,yyscan_t yyscanner );
858
859 FILE *yyget_in (yyscan_t yyscanner );
860
861 void yyset_in (FILE * in_str ,yyscan_t yyscanner );
862
863 FILE *yyget_out (yyscan_t yyscanner );
864
865 void yyset_out (FILE * out_str ,yyscan_t yyscanner );
866
867 int yyget_leng (yyscan_t yyscanner );
868
869 char *yyget_text (yyscan_t yyscanner );
870
871 int yyget_lineno (yyscan_t yyscanner );
872
873 void yyset_lineno (int line_number ,yyscan_t yyscanner );
874
875 /* Macros after this point can all be overridden by user definitions in
876 * section 1.
877 */
878
879 #ifndef YY_SKIP_YYWRAP
880 #ifdef __cplusplus
881 extern "C" int yywrap (yyscan_t yyscanner );
882 #else
883 extern int yywrap (yyscan_t yyscanner );
884 #endif
885 #endif
886
887 static void yyunput (int c,char *buf_ptr ,yyscan_t yyscanner);
888
889 #ifndef yytext_ptr
890 static void yy_flex_strncpy (char *,yyconst char *,int ,yyscan_t yyscanner);
891 #endif
892
893 #ifdef YY_NEED_STRLEN
894 static int yy_flex_strlen (yyconst char * ,yyscan_t yyscanner);
895 #endif
896
897 #ifndef YY_NO_INPUT
898
899 #ifdef __cplusplus
900 static int yyinput (yyscan_t yyscanner );
901 #else
902 static int input (yyscan_t yyscanner );
903 #endif
904
905 #endif
906
907 /* Amount of stuff to slurp up with each read. */
908 #ifndef YY_READ_BUF_SIZE
909 #define YY_READ_BUF_SIZE 8192
910 #endif
911
912 /* Copy whatever the last rule matched to the standard output. */
913 #ifndef ECHO
914 /* This used to be an fputs(), but since the string might contain NUL's,
915 * we now use fwrite().
916 */
917 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
918 #endif
919
920 /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
921 * is returned in "result".
922 */
923 #ifndef YY_INPUT
924 #define YY_INPUT(buf,result,max_size) \
925 errno=0; \
926 while ( (result = read( fileno(yyin), (char *) buf, max_size )) < 0 ) \
927 { \
928 if( errno != EINTR) \
929 { \
930 YY_FATAL_ERROR( "input in flex scanner failed" ); \
931 break; \
932 } \
933 errno=0; \
934 clearerr(yyin); \
935 }\
936 \
937
938 #endif
939
940 /* No semi-colon after return; correct usage is to write "yyterminate();" -
941 * we don't want an extra ';' after the "return" because that will cause
942 * some compilers to complain about unreachable statements.
943 */
944 #ifndef yyterminate
945 #define yyterminate() return YY_NULL
946 #endif
947
948 /* Number of entries by which start-condition stack grows. */
949 #ifndef YY_START_STACK_INCR
950 #define YY_START_STACK_INCR 25
951 #endif
952
953 /* Report a fatal error. */
954 #ifndef YY_FATAL_ERROR
955 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner)
956 #endif
957
958 /* end tables serialization structures and prototypes */
959
960 /* Default declaration of generated scanner - a define so the user can
961 * easily add parameters.
962 */
963 #ifndef YY_DECL
964 #define YY_DECL_IS_OURS 1
965
966 extern int yylex (yyscan_t yyscanner);
967
968 #define YY_DECL int yylex (yyscan_t yyscanner)
969 #endif /* !YY_DECL */
970
971 /* Code executed at the beginning of each rule, after yytext and yyleng
972 * have been set up.
973 */
974 #ifndef YY_USER_ACTION
975 #define YY_USER_ACTION
976 #endif
977
978 /* Code executed at the end of each rule. */
979 #ifndef YY_BREAK
980 #define YY_BREAK break;
981 #endif
982
983 #define YY_RULE_SETUP \
984 YY_USER_ACTION
985
986 /** The main scanner function which does all the work.
987 */
988 YY_DECL
989 {
990 register yy_state_type yy_current_state;
991 register char *yy_cp, *yy_bp;
992 register int yy_act;
993 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
994
995 #line 37 "lscp.l"
996
997
998 #line 999 "lex.yy.c"
999
1000 if ( yyg->yy_init )
1001 {
1002 yyg->yy_init = 0;
1003
1004 #ifdef YY_USER_INIT
1005 YY_USER_INIT;
1006 #endif
1007
1008 if ( ! yyg->yy_start )
1009 yyg->yy_start = 1; /* first start state */
1010
1011 if ( ! yyin )
1012 yyin = stdin;
1013
1014 if ( ! yyout )
1015 yyout = stdout;
1016
1017 if ( ! YY_CURRENT_BUFFER ) {
1018 yyensure_buffer_stack (yyscanner);
1019 YY_CURRENT_BUFFER_LVALUE =
1020 yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
1021 }
1022
1023 yy_load_buffer_state(yyscanner );
1024 }
1025
1026 while ( 1 ) /* loops until end-of-file is reached */
1027 {
1028 yy_cp = yyg->yy_c_buf_p;
1029
1030 /* Support of yytext. */
1031 *yy_cp = yyg->yy_hold_char;
1032
1033 /* yy_bp points to the position in yy_ch_buf of the start of
1034 * the current run.
1035 */
1036 yy_bp = yy_cp;
1037
1038 yy_current_state = yy_start_state_list[yyg->yy_start];
1039 yy_match:
1040 {
1041 register yyconst struct yy_trans_info *yy_trans_info;
1042
1043 register YY_CHAR yy_c;
1044
1045 for ( yy_c = YY_SC_TO_UI(*yy_cp);
1046 (yy_trans_info = &yy_current_state[(unsigned int) yy_c])->
1047 yy_verify == yy_c;
1048 yy_c = YY_SC_TO_UI(*++yy_cp) )
1049 {
1050 yy_current_state += yy_trans_info->yy_nxt;
1051
1052 if ( yy_current_state[-1].yy_nxt )
1053 {
1054 yyg->yy_last_accepting_state = yy_current_state;
1055 yyg->yy_last_accepting_cpos = yy_cp;
1056 }
1057 }
1058 }
1059
1060 yy_find_action:
1061 yy_act = yy_current_state[-1].yy_nxt;
1062
1063 YY_DO_BEFORE_ACTION;
1064
1065 do_action: /* This label is used only to access EOF actions. */
1066
1067 switch ( yy_act )
1068 { /* beginning of action switch */
1069 case 0: /* must back up */
1070 /* undo the effects of YY_DO_BEFORE_ACTION */
1071 *yy_cp = yyg->yy_hold_char;
1072 yy_cp = yyg->yy_last_accepting_cpos + 1;
1073 yy_current_state = yyg->yy_last_accepting_state;
1074 goto yy_find_action;
1075
1076 case 1:
1077 YY_RULE_SETUP
1078 #line 39 "lscp.l"
1079 { return SP; }
1080 YY_BREAK
1081 case 2:
1082 /* rule 2 can match eol */
1083 YY_RULE_SETUP
1084 #line 40 "lscp.l"
1085 { return LF; }
1086 YY_BREAK
1087 case 3:
1088 YY_RULE_SETUP
1089 #line 41 "lscp.l"
1090 { return CR; }
1091 YY_BREAK
1092 case 4:
1093 YY_RULE_SETUP
1094 #line 42 "lscp.l"
1095 { return HASH; }
1096 YY_BREAK
1097 case 5:
1098 YY_RULE_SETUP
1099 #line 43 "lscp.l"
1100 { return EQ; }
1101 YY_BREAK
1102 case 6:
1103 YY_RULE_SETUP
1104 #line 44 "lscp.l"
1105 { yylval->Dotnum = atof(yytext); return DOTNUM; }
1106 YY_BREAK
1107 case 7:
1108 YY_RULE_SETUP
1109 #line 45 "lscp.l"
1110 { return ADD; }
1111 YY_BREAK
1112 case 8:
1113 YY_RULE_SETUP
1114 #line 46 "lscp.l"
1115 { return GET; }
1116 YY_BREAK
1117 case 9:
1118 YY_RULE_SETUP
1119 #line 47 "lscp.l"
1120 { return CREATE; }
1121 YY_BREAK
1122 case 10:
1123 YY_RULE_SETUP
1124 #line 48 "lscp.l"
1125 { return DESTROY; }
1126 YY_BREAK
1127 case 11:
1128 YY_RULE_SETUP
1129 #line 49 "lscp.l"
1130 { return LIST; }
1131 YY_BREAK
1132 case 12:
1133 YY_RULE_SETUP
1134 #line 50 "lscp.l"
1135 { return LOAD; }
1136 YY_BREAK
1137 case 13:
1138 YY_RULE_SETUP
1139 #line 51 "lscp.l"
1140 { return REMOVE; }
1141 YY_BREAK
1142 case 14:
1143 YY_RULE_SETUP
1144 #line 52 "lscp.l"
1145 { return SET; }
1146 YY_BREAK
1147 case 15:
1148 YY_RULE_SETUP
1149 #line 53 "lscp.l"
1150 { return SUBSCRIBE; }
1151 YY_BREAK
1152 case 16:
1153 YY_RULE_SETUP
1154 #line 54 "lscp.l"
1155 { return UNSUBSCRIBE; }
1156 YY_BREAK
1157 case 17:
1158 YY_RULE_SETUP
1159 #line 55 "lscp.l"
1160 { return CHANNEL; }
1161 YY_BREAK
1162 case 18:
1163 YY_RULE_SETUP
1164 #line 56 "lscp.l"
1165 { return NOTIFICATION; }
1166 YY_BREAK
1167 case 19:
1168 YY_RULE_SETUP
1169 #line 57 "lscp.l"
1170 { return AVAILABLE_ENGINES; }
1171 YY_BREAK
1172 case 20:
1173 YY_RULE_SETUP
1174 #line 58 "lscp.l"
1175 { return AVAILABLE_AUDIO_OUTPUT_DRIVERS; }
1176 YY_BREAK
1177 case 21:
1178 YY_RULE_SETUP
1179 #line 59 "lscp.l"
1180 { return CHANNELS; }
1181 YY_BREAK
1182 case 22:
1183 YY_RULE_SETUP
1184 #line 60 "lscp.l"
1185 { return INFO; }
1186 YY_BREAK
1187 case 23:
1188 YY_RULE_SETUP
1189 #line 61 "lscp.l"
1190 { return BUFFER_FILL; }
1191 YY_BREAK
1192 case 24:
1193 YY_RULE_SETUP
1194 #line 62 "lscp.l"
1195 { return STREAM_COUNT; }
1196 YY_BREAK
1197 case 25:
1198 YY_RULE_SETUP
1199 #line 63 "lscp.l"
1200 { return VOICE_COUNT; }
1201 YY_BREAK
1202 case 26:
1203 YY_RULE_SETUP
1204 #line 64 "lscp.l"
1205 { return INSTRUMENT; }
1206 YY_BREAK
1207 case 27:
1208 YY_RULE_SETUP
1209 #line 65 "lscp.l"
1210 { return ENGINE; }
1211 YY_BREAK
1212 case 28:
1213 YY_RULE_SETUP
1214 #line 66 "lscp.l"
1215 { return AUDIO_OUTPUT_DEVICE; }
1216 YY_BREAK
1217 case 29:
1218 YY_RULE_SETUP
1219 #line 67 "lscp.l"
1220 { return AUDIO_OUTPUT_DEVICES; }
1221 YY_BREAK
1222 case 30:
1223 YY_RULE_SETUP
1224 #line 68 "lscp.l"
1225 { return AUDIO_OUTPUT_DEVICE_PARAMETER; }
1226 YY_BREAK
1227 case 31:
1228 YY_RULE_SETUP
1229 #line 69 "lscp.l"
1230 { return AUDIO_OUTPUT_DRIVER; }
1231 YY_BREAK
1232 case 32:
1233 YY_RULE_SETUP
1234 #line 70 "lscp.l"
1235 { return AUDIO_OUTPUT_DRIVER_PARAMETER; }
1236 YY_BREAK
1237 case 33:
1238 YY_RULE_SETUP
1239 #line 71 "lscp.l"
1240 { return AUDIO_OUTPUT_CHANNEL; }
1241 YY_BREAK
1242 case 34:
1243 YY_RULE_SETUP
1244 #line 72 "lscp.l"
1245 { return AUDIO_OUTPUT_CHANNEL_PARAMETER; }
1246 YY_BREAK
1247 case 35:
1248 YY_RULE_SETUP
1249 #line 73 "lscp.l"
1250 { return MIDI_INPUT_PORT; }
1251 YY_BREAK
1252 case 36:
1253 YY_RULE_SETUP
1254 #line 74 "lscp.l"
1255 { return MIDI_INPUT_CHANNEL; }
1256 YY_BREAK
1257 case 37:
1258 YY_RULE_SETUP
1259 #line 75 "lscp.l"
1260 { return MIDI_INPUT_TYPE; }
1261 YY_BREAK
1262 case 38:
1263 YY_RULE_SETUP
1264 #line 76 "lscp.l"
1265 { return VOLUME; }
1266 YY_BREAK
1267 case 39:
1268 YY_RULE_SETUP
1269 #line 77 "lscp.l"
1270 { return BYTES; }
1271 YY_BREAK
1272 case 40:
1273 YY_RULE_SETUP
1274 #line 78 "lscp.l"
1275 { return PERCENTAGE; }
1276 YY_BREAK
1277 case 41:
1278 YY_RULE_SETUP
1279 #line 79 "lscp.l"
1280 { return RESET; }
1281 YY_BREAK
1282 case 42:
1283 YY_RULE_SETUP
1284 #line 80 "lscp.l"
1285 { return QUIT; }
1286 YY_BREAK
1287 case 43:
1288 YY_RULE_SETUP
1289 #line 81 "lscp.l"
1290 { yylval->Number = atoi(yytext); return NUMBER; }
1291 YY_BREAK
1292 case 44:
1293 YY_RULE_SETUP
1294 #line 82 "lscp.l"
1295 { yylval->Char = yytext[0]; return CHAR; }
1296 YY_BREAK
1297 case 45:
1298 YY_RULE_SETUP
1299 #line 84 "lscp.l"
1300 ECHO;
1301 YY_BREAK
1302 #line 1303 "lex.yy.c"
1303 case YY_STATE_EOF(INITIAL):
1304 yyterminate();
1305
1306 case YY_END_OF_BUFFER:
1307 {
1308 /* Amount of text matched not including the EOB char. */
1309 int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;
1310
1311 /* Undo the effects of YY_DO_BEFORE_ACTION. */
1312 *yy_cp = yyg->yy_hold_char;
1313 YY_RESTORE_YY_MORE_OFFSET
1314
1315 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
1316 {
1317 /* We're scanning a new file or input source. It's
1318 * possible that this happened because the user
1319 * just pointed yyin at a new source and called
1320 * yylex(). If so, then we have to assure
1321 * consistency between YY_CURRENT_BUFFER and our
1322 * globals. Here is the right place to do so, because
1323 * this is the first action (other than possibly a
1324 * back-up) that will match for the new input source.
1325 */
1326 yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1327 YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
1328 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
1329 }
1330
1331 /* Note that here we test for yy_c_buf_p "<=" to the position
1332 * of the first EOB in the buffer, since yy_c_buf_p will
1333 * already have been incremented past the NUL character
1334 * (since all states make transitions on EOB to the
1335 * end-of-buffer state). Contrast this with the test
1336 * in input().
1337 */
1338 if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
1339 { /* This was really a NUL. */
1340 yy_state_type yy_next_state;
1341
1342 yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text;
1343
1344 yy_current_state = yy_get_previous_state( yyscanner );
1345
1346 /* Okay, we're now positioned to make the NUL
1347 * transition. We couldn't have
1348 * yy_get_previous_state() go ahead and do it
1349 * for us because it doesn't know how to deal
1350 * with the possibility of jamming (and we don't
1351 * want to build jamming into it because then it
1352 * will run more slowly).
1353 */
1354
1355 yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner);
1356
1357 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
1358
1359 if ( yy_next_state )
1360 {
1361 /* Consume the NUL. */
1362 yy_cp = ++yyg->yy_c_buf_p;
1363 yy_current_state = yy_next_state;
1364 goto yy_match;
1365 }
1366
1367 else
1368 {
1369 yy_cp = yyg->yy_c_buf_p;
1370 goto yy_find_action;
1371 }
1372 }
1373
1374 else switch ( yy_get_next_buffer( yyscanner ) )
1375 {
1376 case EOB_ACT_END_OF_FILE:
1377 {
1378 yyg->yy_did_buffer_switch_on_eof = 0;
1379
1380 if ( yywrap(yyscanner ) )
1381 {
1382 /* Note: because we've taken care in
1383 * yy_get_next_buffer() to have set up
1384 * yytext, we can now set up
1385 * yy_c_buf_p so that if some total
1386 * hoser (like flex itself) wants to
1387 * call the scanner after we return the
1388 * YY_NULL, it'll still work - another
1389 * YY_NULL will get returned.
1390 */
1391 yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
1392
1393 yy_act = YY_STATE_EOF(YY_START);
1394 goto do_action;
1395 }
1396
1397 else
1398 {
1399 if ( ! yyg->yy_did_buffer_switch_on_eof )
1400 YY_NEW_FILE;
1401 }
1402 break;
1403 }
1404
1405 case EOB_ACT_CONTINUE_SCAN:
1406 yyg->yy_c_buf_p =
1407 yyg->yytext_ptr + yy_amount_of_matched_text;
1408
1409 yy_current_state = yy_get_previous_state( yyscanner );
1410
1411 yy_cp = yyg->yy_c_buf_p;
1412 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
1413 goto yy_match;
1414
1415 case EOB_ACT_LAST_MATCH:
1416 yyg->yy_c_buf_p =
1417 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];
1418
1419 yy_current_state = yy_get_previous_state( yyscanner );
1420
1421 yy_cp = yyg->yy_c_buf_p;
1422 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
1423 goto yy_find_action;
1424 }
1425 break;
1426 }
1427
1428 default:
1429 YY_FATAL_ERROR(
1430 "fatal flex scanner internal error--no action found" );
1431 } /* end of action switch */
1432 } /* end of scanning one token */
1433 } /* end of yylex */
1434
1435 /* yy_get_next_buffer - try to read in a new buffer
1436 *
1437 * Returns a code representing an action:
1438 * EOB_ACT_LAST_MATCH -
1439 * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1440 * EOB_ACT_END_OF_FILE - end of file
1441 */
1442 static int yy_get_next_buffer (yyscan_t yyscanner)
1443 {
1444 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1445 register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1446 register char *source = yyg->yytext_ptr;
1447 register int number_to_move, i;
1448 int ret_val;
1449
1450 if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
1451 YY_FATAL_ERROR(
1452 "fatal flex scanner internal error--end of buffer missed" );
1453
1454 if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1455 { /* Don't try to fill the buffer, so this is an EOF. */
1456 if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 )
1457 {
1458 /* We matched a single character, the EOB, so
1459 * treat this as a final EOF.
1460 */
1461 return EOB_ACT_END_OF_FILE;
1462 }
1463
1464 else
1465 {
1466 /* We matched some text prior to the EOB, first
1467 * process it.
1468 */
1469 return EOB_ACT_LAST_MATCH;
1470 }
1471 }
1472
1473 /* Try to read more data. */
1474
1475 /* First move last chars to start of buffer. */
1476 number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr) - 1;
1477
1478 for ( i = 0; i < number_to_move; ++i )
1479 *(dest++) = *(source++);
1480
1481 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1482 /* don't do the read, it's not guaranteed to return an EOF,
1483 * just force an EOF
1484 */
1485 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0;
1486
1487 else
1488 {
1489 size_t num_to_read =
1490 YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1491
1492 while ( num_to_read <= 0 )
1493 { /* Not enough room in the buffer - grow it. */
1494
1495 /* just a shorter name for the current buffer */
1496 YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
1497
1498 int yy_c_buf_p_offset =
1499 (int) (yyg->yy_c_buf_p - b->yy_ch_buf);
1500
1501 if ( b->yy_is_our_buffer )
1502 {
1503 int new_size = b->yy_buf_size * 2;
1504
1505 if ( new_size <= 0 )
1506 b->yy_buf_size += b->yy_buf_size / 8;
1507 else
1508 b->yy_buf_size *= 2;
1509
1510 b->yy_ch_buf = (char *)
1511 /* Include room in for 2 EOB chars. */
1512 yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 ,yyscanner );
1513 }
1514 else
1515 /* Can't grow it, we don't own it. */
1516 b->yy_ch_buf = 0;
1517
1518 if ( ! b->yy_ch_buf )
1519 YY_FATAL_ERROR(
1520 "fatal error - scanner input buffer overflow" );
1521
1522 yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
1523
1524 num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1525 number_to_move - 1;
1526
1527 }
1528
1529 if ( num_to_read > YY_READ_BUF_SIZE )
1530 num_to_read = YY_READ_BUF_SIZE;
1531
1532 /* Read in more data. */
1533 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1534 yyg->yy_n_chars, num_to_read );
1535
1536 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
1537 }
1538
1539 if ( yyg->yy_n_chars == 0 )
1540 {
1541 if ( number_to_move == YY_MORE_ADJ )
1542 {
1543 ret_val = EOB_ACT_END_OF_FILE;
1544 yyrestart(yyin ,yyscanner);
1545 }
1546
1547 else
1548 {
1549 ret_val = EOB_ACT_LAST_MATCH;
1550 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1551 YY_BUFFER_EOF_PENDING;
1552 }
1553 }
1554
1555 else
1556 ret_val = EOB_ACT_CONTINUE_SCAN;
1557
1558 yyg->yy_n_chars += number_to_move;
1559 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
1560 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
1561
1562 yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1563
1564 return ret_val;
1565 }
1566
1567 /* yy_get_previous_state - get the state just before the EOB char was reached */
1568
1569 static yy_state_type yy_get_previous_state (yyscan_t yyscanner)
1570 {
1571 register yy_state_type yy_current_state;
1572 register char *yy_cp;
1573 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1574
1575 yy_current_state = yy_start_state_list[yyg->yy_start];
1576
1577 for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
1578 {
1579 yy_current_state += yy_current_state[(*yy_cp ? YY_SC_TO_UI(*yy_cp) : 256)].yy_nxt;
1580 if ( yy_current_state[-1].yy_nxt )
1581 {
1582 yyg->yy_last_accepting_state = yy_current_state;
1583 yyg->yy_last_accepting_cpos = yy_cp;
1584 }
1585 }
1586
1587 return yy_current_state;
1588 }
1589
1590 /* yy_try_NUL_trans - try to make a transition on the NUL character
1591 *
1592 * synopsis
1593 * next_state = yy_try_NUL_trans( current_state );
1594 */
1595 static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state , yyscan_t yyscanner)
1596 {
1597 register int yy_is_jam;
1598 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1599 register char *yy_cp = yyg->yy_c_buf_p;
1600
1601 register int yy_c = 256;
1602 register yyconst struct yy_trans_info *yy_trans_info;
1603
1604 yy_trans_info = &yy_current_state[(unsigned int) yy_c];
1605 yy_current_state += yy_trans_info->yy_nxt;
1606 yy_is_jam = (yy_trans_info->yy_verify != yy_c);
1607
1608 if ( ! yy_is_jam )
1609 {
1610 if ( yy_current_state[-1].yy_nxt )
1611 {
1612 yyg->yy_last_accepting_state = yy_current_state;
1613 yyg->yy_last_accepting_cpos = yy_cp;
1614 }
1615 }
1616
1617 return yy_is_jam ? 0 : yy_current_state;
1618 }
1619
1620 static void yyunput (int c, register char * yy_bp , yyscan_t yyscanner)
1621 {
1622 register char *yy_cp;
1623 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1624
1625 yy_cp = yyg->yy_c_buf_p;
1626
1627 /* undo effects of setting up yytext */
1628 *yy_cp = yyg->yy_hold_char;
1629
1630 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1631 { /* need to shift things up to make room */
1632 /* +2 for EOB chars. */
1633 register int number_to_move = yyg->yy_n_chars + 2;
1634 register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
1635 YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
1636 register char *source =
1637 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
1638
1639 while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1640 *--dest = *--source;
1641
1642 yy_cp += (int) (dest - source);
1643 yy_bp += (int) (dest - source);
1644 YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
1645 yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
1646
1647 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1648 YY_FATAL_ERROR( "flex scanner push-back overflow" );
1649 }
1650
1651 *--yy_cp = (char) c;
1652
1653 yyg->yytext_ptr = yy_bp;
1654 yyg->yy_hold_char = *yy_cp;
1655 yyg->yy_c_buf_p = yy_cp;
1656 }
1657
1658 #ifndef YY_NO_INPUT
1659 #ifdef __cplusplus
1660 static int yyinput (yyscan_t yyscanner)
1661 #else
1662 static int input (yyscan_t yyscanner)
1663 #endif
1664
1665 {
1666 int c;
1667 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1668
1669 *yyg->yy_c_buf_p = yyg->yy_hold_char;
1670
1671 if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
1672 {
1673 /* yy_c_buf_p now points to the character we want to return.
1674 * If this occurs *before* the EOB characters, then it's a
1675 * valid NUL; if not, then we've hit the end of the buffer.
1676 */
1677 if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
1678 /* This was really a NUL. */
1679 *yyg->yy_c_buf_p = '\0';
1680
1681 else
1682 { /* need more input */
1683 int offset = yyg->yy_c_buf_p - yyg->yytext_ptr;
1684 ++yyg->yy_c_buf_p;
1685
1686 switch ( yy_get_next_buffer( yyscanner ) )
1687 {
1688 case EOB_ACT_LAST_MATCH:
1689 /* This happens because yy_g_n_b()
1690 * sees that we've accumulated a
1691 * token and flags that we need to
1692 * try matching the token before
1693 * proceeding. But for input(),
1694 * there's no matching to consider.
1695 * So convert the EOB_ACT_LAST_MATCH
1696 * to EOB_ACT_END_OF_FILE.
1697 */
1698
1699 /* Reset buffer status. */
1700 yyrestart(yyin ,yyscanner);
1701
1702 /*FALLTHROUGH*/
1703
1704 case EOB_ACT_END_OF_FILE:
1705 {
1706 if ( yywrap(yyscanner ) )
1707 return EOF;
1708
1709 if ( ! yyg->yy_did_buffer_switch_on_eof )
1710 YY_NEW_FILE;
1711 #ifdef __cplusplus
1712 return yyinput(yyscanner);
1713 #else
1714 return input(yyscanner);
1715 #endif
1716 }
1717
1718 case EOB_ACT_CONTINUE_SCAN:
1719 yyg->yy_c_buf_p = yyg->yytext_ptr + offset;
1720 break;
1721 }
1722 }
1723 }
1724
1725 c = *(unsigned char *) yyg->yy_c_buf_p; /* cast for 8-bit char's */
1726 *yyg->yy_c_buf_p = '\0'; /* preserve yytext */
1727 yyg->yy_hold_char = *++yyg->yy_c_buf_p;
1728
1729 return c;
1730 }
1731 #endif /* ifndef YY_NO_INPUT */
1732
1733 /** Immediately switch to a different input stream.
1734 * @param input_file A readable stream.
1735 * @param yyscanner The scanner object.
1736 * @note This function does not reset the start condition to @c INITIAL .
1737 */
1738 void yyrestart (FILE * input_file , yyscan_t yyscanner)
1739 {
1740 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1741
1742 if ( ! YY_CURRENT_BUFFER ){
1743 yyensure_buffer_stack (yyscanner);
1744 YY_CURRENT_BUFFER_LVALUE =
1745 yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
1746 }
1747
1748 yy_init_buffer(YY_CURRENT_BUFFER,input_file ,yyscanner);
1749 yy_load_buffer_state(yyscanner );
1750 }
1751
1752 /** Switch to a different input buffer.
1753 * @param new_buffer The new input buffer.
1754 * @param yyscanner The scanner object.
1755 */
1756 void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
1757 {
1758 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1759
1760 /* TODO. We should be able to replace this entire function body
1761 * with
1762 * yypop_buffer_state();
1763 * yypush_buffer_state(new_buffer);
1764 */
1765 yyensure_buffer_stack (yyscanner);
1766 if ( YY_CURRENT_BUFFER == new_buffer )
1767 return;
1768
1769 if ( YY_CURRENT_BUFFER )
1770 {
1771 /* Flush out information for old buffer. */
1772 *yyg->yy_c_buf_p = yyg->yy_hold_char;
1773 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
1774 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
1775 }
1776
1777 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1778 yy_load_buffer_state(yyscanner );
1779
1780 /* We don't actually know whether we did this switch during
1781 * EOF (yywrap()) processing, but the only time this flag
1782 * is looked at is after yywrap() is called, so it's safe
1783 * to go ahead and always set it.
1784 */
1785 yyg->yy_did_buffer_switch_on_eof = 1;
1786 }
1787
1788 static void yy_load_buffer_state (yyscan_t yyscanner)
1789 {
1790 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1791 yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1792 yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1793 yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1794 yyg->yy_hold_char = *yyg->yy_c_buf_p;
1795 }
1796
1797 /** Allocate and initialize an input buffer state.
1798 * @param file A readable stream.
1799 * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
1800 * @param yyscanner The scanner object.
1801 * @return the allocated buffer state.
1802 */
1803 YY_BUFFER_STATE yy_create_buffer (FILE * file, int size , yyscan_t yyscanner)
1804 {
1805 YY_BUFFER_STATE b;
1806
1807 b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) ,yyscanner );
1808 if ( ! b )
1809 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1810
1811 b->yy_buf_size = size;
1812
1813 /* yy_ch_buf has to be 2 characters longer than the size given because
1814 * we need to put in 2 end-of-buffer characters.
1815 */
1816 b->yy_ch_buf = (char *) yyalloc(b->yy_buf_size + 2 ,yyscanner );
1817 if ( ! b->yy_ch_buf )
1818 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1819
1820 b->yy_is_our_buffer = 1;
1821
1822 yy_init_buffer(b,file ,yyscanner);
1823
1824 return b;
1825 }
1826
1827 /** Destroy the buffer.
1828 * @param b a buffer created with yy_create_buffer()
1829 * @param yyscanner The scanner object.
1830 */
1831 void yy_delete_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner)
1832 {
1833 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1834
1835 if ( ! b )
1836 return;
1837
1838 if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
1839 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
1840
1841 if ( b->yy_is_our_buffer )
1842 yyfree((void *) b->yy_ch_buf ,yyscanner );
1843
1844 yyfree((void *) b ,yyscanner );
1845 }
1846
1847 #ifndef __cplusplus
1848 extern int isatty (int );
1849 #endif /* __cplusplus */
1850
1851 /* Initializes or reinitializes a buffer.
1852 * This function is sometimes called more than once on the same buffer,
1853 * such as during a yyrestart() or at EOF.
1854 */
1855 static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file , yyscan_t yyscanner)
1856
1857 {
1858 int oerrno = errno;
1859 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1860
1861 yy_flush_buffer(b ,yyscanner);
1862
1863 b->yy_input_file = file;
1864 b->yy_fill_buffer = 1;
1865
1866 /* If b is the current buffer, then yy_init_buffer was _probably_
1867 * called from yyrestart() or through yy_get_next_buffer.
1868 * In that case, we don't want to reset the lineno or column.
1869 */
1870 if (b != YY_CURRENT_BUFFER){
1871 b->yy_bs_lineno = 1;
1872 b->yy_bs_column = 0;
1873 }
1874
1875 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1876
1877 errno = oerrno;
1878 }
1879
1880 /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
1881 * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
1882 * @param yyscanner The scanner object.
1883 */
1884 void yy_flush_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner)
1885 {
1886 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1887 if ( ! b )
1888 return;
1889
1890 b->yy_n_chars = 0;
1891
1892 /* We always need two end-of-buffer characters. The first causes
1893 * a transition to the end-of-buffer state. The second causes
1894 * a jam in that state.
1895 */
1896 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1897 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1898
1899 b->yy_buf_pos = &b->yy_ch_buf[0];
1900
1901 b->yy_at_bol = 1;
1902 b->yy_buffer_status = YY_BUFFER_NEW;
1903
1904 if ( b == YY_CURRENT_BUFFER )
1905 yy_load_buffer_state(yyscanner );
1906 }
1907
1908 /** Pushes the new state onto the stack. The new state becomes
1909 * the current state. This function will allocate the stack
1910 * if necessary.
1911 * @param new_buffer The new state.
1912 * @param yyscanner The scanner object.
1913 */
1914 void yypush_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
1915 {
1916 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1917 if (new_buffer == NULL)
1918 return;
1919
1920 yyensure_buffer_stack(yyscanner);
1921
1922 /* This block is copied from yy_switch_to_buffer. */
1923 if ( YY_CURRENT_BUFFER )
1924 {
1925 /* Flush out information for old buffer. */
1926 *yyg->yy_c_buf_p = yyg->yy_hold_char;
1927 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
1928 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
1929 }
1930
1931 /* Only push if top exists. Otherwise, replace top. */
1932 if (YY_CURRENT_BUFFER)
1933 yyg->yy_buffer_stack_top++;
1934 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1935
1936 /* copied from yy_switch_to_buffer. */
1937 yy_load_buffer_state(yyscanner );
1938 yyg->yy_did_buffer_switch_on_eof = 1;
1939 }
1940
1941 /** Removes and deletes the top of the stack, if present.
1942 * The next element becomes the new top.
1943 * @param yyscanner The scanner object.
1944 */
1945 void yypop_buffer_state (yyscan_t yyscanner)
1946 {
1947 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1948 if (!YY_CURRENT_BUFFER)
1949 return;
1950
1951 yy_delete_buffer(YY_CURRENT_BUFFER ,yyscanner);
1952 YY_CURRENT_BUFFER_LVALUE = NULL;
1953 if (yyg->yy_buffer_stack_top > 0)
1954 --yyg->yy_buffer_stack_top;
1955
1956 if (YY_CURRENT_BUFFER) {
1957 yy_load_buffer_state(yyscanner );
1958 yyg->yy_did_buffer_switch_on_eof = 1;
1959 }
1960 }
1961
1962 /* Allocates the stack if it does not exist.
1963 * Guarantees space for at least one push.
1964 */
1965 static void yyensure_buffer_stack (yyscan_t yyscanner)
1966 {
1967 int num_to_alloc;
1968 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1969
1970 if (!yyg->yy_buffer_stack) {
1971
1972 /* First allocation is just for 2 elements, since we don't know if this
1973 * scanner will even need a stack. We use 2 instead of 1 to avoid an
1974 * immediate realloc on the next call.
1975 */
1976 num_to_alloc = 1;
1977 yyg->yy_buffer_stack = (struct yy_buffer_state**)yyalloc
1978 (num_to_alloc * sizeof(struct yy_buffer_state*)
1979 , yyscanner);
1980
1981 memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*));
1982
1983 yyg->yy_buffer_stack_max = num_to_alloc;
1984 yyg->yy_buffer_stack_top = 0;
1985 return;
1986 }
1987
1988 if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){
1989
1990 /* Increase the buffer to prepare for a possible push. */
1991 int grow_size = 8 /* arbitrary grow size */;
1992
1993 num_to_alloc = yyg->yy_buffer_stack_max + grow_size;
1994 yyg->yy_buffer_stack = (struct yy_buffer_state**)yyrealloc
1995 (yyg->yy_buffer_stack,
1996 num_to_alloc * sizeof(struct yy_buffer_state*)
1997 , yyscanner);
1998
1999 /* zero only the new slots.*/
2000 memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*));
2001 yyg->yy_buffer_stack_max = num_to_alloc;
2002 }
2003 }
2004
2005 /** Setup the input buffer state to scan directly from a user-specified character buffer.
2006 * @param base the character buffer
2007 * @param size the size in bytes of the character buffer
2008 * @param yyscanner The scanner object.
2009 * @return the newly allocated buffer state object.
2010 */
2011 YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size , yyscan_t yyscanner)
2012 {
2013 YY_BUFFER_STATE b;
2014
2015 if ( size < 2 ||
2016 base[size-2] != YY_END_OF_BUFFER_CHAR ||
2017 base[size-1] != YY_END_OF_BUFFER_CHAR )
2018 /* They forgot to leave room for the EOB's. */
2019 return 0;
2020
2021 b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) ,yyscanner );
2022 if ( ! b )
2023 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
2024
2025 b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
2026 b->yy_buf_pos = b->yy_ch_buf = base;
2027 b->yy_is_our_buffer = 0;
2028 b->yy_input_file = 0;
2029 b->yy_n_chars = b->yy_buf_size;
2030 b->yy_is_interactive = 0;
2031 b->yy_at_bol = 1;
2032 b->yy_fill_buffer = 0;
2033 b->yy_buffer_status = YY_BUFFER_NEW;
2034
2035 yy_switch_to_buffer(b ,yyscanner );
2036
2037 return b;
2038 }
2039
2040 /** Setup the input buffer state to scan a string. The next call to yylex() will
2041 * scan from a @e copy of @a str.
2042 * @param str a NUL-terminated string to scan
2043 * @param yyscanner The scanner object.
2044 * @return the newly allocated buffer state object.
2045 * @note If you want to scan bytes that may contain NUL values, then use
2046 * yy_scan_bytes() instead.
2047 */
2048 YY_BUFFER_STATE yy_scan_string (yyconst char * yy_str , yyscan_t yyscanner)
2049 {
2050
2051 return yy_scan_bytes(yy_str,strlen(yy_str) ,yyscanner);
2052 }
2053
2054 /** Setup the input buffer state to scan the given bytes. The next call to yylex() will
2055 * scan from a @e copy of @a bytes.
2056 * @param bytes the byte buffer to scan
2057 * @param len the number of bytes in the buffer pointed to by @a bytes.
2058 * @param yyscanner The scanner object.
2059 * @return the newly allocated buffer state object.
2060 */
2061 YY_BUFFER_STATE yy_scan_bytes (yyconst char * bytes, int len , yyscan_t yyscanner)
2062 {
2063 YY_BUFFER_STATE b;
2064 char *buf;
2065 yy_size_t n;
2066 int i;
2067
2068 /* Get memory for full buffer, including space for trailing EOB's. */
2069 n = len + 2;
2070 buf = (char *) yyalloc(n ,yyscanner );
2071 if ( ! buf )
2072 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
2073
2074 for ( i = 0; i < len; ++i )
2075 buf[i] = bytes[i];
2076
2077 buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
2078
2079 b = yy_scan_buffer(buf,n ,yyscanner);
2080 if ( ! b )
2081 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
2082
2083 /* It's okay to grow etc. this buffer, and we should throw it
2084 * away when we're done.
2085 */
2086 b->yy_is_our_buffer = 1;
2087
2088 return b;
2089 }
2090
2091 #ifndef YY_EXIT_FAILURE
2092 #define YY_EXIT_FAILURE 2
2093 #endif
2094
2095 static void yy_fatal_error (yyconst char* msg , yyscan_t yyscanner)
2096 {
2097 (void) fprintf( stderr, "%s\n", msg );
2098 exit( YY_EXIT_FAILURE );
2099 }
2100
2101 /* Redefine yyless() so it works in section 3 code. */
2102
2103 #undef yyless
2104 #define yyless(n) \
2105 do \
2106 { \
2107 /* Undo effects of setting up yytext. */ \
2108 int yyless_macro_arg = (n); \
2109 YY_LESS_LINENO(yyless_macro_arg);\
2110 yytext[yyleng] = yyg->yy_hold_char; \
2111 yyg->yy_c_buf_p = yytext + yyless_macro_arg; \
2112 yyg->yy_hold_char = *yyg->yy_c_buf_p; \
2113 *yyg->yy_c_buf_p = '\0'; \
2114 yyleng = yyless_macro_arg; \
2115 } \
2116 while ( 0 )
2117
2118 /* Accessor methods (get/set functions) to struct members. */
2119
2120 /** Get the user-defined data for this scanner.
2121 * @param yyscanner The scanner object.
2122 */
2123 YY_EXTRA_TYPE yyget_extra (yyscan_t yyscanner)
2124 {
2125 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2126 return yyextra;
2127 }
2128
2129 /** Get the current line number.
2130 * @param yyscanner The scanner object.
2131 */
2132 int yyget_lineno (yyscan_t yyscanner)
2133 {
2134 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2135
2136 if (! YY_CURRENT_BUFFER)
2137 return 0;
2138
2139 return yylineno;
2140 }
2141
2142 /** Get the current column number.
2143 * @param yyscanner The scanner object.
2144 */
2145 int yyget_column (yyscan_t yyscanner)
2146 {
2147 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2148
2149 if (! YY_CURRENT_BUFFER)
2150 return 0;
2151
2152 return yycolumn;
2153 }
2154
2155 /** Get the input stream.
2156 * @param yyscanner The scanner object.
2157 */
2158 FILE *yyget_in (yyscan_t yyscanner)
2159 {
2160 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2161 return yyin;
2162 }
2163
2164 /** Get the output stream.
2165 * @param yyscanner The scanner object.
2166 */
2167 FILE *yyget_out (yyscan_t yyscanner)
2168 {
2169 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2170 return yyout;
2171 }
2172
2173 /** Get the length of the current token.
2174 * @param yyscanner The scanner object.
2175 */
2176 int yyget_leng (yyscan_t yyscanner)
2177 {
2178 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2179 return yyleng;
2180 }
2181
2182 /** Get the current token.
2183 * @param yyscanner The scanner object.
2184 */
2185
2186 char *yyget_text (yyscan_t yyscanner)
2187 {
2188 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2189 return yytext;
2190 }
2191
2192 /** Set the user-defined data. This data is never touched by the scanner.
2193 * @param user_defined The data to be associated with this scanner.
2194 * @param yyscanner The scanner object.
2195 */
2196 void yyset_extra (YY_EXTRA_TYPE user_defined , yyscan_t yyscanner)
2197 {
2198 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2199 yyextra = user_defined ;
2200 }
2201
2202 /** Set the current line number.
2203 * @param line_number
2204 * @param yyscanner The scanner object.
2205 */
2206 void yyset_lineno (int line_number , yyscan_t yyscanner)
2207 {
2208 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2209
2210 /* lineno is only valid if an input buffer exists. */
2211 if (! YY_CURRENT_BUFFER )
2212 yy_fatal_error( "yyset_lineno called with no buffer" , yyscanner);
2213
2214 yylineno = line_number;
2215 }
2216
2217 /** Set the current column.
2218 * @param line_number
2219 * @param yyscanner The scanner object.
2220 */
2221 void yyset_column (int column_no , yyscan_t yyscanner)
2222 {
2223 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2224
2225 /* column is only valid if an input buffer exists. */
2226 if (! YY_CURRENT_BUFFER )
2227 yy_fatal_error( "yyset_column called with no buffer" , yyscanner);
2228
2229 yycolumn = column_no;
2230 }
2231
2232 /** Set the input stream. This does not discard the current
2233 * input buffer.
2234 * @param in_str A readable stream.
2235 * @param yyscanner The scanner object.
2236 * @see yy_switch_to_buffer
2237 */
2238 void yyset_in (FILE * in_str , yyscan_t yyscanner)
2239 {
2240 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2241 yyin = in_str ;
2242 }
2243
2244 void yyset_out (FILE * out_str , yyscan_t yyscanner)
2245 {
2246 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2247 yyout = out_str ;
2248 }
2249
2250 int yyget_debug (yyscan_t yyscanner)
2251 {
2252 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2253 return yy_flex_debug;
2254 }
2255
2256 void yyset_debug (int bdebug , yyscan_t yyscanner)
2257 {
2258 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2259 yy_flex_debug = bdebug ;
2260 }
2261
2262 /* Accessor methods for yylval and yylloc */
2263
2264 static int yy_init_globals (yyscan_t yyscanner)
2265 {
2266 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2267 /* Initialization is the same as for the non-reentrant scanner.
2268 This function is called once per scanner lifetime. */
2269
2270 yyg->yy_buffer_stack = 0;
2271 yyg->yy_buffer_stack_top = 0;
2272 yyg->yy_buffer_stack_max = 0;
2273 yyg->yy_c_buf_p = (char *) 0;
2274 yyg->yy_init = 1;
2275 yyg->yy_start = 0;
2276 yyg->yy_start_stack_ptr = 0;
2277 yyg->yy_start_stack_depth = 0;
2278 yyg->yy_start_stack = (int *) 0;
2279
2280 /* Defined in main.c */
2281 #ifdef YY_STDINIT
2282 yyin = stdin;
2283 yyout = stdout;
2284 #else
2285 yyin = (FILE *) 0;
2286 yyout = (FILE *) 0;
2287 #endif
2288
2289 /* For future reference: Set errno on error, since we are called by
2290 * yylex_init()
2291 */
2292 return 0;
2293 }
2294
2295 /* User-visible API */
2296
2297 /* yylex_init is special because it creates the scanner itself, so it is
2298 * the ONLY reentrant function that doesn't take the scanner as the last argument.
2299 * That's why we explicitly handle the declaration, instead of using our macros.
2300 */
2301
2302 int yylex_init(yyscan_t* ptr_yy_globals)
2303
2304 {
2305 if (ptr_yy_globals == NULL){
2306 errno = EINVAL;
2307 return 1;
2308 }
2309
2310 *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), NULL );
2311
2312 if (*ptr_yy_globals == NULL){
2313 errno = ENOMEM;
2314 return 1;
2315 }
2316
2317 memset(*ptr_yy_globals,0,sizeof(struct yyguts_t));
2318
2319 return yy_init_globals ( *ptr_yy_globals );
2320 }
2321
2322 /* yylex_destroy is for both reentrant and non-reentrant scanners. */
2323 int yylex_destroy (yyscan_t yyscanner)
2324 {
2325 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2326
2327 /* Pop the buffer stack, destroying each element. */
2328 while(YY_CURRENT_BUFFER){
2329 yy_delete_buffer(YY_CURRENT_BUFFER ,yyscanner );
2330 YY_CURRENT_BUFFER_LVALUE = NULL;
2331 yypop_buffer_state(yyscanner);
2332 }
2333
2334 /* Destroy the stack itself. */
2335 yyfree(yyg->yy_buffer_stack ,yyscanner);
2336 yyg->yy_buffer_stack = NULL;
2337
2338 /* Destroy the start condition stack. */
2339 yyfree(yyg->yy_start_stack ,yyscanner );
2340 yyg->yy_start_stack = NULL;
2341
2342 /* Destroy the main struct (reentrant only). */
2343 yyfree ( yyscanner , yyscanner );
2344 return 0;
2345 }
2346
2347 /*
2348 * Internal utility routines.
2349 */
2350
2351 #ifndef yytext_ptr
2352 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n , yyscan_t yyscanner)
2353 {
2354 register int i;
2355 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2356 for ( i = 0; i < n; ++i )
2357 s1[i] = s2[i];
2358 }
2359 #endif
2360
2361 #ifdef YY_NEED_STRLEN
2362 static int yy_flex_strlen (yyconst char * s , yyscan_t yyscanner)
2363 {
2364 register int n;
2365 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2366 for ( n = 0; s[n]; ++n )
2367 ;
2368
2369 return n;
2370 }
2371 #endif
2372
2373 void *yyalloc (yy_size_t size , yyscan_t yyscanner)
2374 {
2375 return (void *) malloc( size );
2376 }
2377
2378 void *yyrealloc (void * ptr, yy_size_t size , yyscan_t yyscanner)
2379 {
2380 /* The cast to (char *) in the following accommodates both
2381 * implementations that use char* generic pointers, and those
2382 * that use void* generic pointers. It works with the latter
2383 * because both ANSI C and C++ allow castless assignment from
2384 * any pointer type to void*, and deal with argument conversions
2385 * as though doing an assignment.
2386 */
2387 return (void *) realloc( (char *) ptr, size );
2388 }
2389
2390 void yyfree (void * ptr , yyscan_t yyscanner)
2391 {
2392 free( (char *) ptr ); /* see yyrealloc() for (char *) cast */
2393 }
2394
2395 #define YYTABLES_NAME "yytables"
2396
2397 #undef YY_NEW_FILE
2398 #undef YY_FLUSH_BUFFER
2399 #undef yy_set_bol
2400 #undef yy_new_buffer
2401 #undef yy_set_interactive
2402 #undef yytext_ptr
2403 #undef YY_DO_BEFORE_ACTION
2404
2405 #ifdef YY_DECL_IS_OURS
2406 #undef YY_DECL_IS_OURS
2407 #undef YY_DECL
2408 #endif
2409 #line 84 "lscp.l"
2410
2411
2412
2413 /**
2414 * We provide our own version of yywrap() so we don't have to link against
2415 * the lex library.
2416 */
2417 int yywrap(yyscan_t yyscanner) {
2418 return 1; // continue scanning
2419 }
2420
  ViewVC Help
Powered by ViewVC