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