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