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