/[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 143 - (hide annotations) (download)
Wed Jun 23 18:54:08 2004 UTC (19 years, 10 months ago) by capela
File size: 99946 byte(s) 
* SET CHANNEL AUDIO_OUTPUT_TYPE <chan> <driver> command is back!
  creates an audio output device instance of the given driver type
  ('Jack' or 'Alsa') with default parameters if none exists,
  otherwise it just picks the first available device and assign
  it to the intended sampler channel.

* The AudioOutputDevice class get's a new pure virtual method,
  Driver(), which is implemented on both of the existing inherited
  classes, AudioOutputDeviceAlsa and AudioOutputDeviceJack, with
  the sole purpose to return the driver type name as a String
  ('Alsa' and 'Jack', respectively).

* The quoting on the filename argument for the LOAD INSTRUMENT
  command has been made optional; you can have both ways, with
  single quotes or none, keeping compability with older LSCP
  specification.

* An additional sanity check is made on LOAD INSTRUMENT, whether
  the sampler channel has an audio output device assigned, thus
  preventing the server from crashing on instrument file load.

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