add 'Selective download'
[claws.git] / src / matcher_parser_lex.c
1 #define yy_create_buffer matcher_parser_create_buffer
2 #define yy_delete_buffer matcher_parser_delete_buffer
3 #define yy_scan_buffer matcher_parser_scan_buffer
4 #define yy_scan_string matcher_parser_scan_string
5 #define yy_scan_bytes matcher_parser_scan_bytes
6 #define yy_flex_debug matcher_parser_flex_debug
7 #define yy_init_buffer matcher_parser_init_buffer
8 #define yy_flush_buffer matcher_parser_flush_buffer
9 #define yy_load_buffer_state matcher_parser_load_buffer_state
10 #define yy_switch_to_buffer matcher_parser_switch_to_buffer
11 #define yyin matcher_parserin
12 #define yyleng matcher_parserleng
13 #define yylex matcher_parserlex
14 #define yyout matcher_parserout
15 #define yyrestart matcher_parserrestart
16 #define yytext matcher_parsertext
17 #define yylineno matcher_parserlineno
18 #define yywrap matcher_parserwrap
19
20 #line 21 "lex.yy.c"
21 /* A lexical scanner generated by flex */
22
23 /* Scanner skeleton version:
24  * $Header$
25  */
26
27 #define FLEX_SCANNER
28 #define YY_FLEX_MAJOR_VERSION 2
29 #define YY_FLEX_MINOR_VERSION 5
30
31 #include <stdio.h>
32 #include <unistd.h>
33
34
35 /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
36 #ifdef c_plusplus
37 #ifndef __cplusplus
38 #define __cplusplus
39 #endif
40 #endif
41
42
43 #ifdef __cplusplus
44
45 #include <stdlib.h>
46
47 /* Use prototypes in function declarations. */
48 #define YY_USE_PROTOS
49
50 /* The "const" storage-class-modifier is valid. */
51 #define YY_USE_CONST
52
53 #else   /* ! __cplusplus */
54
55 #if __STDC__
56
57 #define YY_USE_PROTOS
58 #define YY_USE_CONST
59
60 #endif  /* __STDC__ */
61 #endif  /* ! __cplusplus */
62
63 #ifdef __TURBOC__
64  #pragma warn -rch
65  #pragma warn -use
66 #include <io.h>
67 #include <stdlib.h>
68 #define YY_USE_CONST
69 #define YY_USE_PROTOS
70 #endif
71
72 #ifdef YY_USE_CONST
73 #define yyconst const
74 #else
75 #define yyconst
76 #endif
77
78
79 #ifdef YY_USE_PROTOS
80 #define YY_PROTO(proto) proto
81 #else
82 #define YY_PROTO(proto) ()
83 #endif
84
85 /* Returned upon end-of-file. */
86 #define YY_NULL 0
87
88 /* Promotes a possibly negative, possibly signed char to an unsigned
89  * integer for use as an array index.  If the signed char is negative,
90  * we want to instead treat it as an 8-bit unsigned char, hence the
91  * double cast.
92  */
93 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
94
95 /* Enter a start condition.  This macro really ought to take a parameter,
96  * but we do it the disgusting crufty way forced on us by the ()-less
97  * definition of BEGIN.
98  */
99 #define BEGIN yy_start = 1 + 2 *
100
101 /* Translate the current start state into a value that can be later handed
102  * to BEGIN to return to the state.  The YYSTATE alias is for lex
103  * compatibility.
104  */
105 #define YY_START ((yy_start - 1) / 2)
106 #define YYSTATE YY_START
107
108 /* Action number for EOF rule of a given start state. */
109 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
110
111 /* Special action meaning "start processing a new file". */
112 #define YY_NEW_FILE yyrestart( yyin )
113
114 #define YY_END_OF_BUFFER_CHAR 0
115
116 /* Size of default input buffer. */
117 #define YY_BUF_SIZE 16384
118
119 typedef struct yy_buffer_state *YY_BUFFER_STATE;
120
121 extern int yyleng;
122 extern FILE *yyin, *yyout;
123
124 #define EOB_ACT_CONTINUE_SCAN 0
125 #define EOB_ACT_END_OF_FILE 1
126 #define EOB_ACT_LAST_MATCH 2
127
128 /* The funky do-while in the following #define is used to turn the definition
129  * int a single C statement (which needs a semi-colon terminator).  This
130  * avoids problems with code like:
131  *
132  *      if ( condition_holds )
133  *              yyless( 5 );
134  *      else
135  *              do_something_else();
136  *
137  * Prior to using the do-while the compiler would get upset at the
138  * "else" because it interpreted the "if" statement as being all
139  * done when it reached the ';' after the yyless() call.
140  */
141
142 /* Return all but the first 'n' matched characters back to the input stream. */
143
144 #define yyless(n) \
145         do \
146                 { \
147                 /* Undo effects of setting up yytext. */ \
148                 *yy_cp = yy_hold_char; \
149                 YY_RESTORE_YY_MORE_OFFSET \
150                 yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
151                 YY_DO_BEFORE_ACTION; /* set up yytext again */ \
152                 } \
153         while ( 0 )
154
155 #define unput(c) yyunput( c, yytext_ptr )
156
157 /* The following is because we cannot portably get our hands on size_t
158  * (without autoconf's help, which isn't available because we want
159  * flex-generated scanners to compile on their own).
160  */
161 typedef unsigned int yy_size_t;
162
163
164 struct yy_buffer_state
165         {
166         FILE *yy_input_file;
167
168         char *yy_ch_buf;                /* input buffer */
169         char *yy_buf_pos;               /* current position in input buffer */
170
171         /* Size of input buffer in bytes, not including room for EOB
172          * characters.
173          */
174         yy_size_t yy_buf_size;
175
176         /* Number of characters read into yy_ch_buf, not including EOB
177          * characters.
178          */
179         int yy_n_chars;
180
181         /* Whether we "own" the buffer - i.e., we know we created it,
182          * and can realloc() it to grow it, and should free() it to
183          * delete it.
184          */
185         int yy_is_our_buffer;
186
187         /* Whether this is an "interactive" input source; if so, and
188          * if we're using stdio for input, then we want to use getc()
189          * instead of fread(), to make sure we stop fetching input after
190          * each newline.
191          */
192         int yy_is_interactive;
193
194         /* Whether we're considered to be at the beginning of a line.
195          * If so, '^' rules will be active on the next match, otherwise
196          * not.
197          */
198         int yy_at_bol;
199
200         /* Whether to try to fill the input buffer when we reach the
201          * end of it.
202          */
203         int yy_fill_buffer;
204
205         int yy_buffer_status;
206 #define YY_BUFFER_NEW 0
207 #define YY_BUFFER_NORMAL 1
208         /* When an EOF's been seen but there's still some text to process
209          * then we mark the buffer as YY_EOF_PENDING, to indicate that we
210          * shouldn't try reading from the input source any more.  We might
211          * still have a bunch of tokens to match, though, because of
212          * possible backing-up.
213          *
214          * When we actually see the EOF, we change the status to "new"
215          * (via yyrestart()), so that the user can continue scanning by
216          * just pointing yyin at a new input file.
217          */
218 #define YY_BUFFER_EOF_PENDING 2
219         };
220
221 static YY_BUFFER_STATE yy_current_buffer = 0;
222
223 /* We provide macros for accessing buffer states in case in the
224  * future we want to put the buffer states in a more general
225  * "scanner state".
226  */
227 #define YY_CURRENT_BUFFER yy_current_buffer
228
229
230 /* yy_hold_char holds the character lost when yytext is formed. */
231 static char yy_hold_char;
232
233 static int yy_n_chars;          /* number of characters read into yy_ch_buf */
234
235
236 int yyleng;
237
238 /* Points to current character in buffer. */
239 static char *yy_c_buf_p = (char *) 0;
240 static int yy_init = 1;         /* whether we need to initialize */
241 static int yy_start = 0;        /* start state number */
242
243 /* Flag which is used to allow yywrap()'s to do buffer switches
244  * instead of setting up a fresh yyin.  A bit of a hack ...
245  */
246 static int yy_did_buffer_switch_on_eof;
247
248 void yyrestart YY_PROTO(( FILE *input_file ));
249
250 void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
251 void yy_load_buffer_state YY_PROTO(( void ));
252 YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
253 void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
254 void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
255 void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
256 #define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
257
258 YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
259 YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str ));
260 YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
261
262 static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
263 static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));
264 static void yy_flex_free YY_PROTO(( void * ));
265
266 #define yy_new_buffer yy_create_buffer
267
268 #define yy_set_interactive(is_interactive) \
269         { \
270         if ( ! yy_current_buffer ) \
271                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
272         yy_current_buffer->yy_is_interactive = is_interactive; \
273         }
274
275 #define yy_set_bol(at_bol) \
276         { \
277         if ( ! yy_current_buffer ) \
278                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
279         yy_current_buffer->yy_at_bol = at_bol; \
280         }
281
282 #define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
283
284
285 #define YY_USES_REJECT
286 typedef unsigned char YY_CHAR;
287 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
288 typedef int yy_state_type;
289 extern int yylineno;
290 int yylineno = 1;
291 extern char *yytext;
292 #define yytext_ptr yytext
293
294 static yy_state_type yy_get_previous_state YY_PROTO(( void ));
295 static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
296 static int yy_get_next_buffer YY_PROTO(( void ));
297 static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
298
299 /* Done after the current pattern has been matched and before the
300  * corresponding action - sets up yytext.
301  */
302 #define YY_DO_BEFORE_ACTION \
303         yytext_ptr = yy_bp; \
304         yyleng = (int) (yy_cp - yy_bp); \
305         yy_hold_char = *yy_cp; \
306         *yy_cp = '\0'; \
307         yy_c_buf_p = yy_cp;
308
309 #define YY_NUM_RULES 72
310 #define YY_END_OF_BUFFER 73
311 static yyconst short int yy_acclist[104] =
312     {   0,
313        73,   72,   62,   72,   63,   72,   66,   72,   64,   72,
314        72,   71,   72,   72,   72,   72,   72,   72,   72,   72,
315        72,   72,   72,   72,   72,   72,   72,   72,   65,   72,
316        72,   69,   72,   68,   69,   72,   69,   72,   62,   71,
317        70,   20,   18,   67,    1,    4,   21,   19,   51,   16,
318        53,   50,    5,   59,   46,   49,   17,   60,   52,   35,
319         6,   48,   54,    2,    8,   43,   57,   39,   10,   14,
320        36,    7,    3,   22,    9,   44,   40,   11,   15,   25,
321        41,   12,   28,   45,   23,   26,   30,   47,   42,   13,
322        29,   24,   34,   33,   27,   31,   37,   55,   32,   38,
323
324        56,   61,   58
325     } ;
326
327 static yyconst short int yy_accept[370] =
328     {   0,
329         1,    1,    1,    1,    1,    1,    1,    2,    3,    5,
330         7,    9,   11,   12,   14,   15,   16,   17,   18,   19,
331        20,   21,   22,   23,   24,   25,   26,   27,   28,   29,
332        31,   32,   34,   37,   39,   40,   41,   41,   42,   42,
333        42,   42,   43,   43,   43,   43,   43,   43,   43,   43,
334        43,   43,   43,   43,   43,   43,   43,   44,   44,   44,
335        44,   44,   44,   44,   44,   44,   44,   44,   44,   44,
336        44,   44,   45,   45,   46,   46,   46,   46,   46,   46,
337        46,   46,   46,   46,   46,   46,   46,   46,   46,   47,
338        47,   47,   47,   47,   47,   47,   47,   47,   47,   48,
339
340        48,   48,   48,   48,   48,   48,   48,   48,   48,   48,
341        48,   49,   49,   49,   49,   49,   49,   50,   50,   50,
342        50,   51,   51,   51,   52,   52,   52,   53,   53,   53,
343        53,   53,   53,   53,   53,   53,   53,   53,   53,   53,
344        53,   53,   53,   53,   53,   53,   54,   54,   54,   54,
345        54,   54,   54,   54,   54,   54,   55,   55,   55,   55,
346        55,   55,   55,   55,   56,   56,   56,   56,   56,   56,
347        57,   57,   57,   57,   57,   57,   57,   57,   57,   58,
348        58,   58,   58,   58,   58,   58,   58,   58,   58,   58,
349        58,   58,   58,   59,   60,   60,   60,   61,   61,   61,
350
351        62,   62,   62,   62,   62,   63,   63,   63,   63,   63,
352        64,   65,   65,   65,   65,   65,   65,   65,   65,   65,
353        65,   65,   65,   65,   65,   65,   65,   65,   65,   65,
354        66,   67,   68,   68,   68,   68,   68,   69,   69,   69,
355        69,   70,   70,   70,   70,   71,   71,   71,   71,   71,
356        71,   72,   72,   73,   73,   73,   73,   73,   73,   73,
357        74,   74,   74,   74,   74,   74,   74,   74,   74,   74,
358        74,   74,   74,   74,   74,   74,   74,   75,   75,   76,
359        77,   77,   77,   77,   78,   78,   78,   79,   80,   80,
360        80,   81,   82,   82,   82,   83,   83,   84,   84,   84,
361
362        85,   85,   85,   85,   85,   85,   85,   85,   85,   85,
363        85,   85,   85,   86,   86,   86,   86,   86,   86,   86,
364        87,   88,   89,   89,   89,   89,   90,   91,   91,   92,
365        92,   92,   93,   93,   93,   93,   93,   93,   94,   94,
366        95,   95,   96,   97,   97,   97,   98,   99,   99,   99,
367        99,   99,   99,   99,  100,  101,  101,  101,  102,  102,
368       102,  103,  103,  103,  103,  103,  103,  104,  104
369     } ;
370
371 static yyconst int yy_ec[256] =
372     {   0,
373         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
374         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
375         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
376         1,    2,    1,    4,    1,    1,    1,    5,    1,    1,
377         1,    1,    6,    1,    6,    1,    1,    7,    7,    7,
378         7,    7,    7,    7,    7,    7,    7,    1,    1,    1,
379         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
380         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
381         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
382         8,    9,   10,    1,   11,    1,   12,   13,   14,   15,
383
384        16,   17,   18,   19,   20,   21,   22,   23,   24,   25,
385        26,   27,   28,   29,   30,   31,   32,   33,   34,   35,
386        36,    1,    1,   37,    1,   38,    1,    1,    1,    1,
387         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
388         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
389         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
390         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
391         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
392         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
393         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
394
395         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
396         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
397         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
398         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
399         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
400         1,    1,    1,    1,    1
401     } ;
402
403 static yyconst int yy_meta[39] =
404     {   0,
405         1,    1,    1,    1,    1,    1,    1,    2,    1,    1,
406         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
407         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
408         1,    1,    1,    1,    1,    1,    1,    1
409     } ;
410
411 static yyconst short int yy_base[372] =
412     {   0,
413         0,    0,   36,   38,    0,    0,  386,  387,  383,  387,
414       387,  387,  377,  376,  372,   25,  355,   30,  364,  344,
415        20,  362,  352,   38,  360,  359,   37,  348,  348,  387,
416        57,  387,  387,  368,  369,  363,  359,  387,  352,  344,
417        43,  387,   30,  343,  349,  335,  337,  350,  332,   30,
418       330,  326,  324,   66,  331,  343,  344,   31,  328,  339,
419       336,  316,   36,  334,  324,   51,  332,  331,  314,  319,
420       319,  387,  332,  387,  306,  316,  314,  303,  322,  323,
421       302,  311,  319,  317,  310,  317,  300,  313,  298,  311,
422       310,  302,  295,  302,  296,  309,  304,  304,  387,  295,
423
424       301,  287,  289,  302,  284,  283,  281,  276,   51,  296,
425       297,  278,   62,  295,  291,  275,  387,  272,  270,  289,
426       387,  284,  272,   79,  279,  285,  387,  278,  266,  259,
427       273,  276,  275,  261,  260,  276,  251,  270,  271,  250,
428       259,  267,  265,  258,  249,  248,  261,  253,  254,  248,
429       257,  243,  245,  243,  253,  387,  252,  236,  237,  236,
430       241,  251,  247,  247,  242,  230,  242,  230,  240,  244,
431       240,  242,  230,  236,  239,  218,  216,  235,  387,  230,
432       218,  228,  231,  224,  212,  220,  223,  209,  225,  220,
433       201,  222,  387,   81,  217,  217,  201,  194,  199,  387,
434
435       216,  211,  200,  200,  210,  208,   81,  191,  207,  387,
436       387,  193,  203,  187,  188,  187,  192,  199,  195,  183,
437       195,  194,  195,  197,  192,  194,  189,  175,  177,  387,
438       387,   87,  191,  170,  189,  169,  387,  166,  183,  184,
439       387,  167,  165,  167,  387,  178,  179,  175,  173,  173,
440       157,  150,  387,  169,  158,  158,  167,  150,  166,  387,
441       148,  149,  146,  151,  163,  159,  146,  146,   62,  155,
442       143,  153,  138,  135,  150,  131,  387,  135,  387,  387,
443       147,  151,  130,  387,  128,  145,  387,  387,  144,  141,
444       387,  387,  145,  125,  387,  142,  387,  137,  127,  387,
445
446       121,  120,  133,  136,  135,  130,  114,  129,  116,  116,
447       114,  124,  387,  110,  108,  126,  107,  123,  105,  387,
448       387,  387,  110,  101,  102,  387,  387,  118,  387,   99,
449        98,  387,  111,  114,   94,  109,  107,  387,  106,  387,
450        92,  387,  387,   91,   88,  387,  387,  106,   88,   85,
451        82,   83,   98,  387,  387,   96,   99,  387,   81,   95,
452       387,   83,   77,   84,   54,   35,  387,  387,  104,  106,
453        51
454     } ;
455
456 static yyconst short int yy_def[372] =
457     {   0,
458       368,    1,  369,  369,  370,  370,  368,  368,  368,  368,
459       368,  368,  368,  368,  371,  368,  368,  368,  368,  368,
460       368,  368,  368,  368,  368,  368,  368,  368,  368,  368,
461       368,  368,  368,  368,  368,  368,  371,  368,  368,  368,
462       368,  368,  368,  368,  368,  368,  368,  368,  368,  368,
463       368,  368,  368,  368,  368,  368,  368,  368,  368,  368,
464       368,  368,  368,  368,  368,  368,  368,  368,  368,  368,
465       368,  368,  368,  368,  368,  368,  368,  368,  368,  368,
466       368,  368,  368,  368,  368,  368,  368,  368,  368,  368,
467       368,  368,  368,  368,  368,  368,  368,  368,  368,  368,
468
469       368,  368,  368,  368,  368,  368,  368,  368,  368,  368,
470       368,  368,  368,  368,  368,  368,  368,  368,  368,  368,
471       368,  368,  368,  368,  368,  368,  368,  368,  368,  368,
472       368,  368,  368,  368,  368,  368,  368,  368,  368,  368,
473       368,  368,  368,  368,  368,  368,  368,  368,  368,  368,
474       368,  368,  368,  368,  368,  368,  368,  368,  368,  368,
475       368,  368,  368,  368,  368,  368,  368,  368,  368,  368,
476       368,  368,  368,  368,  368,  368,  368,  368,  368,  368,
477       368,  368,  368,  368,  368,  368,  368,  368,  368,  368,
478       368,  368,  368,  368,  368,  368,  368,  368,  368,  368,
479
480       368,  368,  368,  368,  368,  368,  368,  368,  368,  368,
481       368,  368,  368,  368,  368,  368,  368,  368,  368,  368,
482       368,  368,  368,  368,  368,  368,  368,  368,  368,  368,
483       368,  368,  368,  368,  368,  368,  368,  368,  368,  368,
484       368,  368,  368,  368,  368,  368,  368,  368,  368,  368,
485       368,  368,  368,  368,  368,  368,  368,  368,  368,  368,
486       368,  368,  368,  368,  368,  368,  368,  368,  368,  368,
487       368,  368,  368,  368,  368,  368,  368,  368,  368,  368,
488       368,  368,  368,  368,  368,  368,  368,  368,  368,  368,
489       368,  368,  368,  368,  368,  368,  368,  368,  368,  368,
490
491       368,  368,  368,  368,  368,  368,  368,  368,  368,  368,
492       368,  368,  368,  368,  368,  368,  368,  368,  368,  368,
493       368,  368,  368,  368,  368,  368,  368,  368,  368,  368,
494       368,  368,  368,  368,  368,  368,  368,  368,  368,  368,
495       368,  368,  368,  368,  368,  368,  368,  368,  368,  368,
496       368,  368,  368,  368,  368,  368,  368,  368,  368,  368,
497       368,  368,  368,  368,  368,  368,  368,    0,  368,  368,
498       368
499     } ;
500
501 static yyconst short int yy_nxt[426] =
502     {   0,
503         8,    9,   10,   11,   12,   13,   14,   15,    8,    8,
504         8,   16,   17,   18,   19,   20,   21,    8,   22,   23,
505         8,    8,    8,   24,   25,    8,    8,    8,   26,   27,
506        28,   29,    8,    8,    8,    8,   30,   31,    8,   33,
507         8,   33,   39,   42,   34,   46,   34,   40,   47,   50,
508        55,   37,   77,   51,   96,   43,   78,   75,   85,   97,
509        86,  102,  106,   52,  103,  367,  107,  147,   56,   59,
510        60,   61,   62,   63,   76,   64,   65,  148,  366,  152,
511        66,   67,   90,   91,  153,   68,   69,   70,   71,  162,
512       298,  229,   92,  299,  163,  230,  242,  265,  243,  365,
513
514       364,  363,  266,  244,   32,   32,    8,    8,  362,  361,
515       360,  359,  358,  357,  356,  355,  354,  353,  352,  351,
516       350,  349,  348,  347,  346,  345,  344,  343,  342,  341,
517       340,  339,  338,  337,  336,  335,  334,  333,  332,  331,
518       330,  329,  328,  327,  326,  325,  324,  323,  322,  321,
519       320,  319,  318,  317,  316,  315,  314,  313,  312,  311,
520       310,  309,  308,  307,  306,  305,  304,  303,  302,  301,
521       300,  297,  296,  295,  294,  293,  292,  291,  290,  289,
522       288,  287,  286,  285,  284,  283,  282,  281,  280,  279,
523       278,  277,  276,  275,  274,  273,  272,  271,  270,  269,
524
525       268,  267,  264,  263,  262,  261,  260,  259,  258,  257,
526       256,  255,  254,  253,  252,  251,  250,  249,  248,  247,
527       246,  245,  241,  240,  239,  238,  237,  236,  235,  234,
528       233,  232,  231,  228,  227,  226,  225,  224,  223,  222,
529       221,  220,  219,  218,  217,  216,  215,  214,  213,  212,
530       211,  210,  209,  208,  207,  206,  205,  204,  203,  202,
531       201,  200,  199,  198,  197,  196,  195,  194,  193,  192,
532       191,  190,  189,  188,  187,  186,  185,  184,  183,  182,
533       181,  180,  179,  178,  177,  176,  175,  174,  173,  172,
534       171,  170,  169,  168,  167,  166,  165,  164,  161,  160,
535
536       159,  158,  157,  156,  155,  154,  151,  150,  149,  146,
537       145,  144,  143,  142,  141,  140,  139,  138,  137,  136,
538       135,  134,  133,  132,  131,  130,  129,  128,  127,  126,
539       125,  124,  123,  122,  121,  120,  119,  118,  117,  116,
540       115,  114,  113,  112,  111,  110,  109,  108,  105,  104,
541       101,  100,   99,   98,   95,   94,   93,   89,   88,   87,
542        84,   83,   82,   81,   80,   79,   74,   73,   38,   36,
543        35,   72,   58,   57,   54,   53,   49,   48,   45,   44,
544        41,   38,   36,   36,   35,  368,    7,  368,  368,  368,
545       368,  368,  368,  368,  368,  368,  368,  368,  368,  368,
546
547       368,  368,  368,  368,  368,  368,  368,  368,  368,  368,
548       368,  368,  368,  368,  368,  368,  368,  368,  368,  368,
549       368,  368,  368,  368,  368
550     } ;
551
552 static yyconst short int yy_chk[426] =
553     {   0,
554         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
555         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
556         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
557         1,    1,    1,    1,    1,    1,    1,    1,    3,    3,
558         4,    4,   16,   18,    3,   21,    4,   16,   21,   24,
559        27,  371,   43,   24,   58,   18,   43,   41,   50,   58,
560        50,   63,   66,   24,   63,  366,   66,  109,   27,   31,
561        31,   31,   31,   31,   41,   31,   31,  109,  365,  113,
562        31,   31,   54,   54,  113,   31,   31,   31,   31,  124,
563       269,  194,   54,  269,  124,  194,  207,  232,  207,  364,
564
565       363,  362,  232,  207,  369,  369,  370,  370,  360,  359,
566       357,  356,  353,  352,  351,  350,  349,  348,  345,  344,
567       341,  339,  337,  336,  335,  334,  333,  331,  330,  328,
568       325,  324,  323,  319,  318,  317,  316,  315,  314,  312,
569       311,  310,  309,  308,  307,  306,  305,  304,  303,  302,
570       301,  299,  298,  296,  294,  293,  290,  289,  286,  285,
571       283,  282,  281,  278,  276,  275,  274,  273,  272,  271,
572       270,  268,  267,  266,  265,  264,  263,  262,  261,  259,
573       258,  257,  256,  255,  254,  252,  251,  250,  249,  248,
574       247,  246,  244,  243,  242,  240,  239,  238,  236,  235,
575
576       234,  233,  229,  228,  227,  226,  225,  224,  223,  222,
577       221,  220,  219,  218,  217,  216,  215,  214,  213,  212,
578       209,  208,  206,  205,  204,  203,  202,  201,  199,  198,
579       197,  196,  195,  192,  191,  190,  189,  188,  187,  186,
580       185,  184,  183,  182,  181,  180,  178,  177,  176,  175,
581       174,  173,  172,  171,  170,  169,  168,  167,  166,  165,
582       164,  163,  162,  161,  160,  159,  158,  157,  155,  154,
583       153,  152,  151,  150,  149,  148,  147,  146,  145,  144,
584       143,  142,  141,  140,  139,  138,  137,  136,  135,  134,
585       133,  132,  131,  130,  129,  128,  126,  125,  123,  122,
586
587       120,  119,  118,  116,  115,  114,  112,  111,  110,  108,
588       107,  106,  105,  104,  103,  102,  101,  100,   98,   97,
589        96,   95,   94,   93,   92,   91,   90,   89,   88,   87,
590        86,   85,   84,   83,   82,   81,   80,   79,   78,   77,
591        76,   75,   73,   71,   70,   69,   68,   67,   65,   64,
592        62,   61,   60,   59,   57,   56,   55,   53,   52,   51,
593        49,   48,   47,   46,   45,   44,   40,   39,   37,   36,
594        35,   34,   29,   28,   26,   25,   23,   22,   20,   19,
595        17,   15,   14,   13,    9,    7,  368,  368,  368,  368,
596       368,  368,  368,  368,  368,  368,  368,  368,  368,  368,
597
598       368,  368,  368,  368,  368,  368,  368,  368,  368,  368,
599       368,  368,  368,  368,  368,  368,  368,  368,  368,  368,
600       368,  368,  368,  368,  368
601     } ;
602
603 static yy_state_type yy_state_buf[YY_BUF_SIZE + 2], *yy_state_ptr;
604 static char *yy_full_match;
605 static int yy_lp;
606 #define REJECT \
607 { \
608 *yy_cp = yy_hold_char; /* undo effects of setting up yytext */ \
609 yy_cp = yy_full_match; /* restore poss. backed-over text */ \
610 ++yy_lp; \
611 goto find_rule; \
612 }
613 #define yymore() yymore_used_but_not_detected
614 #define YY_MORE_ADJ 0
615 #define YY_RESTORE_YY_MORE_OFFSET
616 char *yytext;
617 #line 1 "matcher_parser_lex.l"
618 #define INITIAL 0
619 #line 2 "matcher_parser_lex.l"
620 #include "matcher_parser_lex.h"
621 #include "matcher_parser_parse.h"
622 #include <glib.h>
623
624 #define MAX_STR_CONST 512
625
626 char string_buf[MAX_STR_CONST];
627 char * string_buf_ptr;
628
629 static void add_char(char ch)
630 {
631         if (string_buf_ptr - string_buf < sizeof(string_buf))
632                 *string_buf_ptr++ = ch;
633 }
634 #define string 1
635
636 #define section 2
637
638 #line 639 "lex.yy.c"
639
640 /* Macros after this point can all be overridden by user definitions in
641  * section 1.
642  */
643
644 #ifndef YY_SKIP_YYWRAP
645 #ifdef __cplusplus
646 extern "C" int yywrap YY_PROTO(( void ));
647 #else
648 extern int yywrap YY_PROTO(( void ));
649 #endif
650 #endif
651
652 #ifndef YY_NO_UNPUT
653 static void yyunput YY_PROTO(( int c, char *buf_ptr ));
654 #endif
655
656 #ifndef yytext_ptr
657 static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
658 #endif
659
660 #ifdef YY_NEED_STRLEN
661 static int yy_flex_strlen YY_PROTO(( yyconst char * ));
662 #endif
663
664 #ifndef YY_NO_INPUT
665 #ifdef __cplusplus
666 static int yyinput YY_PROTO(( void ));
667 #else
668 static int input YY_PROTO(( void ));
669 #endif
670 #endif
671
672 #if YY_STACK_USED
673 static int yy_start_stack_ptr = 0;
674 static int yy_start_stack_depth = 0;
675 static int *yy_start_stack = 0;
676 #ifndef YY_NO_PUSH_STATE
677 static void yy_push_state YY_PROTO(( int new_state ));
678 #endif
679 #ifndef YY_NO_POP_STATE
680 static void yy_pop_state YY_PROTO(( void ));
681 #endif
682 #ifndef YY_NO_TOP_STATE
683 static int yy_top_state YY_PROTO(( void ));
684 #endif
685
686 #else
687 #define YY_NO_PUSH_STATE 1
688 #define YY_NO_POP_STATE 1
689 #define YY_NO_TOP_STATE 1
690 #endif
691
692 #ifdef YY_MALLOC_DECL
693 YY_MALLOC_DECL
694 #else
695 #if __STDC__
696 #ifndef __cplusplus
697 #include <stdlib.h>
698 #endif
699 #else
700 /* Just try to get by without declaring the routines.  This will fail
701  * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
702  * or sizeof(void*) != sizeof(int).
703  */
704 #endif
705 #endif
706
707 /* Amount of stuff to slurp up with each read. */
708 #ifndef YY_READ_BUF_SIZE
709 #define YY_READ_BUF_SIZE 8192
710 #endif
711
712 /* Copy whatever the last rule matched to the standard output. */
713
714 #ifndef ECHO
715 /* This used to be an fputs(), but since the string might contain NUL's,
716  * we now use fwrite().
717  */
718 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
719 #endif
720
721 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
722  * is returned in "result".
723  */
724 #ifndef YY_INPUT
725 #define YY_INPUT(buf,result,max_size) \
726         if ( yy_current_buffer->yy_is_interactive ) \
727                 { \
728                 int c = '*', n; \
729                 for ( n = 0; n < max_size && \
730                              (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
731                         buf[n] = (char) c; \
732                 if ( c == '\n' ) \
733                         buf[n++] = (char) c; \
734                 if ( c == EOF && ferror( yyin ) ) \
735                         YY_FATAL_ERROR( "input in flex scanner failed" ); \
736                 result = n; \
737                 } \
738         else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
739                   && ferror( yyin ) ) \
740                 YY_FATAL_ERROR( "input in flex scanner failed" );
741 #endif
742
743 /* No semi-colon after return; correct usage is to write "yyterminate();" -
744  * we don't want an extra ';' after the "return" because that will cause
745  * some compilers to complain about unreachable statements.
746  */
747 #ifndef yyterminate
748 #define yyterminate() return YY_NULL
749 #endif
750
751 /* Number of entries by which start-condition stack grows. */
752 #ifndef YY_START_STACK_INCR
753 #define YY_START_STACK_INCR 25
754 #endif
755
756 /* Report a fatal error. */
757 #ifndef YY_FATAL_ERROR
758 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
759 #endif
760
761 /* Default declaration of generated scanner - a define so the user can
762  * easily add parameters.
763  */
764 #ifndef YY_DECL
765 #define YY_DECL int yylex YY_PROTO(( void ))
766 #endif
767
768 /* Code executed at the beginning of each rule, after yytext and yyleng
769  * have been set up.
770  */
771 #ifndef YY_USER_ACTION
772 #define YY_USER_ACTION
773 #endif
774
775 /* Code executed at the end of each rule. */
776 #ifndef YY_BREAK
777 #define YY_BREAK break;
778 #endif
779
780 #define YY_RULE_SETUP \
781         YY_USER_ACTION
782
783 YY_DECL
784         {
785         register yy_state_type yy_current_state;
786         register char *yy_cp = NULL, *yy_bp = NULL;
787         register int yy_act;
788
789 #line 25 "matcher_parser_lex.l"
790
791
792 #line 793 "lex.yy.c"
793
794         if ( yy_init )
795                 {
796                 yy_init = 0;
797
798 #ifdef YY_USER_INIT
799                 YY_USER_INIT;
800 #endif
801
802                 if ( ! yy_start )
803                         yy_start = 1;   /* first start state */
804
805                 if ( ! yyin )
806                         yyin = stdin;
807
808                 if ( ! yyout )
809                         yyout = stdout;
810
811                 if ( ! yy_current_buffer )
812                         yy_current_buffer =
813                                 yy_create_buffer( yyin, YY_BUF_SIZE );
814
815                 yy_load_buffer_state();
816                 }
817
818         while ( 1 )             /* loops until end-of-file is reached */
819                 {
820                 yy_cp = yy_c_buf_p;
821
822                 /* Support of yytext. */
823                 *yy_cp = yy_hold_char;
824
825                 /* yy_bp points to the position in yy_ch_buf of the start of
826                  * the current run.
827                  */
828                 yy_bp = yy_cp;
829
830                 yy_current_state = yy_start;
831                 yy_state_ptr = yy_state_buf;
832                 *yy_state_ptr++ = yy_current_state;
833 yy_match:
834                 do
835                         {
836                         register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
837                         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
838                                 {
839                                 yy_current_state = (int) yy_def[yy_current_state];
840                                 if ( yy_current_state >= 369 )
841                                         yy_c = yy_meta[(unsigned int) yy_c];
842                                 }
843                         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
844                         *yy_state_ptr++ = yy_current_state;
845                         ++yy_cp;
846                         }
847                 while ( yy_base[yy_current_state] != 387 );
848
849 yy_find_action:
850                 yy_current_state = *--yy_state_ptr;
851                 yy_lp = yy_accept[yy_current_state];
852 find_rule: /* we branch to this label when backing up */
853                 for ( ; ; ) /* until we find what rule we matched */
854                         {
855                         if ( yy_lp && yy_lp < yy_accept[yy_current_state + 1] )
856                                 {
857                                 yy_act = yy_acclist[yy_lp];
858                                         {
859                                         yy_full_match = yy_cp;
860                                         break;
861                                         }
862                                 }
863                         --yy_cp;
864                         yy_current_state = *--yy_state_ptr;
865                         yy_lp = yy_accept[yy_current_state];
866                         }
867
868                 YY_DO_BEFORE_ACTION;
869
870                 if ( yy_act != YY_END_OF_BUFFER )
871                         {
872                         int yyl;
873                         for ( yyl = 0; yyl < yyleng; ++yyl )
874                                 if ( yytext[yyl] == '\n' )
875                                         ++yylineno;
876                         }
877
878 do_action:      /* This label is used only to access EOF actions. */
879
880
881                 switch ( yy_act )
882         { /* beginning of action switch */
883 case 1:
884 YY_RULE_SETUP
885 #line 27 "matcher_parser_lex.l"
886 return MATCHER_ALL;
887         YY_BREAK
888 case 2:
889 YY_RULE_SETUP
890 #line 28 "matcher_parser_lex.l"
891 return MATCHER_UNREAD;
892         YY_BREAK
893 case 3:
894 YY_RULE_SETUP
895 #line 29 "matcher_parser_lex.l"
896 return MATCHER_NOT_UNREAD;
897         YY_BREAK
898 case 4:
899 YY_RULE_SETUP
900 #line 30 "matcher_parser_lex.l"
901 return MATCHER_NEW;
902         YY_BREAK
903 case 5:
904 YY_RULE_SETUP
905 #line 31 "matcher_parser_lex.l"
906 return MATCHER_NOT_NEW;
907         YY_BREAK
908 case 6:
909 YY_RULE_SETUP
910 #line 32 "matcher_parser_lex.l"
911 return MATCHER_MARKED;
912         YY_BREAK
913 case 7:
914 YY_RULE_SETUP
915 #line 33 "matcher_parser_lex.l"
916 return MATCHER_NOT_MARKED;
917         YY_BREAK
918 case 8:
919 YY_RULE_SETUP
920 #line 34 "matcher_parser_lex.l"
921 return MATCHER_DELETED;
922         YY_BREAK
923 case 9:
924 YY_RULE_SETUP
925 #line 35 "matcher_parser_lex.l"
926 return MATCHER_NOT_DELETED;
927         YY_BREAK
928 case 10:
929 YY_RULE_SETUP
930 #line 36 "matcher_parser_lex.l"
931 return MATCHER_REPLIED;
932         YY_BREAK
933 case 11:
934 YY_RULE_SETUP
935 #line 37 "matcher_parser_lex.l"
936 return MATCHER_NOT_REPLIED;
937         YY_BREAK
938 case 12:
939 YY_RULE_SETUP
940 #line 38 "matcher_parser_lex.l"
941 return MATCHER_FORWARDED;
942         YY_BREAK
943 case 13:
944 YY_RULE_SETUP
945 #line 39 "matcher_parser_lex.l"
946 return MATCHER_NOT_FORWARDED;
947         YY_BREAK
948 case 14:
949 YY_RULE_SETUP
950 #line 40 "matcher_parser_lex.l"
951 return MATCHER_SUBJECT;
952         YY_BREAK
953 case 15:
954 YY_RULE_SETUP
955 #line 41 "matcher_parser_lex.l"
956 return MATCHER_NOT_SUBJECT;
957         YY_BREAK
958 case 16:
959 YY_RULE_SETUP
960 #line 42 "matcher_parser_lex.l"
961 return MATCHER_FROM;
962         YY_BREAK
963 case 17:
964 YY_RULE_SETUP
965 #line 43 "matcher_parser_lex.l"
966 return MATCHER_NOT_FROM;
967         YY_BREAK
968 case 18:
969 YY_RULE_SETUP
970 #line 44 "matcher_parser_lex.l"
971 return MATCHER_TO;
972         YY_BREAK
973 case 19:
974 YY_RULE_SETUP
975 #line 45 "matcher_parser_lex.l"
976 return MATCHER_NOT_TO;
977         YY_BREAK
978 case 20:
979 YY_RULE_SETUP
980 #line 46 "matcher_parser_lex.l"
981 return MATCHER_CC;
982         YY_BREAK
983 case 21:
984 YY_RULE_SETUP
985 #line 47 "matcher_parser_lex.l"
986 return MATCHER_NOT_CC;
987         YY_BREAK
988 case 22:
989 YY_RULE_SETUP
990 #line 48 "matcher_parser_lex.l"
991 return MATCHER_TO_OR_CC;
992         YY_BREAK
993 case 23:
994 YY_RULE_SETUP
995 #line 49 "matcher_parser_lex.l"
996 return MATCHER_NOT_TO_AND_NOT_CC;
997         YY_BREAK
998 case 24:
999 YY_RULE_SETUP
1000 #line 50 "matcher_parser_lex.l"
1001 return MATCHER_AGE_GREATER;
1002         YY_BREAK
1003 case 25:
1004 YY_RULE_SETUP
1005 #line 51 "matcher_parser_lex.l"
1006 return MATCHER_AGE_LOWER;
1007         YY_BREAK
1008 case 26:
1009 YY_RULE_SETUP
1010 #line 52 "matcher_parser_lex.l"
1011 return MATCHER_NEWSGROUPS;
1012         YY_BREAK
1013 case 27:
1014 YY_RULE_SETUP
1015 #line 53 "matcher_parser_lex.l"
1016 return MATCHER_NOT_NEWSGROUPS;
1017         YY_BREAK
1018 case 28:
1019 YY_RULE_SETUP
1020 #line 54 "matcher_parser_lex.l"
1021 return MATCHER_INREPLYTO;
1022         YY_BREAK
1023 case 29:
1024 YY_RULE_SETUP
1025 #line 55 "matcher_parser_lex.l"
1026 return MATCHER_NOT_INREPLYTO;
1027         YY_BREAK
1028 case 30:
1029 YY_RULE_SETUP
1030 #line 56 "matcher_parser_lex.l"
1031 return MATCHER_REFERENCES;
1032         YY_BREAK
1033 case 31:
1034 YY_RULE_SETUP
1035 #line 57 "matcher_parser_lex.l"
1036 return MATCHER_NOT_REFERENCES;
1037         YY_BREAK
1038 case 32:
1039 YY_RULE_SETUP
1040 #line 58 "matcher_parser_lex.l"
1041 return MATCHER_SCORE_GREATER;
1042         YY_BREAK
1043 case 33:
1044 YY_RULE_SETUP
1045 #line 59 "matcher_parser_lex.l"
1046 return MATCHER_SCORE_LOWER;
1047         YY_BREAK
1048 case 34:
1049 YY_RULE_SETUP
1050 #line 60 "matcher_parser_lex.l"
1051 return MATCHER_SCORE_EQUAL;
1052         YY_BREAK
1053 case 35:
1054 YY_RULE_SETUP
1055 #line 61 "matcher_parser_lex.l"
1056 return MATCHER_HEADER;
1057         YY_BREAK
1058 case 36:
1059 YY_RULE_SETUP
1060 #line 62 "matcher_parser_lex.l"
1061 return MATCHER_NOT_HEADER;
1062         YY_BREAK
1063 case 37:
1064 YY_RULE_SETUP
1065 #line 63 "matcher_parser_lex.l"
1066 return MATCHER_HEADERS_PART;
1067         YY_BREAK
1068 case 38:
1069 YY_RULE_SETUP
1070 #line 64 "matcher_parser_lex.l"
1071 return MATCHER_NOT_HEADERS_PART;
1072         YY_BREAK
1073 case 39:
1074 YY_RULE_SETUP
1075 #line 65 "matcher_parser_lex.l"
1076 return MATCHER_MESSAGE;
1077         YY_BREAK
1078 case 40:
1079 YY_RULE_SETUP
1080 #line 66 "matcher_parser_lex.l"
1081 return MATCHER_NOT_MESSAGE;
1082         YY_BREAK
1083 case 41:
1084 YY_RULE_SETUP
1085 #line 67 "matcher_parser_lex.l"
1086 return MATCHER_BODY_PART;
1087         YY_BREAK
1088 case 42:
1089 YY_RULE_SETUP
1090 #line 68 "matcher_parser_lex.l"
1091 return MATCHER_NOT_BODY_PART;
1092         YY_BREAK
1093 case 43:
1094 YY_RULE_SETUP
1095 #line 69 "matcher_parser_lex.l"
1096 return MATCHER_EXECUTE;
1097         YY_BREAK
1098 case 44:
1099 YY_RULE_SETUP
1100 #line 70 "matcher_parser_lex.l"
1101 return MATCHER_NOT_EXECUTE;
1102         YY_BREAK
1103 case 45:
1104 YY_RULE_SETUP
1105 #line 71 "matcher_parser_lex.l"
1106 return MATCHER_MATCHCASE;
1107         YY_BREAK
1108 case 46:
1109 YY_RULE_SETUP
1110 #line 72 "matcher_parser_lex.l"
1111 return MATCHER_MATCH;
1112         YY_BREAK
1113 case 47:
1114 YY_RULE_SETUP
1115 #line 73 "matcher_parser_lex.l"
1116 return MATCHER_REGEXPCASE;
1117         YY_BREAK
1118 case 48:
1119 YY_RULE_SETUP
1120 #line 74 "matcher_parser_lex.l"
1121 return MATCHER_REGEXP;
1122         YY_BREAK
1123 case 49:
1124 YY_RULE_SETUP
1125 #line 75 "matcher_parser_lex.l"
1126 return MATCHER_SCORE;
1127         YY_BREAK
1128 case 50:
1129 YY_RULE_SETUP
1130 #line 76 "matcher_parser_lex.l"
1131 return MATCHER_MOVE;
1132         YY_BREAK
1133 case 51:
1134 YY_RULE_SETUP
1135 #line 77 "matcher_parser_lex.l"
1136 return MATCHER_COPY;
1137         YY_BREAK
1138 case 52:
1139 YY_RULE_SETUP
1140 #line 78 "matcher_parser_lex.l"
1141 return MATCHER_DELETE;
1142         YY_BREAK
1143 case 53:
1144 YY_RULE_SETUP
1145 #line 79 "matcher_parser_lex.l"
1146 return MATCHER_MARK;
1147         YY_BREAK
1148 case 54:
1149 YY_RULE_SETUP
1150 #line 80 "matcher_parser_lex.l"
1151 return MATCHER_UNMARK;
1152         YY_BREAK
1153 case 55:
1154 YY_RULE_SETUP
1155 #line 81 "matcher_parser_lex.l"
1156 return MATCHER_MARK_AS_READ;
1157         YY_BREAK
1158 case 56:
1159 YY_RULE_SETUP
1160 #line 82 "matcher_parser_lex.l"
1161 return MATCHER_MARK_AS_UNREAD;
1162         YY_BREAK
1163 case 57:
1164 YY_RULE_SETUP
1165 #line 83 "matcher_parser_lex.l"
1166 return MATCHER_FORWARD;
1167         YY_BREAK
1168 case 58:
1169 YY_RULE_SETUP
1170 #line 84 "matcher_parser_lex.l"
1171 return MATCHER_FORWARD_AS_ATTACHMENT;
1172         YY_BREAK
1173 case 59:
1174 YY_RULE_SETUP
1175 #line 85 "matcher_parser_lex.l"
1176 return MATCHER_COLOR;
1177         YY_BREAK
1178 case 60:
1179 YY_RULE_SETUP
1180 #line 86 "matcher_parser_lex.l"
1181 return MATCHER_BOUNCE;
1182         YY_BREAK
1183 case 61:
1184 YY_RULE_SETUP
1185 #line 87 "matcher_parser_lex.l"
1186 return MATCHER_DELETE_ON_SERVER;
1187         YY_BREAK
1188 case 62:
1189 YY_RULE_SETUP
1190 #line 88 "matcher_parser_lex.l"
1191
1192         YY_BREAK
1193 case 63:
1194 YY_RULE_SETUP
1195 #line 89 "matcher_parser_lex.l"
1196 return MATCHER_EOL;
1197         YY_BREAK
1198 case 64:
1199 YY_RULE_SETUP
1200 #line 90 "matcher_parser_lex.l"
1201 return MATCHER_AND;
1202         YY_BREAK
1203 case 65:
1204 YY_RULE_SETUP
1205 #line 91 "matcher_parser_lex.l"
1206 return MATCHER_OR;
1207         YY_BREAK
1208 case 66:
1209 YY_RULE_SETUP
1210 #line 92 "matcher_parser_lex.l"
1211 {
1212                 BEGIN(string);
1213                 string_buf_ptr = string_buf;
1214                 }
1215         YY_BREAK
1216 /* alfons - OK, the new attempt is to just swallow 
1217                  * *EVERYTHING* and make sure everything is escaped
1218                  * when actually performing things. */
1219 case 67:
1220 YY_RULE_SETUP
1221 #line 99 "matcher_parser_lex.l"
1222 {
1223                 /* take care of escaped \" because this means the
1224                  * quote char should be skipped */
1225                 add_char('\\');
1226                 add_char('\"');
1227                 }
1228         YY_BREAK
1229 case 68:
1230 YY_RULE_SETUP
1231 #line 105 "matcher_parser_lex.l"
1232 {
1233                 /* get out of the state: string ends. */
1234                 BEGIN(0);
1235                 *string_buf_ptr = '\0';
1236                 yylval.str = string_buf;
1237                 return MATCHER_STRING;
1238                 }
1239         YY_BREAK
1240 /* put everything else in the output. */
1241 case 69:
1242 YY_RULE_SETUP
1243 #line 113 "matcher_parser_lex.l"
1244 {
1245                 add_char(yytext[0]);
1246                 }
1247         YY_BREAK
1248 case 70:
1249 YY_RULE_SETUP
1250 #line 116 "matcher_parser_lex.l"
1251 {
1252                 BEGIN(0);
1253                 yylval.str = yytext + 1;
1254                 yytext[strlen(yytext) - 1] = '\0';
1255                 return MATCHER_SECTION;
1256                 }
1257         YY_BREAK
1258 case 71:
1259 YY_RULE_SETUP
1260 #line 122 "matcher_parser_lex.l"
1261 {
1262                 yylval.str = yytext;
1263                 return MATCHER_INTEGER;
1264                 }
1265         YY_BREAK
1266 case 72:
1267 YY_RULE_SETUP
1268 #line 127 "matcher_parser_lex.l"
1269 ECHO;
1270         YY_BREAK
1271 #line 1272 "lex.yy.c"
1272                         case YY_STATE_EOF(INITIAL):
1273                         case YY_STATE_EOF(string):
1274                         case YY_STATE_EOF(section):
1275                                 yyterminate();
1276
1277         case YY_END_OF_BUFFER:
1278                 {
1279                 /* Amount of text matched not including the EOB char. */
1280                 int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
1281
1282                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
1283                 *yy_cp = yy_hold_char;
1284                 YY_RESTORE_YY_MORE_OFFSET
1285
1286                 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
1287                         {
1288                         /* We're scanning a new file or input source.  It's
1289                          * possible that this happened because the user
1290                          * just pointed yyin at a new source and called
1291                          * yylex().  If so, then we have to assure
1292                          * consistency between yy_current_buffer and our
1293                          * globals.  Here is the right place to do so, because
1294                          * this is the first action (other than possibly a
1295                          * back-up) that will match for the new input source.
1296                          */
1297                         yy_n_chars = yy_current_buffer->yy_n_chars;
1298                         yy_current_buffer->yy_input_file = yyin;
1299                         yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
1300                         }
1301
1302                 /* Note that here we test for yy_c_buf_p "<=" to the position
1303                  * of the first EOB in the buffer, since yy_c_buf_p will
1304                  * already have been incremented past the NUL character
1305                  * (since all states make transitions on EOB to the
1306                  * end-of-buffer state).  Contrast this with the test
1307                  * in input().
1308                  */
1309                 if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
1310                         { /* This was really a NUL. */
1311                         yy_state_type yy_next_state;
1312
1313                         yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
1314
1315                         yy_current_state = yy_get_previous_state();
1316
1317                         /* Okay, we're now positioned to make the NUL
1318                          * transition.  We couldn't have
1319                          * yy_get_previous_state() go ahead and do it
1320                          * for us because it doesn't know how to deal
1321                          * with the possibility of jamming (and we don't
1322                          * want to build jamming into it because then it
1323                          * will run more slowly).
1324                          */
1325
1326                         yy_next_state = yy_try_NUL_trans( yy_current_state );
1327
1328                         yy_bp = yytext_ptr + YY_MORE_ADJ;
1329
1330                         if ( yy_next_state )
1331                                 {
1332                                 /* Consume the NUL. */
1333                                 yy_cp = ++yy_c_buf_p;
1334                                 yy_current_state = yy_next_state;
1335                                 goto yy_match;
1336                                 }
1337
1338                         else
1339                                 {
1340                                 yy_cp = yy_c_buf_p;
1341                                 goto yy_find_action;
1342                                 }
1343                         }
1344
1345                 else switch ( yy_get_next_buffer() )
1346                         {
1347                         case EOB_ACT_END_OF_FILE:
1348                                 {
1349                                 yy_did_buffer_switch_on_eof = 0;
1350
1351                                 if ( yywrap() )
1352                                         {
1353                                         /* Note: because we've taken care in
1354                                          * yy_get_next_buffer() to have set up
1355                                          * yytext, we can now set up
1356                                          * yy_c_buf_p so that if some total
1357                                          * hoser (like flex itself) wants to
1358                                          * call the scanner after we return the
1359                                          * YY_NULL, it'll still work - another
1360                                          * YY_NULL will get returned.
1361                                          */
1362                                         yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
1363
1364                                         yy_act = YY_STATE_EOF(YY_START);
1365                                         goto do_action;
1366                                         }
1367
1368                                 else
1369                                         {
1370                                         if ( ! yy_did_buffer_switch_on_eof )
1371                                                 YY_NEW_FILE;
1372                                         }
1373                                 break;
1374                                 }
1375
1376                         case EOB_ACT_CONTINUE_SCAN:
1377                                 yy_c_buf_p =
1378                                         yytext_ptr + yy_amount_of_matched_text;
1379
1380                                 yy_current_state = yy_get_previous_state();
1381
1382                                 yy_cp = yy_c_buf_p;
1383                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
1384                                 goto yy_match;
1385
1386                         case EOB_ACT_LAST_MATCH:
1387                                 yy_c_buf_p =
1388                                 &yy_current_buffer->yy_ch_buf[yy_n_chars];
1389
1390                                 yy_current_state = yy_get_previous_state();
1391
1392                                 yy_cp = yy_c_buf_p;
1393                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
1394                                 goto yy_find_action;
1395                         }
1396                 break;
1397                 }
1398
1399         default:
1400                 YY_FATAL_ERROR(
1401                         "fatal flex scanner internal error--no action found" );
1402         } /* end of action switch */
1403                 } /* end of scanning one token */
1404         } /* end of yylex */
1405
1406
1407 /* yy_get_next_buffer - try to read in a new buffer
1408  *
1409  * Returns a code representing an action:
1410  *      EOB_ACT_LAST_MATCH -
1411  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1412  *      EOB_ACT_END_OF_FILE - end of file
1413  */
1414
1415 static int yy_get_next_buffer()
1416         {
1417         register char *dest = yy_current_buffer->yy_ch_buf;
1418         register char *source = yytext_ptr;
1419         register int number_to_move, i;
1420         int ret_val;
1421
1422         if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
1423                 YY_FATAL_ERROR(
1424                 "fatal flex scanner internal error--end of buffer missed" );
1425
1426         if ( yy_current_buffer->yy_fill_buffer == 0 )
1427                 { /* Don't try to fill the buffer, so this is an EOF. */
1428                 if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
1429                         {
1430                         /* We matched a single character, the EOB, so
1431                          * treat this as a final EOF.
1432                          */
1433                         return EOB_ACT_END_OF_FILE;
1434                         }
1435
1436                 else
1437                         {
1438                         /* We matched some text prior to the EOB, first
1439                          * process it.
1440                          */
1441                         return EOB_ACT_LAST_MATCH;
1442                         }
1443                 }
1444
1445         /* Try to read more data. */
1446
1447         /* First move last chars to start of buffer. */
1448         number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
1449
1450         for ( i = 0; i < number_to_move; ++i )
1451                 *(dest++) = *(source++);
1452
1453         if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1454                 /* don't do the read, it's not guaranteed to return an EOF,
1455                  * just force an EOF
1456                  */
1457                 yy_current_buffer->yy_n_chars = yy_n_chars = 0;
1458
1459         else
1460                 {
1461                 int num_to_read =
1462                         yy_current_buffer->yy_buf_size - number_to_move - 1;
1463
1464                 while ( num_to_read <= 0 )
1465                         { /* Not enough room in the buffer - grow it. */
1466 #ifdef YY_USES_REJECT
1467                         YY_FATAL_ERROR(
1468 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
1469 #else
1470
1471                         /* just a shorter name for the current buffer */
1472                         YY_BUFFER_STATE b = yy_current_buffer;
1473
1474                         int yy_c_buf_p_offset =
1475                                 (int) (yy_c_buf_p - b->yy_ch_buf);
1476
1477                         if ( b->yy_is_our_buffer )
1478                                 {
1479                                 int new_size = b->yy_buf_size * 2;
1480
1481                                 if ( new_size <= 0 )
1482                                         b->yy_buf_size += b->yy_buf_size / 8;
1483                                 else
1484                                         b->yy_buf_size *= 2;
1485
1486                                 b->yy_ch_buf = (char *)
1487                                         /* Include room in for 2 EOB chars. */
1488                                         yy_flex_realloc( (void *) b->yy_ch_buf,
1489                                                          b->yy_buf_size + 2 );
1490                                 }
1491                         else
1492                                 /* Can't grow it, we don't own it. */
1493                                 b->yy_ch_buf = 0;
1494
1495                         if ( ! b->yy_ch_buf )
1496                                 YY_FATAL_ERROR(
1497                                 "fatal error - scanner input buffer overflow" );
1498
1499                         yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
1500
1501                         num_to_read = yy_current_buffer->yy_buf_size -
1502                                                 number_to_move - 1;
1503 #endif
1504                         }
1505
1506                 if ( num_to_read > YY_READ_BUF_SIZE )
1507                         num_to_read = YY_READ_BUF_SIZE;
1508
1509                 /* Read in more data. */
1510                 YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
1511                         yy_n_chars, num_to_read );
1512
1513                 yy_current_buffer->yy_n_chars = yy_n_chars;
1514                 }
1515
1516         if ( yy_n_chars == 0 )
1517                 {
1518                 if ( number_to_move == YY_MORE_ADJ )
1519                         {
1520                         ret_val = EOB_ACT_END_OF_FILE;
1521                         yyrestart( yyin );
1522                         }
1523
1524                 else
1525                         {
1526                         ret_val = EOB_ACT_LAST_MATCH;
1527                         yy_current_buffer->yy_buffer_status =
1528                                 YY_BUFFER_EOF_PENDING;
1529                         }
1530                 }
1531
1532         else
1533                 ret_val = EOB_ACT_CONTINUE_SCAN;
1534
1535         yy_n_chars += number_to_move;
1536         yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
1537         yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
1538
1539         yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
1540
1541         return ret_val;
1542         }
1543
1544
1545 /* yy_get_previous_state - get the state just before the EOB char was reached */
1546
1547 static yy_state_type yy_get_previous_state()
1548         {
1549         register yy_state_type yy_current_state;
1550         register char *yy_cp;
1551
1552         yy_current_state = yy_start;
1553         yy_state_ptr = yy_state_buf;
1554         *yy_state_ptr++ = yy_current_state;
1555
1556         for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
1557                 {
1558                 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1559                 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1560                         {
1561                         yy_current_state = (int) yy_def[yy_current_state];
1562                         if ( yy_current_state >= 369 )
1563                                 yy_c = yy_meta[(unsigned int) yy_c];
1564                         }
1565                 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1566                 *yy_state_ptr++ = yy_current_state;
1567                 }
1568
1569         return yy_current_state;
1570         }
1571
1572
1573 /* yy_try_NUL_trans - try to make a transition on the NUL character
1574  *
1575  * synopsis
1576  *      next_state = yy_try_NUL_trans( current_state );
1577  */
1578
1579 #ifdef YY_USE_PROTOS
1580 static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
1581 #else
1582 static yy_state_type yy_try_NUL_trans( yy_current_state )
1583 yy_state_type yy_current_state;
1584 #endif
1585         {
1586         register int yy_is_jam;
1587
1588         register YY_CHAR yy_c = 1;
1589         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1590                 {
1591                 yy_current_state = (int) yy_def[yy_current_state];
1592                 if ( yy_current_state >= 369 )
1593                         yy_c = yy_meta[(unsigned int) yy_c];
1594                 }
1595         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1596         yy_is_jam = (yy_current_state == 368);
1597         if ( ! yy_is_jam )
1598                 *yy_state_ptr++ = yy_current_state;
1599
1600         return yy_is_jam ? 0 : yy_current_state;
1601         }
1602
1603
1604 #ifndef YY_NO_UNPUT
1605 #ifdef YY_USE_PROTOS
1606 static void yyunput( int c, register char *yy_bp )
1607 #else
1608 static void yyunput( c, yy_bp )
1609 int c;
1610 register char *yy_bp;
1611 #endif
1612         {
1613         register char *yy_cp = yy_c_buf_p;
1614
1615         /* undo effects of setting up yytext */
1616         *yy_cp = yy_hold_char;
1617
1618         if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1619                 { /* need to shift things up to make room */
1620                 /* +2 for EOB chars. */
1621                 register int number_to_move = yy_n_chars + 2;
1622                 register char *dest = &yy_current_buffer->yy_ch_buf[
1623                                         yy_current_buffer->yy_buf_size + 2];
1624                 register char *source =
1625                                 &yy_current_buffer->yy_ch_buf[number_to_move];
1626
1627                 while ( source > yy_current_buffer->yy_ch_buf )
1628                         *--dest = *--source;
1629
1630                 yy_cp += (int) (dest - source);
1631                 yy_bp += (int) (dest - source);
1632                 yy_current_buffer->yy_n_chars =
1633                         yy_n_chars = yy_current_buffer->yy_buf_size;
1634
1635                 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1636                         YY_FATAL_ERROR( "flex scanner push-back overflow" );
1637                 }
1638
1639         *--yy_cp = (char) c;
1640
1641         if ( c == '\n' )
1642                 --yylineno;
1643
1644         yytext_ptr = yy_bp;
1645         yy_hold_char = *yy_cp;
1646         yy_c_buf_p = yy_cp;
1647         }
1648 #endif  /* ifndef YY_NO_UNPUT */
1649
1650
1651 #ifdef __cplusplus
1652 static int yyinput()
1653 #else
1654 static int input()
1655 #endif
1656         {
1657         int c;
1658
1659         *yy_c_buf_p = yy_hold_char;
1660
1661         if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
1662                 {
1663                 /* yy_c_buf_p now points to the character we want to return.
1664                  * If this occurs *before* the EOB characters, then it's a
1665                  * valid NUL; if not, then we've hit the end of the buffer.
1666                  */
1667                 if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
1668                         /* This was really a NUL. */
1669                         *yy_c_buf_p = '\0';
1670
1671                 else
1672                         { /* need more input */
1673                         int offset = yy_c_buf_p - yytext_ptr;
1674                         ++yy_c_buf_p;
1675
1676                         switch ( yy_get_next_buffer() )
1677                                 {
1678                                 case EOB_ACT_LAST_MATCH:
1679                                         /* This happens because yy_g_n_b()
1680                                          * sees that we've accumulated a
1681                                          * token and flags that we need to
1682                                          * try matching the token before
1683                                          * proceeding.  But for input(),
1684                                          * there's no matching to consider.
1685                                          * So convert the EOB_ACT_LAST_MATCH
1686                                          * to EOB_ACT_END_OF_FILE.
1687                                          */
1688
1689                                         /* Reset buffer status. */
1690                                         yyrestart( yyin );
1691
1692                                         /* fall through */
1693
1694                                 case EOB_ACT_END_OF_FILE:
1695                                         {
1696                                         if ( yywrap() )
1697                                                 return EOF;
1698
1699                                         if ( ! yy_did_buffer_switch_on_eof )
1700                                                 YY_NEW_FILE;
1701 #ifdef __cplusplus
1702                                         return yyinput();
1703 #else
1704                                         return input();
1705 #endif
1706                                         }
1707
1708                                 case EOB_ACT_CONTINUE_SCAN:
1709                                         yy_c_buf_p = yytext_ptr + offset;
1710                                         break;
1711                                 }
1712                         }
1713                 }
1714
1715         c = *(unsigned char *) yy_c_buf_p;      /* cast for 8-bit char's */
1716         *yy_c_buf_p = '\0';     /* preserve yytext */
1717         yy_hold_char = *++yy_c_buf_p;
1718
1719         if ( c == '\n' )
1720                 ++yylineno;
1721
1722         return c;
1723         }
1724
1725
1726 #ifdef YY_USE_PROTOS
1727 void yyrestart( FILE *input_file )
1728 #else
1729 void yyrestart( input_file )
1730 FILE *input_file;
1731 #endif
1732         {
1733         if ( ! yy_current_buffer )
1734                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
1735
1736         yy_init_buffer( yy_current_buffer, input_file );
1737         yy_load_buffer_state();
1738         }
1739
1740
1741 #ifdef YY_USE_PROTOS
1742 void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
1743 #else
1744 void yy_switch_to_buffer( new_buffer )
1745 YY_BUFFER_STATE new_buffer;
1746 #endif
1747         {
1748         if ( yy_current_buffer == new_buffer )
1749                 return;
1750
1751         if ( yy_current_buffer )
1752                 {
1753                 /* Flush out information for old buffer. */
1754                 *yy_c_buf_p = yy_hold_char;
1755                 yy_current_buffer->yy_buf_pos = yy_c_buf_p;
1756                 yy_current_buffer->yy_n_chars = yy_n_chars;
1757                 }
1758
1759         yy_current_buffer = new_buffer;
1760         yy_load_buffer_state();
1761
1762         /* We don't actually know whether we did this switch during
1763          * EOF (yywrap()) processing, but the only time this flag
1764          * is looked at is after yywrap() is called, so it's safe
1765          * to go ahead and always set it.
1766          */
1767         yy_did_buffer_switch_on_eof = 1;
1768         }
1769
1770
1771 #ifdef YY_USE_PROTOS
1772 void yy_load_buffer_state( void )
1773 #else
1774 void yy_load_buffer_state()
1775 #endif
1776         {
1777         yy_n_chars = yy_current_buffer->yy_n_chars;
1778         yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
1779         yyin = yy_current_buffer->yy_input_file;
1780         yy_hold_char = *yy_c_buf_p;
1781         }
1782
1783
1784 #ifdef YY_USE_PROTOS
1785 YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
1786 #else
1787 YY_BUFFER_STATE yy_create_buffer( file, size )
1788 FILE *file;
1789 int size;
1790 #endif
1791         {
1792         YY_BUFFER_STATE b;
1793
1794         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
1795         if ( ! b )
1796                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1797
1798         b->yy_buf_size = size;
1799
1800         /* yy_ch_buf has to be 2 characters longer than the size given because
1801          * we need to put in 2 end-of-buffer characters.
1802          */
1803         b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
1804         if ( ! b->yy_ch_buf )
1805                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1806
1807         b->yy_is_our_buffer = 1;
1808
1809         yy_init_buffer( b, file );
1810
1811         return b;
1812         }
1813
1814
1815 #ifdef YY_USE_PROTOS
1816 void yy_delete_buffer( YY_BUFFER_STATE b )
1817 #else
1818 void yy_delete_buffer( b )
1819 YY_BUFFER_STATE b;
1820 #endif
1821         {
1822         if ( ! b )
1823                 return;
1824
1825         if ( b == yy_current_buffer )
1826                 yy_current_buffer = (YY_BUFFER_STATE) 0;
1827
1828         if ( b->yy_is_our_buffer )
1829                 yy_flex_free( (void *) b->yy_ch_buf );
1830
1831         yy_flex_free( (void *) b );
1832         }
1833
1834
1835
1836 #ifdef YY_USE_PROTOS
1837 void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
1838 #else
1839 void yy_init_buffer( b, file )
1840 YY_BUFFER_STATE b;
1841 FILE *file;
1842 #endif
1843
1844
1845         {
1846         yy_flush_buffer( b );
1847
1848         b->yy_input_file = file;
1849         b->yy_fill_buffer = 1;
1850
1851 #if YY_ALWAYS_INTERACTIVE
1852         b->yy_is_interactive = 1;
1853 #else
1854 #if YY_NEVER_INTERACTIVE
1855         b->yy_is_interactive = 0;
1856 #else
1857         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1858 #endif
1859 #endif
1860         }
1861
1862
1863 #ifdef YY_USE_PROTOS
1864 void yy_flush_buffer( YY_BUFFER_STATE b )
1865 #else
1866 void yy_flush_buffer( b )
1867 YY_BUFFER_STATE b;
1868 #endif
1869
1870         {
1871         if ( ! b )
1872                 return;
1873
1874         b->yy_n_chars = 0;
1875
1876         /* We always need two end-of-buffer characters.  The first causes
1877          * a transition to the end-of-buffer state.  The second causes
1878          * a jam in that state.
1879          */
1880         b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1881         b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1882
1883         b->yy_buf_pos = &b->yy_ch_buf[0];
1884
1885         b->yy_at_bol = 1;
1886         b->yy_buffer_status = YY_BUFFER_NEW;
1887
1888         if ( b == yy_current_buffer )
1889                 yy_load_buffer_state();
1890         }
1891
1892
1893 #ifndef YY_NO_SCAN_BUFFER
1894 #ifdef YY_USE_PROTOS
1895 YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
1896 #else
1897 YY_BUFFER_STATE yy_scan_buffer( base, size )
1898 char *base;
1899 yy_size_t size;
1900 #endif
1901         {
1902         YY_BUFFER_STATE b;
1903
1904         if ( size < 2 ||
1905              base[size-2] != YY_END_OF_BUFFER_CHAR ||
1906              base[size-1] != YY_END_OF_BUFFER_CHAR )
1907                 /* They forgot to leave room for the EOB's. */
1908                 return 0;
1909
1910         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
1911         if ( ! b )
1912                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
1913
1914         b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
1915         b->yy_buf_pos = b->yy_ch_buf = base;
1916         b->yy_is_our_buffer = 0;
1917         b->yy_input_file = 0;
1918         b->yy_n_chars = b->yy_buf_size;
1919         b->yy_is_interactive = 0;
1920         b->yy_at_bol = 1;
1921         b->yy_fill_buffer = 0;
1922         b->yy_buffer_status = YY_BUFFER_NEW;
1923
1924         yy_switch_to_buffer( b );
1925
1926         return b;
1927         }
1928 #endif
1929
1930
1931 #ifndef YY_NO_SCAN_STRING
1932 #ifdef YY_USE_PROTOS
1933 YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
1934 #else
1935 YY_BUFFER_STATE yy_scan_string( yy_str )
1936 yyconst char *yy_str;
1937 #endif
1938         {
1939         int len;
1940         for ( len = 0; yy_str[len]; ++len )
1941                 ;
1942
1943         return yy_scan_bytes( yy_str, len );
1944         }
1945 #endif
1946
1947
1948 #ifndef YY_NO_SCAN_BYTES
1949 #ifdef YY_USE_PROTOS
1950 YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
1951 #else
1952 YY_BUFFER_STATE yy_scan_bytes( bytes, len )
1953 yyconst char *bytes;
1954 int len;
1955 #endif
1956         {
1957         YY_BUFFER_STATE b;
1958         char *buf;
1959         yy_size_t n;
1960         int i;
1961
1962         /* Get memory for full buffer, including space for trailing EOB's. */
1963         n = len + 2;
1964         buf = (char *) yy_flex_alloc( n );
1965         if ( ! buf )
1966                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
1967
1968         for ( i = 0; i < len; ++i )
1969                 buf[i] = bytes[i];
1970
1971         buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
1972
1973         b = yy_scan_buffer( buf, n );
1974         if ( ! b )
1975                 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
1976
1977         /* It's okay to grow etc. this buffer, and we should throw it
1978          * away when we're done.
1979          */
1980         b->yy_is_our_buffer = 1;
1981
1982         return b;
1983         }
1984 #endif
1985
1986
1987 #ifndef YY_NO_PUSH_STATE
1988 #ifdef YY_USE_PROTOS
1989 static void yy_push_state( int new_state )
1990 #else
1991 static void yy_push_state( new_state )
1992 int new_state;
1993 #endif
1994         {
1995         if ( yy_start_stack_ptr >= yy_start_stack_depth )
1996                 {
1997                 yy_size_t new_size;
1998
1999                 yy_start_stack_depth += YY_START_STACK_INCR;
2000                 new_size = yy_start_stack_depth * sizeof( int );
2001
2002                 if ( ! yy_start_stack )
2003                         yy_start_stack = (int *) yy_flex_alloc( new_size );
2004
2005                 else
2006                         yy_start_stack = (int *) yy_flex_realloc(
2007                                         (void *) yy_start_stack, new_size );
2008
2009                 if ( ! yy_start_stack )
2010                         YY_FATAL_ERROR(
2011                         "out of memory expanding start-condition stack" );
2012                 }
2013
2014         yy_start_stack[yy_start_stack_ptr++] = YY_START;
2015
2016         BEGIN(new_state);
2017         }
2018 #endif
2019
2020
2021 #ifndef YY_NO_POP_STATE
2022 static void yy_pop_state()
2023         {
2024         if ( --yy_start_stack_ptr < 0 )
2025                 YY_FATAL_ERROR( "start-condition stack underflow" );
2026
2027         BEGIN(yy_start_stack[yy_start_stack_ptr]);
2028         }
2029 #endif
2030
2031
2032 #ifndef YY_NO_TOP_STATE
2033 static int yy_top_state()
2034         {
2035         return yy_start_stack[yy_start_stack_ptr - 1];
2036         }
2037 #endif
2038
2039 #ifndef YY_EXIT_FAILURE
2040 #define YY_EXIT_FAILURE 2
2041 #endif
2042
2043 #ifdef YY_USE_PROTOS
2044 static void yy_fatal_error( yyconst char msg[] )
2045 #else
2046 static void yy_fatal_error( msg )
2047 char msg[];
2048 #endif
2049         {
2050         (void) fprintf( stderr, "%s\n", msg );
2051         exit( YY_EXIT_FAILURE );
2052         }
2053
2054
2055
2056 /* Redefine yyless() so it works in section 3 code. */
2057
2058 #undef yyless
2059 #define yyless(n) \
2060         do \
2061                 { \
2062                 /* Undo effects of setting up yytext. */ \
2063                 yytext[yyleng] = yy_hold_char; \
2064                 yy_c_buf_p = yytext + n; \
2065                 yy_hold_char = *yy_c_buf_p; \
2066                 *yy_c_buf_p = '\0'; \
2067                 yyleng = n; \
2068                 } \
2069         while ( 0 )
2070
2071
2072 /* Internal utility routines. */
2073
2074 #ifndef yytext_ptr
2075 #ifdef YY_USE_PROTOS
2076 static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
2077 #else
2078 static void yy_flex_strncpy( s1, s2, n )
2079 char *s1;
2080 yyconst char *s2;
2081 int n;
2082 #endif
2083         {
2084         register int i;
2085         for ( i = 0; i < n; ++i )
2086                 s1[i] = s2[i];
2087         }
2088 #endif
2089
2090 #ifdef YY_NEED_STRLEN
2091 #ifdef YY_USE_PROTOS
2092 static int yy_flex_strlen( yyconst char *s )
2093 #else
2094 static int yy_flex_strlen( s )
2095 yyconst char *s;
2096 #endif
2097         {
2098         register int n;
2099         for ( n = 0; s[n]; ++n )
2100                 ;
2101
2102         return n;
2103         }
2104 #endif
2105
2106
2107 #ifdef YY_USE_PROTOS
2108 static void *yy_flex_alloc( yy_size_t size )
2109 #else
2110 static void *yy_flex_alloc( size )
2111 yy_size_t size;
2112 #endif
2113         {
2114         return (void *) malloc( size );
2115         }
2116
2117 #ifdef YY_USE_PROTOS
2118 static void *yy_flex_realloc( void *ptr, yy_size_t size )
2119 #else
2120 static void *yy_flex_realloc( ptr, size )
2121 void *ptr;
2122 yy_size_t size;
2123 #endif
2124         {
2125         /* The cast to (char *) in the following accommodates both
2126          * implementations that use char* generic pointers, and those
2127          * that use void* generic pointers.  It works with the latter
2128          * because both ANSI C and C++ allow castless assignment from
2129          * any pointer type to void*, and deal with argument conversions
2130          * as though doing an assignment.
2131          */
2132         return (void *) realloc( (char *) ptr, size );
2133         }
2134
2135 #ifdef YY_USE_PROTOS
2136 static void yy_flex_free( void *ptr )
2137 #else
2138 static void yy_flex_free( ptr )
2139 void *ptr;
2140 #endif
2141         {
2142         free( ptr );
2143         }
2144
2145 #if YY_MAIN
2146 int main()
2147         {
2148         yylex();
2149         return 0;
2150         }
2151 #endif
2152 #line 127 "matcher_parser_lex.l"
2153