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