configuration for replying and forwarding
[claws.git] / src / lex.quote_fmt.c
1 #define yy_create_buffer quote_fmt_create_buffer
2 #define yy_delete_buffer quote_fmt_delete_buffer
3 #define yy_scan_buffer quote_fmt_scan_buffer
4 #define yy_scan_string quote_fmt_scan_string
5 #define yy_scan_bytes quote_fmt_scan_bytes
6 #define yy_flex_debug quote_fmt_flex_debug
7 #define yy_init_buffer quote_fmt_init_buffer
8 #define yy_flush_buffer quote_fmt_flush_buffer
9 #define yy_load_buffer_state quote_fmt_load_buffer_state
10 #define yy_switch_to_buffer quote_fmt_switch_to_buffer
11 #define yyin quote_fmtin
12 #define yyleng quote_fmtleng
13 #define yylex quote_fmtlex
14 #define yyout quote_fmtout
15 #define yyrestart quote_fmtrestart
16 #define yytext quote_fmttext
17 #define yywrap quote_fmtwrap
18
19 /* A lexical scanner generated by flex */
20
21 /* Scanner skeleton version:
22  * $Header$
23  */
24
25 #define FLEX_SCANNER
26 #define YY_FLEX_MAJOR_VERSION 2
27 #define YY_FLEX_MINOR_VERSION 5
28
29 #include <stdio.h>
30
31
32 /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
33 #ifdef c_plusplus
34 #ifndef __cplusplus
35 #define __cplusplus
36 #endif
37 #endif
38
39
40 #ifdef __cplusplus
41
42 #include <stdlib.h>
43 #include <unistd.h>
44
45 /* Use prototypes in function declarations. */
46 #define YY_USE_PROTOS
47
48 /* The "const" storage-class-modifier is valid. */
49 #define YY_USE_CONST
50
51 #else   /* ! __cplusplus */
52
53 #if __STDC__
54
55 #define YY_USE_PROTOS
56 #define YY_USE_CONST
57
58 #endif  /* __STDC__ */
59 #endif  /* ! __cplusplus */
60
61 #ifdef __TURBOC__
62  #pragma warn -rch
63  #pragma warn -use
64 #include <io.h>
65 #include <stdlib.h>
66 #define YY_USE_CONST
67 #define YY_USE_PROTOS
68 #endif
69
70 #ifdef YY_USE_CONST
71 #define yyconst const
72 #else
73 #define yyconst
74 #endif
75
76
77 #ifdef YY_USE_PROTOS
78 #define YY_PROTO(proto) proto
79 #else
80 #define YY_PROTO(proto) ()
81 #endif
82
83 /* Returned upon end-of-file. */
84 #define YY_NULL 0
85
86 /* Promotes a possibly negative, possibly signed char to an unsigned
87  * integer for use as an array index.  If the signed char is negative,
88  * we want to instead treat it as an 8-bit unsigned char, hence the
89  * double cast.
90  */
91 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
92
93 /* Enter a start condition.  This macro really ought to take a parameter,
94  * but we do it the disgusting crufty way forced on us by the ()-less
95  * definition of BEGIN.
96  */
97 #define BEGIN yy_start = 1 + 2 *
98
99 /* Translate the current start state into a value that can be later handed
100  * to BEGIN to return to the state.  The YYSTATE alias is for lex
101  * compatibility.
102  */
103 #define YY_START ((yy_start - 1) / 2)
104 #define YYSTATE YY_START
105
106 /* Action number for EOF rule of a given start state. */
107 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
108
109 /* Special action meaning "start processing a new file". */
110 #define YY_NEW_FILE yyrestart( yyin )
111
112 #define YY_END_OF_BUFFER_CHAR 0
113
114 /* Size of default input buffer. */
115 #define YY_BUF_SIZE 16384
116
117 typedef struct yy_buffer_state *YY_BUFFER_STATE;
118
119 extern int yyleng;
120 extern FILE *yyin, *yyout;
121
122 #define EOB_ACT_CONTINUE_SCAN 0
123 #define EOB_ACT_END_OF_FILE 1
124 #define EOB_ACT_LAST_MATCH 2
125
126 /* The funky do-while in the following #define is used to turn the definition
127  * int a single C statement (which needs a semi-colon terminator).  This
128  * avoids problems with code like:
129  *
130  *      if ( condition_holds )
131  *              yyless( 5 );
132  *      else
133  *              do_something_else();
134  *
135  * Prior to using the do-while the compiler would get upset at the
136  * "else" because it interpreted the "if" statement as being all
137  * done when it reached the ';' after the yyless() call.
138  */
139
140 /* Return all but the first 'n' matched characters back to the input stream. */
141
142 #define yyless(n) \
143         do \
144                 { \
145                 /* Undo effects of setting up yytext. */ \
146                 *yy_cp = yy_hold_char; \
147                 YY_RESTORE_YY_MORE_OFFSET \
148                 yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
149                 YY_DO_BEFORE_ACTION; /* set up yytext again */ \
150                 } \
151         while ( 0 )
152
153 #define unput(c) yyunput( c, yytext_ptr )
154
155 /* The following is because we cannot portably get our hands on size_t
156  * (without autoconf's help, which isn't available because we want
157  * flex-generated scanners to compile on their own).
158  */
159 typedef unsigned int yy_size_t;
160
161
162 struct yy_buffer_state
163         {
164         FILE *yy_input_file;
165
166         char *yy_ch_buf;                /* input buffer */
167         char *yy_buf_pos;               /* current position in input buffer */
168
169         /* Size of input buffer in bytes, not including room for EOB
170          * characters.
171          */
172         yy_size_t yy_buf_size;
173
174         /* Number of characters read into yy_ch_buf, not including EOB
175          * characters.
176          */
177         int yy_n_chars;
178
179         /* Whether we "own" the buffer - i.e., we know we created it,
180          * and can realloc() it to grow it, and should free() it to
181          * delete it.
182          */
183         int yy_is_our_buffer;
184
185         /* Whether this is an "interactive" input source; if so, and
186          * if we're using stdio for input, then we want to use getc()
187          * instead of fread(), to make sure we stop fetching input after
188          * each newline.
189          */
190         int yy_is_interactive;
191
192         /* Whether we're considered to be at the beginning of a line.
193          * If so, '^' rules will be active on the next match, otherwise
194          * not.
195          */
196         int yy_at_bol;
197
198         /* Whether to try to fill the input buffer when we reach the
199          * end of it.
200          */
201         int yy_fill_buffer;
202
203         int yy_buffer_status;
204 #define YY_BUFFER_NEW 0
205 #define YY_BUFFER_NORMAL 1
206         /* When an EOF's been seen but there's still some text to process
207          * then we mark the buffer as YY_EOF_PENDING, to indicate that we
208          * shouldn't try reading from the input source any more.  We might
209          * still have a bunch of tokens to match, though, because of
210          * possible backing-up.
211          *
212          * When we actually see the EOF, we change the status to "new"
213          * (via yyrestart()), so that the user can continue scanning by
214          * just pointing yyin at a new input file.
215          */
216 #define YY_BUFFER_EOF_PENDING 2
217         };
218
219 static YY_BUFFER_STATE yy_current_buffer = 0;
220
221 /* We provide macros for accessing buffer states in case in the
222  * future we want to put the buffer states in a more general
223  * "scanner state".
224  */
225 #define YY_CURRENT_BUFFER yy_current_buffer
226
227
228 /* yy_hold_char holds the character lost when yytext is formed. */
229 static char yy_hold_char;
230
231 static int yy_n_chars;          /* number of characters read into yy_ch_buf */
232
233
234 int yyleng;
235
236 /* Points to current character in buffer. */
237 static char *yy_c_buf_p = (char *) 0;
238 static int yy_init = 1;         /* whether we need to initialize */
239 static int yy_start = 0;        /* start state number */
240
241 /* Flag which is used to allow yywrap()'s to do buffer switches
242  * instead of setting up a fresh yyin.  A bit of a hack ...
243  */
244 static int yy_did_buffer_switch_on_eof;
245
246 void yyrestart YY_PROTO(( FILE *input_file ));
247
248 void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
249 void yy_load_buffer_state YY_PROTO(( void ));
250 YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
251 void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
252 void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
253 void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
254 #define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
255
256 YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
257 YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str ));
258 YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
259
260 static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
261 static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));
262 static void yy_flex_free YY_PROTO(( void * ));
263
264 #define yy_new_buffer yy_create_buffer
265
266 #define yy_set_interactive(is_interactive) \
267         { \
268         if ( ! yy_current_buffer ) \
269                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
270         yy_current_buffer->yy_is_interactive = is_interactive; \
271         }
272
273 #define yy_set_bol(at_bol) \
274         { \
275         if ( ! yy_current_buffer ) \
276                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
277         yy_current_buffer->yy_at_bol = at_bol; \
278         }
279
280 #define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
281
282 typedef unsigned char YY_CHAR;
283 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
284 typedef int yy_state_type;
285 extern char *yytext;
286 #define yytext_ptr yytext
287
288 static yy_state_type yy_get_previous_state YY_PROTO(( void ));
289 static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
290 static int yy_get_next_buffer YY_PROTO(( void ));
291 static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
292
293 /* Done after the current pattern has been matched and before the
294  * corresponding action - sets up yytext.
295  */
296 #define YY_DO_BEFORE_ACTION \
297         yytext_ptr = yy_bp; \
298         yyleng = (int) (yy_cp - yy_bp); \
299         yy_hold_char = *yy_cp; \
300         *yy_cp = '\0'; \
301         yy_c_buf_p = yy_cp;
302
303 #define YY_NUM_RULES 33
304 #define YY_END_OF_BUFFER 34
305 static yyconst short int yy_accept[41] =
306     {   0,
307         0,    0,   34,   32,   33,   32,   30,   31,   32,   32,
308        14,    4,    5,   12,    3,   13,    8,    1,    2,   10,
309         9,   11,    6,    7,   23,   26,   21,   22,   28,   27,
310        29,   24,   25,   19,   20,   18,   15,   17,   16,    0
311     } ;
312
313 static yyconst int yy_ec[256] =
314     {   0,
315         1,    1,    1,    1,    1,    1,    1,    1,    1,    2,
316         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
317         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
318         1,    1,    1,    1,    1,    1,    3,    1,    1,    4,
319         5,    1,    1,    1,    1,    1,    1,    1,    1,    1,
320         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
321         1,    1,    6,    1,    1,    1,    1,    1,    1,    7,
322         1,    1,    8,    1,    1,    1,    9,   10,    1,    1,
323        11,    1,    1,    1,    1,    1,    1,    1,    1,    1,
324         1,   12,    1,    1,    1,    1,    1,    1,   13,   14,
325
326         1,   15,    1,    1,   16,    1,    1,    1,    1,   17,
327         1,    1,    1,   18,   19,   20,    1,    1,    1,    1,
328         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
329         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
330         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
331         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
332         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
333         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
334         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
335         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
336
337         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
338         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
339         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
340         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
341         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
342         1,    1,    1,    1,    1
343     } ;
344
345 static yyconst int yy_meta[21] =
346     {   0,
347         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
348         1,    1,    1,    1,    1,    1,    1,    1,    1,    1
349     } ;
350
351 static yyconst short int yy_base[42] =
352     {   0,
353         0,   11,    7,   73,   73,   21,   73,   73,   35,   52,
354        73,   73,   73,   73,   73,   73,   73,   73,   73,   73,
355        73,   73,   73,   73,   73,   73,   73,   73,   73,   73,
356        73,   73,   73,   73,   73,   73,   73,   73,   73,   73,
357         0
358     } ;
359
360 static yyconst short int yy_def[42] =
361     {   0,
362        41,   41,   40,   40,   40,   40,   40,   40,   40,   40,
363        40,   40,   40,   40,   40,   40,   40,   40,   40,   40,
364        40,   40,   40,   40,   40,   40,   40,   40,   40,   40,
365        40,   40,   40,   40,   40,   40,   40,   40,   40,    0,
366        40
367     } ;
368
369 static yyconst short int yy_nxt[94] =
370     {   0,
371         4,    5,    6,    7,    8,    9,   40,   40,   40,   40,
372        40,   10,    5,    6,    7,    8,    9,   40,   40,   40,
373        40,   40,   10,   11,   40,   40,   40,   12,   13,   14,
374        15,   16,   40,   17,   18,   19,   20,   21,   22,   23,
375        24,   25,   25,   40,   25,   40,   40,   26,   27,   28,
376        29,   30,   31,   32,   33,   34,   35,   36,   40,   40,
377        40,   40,   40,   37,   40,   40,   40,   40,   38,   40,
378        40,   39,    3,   40,   40,   40,   40,   40,   40,   40,
379        40,   40,   40,   40,   40,   40,   40,   40,   40,   40,
380        40,   40,   40
381
382     } ;
383
384 static yyconst short int yy_chk[94] =
385     {   0,
386        41,    1,    1,    1,    1,    1,    3,    0,    0,    0,
387         0,    1,    2,    2,    2,    2,    2,    0,    0,    0,
388         0,    0,    2,    6,    0,    0,    0,    6,    6,    6,
389         6,    6,    0,    6,    6,    6,    6,    6,    6,    6,
390         6,    9,    9,    0,    9,    0,    0,    9,    9,    9,
391         9,    9,    9,    9,    9,   10,   10,   10,    0,    0,
392         0,    0,    0,   10,    0,    0,    0,    0,   10,    0,
393         0,   10,   40,   40,   40,   40,   40,   40,   40,   40,
394        40,   40,   40,   40,   40,   40,   40,   40,   40,   40,
395        40,   40,   40
396
397     } ;
398
399 static yy_state_type yy_last_accepting_state;
400 static char *yy_last_accepting_cpos;
401
402 /* The intent behind this definition is that it'll catch
403  * any uses of REJECT which flex missed.
404  */
405 #define REJECT reject_used_but_not_detected
406 #define yymore() yymore_used_but_not_detected
407 #define YY_MORE_ADJ 0
408 #define YY_RESTORE_YY_MORE_OFFSET
409 char *yytext;
410 #line 1 "quote_fmt.l"
411 #define INITIAL 0
412 #line 2 "quote_fmt.l"
413 #line 414 "lex.quote_fmt.c"
414
415 /* Macros after this point can all be overridden by user definitions in
416  * section 1.
417  */
418
419 #ifndef YY_SKIP_YYWRAP
420 #ifdef __cplusplus
421 extern "C" int yywrap YY_PROTO(( void ));
422 #else
423 extern int yywrap YY_PROTO(( void ));
424 #endif
425 #endif
426
427 #ifndef YY_NO_UNPUT
428 static void yyunput YY_PROTO(( int c, char *buf_ptr ));
429 #endif
430
431 #ifndef yytext_ptr
432 static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
433 #endif
434
435 #ifdef YY_NEED_STRLEN
436 static int yy_flex_strlen YY_PROTO(( yyconst char * ));
437 #endif
438
439 #ifndef YY_NO_INPUT
440 #ifdef __cplusplus
441 static int yyinput YY_PROTO(( void ));
442 #else
443 static int input YY_PROTO(( void ));
444 #endif
445 #endif
446
447 #if YY_STACK_USED
448 static int yy_start_stack_ptr = 0;
449 static int yy_start_stack_depth = 0;
450 static int *yy_start_stack = 0;
451 #ifndef YY_NO_PUSH_STATE
452 static void yy_push_state YY_PROTO(( int new_state ));
453 #endif
454 #ifndef YY_NO_POP_STATE
455 static void yy_pop_state YY_PROTO(( void ));
456 #endif
457 #ifndef YY_NO_TOP_STATE
458 static int yy_top_state YY_PROTO(( void ));
459 #endif
460
461 #else
462 #define YY_NO_PUSH_STATE 1
463 #define YY_NO_POP_STATE 1
464 #define YY_NO_TOP_STATE 1
465 #endif
466
467 #ifdef YY_MALLOC_DECL
468 YY_MALLOC_DECL
469 #else
470 #if __STDC__
471 #ifndef __cplusplus
472 #include <stdlib.h>
473 #endif
474 #else
475 /* Just try to get by without declaring the routines.  This will fail
476  * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
477  * or sizeof(void*) != sizeof(int).
478  */
479 #endif
480 #endif
481
482 /* Amount of stuff to slurp up with each read. */
483 #ifndef YY_READ_BUF_SIZE
484 #define YY_READ_BUF_SIZE 8192
485 #endif
486
487 /* Copy whatever the last rule matched to the standard output. */
488
489 #ifndef ECHO
490 /* This used to be an fputs(), but since the string might contain NUL's,
491  * we now use fwrite().
492  */
493 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
494 #endif
495
496 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
497  * is returned in "result".
498  */
499 #ifndef YY_INPUT
500 #define YY_INPUT(buf,result,max_size) \
501         if ( yy_current_buffer->yy_is_interactive ) \
502                 { \
503                 int c = '*', n; \
504                 for ( n = 0; n < max_size && \
505                              (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
506                         buf[n] = (char) c; \
507                 if ( c == '\n' ) \
508                         buf[n++] = (char) c; \
509                 if ( c == EOF && ferror( yyin ) ) \
510                         YY_FATAL_ERROR( "input in flex scanner failed" ); \
511                 result = n; \
512                 } \
513         else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
514                   && ferror( yyin ) ) \
515                 YY_FATAL_ERROR( "input in flex scanner failed" );
516 #endif
517
518 /* No semi-colon after return; correct usage is to write "yyterminate();" -
519  * we don't want an extra ';' after the "return" because that will cause
520  * some compilers to complain about unreachable statements.
521  */
522 #ifndef yyterminate
523 #define yyterminate() return YY_NULL
524 #endif
525
526 /* Number of entries by which start-condition stack grows. */
527 #ifndef YY_START_STACK_INCR
528 #define YY_START_STACK_INCR 25
529 #endif
530
531 /* Report a fatal error. */
532 #ifndef YY_FATAL_ERROR
533 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
534 #endif
535
536 /* Default declaration of generated scanner - a define so the user can
537  * easily add parameters.
538  */
539 #ifndef YY_DECL
540 #define YY_DECL int yylex YY_PROTO(( void ))
541 #endif
542
543 /* Code executed at the beginning of each rule, after yytext and yyleng
544  * have been set up.
545  */
546 #ifndef YY_USER_ACTION
547 #define YY_USER_ACTION
548 #endif
549
550 /* Code executed at the end of each rule. */
551 #ifndef YY_BREAK
552 #define YY_BREAK break;
553 #endif
554
555 #define YY_RULE_SETUP \
556         YY_USER_ACTION
557
558 YY_DECL
559         {
560         register yy_state_type yy_current_state;
561         register char *yy_cp, *yy_bp;
562         register int yy_act;
563
564 #line 6 "quote_fmt.l"
565
566
567 #line 568 "lex.quote_fmt.c"
568
569         if ( yy_init )
570                 {
571                 yy_init = 0;
572
573 #ifdef YY_USER_INIT
574                 YY_USER_INIT;
575 #endif
576
577                 if ( ! yy_start )
578                         yy_start = 1;   /* first start state */
579
580                 if ( ! yyin )
581                         yyin = stdin;
582
583                 if ( ! yyout )
584                         yyout = stdout;
585
586                 if ( ! yy_current_buffer )
587                         yy_current_buffer =
588                                 yy_create_buffer( yyin, YY_BUF_SIZE );
589
590                 yy_load_buffer_state();
591                 }
592
593         while ( 1 )             /* loops until end-of-file is reached */
594                 {
595                 yy_cp = yy_c_buf_p;
596
597                 /* Support of yytext. */
598                 *yy_cp = yy_hold_char;
599
600                 /* yy_bp points to the position in yy_ch_buf of the start of
601                  * the current run.
602                  */
603                 yy_bp = yy_cp;
604
605                 yy_current_state = yy_start;
606 yy_match:
607                 do
608                         {
609                         register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
610                         if ( yy_accept[yy_current_state] )
611                                 {
612                                 yy_last_accepting_state = yy_current_state;
613                                 yy_last_accepting_cpos = yy_cp;
614                                 }
615                         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
616                                 {
617                                 yy_current_state = (int) yy_def[yy_current_state];
618                                 if ( yy_current_state >= 41 )
619                                         yy_c = yy_meta[(unsigned int) yy_c];
620                                 }
621                         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
622                         ++yy_cp;
623                         }
624                 while ( yy_base[yy_current_state] != 73 );
625
626 yy_find_action:
627                 yy_act = yy_accept[yy_current_state];
628                 if ( yy_act == 0 )
629                         { /* have to back up */
630                         yy_cp = yy_last_accepting_cpos;
631                         yy_current_state = yy_last_accepting_state;
632                         yy_act = yy_accept[yy_current_state];
633                         }
634
635                 YY_DO_BEFORE_ACTION;
636
637
638 do_action:      /* This label is used only to access EOF actions. */
639
640
641                 switch ( yy_act )
642         { /* beginning of action switch */
643                         case 0: /* must back up */
644                         /* undo the effects of YY_DO_BEFORE_ACTION */
645                         *yy_cp = yy_hold_char;
646                         yy_cp = yy_last_accepting_cpos;
647                         yy_current_state = yy_last_accepting_state;
648                         goto yy_find_action;
649
650 case 1:
651 YY_RULE_SETUP
652 #line 8 "quote_fmt.l"
653 /* date */ return SHOW_DATE;
654         YY_BREAK
655 case 2:
656 YY_RULE_SETUP
657 #line 9 "quote_fmt.l"
658 /* From */ return SHOW_FROM;
659         YY_BREAK
660 case 3:
661 YY_RULE_SETUP
662 #line 10 "quote_fmt.l"
663 /* Full name */ return SHOW_FULLNAME;
664         YY_BREAK
665 case 4:
666 YY_RULE_SETUP
667 #line 11 "quote_fmt.l"
668 /* firt name */ return SHOW_FIRST_NAME;
669         YY_BREAK
670 case 5:
671 YY_RULE_SETUP
672 #line 12 "quote_fmt.l"
673 /* initial of sender */ return SHOW_SENDER_INITIAL;
674         YY_BREAK
675 case 6:
676 YY_RULE_SETUP
677 #line 13 "quote_fmt.l"
678 /* subject */ return SHOW_SUBJECT;
679         YY_BREAK
680 case 7:
681 YY_RULE_SETUP
682 #line 14 "quote_fmt.l"
683 /* to */ return SHOW_TO;
684         YY_BREAK
685 case 8:
686 YY_RULE_SETUP
687 #line 15 "quote_fmt.l"
688 /* cc */ return SHOW_CC;
689         YY_BREAK
690 case 9:
691 YY_RULE_SETUP
692 #line 16 "quote_fmt.l"
693 /* newsgroups */ return SHOW_NEWSGROUPS;
694         YY_BREAK
695 case 10:
696 YY_RULE_SETUP
697 #line 17 "quote_fmt.l"
698 /* message-id */ return SHOW_MESSAGEID;
699         YY_BREAK
700 case 11:
701 YY_RULE_SETUP
702 #line 18 "quote_fmt.l"
703 /* references */ return SHOW_REFERENCES;
704         YY_BREAK
705 case 12:
706 YY_RULE_SETUP
707 #line 19 "quote_fmt.l"
708 /* message */ return SHOW_MESSAGE;
709         YY_BREAK
710 case 13:
711 YY_RULE_SETUP
712 #line 20 "quote_fmt.l"
713 /* quoted message */ return SHOW_QUOTED_MESSAGE;
714         YY_BREAK
715 case 14:
716 YY_RULE_SETUP
717 #line 21 "quote_fmt.l"
718 /* % */ return SHOW_PERCENT;
719         YY_BREAK
720 case 15:
721 YY_RULE_SETUP
722 #line 22 "quote_fmt.l"
723 /* \ */ return SHOW_BACKSLASH;
724         YY_BREAK
725 case 16:
726 YY_RULE_SETUP
727 #line 23 "quote_fmt.l"
728 /* tab */ return SHOW_TAB;
729         YY_BREAK
730 case 17:
731 YY_RULE_SETUP
732 #line 24 "quote_fmt.l"
733 /* retour à la ligne */ return SHOW_EOL;
734         YY_BREAK
735 case 18:
736 YY_RULE_SETUP
737 #line 25 "quote_fmt.l"
738 /* ? */ return SHOW_QUESTION_MARK;
739         YY_BREAK
740 case 19:
741 YY_RULE_SETUP
742 #line 26 "quote_fmt.l"
743 return SHOW_OPARENT;
744         YY_BREAK
745 case 20:
746 YY_RULE_SETUP
747 #line 27 "quote_fmt.l"
748 return SHOW_CPARENT;
749         YY_BREAK
750 case 21:
751 YY_RULE_SETUP
752 #line 28 "quote_fmt.l"
753 /* query date */ return QUERY_DATE;
754         YY_BREAK
755 case 22:
756 YY_RULE_SETUP
757 #line 29 "quote_fmt.l"
758 /* query from */ return QUERY_FROM;
759         YY_BREAK
760 case 23:
761 YY_RULE_SETUP
762 #line 30 "quote_fmt.l"
763 /* query from name */ return QUERY_FULLNAME;
764         YY_BREAK
765 case 24:
766 YY_RULE_SETUP
767 #line 31 "quote_fmt.l"
768 /* query subject */ return QUERY_SUBJECT;
769         YY_BREAK
770 case 25:
771 YY_RULE_SETUP
772 #line 32 "quote_fmt.l"
773 /* query to */ return QUERY_TO;
774         YY_BREAK
775 case 26:
776 YY_RULE_SETUP
777 #line 33 "quote_fmt.l"
778 /* query cc */ return QUERY_CC;
779         YY_BREAK
780 case 27:
781 YY_RULE_SETUP
782 #line 34 "quote_fmt.l"
783 /* query newsgroups */ return QUERY_NEWSGROUPS;
784         YY_BREAK
785 case 28:
786 YY_RULE_SETUP
787 #line 35 "quote_fmt.l"
788 /* query message-id */ return QUERY_MESSAGEID;
789         YY_BREAK
790 case 29:
791 YY_RULE_SETUP
792 #line 36 "quote_fmt.l"
793 /* query references */ return QUERY_REFERENCES;
794         YY_BREAK
795 case 30:
796 YY_RULE_SETUP
797 #line 37 "quote_fmt.l"
798 return OPARENT;
799         YY_BREAK
800 case 31:
801 YY_RULE_SETUP
802 #line 38 "quote_fmt.l"
803 return CPARENT;
804         YY_BREAK
805 case 32:
806 YY_RULE_SETUP
807 #line 39 "quote_fmt.l"
808 return CHARACTER;
809         YY_BREAK
810 case 33:
811 YY_RULE_SETUP
812 #line 41 "quote_fmt.l"
813 ECHO;
814         YY_BREAK
815 #line 816 "lex.quote_fmt.c"
816 case YY_STATE_EOF(INITIAL):
817         yyterminate();
818
819         case YY_END_OF_BUFFER:
820                 {
821                 /* Amount of text matched not including the EOB char. */
822                 int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
823
824                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
825                 *yy_cp = yy_hold_char;
826                 YY_RESTORE_YY_MORE_OFFSET
827
828                 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
829                         {
830                         /* We're scanning a new file or input source.  It's
831                          * possible that this happened because the user
832                          * just pointed yyin at a new source and called
833                          * yylex().  If so, then we have to assure
834                          * consistency between yy_current_buffer and our
835                          * globals.  Here is the right place to do so, because
836                          * this is the first action (other than possibly a
837                          * back-up) that will match for the new input source.
838                          */
839                         yy_n_chars = yy_current_buffer->yy_n_chars;
840                         yy_current_buffer->yy_input_file = yyin;
841                         yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
842                         }
843
844                 /* Note that here we test for yy_c_buf_p "<=" to the position
845                  * of the first EOB in the buffer, since yy_c_buf_p will
846                  * already have been incremented past the NUL character
847                  * (since all states make transitions on EOB to the
848                  * end-of-buffer state).  Contrast this with the test
849                  * in input().
850                  */
851                 if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
852                         { /* This was really a NUL. */
853                         yy_state_type yy_next_state;
854
855                         yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
856
857                         yy_current_state = yy_get_previous_state();
858
859                         /* Okay, we're now positioned to make the NUL
860                          * transition.  We couldn't have
861                          * yy_get_previous_state() go ahead and do it
862                          * for us because it doesn't know how to deal
863                          * with the possibility of jamming (and we don't
864                          * want to build jamming into it because then it
865                          * will run more slowly).
866                          */
867
868                         yy_next_state = yy_try_NUL_trans( yy_current_state );
869
870                         yy_bp = yytext_ptr + YY_MORE_ADJ;
871
872                         if ( yy_next_state )
873                                 {
874                                 /* Consume the NUL. */
875                                 yy_cp = ++yy_c_buf_p;
876                                 yy_current_state = yy_next_state;
877                                 goto yy_match;
878                                 }
879
880                         else
881                                 {
882                                 yy_cp = yy_c_buf_p;
883                                 goto yy_find_action;
884                                 }
885                         }
886
887                 else switch ( yy_get_next_buffer() )
888                         {
889                         case EOB_ACT_END_OF_FILE:
890                                 {
891                                 yy_did_buffer_switch_on_eof = 0;
892
893                                 if ( yywrap() )
894                                         {
895                                         /* Note: because we've taken care in
896                                          * yy_get_next_buffer() to have set up
897                                          * yytext, we can now set up
898                                          * yy_c_buf_p so that if some total
899                                          * hoser (like flex itself) wants to
900                                          * call the scanner after we return the
901                                          * YY_NULL, it'll still work - another
902                                          * YY_NULL will get returned.
903                                          */
904                                         yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
905
906                                         yy_act = YY_STATE_EOF(YY_START);
907                                         goto do_action;
908                                         }
909
910                                 else
911                                         {
912                                         if ( ! yy_did_buffer_switch_on_eof )
913                                                 YY_NEW_FILE;
914                                         }
915                                 break;
916                                 }
917
918                         case EOB_ACT_CONTINUE_SCAN:
919                                 yy_c_buf_p =
920                                         yytext_ptr + yy_amount_of_matched_text;
921
922                                 yy_current_state = yy_get_previous_state();
923
924                                 yy_cp = yy_c_buf_p;
925                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
926                                 goto yy_match;
927
928                         case EOB_ACT_LAST_MATCH:
929                                 yy_c_buf_p =
930                                 &yy_current_buffer->yy_ch_buf[yy_n_chars];
931
932                                 yy_current_state = yy_get_previous_state();
933
934                                 yy_cp = yy_c_buf_p;
935                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
936                                 goto yy_find_action;
937                         }
938                 break;
939                 }
940
941         default:
942                 YY_FATAL_ERROR(
943                         "fatal flex scanner internal error--no action found" );
944         } /* end of action switch */
945                 } /* end of scanning one token */
946         } /* end of yylex */
947
948
949 /* yy_get_next_buffer - try to read in a new buffer
950  *
951  * Returns a code representing an action:
952  *      EOB_ACT_LAST_MATCH -
953  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
954  *      EOB_ACT_END_OF_FILE - end of file
955  */
956
957 static int yy_get_next_buffer()
958         {
959         register char *dest = yy_current_buffer->yy_ch_buf;
960         register char *source = yytext_ptr;
961         register int number_to_move, i;
962         int ret_val;
963
964         if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
965                 YY_FATAL_ERROR(
966                 "fatal flex scanner internal error--end of buffer missed" );
967
968         if ( yy_current_buffer->yy_fill_buffer == 0 )
969                 { /* Don't try to fill the buffer, so this is an EOF. */
970                 if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
971                         {
972                         /* We matched a single character, the EOB, so
973                          * treat this as a final EOF.
974                          */
975                         return EOB_ACT_END_OF_FILE;
976                         }
977
978                 else
979                         {
980                         /* We matched some text prior to the EOB, first
981                          * process it.
982                          */
983                         return EOB_ACT_LAST_MATCH;
984                         }
985                 }
986
987         /* Try to read more data. */
988
989         /* First move last chars to start of buffer. */
990         number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
991
992         for ( i = 0; i < number_to_move; ++i )
993                 *(dest++) = *(source++);
994
995         if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
996                 /* don't do the read, it's not guaranteed to return an EOF,
997                  * just force an EOF
998                  */
999                 yy_current_buffer->yy_n_chars = yy_n_chars = 0;
1000
1001         else
1002                 {
1003                 int num_to_read =
1004                         yy_current_buffer->yy_buf_size - number_to_move - 1;
1005
1006                 while ( num_to_read <= 0 )
1007                         { /* Not enough room in the buffer - grow it. */
1008 #ifdef YY_USES_REJECT
1009                         YY_FATAL_ERROR(
1010 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
1011 #else
1012
1013                         /* just a shorter name for the current buffer */
1014                         YY_BUFFER_STATE b = yy_current_buffer;
1015
1016                         int yy_c_buf_p_offset =
1017                                 (int) (yy_c_buf_p - b->yy_ch_buf);
1018
1019                         if ( b->yy_is_our_buffer )
1020                                 {
1021                                 int new_size = b->yy_buf_size * 2;
1022
1023                                 if ( new_size <= 0 )
1024                                         b->yy_buf_size += b->yy_buf_size / 8;
1025                                 else
1026                                         b->yy_buf_size *= 2;
1027
1028                                 b->yy_ch_buf = (char *)
1029                                         /* Include room in for 2 EOB chars. */
1030                                         yy_flex_realloc( (void *) b->yy_ch_buf,
1031                                                          b->yy_buf_size + 2 );
1032                                 }
1033                         else
1034                                 /* Can't grow it, we don't own it. */
1035                                 b->yy_ch_buf = 0;
1036
1037                         if ( ! b->yy_ch_buf )
1038                                 YY_FATAL_ERROR(
1039                                 "fatal error - scanner input buffer overflow" );
1040
1041                         yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
1042
1043                         num_to_read = yy_current_buffer->yy_buf_size -
1044                                                 number_to_move - 1;
1045 #endif
1046                         }
1047
1048                 if ( num_to_read > YY_READ_BUF_SIZE )
1049                         num_to_read = YY_READ_BUF_SIZE;
1050
1051                 /* Read in more data. */
1052                 YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
1053                         yy_n_chars, num_to_read );
1054
1055                 yy_current_buffer->yy_n_chars = yy_n_chars;
1056                 }
1057
1058         if ( yy_n_chars == 0 )
1059                 {
1060                 if ( number_to_move == YY_MORE_ADJ )
1061                         {
1062                         ret_val = EOB_ACT_END_OF_FILE;
1063                         yyrestart( yyin );
1064                         }
1065
1066                 else
1067                         {
1068                         ret_val = EOB_ACT_LAST_MATCH;
1069                         yy_current_buffer->yy_buffer_status =
1070                                 YY_BUFFER_EOF_PENDING;
1071                         }
1072                 }
1073
1074         else
1075                 ret_val = EOB_ACT_CONTINUE_SCAN;
1076
1077         yy_n_chars += number_to_move;
1078         yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
1079         yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
1080
1081         yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
1082
1083         return ret_val;
1084         }
1085
1086
1087 /* yy_get_previous_state - get the state just before the EOB char was reached */
1088
1089 static yy_state_type yy_get_previous_state()
1090         {
1091         register yy_state_type yy_current_state;
1092         register char *yy_cp;
1093
1094         yy_current_state = yy_start;
1095
1096         for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
1097                 {
1098                 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1099                 if ( yy_accept[yy_current_state] )
1100                         {
1101                         yy_last_accepting_state = yy_current_state;
1102                         yy_last_accepting_cpos = yy_cp;
1103                         }
1104                 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1105                         {
1106                         yy_current_state = (int) yy_def[yy_current_state];
1107                         if ( yy_current_state >= 41 )
1108                                 yy_c = yy_meta[(unsigned int) yy_c];
1109                         }
1110                 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1111                 }
1112
1113         return yy_current_state;
1114         }
1115
1116
1117 /* yy_try_NUL_trans - try to make a transition on the NUL character
1118  *
1119  * synopsis
1120  *      next_state = yy_try_NUL_trans( current_state );
1121  */
1122
1123 #ifdef YY_USE_PROTOS
1124 static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
1125 #else
1126 static yy_state_type yy_try_NUL_trans( yy_current_state )
1127 yy_state_type yy_current_state;
1128 #endif
1129         {
1130         register int yy_is_jam;
1131         register char *yy_cp = yy_c_buf_p;
1132
1133         register YY_CHAR yy_c = 1;
1134         if ( yy_accept[yy_current_state] )
1135                 {
1136                 yy_last_accepting_state = yy_current_state;
1137                 yy_last_accepting_cpos = yy_cp;
1138                 }
1139         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1140                 {
1141                 yy_current_state = (int) yy_def[yy_current_state];
1142                 if ( yy_current_state >= 41 )
1143                         yy_c = yy_meta[(unsigned int) yy_c];
1144                 }
1145         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1146         yy_is_jam = (yy_current_state == 40);
1147
1148         return yy_is_jam ? 0 : yy_current_state;
1149         }
1150
1151
1152 #ifndef YY_NO_UNPUT
1153 #ifdef YY_USE_PROTOS
1154 static void yyunput( int c, register char *yy_bp )
1155 #else
1156 static void yyunput( c, yy_bp )
1157 int c;
1158 register char *yy_bp;
1159 #endif
1160         {
1161         register char *yy_cp = yy_c_buf_p;
1162
1163         /* undo effects of setting up yytext */
1164         *yy_cp = yy_hold_char;
1165
1166         if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1167                 { /* need to shift things up to make room */
1168                 /* +2 for EOB chars. */
1169                 register int number_to_move = yy_n_chars + 2;
1170                 register char *dest = &yy_current_buffer->yy_ch_buf[
1171                                         yy_current_buffer->yy_buf_size + 2];
1172                 register char *source =
1173                                 &yy_current_buffer->yy_ch_buf[number_to_move];
1174
1175                 while ( source > yy_current_buffer->yy_ch_buf )
1176                         *--dest = *--source;
1177
1178                 yy_cp += (int) (dest - source);
1179                 yy_bp += (int) (dest - source);
1180                 yy_current_buffer->yy_n_chars =
1181                         yy_n_chars = yy_current_buffer->yy_buf_size;
1182
1183                 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1184                         YY_FATAL_ERROR( "flex scanner push-back overflow" );
1185                 }
1186
1187         *--yy_cp = (char) c;
1188
1189
1190         yytext_ptr = yy_bp;
1191         yy_hold_char = *yy_cp;
1192         yy_c_buf_p = yy_cp;
1193         }
1194 #endif  /* ifndef YY_NO_UNPUT */
1195
1196
1197 #ifdef __cplusplus
1198 static int yyinput()
1199 #else
1200 static int input()
1201 #endif
1202         {
1203         int c;
1204
1205         *yy_c_buf_p = yy_hold_char;
1206
1207         if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
1208                 {
1209                 /* yy_c_buf_p now points to the character we want to return.
1210                  * If this occurs *before* the EOB characters, then it's a
1211                  * valid NUL; if not, then we've hit the end of the buffer.
1212                  */
1213                 if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
1214                         /* This was really a NUL. */
1215                         *yy_c_buf_p = '\0';
1216
1217                 else
1218                         { /* need more input */
1219                         int offset = yy_c_buf_p - yytext_ptr;
1220                         ++yy_c_buf_p;
1221
1222                         switch ( yy_get_next_buffer() )
1223                                 {
1224                                 case EOB_ACT_LAST_MATCH:
1225                                         /* This happens because yy_g_n_b()
1226                                          * sees that we've accumulated a
1227                                          * token and flags that we need to
1228                                          * try matching the token before
1229                                          * proceeding.  But for input(),
1230                                          * there's no matching to consider.
1231                                          * So convert the EOB_ACT_LAST_MATCH
1232                                          * to EOB_ACT_END_OF_FILE.
1233                                          */
1234
1235                                         /* Reset buffer status. */
1236                                         yyrestart( yyin );
1237
1238                                         /* fall through */
1239
1240                                 case EOB_ACT_END_OF_FILE:
1241                                         {
1242                                         if ( yywrap() )
1243                                                 return EOF;
1244
1245                                         if ( ! yy_did_buffer_switch_on_eof )
1246                                                 YY_NEW_FILE;
1247 #ifdef __cplusplus
1248                                         return yyinput();
1249 #else
1250                                         return input();
1251 #endif
1252                                         }
1253
1254                                 case EOB_ACT_CONTINUE_SCAN:
1255                                         yy_c_buf_p = yytext_ptr + offset;
1256                                         break;
1257                                 }
1258                         }
1259                 }
1260
1261         c = *(unsigned char *) yy_c_buf_p;      /* cast for 8-bit char's */
1262         *yy_c_buf_p = '\0';     /* preserve yytext */
1263         yy_hold_char = *++yy_c_buf_p;
1264
1265
1266         return c;
1267         }
1268
1269
1270 #ifdef YY_USE_PROTOS
1271 void yyrestart( FILE *input_file )
1272 #else
1273 void yyrestart( input_file )
1274 FILE *input_file;
1275 #endif
1276         {
1277         if ( ! yy_current_buffer )
1278                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
1279
1280         yy_init_buffer( yy_current_buffer, input_file );
1281         yy_load_buffer_state();
1282         }
1283
1284
1285 #ifdef YY_USE_PROTOS
1286 void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
1287 #else
1288 void yy_switch_to_buffer( new_buffer )
1289 YY_BUFFER_STATE new_buffer;
1290 #endif
1291         {
1292         if ( yy_current_buffer == new_buffer )
1293                 return;
1294
1295         if ( yy_current_buffer )
1296                 {
1297                 /* Flush out information for old buffer. */
1298                 *yy_c_buf_p = yy_hold_char;
1299                 yy_current_buffer->yy_buf_pos = yy_c_buf_p;
1300                 yy_current_buffer->yy_n_chars = yy_n_chars;
1301                 }
1302
1303         yy_current_buffer = new_buffer;
1304         yy_load_buffer_state();
1305
1306         /* We don't actually know whether we did this switch during
1307          * EOF (yywrap()) processing, but the only time this flag
1308          * is looked at is after yywrap() is called, so it's safe
1309          * to go ahead and always set it.
1310          */
1311         yy_did_buffer_switch_on_eof = 1;
1312         }
1313
1314
1315 #ifdef YY_USE_PROTOS
1316 void yy_load_buffer_state( void )
1317 #else
1318 void yy_load_buffer_state()
1319 #endif
1320         {
1321         yy_n_chars = yy_current_buffer->yy_n_chars;
1322         yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
1323         yyin = yy_current_buffer->yy_input_file;
1324         yy_hold_char = *yy_c_buf_p;
1325         }
1326
1327
1328 #ifdef YY_USE_PROTOS
1329 YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
1330 #else
1331 YY_BUFFER_STATE yy_create_buffer( file, size )
1332 FILE *file;
1333 int size;
1334 #endif
1335         {
1336         YY_BUFFER_STATE b;
1337
1338         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
1339         if ( ! b )
1340                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1341
1342         b->yy_buf_size = size;
1343
1344         /* yy_ch_buf has to be 2 characters longer than the size given because
1345          * we need to put in 2 end-of-buffer characters.
1346          */
1347         b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
1348         if ( ! b->yy_ch_buf )
1349                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1350
1351         b->yy_is_our_buffer = 1;
1352
1353         yy_init_buffer( b, file );
1354
1355         return b;
1356         }
1357
1358
1359 #ifdef YY_USE_PROTOS
1360 void yy_delete_buffer( YY_BUFFER_STATE b )
1361 #else
1362 void yy_delete_buffer( b )
1363 YY_BUFFER_STATE b;
1364 #endif
1365         {
1366         if ( ! b )
1367                 return;
1368
1369         if ( b == yy_current_buffer )
1370                 yy_current_buffer = (YY_BUFFER_STATE) 0;
1371
1372         if ( b->yy_is_our_buffer )
1373                 yy_flex_free( (void *) b->yy_ch_buf );
1374
1375         yy_flex_free( (void *) b );
1376         }
1377
1378
1379 #ifndef YY_ALWAYS_INTERACTIVE
1380 #ifndef YY_NEVER_INTERACTIVE
1381 extern int isatty YY_PROTO(( int ));
1382 #endif
1383 #endif
1384
1385 #ifdef YY_USE_PROTOS
1386 void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
1387 #else
1388 void yy_init_buffer( b, file )
1389 YY_BUFFER_STATE b;
1390 FILE *file;
1391 #endif
1392
1393
1394         {
1395         yy_flush_buffer( b );
1396
1397         b->yy_input_file = file;
1398         b->yy_fill_buffer = 1;
1399
1400 #if YY_ALWAYS_INTERACTIVE
1401         b->yy_is_interactive = 1;
1402 #else
1403 #if YY_NEVER_INTERACTIVE
1404         b->yy_is_interactive = 0;
1405 #else
1406         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1407 #endif
1408 #endif
1409         }
1410
1411
1412 #ifdef YY_USE_PROTOS
1413 void yy_flush_buffer( YY_BUFFER_STATE b )
1414 #else
1415 void yy_flush_buffer( b )
1416 YY_BUFFER_STATE b;
1417 #endif
1418
1419         {
1420         if ( ! b )
1421                 return;
1422
1423         b->yy_n_chars = 0;
1424
1425         /* We always need two end-of-buffer characters.  The first causes
1426          * a transition to the end-of-buffer state.  The second causes
1427          * a jam in that state.
1428          */
1429         b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1430         b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1431
1432         b->yy_buf_pos = &b->yy_ch_buf[0];
1433
1434         b->yy_at_bol = 1;
1435         b->yy_buffer_status = YY_BUFFER_NEW;
1436
1437         if ( b == yy_current_buffer )
1438                 yy_load_buffer_state();
1439         }
1440
1441
1442 #ifndef YY_NO_SCAN_BUFFER
1443 #ifdef YY_USE_PROTOS
1444 YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
1445 #else
1446 YY_BUFFER_STATE yy_scan_buffer( base, size )
1447 char *base;
1448 yy_size_t size;
1449 #endif
1450         {
1451         YY_BUFFER_STATE b;
1452
1453         if ( size < 2 ||
1454              base[size-2] != YY_END_OF_BUFFER_CHAR ||
1455              base[size-1] != YY_END_OF_BUFFER_CHAR )
1456                 /* They forgot to leave room for the EOB's. */
1457                 return 0;
1458
1459         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
1460         if ( ! b )
1461                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
1462
1463         b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
1464         b->yy_buf_pos = b->yy_ch_buf = base;
1465         b->yy_is_our_buffer = 0;
1466         b->yy_input_file = 0;
1467         b->yy_n_chars = b->yy_buf_size;
1468         b->yy_is_interactive = 0;
1469         b->yy_at_bol = 1;
1470         b->yy_fill_buffer = 0;
1471         b->yy_buffer_status = YY_BUFFER_NEW;
1472
1473         yy_switch_to_buffer( b );
1474
1475         return b;
1476         }
1477 #endif
1478
1479
1480 #ifndef YY_NO_SCAN_STRING
1481 #ifdef YY_USE_PROTOS
1482 YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
1483 #else
1484 YY_BUFFER_STATE yy_scan_string( yy_str )
1485 yyconst char *yy_str;
1486 #endif
1487         {
1488         int len;
1489         for ( len = 0; yy_str[len]; ++len )
1490                 ;
1491
1492         return yy_scan_bytes( yy_str, len );
1493         }
1494 #endif
1495
1496
1497 #ifndef YY_NO_SCAN_BYTES
1498 #ifdef YY_USE_PROTOS
1499 YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
1500 #else
1501 YY_BUFFER_STATE yy_scan_bytes( bytes, len )
1502 yyconst char *bytes;
1503 int len;
1504 #endif
1505         {
1506         YY_BUFFER_STATE b;
1507         char *buf;
1508         yy_size_t n;
1509         int i;
1510
1511         /* Get memory for full buffer, including space for trailing EOB's. */
1512         n = len + 2;
1513         buf = (char *) yy_flex_alloc( n );
1514         if ( ! buf )
1515                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
1516
1517         for ( i = 0; i < len; ++i )
1518                 buf[i] = bytes[i];
1519
1520         buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
1521
1522         b = yy_scan_buffer( buf, n );
1523         if ( ! b )
1524                 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
1525
1526         /* It's okay to grow etc. this buffer, and we should throw it
1527          * away when we're done.
1528          */
1529         b->yy_is_our_buffer = 1;
1530
1531         return b;
1532         }
1533 #endif
1534
1535
1536 #ifndef YY_NO_PUSH_STATE
1537 #ifdef YY_USE_PROTOS
1538 static void yy_push_state( int new_state )
1539 #else
1540 static void yy_push_state( new_state )
1541 int new_state;
1542 #endif
1543         {
1544         if ( yy_start_stack_ptr >= yy_start_stack_depth )
1545                 {
1546                 yy_size_t new_size;
1547
1548                 yy_start_stack_depth += YY_START_STACK_INCR;
1549                 new_size = yy_start_stack_depth * sizeof( int );
1550
1551                 if ( ! yy_start_stack )
1552                         yy_start_stack = (int *) yy_flex_alloc( new_size );
1553
1554                 else
1555                         yy_start_stack = (int *) yy_flex_realloc(
1556                                         (void *) yy_start_stack, new_size );
1557
1558                 if ( ! yy_start_stack )
1559                         YY_FATAL_ERROR(
1560                         "out of memory expanding start-condition stack" );
1561                 }
1562
1563         yy_start_stack[yy_start_stack_ptr++] = YY_START;
1564
1565         BEGIN(new_state);
1566         }
1567 #endif
1568
1569
1570 #ifndef YY_NO_POP_STATE
1571 static void yy_pop_state()
1572         {
1573         if ( --yy_start_stack_ptr < 0 )
1574                 YY_FATAL_ERROR( "start-condition stack underflow" );
1575
1576         BEGIN(yy_start_stack[yy_start_stack_ptr]);
1577         }
1578 #endif
1579
1580
1581 #ifndef YY_NO_TOP_STATE
1582 static int yy_top_state()
1583         {
1584         return yy_start_stack[yy_start_stack_ptr - 1];
1585         }
1586 #endif
1587
1588 #ifndef YY_EXIT_FAILURE
1589 #define YY_EXIT_FAILURE 2
1590 #endif
1591
1592 #ifdef YY_USE_PROTOS
1593 static void yy_fatal_error( yyconst char msg[] )
1594 #else
1595 static void yy_fatal_error( msg )
1596 char msg[];
1597 #endif
1598         {
1599         (void) fprintf( stderr, "%s\n", msg );
1600         exit( YY_EXIT_FAILURE );
1601         }
1602
1603
1604
1605 /* Redefine yyless() so it works in section 3 code. */
1606
1607 #undef yyless
1608 #define yyless(n) \
1609         do \
1610                 { \
1611                 /* Undo effects of setting up yytext. */ \
1612                 yytext[yyleng] = yy_hold_char; \
1613                 yy_c_buf_p = yytext + n; \
1614                 yy_hold_char = *yy_c_buf_p; \
1615                 *yy_c_buf_p = '\0'; \
1616                 yyleng = n; \
1617                 } \
1618         while ( 0 )
1619
1620
1621 /* Internal utility routines. */
1622
1623 #ifndef yytext_ptr
1624 #ifdef YY_USE_PROTOS
1625 static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
1626 #else
1627 static void yy_flex_strncpy( s1, s2, n )
1628 char *s1;
1629 yyconst char *s2;
1630 int n;
1631 #endif
1632         {
1633         register int i;
1634         for ( i = 0; i < n; ++i )
1635                 s1[i] = s2[i];
1636         }
1637 #endif
1638
1639 #ifdef YY_NEED_STRLEN
1640 #ifdef YY_USE_PROTOS
1641 static int yy_flex_strlen( yyconst char *s )
1642 #else
1643 static int yy_flex_strlen( s )
1644 yyconst char *s;
1645 #endif
1646         {
1647         register int n;
1648         for ( n = 0; s[n]; ++n )
1649                 ;
1650
1651         return n;
1652         }
1653 #endif
1654
1655
1656 #ifdef YY_USE_PROTOS
1657 static void *yy_flex_alloc( yy_size_t size )
1658 #else
1659 static void *yy_flex_alloc( size )
1660 yy_size_t size;
1661 #endif
1662         {
1663         return (void *) malloc( size );
1664         }
1665
1666 #ifdef YY_USE_PROTOS
1667 static void *yy_flex_realloc( void *ptr, yy_size_t size )
1668 #else
1669 static void *yy_flex_realloc( ptr, size )
1670 void *ptr;
1671 yy_size_t size;
1672 #endif
1673         {
1674         /* The cast to (char *) in the following accommodates both
1675          * implementations that use char* generic pointers, and those
1676          * that use void* generic pointers.  It works with the latter
1677          * because both ANSI C and C++ allow castless assignment from
1678          * any pointer type to void*, and deal with argument conversions
1679          * as though doing an assignment.
1680          */
1681         return (void *) realloc( (char *) ptr, size );
1682         }
1683
1684 #ifdef YY_USE_PROTOS
1685 static void yy_flex_free( void *ptr )
1686 #else
1687 static void yy_flex_free( ptr )
1688 void *ptr;
1689 #endif
1690         {
1691         free( ptr );
1692         }
1693
1694 #if YY_MAIN
1695 int main()
1696         {
1697         yylex();
1698         return 0;
1699         }
1700 #endif
1701 #line 41 "quote_fmt.l"
1702