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