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

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

Parent Directory Parent Directory | Revision Log Revision Log

Revision 123 - (hide 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 schoenebeck 35
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 schoenebeck 111 typedef unsigned char YY_CHAR;
322 schoenebeck 35
323 schoenebeck 111 typedef yyconst struct yy_trans_info *yy_state_type;
324 schoenebeck 35
325     #define yytext_ptr yytext_r
326    
327 schoenebeck 111 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 schoenebeck 35
332 schoenebeck 111 /* 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 schoenebeck 35
342 schoenebeck 123 #define YY_NUM_RULES 45
343     #define YY_END_OF_BUFFER 46
344 schoenebeck 111 struct yy_trans_info
345     {
346     flex_int16_t yy_verify;
347     flex_int16_t yy_nxt;
348     };
349 schoenebeck 123 static yyconst struct yy_trans_info yy_transition[2068] =
350 schoenebeck 35 {
351 schoenebeck 123 { 0, 0 }, { 0,1812 }, { 0, 0 }, { 0,1810 }, { 1, 516 },
352 schoenebeck 111 { 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 schoenebeck 35
362 schoenebeck 111 { 47, 516 }, { 48, 538 }, { 49, 550 }, { 50, 550 }, { 51, 550 },
363     { 52, 550 }, { 53, 550 }, { 54, 550 }, { 55, 550 }, { 56, 550 },
364 schoenebeck 123 { 57, 550 }, { 58, 516 }, { 59, 516 }, { 60, 516 }, { 61, 528 },
365 schoenebeck 111 { 62, 516 }, { 63, 516 }, { 64, 516 }, { 65, 540 }, { 66, 542 },
366 schoenebeck 123 { 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 schoenebeck 111 { 87, 516 }, { 88, 516 }, { 89, 516 }, { 90, 516 }, { 91, 516 },
371     { 92, 516 }, { 93, 516 }, { 94, 516 }, { 95, 516 }, { 96, 516 },
372 schoenebeck 35
373 schoenebeck 111 { 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 schoenebeck 35
384 schoenebeck 111 { 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 schoenebeck 35
395 schoenebeck 111 { 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 schoenebeck 35
406 schoenebeck 111 { 247, 516 }, { 248, 516 }, { 249, 516 }, { 250, 516 }, { 251, 516 },
407     { 252, 516 }, { 253, 516 }, { 254, 516 }, { 255, 516 }, { 256, 516 },
408 schoenebeck 123 { 0, 0 }, { 0,1552 }, { 1, 258 }, { 2, 258 }, { 3, 258 },
409 schoenebeck 111 { 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 schoenebeck 35
417 schoenebeck 111 { 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 schoenebeck 123 { 59, 258 }, { 60, 258 }, { 61, 270 }, { 62, 258 }, { 63, 258 },
422     { 64, 258 }, { 65, 282 }, { 66, 284 }, { 67, 288 }, { 68, 290 },
423 schoenebeck 111 { 69, 294 }, { 70, 258 }, { 71, 296 }, { 72, 258 }, { 73, 298 },
424 schoenebeck 123 { 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 schoenebeck 35
428 schoenebeck 111 { 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 schoenebeck 35
439 schoenebeck 111 { 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 schoenebeck 35
450 schoenebeck 111 { 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 schoenebeck 35
461 schoenebeck 111 { 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 schoenebeck 123 { 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 schoenebeck 111 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
469 schoenebeck 123 { 0, 43 }, { 0,1272 }, { 0, 44 }, { 0,1270 }, { 0, 44 },
470     { 0,1268 }, { 0, 0 }, { 0, 0 }, { 0, 44 }, { 0,1264 },
471 schoenebeck 35
472 schoenebeck 123 { 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 schoenebeck 35
483 schoenebeck 123 { 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 schoenebeck 35
494 schoenebeck 123 { 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 schoenebeck 111 { 48, 0 }, { 49, 0 }, { 50, 0 }, { 51, 0 }, { 52, 0 },
498     { 53, 0 }, { 54, 0 }, { 55, 0 }, { 56, 0 }, { 57, 0 },
499 schoenebeck 123 { 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 schoenebeck 35
505 schoenebeck 123 { 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 schoenebeck 35
516 schoenebeck 123 { 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 schoenebeck 35
527 schoenebeck 123 { 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 schoenebeck 35
538 schoenebeck 123 { 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 schoenebeck 111 { 0, 0 }, { 0, 712 }, { 0, 0 }, { 0, 710 }, { 0, 0 },
594 schoenebeck 123 { 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 schoenebeck 111 { 0, 0 }, { 0, 692 }, { 0, 0 }, { 0, 690 }, { 0, 0 },
598 schoenebeck 123 { 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 schoenebeck 35
604 schoenebeck 123 { 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 schoenebeck 35
615 schoenebeck 123 { 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 schoenebeck 35
626 schoenebeck 123 { 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 schoenebeck 35
637 schoenebeck 123 { 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 schoenebeck 35
648 schoenebeck 123 { 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 schoenebeck 35
659 schoenebeck 123 { 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 schoenebeck 35
670 schoenebeck 123 { 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 schoenebeck 35
681 schoenebeck 123 { 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 schoenebeck 35
692 schoenebeck 123 { 0, 0 }, { 73, 24 }, { 0, 34 }, { 0, 260 }, { 0, 20 },
693     { 0, 258 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
694 schoenebeck 111 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
695 schoenebeck 123 { 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 schoenebeck 111 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
701 schoenebeck 123 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
702 schoenebeck 35
703 schoenebeck 111 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
704 schoenebeck 123 { 0, 0 }, { 0, 0 }, { 82, 9 }, { 0, 0 }, { 82, 9 },
705     { 0, 0 }, { 82, 15 }, { 0, 0 }, { 0, 0 }, { 82, 21 },
706 schoenebeck 111 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
707     { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
708 schoenebeck 123 { 0, 0 }, { 0, 0 }, { 83, 11 }, { 0, 0 }, { 0, 0 },
709 schoenebeck 111 { 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 schoenebeck 35
714 schoenebeck 111 { 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 schoenebeck 35
725 schoenebeck 111 { 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 schoenebeck 35
736 schoenebeck 111 { 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 schoenebeck 123 { 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 schoenebeck 35
747 schoenebeck 123 { 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 schoenebeck 111 static yyconst struct yy_trans_info *yy_start_state_list[3] =
752 schoenebeck 35 {
753 schoenebeck 111 &yy_transition[1],
754     &yy_transition[3],
755     &yy_transition[261],
756 schoenebeck 35
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 schoenebeck 61 * Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck *
772 schoenebeck 35 * *
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 schoenebeck 123 #line 797 "lex.yy.c"
797 schoenebeck 35
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 schoenebeck 123 #line 999 "lex.yy.c"
999 schoenebeck 35
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 schoenebeck 111 yy_current_state = yy_start_state_list[yyg->yy_start];
1039 schoenebeck 35 yy_match:
1040 schoenebeck 111 {
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 schoenebeck 35 {
1050 schoenebeck 111 yy_current_state += yy_trans_info->yy_nxt;
1051    
1052     if ( yy_current_state[-1].yy_nxt )
1053 schoenebeck 35 {
1054     yyg->yy_last_accepting_state = yy_current_state;
1055     yyg->yy_last_accepting_cpos = yy_cp;
1056     }
1057     }
1058 schoenebeck 111 }
1059 schoenebeck 35
1060     yy_find_action:
1061 schoenebeck 111 yy_act = yy_current_state[-1].yy_nxt;
1062 schoenebeck 35
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 schoenebeck 111 { return HASH; }
1096 schoenebeck 35 YY_BREAK
1097     case 5:
1098     YY_RULE_SETUP
1099     #line 43 "lscp.l"
1100 schoenebeck 123 { return EQ; }
1101 schoenebeck 35 YY_BREAK
1102     case 6:
1103     YY_RULE_SETUP
1104     #line 44 "lscp.l"
1105 schoenebeck 123 { yylval->Dotnum = atof(yytext); return DOTNUM; }
1106 schoenebeck 35 YY_BREAK
1107     case 7:
1108     YY_RULE_SETUP
1109     #line 45 "lscp.l"
1110 schoenebeck 123 { return ADD; }
1111 schoenebeck 35 YY_BREAK
1112     case 8:
1113     YY_RULE_SETUP
1114     #line 46 "lscp.l"
1115 schoenebeck 123 { return GET; }
1116 schoenebeck 35 YY_BREAK
1117     case 9:
1118     YY_RULE_SETUP
1119     #line 47 "lscp.l"
1120 schoenebeck 123 { return CREATE; }
1121 schoenebeck 35 YY_BREAK
1122     case 10:
1123     YY_RULE_SETUP
1124     #line 48 "lscp.l"
1125 schoenebeck 123 { return DESTROY; }
1126 schoenebeck 35 YY_BREAK
1127     case 11:
1128     YY_RULE_SETUP
1129     #line 49 "lscp.l"
1130 schoenebeck 123 { return LIST; }
1131 schoenebeck 35 YY_BREAK
1132     case 12:
1133     YY_RULE_SETUP
1134     #line 50 "lscp.l"
1135 schoenebeck 123 { return LOAD; }
1136 schoenebeck 35 YY_BREAK
1137     case 13:
1138     YY_RULE_SETUP
1139     #line 51 "lscp.l"
1140 schoenebeck 123 { return REMOVE; }
1141 schoenebeck 35 YY_BREAK
1142     case 14:
1143     YY_RULE_SETUP
1144     #line 52 "lscp.l"
1145 schoenebeck 123 { return SET; }
1146 schoenebeck 35 YY_BREAK
1147     case 15:
1148     YY_RULE_SETUP
1149     #line 53 "lscp.l"
1150 schoenebeck 123 { return SUBSCRIBE; }
1151 schoenebeck 35 YY_BREAK
1152     case 16:
1153     YY_RULE_SETUP
1154     #line 54 "lscp.l"
1155 schoenebeck 123 { return UNSUBSCRIBE; }
1156 schoenebeck 35 YY_BREAK
1157     case 17:
1158     YY_RULE_SETUP
1159     #line 55 "lscp.l"
1160 schoenebeck 123 { return CHANNEL; }
1161 schoenebeck 35 YY_BREAK
1162     case 18:
1163     YY_RULE_SETUP
1164     #line 56 "lscp.l"
1165 schoenebeck 123 { return NOTIFICATION; }
1166 schoenebeck 35 YY_BREAK
1167     case 19:
1168     YY_RULE_SETUP
1169     #line 57 "lscp.l"
1170 schoenebeck 123 { return AVAILABLE_ENGINES; }
1171 schoenebeck 35 YY_BREAK
1172     case 20:
1173     YY_RULE_SETUP
1174     #line 58 "lscp.l"
1175 schoenebeck 123 { return AVAILABLE_AUDIO_OUTPUT_DRIVERS; }
1176 schoenebeck 35 YY_BREAK
1177     case 21:
1178     YY_RULE_SETUP
1179     #line 59 "lscp.l"
1180 schoenebeck 123 { return CHANNELS; }
1181 schoenebeck 35 YY_BREAK
1182     case 22:
1183     YY_RULE_SETUP
1184     #line 60 "lscp.l"
1185 schoenebeck 123 { return INFO; }
1186 schoenebeck 35 YY_BREAK
1187     case 23:
1188     YY_RULE_SETUP
1189     #line 61 "lscp.l"
1190 schoenebeck 123 { return BUFFER_FILL; }
1191 schoenebeck 35 YY_BREAK
1192     case 24:
1193     YY_RULE_SETUP
1194     #line 62 "lscp.l"
1195 schoenebeck 123 { return STREAM_COUNT; }
1196 schoenebeck 35 YY_BREAK
1197     case 25:
1198     YY_RULE_SETUP
1199     #line 63 "lscp.l"
1200 schoenebeck 123 { return VOICE_COUNT; }
1201 schoenebeck 35 YY_BREAK
1202     case 26:
1203     YY_RULE_SETUP
1204     #line 64 "lscp.l"
1205 schoenebeck 123 { return INSTRUMENT; }
1206 schoenebeck 35 YY_BREAK
1207     case 27:
1208     YY_RULE_SETUP
1209     #line 65 "lscp.l"
1210 schoenebeck 123 { return ENGINE; }
1211 schoenebeck 35 YY_BREAK
1212     case 28:
1213     YY_RULE_SETUP
1214     #line 66 "lscp.l"
1215 schoenebeck 123 { return AUDIO_OUTPUT_DEVICE; }
1216 schoenebeck 35 YY_BREAK
1217     case 29:
1218     YY_RULE_SETUP
1219     #line 67 "lscp.l"
1220 schoenebeck 123 { return AUDIO_OUTPUT_DEVICES; }
1221 schoenebeck 35 YY_BREAK
1222     case 30:
1223     YY_RULE_SETUP
1224     #line 68 "lscp.l"
1225 schoenebeck 123 { return AUDIO_OUTPUT_DEVICE_PARAMETER; }
1226 schoenebeck 35 YY_BREAK
1227     case 31:
1228     YY_RULE_SETUP
1229     #line 69 "lscp.l"
1230 schoenebeck 123 { return AUDIO_OUTPUT_DRIVER; }
1231 schoenebeck 35 YY_BREAK
1232     case 32:
1233     YY_RULE_SETUP
1234     #line 70 "lscp.l"
1235 schoenebeck 123 { return AUDIO_OUTPUT_DRIVER_PARAMETER; }
1236 schoenebeck 35 YY_BREAK
1237     case 33:
1238     YY_RULE_SETUP
1239     #line 71 "lscp.l"
1240 schoenebeck 123 { return AUDIO_OUTPUT_CHANNEL; }
1241 schoenebeck 35 YY_BREAK
1242     case 34:
1243     YY_RULE_SETUP
1244     #line 72 "lscp.l"
1245 schoenebeck 123 { return AUDIO_OUTPUT_CHANNEL_PARAMETER; }
1246 schoenebeck 35 YY_BREAK
1247     case 35:
1248     YY_RULE_SETUP
1249     #line 73 "lscp.l"
1250 schoenebeck 123 { return MIDI_INPUT_PORT; }
1251 schoenebeck 35 YY_BREAK
1252     case 36:
1253     YY_RULE_SETUP
1254 schoenebeck 111 #line 74 "lscp.l"
1255 schoenebeck 123 { return MIDI_INPUT_CHANNEL; }
1256 schoenebeck 111 YY_BREAK
1257     case 37:
1258     YY_RULE_SETUP
1259 schoenebeck 123 #line 75 "lscp.l"
1260     { return MIDI_INPUT_TYPE; }
1261     YY_BREAK
1262     case 38:
1263     YY_RULE_SETUP
1264 schoenebeck 111 #line 76 "lscp.l"
1265 schoenebeck 123 { 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 schoenebeck 35 ECHO;
1301     YY_BREAK
1302 schoenebeck 123 #line 1303 "lex.yy.c"
1303 schoenebeck 35 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 schoenebeck 111 yy_current_state = yy_start_state_list[yyg->yy_start];
1576 schoenebeck 35
1577     for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
1578     {
1579 schoenebeck 111 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 schoenebeck 35 {
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 schoenebeck 111 register int yy_c = 256;
1602     register yyconst struct yy_trans_info *yy_trans_info;
1603 schoenebeck 35
1604 schoenebeck 111 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 schoenebeck 35 if ( ! yy_is_jam )
1609     {
1610 schoenebeck 111 if ( yy_current_state[-1].yy_nxt )
1611 schoenebeck 35 {
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 schoenebeck 123 #line 84 "lscp.l"
2410 schoenebeck 35
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