| blob | 8cb5ff5ac35a2b2efe6464273d79feb7df2ffc52 |
1 diff -urN empty/config.h src/config.h
2 --- empty/config.h Thu Jan 1 00:00:00 1970
3 +++ src/config.h Sat May 11 01:05:28 2002
4 @@ -0,0 +1,389 @@
5 +/* config.h.in. Generated automatically from configure.in by autoheader 2.13. */
6 +
7 +/* Define to 1 if translation of program messages to the user's native language
8 + is requested. */
9 +#define ENABLE_NLS 1
10 +//tm/* #undef HAVE_CATGETS */
11 +/* Define if the GNU gettext() function is already present or preinstalled. */
12 +#define HAVE_GETTEXT 1
13 +/* Define if your <locale.h> file defines LC_MESSAGES. */
14 +#undef HAVE_LC_MESSAGES
15 +
16 +/* #undef HAVE_STPCPY */
17 +
18 +//#define HAVE_GDK_PIXBUF 1
19 +#undef HAVE_GDK_PIXBUF
20 +#undef HAVE_GDK_IMLIB
21 +
22 +#undef USE_XIM
23 +
24 +/* OK: include gthread-2.0.lib * Whether to use multithread or not */
25 +#undef USE_THREADS
26 +
27 +/* Define if you want IPv6 support. */
28 +#undef INET6
29 +
30 +/* GPGME has no VC project * Define if you use GPGME to support OpenPGP */
31 +//#undef USE_GPGME
32 +#define USE_GPGME 1
33 +
34 +/* Define if you use PSPELL to support spell checking */
35 +/* #undef USE_PSPELL */
36 +
37 +/* Define PSPELL's default directory */
38 +/* #undef PSPELL_PATH */
39 +
40 +/* Define if you use OpenSSL to support SSL */
41 +#define USE_SSL 1
42 +
43 +/* Define if you want JPilot support in addressbook. */
44 +#undef USE_JPILOT
45 +
46 +/* OPENLDAP doesnt compile * Define if you want LDAP support in addressbook. */
47 +#undef USE_LDAP
48 +
49 +/* Define to `unsigned int' if <stddef.h> or <wchar.h> doesn't define. */
50 +#undef wint_t
51 +
52 +/* Used to test for a u32 typedef */
53 +#undef HAVE_U32_TYPEDEF
54 +
55 +
56 +#define CLAWS 1
57 +
58 +//#define PACKAGE_DATA_DIR "/usr/local/share/sylpheed"
59 +
60 +/* Define to one of _getb67, GETB67, getb67 for Cray-2 and Cray-YMP systems.
61 + This function is required for alloca.c support on those systems. */
62 +
63 +#undef CRAY_STACKSEG_END
64 +
65 +/* Define if using alloca.c. */
66 +#undef C_ALLOCA
67 +
68 +/* Define to 1 if translation of program messages to the user's native
69 + language is requested. */
70 +//#define ENABLE_NLS 1
71 +
72 +/* Define if you have alloca, as a function or macro. */
73 +#undef HAVE_ALLOCA
74 +
75 +/* Define if you have <alloca.h> and it should be used (not on Ultrix). */
76 +#undef HAVE_ALLOCA_H
77 +
78 +/* Define if you have the <argz.h> header file. */
79 +#undef HAVE_ARGZ_H
80 +
81 +/* Define if you have the dcgettext function. */
82 +#undef HAVE_DCGETTEXT
83 +
84 +/* Define if you have the <dirent.h> header file. */
85 +#undef HAVE_DIRENT_H
86 +
87 +/* Define if you have the <dlfcn.h> header file. */
88 +#undef HAVE_DLFCN_H
89 +
90 +/* Define if you have the fchmod function. */
91 +#undef HAVE_FCHMOD
92 +
93 +/* Define if you have the <fcntl.h> header file. */
94 +#define HAVE_FCNTL_H 1
95 +
96 +/* Define if you have the feof_unlocked function. */
97 +#undef HAVE_FEOF_UNLOCKED
98 +
99 +/* Define if you have the fgets_unlocked function. */
100 +#undef HAVE_FGETS_UNLOCKED
101 +
102 +/* Define if you have the flock function. */
103 +#undef HAVE_FLOCK
104 +
105 +/* Define if you have the getcwd function. */
106 +#undef HAVE_GETCWD
107 +
108 +/* Define if you have the getegid function. */
109 +#undef HAVE_GETEGID
110 +
111 +/* Define if you have the geteuid function. */
112 +#undef HAVE_GETEUID
113 +
114 +/* Define if you have the getgid function. */
115 +#undef HAVE_GETGID
116 +
117 +/* Define if you have the gethostname function. */
118 +#undef HAVE_GETHOSTNAME
119 +
120 +/* Define if you have the getpagesize function. */
121 +#undef HAVE_GETPAGESIZE
122 +
123 +/* Define if the GNU gettext() function is already present or preinstalled. */
124 +//#define HAVE_GETTEXT 1
125 +
126 +/* Define if you have the getuid function. */
127 +#undef HAVE_GETUID
128 +
129 +/* Define if you have the iconv() function. */
130 +#define HAVE_ICONV 1
131 +
132 +/* Define if you have the inet_addr function. */
133 +#undef HAVE_INET_ADDR
134 +
135 +/* Define if you have the inet_aton function. */
136 +#undef HAVE_INET_ATON
137 +
138 +/* Define if you have the <inttypes.h> header file. */
139 +//tm#define HAVE_INTTYPES_H 1
140 +
141 +/* Define if you have the iswalnum function. */
142 +#define HAVE_ISWALNUM 1
143 +
144 +/* Define if you have the iswspace function. */
145 +#define HAVE_ISWSPACE 1
146 +
147 +/* Define if you have <langinfo.h> and nl_langinfo(CODESET). */
148 +#undef HAVE_LANGINFO_CODESET
149 +
150 +/* Define if you have the <lber.h> header file. */
151 +#undef HAVE_LBER_H
152 +
153 +/* Define if your <locale.h> file defines LC_MESSAGES. */
154 +//#define HAVE_LC_MESSAGES 1
155 +
156 +/* Define if you have the <ldap.h> header file. */
157 +#undef HAVE_LDAP_H
158 +
159 +/* Define if you have the compface library (-lcompface). */
160 +#define HAVE_LIBCOMPFACE 1
161 +
162 +/* Define if you have the jconv library (-ljconv). */
163 +#define HAVE_LIBJCONV 1
164 +//#undef HAVE_LIBJCONV
165 +
166 +/* Define if you have the <libpisock/pi-address.h> header file. */
167 +#undef HAVE_LIBPISOCK_PI_ADDRESS_H
168 +
169 +/* Define if you have the <libpisock/pi-appinfo.h> header file. */
170 +#undef HAVE_LIBPISOCK_PI_APPINFO_H
171 +
172 +/* Define if you have the <libpisock/pi-args.h> header file. */
173 +#undef HAVE_LIBPISOCK_PI_ARGS_H
174 +
175 +/* Define if you have the xpg4 library (-lxpg4). */
176 +#undef HAVE_LIBXPG4
177 +
178 +/* Define if you have the <limits.h> header file. */
179 +#undef HAVE_LIMITS_H
180 +
181 +/* Define if you have the <locale.h> header file. */
182 +#define HAVE_LOCALE_H 1
183 +
184 +/* Define if you have the lockf function. */
185 +#undef HAVE_LOCKF
186 +
187 +/* Define if you have the <malloc.h> header file. */
188 +#undef HAVE_MALLOC_H
189 +
190 +/* Define if you have the <memory.h> header file. */
191 +//#define HAVE_MEMORY_H 1
192 +
193 +/* Define if you have the mempcpy function. */
194 +#undef HAVE_MEMPCPY
195 +
196 +/* Define if you have the mkdir function. */
197 +#undef HAVE_MKDIR
198 +
199 +/* Define if you have the mkstemp function. */
200 +#undef HAVE_MKSTEMP
201 +
202 +/* Define if you have the mktime function. */
203 +#undef HAVE_MKTIME
204 +
205 +/* Define if you have a working `mmap' system call. */
206 +#undef HAVE_MMAP
207 +
208 +/* Define if you have the munmap function. */
209 +#undef HAVE_MUNMAP
210 +
211 +/* Define if you have the <ndir.h> header file. */
212 +#undef HAVE_NDIR_H
213 +
214 +/* Define if you have the <nl_types.h> header file. */
215 +#undef HAVE_NL_TYPES_H
216 +
217 +/* Define if you have the <paths.h> header file. */
218 +#undef HAVE_PATHS_H
219 +
220 +/* Define if you have the <pi-address.h> header file. */
221 +#undef HAVE_PI_ADDRESS_H
222 +
223 +/* Define if you have the <pi-appinfo.h> header file. */
224 +#undef HAVE_PI_APPINFO_H
225 +
226 +/* Define if you have the <pi-args.h> header file. */
227 +#undef HAVE_PI_ARGS_H
228 +
229 +/* Define if you have the <pthread.h> header file. */
230 +#undef HAVE_PTHREAD_H
231 +
232 +/* Define if you have the putenv function. */
233 +#undef HAVE_PUTENV
234 +
235 +/* Define if you have the setenv function. */
236 +#undef HAVE_SETENV
237 +
238 +/* Define if you have the setlocale function. */
239 +#undef HAVE_SETLOCALE
240 +
241 +/* Define if you have the socket function. */
242 +#undef HAVE_SOCKET
243 +
244 +/* Define if you have the <stddef.h> header file. */
245 +#undef HAVE_STDDEF_H
246 +
247 +/* Define if you have the <stdint.h> header file. */
248 +//#define HAVE_STDINT_H 1
249 +
250 +/* Define if you have the <stdlib.h> header file. */
251 +#define HAVE_STDLIB_H 1
252 +
253 +/* Define if you have the stpcpy function. */
254 +#undef HAVE_STPCPY
255 +
256 +/* Define if you have the strcasecmp function. */
257 +#undef HAVE_STRCASECMP
258 +
259 +/* Define if you have the strchr function. */
260 +#undef HAVE_STRCHR
261 +
262 +/* Define if you have the strdup function. */
263 +#undef HAVE_STRDUP
264 +
265 +/* Define if you have the <strings.h> header file. */
266 +//#define HAVE_STRINGS_H 1
267 +
268 +/* Define if you have the <string.h> header file. */
269 +#define HAVE_STRING_H 1
270 +
271 +/* Define if you have the strstr function. */
272 +#undef HAVE_STRSTR
273 +
274 +/* Define if you have the strtoul function. */
275 +#undef HAVE_STRTOUL
276 +
277 +/* Define if you have the <sys/dir.h> header file. */
278 +#undef HAVE_SYS_DIR_H
279 +
280 +/* Define if you have the <sys/file.h> header file. */
281 +#undef HAVE_SYS_FILE_H
282 +
283 +/* Define if you have the <sys/ndir.h> header file. */
284 +#undef HAVE_SYS_NDIR_H
285 +
286 +/* Define if you have the <sys/param.h> header file. */
287 +#undef HAVE_SYS_PARAM_H
288 +
289 +/* Define if you have the <sys/stat.h> header file. */
290 +//#define HAVE_SYS_STAT_H 1
291 +
292 +/* Define if you have the <sys/types.h> header file. */
293 +//#define HAVE_SYS_TYPES_H 1
294 +
295 +/* Define if you have the <sys/utsname.h> header file. */
296 +#undef HAVE_SYS_UTSNAME_H
297 +
298 +/* Define if you have <sys/wait.h> that is POSIX.1 compatible. */
299 +#undef HAVE_SYS_WAIT_H
300 +
301 +/* Define if you have the towlower function. */
302 +#define HAVE_TOWLOWER 1
303 +
304 +/* Define if you have the tsearch function. */
305 +#undef HAVE_TSEARCH
306 +
307 +/* Define if you have the uname function. */
308 +#undef HAVE_UNAME
309 +
310 +/* Define if you have the <unistd.h> header file. */
311 +#undef HAVE_UNISTD_H
312 +
313 +/* Define if you have the <wchar.h> header file. */
314 +#define HAVE_WCHAR_H 1
315 +
316 +/* Define if you have the wcscpy function. */
317 +#define HAVE_WCSCPY 1
318 +
319 +/* Define if you have the wcslen function. */
320 +#define HAVE_WCSLEN 1
321 +
322 +/* Define if you have the wcsncpy function. */
323 +#define HAVE_WCSNCPY 1
324 +
325 +/* Define if you have the wcsstr function. */
326 +#define HAVE_WCSSTR 1
327 +
328 +/* Define if you have the wcswcs function. */
329 +#define HAVE_WCSWCS 1
330 +
331 +/* Define if you have the <wctype.h> header file. */
332 +#define HAVE_WCTYPE_H 1
333 +
334 +/* Define if you have the __argz_count function. */
335 +#undef HAVE___ARGZ_COUNT
336 +
337 +/* Define if you have the __argz_next function. */
338 +#undef HAVE___ARGZ_NEXT
339 +
340 +/* Define if you have the __argz_stringify function. */
341 +#undef HAVE___ARGZ_STRINGIFY
342 +
343 +/* Define as const if the declaration of iconv() needs const. */
344 +#undef ICONV_CONST
345 +
346 +/* The number of bytes in a unsigned int. */
347 +#undef SIZEOF_UNSIGNED_INT
348 +
349 +/* The number of bytes in a unsigned long. */
350 +#undef SIZEOF_UNSIGNED_LONG
351 +
352 +/* The number of bytes in a unsigned short. */
353 +#undef SIZEOF_UNSIGNED_SHORT
354 +
355 +/* If using the C implementation of alloca, define if you know the
356 + direction of stack growth for your system; otherwise it will be
357 + automatically deduced at run-time.
358 + STACK_DIRECTION > 0 => grows toward higher addresses
359 + STACK_DIRECTION < 0 => grows toward lower addresses
360 + STACK_DIRECTION = 0 => direction of growth unknown */
361 +#undef STACK_DIRECTION
362 +
363 +/* Define if you have the ANSI C header files. */
364 +#undef STDC_HEADERS
365 +
366 +/* Define if your <sys/time.h> declares struct tm. */
367 +#undef TM_IN_SYS_TIME
368 +
369 +/* Define if lex declares yytext as a char * by default, not a char[]. */
370 +#undef YYTEXT_POINTER
371 +
372 +/* Define to empty if the keyword does not work. */
373 +#undef const
374 +
375 +/* Define as __inline if that's what the C compiler calls it. */
376 +#undef inline
377 +
378 +/* Define to `long' if <sys/types.h> doesn't define. */
379 +#undef off_t
380 +
381 +/* Define to `int' if <sys/types.h> doesn't define. */
382 +#undef pid_t
383 +
384 +/* Define to `unsigned' if <sys/types.h> doesn't define. */
385 +#undef size_t
386 +
387 +/* Others */
388 +#define HAVE_DOSISH_SYSTEM 1
389 +#define HOST_ALIAS "Win32"
390 +#define MANUALDIR "doc\\manual"
391 +#define SYSCONFDIR "etc"
392 +#define LOCALEDIR "locale"
393 +#define FAQDIR "doc\\faq"
394 diff -urN empty/matcher_parser_lex.c src/matcher_parser_lex.c
395 --- empty/matcher_parser_lex.c Thu Jan 1 00:00:00 1970
396 +++ src/matcher_parser_lex.c Sun May 12 00:04:36 2002
397 @@ -0,0 +1,2187 @@
398 +#define yy_create_buffer matcher_parser_create_buffer
399 +#define yy_delete_buffer matcher_parser_delete_buffer
400 +#define yy_scan_buffer matcher_parser_scan_buffer
401 +#define yy_scan_string matcher_parser_scan_string
402 +#define yy_scan_bytes matcher_parser_scan_bytes
403 +#define yy_flex_debug matcher_parser_flex_debug
404 +#define yy_init_buffer matcher_parser_init_buffer
405 +#define yy_flush_buffer matcher_parser_flush_buffer
406 +#define yy_load_buffer_state matcher_parser_load_buffer_state
407 +#define yy_switch_to_buffer matcher_parser_switch_to_buffer
408 +#define yyin matcher_parserin
409 +#define yyleng matcher_parserleng
410 +#define yylex matcher_parserlex
411 +#define yyout matcher_parserout
412 +#define yyrestart matcher_parserrestart
413 +#define yytext matcher_parsertext
414 +#define yylineno matcher_parserlineno
415 +#define yywrap matcher_parserwrap
416 +
417 +#line 21 "lex.yy.c"
418 +/* A lexical scanner generated by flex */
419 +
420 +/* Scanner skeleton version:
421 + * $Header$
422 + */
423 +
424 +#define FLEX_SCANNER
425 +#define YY_FLEX_MAJOR_VERSION 2
426 +#define YY_FLEX_MINOR_VERSION 5
427 +
428 +#include <stdio.h>
429 +
430 +
431 +/* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
432 +#ifdef c_plusplus
433 +#ifndef __cplusplus
434 +#define __cplusplus
435 +#endif
436 +#endif
437 +
438 +
439 +#ifdef __cplusplus
440 +
441 +#include <stdlib.h>
442 +#include <unistd.h>
443 +
444 +/* Use prototypes in function declarations. */
445 +#define YY_USE_PROTOS
446 +
447 +/* The "const" storage-class-modifier is valid. */
448 +#define YY_USE_CONST
449 +
450 +#else /* ! __cplusplus */
451 +
452 +#if __STDC__
453 +
454 +#define YY_USE_PROTOS
455 +#define YY_USE_CONST
456 +
457 +#endif /* __STDC__ */
458 +#endif /* ! __cplusplus */
459 +
460 +#ifdef __TURBOC__
461 + #pragma warn -rch
462 + #pragma warn -use
463 +#include <io.h>
464 +#include <stdlib.h>
465 +#define YY_USE_CONST
466 +#define YY_USE_PROTOS
467 +#endif
468 +
469 +#ifdef YY_USE_CONST
470 +#define yyconst const
471 +#else
472 +#define yyconst
473 +#endif
474 +
475 +
476 +#ifdef YY_USE_PROTOS
477 +#define YY_PROTO(proto) proto
478 +#else
479 +#define YY_PROTO(proto) ()
480 +#endif
481 +
482 +/* Returned upon end-of-file. */
483 +#define YY_NULL 0
484 +
485 +/* Promotes a possibly negative, possibly signed char to an unsigned
486 + * integer for use as an array index. If the signed char is negative,
487 + * we want to instead treat it as an 8-bit unsigned char, hence the
488 + * double cast.
489 + */
490 +#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
491 +
492 +/* Enter a start condition. This macro really ought to take a parameter,
493 + * but we do it the disgusting crufty way forced on us by the ()-less
494 + * definition of BEGIN.
495 + */
496 +#define BEGIN yy_start = 1 + 2 *
497 +
498 +/* Translate the current start state into a value that can be later handed
499 + * to BEGIN to return to the state. The YYSTATE alias is for lex
500 + * compatibility.
501 + */
502 +#define YY_START ((yy_start - 1) / 2)
503 +#define YYSTATE YY_START
504 +
505 +/* Action number for EOF rule of a given start state. */
506 +#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
507 +
508 +/* Special action meaning "start processing a new file". */
509 +#define YY_NEW_FILE yyrestart( yyin )
510 +
511 +#define YY_END_OF_BUFFER_CHAR 0
512 +
513 +/* Size of default input buffer. */
514 +#define YY_BUF_SIZE 16384
515 +
516 +typedef struct yy_buffer_state *YY_BUFFER_STATE;
517 +
518 +extern int yyleng;
519 +extern FILE *yyin, *yyout;
520 +
521 +#define EOB_ACT_CONTINUE_SCAN 0
522 +#define EOB_ACT_END_OF_FILE 1
523 +#define EOB_ACT_LAST_MATCH 2
524 +
525 +/* The funky do-while in the following #define is used to turn the definition
526 + * int a single C statement (which needs a semi-colon terminator). This
527 + * avoids problems with code like:
528 + *
529 + * if ( condition_holds )
530 + * yyless( 5 );
531 + * else
532 + * do_something_else();
533 + *
534 + * Prior to using the do-while the compiler would get upset at the
535 + * "else" because it interpreted the "if" statement as being all
536 + * done when it reached the ';' after the yyless() call.
537 + */
538 +
539 +/* Return all but the first 'n' matched characters back to the input stream. */
540 +
541 +#define yyless(n) \
542 + do \
543 + { \
544 + /* Undo effects of setting up yytext. */ \
545 + *yy_cp = yy_hold_char; \
546 + YY_RESTORE_YY_MORE_OFFSET \
547 + yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
548 + YY_DO_BEFORE_ACTION; /* set up yytext again */ \
549 + } \
550 + while ( 0 )
551 +
552 +#define unput(c) yyunput( c, yytext_ptr )
553 +
554 +/* The following is because we cannot portably get our hands on size_t
555 + * (without autoconf's help, which isn't available because we want
556 + * flex-generated scanners to compile on their own).
557 + */
558 +typedef unsigned int yy_size_t;
559 +
560 +
561 +struct yy_buffer_state
562 + {
563 + FILE *yy_input_file;
564 +
565 + char *yy_ch_buf; /* input buffer */
566 + char *yy_buf_pos; /* current position in input buffer */
567 +
568 + /* Size of input buffer in bytes, not including room for EOB
569 + * characters.
570 + */
571 + yy_size_t yy_buf_size;
572 +
573 + /* Number of characters read into yy_ch_buf, not including EOB
574 + * characters.
575 + */
576 + int yy_n_chars;
577 +
578 + /* Whether we "own" the buffer - i.e., we know we created it,
579 + * and can realloc() it to grow it, and should free() it to
580 + * delete it.
581 + */
582 + int yy_is_our_buffer;
583 +
584 + /* Whether this is an "interactive" input source; if so, and
585 + * if we're using stdio for input, then we want to use getc()
586 + * instead of fread(), to make sure we stop fetching input after
587 + * each newline.
588 + */
589 + int yy_is_interactive;
590 +
591 + /* Whether we're considered to be at the beginning of a line.
592 + * If so, '^' rules will be active on the next match, otherwise
593 + * not.
594 + */
595 + int yy_at_bol;
596 +
597 + /* Whether to try to fill the input buffer when we reach the
598 + * end of it.
599 + */
600 + int yy_fill_buffer;
601 +
602 + int yy_buffer_status;
603 +#define YY_BUFFER_NEW 0
604 +#define YY_BUFFER_NORMAL 1
605 + /* When an EOF's been seen but there's still some text to process
606 + * then we mark the buffer as YY_EOF_PENDING, to indicate that we
607 + * shouldn't try reading from the input source any more. We might
608 + * still have a bunch of tokens to match, though, because of
609 + * possible backing-up.
610 + *
611 + * When we actually see the EOF, we change the status to "new"
612 + * (via yyrestart()), so that the user can continue scanning by
613 + * just pointing yyin at a new input file.
614 + */
615 +#define YY_BUFFER_EOF_PENDING 2
616 + };
617 +
618 +static YY_BUFFER_STATE yy_current_buffer = 0;
619 +
620 +/* We provide macros for accessing buffer states in case in the
621 + * future we want to put the buffer states in a more general
622 + * "scanner state".
623 + */
624 +#define YY_CURRENT_BUFFER yy_current_buffer
625 +
626 +
627 +/* yy_hold_char holds the character lost when yytext is formed. */
628 +static char yy_hold_char;
629 +
630 +static int yy_n_chars; /* number of characters read into yy_ch_buf */
631 +
632 +
633 +int yyleng;
634 +
635 +/* Points to current character in buffer. */
636 +static char *yy_c_buf_p = (char *) 0;
637 +static int yy_init = 1; /* whether we need to initialize */
638 +static int yy_start = 0; /* start state number */
639 +
640 +/* Flag which is used to allow yywrap()'s to do buffer switches
641 + * instead of setting up a fresh yyin. A bit of a hack ...
642 + */
643 +static int yy_did_buffer_switch_on_eof;
644 +
645 +void yyrestart YY_PROTO(( FILE *input_file ));
646 +
647 +void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
648 +void yy_load_buffer_state YY_PROTO(( void ));
649 +YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
650 +void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
651 +void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
652 +void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
653 +#define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
654 +
655 +YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
656 +YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str ));
657 +YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
658 +
659 +static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
660 +static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));
661 +static void yy_flex_free YY_PROTO(( void * ));
662 +
663 +#define yy_new_buffer yy_create_buffer
664 +
665 +#define yy_set_interactive(is_interactive) \
666 + { \
667 + if ( ! yy_current_buffer ) \
668 + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
669 + yy_current_buffer->yy_is_interactive = is_interactive; \
670 + }
671 +
672 +#define yy_set_bol(at_bol) \
673 + { \
674 + if ( ! yy_current_buffer ) \
675 + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
676 + yy_current_buffer->yy_at_bol = at_bol; \
677 + }
678 +
679 +#define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
680 +
681 +
682 +#define YY_USES_REJECT
683 +typedef unsigned char YY_CHAR;
684 +FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
685 +typedef int yy_state_type;
686 +extern int yylineno;
687 +int yylineno = 1;
688 +extern char *yytext;
689 +#define yytext_ptr yytext
690 +
691 +static yy_state_type yy_get_previous_state YY_PROTO(( void ));
692 +static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
693 +static int yy_get_next_buffer YY_PROTO(( void ));
694 +static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
695 +
696 +/* Done after the current pattern has been matched and before the
697 + * corresponding action - sets up yytext.
698 + */
699 +#define YY_DO_BEFORE_ACTION \
700 + yytext_ptr = yy_bp; \
701 + yyleng = (int) (yy_cp - yy_bp); \
702 + yy_hold_char = *yy_cp; \
703 + *yy_cp = '\0'; \
704 + yy_c_buf_p = yy_cp;
705 +
706 +#define YY_NUM_RULES 75
707 +#define YY_END_OF_BUFFER 76
708 +static yyconst short int yy_acclist[107] =
709 + { 0,
710 + 76, 75, 65, 75, 66, 75, 69, 75, 67, 75,
711 + 75, 74, 75, 75, 75, 75, 75, 75, 75, 75,
712 + 75, 75, 75, 75, 75, 75, 75, 75, 68, 75,
713 + 75, 72, 75, 71, 72, 75, 72, 75, 65, 74,
714 + 73, 20, 18, 70, 1, 4, 21, 19, 54, 16,
715 + 56, 53, 5, 62, 49, 52, 17, 63, 55, 38,
716 + 6, 51, 57, 2, 8, 46, 60, 42, 10, 14,
717 + 39, 7, 3, 22, 9, 47, 43, 11, 15, 25,
718 + 44, 12, 28, 48, 23, 26, 30, 50, 37, 45,
719 + 13, 29, 24, 34, 33, 27, 31, 40, 58, 35,
720 +
721 + 36, 32, 41, 59, 64, 61
722 + } ;
723 +
724 +static yyconst short int yy_accept[393] =
725 + { 0,
726 + 1, 1, 1, 1, 1, 1, 1, 2, 3, 5,
727 + 7, 9, 11, 12, 14, 15, 16, 17, 18, 19,
728 + 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
729 + 31, 32, 34, 37, 39, 40, 41, 41, 42, 42,
730 + 42, 42, 43, 43, 43, 43, 43, 43, 43, 43,
731 + 43, 43, 43, 43, 43, 43, 43, 43, 44, 44,
732 + 44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
733 + 44, 44, 44, 45, 45, 46, 46, 46, 46, 46,
734 + 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
735 + 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
736 +
737 + 47, 48, 48, 48, 48, 48, 48, 48, 48, 48,
738 + 48, 48, 48, 49, 49, 49, 49, 49, 49, 50,
739 + 50, 50, 50, 51, 51, 51, 52, 52, 52, 53,
740 + 53, 53, 53, 53, 53, 53, 53, 53, 53, 53,
741 + 53, 53, 53, 53, 53, 53, 53, 53, 53, 54,
742 + 54, 54, 54, 54, 54, 54, 54, 54, 54, 55,
743 + 55, 55, 55, 55, 55, 55, 55, 56, 56, 56,
744 + 56, 56, 56, 57, 57, 57, 57, 57, 57, 57,
745 + 57, 57, 57, 58, 58, 58, 58, 58, 58, 58,
746 + 58, 58, 58, 58, 58, 58, 58, 59, 60, 60,
747 +
748 + 60, 61, 61, 61, 62, 62, 62, 62, 62, 63,
749 + 63, 63, 63, 63, 63, 63, 63, 64, 65, 65,
750 + 65, 65, 65, 65, 65, 65, 65, 65, 65, 65,
751 + 65, 65, 65, 65, 65, 65, 65, 66, 67, 68,
752 + 68, 68, 68, 68, 69, 69, 69, 69, 70, 70,
753 + 70, 70, 70, 70, 70, 71, 71, 71, 71, 71,
754 + 71, 72, 72, 73, 73, 73, 73, 73, 73, 73,
755 + 74, 74, 74, 74, 74, 74, 74, 74, 74, 74,
756 + 74, 74, 74, 74, 74, 74, 74, 74, 74, 74,
757 + 75, 75, 76, 77, 77, 77, 77, 78, 78, 78,
758 +
759 + 79, 80, 80, 80, 81, 82, 82, 82, 83, 83,
760 + 84, 84, 84, 85, 85, 85, 85, 85, 85, 85,
761 + 85, 85, 85, 85, 85, 85, 85, 85, 85, 86,
762 + 86, 86, 86, 86, 86, 86, 87, 88, 89, 89,
763 + 89, 89, 90, 90, 90, 91, 92, 92, 93, 93,
764 + 93, 94, 94, 94, 94, 94, 94, 95, 95, 96,
765 + 96, 96, 96, 97, 98, 98, 98, 99, 100, 100,
766 + 100, 101, 102, 102, 102, 102, 102, 103, 104, 104,
767 + 104, 105, 105, 105, 106, 106, 106, 106, 106, 106,
768 + 107, 107
769 +
770 + } ;
771 +
772 +static yyconst int yy_ec[256] =
773 + { 0,
774 + 1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
775 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
776 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
777 + 1, 2, 1, 4, 1, 1, 1, 5, 1, 1,
778 + 1, 1, 6, 1, 6, 1, 1, 7, 7, 7,
779 + 7, 7, 7, 7, 7, 7, 7, 1, 1, 1,
780 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
781 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
782 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
783 + 8, 9, 10, 1, 11, 1, 12, 13, 14, 15,
784 +
785 + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
786 + 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
787 + 36, 37, 1, 38, 1, 39, 1, 1, 1, 1,
788 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
789 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
790 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
791 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
792 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
793 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
794 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
795 +
796 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
797 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
798 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
799 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
800 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
801 + 1, 1, 1, 1, 1
802 + } ;
803 +
804 +static yyconst int yy_meta[40] =
805 + { 0,
806 + 1, 1, 1, 1, 1, 1, 1, 2, 1, 1,
807 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
808 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
809 + 1, 1, 1, 1, 1, 1, 1, 1, 1
810 + } ;
811 +
812 +static yyconst short int yy_base[395] =
813 + { 0,
814 + 0, 0, 37, 39, 0, 0, 410, 411, 407, 411,
815 + 411, 411, 401, 400, 396, 26, 379, 31, 388, 368,
816 + 21, 386, 376, 39, 384, 383, 38, 372, 372, 411,
817 + 58, 411, 411, 392, 393, 387, 383, 411, 376, 368,
818 + 44, 411, 33, 367, 373, 359, 361, 374, 356, 32,
819 + 354, 350, 348, 67, 355, 343, 366, 367, 38, 351,
820 + 362, 359, 339, 40, 357, 347, 52, 355, 354, 337,
821 + 342, 342, 411, 355, 411, 329, 339, 337, 326, 345,
822 + 346, 325, 334, 342, 340, 333, 340, 323, 336, 321,
823 + 334, 333, 325, 318, 330, 324, 318, 331, 326, 326,
824 +
825 + 411, 317, 323, 309, 311, 324, 306, 305, 303, 298,
826 + 64, 318, 319, 300, 74, 317, 313, 297, 411, 294,
827 + 292, 311, 411, 306, 294, 82, 301, 307, 411, 300,
828 + 288, 281, 295, 298, 302, 296, 282, 281, 297, 272,
829 + 291, 292, 271, 280, 288, 286, 279, 270, 269, 282,
830 + 274, 275, 269, 278, 264, 266, 264, 274, 411, 273,
831 + 257, 258, 257, 262, 272, 268, 268, 263, 251, 263,
832 + 251, 261, 265, 83, 261, 263, 251, 257, 260, 239,
833 + 237, 256, 411, 251, 239, 249, 252, 245, 233, 241,
834 + 244, 230, 246, 241, 222, 243, 411, 85, 238, 238,
835 +
836 + 222, 215, 220, 411, 237, 232, 221, 221, 231, 229,
837 + 86, 215, 213, 217, 209, 225, 411, 411, 211, 221,
838 + 205, 206, 205, 210, 217, 213, 201, 213, 212, 213,
839 + 215, 210, 212, 207, 193, 195, 411, 411, 92, 209,
840 + 188, 207, 187, 411, 184, 201, 202, 411, 185, 183,
841 + 185, 178, 193, 196, 411, 193, 194, 190, 188, 188,
842 + 172, 165, 411, 184, 173, 173, 182, 165, 181, 411,
843 + 163, 164, 161, 166, 178, 174, 161, 161, 78, 170,
844 + 158, 168, 153, 150, 165, 146, 167, 166, 154, 411,
845 + 147, 411, 411, 159, 163, 142, 411, 140, 157, 411,
846 +
847 + 411, 156, 153, 411, 411, 157, 137, 411, 154, 411,
848 + 149, 139, 411, 133, 132, 145, 148, 147, 142, 134,
849 + 125, 132, 123, 138, 125, 125, 123, 133, 411, 119,
850 + 117, 135, 116, 132, 114, 411, 411, 411, 119, 110,
851 + 111, 411, 123, 122, 411, 411, 125, 411, 106, 105,
852 + 411, 118, 121, 101, 116, 114, 411, 113, 411, 99,
853 + 98, 97, 411, 411, 96, 93, 411, 411, 111, 93,
854 + 411, 411, 90, 87, 88, 103, 411, 411, 96, 99,
855 + 411, 77, 91, 411, 76, 62, 64, 54, 23, 411,
856 + 411, 113, 115, 52
857 +
858 + } ;
859 +
860 +static yyconst short int yy_def[395] =
861 + { 0,
862 + 391, 1, 392, 392, 393, 393, 391, 391, 391, 391,
863 + 391, 391, 391, 391, 394, 391, 391, 391, 391, 391,
864 + 391, 391, 391, 391, 391, 391, 391, 391, 391, 391,
865 + 391, 391, 391, 391, 391, 391, 394, 391, 391, 391,
866 + 391, 391, 391, 391, 391, 391, 391, 391, 391, 391,
867 + 391, 391, 391, 391, 391, 391, 391, 391, 391, 391,
868 + 391, 391, 391, 391, 391, 391, 391, 391, 391, 391,
869 + 391, 391, 391, 391, 391, 391, 391, 391, 391, 391,
870 + 391, 391, 391, 391, 391, 391, 391, 391, 391, 391,
871 + 391, 391, 391, 391, 391, 391, 391, 391, 391, 391,
872 +
873 + 391, 391, 391, 391, 391, 391, 391, 391, 391, 391,
874 + 391, 391, 391, 391, 391, 391, 391, 391, 391, 391,
875 + 391, 391, 391, 391, 391, 391, 391, 391, 391, 391,
876 + 391, 391, 391, 391, 391, 391, 391, 391, 391, 391,
877 + 391, 391, 391, 391, 391, 391, 391, 391, 391, 391,
878 + 391, 391, 391, 391, 391, 391, 391, 391, 391, 391,
879 + 391, 391, 391, 391, 391, 391, 391, 391, 391, 391,
880 + 391, 391, 391, 391, 391, 391, 391, 391, 391, 391,
881 + 391, 391, 391, 391, 391, 391, 391, 391, 391, 391,
882 + 391, 391, 391, 391, 391, 391, 391, 391, 391, 391,
883 +
884 + 391, 391, 391, 391, 391, 391, 391, 391, 391, 391,
885 + 391, 391, 391, 391, 391, 391, 391, 391, 391, 391,
886 + 391, 391, 391, 391, 391, 391, 391, 391, 391, 391,
887 + 391, 391, 391, 391, 391, 391, 391, 391, 391, 391,
888 + 391, 391, 391, 391, 391, 391, 391, 391, 391, 391,
889 + 391, 391, 391, 391, 391, 391, 391, 391, 391, 391,
890 + 391, 391, 391, 391, 391, 391, 391, 391, 391, 391,
891 + 391, 391, 391, 391, 391, 391, 391, 391, 391, 391,
892 + 391, 391, 391, 391, 391, 391, 391, 391, 391, 391,
893 + 391, 391, 391, 391, 391, 391, 391, 391, 391, 391,
894 +
895 + 391, 391, 391, 391, 391, 391, 391, 391, 391, 391,
896 + 391, 391, 391, 391, 391, 391, 391, 391, 391, 391,
897 + 391, 391, 391, 391, 391, 391, 391, 391, 391, 391,
898 + 391, 391, 391, 391, 391, 391, 391, 391, 391, 391,
899 + 391, 391, 391, 391, 391, 391, 391, 391, 391, 391,
900 + 391, 391, 391, 391, 391, 391, 391, 391, 391, 391,
901 + 391, 391, 391, 391, 391, 391, 391, 391, 391, 391,
902 + 391, 391, 391, 391, 391, 391, 391, 391, 391, 391,
903 + 391, 391, 391, 391, 391, 391, 391, 391, 391, 391,
904 + 0, 391, 391, 391
905 +
906 + } ;
907 +
908 +static yyconst short int yy_nxt[451] =
909 + { 0,
910 + 8, 9, 10, 11, 12, 13, 14, 15, 8, 8,
911 + 8, 16, 17, 18, 19, 20, 21, 8, 22, 23,
912 + 8, 8, 8, 24, 25, 8, 8, 8, 26, 27,
913 + 28, 29, 8, 8, 8, 8, 8, 30, 31, 8,
914 + 33, 8, 33, 39, 42, 34, 46, 34, 40, 47,
915 + 50, 55, 37, 390, 51, 78, 43, 56, 76, 79,
916 + 86, 98, 87, 108, 52, 104, 99, 109, 105, 57,
917 + 60, 61, 62, 63, 64, 77, 65, 66, 389, 388,
918 + 150, 67, 68, 91, 92, 387, 69, 70, 71, 72,
919 + 151, 155, 165, 93, 386, 236, 156, 166, 212, 237,
920 +
921 + 213, 249, 275, 250, 385, 384, 311, 276, 251, 312,
922 + 383, 382, 214, 32, 32, 8, 8, 381, 380, 379,
923 + 378, 377, 376, 375, 374, 373, 372, 371, 370, 369,
924 + 368, 367, 366, 365, 364, 363, 362, 361, 360, 359,
925 + 358, 357, 356, 355, 354, 353, 352, 351, 350, 349,
926 + 348, 347, 346, 345, 344, 343, 342, 341, 340, 339,
927 + 338, 337, 336, 335, 334, 333, 332, 331, 330, 329,
928 + 328, 327, 326, 325, 324, 323, 322, 321, 320, 319,
929 + 318, 317, 316, 315, 314, 313, 310, 309, 308, 307,
930 + 306, 305, 304, 303, 302, 301, 300, 299, 298, 297,
931 +
932 + 296, 295, 294, 293, 292, 291, 290, 289, 288, 287,
933 + 286, 285, 284, 283, 282, 281, 280, 279, 278, 277,
934 + 274, 273, 272, 271, 270, 269, 268, 267, 266, 265,
935 + 264, 263, 262, 261, 260, 259, 258, 257, 256, 255,
936 + 254, 253, 252, 248, 247, 246, 245, 244, 243, 242,
937 + 241, 240, 239, 238, 235, 234, 233, 232, 231, 230,
938 + 229, 228, 227, 226, 225, 224, 223, 222, 221, 220,
939 + 219, 218, 217, 216, 215, 211, 210, 209, 208, 207,
940 + 206, 205, 204, 203, 202, 201, 200, 199, 198, 197,
941 + 196, 195, 194, 193, 192, 191, 190, 189, 188, 187,
942 +
943 + 186, 185, 184, 183, 182, 181, 180, 179, 178, 177,
944 + 176, 175, 174, 173, 172, 171, 170, 169, 168, 167,
945 + 164, 163, 162, 161, 160, 159, 158, 157, 154, 153,
946 + 152, 149, 148, 147, 146, 145, 144, 143, 142, 141,
947 + 140, 139, 138, 137, 136, 135, 134, 133, 132, 131,
948 + 130, 129, 128, 127, 126, 125, 124, 123, 122, 121,
949 + 120, 119, 118, 117, 116, 115, 114, 113, 112, 111,
950 + 110, 107, 106, 103, 102, 101, 100, 97, 96, 95,
951 + 94, 90, 89, 88, 85, 84, 83, 82, 81, 80,
952 + 75, 74, 38, 36, 35, 73, 59, 58, 54, 53,
953 +
954 + 49, 48, 45, 44, 41, 38, 36, 36, 35, 391,
955 + 7, 391, 391, 391, 391, 391, 391, 391, 391, 391,
956 + 391, 391, 391, 391, 391, 391, 391, 391, 391, 391,
957 + 391, 391, 391, 391, 391, 391, 391, 391, 391, 391,
958 + 391, 391, 391, 391, 391, 391, 391, 391, 391, 391
959 + } ;
960 +
961 +static yyconst short int yy_chk[451] =
962 + { 0,
963 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
964 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
965 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
966 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 3,
967 + 3, 4, 4, 16, 18, 3, 21, 4, 16, 21,
968 + 24, 27, 394, 389, 24, 43, 18, 27, 41, 43,
969 + 50, 59, 50, 67, 24, 64, 59, 67, 64, 27,
970 + 31, 31, 31, 31, 31, 41, 31, 31, 388, 387,
971 + 111, 31, 31, 54, 54, 386, 31, 31, 31, 31,
972 + 111, 115, 126, 54, 385, 198, 115, 126, 174, 198,
973 +
974 + 174, 211, 239, 211, 383, 382, 279, 239, 211, 279,
975 + 380, 379, 174, 392, 392, 393, 393, 376, 375, 374,
976 + 373, 370, 369, 366, 365, 362, 361, 360, 358, 356,
977 + 355, 354, 353, 352, 350, 349, 347, 344, 343, 341,
978 + 340, 339, 335, 334, 333, 332, 331, 330, 328, 327,
979 + 326, 325, 324, 323, 322, 321, 320, 319, 318, 317,
980 + 316, 315, 314, 312, 311, 309, 307, 306, 303, 302,
981 + 299, 298, 296, 295, 294, 291, 289, 288, 287, 286,
982 + 285, 284, 283, 282, 281, 280, 278, 277, 276, 275,
983 + 274, 273, 272, 271, 269, 268, 267, 266, 265, 264,
984 +
985 + 262, 261, 260, 259, 258, 257, 256, 254, 253, 252,
986 + 251, 250, 249, 247, 246, 245, 243, 242, 241, 240,
987 + 236, 235, 234, 233, 232, 231, 230, 229, 228, 227,
988 + 226, 225, 224, 223, 222, 221, 220, 219, 216, 215,
989 + 214, 213, 212, 210, 209, 208, 207, 206, 205, 203,
990 + 202, 201, 200, 199, 196, 195, 194, 193, 192, 191,
991 + 190, 189, 188, 187, 186, 185, 184, 182, 181, 180,
992 + 179, 178, 177, 176, 175, 173, 172, 171, 170, 169,
993 + 168, 167, 166, 165, 164, 163, 162, 161, 160, 158,
994 + 157, 156, 155, 154, 153, 152, 151, 150, 149, 148,
995 +
996 + 147, 146, 145, 144, 143, 142, 141, 140, 139, 138,
997 + 137, 136, 135, 134, 133, 132, 131, 130, 128, 127,
998 + 125, 124, 122, 121, 120, 118, 117, 116, 114, 113,
999 + 112, 110, 109, 108, 107, 106, 105, 104, 103, 102,
1000 + 100, 99, 98, 97, 96, 95, 94, 93, 92, 91,
1001 + 90, 89, 88, 87, 86, 85, 84, 83, 82, 81,
1002 + 80, 79, 78, 77, 76, 74, 72, 71, 70, 69,
1003 + 68, 66, 65, 63, 62, 61, 60, 58, 57, 56,
1004 + 55, 53, 52, 51, 49, 48, 47, 46, 45, 44,
1005 + 40, 39, 37, 36, 35, 34, 29, 28, 26, 25,
1006 +
1007 + 23, 22, 20, 19, 17, 15, 14, 13, 9, 7,
1008 + 391, 391, 391, 391, 391, 391, 391, 391, 391, 391,
1009 + 391, 391, 391, 391, 391, 391, 391, 391, 391, 391,
1010 + 391, 391, 391, 391, 391, 391, 391, 391, 391, 391,
1011 + 391, 391, 391, 391, 391, 391, 391, 391, 391, 391
1012 + } ;
1013 +
1014 +static yy_state_type yy_state_buf[YY_BUF_SIZE + 2], *yy_state_ptr;
1015 +static char *yy_full_match;
1016 +static int yy_lp;
1017 +#define REJECT \
1018 +{ \
1019 +*yy_cp = yy_hold_char; /* undo effects of setting up yytext */ \
1020 +yy_cp = yy_full_match; /* restore poss. backed-over text */ \
1021 +++yy_lp; \
1022 +goto find_rule; \
1023 +}
1024 +#define yymore() yymore_used_but_not_detected
1025 +#define YY_MORE_ADJ 0
1026 +#define YY_RESTORE_YY_MORE_OFFSET
1027 +char *yytext;
1028 +#line 1 "matcher_parser_lex.l"
1029 +#define INITIAL 0
1030 +#line 2 "matcher_parser_lex.l"
1031 +#include "matcher_parser_lex.h"
1032 +#include "matcher_parser_parse.h"
1033 +#include <glib.h>
1034 +
1035 +#define MAX_STR_CONST 512
1036 +
1037 +char string_buf[MAX_STR_CONST];
1038 +char * string_buf_ptr;
1039 +
1040 +static void add_char(char ch)
1041 +{
1042 + if (string_buf_ptr - string_buf < sizeof(string_buf))
1043 + *string_buf_ptr++ = ch;
1044 +}
1045 +#define string 1
1046 +
1047 +#define section 2
1048 +
1049 +#line 653 "lex.yy.c"
1050 +
1051 +/* Macros after this point can all be overridden by user definitions in
1052 + * section 1.
1053 + */
1054 +
1055 +#ifndef YY_SKIP_YYWRAP
1056 +#ifdef __cplusplus
1057 +extern "C" int yywrap YY_PROTO(( void ));
1058 +#else
1059 +extern int yywrap YY_PROTO(( void ));
1060 +#endif
1061 +#endif
1062 +
1063 +#ifndef YY_NO_UNPUT
1064 +static void yyunput YY_PROTO(( int c, char *buf_ptr ));
1065 +#endif
1066 +
1067 +#ifndef yytext_ptr
1068 +static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
1069 +#endif
1070 +
1071 +#ifdef YY_NEED_STRLEN
1072 +static int yy_flex_strlen YY_PROTO(( yyconst char * ));
1073 +#endif
1074 +
1075 +#ifndef YY_NO_INPUT
1076 +#ifdef __cplusplus
1077 +static int yyinput YY_PROTO(( void ));
1078 +#else
1079 +static int input YY_PROTO(( void ));
1080 +#endif
1081 +#endif
1082 +
1083 +#if YY_STACK_USED
1084 +static int yy_start_stack_ptr = 0;
1085 +static int yy_start_stack_depth = 0;
1086 +static int *yy_start_stack = 0;
1087 +#ifndef YY_NO_PUSH_STATE
1088 +static void yy_push_state YY_PROTO(( int new_state ));
1089 +#endif
1090 +#ifndef YY_NO_POP_STATE
1091 +static void yy_pop_state YY_PROTO(( void ));
1092 +#endif
1093 +#ifndef YY_NO_TOP_STATE
1094 +static int yy_top_state YY_PROTO(( void ));
1095 +#endif
1096 +
1097 +#else
1098 +#define YY_NO_PUSH_STATE 1
1099 +#define YY_NO_POP_STATE 1
1100 +#define YY_NO_TOP_STATE 1
1101 +#endif
1102 +
1103 +#ifdef YY_MALLOC_DECL
1104 +YY_MALLOC_DECL
1105 +#else
1106 +#if __STDC__
1107 +#ifndef __cplusplus
1108 +#include <stdlib.h>
1109 +#endif
1110 +#else
1111 +/* Just try to get by without declaring the routines. This will fail
1112 + * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
1113 + * or sizeof(void*) != sizeof(int).
1114 + */
1115 +#endif
1116 +#endif
1117 +
1118 +/* Amount of stuff to slurp up with each read. */
1119 +#ifndef YY_READ_BUF_SIZE
1120 +#define YY_READ_BUF_SIZE 8192
1121 +#endif
1122 +
1123 +/* Copy whatever the last rule matched to the standard output. */
1124 +
1125 +#ifndef ECHO
1126 +/* This used to be an fputs(), but since the string might contain NUL's,
1127 + * we now use fwrite().
1128 + */
1129 +#define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
1130 +#endif
1131 +
1132 +/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
1133 + * is returned in "result".
1134 + */
1135 +#ifndef YY_INPUT
1136 +#define YY_INPUT(buf,result,max_size) \
1137 + if ( yy_current_buffer->yy_is_interactive ) \
1138 + { \
1139 + int c = '*', n; \
1140 + for ( n = 0; n < max_size && \
1141 + (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
1142 + buf[n] = (char) c; \
1143 + if ( c == '\n' ) \
1144 + buf[n++] = (char) c; \
1145 + if ( c == EOF && ferror( yyin ) ) \
1146 + YY_FATAL_ERROR( "input in flex scanner failed" ); \
1147 + result = n; \
1148 + } \
1149 + else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
1150 + && ferror( yyin ) ) \
1151 + YY_FATAL_ERROR( "input in flex scanner failed" );
1152 +#endif
1153 +
1154 +/* No semi-colon after return; correct usage is to write "yyterminate();" -
1155 + * we don't want an extra ';' after the "return" because that will cause
1156 + * some compilers to complain about unreachable statements.
1157 + */
1158 +#ifndef yyterminate
1159 +#define yyterminate() return YY_NULL
1160 +#endif
1161 +
1162 +/* Number of entries by which start-condition stack grows. */
1163 +#ifndef YY_START_STACK_INCR
1164 +#define YY_START_STACK_INCR 25
1165 +#endif
1166 +
1167 +/* Report a fatal error. */
1168 +#ifndef YY_FATAL_ERROR
1169 +#define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
1170 +#endif
1171 +
1172 +/* Default declaration of generated scanner - a define so the user can
1173 + * easily add parameters.
1174 + */
1175 +#ifndef YY_DECL
1176 +#define YY_DECL int yylex YY_PROTO(( void ))
1177 +#endif
1178 +
1179 +/* Code executed at the beginning of each rule, after yytext and yyleng
1180 + * have been set up.
1181 + */
1182 +#ifndef YY_USER_ACTION
1183 +#define YY_USER_ACTION
1184 +#endif
1185 +
1186 +/* Code executed at the end of each rule. */
1187 +#ifndef YY_BREAK
1188 +#define YY_BREAK break;
1189 +#endif
1190 +
1191 +#define YY_RULE_SETUP \
1192 + YY_USER_ACTION
1193 +
1194 +YY_DECL
1195 + {
1196 + register yy_state_type yy_current_state;
1197 + register char *yy_cp, *yy_bp;
1198 + register int yy_act;
1199 +
1200 +#line 25 "matcher_parser_lex.l"
1201 +
1202 +
1203 +#line 807 "lex.yy.c"
1204 +
1205 + if ( yy_init )
1206 + {
1207 + yy_init = 0;
1208 +
1209 +#ifdef YY_USER_INIT
1210 + YY_USER_INIT;
1211 +#endif
1212 +
1213 + if ( ! yy_start )
1214 + yy_start = 1; /* first start state */
1215 +
1216 + if ( ! yyin )
1217 + yyin = stdin;
1218 +
1219 + if ( ! yyout )
1220 + yyout = stdout;
1221 +
1222 + if ( ! yy_current_buffer )
1223 + yy_current_buffer =
1224 + yy_create_buffer( yyin, YY_BUF_SIZE );
1225 +
1226 + yy_load_buffer_state();
1227 + }
1228 +
1229 + while ( 1 ) /* loops until end-of-file is reached */
1230 + {
1231 + yy_cp = yy_c_buf_p;
1232 +
1233 + /* Support of yytext. */
1234 + *yy_cp = yy_hold_char;
1235 +
1236 + /* yy_bp points to the position in yy_ch_buf of the start of
1237 + * the current run.
1238 + */
1239 + yy_bp = yy_cp;
1240 +
1241 + yy_current_state = yy_start;
1242 + yy_state_ptr = yy_state_buf;
1243 + *yy_state_ptr++ = yy_current_state;
1244 +yy_match:
1245 + do
1246 + {
1247 + register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
1248 + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1249 + {
1250 + yy_current_state = (int) yy_def[yy_current_state];
1251 + if ( yy_current_state >= 392 )
1252 + yy_c = yy_meta[(unsigned int) yy_c];
1253 + }
1254 + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1255 + *yy_state_ptr++ = yy_current_state;
1256 + ++yy_cp;
1257 + }
1258 + while ( yy_base[yy_current_state] != 411 );
1259 +
1260 +yy_find_action:
1261 + yy_current_state = *--yy_state_ptr;
1262 + yy_lp = yy_accept[yy_current_state];
1263 +find_rule: /* we branch to this label when backing up */
1264 + for ( ; ; ) /* until we find what rule we matched */
1265 + {
1266 + if ( yy_lp && yy_lp < yy_accept[yy_current_state + 1] )
1267 + {
1268 + yy_act = yy_acclist[yy_lp];
1269 + {
1270 + yy_full_match = yy_cp;
1271 + break;
1272 + }
1273 + }
1274 + --yy_cp;
1275 + yy_current_state = *--yy_state_ptr;
1276 + yy_lp = yy_accept[yy_current_state];
1277 + }
1278 +
1279 + YY_DO_BEFORE_ACTION;
1280 +
1281 + if ( yy_act != YY_END_OF_BUFFER )
1282 + {
1283 + int yyl;
1284 + for ( yyl = 0; yyl < yyleng; ++yyl )
1285 + if ( yytext[yyl] == '\n' )
1286 + ++yylineno;
1287 + }
1288 +
1289 +do_action: /* This label is used only to access EOF actions. */
1290 +
1291 +
1292 + switch ( yy_act )
1293 + { /* beginning of action switch */
1294 +case 1:
1295 +YY_RULE_SETUP
1296 +#line 27 "matcher_parser_lex.l"
1297 +return MATCHER_ALL;
1298 + YY_BREAK
1299 +case 2:
1300 +YY_RULE_SETUP
1301 +#line 28 "matcher_parser_lex.l"
1302 +return MATCHER_UNREAD;
1303 + YY_BREAK
1304 +case 3:
1305 +YY_RULE_SETUP
1306 +#line 29 "matcher_parser_lex.l"
1307 +return MATCHER_NOT_UNREAD;
1308 + YY_BREAK
1309 +case 4:
1310 +YY_RULE_SETUP
1311 +#line 30 "matcher_parser_lex.l"
1312 +return MATCHER_NEW;
1313 + YY_BREAK
1314 +case 5:
1315 +YY_RULE_SETUP
1316 +#line 31 "matcher_parser_lex.l"
1317 +return MATCHER_NOT_NEW;
1318 + YY_BREAK
1319 +case 6:
1320 +YY_RULE_SETUP
1321 +#line 32 "matcher_parser_lex.l"
1322 +return MATCHER_MARKED;
1323 + YY_BREAK
1324 +case 7:
1325 +YY_RULE_SETUP
1326 +#line 33 "matcher_parser_lex.l"
1327 +return MATCHER_NOT_MARKED;
1328 + YY_BREAK
1329 +case 8:
1330 +YY_RULE_SETUP
1331 +#line 34 "matcher_parser_lex.l"
1332 +return MATCHER_DELETED;
1333 + YY_BREAK
1334 +case 9:
1335 +YY_RULE_SETUP
1336 +#line 35 "matcher_parser_lex.l"
1337 +return MATCHER_NOT_DELETED;
1338 + YY_BREAK
1339 +case 10:
1340 +YY_RULE_SETUP
1341 +#line 36 "matcher_parser_lex.l"
1342 +return MATCHER_REPLIED;
1343 + YY_BREAK
1344 +case 11:
1345 +YY_RULE_SETUP
1346 +#line 37 "matcher_parser_lex.l"
1347 +return MATCHER_NOT_REPLIED;
1348 + YY_BREAK
1349 +case 12:
1350 +YY_RULE_SETUP
1351 +#line 38 "matcher_parser_lex.l"
1352 +return MATCHER_FORWARDED;
1353 + YY_BREAK
1354 +case 13:
1355 +YY_RULE_SETUP
1356 +#line 39 "matcher_parser_lex.l"
1357 +return MATCHER_NOT_FORWARDED;
1358 + YY_BREAK
1359 +case 14:
1360 +YY_RULE_SETUP
1361 +#line 40 "matcher_parser_lex.l"
1362 +return MATCHER_SUBJECT;
1363 + YY_BREAK
1364 +case 15:
1365 +YY_RULE_SETUP
1366 +#line 41 "matcher_parser_lex.l"
1367 +return MATCHER_NOT_SUBJECT;
1368 + YY_BREAK
1369 +case 16:
1370 +YY_RULE_SETUP
1371 +#line 42 "matcher_parser_lex.l"
1372 +return MATCHER_FROM;
1373 + YY_BREAK
1374 +case 17:
1375 +YY_RULE_SETUP
1376 +#line 43 "matcher_parser_lex.l"
1377 +return MATCHER_NOT_FROM;
1378 + YY_BREAK
1379 +case 18:
1380 +YY_RULE_SETUP
1381 +#line 44 "matcher_parser_lex.l"
1382 +return MATCHER_TO;
1383 + YY_BREAK
1384 +case 19:
1385 +YY_RULE_SETUP
1386 +#line 45 "matcher_parser_lex.l"
1387 +return MATCHER_NOT_TO;
1388 + YY_BREAK
1389 +case 20:
1390 +YY_RULE_SETUP
1391 +#line 46 "matcher_parser_lex.l"
1392 +return MATCHER_CC;
1393 + YY_BREAK
1394 +case 21:
1395 +YY_RULE_SETUP
1396 +#line 47 "matcher_parser_lex.l"
1397 +return MATCHER_NOT_CC;
1398 + YY_BREAK
1399 +case 22:
1400 +YY_RULE_SETUP
1401 +#line 48 "matcher_parser_lex.l"
1402 +return MATCHER_TO_OR_CC;
1403 + YY_BREAK
1404 +case 23:
1405 +YY_RULE_SETUP
1406 +#line 49 "matcher_parser_lex.l"
1407 +return MATCHER_NOT_TO_AND_NOT_CC;
1408 + YY_BREAK
1409 +case 24:
1410 +YY_RULE_SETUP
1411 +#line 50 "matcher_parser_lex.l"
1412 +return MATCHER_AGE_GREATER;
1413 + YY_BREAK
1414 +case 25:
1415 +YY_RULE_SETUP
1416 +#line 51 "matcher_parser_lex.l"
1417 +return MATCHER_AGE_LOWER;
1418 + YY_BREAK
1419 +case 26:
1420 +YY_RULE_SETUP
1421 +#line 52 "matcher_parser_lex.l"
1422 +return MATCHER_NEWSGROUPS;
1423 + YY_BREAK
1424 +case 27:
1425 +YY_RULE_SETUP
1426 +#line 53 "matcher_parser_lex.l"
1427 +return MATCHER_NOT_NEWSGROUPS;
1428 + YY_BREAK
1429 +case 28:
1430 +YY_RULE_SETUP
1431 +#line 54 "matcher_parser_lex.l"
1432 +return MATCHER_INREPLYTO;
1433 + YY_BREAK
1434 +case 29:
1435 +YY_RULE_SETUP
1436 +#line 55 "matcher_parser_lex.l"
1437 +return MATCHER_NOT_INREPLYTO;
1438 + YY_BREAK
1439 +case 30:
1440 +YY_RULE_SETUP
1441 +#line 56 "matcher_parser_lex.l"
1442 +return MATCHER_REFERENCES;
1443 + YY_BREAK
1444 +case 31:
1445 +YY_RULE_SETUP
1446 +#line 57 "matcher_parser_lex.l"
1447 +return MATCHER_NOT_REFERENCES;
1448 + YY_BREAK
1449 +case 32:
1450 +YY_RULE_SETUP
1451 +#line 58 "matcher_parser_lex.l"
1452 +return MATCHER_SCORE_GREATER;
1453 + YY_BREAK
1454 +case 33:
1455 +YY_RULE_SETUP
1456 +#line 59 "matcher_parser_lex.l"
1457 +return MATCHER_SCORE_LOWER;
1458 + YY_BREAK
1459 +case 34:
1460 +YY_RULE_SETUP
1461 +#line 60 "matcher_parser_lex.l"
1462 +return MATCHER_SCORE_EQUAL;
1463 + YY_BREAK
1464 +case 35:
1465 +YY_RULE_SETUP
1466 +#line 61 "matcher_parser_lex.l"
1467 +return MATCHER_SIZE_GREATER;
1468 + YY_BREAK
1469 +case 36:
1470 +YY_RULE_SETUP
1471 +#line 62 "matcher_parser_lex.l"
1472 +return MATCHER_SIZE_SMALLER;
1473 + YY_BREAK
1474 +case 37:
1475 +YY_RULE_SETUP
1476 +#line 63 "matcher_parser_lex.l"
1477 +return MATCHER_SIZE_EQUAL;
1478 + YY_BREAK
1479 +case 38:
1480 +YY_RULE_SETUP
1481 +#line 64 "matcher_parser_lex.l"
1482 +return MATCHER_HEADER;
1483 + YY_BREAK
1484 +case 39:
1485 +YY_RULE_SETUP
1486 +#line 65 "matcher_parser_lex.l"
1487 +return MATCHER_NOT_HEADER;
1488 + YY_BREAK
1489 +case 40:
1490 +YY_RULE_SETUP
1491 +#line 66 "matcher_parser_lex.l"
1492 +return MATCHER_HEADERS_PART;
1493 + YY_BREAK
1494 +case 41:
1495 +YY_RULE_SETUP
1496 +#line 67 "matcher_parser_lex.l"
1497 +return MATCHER_NOT_HEADERS_PART;
1498 + YY_BREAK
1499 +case 42:
1500 +YY_RULE_SETUP
1501 +#line 68 "matcher_parser_lex.l"
1502 +return MATCHER_MESSAGE;
1503 + YY_BREAK
1504 +case 43:
1505 +YY_RULE_SETUP
1506 +#line 69 "matcher_parser_lex.l"
1507 +return MATCHER_NOT_MESSAGE;
1508 + YY_BREAK
1509 +case 44:
1510 +YY_RULE_SETUP
1511 +#line 70 "matcher_parser_lex.l"
1512 +return MATCHER_BODY_PART;
1513 + YY_BREAK
1514 +case 45:
1515 +YY_RULE_SETUP
1516 +#line 71 "matcher_parser_lex.l"
1517 +return MATCHER_NOT_BODY_PART;
1518 + YY_BREAK
1519 +case 46:
1520 +YY_RULE_SETUP
1521 +#line 72 "matcher_parser_lex.l"
1522 +return MATCHER_EXECUTE;
1523 + YY_BREAK
1524 +case 47:
1525 +YY_RULE_SETUP
1526 +#line 73 "matcher_parser_lex.l"
1527 +return MATCHER_NOT_EXECUTE;
1528 + YY_BREAK
1529 +case 48:
1530 +YY_RULE_SETUP
1531 +#line 74 "matcher_parser_lex.l"
1532 +return MATCHER_MATCHCASE;
1533 + YY_BREAK
1534 +case 49:
1535 +YY_RULE_SETUP
1536 +#line 75 "matcher_parser_lex.l"
1537 +return MATCHER_MATCH;
1538 + YY_BREAK
1539 +case 50:
1540 +YY_RULE_SETUP
1541 +#line 76 "matcher_parser_lex.l"
1542 +return MATCHER_REGEXPCASE;
1543 + YY_BREAK
1544 +case 51:
1545 +YY_RULE_SETUP
1546 +#line 77 "matcher_parser_lex.l"
1547 +return MATCHER_REGEXP;
1548 + YY_BREAK
1549 +case 52:
1550 +YY_RULE_SETUP
1551 +#line 78 "matcher_parser_lex.l"
1552 +return MATCHER_SCORE;
1553 + YY_BREAK
1554 +case 53:
1555 +YY_RULE_SETUP
1556 +#line 79 "matcher_parser_lex.l"
1557 +return MATCHER_MOVE;
1558 + YY_BREAK
1559 +case 54:
1560 +YY_RULE_SETUP
1561 +#line 80 "matcher_parser_lex.l"
1562 +return MATCHER_COPY;
1563 + YY_BREAK
1564 +case 55:
1565 +YY_RULE_SETUP
1566 +#line 81 "matcher_parser_lex.l"
1567 +return MATCHER_DELETE;
1568 + YY_BREAK
1569 +case 56:
1570 +YY_RULE_SETUP
1571 +#line 82 "matcher_parser_lex.l"
1572 +return MATCHER_MARK;
1573 + YY_BREAK
1574 +case 57:
1575 +YY_RULE_SETUP
1576 +#line 83 "matcher_parser_lex.l"
1577 +return MATCHER_UNMARK;
1578 + YY_BREAK
1579 +case 58:
1580 +YY_RULE_SETUP
1581 +#line 84 "matcher_parser_lex.l"
1582 +return MATCHER_MARK_AS_READ;
1583 + YY_BREAK
1584 +case 59:
1585 +YY_RULE_SETUP
1586 +#line 85 "matcher_parser_lex.l"
1587 +return MATCHER_MARK_AS_UNREAD;
1588 + YY_BREAK
1589 +case 60:
1590 +YY_RULE_SETUP
1591 +#line 86 "matcher_parser_lex.l"
1592 +return MATCHER_FORWARD;
1593 + YY_BREAK
1594 +case 61:
1595 +YY_RULE_SETUP
1596 +#line 87 "matcher_parser_lex.l"
1597 +return MATCHER_FORWARD_AS_ATTACHMENT;
1598 + YY_BREAK
1599 +case 62:
1600 +YY_RULE_SETUP
1601 +#line 88 "matcher_parser_lex.l"
1602 +return MATCHER_COLOR;
1603 + YY_BREAK
1604 +case 63:
1605 +YY_RULE_SETUP
1606 +#line 89 "matcher_parser_lex.l"
1607 +return MATCHER_BOUNCE;
1608 + YY_BREAK
1609 +case 64:
1610 +YY_RULE_SETUP
1611 +#line 90 "matcher_parser_lex.l"
1612 +return MATCHER_DELETE_ON_SERVER;
1613 + YY_BREAK
1614 +case 65:
1615 +YY_RULE_SETUP
1616 +#line 91 "matcher_parser_lex.l"
1617 +
1618 + YY_BREAK
1619 +case 66:
1620 +YY_RULE_SETUP
1621 +#line 92 "matcher_parser_lex.l"
1622 +return MATCHER_EOL;
1623 + YY_BREAK
1624 +case 67:
1625 +YY_RULE_SETUP
1626 +#line 93 "matcher_parser_lex.l"
1627 +return MATCHER_AND;
1628 + YY_BREAK
1629 +case 68:
1630 +YY_RULE_SETUP
1631 +#line 94 "matcher_parser_lex.l"
1632 +return MATCHER_OR;
1633 + YY_BREAK
1634 +case 69:
1635 +YY_RULE_SETUP
1636 +#line 95 "matcher_parser_lex.l"
1637 +{
1638 + BEGIN(string);
1639 + string_buf_ptr = string_buf;
1640 + }
1641 + YY_BREAK
1642 +/* alfons - OK, the new attempt is to just swallow
1643 + * *EVERYTHING* and make sure everything is escaped
1644 + * when actually performing things. */
1645 +case 70:
1646 +YY_RULE_SETUP
1647 +#line 102 "matcher_parser_lex.l"
1648 +{
1649 + /* take care of escaped \" because this means the
1650 + * quote char should be skipped */
1651 + add_char('\\');
1652 + add_char('\"');
1653 + }
1654 + YY_BREAK
1655 +case 71:
1656 +YY_RULE_SETUP
1657 +#line 108 "matcher_parser_lex.l"
1658 +{
1659 + /* get out of the state: string ends. */
1660 + BEGIN(0);
1661 + *string_buf_ptr = '\0';
1662 + yylval.str = string_buf;
1663 + return MATCHER_STRING;
1664 + }
1665 + YY_BREAK
1666 +/* put everything else in the output. */
1667 +case 72:
1668 +YY_RULE_SETUP
1669 +#line 116 "matcher_parser_lex.l"
1670 +{
1671 + add_char(yytext[0]);
1672 + }
1673 + YY_BREAK
1674 +case 73:
1675 +YY_RULE_SETUP
1676 +#line 119 "matcher_parser_lex.l"
1677 +{
1678 + BEGIN(0);
1679 + yylval.str = yytext + 1;
1680 + yytext[strlen(yytext) - 1] = '\0';
1681 + return MATCHER_SECTION;
1682 + }
1683 + YY_BREAK
1684 +case 74:
1685 +YY_RULE_SETUP
1686 +#line 125 "matcher_parser_lex.l"
1687 +{
1688 + yylval.str = yytext;
1689 + return MATCHER_INTEGER;
1690 + }
1691 + YY_BREAK
1692 +case 75:
1693 +YY_RULE_SETUP
1694 +#line 130 "matcher_parser_lex.l"
1695 +ECHO;
1696 + YY_BREAK
1697 +#line 1301 "lex.yy.c"
1698 + case YY_STATE_EOF(INITIAL):
1699 + case YY_STATE_EOF(string):
1700 + case YY_STATE_EOF(section):
1701 + yyterminate();
1702 +
1703 + case YY_END_OF_BUFFER:
1704 + {
1705 + /* Amount of text matched not including the EOB char. */
1706 + int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
1707 +
1708 + /* Undo the effects of YY_DO_BEFORE_ACTION. */
1709 + *yy_cp = yy_hold_char;
1710 + YY_RESTORE_YY_MORE_OFFSET
1711 +
1712 + if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
1713 + {
1714 + /* We're scanning a new file or input source. It's
1715 + * possible that this happened because the user
1716 + * just pointed yyin at a new source and called
1717 + * yylex(). If so, then we have to assure
1718 + * consistency between yy_current_buffer and our
1719 + * globals. Here is the right place to do so, because
1720 + * this is the first action (other than possibly a
1721 + * back-up) that will match for the new input source.
1722 + */
1723 + yy_n_chars = yy_current_buffer->yy_n_chars;
1724 + yy_current_buffer->yy_input_file = yyin;
1725 + yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
1726 + }
1727 +
1728 + /* Note that here we test for yy_c_buf_p "<=" to the position
1729 + * of the first EOB in the buffer, since yy_c_buf_p will
1730 + * already have been incremented past the NUL character
1731 + * (since all states make transitions on EOB to the
1732 + * end-of-buffer state). Contrast this with the test
1733 + * in input().
1734 + */
1735 + if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
1736 + { /* This was really a NUL. */
1737 + yy_state_type yy_next_state;
1738 +
1739 + yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
1740 +
1741 + yy_current_state = yy_get_previous_state();
1742 +
1743 + /* Okay, we're now positioned to make the NUL
1744 + * transition. We couldn't have
1745 + * yy_get_previous_state() go ahead and do it
1746 + * for us because it doesn't know how to deal
1747 + * with the possibility of jamming (and we don't
1748 + * want to build jamming into it because then it
1749 + * will run more slowly).
1750 + */
1751 +
1752 + yy_next_state = yy_try_NUL_trans( yy_current_state );
1753 +
1754 + yy_bp = yytext_ptr + YY_MORE_ADJ;
1755 +
1756 + if ( yy_next_state )
1757 + {
1758 + /* Consume the NUL. */
1759 + yy_cp = ++yy_c_buf_p;
1760 + yy_current_state = yy_next_state;
1761 + goto yy_match;
1762 + }
1763 +
1764 + else
1765 + {
1766 + yy_cp = yy_c_buf_p;
1767 + goto yy_find_action;
1768 + }
1769 + }
1770 +
1771 + else switch ( yy_get_next_buffer() )
1772 + {
1773 + case EOB_ACT_END_OF_FILE:
1774 + {
1775 + yy_did_buffer_switch_on_eof = 0;
1776 +
1777 + if ( yywrap() )
1778 + {
1779 + /* Note: because we've taken care in
1780 + * yy_get_next_buffer() to have set up
1781 + * yytext, we can now set up
1782 + * yy_c_buf_p so that if some total
1783 + * hoser (like flex itself) wants to
1784 + * call the scanner after we return the
1785 + * YY_NULL, it'll still work - another
1786 + * YY_NULL will get returned.
1787 + */
1788 + yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
1789 +
1790 + yy_act = YY_STATE_EOF(YY_START);
1791 + goto do_action;
1792 + }
1793 +
1794 + else
1795 + {
1796 + if ( ! yy_did_buffer_switch_on_eof )
1797 + YY_NEW_FILE;
1798 + }
1799 + break;
1800 + }
1801 +
1802 + case EOB_ACT_CONTINUE_SCAN:
1803 + yy_c_buf_p =
1804 + yytext_ptr + yy_amount_of_matched_text;
1805 +
1806 + yy_current_state = yy_get_previous_state();
1807 +
1808 + yy_cp = yy_c_buf_p;
1809 + yy_bp = yytext_ptr + YY_MORE_ADJ;
1810 + goto yy_match;
1811 +
1812 + case EOB_ACT_LAST_MATCH:
1813 + yy_c_buf_p =
1814 + &yy_current_buffer->yy_ch_buf[yy_n_chars];
1815 +
1816 + yy_current_state = yy_get_previous_state();
1817 +
1818 + yy_cp = yy_c_buf_p;
1819 + yy_bp = yytext_ptr + YY_MORE_ADJ;
1820 + goto yy_find_action;
1821 + }
1822 + break;
1823 + }
1824 +
1825 + default:
1826 + YY_FATAL_ERROR(
1827 + "fatal flex scanner internal error--no action found" );
1828 + } /* end of action switch */
1829 + } /* end of scanning one token */
1830 + } /* end of yylex */
1831 +
1832 +
1833 +/* yy_get_next_buffer - try to read in a new buffer
1834 + *
1835 + * Returns a code representing an action:
1836 + * EOB_ACT_LAST_MATCH -
1837 + * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1838 + * EOB_ACT_END_OF_FILE - end of file
1839 + */
1840 +
1841 +static int yy_get_next_buffer()
1842 + {
1843 + register char *dest = yy_current_buffer->yy_ch_buf;
1844 + register char *source = yytext_ptr;
1845 + register int number_to_move, i;
1846 + int ret_val;
1847 +
1848 + if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
1849 + YY_FATAL_ERROR(
1850 + "fatal flex scanner internal error--end of buffer missed" );
1851 +
1852 + if ( yy_current_buffer->yy_fill_buffer == 0 )
1853 + { /* Don't try to fill the buffer, so this is an EOF. */
1854 + if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
1855 + {
1856 + /* We matched a single character, the EOB, so
1857 + * treat this as a final EOF.
1858 + */
1859 + return EOB_ACT_END_OF_FILE;
1860 + }
1861 +
1862 + else
1863 + {
1864 + /* We matched some text prior to the EOB, first
1865 + * process it.
1866 + */
1867 + return EOB_ACT_LAST_MATCH;
1868 + }
1869 + }
1870 +
1871 + /* Try to read more data. */
1872 +
1873 + /* First move last chars to start of buffer. */
1874 + number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
1875 +
1876 + for ( i = 0; i < number_to_move; ++i )
1877 + *(dest++) = *(source++);
1878 +
1879 + if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1880 + /* don't do the read, it's not guaranteed to return an EOF,
1881 + * just force an EOF
1882 + */
1883 + yy_current_buffer->yy_n_chars = yy_n_chars = 0;
1884 +
1885 + else
1886 + {
1887 + int num_to_read =
1888 + yy_current_buffer->yy_buf_size - number_to_move - 1;
1889 +
1890 + while ( num_to_read <= 0 )
1891 + { /* Not enough room in the buffer - grow it. */
1892 +#ifdef YY_USES_REJECT
1893 + YY_FATAL_ERROR(
1894 +"input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
1895 +#else
1896 +
1897 + /* just a shorter name for the current buffer */
1898 + YY_BUFFER_STATE b = yy_current_buffer;
1899 +
1900 + int yy_c_buf_p_offset =
1901 + (int) (yy_c_buf_p - b->yy_ch_buf);
1902 +
1903 + if ( b->yy_is_our_buffer )
1904 + {
1905 + int new_size = b->yy_buf_size * 2;
1906 +
1907 + if ( new_size <= 0 )
1908 + b->yy_buf_size += b->yy_buf_size / 8;
1909 + else
1910 + b->yy_buf_size *= 2;
1911 +
1912 + b->yy_ch_buf = (char *)
1913 + /* Include room in for 2 EOB chars. */
1914 + yy_flex_realloc( (void *) b->yy_ch_buf,
1915 + b->yy_buf_size + 2 );
1916 + }
1917 + else
1918 + /* Can't grow it, we don't own it. */
1919 + b->yy_ch_buf = 0;
1920 +
1921 + if ( ! b->yy_ch_buf )
1922 + YY_FATAL_ERROR(
1923 + "fatal error - scanner input buffer overflow" );
1924 +
1925 + yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
1926 +
1927 + num_to_read = yy_current_buffer->yy_buf_size -
1928 + number_to_move - 1;
1929 +#endif
1930 + }
1931 +
1932 + if ( num_to_read > YY_READ_BUF_SIZE )
1933 + num_to_read = YY_READ_BUF_SIZE;
1934 +
1935 + /* Read in more data. */
1936 + YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
1937 + yy_n_chars, num_to_read );
1938 +
1939 + yy_current_buffer->yy_n_chars = yy_n_chars;
1940 + }
1941 +
1942 + if ( yy_n_chars == 0 )
1943 + {
1944 + if ( number_to_move == YY_MORE_ADJ )
1945 + {
1946 + ret_val = EOB_ACT_END_OF_FILE;
1947 + yyrestart( yyin );
1948 + }
1949 +
1950 + else
1951 + {
1952 + ret_val = EOB_ACT_LAST_MATCH;
1953 + yy_current_buffer->yy_buffer_status =
1954 + YY_BUFFER_EOF_PENDING;
1955 + }
1956 + }
1957 +
1958 + else
1959 + ret_val = EOB_ACT_CONTINUE_SCAN;
1960 +
1961 + yy_n_chars += number_to_move;
1962 + yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
1963 + yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
1964 +
1965 + yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
1966 +
1967 + return ret_val;
1968 + }
1969 +
1970 +
1971 +/* yy_get_previous_state - get the state just before the EOB char was reached */
1972 +
1973 +static yy_state_type yy_get_previous_state()
1974 + {
1975 + register yy_state_type yy_current_state;
1976 + register char *yy_cp;
1977 +
1978 + yy_current_state = yy_start;
1979 + yy_state_ptr = yy_state_buf;
1980 + *yy_state_ptr++ = yy_current_state;
1981 +
1982 + for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
1983 + {
1984 + register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1985 + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1986 + {
1987 + yy_current_state = (int) yy_def[yy_current_state];
1988 + if ( yy_current_state >= 392 )
1989 + yy_c = yy_meta[(unsigned int) yy_c];
1990 + }
1991 + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1992 + *yy_state_ptr++ = yy_current_state;
1993 + }
1994 +
1995 + return yy_current_state;
1996 + }
1997 +
1998 +
1999 +/* yy_try_NUL_trans - try to make a transition on the NUL character
2000 + *
2001 + * synopsis
2002 + * next_state = yy_try_NUL_trans( current_state );
2003 + */
2004 +
2005 +#ifdef YY_USE_PROTOS
2006 +static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
2007 +#else
2008 +static yy_state_type yy_try_NUL_trans( yy_current_state )
2009 +yy_state_type yy_current_state;
2010 +#endif
2011 + {
2012 + register int yy_is_jam;
2013 +
2014 + register YY_CHAR yy_c = 1;
2015 + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
2016 + {
2017 + yy_current_state = (int) yy_def[yy_current_state];
2018 + if ( yy_current_state >= 392 )
2019 + yy_c = yy_meta[(unsigned int) yy_c];
2020 + }
2021 + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
2022 + yy_is_jam = (yy_current_state == 391);
2023 + if ( ! yy_is_jam )
2024 + *yy_state_ptr++ = yy_current_state;
2025 +
2026 + return yy_is_jam ? 0 : yy_current_state;
2027 + }
2028 +
2029 +
2030 +#ifndef YY_NO_UNPUT
2031 +#ifdef YY_USE_PROTOS
2032 +static void yyunput( int c, register char *yy_bp )
2033 +#else
2034 +static void yyunput( c, yy_bp )
2035 +int c;
2036 +register char *yy_bp;
2037 +#endif
2038 + {
2039 + register char *yy_cp = yy_c_buf_p;
2040 +
2041 + /* undo effects of setting up yytext */
2042 + *yy_cp = yy_hold_char;
2043 +
2044 + if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
2045 + { /* need to shift things up to make room */
2046 + /* +2 for EOB chars. */
2047 + register int number_to_move = yy_n_chars + 2;
2048 + register char *dest = &yy_current_buffer->yy_ch_buf[
2049 + yy_current_buffer->yy_buf_size + 2];
2050 + register char *source =
2051 + &yy_current_buffer->yy_ch_buf[number_to_move];
2052 +
2053 + while ( source > yy_current_buffer->yy_ch_buf )
2054 + *--dest = *--source;
2055 +
2056 + yy_cp += (int) (dest - source);
2057 + yy_bp += (int) (dest - source);
2058 + yy_current_buffer->yy_n_chars =
2059 + yy_n_chars = yy_current_buffer->yy_buf_size;
2060 +
2061 + if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
2062 + YY_FATAL_ERROR( "flex scanner push-back overflow" );
2063 + }
2064 +
2065 + *--yy_cp = (char) c;
2066 +
2067 + if ( c == '\n' )
2068 + --yylineno;
2069 +
2070 + yytext_ptr = yy_bp;
2071 + yy_hold_char = *yy_cp;
2072 + yy_c_buf_p = yy_cp;
2073 + }
2074 +#endif /* ifndef YY_NO_UNPUT */
2075 +
2076 +
2077 +#ifdef __cplusplus
2078 +static int yyinput()
2079 +#else
2080 +static int input()
2081 +#endif
2082 + {
2083 + int c;
2084 +
2085 + *yy_c_buf_p = yy_hold_char;
2086 +
2087 + if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
2088 + {
2089 + /* yy_c_buf_p now points to the character we want to return.
2090 + * If this occurs *before* the EOB characters, then it's a
2091 + * valid NUL; if not, then we've hit the end of the buffer.
2092 + */
2093 + if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
2094 + /* This was really a NUL. */
2095 + *yy_c_buf_p = '\0';
2096 +
2097 + else
2098 + { /* need more input */
2099 + int offset = yy_c_buf_p - yytext_ptr;
2100 + ++yy_c_buf_p;
2101 +
2102 + switch ( yy_get_next_buffer() )
2103 + {
2104 + case EOB_ACT_LAST_MATCH:
2105 + /* This happens because yy_g_n_b()
2106 + * sees that we've accumulated a
2107 + * token and flags that we need to
2108 + * try matching the token before
2109 + * proceeding. But for input(),
2110 + * there's no matching to consider.
2111 + * So convert the EOB_ACT_LAST_MATCH
2112 + * to EOB_ACT_END_OF_FILE.
2113 + */
2114 +
2115 + /* Reset buffer status. */
2116 + yyrestart( yyin );
2117 +
2118 + /* fall through */
2119 +
2120 + case EOB_ACT_END_OF_FILE:
2121 + {
2122 + if ( yywrap() )
2123 + return EOF;
2124 +
2125 + if ( ! yy_did_buffer_switch_on_eof )
2126 + YY_NEW_FILE;
2127 +#ifdef __cplusplus
2128 + return yyinput();
2129 +#else
2130 + return input();
2131 +#endif
2132 + }
2133 +
2134 + case EOB_ACT_CONTINUE_SCAN:
2135 + yy_c_buf_p = yytext_ptr + offset;
2136 + break;
2137 + }
2138 + }
2139 + }
2140 +
2141 + c = *(unsigned char *) yy_c_buf_p; /* cast for 8-bit char's */
2142 + *yy_c_buf_p = '\0'; /* preserve yytext */
2143 + yy_hold_char = *++yy_c_buf_p;
2144 +
2145 + if ( c == '\n' )
2146 + ++yylineno;
2147 +
2148 + return c;
2149 + }
2150 +
2151 +
2152 +#ifdef YY_USE_PROTOS
2153 +void yyrestart( FILE *input_file )
2154 +#else
2155 +void yyrestart( input_file )
2156 +FILE *input_file;
2157 +#endif
2158 + {
2159 + if ( ! yy_current_buffer )
2160 + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
2161 +
2162 + yy_init_buffer( yy_current_buffer, input_file );
2163 + yy_load_buffer_state();
2164 + }
2165 +
2166 +
2167 +#ifdef YY_USE_PROTOS
2168 +void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
2169 +#else
2170 +void yy_switch_to_buffer( new_buffer )
2171 +YY_BUFFER_STATE new_buffer;
2172 +#endif
2173 + {
2174 + if ( yy_current_buffer == new_buffer )
2175 + return;
2176 +
2177 + if ( yy_current_buffer )
2178 + {
2179 + /* Flush out information for old buffer. */
2180 + *yy_c_buf_p = yy_hold_char;
2181 + yy_current_buffer->yy_buf_pos = yy_c_buf_p;
2182 + yy_current_buffer->yy_n_chars = yy_n_chars;
2183 + }
2184 +
2185 + yy_current_buffer = new_buffer;
2186 + yy_load_buffer_state();
2187 +
2188 + /* We don't actually know whether we did this switch during
2189 + * EOF (yywrap()) processing, but the only time this flag
2190 + * is looked at is after yywrap() is called, so it's safe
2191 + * to go ahead and always set it.
2192 + */
2193 + yy_did_buffer_switch_on_eof = 1;
2194 + }
2195 +
2196 +
2197 +#ifdef YY_USE_PROTOS
2198 +void yy_load_buffer_state( void )
2199 +#else
2200 +void yy_load_buffer_state()
2201 +#endif
2202 + {
2203 + yy_n_chars = yy_current_buffer->yy_n_chars;
2204 + yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
2205 + yyin = yy_current_buffer->yy_input_file;
2206 + yy_hold_char = *yy_c_buf_p;
2207 + }
2208 +
2209 +
2210 +#ifdef YY_USE_PROTOS
2211 +YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
2212 +#else
2213 +YY_BUFFER_STATE yy_create_buffer( file, size )
2214 +FILE *file;
2215 +int size;
2216 +#endif
2217 + {
2218 + YY_BUFFER_STATE b;
2219 +
2220 + b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
2221 + if ( ! b )
2222 + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2223 +
2224 + b->yy_buf_size = size;
2225 +
2226 + /* yy_ch_buf has to be 2 characters longer than the size given because
2227 + * we need to put in 2 end-of-buffer characters.
2228 + */
2229 + b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
2230 + if ( ! b->yy_ch_buf )
2231 + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2232 +
2233 + b->yy_is_our_buffer = 1;
2234 +
2235 + yy_init_buffer( b, file );
2236 +
2237 + return b;
2238 + }
2239 +
2240 +
2241 +#ifdef YY_USE_PROTOS
2242 +void yy_delete_buffer( YY_BUFFER_STATE b )
2243 +#else
2244 +void yy_delete_buffer( b )
2245 +YY_BUFFER_STATE b;
2246 +#endif
2247 + {
2248 + if ( ! b )
2249 + return;
2250 +
2251 + if ( b == yy_current_buffer )
2252 + yy_current_buffer = (YY_BUFFER_STATE) 0;
2253 +
2254 + if ( b->yy_is_our_buffer )
2255 + yy_flex_free( (void *) b->yy_ch_buf );
2256 +
2257 + yy_flex_free( (void *) b );
2258 + }
2259 +
2260 +
2261 +#ifndef YY_ALWAYS_INTERACTIVE
2262 +#ifndef YY_NEVER_INTERACTIVE
2263 +extern int isatty YY_PROTO(( int ));
2264 +#endif
2265 +#endif
2266 +
2267 +#ifdef YY_USE_PROTOS
2268 +void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
2269 +#else
2270 +void yy_init_buffer( b, file )
2271 +YY_BUFFER_STATE b;
2272 +FILE *file;
2273 +#endif
2274 +
2275 +
2276 + {
2277 + yy_flush_buffer( b );
2278 +
2279 + b->yy_input_file = file;
2280 + b->yy_fill_buffer = 1;
2281 +
2282 +#if YY_ALWAYS_INTERACTIVE
2283 + b->yy_is_interactive = 1;
2284 +#else
2285 +#if YY_NEVER_INTERACTIVE
2286 + b->yy_is_interactive = 0;
2287 +#else
2288 + b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
2289 +#endif
2290 +#endif
2291 + }
2292 +
2293 +
2294 +#ifdef YY_USE_PROTOS
2295 +void yy_flush_buffer( YY_BUFFER_STATE b )
2296 +#else
2297 +void yy_flush_buffer( b )
2298 +YY_BUFFER_STATE b;
2299 +#endif
2300 +
2301 + {
2302 + if ( ! b )
2303 + return;
2304 +
2305 + b->yy_n_chars = 0;
2306 +
2307 + /* We always need two end-of-buffer characters. The first causes
2308 + * a transition to the end-of-buffer state. The second causes
2309 + * a jam in that state.
2310 + */
2311 + b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
2312 + b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
2313 +
2314 + b->yy_buf_pos = &b->yy_ch_buf[0];
2315 +
2316 + b->yy_at_bol = 1;
2317 + b->yy_buffer_status = YY_BUFFER_NEW;
2318 +
2319 + if ( b == yy_current_buffer )
2320 + yy_load_buffer_state();
2321 + }
2322 +
2323 +
2324 +#ifndef YY_NO_SCAN_BUFFER
2325 +#ifdef YY_USE_PROTOS
2326 +YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
2327 +#else
2328 +YY_BUFFER_STATE yy_scan_buffer( base, size )
2329 +char *base;
2330 +yy_size_t size;
2331 +#endif
2332 + {
2333 + YY_BUFFER_STATE b;
2334 +
2335 + if ( size < 2 ||
2336 + base[size-2] != YY_END_OF_BUFFER_CHAR ||
2337 + base[size-1] != YY_END_OF_BUFFER_CHAR )
2338 + /* They forgot to leave room for the EOB's. */
2339 + return 0;
2340 +
2341 + b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
2342 + if ( ! b )
2343 + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
2344 +
2345 + b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
2346 + b->yy_buf_pos = b->yy_ch_buf = base;
2347 + b->yy_is_our_buffer = 0;
2348 + b->yy_input_file = 0;
2349 + b->yy_n_chars = b->yy_buf_size;
2350 + b->yy_is_interactive = 0;
2351 + b->yy_at_bol = 1;
2352 + b->yy_fill_buffer = 0;
2353 + b->yy_buffer_status = YY_BUFFER_NEW;
2354 +
2355 + yy_switch_to_buffer( b );
2356 +
2357 + return b;
2358 + }
2359 +#endif
2360 +
2361 +
2362 +#ifndef YY_NO_SCAN_STRING
2363 +#ifdef YY_USE_PROTOS
2364 +YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
2365 +#else
2366 +YY_BUFFER_STATE yy_scan_string( yy_str )
2367 +yyconst char *yy_str;
2368 +#endif
2369 + {
2370 + int len;
2371 + for ( len = 0; yy_str[len]; ++len )
2372 + ;
2373 +
2374 + return yy_scan_bytes( yy_str, len );
2375 + }
2376 +#endif
2377 +
2378 +
2379 +#ifndef YY_NO_SCAN_BYTES
2380 +#ifdef YY_USE_PROTOS
2381 +YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
2382 +#else
2383 +YY_BUFFER_STATE yy_scan_bytes( bytes, len )
2384 +yyconst char *bytes;
2385 +int len;
2386 +#endif
2387 + {
2388 + YY_BUFFER_STATE b;
2389 + char *buf;
2390 + yy_size_t n;
2391 + int i;
2392 +
2393 + /* Get memory for full buffer, including space for trailing EOB's. */
2394 + n = len + 2;
2395 + buf = (char *) yy_flex_alloc( n );
2396 + if ( ! buf )
2397 + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
2398 +
2399 + for ( i = 0; i < len; ++i )
2400 + buf[i] = bytes[i];
2401 +
2402 + buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
2403 +
2404 + b = yy_scan_buffer( buf, n );
2405 + if ( ! b )
2406 + YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
2407 +
2408 + /* It's okay to grow etc. this buffer, and we should throw it
2409 + * away when we're done.
2410 + */
2411 + b->yy_is_our_buffer = 1;
2412 +
2413 + return b;
2414 + }
2415 +#endif
2416 +
2417 +
2418 +#ifndef YY_NO_PUSH_STATE
2419 +#ifdef YY_USE_PROTOS
2420 +static void yy_push_state( int new_state )
2421 +#else
2422 +static void yy_push_state( new_state )
2423 +int new_state;
2424 +#endif
2425 + {
2426 + if ( yy_start_stack_ptr >= yy_start_stack_depth )
2427 + {
2428 + yy_size_t new_size;
2429 +
2430 + yy_start_stack_depth += YY_START_STACK_INCR;
2431 + new_size = yy_start_stack_depth * sizeof( int );
2432 +
2433 + if ( ! yy_start_stack )
2434 + yy_start_stack = (int *) yy_flex_alloc( new_size );
2435 +
2436 + else
2437 + yy_start_stack = (int *) yy_flex_realloc(
2438 + (void *) yy_start_stack, new_size );
2439 +
2440 + if ( ! yy_start_stack )
2441 + YY_FATAL_ERROR(
2442 + "out of memory expanding start-condition stack" );
2443 + }
2444 +
2445 + yy_start_stack[yy_start_stack_ptr++] = YY_START;
2446 +
2447 + BEGIN(new_state);
2448 + }
2449 +#endif
2450 +
2451 +
2452 +#ifndef YY_NO_POP_STATE
2453 +static void yy_pop_state()
2454 + {
2455 + if ( --yy_start_stack_ptr < 0 )
2456 + YY_FATAL_ERROR( "start-condition stack underflow" );
2457 +
2458 + BEGIN(yy_start_stack[yy_start_stack_ptr]);
2459 + }
2460 +#endif
2461 +
2462 +
2463 +#ifndef YY_NO_TOP_STATE
2464 +static int yy_top_state()
2465 + {
2466 + return yy_start_stack[yy_start_stack_ptr - 1];
2467 + }
2468 +#endif
2469 +
2470 +#ifndef YY_EXIT_FAILURE
2471 +#define YY_EXIT_FAILURE 2
2472 +#endif
2473 +
2474 +#ifdef YY_USE_PROTOS
2475 +static void yy_fatal_error( yyconst char msg[] )
2476 +#else
2477 +static void yy_fatal_error( msg )
2478 +char msg[];
2479 +#endif
2480 + {
2481 + (void) fprintf( stderr, "%s\n", msg );
2482 + exit( YY_EXIT_FAILURE );
2483 + }
2484 +
2485 +
2486 +
2487 +/* Redefine yyless() so it works in section 3 code. */
2488 +
2489 +#undef yyless
2490 +#define yyless(n) \
2491 + do \
2492 + { \
2493 + /* Undo effects of setting up yytext. */ \
2494 + yytext[yyleng] = yy_hold_char; \
2495 + yy_c_buf_p = yytext + n; \
2496 + yy_hold_char = *yy_c_buf_p; \
2497 + *yy_c_buf_p = '\0'; \
2498 + yyleng = n; \
2499 + } \
2500 + while ( 0 )
2501 +
2502 +
2503 +/* Internal utility routines. */
2504 +
2505 +#ifndef yytext_ptr
2506 +#ifdef YY_USE_PROTOS
2507 +static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
2508 +#else
2509 +static void yy_flex_strncpy( s1, s2, n )
2510 +char *s1;
2511 +yyconst char *s2;
2512 +int n;
2513 +#endif
2514 + {
2515 + register int i;
2516 + for ( i = 0; i < n; ++i )
2517 + s1[i] = s2[i];
2518 + }
2519 +#endif
2520 +
2521 +#ifdef YY_NEED_STRLEN
2522 +#ifdef YY_USE_PROTOS
2523 +static int yy_flex_strlen( yyconst char *s )
2524 +#else
2525 +static int yy_flex_strlen( s )
2526 +yyconst char *s;
2527 +#endif
2528 + {
2529 + register int n;
2530 + for ( n = 0; s[n]; ++n )
2531 + ;
2532 +
2533 + return n;
2534 + }
2535 +#endif
2536 +
2537 +
2538 +#ifdef YY_USE_PROTOS
2539 +static void *yy_flex_alloc( yy_size_t size )
2540 +#else
2541 +static void *yy_flex_alloc( size )
2542 +yy_size_t size;
2543 +#endif
2544 + {
2545 + return (void *) malloc( size );
2546 + }
2547 +
2548 +#ifdef YY_USE_PROTOS
2549 +static void *yy_flex_realloc( void *ptr, yy_size_t size )
2550 +#else
2551 +static void *yy_flex_realloc( ptr, size )
2552 +void *ptr;
2553 +yy_size_t size;
2554 +#endif
2555 + {
2556 + /* The cast to (char *) in the following accommodates both
2557 + * implementations that use char* generic pointers, and those
2558 + * that use void* generic pointers. It works with the latter
2559 + * because both ANSI C and C++ allow castless assignment from
2560 + * any pointer type to void*, and deal with argument conversions
2561 + * as though doing an assignment.
2562 + */
2563 + return (void *) realloc( (char *) ptr, size );
2564 + }
2565 +
2566 +#ifdef YY_USE_PROTOS
2567 +static void yy_flex_free( void *ptr )
2568 +#else
2569 +static void yy_flex_free( ptr )
2570 +void *ptr;
2571 +#endif
2572 + {
2573 + free( ptr );
2574 + }
2575 +
2576 +#if YY_MAIN
2577 +int main()
2578 + {
2579 + yylex();
2580 + return 0;
2581 + }
2582 +#endif
2583 +#line 130 "matcher_parser_lex.l"
2584 +
2585 diff -urN empty/matcher_parser_parse.c src/matcher_parser_parse.c
2586 --- empty/matcher_parser_parse.c Thu Jan 1 00:00:00 1970
2587 +++ src/matcher_parser_parse.c Sun May 12 00:04:36 2002
2588 @@ -0,0 +1,2266 @@
2589 +/* A Bison parser, made from /src/sylpheed-claws-w32/sylpheed-claws/src/matcher_parser_parse.y
2590 + by GNU bison 1.31. */
2591 +
2592 +#define YYBISON 1 /* Identify Bison output. */
2593 +
2594 +# define MATCHER_ALL 257
2595 +# define MATCHER_UNREAD 258
2596 +# define MATCHER_NOT_UNREAD 259
2597 +# define MATCHER_NEW 260
2598 +# define MATCHER_NOT_NEW 261
2599 +# define MATCHER_MARKED 262
2600 +# define MATCHER_NOT_MARKED 263
2601 +# define MATCHER_DELETED 264
2602 +# define MATCHER_NOT_DELETED 265
2603 +# define MATCHER_REPLIED 266
2604 +# define MATCHER_NOT_REPLIED 267
2605 +# define MATCHER_FORWARDED 268
2606 +# define MATCHER_NOT_FORWARDED 269
2607 +# define MATCHER_SUBJECT 270
2608 +# define MATCHER_NOT_SUBJECT 271
2609 +# define MATCHER_FROM 272
2610 +# define MATCHER_NOT_FROM 273
2611 +# define MATCHER_TO 274
2612 +# define MATCHER_NOT_TO 275
2613 +# define MATCHER_CC 276
2614 +# define MATCHER_NOT_CC 277
2615 +# define MATCHER_TO_OR_CC 278
2616 +# define MATCHER_NOT_TO_AND_NOT_CC 279
2617 +# define MATCHER_AGE_GREATER 280
2618 +# define MATCHER_AGE_LOWER 281
2619 +# define MATCHER_NEWSGROUPS 282
2620 +# define MATCHER_NOT_NEWSGROUPS 283
2621 +# define MATCHER_INREPLYTO 284
2622 +# define MATCHER_NOT_INREPLYTO 285
2623 +# define MATCHER_REFERENCES 286
2624 +# define MATCHER_NOT_REFERENCES 287
2625 +# define MATCHER_SCORE_GREATER 288
2626 +# define MATCHER_SCORE_LOWER 289
2627 +# define MATCHER_HEADER 290
2628 +# define MATCHER_NOT_HEADER 291
2629 +# define MATCHER_HEADERS_PART 292
2630 +# define MATCHER_NOT_HEADERS_PART 293
2631 +# define MATCHER_MESSAGE 294
2632 +# define MATCHER_NOT_MESSAGE 295
2633 +# define MATCHER_BODY_PART 296
2634 +# define MATCHER_NOT_BODY_PART 297
2635 +# define MATCHER_EXECUTE 298
2636 +# define MATCHER_NOT_EXECUTE 299
2637 +# define MATCHER_MATCHCASE 300
2638 +# define MATCHER_MATCH 301
2639 +# define MATCHER_REGEXPCASE 302
2640 +# define MATCHER_REGEXP 303
2641 +# define MATCHER_SCORE 304
2642 +# define MATCHER_MOVE 305
2643 +# define MATCHER_COPY 306
2644 +# define MATCHER_DELETE 307
2645 +# define MATCHER_MARK 308
2646 +# define MATCHER_UNMARK 309
2647 +# define MATCHER_MARK_AS_READ 310
2648 +# define MATCHER_MARK_AS_UNREAD 311
2649 +# define MATCHER_FORWARD 312
2650 +# define MATCHER_FORWARD_AS_ATTACHMENT 313
2651 +# define MATCHER_EOL 314
2652 +# define MATCHER_STRING 315
2653 +# define MATCHER_OR 316
2654 +# define MATCHER_AND 317
2655 +# define MATCHER_COLOR 318
2656 +# define MATCHER_SCORE_EQUAL 319
2657 +# define MATCHER_BOUNCE 320
2658 +# define MATCHER_DELETE_ON_SERVER 321
2659 +# define MATCHER_SIZE_GREATER 322
2660 +# define MATCHER_SIZE_SMALLER 323
2661 +# define MATCHER_SIZE_EQUAL 324
2662 +# define MATCHER_SECTION 325
2663 +# define MATCHER_INTEGER 326
2664 +
2665 +#line 1 "matcher_parser_parse.y"
2666 +
2667 +#include "defs.h"
2668 +
2669 +#include <glib.h>
2670 +
2671 +#include "intl.h"
2672 +#include "utils.h"
2673 +#include "filtering.h"
2674 +#include "scoring.h"
2675 +#include "matcher.h"
2676 +#include "matcher_parser.h"
2677 +#include "matcher_parser_lex.h"
2678 +
2679 +static gint error = 0;
2680 +static gint bool_op = 0;
2681 +static gint match_type = 0;
2682 +static gchar * header = NULL;
2683 +
2684 +static MatcherProp * prop;
2685 +
2686 +static GSList * matchers_list = NULL;
2687 +
2688 +static MatcherList * cond;
2689 +static gint score = 0;
2690 +static FilteringAction * action = NULL;
2691 +
2692 +static FilteringProp * filtering;
2693 +static ScoringProp * scoring = NULL;
2694 +
2695 +static GSList ** prefs_scoring = NULL;
2696 +static GSList ** prefs_filtering = NULL;
2697 +
2698 +static int matcher_parser_dialog = 0;
2699 +
2700 +
2701 +/* ******************************************************************** */
2702 +
2703 +
2704 +
2705 +void matcher_parser_start_parsing(FILE * f)
2706 +{
2707 + matcher_parserrestart(f);
2708 + matcher_parserparse();
2709 +}
2710 +
2711 +FilteringProp * matcher_parser_get_filtering(gchar * str)
2712 +{
2713 + void * bufstate;
2714 +
2715 + /* bad coding to enable the sub-grammar matching
2716 + in yacc */
2717 + matcher_parserlineno = 1;
2718 + matcher_parser_dialog = 1;
2719 + bufstate = matcher_parser_scan_string(str);
2720 + if (matcher_parserparse() != 0)
2721 + filtering = NULL;
2722 + matcher_parser_dialog = 0;
2723 + matcher_parser_delete_buffer(bufstate);
2724 + return filtering;
2725 +}
2726 +
2727 +ScoringProp * matcher_parser_get_scoring(gchar * str)
2728 +{
2729 + void * bufstate;
2730 +
2731 + /* bad coding to enable the sub-grammar matching
2732 + in yacc */
2733 + matcher_parserlineno = 1;
2734 + matcher_parser_dialog = 1;
2735 + bufstate = matcher_parser_scan_string(str);
2736 + if (matcher_parserparse() != 0)
2737 + scoring = NULL;
2738 + matcher_parser_dialog = 0;
2739 + matcher_parser_delete_buffer(bufstate);
2740 + return scoring;
2741 +}
2742 +
2743 +MatcherList * matcher_parser_get_cond(gchar * str)
2744 +{
2745 + void * bufstate;
2746 +
2747 + /* bad coding to enable the sub-grammar matching
2748 + in yacc */
2749 + matcher_parserlineno = 1;
2750 + matcher_parser_dialog = 1;
2751 + bufstate = matcher_parser_scan_string(str);
2752 + matcher_parserparse();
2753 + matcher_parser_dialog = 0;
2754 + matcher_parser_delete_buffer(bufstate);
2755 + return cond;
2756 +}
2757 +
2758 +MatcherProp * matcher_parser_get_prop(gchar * str)
2759 +{
2760 + MatcherList * list;
2761 + MatcherProp * prop;
2762 +
2763 + matcher_parserlineno = 1;
2764 + list = matcher_parser_get_cond(str);
2765 + if (list == NULL)
2766 + return NULL;
2767 +
2768 + if (list->matchers == NULL)
2769 + return NULL;
2770 +
2771 + if (list->matchers->next != NULL)
2772 + return NULL;
2773 +
2774 + prop = list->matchers->data;
2775 +
2776 + g_slist_free(list->matchers);
2777 + g_free(list);
2778 +
2779 + return prop;
2780 +}
2781 +
2782 +void matcher_parsererror(char * str)
2783 +{
2784 + GSList * l;
2785 +
2786 + if (matchers_list) {
2787 + for(l = matchers_list ; l != NULL ;
2788 + l = g_slist_next(l))
2789 + matcherprop_free((MatcherProp *)
2790 + l->data);
2791 + g_slist_free(matchers_list);
2792 + matchers_list = NULL;
2793 + }
2794 +
2795 + g_warning(_("scoring / filtering parsing: %i: %s\n"),
2796 + matcher_parserlineno, str);
2797 + error = 1;
2798 +}
2799 +
2800 +int matcher_parserwrap(void)
2801 +{
2802 + return 1;
2803 +}
2804 +
2805 +#line 141 "matcher_parser_parse.y"
2806 +#ifndef YYSTYPE
2807 +typedef union {
2808 + char * str;
2809 + int value;
2810 +} yystype;
2811 +# define YYSTYPE yystype
2812 +#endif
2813 +#ifndef YYDEBUG
2814 +# define YYDEBUG 0
2815 +#endif
2816 +
2817 +
2818 +
2819 +#define YYFINAL 165
2820 +#define YYFLAG -32768
2821 +#define YYNTBASE 73
2822 +
2823 +/* YYTRANSLATE(YYLEX) -- Bison token number corresponding to YYLEX. */
2824 +#define YYTRANSLATE(x) ((unsigned)(x) <= 326 ? yytranslate[x] : 91)
2825 +
2826 +/* YYTRANSLATE[YYLEX] -- Bison token number corresponding to YYLEX. */
2827 +static const char yytranslate[] =
2828 +{
2829 + 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2830 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2831 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2832 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2833 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2834 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2835 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2836 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2837 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2838 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2839 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2840 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2841 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2842 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2843 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2844 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2845 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2846 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2847 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2848 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2849 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2850 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2851 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2852 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2853 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2854 + 2, 2, 2, 2, 2, 2, 1, 3, 4, 5,
2855 + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
2856 + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
2857 + 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
2858 + 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
2859 + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
2860 + 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
2861 + 66, 67, 68, 69, 70, 71, 72
2862 +};
2863 +
2864 +#if YYDEBUG
2865 +static const short yyprhs[] =
2866 +{
2867 + 0, 0, 1, 4, 7, 9, 11, 13, 16, 19,
2868 + 22, 24, 27, 28, 30, 31, 33, 35, 37, 39,
2869 + 41, 43, 45, 49, 51, 53, 55, 57, 59, 61,
2870 + 63, 65, 67, 69, 71, 73, 75, 77, 79, 81,
2871 + 85, 89, 93, 97, 101, 105, 109, 113, 117, 121,
2872 + 124, 127, 131, 135, 139, 143, 147, 151, 154, 157,
2873 + 160, 163, 166, 169, 170, 176, 177, 183, 187, 191,
2874 + 195, 199, 203, 207, 210, 213, 216, 219, 222, 224,
2875 + 226, 228, 230, 232, 236, 240, 244, 247, 249
2876 +};
2877 +static const short yyrhs[] =
2878 +{
2879 + -1, 74, 75, 0, 76, 75, 0, 76, 0, 77,
2880 + 0, 78, 0, 1, 60, 0, 71, 60, 0, 83,
2881 + 79, 0, 60, 0, 81, 80, 0, 0, 60, 0,
2882 + 0, 89, 0, 90, 0, 46, 0, 47, 0, 48,
2883 + 0, 49, 0, 84, 0, 84, 85, 86, 0, 86,
2884 + 0, 63, 0, 62, 0, 3, 0, 4, 0, 5,
2885 + 0, 6, 0, 7, 0, 8, 0, 9, 0, 10,
2886 + 0, 11, 0, 12, 0, 13, 0, 14, 0, 15,
2887 + 0, 16, 82, 61, 0, 17, 82, 61, 0, 18,
2888 + 82, 61, 0, 19, 82, 61, 0, 20, 82, 61,
2889 + 0, 21, 82, 61, 0, 22, 82, 61, 0, 23,
2890 + 82, 61, 0, 24, 82, 61, 0, 25, 82, 61,
2891 + 0, 26, 72, 0, 27, 72, 0, 28, 82, 61,
2892 + 0, 29, 82, 61, 0, 30, 82, 61, 0, 31,
2893 + 82, 61, 0, 32, 82, 61, 0, 33, 82, 61,
2894 + 0, 34, 72, 0, 35, 72, 0, 65, 72, 0,
2895 + 68, 72, 0, 69, 72, 0, 70, 72, 0, 0,
2896 + 36, 61, 87, 82, 61, 0, 0, 37, 61, 88,
2897 + 82, 61, 0, 38, 82, 61, 0, 39, 82, 61,
2898 + 0, 40, 82, 61, 0, 41, 82, 61, 0, 42,
2899 + 82, 61, 0, 43, 82, 61, 0, 44, 61, 0,
2900 + 45, 61, 0, 44, 61, 0, 51, 61, 0, 52,
2901 + 61, 0, 53, 0, 54, 0, 55, 0, 56, 0,
2902 + 57, 0, 58, 72, 61, 0, 59, 72, 61, 0,
2903 + 66, 72, 61, 0, 64, 72, 0, 67, 0, 50,
2904 + 72, 0
2905 +};
2906 +
2907 +#endif
2908 +
2909 +#if YYDEBUG
2910 +/* YYRLINE[YYN] -- source line where rule number YYN was defined. */
2911 +static const short yyrline[] =
2912 +{
2913 + 0, 176, 176, 185, 188, 191, 193, 194, 199, 219,
2914 + 221, 224, 226, 237, 239, 250, 262, 274, 279, 283,
2915 + 287, 293, 301, 306, 313, 318, 324, 332, 339, 346,
2916 + 353, 360, 367, 374, 381, 388, 395, 402, 409, 416,
2917 + 425, 434, 443, 452, 461, 470, 479, 488, 497, 506,
2918 + 515, 524, 533, 542, 551, 560, 569, 578, 587, 596,
2919 + 605, 613, 621, 629, 629, 642, 642, 655, 664, 673,
2920 + 682, 691, 700, 709, 718, 729, 739, 748, 757, 764,
2921 + 771, 778, 785, 792, 803, 814, 825, 834, 842
2922 +};
2923 +#endif
2924 +
2925 +
2926 +#if (YYDEBUG) || defined YYERROR_VERBOSE
2927 +
2928 +/* YYTNAME[TOKEN_NUM] -- String name of the token TOKEN_NUM. */
2929 +static const char *const yytname[] =
2930 +{
2931 + "$", "error", "$undefined.", "MATCHER_ALL", "MATCHER_UNREAD",
2932 + "MATCHER_NOT_UNREAD", "MATCHER_NEW", "MATCHER_NOT_NEW",
2933 + "MATCHER_MARKED", "MATCHER_NOT_MARKED", "MATCHER_DELETED",
2934 + "MATCHER_NOT_DELETED", "MATCHER_REPLIED", "MATCHER_NOT_REPLIED",
2935 + "MATCHER_FORWARDED", "MATCHER_NOT_FORWARDED", "MATCHER_SUBJECT",
2936 + "MATCHER_NOT_SUBJECT", "MATCHER_FROM", "MATCHER_NOT_FROM", "MATCHER_TO",
2937 + "MATCHER_NOT_TO", "MATCHER_CC", "MATCHER_NOT_CC", "MATCHER_TO_OR_CC",
2938 + "MATCHER_NOT_TO_AND_NOT_CC", "MATCHER_AGE_GREATER", "MATCHER_AGE_LOWER",
2939 + "MATCHER_NEWSGROUPS", "MATCHER_NOT_NEWSGROUPS", "MATCHER_INREPLYTO",
2940 + "MATCHER_NOT_INREPLYTO", "MATCHER_REFERENCES", "MATCHER_NOT_REFERENCES",
2941 + "MATCHER_SCORE_GREATER", "MATCHER_SCORE_LOWER", "MATCHER_HEADER",
2942 + "MATCHER_NOT_HEADER", "MATCHER_HEADERS_PART",
2943 + "MATCHER_NOT_HEADERS_PART", "MATCHER_MESSAGE", "MATCHER_NOT_MESSAGE",
2944 + "MATCHER_BODY_PART", "MATCHER_NOT_BODY_PART", "MATCHER_EXECUTE",
2945 + "MATCHER_NOT_EXECUTE", "MATCHER_MATCHCASE", "MATCHER_MATCH",
2946 + "MATCHER_REGEXPCASE", "MATCHER_REGEXP", "MATCHER_SCORE", "MATCHER_MOVE",
2947 + "MATCHER_COPY", "MATCHER_DELETE", "MATCHER_MARK", "MATCHER_UNMARK",
2948 + "MATCHER_MARK_AS_READ", "MATCHER_MARK_AS_UNREAD", "MATCHER_FORWARD",
2949 + "MATCHER_FORWARD_AS_ATTACHMENT", "MATCHER_EOL", "MATCHER_STRING",
2950 + "MATCHER_OR", "MATCHER_AND", "MATCHER_COLOR", "MATCHER_SCORE_EQUAL",
2951 + "MATCHER_BOUNCE", "MATCHER_DELETE_ON_SERVER", "MATCHER_SIZE_GREATER",
2952 + "MATCHER_SIZE_SMALLER", "MATCHER_SIZE_EQUAL", "MATCHER_SECTION",
2953 + "MATCHER_INTEGER", "file", "@1", "file_line_list", "file_line",
2954 + "section_notification", "instruction", "end_instr_opt", "end_action",
2955 + "filtering_or_scoring", "match_type", "condition", "condition_list",
2956 + "bool_op", "one_condition", "@2", "@3", "filtering_action",
2957 + "scoring_rule", NULL
2958 +};
2959 +#endif
2960 +
2961 +/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
2962 +static const short yyr1[] =
2963 +{
2964 + 0, 74, 73, 75, 75, 76, 76, 76, 77, 78,
2965 + 78, 79, 79, 80, 80, 81, 81, 82, 82, 82,
2966 + 82, 83, 84, 84, 85, 85, 86, 86, 86, 86,
2967 + 86, 86, 86, 86, 86, 86, 86, 86, 86, 86,
2968 + 86, 86, 86, 86, 86, 86, 86, 86, 86, 86,
2969 + 86, 86, 86, 86, 86, 86, 86, 86, 86, 86,
2970 + 86, 86, 86, 87, 86, 88, 86, 86, 86, 86,
2971 + 86, 86, 86, 86, 86, 89, 89, 89, 89, 89,
2972 + 89, 89, 89, 89, 89, 89, 89, 89, 90
2973 +};
2974 +
2975 +/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
2976 +static const short yyr2[] =
2977 +{
2978 + 0, 0, 2, 2, 1, 1, 1, 2, 2, 2,
2979 + 1, 2, 0, 1, 0, 1, 1, 1, 1, 1,
2980 + 1, 1, 3, 1, 1, 1, 1, 1, 1, 1,
2981 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 3,
2982 + 3, 3, 3, 3, 3, 3, 3, 3, 3, 2,
2983 + 2, 3, 3, 3, 3, 3, 3, 2, 2, 2,
2984 + 2, 2, 2, 0, 5, 0, 5, 3, 3, 3,
2985 + 3, 3, 3, 2, 2, 2, 2, 2, 1, 1,
2986 + 1, 1, 1, 3, 3, 3, 2, 1, 2
2987 +};
2988 +
2989 +/* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE
2990 + doesn't specify something else to do. Zero means the default is an
2991 + error. */
2992 +static const short yydefact[] =
2993 +{
2994 + 1, 0, 0, 26, 27, 28, 29, 30, 31, 32,
2995 + 33, 34, 35, 36, 37, 38, 0, 0, 0, 0,
2996 + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2997 + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2998 + 0, 0, 0, 0, 0, 0, 10, 0, 0, 0,
2999 + 0, 0, 2, 0, 5, 6, 12, 21, 23, 7,
3000 + 17, 18, 19, 20, 0, 0, 0, 0, 0, 0,
3001 + 0, 0, 0, 0, 49, 50, 0, 0, 0, 0,
3002 + 0, 0, 57, 58, 63, 65, 0, 0, 0, 0,
3003 + 0, 0, 73, 74, 59, 60, 61, 62, 8, 3,
3004 + 0, 0, 0, 0, 78, 79, 80, 81, 82, 0,
3005 + 0, 0, 0, 87, 9, 14, 15, 16, 25, 24,
3006 + 0, 39, 40, 41, 42, 43, 44, 45, 46, 47,
3007 + 48, 51, 52, 53, 54, 55, 56, 0, 0, 67,
3008 + 68, 69, 70, 71, 72, 75, 88, 76, 77, 0,
3009 + 0, 86, 0, 13, 11, 22, 0, 0, 83, 84,
3010 + 85, 64, 66, 0, 0, 0
3011 +};
3012 +
3013 +static const short yydefgoto[] =
3014 +{
3015 + 163, 1, 52, 53, 54, 55, 114, 154, 115, 64,
3016 + 56, 57, 120, 58, 137, 138, 116, 117
3017 +};
3018 +
3019 +static const short yypact[] =
3020 +{
3021 + -32768, 121, -31,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
3022 + -32768,-32768,-32768,-32768,-32768,-32768, -29, -29, -29, -29,
3023 + -29, -29, -29, -29, -29, -29, 1, 2, -29, -29,
3024 + -29, -29, -29, -29, 3, 4, 16, 17, -29, -29,
3025 + -29, -29, -29, -29, 18, 19,-32768, 9, 10, 11,
3026 + 12, 25,-32768, 27,-32768,-32768, 49, -53,-32768,-32768,
3027 + -32768,-32768,-32768,-32768, 28, 29, 30, 33, 48, 50,
3028 + 51, 53, 56, 57,-32768,-32768, 58, 62, 106, 107,
3029 + 108, 109,-32768,-32768,-32768,-32768, 110, 111, 112, 113,
3030 + 114, 115,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
3031 + 116, 14, 117, 118,-32768,-32768,-32768,-32768,-32768, 38,
3032 + 164, 165, 166,-32768,-32768, 120,-32768,-32768,-32768,-32768,
3033 + 190,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
3034 + -32768,-32768,-32768,-32768,-32768,-32768,-32768, -29, -29,-32768,
3035 + -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, 122,
3036 + 123,-32768, 124,-32768,-32768,-32768, 126, 127,-32768,-32768,
3037 + -32768,-32768,-32768, 88, 182,-32768
3038 +};
3039 +
3040 +static const short yypgoto[] =
3041 +{
3042 + -32768,-32768, 186,-32768,-32768,-32768,-32768,-32768,-32768, -17,
3043 + -32768,-32768,-32768, 125,-32768,-32768,-32768,-32768
3044 +};
3045 +
3046 +
3047 +#define YYLAST 260
3048 +
3049 +
3050 +static const short yytable[] =
3051 +{
3052 + 65, 66, 67, 68, 69, 70, 71, 72, 73, 118,
3053 + 119, 76, 77, 78, 79, 80, 81, 60, 61, 62,
3054 + 63, 86, 87, 88, 89, 90, 91, -4, 2, 59,
3055 + 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
3056 + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
3057 + 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
3058 + 33, 34, 35, 36, 37, 38, 39, 40, 41, 42,
3059 + 43, 44, 45, 74, 75, 82, 83, 84, 85, 92,
3060 + 93, 94, 95, 96, 97, 98, 146, 46, 164, 121,
3061 + 122, 123, 47, 100, 124, 48, 49, 50, 51, 101,
3062 + 102, 103, 104, 105, 106, 107, 108, 109, 110, 125,
3063 + 149, 126, 127, 111, 128, 112, 113, 129, 130, 131,
3064 + 156, 157, 2, 132, 3, 4, 5, 6, 7, 8,
3065 + 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
3066 + 19, 20, 21, 22, 23, 24, 25, 26, 27, 28,
3067 + 29, 30, 31, 32, 33, 34, 35, 36, 37, 38,
3068 + 39, 40, 41, 42, 43, 44, 45, 133, 134, 135,
3069 + 136, 139, 140, 141, 142, 143, 144, 145, 147, 148,
3070 + 153, 46, 165, 158, 159, 160, 47, 161, 162, 48,
3071 + 49, 50, 51, 3, 4, 5, 6, 7, 8, 9,
3072 + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
3073 + 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
3074 + 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
3075 + 40, 41, 42, 43, 44, 45, 150, 151, 152, 99,
3076 + 0, 0, 0, 0, 0, 155, 0, 0, 0, 0,
3077 + 0, 0, 0, 0, 0, 47, 0, 0, 48, 49,
3078 + 50
3079 +};
3080 +
3081 +static const short yycheck[] =
3082 +{
3083 + 17, 18, 19, 20, 21, 22, 23, 24, 25, 62,
3084 + 63, 28, 29, 30, 31, 32, 33, 46, 47, 48,
3085 + 49, 38, 39, 40, 41, 42, 43, 0, 1, 60,
3086 + 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
3087 + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
3088 + 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
3089 + 33, 34, 35, 36, 37, 38, 39, 40, 41, 42,
3090 + 43, 44, 45, 72, 72, 72, 72, 61, 61, 61,
3091 + 61, 72, 72, 72, 72, 60, 72, 60, 0, 61,
3092 + 61, 61, 65, 44, 61, 68, 69, 70, 71, 50,
3093 + 51, 52, 53, 54, 55, 56, 57, 58, 59, 61,
3094 + 72, 61, 61, 64, 61, 66, 67, 61, 61, 61,
3095 + 137, 138, 1, 61, 3, 4, 5, 6, 7, 8,
3096 + 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
3097 + 19, 20, 21, 22, 23, 24, 25, 26, 27, 28,
3098 + 29, 30, 31, 32, 33, 34, 35, 36, 37, 38,
3099 + 39, 40, 41, 42, 43, 44, 45, 61, 61, 61,
3100 + 61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
3101 + 60, 60, 0, 61, 61, 61, 65, 61, 61, 68,
3102 + 69, 70, 71, 3, 4, 5, 6, 7, 8, 9,
3103 + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
3104 + 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
3105 + 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
3106 + 40, 41, 42, 43, 44, 45, 72, 72, 72, 53,
3107 + -1, -1, -1, -1, -1, 120, -1, -1, -1, -1,
3108 + -1, -1, -1, -1, -1, 65, -1, -1, 68, 69,
3109 + 70
3110 +};
3111 +/* -*-C-*- Note some compilers choke on comments on `#line' lines. */
3112 +#line 3 "/usr/share/bison/bison.simple"
3113 +
3114 +/* Skeleton output parser for bison,
3115 + Copyright (C) 1984, 1989, 1990, 2000, 2001 Free Software Foundation, Inc.
3116 +
3117 + This program is free software; you can redistribute it and/or modify
3118 + it under the terms of the GNU General Public License as published by
3119 + the Free Software Foundation; either version 2, or (at your option)
3120 + any later version.
3121 +
3122 + This program is distributed in the hope that it will be useful,
3123 + but WITHOUT ANY WARRANTY; without even the implied warranty of
3124 + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
3125 + GNU General Public License for more details.
3126 +
3127 + You should have received a copy of the GNU General Public License
3128 + along with this program; if not, write to the Free Software
3129 + Foundation, Inc., 59 Temple Place - Suite 330,
3130 + Boston, MA 02111-1307, USA. */
3131 +
3132 +/* As a special exception, when this file is copied by Bison into a
3133 + Bison output file, you may use that output file without restriction.
3134 + This special exception was added by the Free Software Foundation
3135 + in version 1.24 of Bison. */
3136 +
3137 +/* This is the parser code that is written into each bison parser when
3138 + the %semantic_parser declaration is not specified in the grammar.
3139 + It was written by Richard Stallman by simplifying the hairy parser
3140 + used when %semantic_parser is specified. */
3141 +
3142 +/* All symbols defined below should begin with yy or YY, to avoid
3143 + infringing on user name space. This should be done even for local
3144 + variables, as they might otherwise be expanded by user macros.
3145 + There are some unavoidable exceptions within include files to
3146 + define necessary library symbols; they are noted "INFRINGES ON
3147 + USER NAME SPACE" below. */
3148 +
3149 +#ifdef __cplusplus
3150 +# define YYSTD(x) std::x
3151 +#else
3152 +# define YYSTD(x) x
3153 +#endif
3154 +
3155 +#if ! defined (yyoverflow) || defined (YYERROR_VERBOSE)
3156 +
3157 +/* The parser invokes alloca or malloc; define the necessary symbols. */
3158 +
3159 +# if YYSTACK_USE_ALLOCA
3160 +# define YYSTACK_ALLOC alloca
3161 +# define YYSIZE_T YYSTD (size_t)
3162 +# else
3163 +# ifndef YYSTACK_USE_ALLOCA
3164 +# if defined (alloca) || defined (_ALLOCA_H)
3165 +# define YYSTACK_ALLOC alloca
3166 +# define YYSIZE_T YYSTD (size_t)
3167 +# else
3168 +# ifdef __GNUC__
3169 +# define YYSTACK_ALLOC __builtin_alloca
3170 +# endif
3171 +# endif
3172 +# endif
3173 +# endif
3174 +
3175 +# ifdef YYSTACK_ALLOC
3176 + /* Pacify GCC's `empty if-body' warning. */
3177 +# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
3178 +# else
3179 +# ifdef __cplusplus
3180 +# include <cstdlib> /* INFRINGES ON USER NAME SPACE */
3181 +# define YYSIZE_T std::size_t
3182 +# else
3183 +# ifdef __STDC__
3184 +# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
3185 +# define YYSIZE_T size_t
3186 +# endif
3187 +# endif
3188 +# define YYSTACK_ALLOC YYSTD (malloc)
3189 +# define YYSTACK_FREE YYSTD (free)
3190 +# endif
3191 +
3192 +/* A type that is properly aligned for any stack member. */
3193 +union yyalloc
3194 +{
3195 + short yyss;
3196 + YYSTYPE yyvs;
3197 +# if YYLSP_NEEDED
3198 + YYLTYPE yyls;
3199 +# endif
3200 +};
3201 +
3202 +/* The size of the maximum gap between one aligned stack and the next. */
3203 +# define YYSTACK_GAP_MAX (sizeof (union yyalloc) - 1)
3204 +
3205 +/* The size of an array large to enough to hold all stacks, each with
3206 + N elements. */
3207 +# if YYLSP_NEEDED
3208 +# define YYSTACK_BYTES(N) \
3209 + ((N) * (sizeof (short) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \
3210 + + 2 * YYSTACK_GAP_MAX)
3211 +# else
3212 +# define YYSTACK_BYTES(N) \
3213 + ((N) * (sizeof (short) + sizeof (YYSTYPE)) \
3214 + + YYSTACK_GAP_MAX)
3215 +# endif
3216 +
3217 +/* Relocate the TYPE STACK from its old location to the new one. The
3218 + local variables YYSIZE and YYSTACKSIZE give the old and new number of
3219 + elements in the stack, and YYPTR gives the new location of the
3220 + stack. Advance YYPTR to a properly aligned location for the next
3221 + stack. */
3222 +# define YYSTACK_RELOCATE(Type, Stack) \
3223 + do \
3224 + { \
3225 + YYSIZE_T yynewbytes; \
3226 + yymemcpy ((char *) yyptr, (char *) (Stack), \
3227 + yysize * (YYSIZE_T) sizeof (Type)); \
3228 + Stack = &yyptr->Stack; \
3229 + yynewbytes = yystacksize * sizeof (Type) + YYSTACK_GAP_MAX; \
3230 + yyptr += yynewbytes / sizeof (*yyptr); \
3231 + } \
3232 + while (0)
3233 +
3234 +#endif /* ! defined (yyoverflow) || defined (YYERROR_VERBOSE) */
3235 +
3236 +
3237 +#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
3238 +# define YYSIZE_T __SIZE_TYPE__
3239 +#endif
3240 +#if ! defined (YYSIZE_T) && defined (size_t)
3241 +# define YYSIZE_T size_t
3242 +#endif
3243 +#if ! defined (YYSIZE_T)
3244 +# ifdef __cplusplus
3245 +# include <cstddef> /* INFRINGES ON USER NAME SPACE */
3246 +# define YYSIZE_T std::size_t
3247 +# else
3248 +# ifdef __STDC__
3249 +# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
3250 +# define YYSIZE_T size_t
3251 +# endif
3252 +# endif
3253 +#endif
3254 +#if ! defined (YYSIZE_T)
3255 +# define YYSIZE_T unsigned int
3256 +#endif
3257 +
3258 +#define yyerrok (yyerrstatus = 0)
3259 +#define yyclearin (yychar = YYEMPTY)
3260 +#define YYEMPTY -2
3261 +#define YYEOF 0
3262 +#define YYACCEPT goto yyacceptlab
3263 +#define YYABORT goto yyabortlab
3264 +#define YYERROR goto yyerrlab1
3265 +/* Like YYERROR except do call yyerror. This remains here temporarily
3266 + to ease the transition to the new meaning of YYERROR, for GCC.
3267 + Once GCC version 2 has supplanted version 1, this can go. */
3268 +#define YYFAIL goto yyerrlab
3269 +#define YYRECOVERING() (!!yyerrstatus)
3270 +#define YYBACKUP(Token, Value) \
3271 +do \
3272 + if (yychar == YYEMPTY && yylen == 1) \
3273 + { \
3274 + yychar = (Token); \
3275 + yylval = (Value); \
3276 + yychar1 = YYTRANSLATE (yychar); \
3277 + YYPOPSTACK; \
3278 + goto yybackup; \
3279 + } \
3280 + else \
3281 + { \
3282 + yyerror ("syntax error: cannot back up"); \
3283 + YYERROR; \
3284 + } \
3285 +while (0)
3286 +
3287 +#define YYTERROR 1
3288 +#define YYERRCODE 256
3289 +
3290 +
3291 +/* YYLLOC_DEFAULT -- Compute the default location (before the actions
3292 + are run).
3293 +
3294 + When YYLLOC_DEFAULT is run, CURRENT is set the location of the
3295 + first token. By default, to implement support for ranges, extend
3296 + its range to the last symbol. */
3297 +
3298 +#ifndef YYLLOC_DEFAULT
3299 +# define YYLLOC_DEFAULT(Current, Rhs, N) \
3300 + Current.last_line = Rhs[N].last_line; \
3301 + Current.last_column = Rhs[N].last_column;
3302 +#endif
3303 +
3304 +
3305 +/* YYLEX -- calling `yylex' with the right arguments. */
3306 +
3307 +#if YYPURE
3308 +# if YYLSP_NEEDED
3309 +# ifdef YYLEX_PARAM
3310 +# define YYLEX yylex (&yylval, &yylloc, YYLEX_PARAM)
3311 +# else
3312 +# define YYLEX yylex (&yylval, &yylloc)
3313 +# endif
3314 +# else /* !YYLSP_NEEDED */
3315 +# ifdef YYLEX_PARAM
3316 +# define YYLEX yylex (&yylval, YYLEX_PARAM)
3317 +# else
3318 +# define YYLEX yylex (&yylval)
3319 +# endif
3320 +# endif /* !YYLSP_NEEDED */
3321 +#else /* !YYPURE */
3322 +# define YYLEX yylex ()
3323 +#endif /* !YYPURE */
3324 +
3325 +
3326 +/* Enable debugging if requested. */
3327 +#if YYDEBUG
3328 +
3329 +# ifndef YYFPRINTF
3330 +# ifdef __cplusplus
3331 +# include <cstdio> /* INFRINGES ON USER NAME SPACE */
3332 +# else
3333 +# include <stdio.h> /* INFRINGES ON USER NAME SPACE */
3334 +# endif
3335 +# define YYFPRINTF YYSTD (fprintf)
3336 +# endif
3337 +
3338 +# define YYDPRINTF(Args) \
3339 +do { \
3340 + if (yydebug) \
3341 + YYFPRINTF Args; \
3342 +} while (0)
3343 +/* Nonzero means print parse trace. [The following comment makes no
3344 + sense to me. Could someone clarify it? --akim] Since this is
3345 + uninitialized, it does not stop multiple parsers from coexisting.
3346 + */
3347 +int yydebug;
3348 +#else /* !YYDEBUG */
3349 +# define YYDPRINTF(Args)
3350 +#endif /* !YYDEBUG */
3351 +
3352 +/* YYINITDEPTH -- initial size of the parser's stacks. */
3353 +#ifndef YYINITDEPTH
3354 +# define YYINITDEPTH 200
3355 +#endif
3356 +
3357 +/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
3358 + if the built-in stack extension method is used).
3359 +
3360 + Do not make this value too large; the results are undefined if
3361 + SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
3362 + evaluated with infinite-precision integer arithmetic. */
3363 +
3364 +#if YYMAXDEPTH == 0
3365 +# undef YYMAXDEPTH
3366 +#endif
3367 +
3368 +#ifndef YYMAXDEPTH
3369 +# define YYMAXDEPTH 10000
3370 +#endif
3371 +\f
3372 +#if ! defined (yyoverflow) && ! defined (yymemcpy)
3373 +# if __GNUC__ > 1 /* GNU C and GNU C++ define this. */
3374 +# define yymemcpy __builtin_memcpy
3375 +# else /* not GNU C or C++ */
3376 +
3377 +/* This is the most reliable way to avoid incompatibilities
3378 + in available built-in functions on various systems. */
3379 +static void
3380 +# if defined (__STDC__) || defined (__cplusplus)
3381 +yymemcpy (char *yyto, const char *yyfrom, YYSIZE_T yycount)
3382 +# else
3383 +yymemcpy (yyto, yyfrom, yycount)
3384 + char *yyto;
3385 + const char *yyfrom;
3386 + YYSIZE_T yycount;
3387 +# endif
3388 +{
3389 + register const char *yyf = yyfrom;
3390 + register char *yyt = yyto;
3391 + register YYSIZE_T yyi = yycount;
3392 +
3393 + while (yyi-- != 0)
3394 + *yyt++ = *yyf++;
3395 +}
3396 +# endif
3397 +#endif
3398 +
3399 +#ifdef YYERROR_VERBOSE
3400 +
3401 +# ifndef yystrlen
3402 +# if defined (__GLIBC__) && defined (_STRING_H)
3403 +# define yystrlen strlen
3404 +# else
3405 +/* Return the length of YYSTR. */
3406 +static YYSIZE_T
3407 +# if defined (__STDC__) || defined (__cplusplus)
3408 +yystrlen (const char *yystr)
3409 +# else
3410 +yystrlen (yystr)
3411 + const char *yystr;
3412 +# endif
3413 +{
3414 + register const char *yys = yystr;
3415 +
3416 + while (*yys++ != '\0')
3417 + continue;
3418 +
3419 + return yys - yystr - 1;
3420 +}
3421 +# endif
3422 +# endif
3423 +
3424 +# ifndef yystpcpy
3425 +# if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
3426 +# define yystpcpy stpcpy
3427 +# else
3428 +/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
3429 + YYDEST. */
3430 +static char *
3431 +# if defined (__STDC__) || defined (__cplusplus)
3432 +yystpcpy (char *yydest, const char *yysrc)
3433 +# else
3434 +yystpcpy (yydest, yysrc)
3435 + char *yydest;
3436 + const char *yysrc;
3437 +# endif
3438 +{
3439 + register char *yyd = yydest;
3440 + register const char *yys = yysrc;
3441 +
3442 + while ((*yyd++ = *yys++) != '\0')
3443 + continue;
3444 +
3445 + return yyd - 1;
3446 +}
3447 +# endif
3448 +# endif
3449 +#endif
3450 +\f
3451 +#line 341 "/usr/share/bison/bison.simple"
3452 +
3453 +
3454 +/* The user can define YYPARSE_PARAM as the name of an argument to be passed
3455 + into yyparse. The argument should have type void *.
3456 + It should actually point to an object.
3457 + Grammar actions can access the variable by casting it
3458 + to the proper pointer type. */
3459 +
3460 +#ifdef YYPARSE_PARAM
3461 +# ifdef __cplusplus
3462 +# define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
3463 +# define YYPARSE_PARAM_DECL
3464 +# else /* !__cplusplus */
3465 +# define YYPARSE_PARAM_ARG YYPARSE_PARAM
3466 +# define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
3467 +# endif /* !__cplusplus */
3468 +#else /* !YYPARSE_PARAM */
3469 +# define YYPARSE_PARAM_ARG
3470 +# define YYPARSE_PARAM_DECL
3471 +#endif /* !YYPARSE_PARAM */
3472 +
3473 +/* Prevent warning if -Wstrict-prototypes. */
3474 +#ifdef __GNUC__
3475 +# ifdef YYPARSE_PARAM
3476 +int yyparse (void *);
3477 +# else
3478 +int yyparse (void);
3479 +# endif
3480 +#endif
3481 +
3482 +/* YY_DECL_VARIABLES -- depending whether we use a pure parser,
3483 + variables are global, or local to YYPARSE. */
3484 +
3485 +#define YY_DECL_NON_LSP_VARIABLES \
3486 +/* The lookahead symbol. */ \
3487 +int yychar; \
3488 + \
3489 +/* The semantic value of the lookahead symbol. */ \
3490 +YYSTYPE yylval; \
3491 + \
3492 +/* Number of parse errors so far. */ \
3493 +int yynerrs;
3494 +
3495 +#if YYLSP_NEEDED
3496 +# define YY_DECL_VARIABLES \
3497 +YY_DECL_NON_LSP_VARIABLES \
3498 + \
3499 +/* Location data for the lookahead symbol. */ \
3500 +YYLTYPE yylloc;
3501 +#else
3502 +# define YY_DECL_VARIABLES \
3503 +YY_DECL_NON_LSP_VARIABLES
3504 +#endif
3505 +
3506 +
3507 +/* If nonreentrant, generate the variables here. */
3508 +
3509 +#if !YYPURE
3510 +YY_DECL_VARIABLES
3511 +#endif /* !YYPURE */
3512 +
3513 +int
3514 +yyparse (YYPARSE_PARAM_ARG)
3515 + YYPARSE_PARAM_DECL
3516 +{
3517 + /* If reentrant, generate the variables here. */
3518 +#if YYPURE
3519 + YY_DECL_VARIABLES
3520 +#endif /* !YYPURE */
3521 +
3522 + register int yystate;
3523 + register int yyn;
3524 + int yyresult;
3525 + /* Number of tokens to shift before error messages enabled. */
3526 + int yyerrstatus;
3527 + /* Lookahead token as an internal (translated) token number. */
3528 + int yychar1 = 0;
3529 +
3530 + /* Three stacks and their tools:
3531 + `yyss': related to states,
3532 + `yyvs': related to semantic values,
3533 + `yyls': related to locations.
3534 +
3535 + Refer to the stacks thru separate pointers, to allow yyoverflow
3536 + to reallocate them elsewhere. */
3537 +
3538 + /* The state stack. */
3539 + short yyssa[YYINITDEPTH];
3540 + short *yyss = yyssa;
3541 + register short *yyssp;
3542 +
3543 + /* The semantic value stack. */
3544 + YYSTYPE yyvsa[YYINITDEPTH];
3545 + YYSTYPE *yyvs = yyvsa;
3546 + register YYSTYPE *yyvsp;
3547 +
3548 +#if YYLSP_NEEDED
3549 + /* The location stack. */
3550 + YYLTYPE yylsa[YYINITDEPTH];
3551 + YYLTYPE *yyls = yylsa;
3552 + YYLTYPE *yylsp;
3553 +#endif
3554 +
3555 +#if YYLSP_NEEDED
3556 +# define YYPOPSTACK (yyvsp--, yyssp--, yylsp--)
3557 +#else
3558 +# define YYPOPSTACK (yyvsp--, yyssp--)
3559 +#endif
3560 +
3561 + YYSIZE_T yystacksize = YYINITDEPTH;
3562 +
3563 +
3564 + /* The variables used to return semantic value and location from the
3565 + action routines. */
3566 + YYSTYPE yyval;
3567 +#if YYLSP_NEEDED
3568 + YYLTYPE yyloc;
3569 +#endif
3570 +
3571 + /* When reducing, the number of symbols on the RHS of the reduced
3572 + rule. */
3573 + int yylen;
3574 +
3575 + YYDPRINTF ((stderr, "Starting parse\n"));
3576 +
3577 + yystate = 0;
3578 + yyerrstatus = 0;
3579 + yynerrs = 0;
3580 + yychar = YYEMPTY; /* Cause a token to be read. */
3581 +
3582 + /* Initialize stack pointers.
3583 + Waste one element of value and location stack
3584 + so that they stay on the same level as the state stack.
3585 + The wasted elements are never initialized. */
3586 +
3587 + yyssp = yyss;
3588 + yyvsp = yyvs;
3589 +#if YYLSP_NEEDED
3590 + yylsp = yyls;
3591 +#endif
3592 + goto yysetstate;
3593 +
3594 +/*------------------------------------------------------------.
3595 +| yynewstate -- Push a new state, which is found in yystate. |
3596 +`------------------------------------------------------------*/
3597 + yynewstate:
3598 + /* In all cases, when you get here, the value and location stacks
3599 + have just been pushed. so pushing a state here evens the stacks.
3600 + */
3601 + yyssp++;
3602 +
3603 + yysetstate:
3604 + *yyssp = yystate;
3605 +
3606 + if (yyssp >= yyss + yystacksize - 1)
3607 + {
3608 + /* Get the current used size of the three stacks, in elements. */
3609 + YYSIZE_T yysize = yyssp - yyss + 1;
3610 +
3611 +#ifdef yyoverflow
3612 + {
3613 + /* Give user a chance to reallocate the stack. Use copies of
3614 + these so that the &'s don't force the real ones into
3615 + memory. */
3616 + YYSTYPE *yyvs1 = yyvs;
3617 + short *yyss1 = yyss;
3618 +
3619 + /* Each stack pointer address is followed by the size of the
3620 + data in use in that stack, in bytes. */
3621 +# if YYLSP_NEEDED
3622 + YYLTYPE *yyls1 = yyls;
3623 + /* This used to be a conditional around just the two extra args,
3624 + but that might be undefined if yyoverflow is a macro. */
3625 + yyoverflow ("parser stack overflow",
3626 + &yyss1, yysize * sizeof (*yyssp),
3627 + &yyvs1, yysize * sizeof (*yyvsp),
3628 + &yyls1, yysize * sizeof (*yylsp),
3629 + &yystacksize);
3630 + yyls = yyls1;
3631 +# else
3632 + yyoverflow ("parser stack overflow",
3633 + &yyss1, yysize * sizeof (*yyssp),
3634 + &yyvs1, yysize * sizeof (*yyvsp),
3635 + &yystacksize);
3636 +# endif
3637 + yyss = yyss1;
3638 + yyvs = yyvs1;
3639 + }
3640 +#else /* no yyoverflow */
3641 + /* Extend the stack our own way. */
3642 + if (yystacksize >= YYMAXDEPTH)
3643 + goto yyoverflowlab;
3644 + yystacksize *= 2;
3645 + if (yystacksize > YYMAXDEPTH)
3646 + yystacksize = YYMAXDEPTH;
3647 +
3648 + {
3649 + short *yyss1 = yyss;
3650 + union yyalloc *yyptr =
3651 + (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
3652 + if (! yyptr)
3653 + goto yyoverflowlab;
3654 + YYSTACK_RELOCATE (short, yyss);
3655 + YYSTACK_RELOCATE (YYSTYPE, yyvs);
3656 +# if YYLSP_NEEDED
3657 + YYSTACK_RELOCATE (YYLTYPE, yyls);
3658 +# endif
3659 +# undef YYSTACK_RELOCATE
3660 + if (yyss1 != yyssa)
3661 + YYSTACK_FREE (yyss1);
3662 + }
3663 +#endif /* no yyoverflow */
3664 +
3665 + yyssp = yyss + yysize - 1;
3666 + yyvsp = yyvs + yysize - 1;
3667 +#if YYLSP_NEEDED
3668 + yylsp = yyls + yysize - 1;
3669 +#endif
3670 +
3671 + YYDPRINTF ((stderr, "Stack size increased to %lu\n",
3672 + (unsigned long int) yystacksize));
3673 +
3674 + if (yyssp >= yyss + yystacksize - 1)
3675 + YYABORT;
3676 + }
3677 +
3678 + YYDPRINTF ((stderr, "Entering state %d\n", yystate));
3679 +
3680 + goto yybackup;
3681 +
3682 +
3683 +/*-----------.
3684 +| yybackup. |
3685 +`-----------*/
3686 +yybackup:
3687 +
3688 +/* Do appropriate processing given the current state. */
3689 +/* Read a lookahead token if we need one and don't already have one. */
3690 +/* yyresume: */
3691 +
3692 + /* First try to decide what to do without reference to lookahead token. */
3693 +
3694 + yyn = yypact[yystate];
3695 + if (yyn == YYFLAG)
3696 + goto yydefault;
3697 +
3698 + /* Not known => get a lookahead token if don't already have one. */
3699 +
3700 + /* yychar is either YYEMPTY or YYEOF
3701 + or a valid token in external form. */
3702 +
3703 + if (yychar == YYEMPTY)
3704 + {
3705 + YYDPRINTF ((stderr, "Reading a token: "));
3706 + yychar = YYLEX;
3707 + }
3708 +
3709 + /* Convert token to internal form (in yychar1) for indexing tables with */
3710 +
3711 + if (yychar <= 0) /* This means end of input. */
3712 + {
3713 + yychar1 = 0;
3714 + yychar = YYEOF; /* Don't call YYLEX any more */
3715 +
3716 + YYDPRINTF ((stderr, "Now at end of input.\n"));
3717 + }
3718 + else
3719 + {
3720 + yychar1 = YYTRANSLATE (yychar);
3721 +
3722 +#if YYDEBUG
3723 + /* We have to keep this `#if YYDEBUG', since we use variables
3724 + which are defined only if `YYDEBUG' is set. */
3725 + if (yydebug)
3726 + {
3727 + YYFPRINTF (stderr, "Next token is %d (%s",
3728 + yychar, yytname[yychar1]);
3729 + /* Give the individual parser a way to print the precise
3730 + meaning of a token, for further debugging info. */
3731 +# ifdef YYPRINT
3732 + YYPRINT (stderr, yychar, yylval);
3733 +# endif
3734 + YYFPRINTF (stderr, ")\n");
3735 + }
3736 +#endif
3737 + }
3738 +
3739 + yyn += yychar1;
3740 + if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
3741 + goto yydefault;
3742 +
3743 + yyn = yytable[yyn];
3744 +
3745 + /* yyn is what to do for this token type in this state.
3746 + Negative => reduce, -yyn is rule number.
3747 + Positive => shift, yyn is new state.
3748 + New state is final state => don't bother to shift,
3749 + just return success.
3750 + 0, or most negative number => error. */
3751 +
3752 + if (yyn < 0)
3753 + {
3754 + if (yyn == YYFLAG)
3755 + goto yyerrlab;
3756 + yyn = -yyn;
3757 + goto yyreduce;
3758 + }
3759 + else if (yyn == 0)
3760 + goto yyerrlab;
3761 +
3762 + if (yyn == YYFINAL)
3763 + YYACCEPT;
3764 +
3765 + /* Shift the lookahead token. */
3766 + YYDPRINTF ((stderr, "Shifting token %d (%s), ",
3767 + yychar, yytname[yychar1]));
3768 +
3769 + /* Discard the token being shifted unless it is eof. */
3770 + if (yychar != YYEOF)
3771 + yychar = YYEMPTY;
3772 +
3773 + *++yyvsp = yylval;
3774 +#if YYLSP_NEEDED
3775 + *++yylsp = yylloc;
3776 +#endif
3777 +
3778 + /* Count tokens shifted since error; after three, turn off error
3779 + status. */
3780 + if (yyerrstatus)
3781 + yyerrstatus--;
3782 +
3783 + yystate = yyn;
3784 + goto yynewstate;
3785 +
3786 +
3787 +/*-----------------------------------------------------------.
3788 +| yydefault -- do the default action for the current state. |
3789 +`-----------------------------------------------------------*/
3790 +yydefault:
3791 + yyn = yydefact[yystate];
3792 + if (yyn == 0)
3793 + goto yyerrlab;
3794 + goto yyreduce;
3795 +
3796 +
3797 +/*-----------------------------.
3798 +| yyreduce -- Do a reduction. |
3799 +`-----------------------------*/
3800 +yyreduce:
3801 + /* yyn is the number of a rule to reduce with. */
3802 + yylen = yyr2[yyn];
3803 +
3804 + /* If YYLEN is nonzero, implement the default value of the action:
3805 + `$$ = $1'.
3806 +
3807 + Otherwise, the following line sets YYVAL to the semantic value of
3808 + the lookahead token. This behavior is undocumented and Bison
3809 + users should not rely upon it. Assigning to YYVAL
3810 + unconditionally makes the parser a bit smaller, and it avoids a
3811 + GCC warning that YYVAL may be used uninitialized. */
3812 + yyval = yyvsp[1-yylen];
3813 +
3814 +#if YYLSP_NEEDED
3815 + /* Similarly for the default location. Let the user run additional
3816 + commands if for instance locations are ranges. */
3817 + yyloc = yylsp[1-yylen];
3818 + YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
3819 +#endif
3820 +
3821 +#if YYDEBUG
3822 + /* We have to keep this `#if YYDEBUG', since we use variables which
3823 + are defined only if `YYDEBUG' is set. */
3824 + if (yydebug)
3825 + {
3826 + int yyi;
3827 +
3828 + YYFPRINTF (stderr, "Reducing via rule %d (line %d), ",
3829 + yyn, yyrline[yyn]);
3830 +
3831 + /* Print the symbols being reduced, and their result. */
3832 + for (yyi = yyprhs[yyn]; yyrhs[yyi] > 0; yyi++)
3833 + YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
3834 + YYFPRINTF (stderr, " -> %s\n", yytname[yyr1[yyn]]);
3835 + }
3836 +#endif
3837 +
3838 + switch (yyn) {
3839 +
3840 +case 1:
3841 +#line 177 "matcher_parser_parse.y"
3842 +{
3843 + if (!matcher_parser_dialog) {
3844 + prefs_scoring = &global_scoring;
3845 + prefs_filtering = &global_processing;
3846 + }
3847 +}
3848 + break;
3849 +case 7:
3850 +#line 195 "matcher_parser_parse.y"
3851 +{
3852 + yyerrok;
3853 +}
3854 + break;
3855 +case 8:
3856 +#line 201 "matcher_parser_parse.y"
3857 +{
3858 + gchar * folder = yyvsp[-1].str;
3859 + FolderItem * item = NULL;
3860 +
3861 + if (!matcher_parser_dialog) {
3862 + item = folder_find_item_from_identifier(folder);
3863 + if (item == NULL) {
3864 + prefs_scoring = &global_scoring;
3865 + prefs_filtering = &global_processing;
3866 + }
3867 + else {
3868 + prefs_scoring = &item->prefs->scoring;
3869 + prefs_filtering = &item->prefs->processing;
3870 + }
3871 + }
3872 +}
3873 + break;
3874 +case 12:
3875 +#line 227 "matcher_parser_parse.y"
3876 +{
3877 + if (matcher_parser_dialog)
3878 + YYACCEPT;
3879 + else {
3880 + matcher_parsererror("parse error");
3881 + YYERROR;
3882 + }
3883 +}
3884 + break;
3885 +case 14:
3886 +#line 240 "matcher_parser_parse.y"
3887 +{
3888 + if (matcher_parser_dialog)
3889 + YYACCEPT;
3890 + else {
3891 + matcher_parsererror("parse error");
3892 + YYERROR;
3893 + }
3894 +}
3895 + break;
3896 +case 15:
3897 +#line 252 "matcher_parser_parse.y"
3898 +{
3899 + filtering = filteringprop_new(cond, action);
3900 + cond = NULL;
3901 + action = NULL;
3902 + if (!matcher_parser_dialog) {
3903 + * prefs_filtering = g_slist_append(* prefs_filtering,
3904 + filtering);
3905 + filtering = NULL;
3906 + }
3907 +}
3908 + break;
3909 +case 16:
3910 +#line 263 "matcher_parser_parse.y"
3911 +{
3912 + scoring = scoringprop_new(cond, score);
3913 + cond = NULL;
3914 + score = 0;
3915 + if (!matcher_parser_dialog) {
3916 + * prefs_scoring = g_slist_append(* prefs_scoring, scoring);
3917 + scoring = NULL;
3918 + }
3919 +}
3920 + break;
3921 +case 17:
3922 +#line 276 "matcher_parser_parse.y"
3923 +{
3924 + match_type = MATCHTYPE_MATCHCASE;
3925 +}
3926 + break;
3927 +case 18:
3928 +#line 280 "matcher_parser_parse.y"
3929 +{
3930 + match_type = MATCHTYPE_MATCH;
3931 +}
3932 + break;
3933 +case 19:
3934 +#line 284 "matcher_parser_parse.y"
3935 +{
3936 + match_type = MATCHTYPE_REGEXPCASE;
3937 +}
3938 + break;
3939 +case 20:
3940 +#line 288 "matcher_parser_parse.y"
3941 +{
3942 + match_type = MATCHTYPE_REGEXP;
3943 +}
3944 + break;
3945 +case 21:
3946 +#line 295 "matcher_parser_parse.y"
3947 +{
3948 + cond = matcherlist_new(matchers_list, (bool_op == MATCHERBOOL_AND));
3949 + matchers_list = NULL;
3950 +}
3951 + break;
3952 +case 22:
3953 +#line 303 "matcher_parser_parse.y"
3954 +{
3955 + matchers_list = g_slist_append(matchers_list, prop);
3956 +}
3957 + break;
3958 +case 23:
3959 +#line 307 "matcher_parser_parse.y"
3960 +{
3961 + matchers_list = NULL;
3962 + matchers_list = g_slist_append(matchers_list, prop);
3963 +}
3964 + break;
3965 +case 24:
3966 +#line 315 "matcher_parser_parse.y"
3967 +{
3968 + bool_op = MATCHERBOOL_AND;
3969 +}
3970 + break;
3971 +case 25:
3972 +#line 319 "matcher_parser_parse.y"
3973 +{
3974 + bool_op = MATCHERBOOL_OR;
3975 +}
3976 + break;
3977 +case 26:
3978 +#line 326 "matcher_parser_parse.y"
3979 +{
3980 + gint criteria = 0;
3981 +
3982 + criteria = MATCHCRITERIA_ALL;
3983 + prop = matcherprop_new(criteria, NULL, 0, NULL, 0);
3984 +}
3985 + break;
3986 +case 27:
3987 +#line 333 "matcher_parser_parse.y"
3988 +{
3989 + gint criteria = 0;
3990 +
3991 + criteria = MATCHCRITERIA_UNREAD;
3992 + prop = matcherprop_new(criteria, NULL, 0, NULL, 0);
3993 +}
3994 + break;
3995 +case 28:
3996 +#line 340 "matcher_parser_parse.y"
3997 +{
3998 + gint criteria = 0;
3999 +
4000 + criteria = MATCHCRITERIA_NOT_UNREAD;
4001 + prop = matcherprop_new(criteria, NULL, 0, NULL, 0);
4002 +}
4003 + break;
4004 +case 29:
4005 +#line 347 "matcher_parser_parse.y"
4006 +{
4007 + gint criteria = 0;
4008 +
4009 + criteria = MATCHCRITERIA_NEW;
4010 + prop = matcherprop_new(criteria, NULL, 0, NULL, 0);
4011 +}
4012 + break;
4013 +case 30:
4014 +#line 354 "matcher_parser_parse.y"
4015 +{
4016 + gint criteria = 0;
4017 +
4018 + criteria = MATCHCRITERIA_NOT_NEW;
4019 + prop = matcherprop_new(criteria, NULL, 0, NULL, 0);
4020 +}
4021 + break;
4022 +case 31:
4023 +#line 361 "matcher_parser_parse.y"
4024 +{
4025 + gint criteria = 0;
4026 +
4027 + criteria = MATCHCRITERIA_MARKED;
4028 + prop = matcherprop_new(criteria, NULL, 0, NULL, 0);
4029 +}
4030 + break;
4031 +case 32:
4032 +#line 368 "matcher_parser_parse.y"
4033 +{
4034 + gint criteria = 0;
4035 +
4036 + criteria = MATCHCRITERIA_NOT_MARKED;
4037 + prop = matcherprop_new(criteria, NULL, 0, NULL, 0);
4038 +}
4039 + break;
4040 +case 33:
4041 +#line 375 "matcher_parser_parse.y"
4042 +{
4043 + gint criteria = 0;
4044 +
4045 + criteria = MATCHCRITERIA_DELETED;
4046 + prop = matcherprop_new(criteria, NULL, 0, NULL, 0);
4047 +}
4048 + break;
4049 +case 34:
4050 +#line 382 "matcher_parser_parse.y"
4051 +{
4052 + gint criteria = 0;
4053 +
4054 + criteria = MATCHCRITERIA_NOT_DELETED;
4055 + prop = matcherprop_new(criteria, NULL, 0, NULL, 0);
4056 +}
4057 + break;
4058 +case 35:
4059 +#line 389 "matcher_parser_parse.y"
4060 +{
4061 + gint criteria = 0;
4062 +
4063 + criteria = MATCHCRITERIA_REPLIED;
4064 + prop = matcherprop_new(criteria, NULL, 0, NULL, 0);
4065 +}
4066 + break;
4067 +case 36:
4068 +#line 396 "matcher_parser_parse.y"
4069 +{
4070 + gint criteria = 0;
4071 +
4072 + criteria = MATCHCRITERIA_NOT_REPLIED;
4073 + prop = matcherprop_new(criteria, NULL, 0, NULL, 0);
4074 +}
4075 + break;
4076 +case 37:
4077 +#line 403 "matcher_parser_parse.y"
4078 +{
4079 + gint criteria = 0;
4080 +
4081 + criteria = MATCHCRITERIA_FORWARDED;
4082 + prop = matcherprop_new(criteria, NULL, 0, NULL, 0);
4083 +}
4084 + break;
4085 +case 38:
4086 +#line 410 "matcher_parser_parse.y"
4087 +{
4088 + gint criteria = 0;
4089 +
4090 + criteria = MATCHCRITERIA_NOT_FORWARDED;
4091 + prop = matcherprop_new(criteria, NULL, 0, NULL, 0);
4092 +}
4093 + break;
4094 +case 39:
4095 +#line 417 "matcher_parser_parse.y"
4096 +{
4097 + gint criteria = 0;
4098 + gchar * expr = NULL;
4099 +
4100 + criteria = MATCHCRITERIA_SUBJECT;
4101 + expr = yyvsp[0].str;
4102 + prop = matcherprop_new(criteria, NULL, match_type, expr, 0);
4103 +}
4104 + break;
4105 +case 40:
4106 +#line 426 "matcher_parser_parse.y"
4107 +{
4108 + gint criteria = 0;
4109 + gchar * expr = NULL;
4110 +
4111 + criteria = MATCHCRITERIA_NOT_SUBJECT;
4112 + expr = yyvsp[0].str;
4113 + prop = matcherprop_new(criteria, NULL, match_type, expr, 0);
4114 +}
4115 + break;
4116 +case 41:
4117 +#line 435 "matcher_parser_parse.y"
4118 +{
4119 + gint criteria = 0;
4120 + gchar * expr = NULL;
4121 +
4122 + criteria = MATCHCRITERIA_FROM;
4123 + expr = yyvsp[0].str;
4124 + prop = matcherprop_new(criteria, NULL, match_type, expr, 0);
4125 +}
4126 + break;
4127 +case 42:
4128 +#line 444 "matcher_parser_parse.y"
4129 +{
4130 + gint criteria = 0;
4131 + gchar * expr = NULL;
4132 +
4133 + criteria = MATCHCRITERIA_NOT_FROM;
4134 + expr = yyvsp[0].str;
4135 + prop = matcherprop_new(criteria, NULL, match_type, expr, 0);
4136 +}
4137 + break;
4138 +case 43:
4139 +#line 453 "matcher_parser_parse.y"
4140 +{
4141 + gint criteria = 0;
4142 + gchar * expr = NULL;
4143 +
4144 + criteria = MATCHCRITERIA_TO;
4145 + expr = yyvsp[0].str;
4146 + prop = matcherprop_new(criteria, NULL, match_type, expr, 0);
4147 +}
4148 + break;
4149 +case 44:
4150 +#line 462 "matcher_parser_parse.y"
4151 +{
4152 + gint criteria = 0;
4153 + gchar * expr = NULL;
4154 +
4155 + criteria = MATCHCRITERIA_NOT_TO;
4156 + expr = yyvsp[0].str;
4157 + prop = matcherprop_new(criteria, NULL, match_type, expr, 0);
4158 +}
4159 + break;
4160 +case 45:
4161 +#line 471 "matcher_parser_parse.y"
4162 +{
4163 + gint criteria = 0;
4164 + gchar * expr = NULL;
4165 +
4166 + criteria = MATCHCRITERIA_CC;
4167 + expr = yyvsp[0].str;
4168 + prop = matcherprop_new(criteria, NULL, match_type, expr, 0);
4169 +}
4170 + break;
4171 +case 46:
4172 +#line 480 "matcher_parser_parse.y"
4173 +{
4174 + gint criteria = 0;
4175 + gchar * expr = NULL;
4176 +
4177 + criteria = MATCHCRITERIA_NOT_CC;
4178 + expr = yyvsp[0].str;
4179 + prop = matcherprop_new(criteria, NULL, match_type, expr, 0);
4180 +}
4181 + break;
4182 +case 47:
4183 +#line 489 "matcher_parser_parse.y"
4184 +{
4185 + gint criteria = 0;
4186 + gchar * expr = NULL;
4187 +
4188 + criteria = MATCHCRITERIA_TO_OR_CC;
4189 + expr = yyvsp[0].str;
4190 + prop = matcherprop_new(criteria, NULL, match_type, expr, 0);
4191 +}
4192 + break;
4193 +case 48:
4194 +#line 498 "matcher_parser_parse.y"
4195 +{
4196 + gint criteria = 0;
4197 + gchar * expr = NULL;
4198 +
4199 + criteria = MATCHCRITERIA_NOT_TO_AND_NOT_CC;
4200 + expr = yyvsp[0].str;
4201 + prop = matcherprop_new(criteria, NULL, match_type, expr, 0);
4202 +}
4203 + break;
4204 +case 49:
4205 +#line 507 "matcher_parser_parse.y"
4206 +{
4207 + gint criteria = 0;
4208 + gint value = 0;
4209 +
4210 + criteria = MATCHCRITERIA_AGE_GREATER;
4211 + value = atoi(yyvsp[0].value);
4212 + prop = matcherprop_new(criteria, NULL, 0, NULL, value);
4213 +}
4214 + break;
4215 +case 50:
4216 +#line 516 "matcher_parser_parse.y"
4217 +{
4218 + gint criteria = 0;
4219 + gint value = 0;
4220 +
4221 + criteria = MATCHCRITERIA_AGE_LOWER;
4222 + value = atoi(yyvsp[0].value);
4223 + prop = matcherprop_new(criteria, NULL, 0, NULL, value);
4224 +}
4225 + break;
4226 +case 51:
4227 +#line 525 "matcher_parser_parse.y"
4228 +{
4229 + gint criteria = 0;
4230 + gchar * expr = NULL;
4231 +
4232 + criteria = MATCHCRITERIA_NEWSGROUPS;
4233 + expr = yyvsp[0].str;
4234 + prop = matcherprop_new(criteria, NULL, match_type, expr, 0);
4235 +}
4236 + break;
4237 +case 52:
4238 +#line 534 "matcher_parser_parse.y"
4239 +{
4240 + gint criteria = 0;
4241 + gchar * expr = NULL;
4242 +
4243 + criteria = MATCHCRITERIA_NOT_NEWSGROUPS;
4244 + expr = yyvsp[0].str;
4245 + prop = matcherprop_new(criteria, NULL, match_type, expr, 0);
4246 +}
4247 + break;
4248 +case 53:
4249 +#line 543 "matcher_parser_parse.y"
4250 +{
4251 + gint criteria = 0;
4252 + gchar * expr = NULL;
4253 +
4254 + criteria = MATCHCRITERIA_INREPLYTO;
4255 + expr = yyvsp[0].str;
4256 + prop = matcherprop_new(criteria, NULL, match_type, expr, 0);
4257 +}
4258 + break;
4259 +case 54:
4260 +#line 552 "matcher_parser_parse.y"
4261 +{
4262 + gint criteria = 0;
4263 + gchar * expr = NULL;
4264 +
4265 + criteria = MATCHCRITERIA_NOT_INREPLYTO;
4266 + expr = yyvsp[0].str;
4267 + prop = matcherprop_new(criteria, NULL, match_type, expr, 0);
4268 +}
4269 + break;
4270 +case 55:
4271 +#line 561 "matcher_parser_parse.y"
4272 +{
4273 + gint criteria = 0;
4274 + gchar * expr = NULL;
4275 +
4276 + criteria = MATCHCRITERIA_REFERENCES;
4277 + expr = yyvsp[0].str;
4278 + prop = matcherprop_new(criteria, NULL, match_type, expr, 0);
4279 +}
4280 + break;
4281 +case 56:
4282 +#line 570 "matcher_parser_parse.y"
4283 +{
4284 + gint criteria = 0;
4285 + gchar * expr = NULL;
4286 +
4287 + criteria = MATCHCRITERIA_NOT_REFERENCES;
4288 + expr = yyvsp[0].str;
4289 + prop = matcherprop_new(criteria, NULL, match_type, expr, 0);
4290 +}
4291 + break;
4292 +case 57:
4293 +#line 579 "matcher_parser_parse.y"
4294 +{
4295 + gint criteria = 0;
4296 + gint value = 0;
4297 +
4298 + criteria = MATCHCRITERIA_SCORE_GREATER;
4299 + value = atoi(yyvsp[0].value);
4300 + prop = matcherprop_new(criteria, NULL, 0, NULL, value);
4301 +}
4302 + break;
4303 +case 58:
4304 +#line 588 "matcher_parser_parse.y"
4305 +{
4306 + gint criteria = 0;
4307 + gint value = 0;
4308 +
4309 + criteria = MATCHCRITERIA_SCORE_LOWER;
4310 + value = atoi(yyvsp[0].value);
4311 + prop = matcherprop_new(criteria, NULL, 0, NULL, value);
4312 +}
4313 + break;
4314 +case 59:
4315 +#line 597 "matcher_parser_parse.y"
4316 +{
4317 + gint criteria = 0;
4318 + gint value = 0;
4319 +
4320 + criteria = MATCHCRITERIA_SCORE_EQUAL;
4321 + value = atoi(yyvsp[0].value);
4322 + prop = matcherprop_new(criteria, NULL, 0, NULL, value);
4323 +}
4324 + break;
4325 +case 60:
4326 +#line 606 "matcher_parser_parse.y"
4327 +{
4328 + gint criteria = 0;
4329 + gint value = 0;
4330 + criteria = MATCHCRITERIA_SIZE_GREATER;
4331 + value = atoi(yyvsp[0].value);
4332 + prop = matcherprop_new(criteria, NULL, 0, NULL, value);
4333 +}
4334 + break;
4335 +case 61:
4336 +#line 614 "matcher_parser_parse.y"
4337 +{
4338 + gint criteria = 0;
4339 + gint value = 0;
4340 + criteria = MATCHCRITERIA_SIZE_SMALLER;
4341 + value = atoi(yyvsp[0].value);
4342 + prop = matcherprop_new(criteria, NULL, 0, NULL, value);
4343 +}
4344 + break;
4345 +case 62:
4346 +#line 622 "matcher_parser_parse.y"
4347 +{
4348 + gint criteria = 0;
4349 + gint value = 0;
4350 + criteria = MATCHCRITERIA_SIZE_EQUAL;
4351 + value = atoi(yyvsp[0].value);
4352 + prop = matcherprop_new(criteria, NULL, 0, NULL, value);
4353 +}
4354 + break;
4355 +case 63:
4356 +#line 630 "matcher_parser_parse.y"
4357 +{
4358 + header = g_strdup(yyvsp[0].str);
4359 +}
4360 + break;
4361 +case 64:
4362 +#line 633 "matcher_parser_parse.y"
4363 +{
4364 + gint criteria = 0;
4365 + gchar * expr = NULL;
4366 +
4367 + criteria = MATCHCRITERIA_HEADER;
4368 + expr = yyvsp[-3].str;
4369 + prop = matcherprop_new(criteria, header, match_type, expr, 0);
4370 + g_free(header);
4371 +}
4372 + break;
4373 +case 65:
4374 +#line 643 "matcher_parser_parse.y"
4375 +{
4376 + header = g_strdup(yyvsp[0].str);
4377 +}
4378 + break;
4379 +case 66:
4380 +#line 646 "matcher_parser_parse.y"
4381 +{
4382 + gint criteria = 0;
4383 + gchar * expr = NULL;
4384 +
4385 + criteria = MATCHCRITERIA_NOT_HEADER;
4386 + expr = yyvsp[-3].str;
4387 + prop = matcherprop_new(criteria, header, match_type, expr, 0);
4388 + g_free(header);
4389 +}
4390 + break;
4391 +case 67:
4392 +#line 656 "matcher_parser_parse.y"
4393 +{
4394 + gint criteria = 0;
4395 + gchar * expr = NULL;
4396 +
4397 + criteria = MATCHCRITERIA_HEADERS_PART;
4398 + expr = yyvsp[0].str;
4399 + prop = matcherprop_new(criteria, NULL, match_type, expr, 0);
4400 +}
4401 + break;
4402 +case 68:
4403 +#line 665 "matcher_parser_parse.y"
4404 +{
4405 + gint criteria = 0;
4406 + gchar * expr = NULL;
4407 +
4408 + criteria = MATCHCRITERIA_NOT_HEADERS_PART;
4409 + expr = yyvsp[0].str;
4410 + prop = matcherprop_new(criteria, NULL, match_type, expr, 0);
4411 +}
4412 + break;
4413 +case 69:
4414 +#line 674 "matcher_parser_parse.y"
4415 +{
4416 + gint criteria = 0;
4417 + gchar * expr = NULL;
4418 +
4419 + criteria = MATCHCRITERIA_MESSAGE;
4420 + expr = yyvsp[0].str;
4421 + prop = matcherprop_new(criteria, NULL, match_type, expr, 0);
4422 +}
4423 + break;
4424 +case 70:
4425 +#line 683 "matcher_parser_parse.y"
4426 +{
4427 + gint criteria = 0;
4428 + gchar * expr = NULL;
4429 +
4430 + criteria = MATCHCRITERIA_NOT_MESSAGE;
4431 + expr = yyvsp[0].str;
4432 + prop = matcherprop_new(criteria, NULL, match_type, expr, 0);
4433 +}
4434 + break;
4435 +case 71:
4436 +#line 692 "matcher_parser_parse.y"
4437 +{
4438 + gint criteria = 0;
4439 + gchar * expr = NULL;
4440 +
4441 + criteria = MATCHCRITERIA_BODY_PART;
4442 + expr = yyvsp[0].str;
4443 + prop = matcherprop_new(criteria, NULL, match_type, expr, 0);
4444 +}
4445 + break;
4446 +case 72:
4447 +#line 701 "matcher_parser_parse.y"
4448 +{
4449 + gint criteria = 0;
4450 + gchar * expr = NULL;
4451 +
4452 + criteria = MATCHCRITERIA_NOT_BODY_PART;
4453 + expr = yyvsp[0].str;
4454 + prop = matcherprop_new(criteria, NULL, match_type, expr, 0);
4455 +}
4456 + break;
4457 +case 73:
4458 +#line 710 "matcher_parser_parse.y"
4459 +{
4460 + gint criteria = 0;
4461 + gchar * expr = NULL;
4462 +
4463 + criteria = MATCHCRITERIA_EXECUTE;
4464 + expr = yyvsp[0].str;
4465 + prop = matcherprop_new(criteria, NULL, 0, expr, 0);
4466 +}
4467 + break;
4468 +case 74:
4469 +#line 719 "matcher_parser_parse.y"
4470 +{
4471 + gint criteria = 0;
4472 + gchar * expr = NULL;
4473 +
4474 + criteria = MATCHCRITERIA_NOT_EXECUTE;
4475 + expr = yyvsp[0].str;
4476 + prop = matcherprop_new(criteria, NULL, 0, expr, 0);
4477 +}
4478 + break;
4479 +case 75:
4480 +#line 731 "matcher_parser_parse.y"
4481 +{
4482 + gchar * cmd = NULL;
4483 + gint action_type = 0;
4484 +
4485 + action_type = MATCHACTION_EXECUTE;
4486 + cmd = yyvsp[0].str;
4487 + action = filteringaction_new(action_type, 0, cmd, 0);
4488 +}
4489 + break;
4490 +case 76:
4491 +#line 740 "matcher_parser_parse.y"
4492 +{
4493 + gchar * destination = NULL;
4494 + gint action_type = 0;
4495 +
4496 + action_type = MATCHACTION_MOVE;
4497 + destination = yyvsp[0].str;
4498 + action = filteringaction_new(action_type, 0, destination, 0);
4499 +}
4500 + break;
4501 +case 77:
4502 +#line 749 "matcher_parser_parse.y"
4503 +{
4504 + gchar * destination = NULL;
4505 + gint action_type = 0;
4506 +
4507 + action_type = MATCHACTION_COPY;
4508 + destination = yyvsp[0].str;
4509 + action = filteringaction_new(action_type, 0, destination, 0);
4510 +}
4511 + break;
4512 +case 78:
4513 +#line 758 "matcher_parser_parse.y"
4514 +{
4515 + gint action_type = 0;
4516 +
4517 + action_type = MATCHACTION_DELETE;
4518 + action = filteringaction_new(action_type, 0, NULL, 0);
4519 +}
4520 + break;
4521 +case 79:
4522 +#line 765 "matcher_parser_parse.y"
4523 +{
4524 + gint action_type = 0;
4525 +
4526 + action_type = MATCHACTION_MARK;
4527 + action = filteringaction_new(action_type, 0, NULL, 0);
4528 +}
4529 + break;
4530 +case 80:
4531 +#line 772 "matcher_parser_parse.y"
4532 +{
4533 + gint action_type = 0;
4534 +
4535 + action_type = MATCHACTION_UNMARK;
4536 + action = filteringaction_new(action_type, 0, NULL, 0);
4537 +}
4538 + break;
4539 +case 81:
4540 +#line 779 "matcher_parser_parse.y"
4541 +{
4542 + gint action_type = 0;
4543 +
4544 + action_type = MATCHACTION_MARK_AS_READ;
4545 + action = filteringaction_new(action_type, 0, NULL, 0);
4546 +}
4547 + break;
4548 +case 82:
4549 +#line 786 "matcher_parser_parse.y"
4550 +{
4551 + gint action_type = 0;
4552 +
4553 + action_type = MATCHACTION_MARK_AS_UNREAD;
4554 + action = filteringaction_new(action_type, 0, NULL, 0);
4555 +}
4556 + break;
4557 +case 83:
4558 +#line 793 "matcher_parser_parse.y"
4559 +{
4560 + gchar * destination = NULL;
4561 + gint action_type = 0;
4562 + gint account_id = 0;
4563 +
4564 + action_type = MATCHACTION_FORWARD;
4565 + account_id = atoi(yyvsp[-1].value);
4566 + destination = yyvsp[0].str;
4567 + action = filteringaction_new(action_type, account_id, destination, 0);
4568 +}
4569 + break;
4570 +case 84:
4571 +#line 804 "matcher_parser_parse.y"
4572 +{
4573 + gchar * destination = NULL;
4574 + gint action_type = 0;
4575 + gint account_id = 0;
4576 +
4577 + action_type = MATCHACTION_FORWARD_AS_ATTACHMENT;
4578 + account_id = atoi(yyvsp[-1].value);
4579 + destination = yyvsp[0].str;
4580 + action = filteringaction_new(action_type, account_id, destination, 0);
4581 +}
4582 + break;
4583 +case 85:
4584 +#line 815 "matcher_parser_parse.y"
4585 +{
4586 + gchar * destination = NULL;
4587 + gint action_type = 0;
4588 + gint account_id = 0;
4589 +
4590 + action_type = MATCHACTION_BOUNCE;
4591 + account_id = atoi(yyvsp[-1].value);
4592 + destination = yyvsp[0].str;
4593 + action = filteringaction_new(action_type, account_id, destination, 0);
4594 +}
4595 + break;
4596 +case 86:
4597 +#line 826 "matcher_parser_parse.y"
4598 +{
4599 + gint action_type = 0;
4600 + gint color = 0;
4601 +
4602 + action_type = MATCHACTION_COLOR;
4603 + color = atoi(yyvsp[0].value);
4604 + action = filteringaction_new(action_type, 0, NULL, color);
4605 +}
4606 + break;
4607 +case 87:
4608 +#line 835 "matcher_parser_parse.y"
4609 +{
4610 + gint action_type = 0;
4611 + action_type = MATCHACTION_DELETE_ON_SERVER;
4612 + action = filteringaction_new(action_type, 0, NULL, 0);
4613 +}
4614 + break;
4615 +case 88:
4616 +#line 844 "matcher_parser_parse.y"
4617 +{
4618 + score = atoi(yyvsp[0].value);
4619 +}
4620 + break;
4621 +}
4622 +
4623 +#line 727 "/usr/share/bison/bison.simple"
4624 +
4625 +\f
4626 + yyvsp -= yylen;
4627 + yyssp -= yylen;
4628 +#if YYLSP_NEEDED
4629 + yylsp -= yylen;
4630 +#endif
4631 +
4632 +#if YYDEBUG
4633 + if (yydebug)
4634 + {
4635 + short *yyssp1 = yyss - 1;
4636 + YYFPRINTF (stderr, "state stack now");
4637 + while (yyssp1 != yyssp)
4638 + YYFPRINTF (stderr, " %d", *++yyssp1);
4639 + YYFPRINTF (stderr, "\n");
4640 + }
4641 +#endif
4642 +
4643 + *++yyvsp = yyval;
4644 +#if YYLSP_NEEDED
4645 + *++yylsp = yyloc;
4646 +#endif
4647 +
4648 + /* Now `shift' the result of the reduction. Determine what state
4649 + that goes to, based on the state we popped back to and the rule
4650 + number reduced by. */
4651 +
4652 + yyn = yyr1[yyn];
4653 +
4654 + yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
4655 + if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
4656 + yystate = yytable[yystate];
4657 + else
4658 + yystate = yydefgoto[yyn - YYNTBASE];
4659 +
4660 + goto yynewstate;
4661 +
4662 +
4663 +/*------------------------------------.
4664 +| yyerrlab -- here on detecting error |
4665 +`------------------------------------*/
4666 +yyerrlab:
4667 + /* If not already recovering from an error, report this error. */
4668 + if (!yyerrstatus)
4669 + {
4670 + ++yynerrs;
4671 +
4672 +#ifdef YYERROR_VERBOSE
4673 + yyn = yypact[yystate];
4674 +
4675 + if (yyn > YYFLAG && yyn < YYLAST)
4676 + {
4677 + YYSIZE_T yysize = 0;
4678 + char *yymsg;
4679 + int yyx, yycount;
4680 +
4681 + yycount = 0;
4682 + /* Start YYX at -YYN if negative to avoid negative indexes in
4683 + YYCHECK. */
4684 + for (yyx = yyn < 0 ? -yyn : 0;
4685 + yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)
4686 + if (yycheck[yyx + yyn] == yyx)
4687 + yysize += yystrlen (yytname[yyx]) + 15, yycount++;
4688 + yysize += yystrlen ("parse error, unexpected ") + 1;
4689 + yysize += yystrlen (yytname[YYTRANSLATE (yychar)]);
4690 + yymsg = (char *) YYSTACK_ALLOC (yysize);
4691 + if (yymsg != 0)
4692 + {
4693 + char *yyp = yystpcpy (yymsg, "parse error, unexpected ");
4694 + yyp = yystpcpy (yyp, yytname[YYTRANSLATE (yychar)]);
4695 +
4696 + if (yycount < 5)
4697 + {
4698 + yycount = 0;
4699 + for (yyx = yyn < 0 ? -yyn : 0;
4700 + yyx < (int) (sizeof (yytname) / sizeof (char *));
4701 + yyx++)
4702 + if (yycheck[yyx + yyn] == yyx)
4703 + {
4704 + const char *yyq = ! yycount ? ", expecting " : " or ";
4705 + yyp = yystpcpy (yyp, yyq);
4706 + yyp = yystpcpy (yyp, yytname[yyx]);
4707 + yycount++;
4708 + }
4709 + }
4710 + yyerror (yymsg);
4711 + YYSTACK_FREE (yymsg);
4712 + }
4713 + else
4714 + yyerror ("parse error; also virtual memory exhausted");
4715 + }
4716 + else
4717 +#endif /* defined (YYERROR_VERBOSE) */
4718 + yyerror ("parse error");
4719 + }
4720 + goto yyerrlab1;
4721 +
4722 +
4723 +/*--------------------------------------------------.
4724 +| yyerrlab1 -- error raised explicitly by an action |
4725 +`--------------------------------------------------*/
4726 +yyerrlab1:
4727 + if (yyerrstatus == 3)
4728 + {
4729 + /* If just tried and failed to reuse lookahead token after an
4730 + error, discard it. */
4731 +
4732 + /* return failure if at end of input */
4733 + if (yychar == YYEOF)
4734 + YYABORT;
4735 + YYDPRINTF ((stderr, "Discarding token %d (%s).\n",
4736 + yychar, yytname[yychar1]));
4737 + yychar = YYEMPTY;
4738 + }
4739 +
4740 + /* Else will try to reuse lookahead token after shifting the error
4741 + token. */
4742 +
4743 + yyerrstatus = 3; /* Each real token shifted decrements this */
4744 +
4745 + goto yyerrhandle;
4746 +
4747 +
4748 +/*-------------------------------------------------------------------.
4749 +| yyerrdefault -- current state does not do anything special for the |
4750 +| error token. |
4751 +`-------------------------------------------------------------------*/
4752 +yyerrdefault:
4753 +#if 0
4754 + /* This is wrong; only states that explicitly want error tokens
4755 + should shift them. */
4756 +
4757 + /* If its default is to accept any token, ok. Otherwise pop it. */
4758 + yyn = yydefact[yystate];
4759 + if (yyn)
4760 + goto yydefault;
4761 +#endif
4762 +
4763 +
4764 +/*---------------------------------------------------------------.
4765 +| yyerrpop -- pop the current state because it cannot handle the |
4766 +| error token |
4767 +`---------------------------------------------------------------*/
4768 +yyerrpop:
4769 + if (yyssp == yyss)
4770 + YYABORT;
4771 + yyvsp--;
4772 + yystate = *--yyssp;
4773 +#if YYLSP_NEEDED
4774 + yylsp--;
4775 +#endif
4776 +
4777 +#if YYDEBUG
4778 + if (yydebug)
4779 + {
4780 + short *yyssp1 = yyss - 1;
4781 + YYFPRINTF (stderr, "Error: state stack now");
4782 + while (yyssp1 != yyssp)
4783 + YYFPRINTF (stderr, " %d", *++yyssp1);
4784 + YYFPRINTF (stderr, "\n");
4785 + }
4786 +#endif
4787 +
4788 +/*--------------.
4789 +| yyerrhandle. |
4790 +`--------------*/
4791 +yyerrhandle:
4792 + yyn = yypact[yystate];
4793 + if (yyn == YYFLAG)
4794 + goto yyerrdefault;
4795 +
4796 + yyn += YYTERROR;
4797 + if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
4798 + goto yyerrdefault;
4799 +
4800 + yyn = yytable[yyn];
4801 + if (yyn < 0)
4802 + {
4803 + if (yyn == YYFLAG)
4804 + goto yyerrpop;
4805 + yyn = -yyn;
4806 + goto yyreduce;
4807 + }
4808 + else if (yyn == 0)
4809 + goto yyerrpop;
4810 +
4811 + if (yyn == YYFINAL)
4812 + YYACCEPT;
4813 +
4814 + YYDPRINTF ((stderr, "Shifting error token, "));
4815 +
4816 + *++yyvsp = yylval;
4817 +#if YYLSP_NEEDED
4818 + *++yylsp = yylloc;
4819 +#endif
4820 +
4821 + yystate = yyn;
4822 + goto yynewstate;
4823 +
4824 +
4825 +/*-------------------------------------.
4826 +| yyacceptlab -- YYACCEPT comes here. |
4827 +`-------------------------------------*/
4828 +yyacceptlab:
4829 + yyresult = 0;
4830 + goto yyreturn;
4831 +
4832 +/*-----------------------------------.
4833 +| yyabortlab -- YYABORT comes here. |
4834 +`-----------------------------------*/
4835 +yyabortlab:
4836 + yyresult = 1;
4837 + goto yyreturn;
4838 +
4839 +/*---------------------------------------------.
4840 +| yyoverflowab -- parser overflow comes here. |
4841 +`---------------------------------------------*/
4842 +yyoverflowlab:
4843 + yyerror ("parser stack overflow");
4844 + yyresult = 2;
4845 + /* Fall through. */
4846 +
4847 +yyreturn:
4848 +#ifndef yyoverflow
4849 + if (yyss != yyssa)
4850 + YYSTACK_FREE (yyss);
4851 +#endif
4852 + return yyresult;
4853 +}
4854 +#line 848 "matcher_parser_parse.y"
4855 diff -urN empty/matcher_parser_parse.h src/matcher_parser_parse.h
4856 --- empty/matcher_parser_parse.h Thu Jan 1 00:00:00 1970
4857 +++ src/matcher_parser_parse.h Sun May 12 00:04:36 2002
4858 @@ -0,0 +1,85 @@
4859 +#ifndef BISON_Y_TAB_H
4860 +# define BISON_Y_TAB_H
4861 +
4862 +#ifndef YYSTYPE
4863 +typedef union {
4864 + char * str;
4865 + int value;
4866 +} yystype;
4867 +# define YYSTYPE yystype
4868 +#endif
4869 +# define MATCHER_ALL 257
4870 +# define MATCHER_UNREAD 258
4871 +# define MATCHER_NOT_UNREAD 259
4872 +# define MATCHER_NEW 260
4873 +# define MATCHER_NOT_NEW 261
4874 +# define MATCHER_MARKED 262
4875 +# define MATCHER_NOT_MARKED 263
4876 +# define MATCHER_DELETED 264
4877 +# define MATCHER_NOT_DELETED 265
4878 +# define MATCHER_REPLIED 266
4879 +# define MATCHER_NOT_REPLIED 267
4880 +# define MATCHER_FORWARDED 268
4881 +# define MATCHER_NOT_FORWARDED 269
4882 +# define MATCHER_SUBJECT 270
4883 +# define MATCHER_NOT_SUBJECT 271
4884 +# define MATCHER_FROM 272
4885 +# define MATCHER_NOT_FROM 273
4886 +# define MATCHER_TO 274
4887 +# define MATCHER_NOT_TO 275
4888 +# define MATCHER_CC 276
4889 +# define MATCHER_NOT_CC 277
4890 +# define MATCHER_TO_OR_CC 278
4891 +# define MATCHER_NOT_TO_AND_NOT_CC 279
4892 +# define MATCHER_AGE_GREATER 280
4893 +# define MATCHER_AGE_LOWER 281
4894 +# define MATCHER_NEWSGROUPS 282
4895 +# define MATCHER_NOT_NEWSGROUPS 283
4896 +# define MATCHER_INREPLYTO 284
4897 +# define MATCHER_NOT_INREPLYTO 285
4898 +# define MATCHER_REFERENCES 286
4899 +# define MATCHER_NOT_REFERENCES 287
4900 +# define MATCHER_SCORE_GREATER 288
4901 +# define MATCHER_SCORE_LOWER 289
4902 +# define MATCHER_HEADER 290
4903 +# define MATCHER_NOT_HEADER 291
4904 +# define MATCHER_HEADERS_PART 292
4905 +# define MATCHER_NOT_HEADERS_PART 293
4906 +# define MATCHER_MESSAGE 294
4907 +# define MATCHER_NOT_MESSAGE 295
4908 +# define MATCHER_BODY_PART 296
4909 +# define MATCHER_NOT_BODY_PART 297
4910 +# define MATCHER_EXECUTE 298
4911 +# define MATCHER_NOT_EXECUTE 299
4912 +# define MATCHER_MATCHCASE 300
4913 +# define MATCHER_MATCH 301
4914 +# define MATCHER_REGEXPCASE 302
4915 +# define MATCHER_REGEXP 303
4916 +# define MATCHER_SCORE 304
4917 +# define MATCHER_MOVE 305
4918 +# define MATCHER_COPY 306
4919 +# define MATCHER_DELETE 307
4920 +# define MATCHER_MARK 308
4921 +# define MATCHER_UNMARK 309
4922 +# define MATCHER_MARK_AS_READ 310
4923 +# define MATCHER_MARK_AS_UNREAD 311
4924 +# define MATCHER_FORWARD 312
4925 +# define MATCHER_FORWARD_AS_ATTACHMENT 313
4926 +# define MATCHER_EOL 314
4927 +# define MATCHER_STRING 315
4928 +# define MATCHER_OR 316
4929 +# define MATCHER_AND 317
4930 +# define MATCHER_COLOR 318
4931 +# define MATCHER_SCORE_EQUAL 319
4932 +# define MATCHER_BOUNCE 320
4933 +# define MATCHER_DELETE_ON_SERVER 321
4934 +# define MATCHER_SIZE_GREATER 322
4935 +# define MATCHER_SIZE_SMALLER 323
4936 +# define MATCHER_SIZE_EQUAL 324
4937 +# define MATCHER_SECTION 325
4938 +# define MATCHER_INTEGER 326
4939 +
4940 +
4941 +extern YYSTYPE yylval;
4942 +
4943 +#endif /* not BISON_Y_TAB_H */
4944 diff -urN empty/quote_fmt_lex.c src/quote_fmt_lex.c
4945 --- empty/quote_fmt_lex.c Thu Jan 1 00:00:00 1970
4946 +++ src/quote_fmt_lex.c Sun May 12 00:04:36 2002
4947 @@ -0,0 +1,1809 @@
4948 +#define yy_create_buffer quote_fmt_create_buffer
4949 +#define yy_delete_buffer quote_fmt_delete_buffer
4950 +#define yy_scan_buffer quote_fmt_scan_buffer
4951 +#define yy_scan_string quote_fmt_scan_string
4952 +#define yy_scan_bytes quote_fmt_scan_bytes
4953 +#define yy_flex_debug quote_fmt_flex_debug
4954 +#define yy_init_buffer quote_fmt_init_buffer
4955 +#define yy_flush_buffer quote_fmt_flush_buffer
4956 +#define yy_load_buffer_state quote_fmt_load_buffer_state
4957 +#define yy_switch_to_buffer quote_fmt_switch_to_buffer
4958 +#define yyin quote_fmtin
4959 +#define yyleng quote_fmtleng
4960 +#define yylex quote_fmtlex
4961 +#define yyout quote_fmtout
4962 +#define yyrestart quote_fmtrestart
4963 +#define yytext quote_fmttext
4964 +#define yywrap quote_fmtwrap
4965 +
4966 +#line 20 "lex.yy.c"
4967 +/* A lexical scanner generated by flex */
4968 +
4969 +/* Scanner skeleton version:
4970 + * $Header$
4971 + */
4972 +
4973 +#define FLEX_SCANNER
4974 +#define YY_FLEX_MAJOR_VERSION 2
4975 +#define YY_FLEX_MINOR_VERSION 5
4976 +
4977 +#include <stdio.h>
4978 +
4979 +
4980 +/* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
4981 +#ifdef c_plusplus
4982 +#ifndef __cplusplus
4983 +#define __cplusplus
4984 +#endif
4985 +#endif
4986 +
4987 +
4988 +#ifdef __cplusplus
4989 +
4990 +#include <stdlib.h>
4991 +#include <unistd.h>
4992 +
4993 +/* Use prototypes in function declarations. */
4994 +#define YY_USE_PROTOS
4995 +
4996 +/* The "const" storage-class-modifier is valid. */
4997 +#define YY_USE_CONST
4998 +
4999 +#else /* ! __cplusplus */
5000 +
5001 +#if __STDC__
5002 +
5003 +#define YY_USE_PROTOS
5004 +#define YY_USE_CONST
5005 +
5006 +#endif /* __STDC__ */
5007 +#endif /* ! __cplusplus */
5008 +
5009 +#ifdef __TURBOC__
5010 + #pragma warn -rch
5011 + #pragma warn -use
5012 +#include <io.h>
5013 +#include <stdlib.h>
5014 +#define YY_USE_CONST
5015 +#define YY_USE_PROTOS
5016 +#endif
5017 +
5018 +#ifdef YY_USE_CONST
5019 +#define yyconst const
5020 +#else
5021 +#define yyconst
5022 +#endif
5023 +
5024 +
5025 +#ifdef YY_USE_PROTOS
5026 +#define YY_PROTO(proto) proto
5027 +#else
5028 +#define YY_PROTO(proto) ()
5029 +#endif
5030 +
5031 +/* Returned upon end-of-file. */
5032 +#define YY_NULL 0
5033 +
5034 +/* Promotes a possibly negative, possibly signed char to an unsigned
5035 + * integer for use as an array index. If the signed char is negative,
5036 + * we want to instead treat it as an 8-bit unsigned char, hence the
5037 + * double cast.
5038 + */
5039 +#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
5040 +
5041 +/* Enter a start condition. This macro really ought to take a parameter,
5042 + * but we do it the disgusting crufty way forced on us by the ()-less
5043 + * definition of BEGIN.
5044 + */
5045 +#define BEGIN yy_start = 1 + 2 *
5046 +
5047 +/* Translate the current start state into a value that can be later handed
5048 + * to BEGIN to return to the state. The YYSTATE alias is for lex
5049 + * compatibility.
5050 + */
5051 +#define YY_START ((yy_start - 1) / 2)
5052 +#define YYSTATE YY_START
5053 +
5054 +/* Action number for EOF rule of a given start state. */
5055 +#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
5056 +
5057 +/* Special action meaning "start processing a new file". */
5058 +#define YY_NEW_FILE yyrestart( yyin )
5059 +
5060 +#define YY_END_OF_BUFFER_CHAR 0
5061 +
5062 +/* Size of default input buffer. */
5063 +#define YY_BUF_SIZE 16384
5064 +
5065 +typedef struct yy_buffer_state *YY_BUFFER_STATE;
5066 +
5067 +extern int yyleng;
5068 +extern FILE *yyin, *yyout;
5069 +
5070 +#define EOB_ACT_CONTINUE_SCAN 0
5071 +#define EOB_ACT_END_OF_FILE 1
5072 +#define EOB_ACT_LAST_MATCH 2
5073 +
5074 +/* The funky do-while in the following #define is used to turn the definition
5075 + * int a single C statement (which needs a semi-colon terminator). This
5076 + * avoids problems with code like:
5077 + *
5078 + * if ( condition_holds )
5079 + * yyless( 5 );
5080 + * else
5081 + * do_something_else();
5082 + *
5083 + * Prior to using the do-while the compiler would get upset at the
5084 + * "else" because it interpreted the "if" statement as being all
5085 + * done when it reached the ';' after the yyless() call.
5086 + */
5087 +
5088 +/* Return all but the first 'n' matched characters back to the input stream. */
5089 +
5090 +#define yyless(n) \
5091 + do \
5092 + { \
5093 + /* Undo effects of setting up yytext. */ \
5094 + *yy_cp = yy_hold_char; \
5095 + YY_RESTORE_YY_MORE_OFFSET \
5096 + yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
5097 + YY_DO_BEFORE_ACTION; /* set up yytext again */ \
5098 + } \
5099 + while ( 0 )
5100 +
5101 +#define unput(c) yyunput( c, yytext_ptr )
5102 +
5103 +/* The following is because we cannot portably get our hands on size_t
5104 + * (without autoconf's help, which isn't available because we want
5105 + * flex-generated scanners to compile on their own).
5106 + */
5107 +typedef unsigned int yy_size_t;
5108 +
5109 +
5110 +struct yy_buffer_state
5111 + {
5112 + FILE *yy_input_file;
5113 +
5114 + char *yy_ch_buf; /* input buffer */
5115 + char *yy_buf_pos; /* current position in input buffer */
5116 +
5117 + /* Size of input buffer in bytes, not including room for EOB
5118 + * characters.
5119 + */
5120 + yy_size_t yy_buf_size;
5121 +
5122 + /* Number of characters read into yy_ch_buf, not including EOB
5123 + * characters.
5124 + */
5125 + int yy_n_chars;
5126 +
5127 + /* Whether we "own" the buffer - i.e., we know we created it,
5128 + * and can realloc() it to grow it, and should free() it to
5129 + * delete it.
5130 + */
5131 + int yy_is_our_buffer;
5132 +
5133 + /* Whether this is an "interactive" input source; if so, and
5134 + * if we're using stdio for input, then we want to use getc()
5135 + * instead of fread(), to make sure we stop fetching input after
5136 + * each newline.
5137 + */
5138 + int yy_is_interactive;
5139 +
5140 + /* Whether we're considered to be at the beginning of a line.
5141 + * If so, '^' rules will be active on the next match, otherwise
5142 + * not.
5143 + */
5144 + int yy_at_bol;
5145 +
5146 + /* Whether to try to fill the input buffer when we reach the
5147 + * end of it.
5148 + */
5149 + int yy_fill_buffer;
5150 +
5151 + int yy_buffer_status;
5152 +#define YY_BUFFER_NEW 0
5153 +#define YY_BUFFER_NORMAL 1
5154 + /* When an EOF's been seen but there's still some text to process
5155 + * then we mark the buffer as YY_EOF_PENDING, to indicate that we
5156 + * shouldn't try reading from the input source any more. We might
5157 + * still have a bunch of tokens to match, though, because of
5158 + * possible backing-up.
5159 + *
5160 + * When we actually see the EOF, we change the status to "new"
5161 + * (via yyrestart()), so that the user can continue scanning by
5162 + * just pointing yyin at a new input file.
5163 + */
5164 +#define YY_BUFFER_EOF_PENDING 2
5165 + };
5166 +
5167 +static YY_BUFFER_STATE yy_current_buffer = 0;
5168 +
5169 +/* We provide macros for accessing buffer states in case in the
5170 + * future we want to put the buffer states in a more general
5171 + * "scanner state".
5172 + */
5173 +#define YY_CURRENT_BUFFER yy_current_buffer
5174 +
5175 +
5176 +/* yy_hold_char holds the character lost when yytext is formed. */
5177 +static char yy_hold_char;
5178 +
5179 +static int yy_n_chars; /* number of characters read into yy_ch_buf */
5180 +
5181 +
5182 +int yyleng;
5183 +
5184 +/* Points to current character in buffer. */
5185 +static char *yy_c_buf_p = (char *) 0;
5186 +static int yy_init = 1; /* whether we need to initialize */
5187 +static int yy_start = 0; /* start state number */
5188 +
5189 +/* Flag which is used to allow yywrap()'s to do buffer switches
5190 + * instead of setting up a fresh yyin. A bit of a hack ...
5191 + */
5192 +static int yy_did_buffer_switch_on_eof;
5193 +
5194 +void yyrestart YY_PROTO(( FILE *input_file ));
5195 +
5196 +void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
5197 +void yy_load_buffer_state YY_PROTO(( void ));
5198 +YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
5199 +void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
5200 +void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
5201 +void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
5202 +#define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
5203 +
5204 +YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
5205 +YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str ));
5206 +YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
5207 +
5208 +static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
5209 +static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));
5210 +static void yy_flex_free YY_PROTO(( void * ));
5211 +
5212 +#define yy_new_buffer yy_create_buffer
5213 +
5214 +#define yy_set_interactive(is_interactive) \
5215 + { \
5216 + if ( ! yy_current_buffer ) \
5217 + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
5218 + yy_current_buffer->yy_is_interactive = is_interactive; \
5219 + }
5220 +
5221 +#define yy_set_bol(at_bol) \
5222 + { \
5223 + if ( ! yy_current_buffer ) \
5224 + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
5225 + yy_current_buffer->yy_at_bol = at_bol; \
5226 + }
5227 +
5228 +#define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
5229 +
5230 +typedef unsigned char YY_CHAR;
5231 +FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
5232 +typedef int yy_state_type;
5233 +extern char *yytext;
5234 +#define yytext_ptr yytext
5235 +
5236 +static yy_state_type yy_get_previous_state YY_PROTO(( void ));
5237 +static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
5238 +static int yy_get_next_buffer YY_PROTO(( void ));
5239 +static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
5240 +
5241 +/* Done after the current pattern has been matched and before the
5242 + * corresponding action - sets up yytext.
5243 + */
5244 +#define YY_DO_BEFORE_ACTION \
5245 + yytext_ptr = yy_bp; \
5246 + yyleng = (int) (yy_cp - yy_bp); \
5247 + yy_hold_char = *yy_cp; \
5248 + *yy_cp = '\0'; \
5249 + yy_c_buf_p = yy_cp;
5250 +
5251 +#define YY_NUM_RULES 42
5252 +#define YY_END_OF_BUFFER 43
5253 +static yyconst short int yy_accept[56] =
5254 + { 0,
5255 + 0, 0, 0, 0, 0, 0, 43, 41, 20, 21,
5256 + 41, 41, 41, 41, 39, 40, 37, 38, 28, 31,
5257 + 26, 27, 33, 32, 34, 29, 30, 18, 22, 19,
5258 + 21, 20, 24, 23, 25, 35, 36, 3, 5, 7,
5259 + 12, 9, 11, 16, 1, 2, 4, 6, 8, 10,
5260 + 17, 13, 14, 15, 0
5261 + } ;
5262 +
5263 +static yyconst int yy_ec[256] =
5264 + { 0,
5265 + 1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
5266 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5267 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5268 + 1, 1, 1, 1, 1, 1, 4, 1, 1, 1,
5269 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5270 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5271 + 1, 1, 5, 1, 1, 1, 1, 6, 1, 7,
5272 + 1, 1, 8, 1, 1, 9, 10, 11, 1, 1,
5273 + 12, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5274 + 1, 13, 1, 1, 1, 1, 1, 1, 14, 15,
5275 +
5276 + 1, 16, 1, 1, 17, 1, 1, 1, 18, 19,
5277 + 1, 20, 21, 22, 23, 24, 1, 1, 1, 1,
5278 + 1, 1, 25, 26, 27, 1, 1, 1, 1, 1,
5279 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5280 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5281 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5282 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5283 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5284 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5285 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5286 +
5287 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5288 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5289 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5290 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5291 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5292 + 1, 1, 1, 1, 1
5293 + } ;
5294 +
5295 +static yyconst int yy_meta[28] =
5296 + { 0,
5297 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5298 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5299 + 1, 1, 1, 1, 1, 1, 1
5300 + } ;
5301 +
5302 +static yyconst short int yy_base[57] =
5303 + { 0,
5304 + 0, 25, 50, 0, 4, 7, 4, 139, 139, 139,
5305 + 71, 92, 0, 114, 139, 139, 139, 139, 139, 139,
5306 + 139, 139, 139, 139, 139, 139, 139, 139, 139, 139,
5307 + 139, 139, 139, 139, 139, 139, 139, 139, 139, 139,
5308 + 139, 139, 139, 139, 139, 139, 139, 139, 139, 139,
5309 + 139, 139, 139, 139, 139, 0
5310 + } ;
5311 +
5312 +static yyconst short int yy_def[57] =
5313 + { 0,
5314 + 56, 56, 56, 3, 3, 3, 55, 55, 55, 55,
5315 + 55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
5316 + 55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
5317 + 55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
5318 + 55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
5319 + 55, 55, 55, 55, 0, 55
5320 + } ;
5321 +
5322 +static yyconst short int yy_nxt[167] =
5323 + { 0,
5324 + 8, 9, 10, 55, 11, 55, 55, 8, 55, 55,
5325 + 8, 55, 12, 55, 55, 36, 55, 55, 55, 37,
5326 + 55, 55, 55, 55, 55, 13, 9, 10, 17, 11,
5327 + 18, 17, 55, 18, 55, 55, 55, 12, 55, 55,
5328 + 55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
5329 + 13, 9, 10, 14, 11, 55, 55, 55, 55, 55,
5330 + 55, 55, 12, 55, 55, 55, 55, 55, 55, 55,
5331 + 55, 55, 55, 55, 15, 13, 16, 19, 19, 55,
5332 + 55, 19, 55, 55, 20, 21, 22, 23, 55, 24,
5333 + 55, 55, 25, 26, 27, 28, 29, 55, 55, 55,
5334 +
5335 + 55, 55, 55, 55, 30, 55, 55, 55, 55, 55,
5336 + 31, 55, 55, 55, 55, 32, 33, 34, 35, 38,
5337 + 39, 40, 41, 42, 43, 44, 55, 45, 46, 47,
5338 + 48, 49, 50, 55, 51, 52, 53, 54, 7, 55,
5339 + 55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
5340 + 55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
5341 + 55, 55, 55, 55, 55, 55
5342 + } ;
5343 +
5344 +static yyconst short int yy_chk[167] =
5345 + { 0,
5346 + 56, 1, 1, 7, 1, 0, 0, 5, 0, 0,
5347 + 6, 0, 1, 0, 0, 13, 0, 0, 0, 13,
5348 + 0, 0, 0, 0, 0, 1, 2, 2, 5, 2,
5349 + 5, 6, 0, 6, 0, 0, 0, 2, 0, 0,
5350 + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5351 + 2, 3, 3, 3, 3, 0, 0, 0, 0, 0,
5352 + 0, 0, 3, 0, 0, 0, 0, 0, 0, 0,
5353 + 0, 0, 0, 0, 3, 3, 3, 11, 11, 0,
5354 + 0, 11, 0, 0, 11, 11, 11, 11, 0, 11,
5355 + 0, 0, 11, 11, 11, 12, 12, 0, 0, 0,
5356 +
5357 + 0, 0, 0, 0, 12, 0, 0, 0, 0, 0,
5358 + 12, 0, 0, 0, 0, 12, 12, 12, 12, 14,
5359 + 14, 14, 14, 14, 14, 14, 0, 14, 14, 14,
5360 + 14, 14, 14, 0, 14, 14, 14, 14, 55, 55,
5361 + 55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
5362 + 55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
5363 + 55, 55, 55, 55, 55, 55
5364 + } ;
5365 +
5366 +static yy_state_type yy_last_accepting_state;
5367 +static char *yy_last_accepting_cpos;
5368 +
5369 +/* The intent behind this definition is that it'll catch
5370 + * any uses of REJECT which flex missed.
5371 + */
5372 +#define REJECT reject_used_but_not_detected
5373 +#define yymore() yymore_used_but_not_detected
5374 +#define YY_MORE_ADJ 0
5375 +#define YY_RESTORE_YY_MORE_OFFSET
5376 +char *yytext;
5377 +#line 1 "quote_fmt_lex.l"
5378 +#define INITIAL 0
5379 +#line 2 "quote_fmt_lex.l"
5380 +#include "quote_fmt_lex.h"
5381 +#include "quote_fmt_parse.h"
5382 +#define S_NORMAL 1
5383 +#define S_DATE 2
5384 +
5385 +#line 12 "quote_fmt_lex.l"
5386 +/*
5387 + * see notes below.
5388 + */
5389 +static int firsttime = 1;
5390 +#line 444 "lex.yy.c"
5391 +
5392 +/* Macros after this point can all be overridden by user definitions in
5393 + * section 1.
5394 + */
5395 +
5396 +#ifndef YY_SKIP_YYWRAP
5397 +#ifdef __cplusplus
5398 +extern "C" int yywrap YY_PROTO(( void ));
5399 +#else
5400 +extern int yywrap YY_PROTO(( void ));
5401 +#endif
5402 +#endif
5403 +
5404 +#ifndef YY_NO_UNPUT
5405 +static void yyunput YY_PROTO(( int c, char *buf_ptr ));
5406 +#endif
5407 +
5408 +#ifndef yytext_ptr
5409 +static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
5410 +#endif
5411 +
5412 +#ifdef YY_NEED_STRLEN
5413 +static int yy_flex_strlen YY_PROTO(( yyconst char * ));
5414 +#endif
5415 +
5416 +#ifndef YY_NO_INPUT
5417 +#ifdef __cplusplus
5418 +static int yyinput YY_PROTO(( void ));
5419 +#else
5420 +static int input YY_PROTO(( void ));
5421 +#endif
5422 +#endif
5423 +
5424 +#if YY_STACK_USED
5425 +static int yy_start_stack_ptr = 0;
5426 +static int yy_start_stack_depth = 0;
5427 +static int *yy_start_stack = 0;
5428 +#ifndef YY_NO_PUSH_STATE
5429 +static void yy_push_state YY_PROTO(( int new_state ));
5430 +#endif
5431 +#ifndef YY_NO_POP_STATE
5432 +static void yy_pop_state YY_PROTO(( void ));
5433 +#endif
5434 +#ifndef YY_NO_TOP_STATE
5435 +static int yy_top_state YY_PROTO(( void ));
5436 +#endif
5437 +
5438 +#else
5439 +#define YY_NO_PUSH_STATE 1
5440 +#define YY_NO_POP_STATE 1
5441 +#define YY_NO_TOP_STATE 1
5442 +#endif
5443 +
5444 +#ifdef YY_MALLOC_DECL
5445 +YY_MALLOC_DECL
5446 +#else
5447 +#if __STDC__
5448 +#ifndef __cplusplus
5449 +#include <stdlib.h>
5450 +#endif
5451 +#else
5452 +/* Just try to get by without declaring the routines. This will fail
5453 + * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
5454 + * or sizeof(void*) != sizeof(int).
5455 + */
5456 +#endif
5457 +#endif
5458 +
5459 +/* Amount of stuff to slurp up with each read. */
5460 +#ifndef YY_READ_BUF_SIZE
5461 +#define YY_READ_BUF_SIZE 8192
5462 +#endif
5463 +
5464 +/* Copy whatever the last rule matched to the standard output. */
5465 +
5466 +#ifndef ECHO
5467 +/* This used to be an fputs(), but since the string might contain NUL's,
5468 + * we now use fwrite().
5469 + */
5470 +#define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
5471 +#endif
5472 +
5473 +/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
5474 + * is returned in "result".
5475 + */
5476 +#ifndef YY_INPUT
5477 +#define YY_INPUT(buf,result,max_size) \
5478 + if ( yy_current_buffer->yy_is_interactive ) \
5479 + { \
5480 + int c = '*', n; \
5481 + for ( n = 0; n < max_size && \
5482 + (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
5483 + buf[n] = (char) c; \
5484 + if ( c == '\n' ) \
5485 + buf[n++] = (char) c; \
5486 + if ( c == EOF && ferror( yyin ) ) \
5487 + YY_FATAL_ERROR( "input in flex scanner failed" ); \
5488 + result = n; \
5489 + } \
5490 + else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
5491 + && ferror( yyin ) ) \
5492 + YY_FATAL_ERROR( "input in flex scanner failed" );
5493 +#endif
5494 +
5495 +/* No semi-colon after return; correct usage is to write "yyterminate();" -
5496 + * we don't want an extra ';' after the "return" because that will cause
5497 + * some compilers to complain about unreachable statements.
5498 + */
5499 +#ifndef yyterminate
5500 +#define yyterminate() return YY_NULL
5501 +#endif
5502 +
5503 +/* Number of entries by which start-condition stack grows. */
5504 +#ifndef YY_START_STACK_INCR
5505 +#define YY_START_STACK_INCR 25
5506 +#endif
5507 +
5508 +/* Report a fatal error. */
5509 +#ifndef YY_FATAL_ERROR
5510 +#define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
5511 +#endif
5512 +
5513 +/* Default declaration of generated scanner - a define so the user can
5514 + * easily add parameters.
5515 + */
5516 +#ifndef YY_DECL
5517 +#define YY_DECL int yylex YY_PROTO(( void ))
5518 +#endif
5519 +
5520 +/* Code executed at the beginning of each rule, after yytext and yyleng
5521 + * have been set up.
5522 + */
5523 +#ifndef YY_USER_ACTION
5524 +#define YY_USER_ACTION
5525 +#endif
5526 +
5527 +/* Code executed at the end of each rule. */
5528 +#ifndef YY_BREAK
5529 +#define YY_BREAK break;
5530 +#endif
5531 +
5532 +#define YY_RULE_SETUP \
5533 + YY_USER_ACTION
5534 +
5535 +YY_DECL
5536 + {
5537 + register yy_state_type yy_current_state;
5538 + register char *yy_cp, *yy_bp;
5539 + register int yy_act;
5540 +
5541 +#line 18 "quote_fmt_lex.l"
5542 +
5543 +
5544 +
5545 +/*
5546 + * NOTES:
5547 + * this lex script used to use characters also in use
5548 + * by strftime() (which we want to use for custom
5549 + * time formats in replies and templates). to circumvent
5550 + * this we have to play a little bit with states.
5551 + *
5552 + * these are the characters we also want to use in the
5553 + * %D time customizer:
5554 + *
5555 + * %a %A %b %B %c %C %d %H %I %j %m %M %p %S %w %x %y %Y %Z
5556 + *
5557 + * you can use these characters too, but don't forget to
5558 + * prepend them with the <S_NORMAL> state.
5559 + *
5560 + * also there is also work around for resetting the state
5561 + * (firsttime variable). this assumes that yylex() will
5562 + * always return to S_NORMAL after quote fmt parsing is
5563 + * done.
5564 + */
5565 +
5566 +
5567 +
5568 + if (firsttime) {
5569 + BEGIN S_NORMAL;
5570 + firsttime = 0;
5571 + }
5572 +
5573 +
5574 +#line 628 "lex.yy.c"
5575 +
5576 + if ( yy_init )
5577 + {
5578 + yy_init = 0;
5579 +
5580 +#ifdef YY_USER_INIT
5581 + YY_USER_INIT;
5582 +#endif
5583 +
5584 + if ( ! yy_start )
5585 + yy_start = 1; /* first start state */
5586 +
5587 + if ( ! yyin )
5588 + yyin = stdin;
5589 +
5590 + if ( ! yyout )
5591 + yyout = stdout;
5592 +
5593 + if ( ! yy_current_buffer )
5594 + yy_current_buffer =
5595 + yy_create_buffer( yyin, YY_BUF_SIZE );
5596 +
5597 + yy_load_buffer_state();
5598 + }
5599 +
5600 + while ( 1 ) /* loops until end-of-file is reached */
5601 + {
5602 + yy_cp = yy_c_buf_p;
5603 +
5604 + /* Support of yytext. */
5605 + *yy_cp = yy_hold_char;
5606 +
5607 + /* yy_bp points to the position in yy_ch_buf of the start of
5608 + * the current run.
5609 + */
5610 + yy_bp = yy_cp;
5611 +
5612 + yy_current_state = yy_start;
5613 +yy_match:
5614 + do
5615 + {
5616 + register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
5617 + if ( yy_accept[yy_current_state] )
5618 + {
5619 + yy_last_accepting_state = yy_current_state;
5620 + yy_last_accepting_cpos = yy_cp;
5621 + }
5622 + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
5623 + {
5624 + yy_current_state = (int) yy_def[yy_current_state];
5625 + if ( yy_current_state >= 56 )
5626 + yy_c = yy_meta[(unsigned int) yy_c];
5627 + }
5628 + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
5629 + ++yy_cp;
5630 + }
5631 + while ( yy_base[yy_current_state] != 139 );
5632 +
5633 +yy_find_action:
5634 + yy_act = yy_accept[yy_current_state];
5635 + if ( yy_act == 0 )
5636 + { /* have to back up */
5637 + yy_cp = yy_last_accepting_cpos;
5638 + yy_current_state = yy_last_accepting_state;
5639 + yy_act = yy_accept[yy_current_state];
5640 + }
5641 +
5642 + YY_DO_BEFORE_ACTION;
5643 +
5644 +
5645 +do_action: /* This label is used only to access EOF actions. */
5646 +
5647 +
5648 + switch ( yy_act )
5649 + { /* beginning of action switch */
5650 + case 0: /* must back up */
5651 + /* undo the effects of YY_DO_BEFORE_ACTION */
5652 + *yy_cp = yy_hold_char;
5653 + yy_cp = yy_last_accepting_cpos;
5654 + yy_current_state = yy_last_accepting_state;
5655 + goto yy_find_action;
5656 +
5657 +case 1:
5658 +YY_RULE_SETUP
5659 +#line 50 "quote_fmt_lex.l"
5660 +/* cc */ return SHOW_CC;
5661 + YY_BREAK
5662 +case 2:
5663 +YY_RULE_SETUP
5664 +#line 51 "quote_fmt_lex.l"
5665 +/* date */ return SHOW_DATE;
5666 + YY_BREAK
5667 +case 3:
5668 +YY_RULE_SETUP
5669 +#line 52 "quote_fmt_lex.l"
5670 +/* date */ { BEGIN S_DATE; return SHOW_DATE_EXPR; }
5671 + YY_BREAK
5672 +case 4:
5673 +YY_RULE_SETUP
5674 +#line 53 "quote_fmt_lex.l"
5675 +/* from */ return SHOW_FROM;
5676 + YY_BREAK
5677 +case 5:
5678 +YY_RULE_SETUP
5679 +#line 54 "quote_fmt_lex.l"
5680 +/* first name */ return SHOW_FIRST_NAME;
5681 + YY_BREAK
5682 +case 6:
5683 +YY_RULE_SETUP
5684 +#line 55 "quote_fmt_lex.l"
5685 +/* message-id */ return SHOW_MESSAGEID;
5686 + YY_BREAK
5687 +case 7:
5688 +YY_RULE_SETUP
5689 +#line 56 "quote_fmt_lex.l"
5690 +/* initial of sender */ return SHOW_SENDER_INITIAL;
5691 + YY_BREAK
5692 +case 8:
5693 +YY_RULE_SETUP
5694 +#line 57 "quote_fmt_lex.l"
5695 +/* message with no signature */ return SHOW_MESSAGE_NO_SIGNATURE;
5696 + YY_BREAK
5697 +case 9:
5698 +YY_RULE_SETUP
5699 +#line 58 "quote_fmt_lex.l"
5700 +/* message */ return SHOW_MESSAGE;
5701 + YY_BREAK
5702 +case 10:
5703 +YY_RULE_SETUP
5704 +#line 59 "quote_fmt_lex.l"
5705 +/* newsgroups */ return SHOW_NEWSGROUPS;
5706 + YY_BREAK
5707 +case 11:
5708 +YY_RULE_SETUP
5709 +#line 60 "quote_fmt_lex.l"
5710 +/* full name */ return SHOW_FULLNAME;
5711 + YY_BREAK
5712 +case 12:
5713 +YY_RULE_SETUP
5714 +#line 61 "quote_fmt_lex.l"
5715 +/* last name */ return SHOW_LAST_NAME;
5716 + YY_BREAK
5717 +case 13:
5718 +YY_RULE_SETUP
5719 +#line 62 "quote_fmt_lex.l"
5720 +/* references */ return SHOW_REFERENCES;
5721 + YY_BREAK
5722 +case 14:
5723 +YY_RULE_SETUP
5724 +#line 63 "quote_fmt_lex.l"
5725 +/* subject */ return SHOW_SUBJECT;
5726 + YY_BREAK
5727 +case 15:
5728 +YY_RULE_SETUP
5729 +#line 64 "quote_fmt_lex.l"
5730 +/* to */ return SHOW_TO;
5731 + YY_BREAK
5732 +case 16:
5733 +YY_RULE_SETUP
5734 +#line 65 "quote_fmt_lex.l"
5735 +/* quoted message */ return SHOW_QUOTED_MESSAGE;
5736 + YY_BREAK
5737 +case 17:
5738 +YY_RULE_SETUP
5739 +#line 66 "quote_fmt_lex.l"
5740 +/* quoted message with no signature */ return SHOW_QUOTED_MESSAGE_NO_SIGNATURE;
5741 + YY_BREAK
5742 +case 18:
5743 +YY_RULE_SETUP
5744 +#line 67 "quote_fmt_lex.l"
5745 +/* % */ return SHOW_PERCENT;
5746 + YY_BREAK
5747 +case 19:
5748 +YY_RULE_SETUP
5749 +#line 68 "quote_fmt_lex.l"
5750 +/* \ */ return SHOW_BACKSLASH;
5751 + YY_BREAK
5752 +case 20:
5753 +YY_RULE_SETUP
5754 +#line 69 "quote_fmt_lex.l"
5755 +/* tab */ return SHOW_TAB;
5756 + YY_BREAK
5757 +case 21:
5758 +YY_RULE_SETUP
5759 +#line 70 "quote_fmt_lex.l"
5760 +/* return */ return SHOW_EOL;
5761 + YY_BREAK
5762 +case 22:
5763 +YY_RULE_SETUP
5764 +#line 71 "quote_fmt_lex.l"
5765 +/* ? */ return SHOW_QUESTION_MARK;
5766 + YY_BREAK
5767 +case 23:
5768 +YY_RULE_SETUP
5769 +#line 72 "quote_fmt_lex.l"
5770 +return SHOW_PIPE;
5771 + YY_BREAK
5772 +case 24:
5773 +YY_RULE_SETUP
5774 +#line 73 "quote_fmt_lex.l"
5775 +return SHOW_OPARENT;
5776 + YY_BREAK
5777 +case 25:
5778 +YY_RULE_SETUP
5779 +#line 74 "quote_fmt_lex.l"
5780 +return SHOW_CPARENT;
5781 + YY_BREAK
5782 +case 26:
5783 +YY_RULE_SETUP
5784 +#line 75 "quote_fmt_lex.l"
5785 +/* query date */ return QUERY_DATE;
5786 + YY_BREAK
5787 +case 27:
5788 +YY_RULE_SETUP
5789 +#line 76 "quote_fmt_lex.l"
5790 +/* query from */ return QUERY_FROM;
5791 + YY_BREAK
5792 +case 28:
5793 +YY_RULE_SETUP
5794 +#line 77 "quote_fmt_lex.l"
5795 +/* query from name */ return QUERY_FULLNAME;
5796 + YY_BREAK
5797 +case 29:
5798 +YY_RULE_SETUP
5799 +#line 78 "quote_fmt_lex.l"
5800 +/* query subject */ return QUERY_SUBJECT;
5801 + YY_BREAK
5802 +case 30:
5803 +YY_RULE_SETUP
5804 +#line 79 "quote_fmt_lex.l"
5805 +/* query to */ return QUERY_TO;
5806 + YY_BREAK
5807 +case 31:
5808 +YY_RULE_SETUP
5809 +#line 80 "quote_fmt_lex.l"
5810 +/* query cc */ return QUERY_CC;
5811 + YY_BREAK
5812 +case 32:
5813 +YY_RULE_SETUP
5814 +#line 81 "quote_fmt_lex.l"
5815 +/* query newsgroups */ return QUERY_NEWSGROUPS;
5816 + YY_BREAK
5817 +case 33:
5818 +YY_RULE_SETUP
5819 +#line 82 "quote_fmt_lex.l"
5820 +/* query message-id */ return QUERY_MESSAGEID;
5821 + YY_BREAK
5822 +case 34:
5823 +YY_RULE_SETUP
5824 +#line 83 "quote_fmt_lex.l"
5825 +/* query references */ return QUERY_REFERENCES;
5826 + YY_BREAK
5827 +case 35:
5828 +YY_RULE_SETUP
5829 +#line 84 "quote_fmt_lex.l"
5830 +/* insert file */ return INSERT_FILE;
5831 + YY_BREAK
5832 +case 36:
5833 +YY_RULE_SETUP
5834 +#line 85 "quote_fmt_lex.l"
5835 +/* insert program output */ return INSERT_PROGRAMOUTPUT;
5836 + YY_BREAK
5837 +case 37:
5838 +YY_RULE_SETUP
5839 +#line 86 "quote_fmt_lex.l"
5840 +return OPARENT;
5841 + YY_BREAK
5842 +case 38:
5843 +YY_RULE_SETUP
5844 +#line 87 "quote_fmt_lex.l"
5845 +{ BEGIN S_NORMAL; return CPARENT; }
5846 + YY_BREAK
5847 +case 39:
5848 +YY_RULE_SETUP
5849 +#line 88 "quote_fmt_lex.l"
5850 +return OPARENT;
5851 + YY_BREAK
5852 +case 40:
5853 +YY_RULE_SETUP
5854 +#line 89 "quote_fmt_lex.l"
5855 +return CPARENT;
5856 + YY_BREAK
5857 +case 41:
5858 +YY_RULE_SETUP
5859 +#line 90 "quote_fmt_lex.l"
5860 +{ yylval.chr = yytext[0]; return CHARACTER; }
5861 + YY_BREAK
5862 +case 42:
5863 +YY_RULE_SETUP
5864 +#line 92 "quote_fmt_lex.l"
5865 +ECHO;
5866 + YY_BREAK
5867 +#line 921 "lex.yy.c"
5868 +case YY_STATE_EOF(INITIAL):
5869 +case YY_STATE_EOF(S_NORMAL):
5870 +case YY_STATE_EOF(S_DATE):
5871 + yyterminate();
5872 +
5873 + case YY_END_OF_BUFFER:
5874 + {
5875 + /* Amount of text matched not including the EOB char. */
5876 + int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
5877 +
5878 + /* Undo the effects of YY_DO_BEFORE_ACTION. */
5879 + *yy_cp = yy_hold_char;
5880 + YY_RESTORE_YY_MORE_OFFSET
5881 +
5882 + if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
5883 + {
5884 + /* We're scanning a new file or input source. It's
5885 + * possible that this happened because the user
5886 + * just pointed yyin at a new source and called
5887 + * yylex(). If so, then we have to assure
5888 + * consistency between yy_current_buffer and our
5889 + * globals. Here is the right place to do so, because
5890 + * this is the first action (other than possibly a
5891 + * back-up) that will match for the new input source.
5892 + */
5893 + yy_n_chars = yy_current_buffer->yy_n_chars;
5894 + yy_current_buffer->yy_input_file = yyin;
5895 + yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
5896 + }
5897 +
5898 + /* Note that here we test for yy_c_buf_p "<=" to the position
5899 + * of the first EOB in the buffer, since yy_c_buf_p will
5900 + * already have been incremented past the NUL character
5901 + * (since all states make transitions on EOB to the
5902 + * end-of-buffer state). Contrast this with the test
5903 + * in input().
5904 + */
5905 + if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
5906 + { /* This was really a NUL. */
5907 + yy_state_type yy_next_state;
5908 +
5909 + yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
5910 +
5911 + yy_current_state = yy_get_previous_state();
5912 +
5913 + /* Okay, we're now positioned to make the NUL
5914 + * transition. We couldn't have
5915 + * yy_get_previous_state() go ahead and do it
5916 + * for us because it doesn't know how to deal
5917 + * with the possibility of jamming (and we don't
5918 + * want to build jamming into it because then it
5919 + * will run more slowly).
5920 + */
5921 +
5922 + yy_next_state = yy_try_NUL_trans( yy_current_state );
5923 +
5924 + yy_bp = yytext_ptr + YY_MORE_ADJ;
5925 +
5926 + if ( yy_next_state )
5927 + {
5928 + /* Consume the NUL. */
5929 + yy_cp = ++yy_c_buf_p;
5930 + yy_current_state = yy_next_state;
5931 + goto yy_match;
5932 + }
5933 +
5934 + else
5935 + {
5936 + yy_cp = yy_c_buf_p;
5937 + goto yy_find_action;
5938 + }
5939 + }
5940 +
5941 + else switch ( yy_get_next_buffer() )
5942 + {
5943 + case EOB_ACT_END_OF_FILE:
5944 + {
5945 + yy_did_buffer_switch_on_eof = 0;
5946 +
5947 + if ( yywrap() )
5948 + {
5949 + /* Note: because we've taken care in
5950 + * yy_get_next_buffer() to have set up
5951 + * yytext, we can now set up
5952 + * yy_c_buf_p so that if some total
5953 + * hoser (like flex itself) wants to
5954 + * call the scanner after we return the
5955 + * YY_NULL, it'll still work - another
5956 + * YY_NULL will get returned.
5957 + */
5958 + yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
5959 +
5960 + yy_act = YY_STATE_EOF(YY_START);
5961 + goto do_action;
5962 + }
5963 +
5964 + else
5965 + {
5966 + if ( ! yy_did_buffer_switch_on_eof )
5967 + YY_NEW_FILE;
5968 + }
5969 + break;
5970 + }
5971 +
5972 + case EOB_ACT_CONTINUE_SCAN:
5973 + yy_c_buf_p =
5974 + yytext_ptr + yy_amount_of_matched_text;
5975 +
5976 + yy_current_state = yy_get_previous_state();
5977 +
5978 + yy_cp = yy_c_buf_p;
5979 + yy_bp = yytext_ptr + YY_MORE_ADJ;
5980 + goto yy_match;
5981 +
5982 + case EOB_ACT_LAST_MATCH:
5983 + yy_c_buf_p =
5984 + &yy_current_buffer->yy_ch_buf[yy_n_chars];
5985 +
5986 + yy_current_state = yy_get_previous_state();
5987 +
5988 + yy_cp = yy_c_buf_p;
5989 + yy_bp = yytext_ptr + YY_MORE_ADJ;
5990 + goto yy_find_action;
5991 + }
5992 + break;
5993 + }
5994 +
5995 + default:
5996 + YY_FATAL_ERROR(
5997 + "fatal flex scanner internal error--no action found" );
5998 + } /* end of action switch */
5999 + } /* end of scanning one token */
6000 + } /* end of yylex */
6001 +
6002 +
6003 +/* yy_get_next_buffer - try to read in a new buffer
6004 + *
6005 + * Returns a code representing an action:
6006 + * EOB_ACT_LAST_MATCH -
6007 + * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
6008 + * EOB_ACT_END_OF_FILE - end of file
6009 + */
6010 +
6011 +static int yy_get_next_buffer()
6012 + {
6013 + register char *dest = yy_current_buffer->yy_ch_buf;
6014 + register char *source = yytext_ptr;
6015 + register int number_to_move, i;
6016 + int ret_val;
6017 +
6018 + if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
6019 + YY_FATAL_ERROR(
6020 + "fatal flex scanner internal error--end of buffer missed" );
6021 +
6022 + if ( yy_current_buffer->yy_fill_buffer == 0 )
6023 + { /* Don't try to fill the buffer, so this is an EOF. */
6024 + if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
6025 + {
6026 + /* We matched a single character, the EOB, so
6027 + * treat this as a final EOF.
6028 + */
6029 + return EOB_ACT_END_OF_FILE;
6030 + }
6031 +
6032 + else
6033 + {
6034 + /* We matched some text prior to the EOB, first
6035 + * process it.
6036 + */
6037 + return EOB_ACT_LAST_MATCH;
6038 + }
6039 + }
6040 +
6041 + /* Try to read more data. */
6042 +
6043 + /* First move last chars to start of buffer. */
6044 + number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
6045 +
6046 + for ( i = 0; i < number_to_move; ++i )
6047 + *(dest++) = *(source++);
6048 +
6049 + if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
6050 + /* don't do the read, it's not guaranteed to return an EOF,
6051 + * just force an EOF
6052 + */
6053 + yy_current_buffer->yy_n_chars = yy_n_chars = 0;
6054 +
6055 + else
6056 + {
6057 + int num_to_read =
6058 + yy_current_buffer->yy_buf_size - number_to_move - 1;
6059 +
6060 + while ( num_to_read <= 0 )
6061 + { /* Not enough room in the buffer - grow it. */
6062 +#ifdef YY_USES_REJECT
6063 + YY_FATAL_ERROR(
6064 +"input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
6065 +#else
6066 +
6067 + /* just a shorter name for the current buffer */
6068 + YY_BUFFER_STATE b = yy_current_buffer;
6069 +
6070 + int yy_c_buf_p_offset =
6071 + (int) (yy_c_buf_p - b->yy_ch_buf);
6072 +
6073 + if ( b->yy_is_our_buffer )
6074 + {
6075 + int new_size = b->yy_buf_size * 2;
6076 +
6077 + if ( new_size <= 0 )
6078 + b->yy_buf_size += b->yy_buf_size / 8;
6079 + else
6080 + b->yy_buf_size *= 2;
6081 +
6082 + b->yy_ch_buf = (char *)
6083 + /* Include room in for 2 EOB chars. */
6084 + yy_flex_realloc( (void *) b->yy_ch_buf,
6085 + b->yy_buf_size + 2 );
6086 + }
6087 + else
6088 + /* Can't grow it, we don't own it. */
6089 + b->yy_ch_buf = 0;
6090 +
6091 + if ( ! b->yy_ch_buf )
6092 + YY_FATAL_ERROR(
6093 + "fatal error - scanner input buffer overflow" );
6094 +
6095 + yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
6096 +
6097 + num_to_read = yy_current_buffer->yy_buf_size -
6098 + number_to_move - 1;
6099 +#endif
6100 + }
6101 +
6102 + if ( num_to_read > YY_READ_BUF_SIZE )
6103 + num_to_read = YY_READ_BUF_SIZE;
6104 +
6105 + /* Read in more data. */
6106 + YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
6107 + yy_n_chars, num_to_read );
6108 +
6109 + yy_current_buffer->yy_n_chars = yy_n_chars;
6110 + }
6111 +
6112 + if ( yy_n_chars == 0 )
6113 + {
6114 + if ( number_to_move == YY_MORE_ADJ )
6115 + {
6116 + ret_val = EOB_ACT_END_OF_FILE;
6117 + yyrestart( yyin );
6118 + }
6119 +
6120 + else
6121 + {
6122 + ret_val = EOB_ACT_LAST_MATCH;
6123 + yy_current_buffer->yy_buffer_status =
6124 + YY_BUFFER_EOF_PENDING;
6125 + }
6126 + }
6127 +
6128 + else
6129 + ret_val = EOB_ACT_CONTINUE_SCAN;
6130 +
6131 + yy_n_chars += number_to_move;
6132 + yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
6133 + yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
6134 +
6135 + yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
6136 +
6137 + return ret_val;
6138 + }
6139 +
6140 +
6141 +/* yy_get_previous_state - get the state just before the EOB char was reached */
6142 +
6143 +static yy_state_type yy_get_previous_state()
6144 + {
6145 + register yy_state_type yy_current_state;
6146 + register char *yy_cp;
6147 +
6148 + yy_current_state = yy_start;
6149 +
6150 + for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
6151 + {
6152 + register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
6153 + if ( yy_accept[yy_current_state] )
6154 + {
6155 + yy_last_accepting_state = yy_current_state;
6156 + yy_last_accepting_cpos = yy_cp;
6157 + }
6158 + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
6159 + {
6160 + yy_current_state = (int) yy_def[yy_current_state];
6161 + if ( yy_current_state >= 56 )
6162 + yy_c = yy_meta[(unsigned int) yy_c];
6163 + }
6164 + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
6165 + }
6166 +
6167 + return yy_current_state;
6168 + }
6169 +
6170 +
6171 +/* yy_try_NUL_trans - try to make a transition on the NUL character
6172 + *
6173 + * synopsis
6174 + * next_state = yy_try_NUL_trans( current_state );
6175 + */
6176 +
6177 +#ifdef YY_USE_PROTOS
6178 +static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
6179 +#else
6180 +static yy_state_type yy_try_NUL_trans( yy_current_state )
6181 +yy_state_type yy_current_state;
6182 +#endif
6183 + {
6184 + register int yy_is_jam;
6185 + register char *yy_cp = yy_c_buf_p;
6186 +
6187 + register YY_CHAR yy_c = 1;
6188 + if ( yy_accept[yy_current_state] )
6189 + {
6190 + yy_last_accepting_state = yy_current_state;
6191 + yy_last_accepting_cpos = yy_cp;
6192 + }
6193 + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
6194 + {
6195 + yy_current_state = (int) yy_def[yy_current_state];
6196 + if ( yy_current_state >= 56 )
6197 + yy_c = yy_meta[(unsigned int) yy_c];
6198 + }
6199 + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
6200 + yy_is_jam = (yy_current_state == 55);
6201 +
6202 + return yy_is_jam ? 0 : yy_current_state;
6203 + }
6204 +
6205 +
6206 +#ifndef YY_NO_UNPUT
6207 +#ifdef YY_USE_PROTOS
6208 +static void yyunput( int c, register char *yy_bp )
6209 +#else
6210 +static void yyunput( c, yy_bp )
6211 +int c;
6212 +register char *yy_bp;
6213 +#endif
6214 + {
6215 + register char *yy_cp = yy_c_buf_p;
6216 +
6217 + /* undo effects of setting up yytext */
6218 + *yy_cp = yy_hold_char;
6219 +
6220 + if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
6221 + { /* need to shift things up to make room */
6222 + /* +2 for EOB chars. */
6223 + register int number_to_move = yy_n_chars + 2;
6224 + register char *dest = &yy_current_buffer->yy_ch_buf[
6225 + yy_current_buffer->yy_buf_size + 2];
6226 + register char *source =
6227 + &yy_current_buffer->yy_ch_buf[number_to_move];
6228 +
6229 + while ( source > yy_current_buffer->yy_ch_buf )
6230 + *--dest = *--source;
6231 +
6232 + yy_cp += (int) (dest - source);
6233 + yy_bp += (int) (dest - source);
6234 + yy_current_buffer->yy_n_chars =
6235 + yy_n_chars = yy_current_buffer->yy_buf_size;
6236 +
6237 + if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
6238 + YY_FATAL_ERROR( "flex scanner push-back overflow" );
6239 + }
6240 +
6241 + *--yy_cp = (char) c;
6242 +
6243 +
6244 + yytext_ptr = yy_bp;
6245 + yy_hold_char = *yy_cp;
6246 + yy_c_buf_p = yy_cp;
6247 + }
6248 +#endif /* ifndef YY_NO_UNPUT */
6249 +
6250 +
6251 +#ifdef __cplusplus
6252 +static int yyinput()
6253 +#else
6254 +static int input()
6255 +#endif
6256 + {
6257 + int c;
6258 +
6259 + *yy_c_buf_p = yy_hold_char;
6260 +
6261 + if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
6262 + {
6263 + /* yy_c_buf_p now points to the character we want to return.
6264 + * If this occurs *before* the EOB characters, then it's a
6265 + * valid NUL; if not, then we've hit the end of the buffer.
6266 + */
6267 + if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
6268 + /* This was really a NUL. */
6269 + *yy_c_buf_p = '\0';
6270 +
6271 + else
6272 + { /* need more input */
6273 + int offset = yy_c_buf_p - yytext_ptr;
6274 + ++yy_c_buf_p;
6275 +
6276 + switch ( yy_get_next_buffer() )
6277 + {
6278 + case EOB_ACT_LAST_MATCH:
6279 + /* This happens because yy_g_n_b()
6280 + * sees that we've accumulated a
6281 + * token and flags that we need to
6282 + * try matching the token before
6283 + * proceeding. But for input(),
6284 + * there's no matching to consider.
6285 + * So convert the EOB_ACT_LAST_MATCH
6286 + * to EOB_ACT_END_OF_FILE.
6287 + */
6288 +
6289 + /* Reset buffer status. */
6290 + yyrestart( yyin );
6291 +
6292 + /* fall through */
6293 +
6294 + case EOB_ACT_END_OF_FILE:
6295 + {
6296 + if ( yywrap() )
6297 + return EOF;
6298 +
6299 + if ( ! yy_did_buffer_switch_on_eof )
6300 + YY_NEW_FILE;
6301 +#ifdef __cplusplus
6302 + return yyinput();
6303 +#else
6304 + return input();
6305 +#endif
6306 + }
6307 +
6308 + case EOB_ACT_CONTINUE_SCAN:
6309 + yy_c_buf_p = yytext_ptr + offset;
6310 + break;
6311 + }
6312 + }
6313 + }
6314 +
6315 + c = *(unsigned char *) yy_c_buf_p; /* cast for 8-bit char's */
6316 + *yy_c_buf_p = '\0'; /* preserve yytext */
6317 + yy_hold_char = *++yy_c_buf_p;
6318 +
6319 +
6320 + return c;
6321 + }
6322 +
6323 +
6324 +#ifdef YY_USE_PROTOS
6325 +void yyrestart( FILE *input_file )
6326 +#else
6327 +void yyrestart( input_file )
6328 +FILE *input_file;
6329 +#endif
6330 + {
6331 + if ( ! yy_current_buffer )
6332 + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
6333 +
6334 + yy_init_buffer( yy_current_buffer, input_file );
6335 + yy_load_buffer_state();
6336 + }
6337 +
6338 +
6339 +#ifdef YY_USE_PROTOS
6340 +void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
6341 +#else
6342 +void yy_switch_to_buffer( new_buffer )
6343 +YY_BUFFER_STATE new_buffer;
6344 +#endif
6345 + {
6346 + if ( yy_current_buffer == new_buffer )
6347 + return;
6348 +
6349 + if ( yy_current_buffer )
6350 + {
6351 + /* Flush out information for old buffer. */
6352 + *yy_c_buf_p = yy_hold_char;
6353 + yy_current_buffer->yy_buf_pos = yy_c_buf_p;
6354 + yy_current_buffer->yy_n_chars = yy_n_chars;
6355 + }
6356 +
6357 + yy_current_buffer = new_buffer;
6358 + yy_load_buffer_state();
6359 +
6360 + /* We don't actually know whether we did this switch during
6361 + * EOF (yywrap()) processing, but the only time this flag
6362 + * is looked at is after yywrap() is called, so it's safe
6363 + * to go ahead and always set it.
6364 + */
6365 + yy_did_buffer_switch_on_eof = 1;
6366 + }
6367 +
6368 +
6369 +#ifdef YY_USE_PROTOS
6370 +void yy_load_buffer_state( void )
6371 +#else
6372 +void yy_load_buffer_state()
6373 +#endif
6374 + {
6375 + yy_n_chars = yy_current_buffer->yy_n_chars;
6376 + yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
6377 + yyin = yy_current_buffer->yy_input_file;
6378 + yy_hold_char = *yy_c_buf_p;
6379 + }
6380 +
6381 +
6382 +#ifdef YY_USE_PROTOS
6383 +YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
6384 +#else
6385 +YY_BUFFER_STATE yy_create_buffer( file, size )
6386 +FILE *file;
6387 +int size;
6388 +#endif
6389 + {
6390 + YY_BUFFER_STATE b;
6391 +
6392 + b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
6393 + if ( ! b )
6394 + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
6395 +
6396 + b->yy_buf_size = size;
6397 +
6398 + /* yy_ch_buf has to be 2 characters longer than the size given because
6399 + * we need to put in 2 end-of-buffer characters.
6400 + */
6401 + b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
6402 + if ( ! b->yy_ch_buf )
6403 + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
6404 +
6405 + b->yy_is_our_buffer = 1;
6406 +
6407 + yy_init_buffer( b, file );
6408 +
6409 + return b;
6410 + }
6411 +
6412 +
6413 +#ifdef YY_USE_PROTOS
6414 +void yy_delete_buffer( YY_BUFFER_STATE b )
6415 +#else
6416 +void yy_delete_buffer( b )
6417 +YY_BUFFER_STATE b;
6418 +#endif
6419 + {
6420 + if ( ! b )
6421 + return;
6422 +
6423 + if ( b == yy_current_buffer )
6424 + yy_current_buffer = (YY_BUFFER_STATE) 0;
6425 +
6426 + if ( b->yy_is_our_buffer )
6427 + yy_flex_free( (void *) b->yy_ch_buf );
6428 +
6429 + yy_flex_free( (void *) b );
6430 + }
6431 +
6432 +
6433 +#ifndef YY_ALWAYS_INTERACTIVE
6434 +#ifndef YY_NEVER_INTERACTIVE
6435 +extern int isatty YY_PROTO(( int ));
6436 +#endif
6437 +#endif
6438 +
6439 +#ifdef YY_USE_PROTOS
6440 +void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
6441 +#else
6442 +void yy_init_buffer( b, file )
6443 +YY_BUFFER_STATE b;
6444 +FILE *file;
6445 +#endif
6446 +
6447 +
6448 + {
6449 + yy_flush_buffer( b );
6450 +
6451 + b->yy_input_file = file;
6452 + b->yy_fill_buffer = 1;
6453 +
6454 +#if YY_ALWAYS_INTERACTIVE
6455 + b->yy_is_interactive = 1;
6456 +#else
6457 +#if YY_NEVER_INTERACTIVE
6458 + b->yy_is_interactive = 0;
6459 +#else
6460 + b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
6461 +#endif
6462 +#endif
6463 + }
6464 +
6465 +
6466 +#ifdef YY_USE_PROTOS
6467 +void yy_flush_buffer( YY_BUFFER_STATE b )
6468 +#else
6469 +void yy_flush_buffer( b )
6470 +YY_BUFFER_STATE b;
6471 +#endif
6472 +
6473 + {
6474 + if ( ! b )
6475 + return;
6476 +
6477 + b->yy_n_chars = 0;
6478 +
6479 + /* We always need two end-of-buffer characters. The first causes
6480 + * a transition to the end-of-buffer state. The second causes
6481 + * a jam in that state.
6482 + */
6483 + b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
6484 + b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
6485 +
6486 + b->yy_buf_pos = &b->yy_ch_buf[0];
6487 +
6488 + b->yy_at_bol = 1;
6489 + b->yy_buffer_status = YY_BUFFER_NEW;
6490 +
6491 + if ( b == yy_current_buffer )
6492 + yy_load_buffer_state();
6493 + }
6494 +
6495 +
6496 +#ifndef YY_NO_SCAN_BUFFER
6497 +#ifdef YY_USE_PROTOS
6498 +YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
6499 +#else
6500 +YY_BUFFER_STATE yy_scan_buffer( base, size )
6501 +char *base;
6502 +yy_size_t size;
6503 +#endif
6504 + {
6505 + YY_BUFFER_STATE b;
6506 +
6507 + if ( size < 2 ||
6508 + base[size-2] != YY_END_OF_BUFFER_CHAR ||
6509 + base[size-1] != YY_END_OF_BUFFER_CHAR )
6510 + /* They forgot to leave room for the EOB's. */
6511 + return 0;
6512 +
6513 + b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
6514 + if ( ! b )
6515 + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
6516 +
6517 + b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
6518 + b->yy_buf_pos = b->yy_ch_buf = base;
6519 + b->yy_is_our_buffer = 0;
6520 + b->yy_input_file = 0;
6521 + b->yy_n_chars = b->yy_buf_size;
6522 + b->yy_is_interactive = 0;
6523 + b->yy_at_bol = 1;
6524 + b->yy_fill_buffer = 0;
6525 + b->yy_buffer_status = YY_BUFFER_NEW;
6526 +
6527 + yy_switch_to_buffer( b );
6528 +
6529 + return b;
6530 + }
6531 +#endif
6532 +
6533 +
6534 +#ifndef YY_NO_SCAN_STRING
6535 +#ifdef YY_USE_PROTOS
6536 +YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
6537 +#else
6538 +YY_BUFFER_STATE yy_scan_string( yy_str )
6539 +yyconst char *yy_str;
6540 +#endif
6541 + {
6542 + int len;
6543 + for ( len = 0; yy_str[len]; ++len )
6544 + ;
6545 +
6546 + return yy_scan_bytes( yy_str, len );
6547 + }
6548 +#endif
6549 +
6550 +
6551 +#ifndef YY_NO_SCAN_BYTES
6552 +#ifdef YY_USE_PROTOS
6553 +YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
6554 +#else
6555 +YY_BUFFER_STATE yy_scan_bytes( bytes, len )
6556 +yyconst char *bytes;
6557 +int len;
6558 +#endif
6559 + {
6560 + YY_BUFFER_STATE b;
6561 + char *buf;
6562 + yy_size_t n;
6563 + int i;
6564 +
6565 + /* Get memory for full buffer, including space for trailing EOB's. */
6566 + n = len + 2;
6567 + buf = (char *) yy_flex_alloc( n );
6568 + if ( ! buf )
6569 + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
6570 +
6571 + for ( i = 0; i < len; ++i )
6572 + buf[i] = bytes[i];
6573 +
6574 + buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
6575 +
6576 + b = yy_scan_buffer( buf, n );
6577 + if ( ! b )
6578 + YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
6579 +
6580 + /* It's okay to grow etc. this buffer, and we should throw it
6581 + * away when we're done.
6582 + */
6583 + b->yy_is_our_buffer = 1;
6584 +
6585 + return b;
6586 + }
6587 +#endif
6588 +
6589 +
6590 +#ifndef YY_NO_PUSH_STATE
6591 +#ifdef YY_USE_PROTOS
6592 +static void yy_push_state( int new_state )
6593 +#else
6594 +static void yy_push_state( new_state )
6595 +int new_state;
6596 +#endif
6597 + {
6598 + if ( yy_start_stack_ptr >= yy_start_stack_depth )
6599 + {
6600 + yy_size_t new_size;
6601 +
6602 + yy_start_stack_depth += YY_START_STACK_INCR;
6603 + new_size = yy_start_stack_depth * sizeof( int );
6604 +
6605 + if ( ! yy_start_stack )
6606 + yy_start_stack = (int *) yy_flex_alloc( new_size );
6607 +
6608 + else
6609 + yy_start_stack = (int *) yy_flex_realloc(
6610 + (void *) yy_start_stack, new_size );
6611 +
6612 + if ( ! yy_start_stack )
6613 + YY_FATAL_ERROR(
6614 + "out of memory expanding start-condition stack" );
6615 + }
6616 +
6617 + yy_start_stack[yy_start_stack_ptr++] = YY_START;
6618 +
6619 + BEGIN(new_state);
6620 + }
6621 +#endif
6622 +
6623 +
6624 +#ifndef YY_NO_POP_STATE
6625 +static void yy_pop_state()
6626 + {
6627 + if ( --yy_start_stack_ptr < 0 )
6628 + YY_FATAL_ERROR( "start-condition stack underflow" );
6629 +
6630 + BEGIN(yy_start_stack[yy_start_stack_ptr]);
6631 + }
6632 +#endif
6633 +
6634 +
6635 +#ifndef YY_NO_TOP_STATE
6636 +static int yy_top_state()
6637 + {
6638 + return yy_start_stack[yy_start_stack_ptr - 1];
6639 + }
6640 +#endif
6641 +
6642 +#ifndef YY_EXIT_FAILURE
6643 +#define YY_EXIT_FAILURE 2
6644 +#endif
6645 +
6646 +#ifdef YY_USE_PROTOS
6647 +static void yy_fatal_error( yyconst char msg[] )
6648 +#else
6649 +static void yy_fatal_error( msg )
6650 +char msg[];
6651 +#endif
6652 + {
6653 + (void) fprintf( stderr, "%s\n", msg );
6654 + exit( YY_EXIT_FAILURE );
6655 + }
6656 +
6657 +
6658 +
6659 +/* Redefine yyless() so it works in section 3 code. */
6660 +
6661 +#undef yyless
6662 +#define yyless(n) \
6663 + do \
6664 + { \
6665 + /* Undo effects of setting up yytext. */ \
6666 + yytext[yyleng] = yy_hold_char; \
6667 + yy_c_buf_p = yytext + n; \
6668 + yy_hold_char = *yy_c_buf_p; \
6669 + *yy_c_buf_p = '\0'; \
6670 + yyleng = n; \
6671 + } \
6672 + while ( 0 )
6673 +
6674 +
6675 +/* Internal utility routines. */
6676 +
6677 +#ifndef yytext_ptr
6678 +#ifdef YY_USE_PROTOS
6679 +static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
6680 +#else
6681 +static void yy_flex_strncpy( s1, s2, n )
6682 +char *s1;
6683 +yyconst char *s2;
6684 +int n;
6685 +#endif
6686 + {
6687 + register int i;
6688 + for ( i = 0; i < n; ++i )
6689 + s1[i] = s2[i];
6690 + }
6691 +#endif
6692 +
6693 +#ifdef YY_NEED_STRLEN
6694 +#ifdef YY_USE_PROTOS
6695 +static int yy_flex_strlen( yyconst char *s )
6696 +#else
6697 +static int yy_flex_strlen( s )
6698 +yyconst char *s;
6699 +#endif
6700 + {
6701 + register int n;
6702 + for ( n = 0; s[n]; ++n )
6703 + ;
6704 +
6705 + return n;
6706 + }
6707 +#endif
6708 +
6709 +
6710 +#ifdef YY_USE_PROTOS
6711 +static void *yy_flex_alloc( yy_size_t size )
6712 +#else
6713 +static void *yy_flex_alloc( size )
6714 +yy_size_t size;
6715 +#endif
6716 + {
6717 + return (void *) malloc( size );
6718 + }
6719 +
6720 +#ifdef YY_USE_PROTOS
6721 +static void *yy_flex_realloc( void *ptr, yy_size_t size )
6722 +#else
6723 +static void *yy_flex_realloc( ptr, size )
6724 +void *ptr;
6725 +yy_size_t size;
6726 +#endif
6727 + {
6728 + /* The cast to (char *) in the following accommodates both
6729 + * implementations that use char* generic pointers, and those
6730 + * that use void* generic pointers. It works with the latter
6731 + * because both ANSI C and C++ allow castless assignment from
6732 + * any pointer type to void*, and deal with argument conversions
6733 + * as though doing an assignment.
6734 + */
6735 + return (void *) realloc( (char *) ptr, size );
6736 + }
6737 +
6738 +#ifdef YY_USE_PROTOS
6739 +static void yy_flex_free( void *ptr )
6740 +#else
6741 +static void yy_flex_free( ptr )
6742 +void *ptr;
6743 +#endif
6744 + {
6745 + free( ptr );
6746 + }
6747 +
6748 +#if YY_MAIN
6749 +int main()
6750 + {
6751 + yylex();
6752 + return 0;
6753 + }
6754 +#endif
6755 +#line 92 "quote_fmt_lex.l"
6756 +
6757 diff -urN empty/quote_fmt_parse.c src/quote_fmt_parse.c
6758 --- empty/quote_fmt_parse.c Thu Jan 1 00:00:00 1970
6759 +++ src/quote_fmt_parse.c Sun May 12 00:04:36 2002
6760 @@ -0,0 +1,1821 @@
6761 +/* A Bison parser, made from /src/sylpheed-claws-w32/sylpheed-claws/src/quote_fmt_parse.y
6762 + by GNU bison 1.31. */
6763 +
6764 +#define YYBISON 1 /* Identify Bison output. */
6765 +
6766 +# define SHOW_NEWSGROUPS 257
6767 +# define SHOW_DATE 258
6768 +# define SHOW_FROM 259
6769 +# define SHOW_FULLNAME 260
6770 +# define SHOW_FIRST_NAME 261
6771 +# define SHOW_LAST_NAME 262
6772 +# define SHOW_SENDER_INITIAL 263
6773 +# define SHOW_SUBJECT 264
6774 +# define SHOW_TO 265
6775 +# define SHOW_MESSAGEID 266
6776 +# define SHOW_PERCENT 267
6777 +# define SHOW_CC 268
6778 +# define SHOW_REFERENCES 269
6779 +# define SHOW_MESSAGE 270
6780 +# define SHOW_QUOTED_MESSAGE 271
6781 +# define SHOW_BACKSLASH 272
6782 +# define SHOW_TAB 273
6783 +# define SHOW_QUOTED_MESSAGE_NO_SIGNATURE 274
6784 +# define SHOW_MESSAGE_NO_SIGNATURE 275
6785 +# define SHOW_EOL 276
6786 +# define SHOW_QUESTION_MARK 277
6787 +# define SHOW_PIPE 278
6788 +# define SHOW_OPARENT 279
6789 +# define SHOW_CPARENT 280
6790 +# define QUERY_DATE 281
6791 +# define QUERY_FROM 282
6792 +# define QUERY_FULLNAME 283
6793 +# define QUERY_SUBJECT 284
6794 +# define QUERY_TO 285
6795 +# define QUERY_NEWSGROUPS 286
6796 +# define QUERY_MESSAGEID 287
6797 +# define QUERY_CC 288
6798 +# define QUERY_REFERENCES 289
6799 +# define INSERT_FILE 290
6800 +# define INSERT_PROGRAMOUTPUT 291
6801 +# define OPARENT 292
6802 +# define CPARENT 293
6803 +# define CHARACTER 294
6804 +# define SHOW_DATE_EXPR 295
6805 +
6806 +#line 1 "quote_fmt_parse.y"
6807 +
6808 +
6809 +#include "defs.h"
6810 +
6811 +#include <glib.h>
6812 +#include <ctype.h>
6813 +
6814 +#include "procmsg.h"
6815 +#include "procmime.h"
6816 +#include "utils.h"
6817 +#include "intl.h"
6818 +
6819 +#include "quote_fmt.h"
6820 +#include "quote_fmt_lex.h"
6821 +
6822 +/* decl */
6823 +/*
6824 +flex quote_fmt.l
6825 +bison -p quote_fmt quote_fmt.y
6826 +*/
6827 +
6828 +int yylex(void);
6829 +
6830 +static MsgInfo *msginfo = NULL;
6831 +static gboolean *visible = NULL;
6832 +static gint maxsize = 0;
6833 +static gint stacksize = 0;
6834 +
6835 +static gchar *buffer = NULL;
6836 +static gint bufmax = 0;
6837 +static gint bufsize = 0;
6838 +static const gchar *quote_str = NULL;
6839 +static const gchar *body = NULL;
6840 +static gint error = 0;
6841 +
6842 +static void add_visibility(gboolean val)
6843 +{
6844 + stacksize++;
6845 + if (maxsize < stacksize) {
6846 + maxsize += 128;
6847 + visible = g_realloc(visible, maxsize * sizeof(gboolean));
6848 + if (visible == NULL)
6849 + maxsize = 0;
6850 + }
6851 +
6852 + visible[stacksize - 1] = val;
6853 +}
6854 +
6855 +static void remove_visibility(void)
6856 +{
6857 + stacksize--;
6858 +}
6859 +
6860 +static void add_buffer(const gchar *s)
6861 +{
6862 + gint len;
6863 +
6864 + len = strlen(s);
6865 + if (bufsize + len + 1 > bufmax) {
6866 + if (bufmax == 0)
6867 + bufmax = 128;
6868 + while (bufsize + len + 1 > bufmax)
6869 + bufmax *= 2;
6870 + buffer = g_realloc(buffer, bufmax);
6871 + }
6872 + strcpy(buffer + bufsize, s);
6873 + bufsize += len;
6874 +}
6875 +
6876 +static void flush_buffer(void)
6877 +{
6878 + if (buffer != NULL)
6879 + *buffer = '\0';
6880 + bufsize = 0;
6881 +}
6882 +
6883 +gchar *quote_fmt_get_buffer(void)
6884 +{
6885 + if (error != 0)
6886 + return NULL;
6887 + else
6888 + return buffer;
6889 +}
6890 +
6891 +#define INSERT(buf) \
6892 + if (stacksize != 0 && visible[stacksize - 1]) \
6893 + add_buffer(buf)
6894 +
6895 +#define INSERT_CHARACTER(chr) \
6896 + if (stacksize != 0 && visible[stacksize - 1]) { \
6897 + gchar tmp[2]; \
6898 + tmp[0] = (chr); \
6899 + tmp[1] = '\0'; \
6900 + add_buffer(tmp); \
6901 + }
6902 +
6903 +void quote_fmt_init(MsgInfo *info, const gchar *my_quote_str,
6904 + const gchar *my_body)
6905 +{
6906 + quote_str = my_quote_str;
6907 + body = my_body;
6908 + msginfo = info;
6909 + stacksize = 0;
6910 + add_visibility(TRUE);
6911 + if (buffer != NULL)
6912 + *buffer = 0;
6913 + bufsize = 0;
6914 + error = 0;
6915 +}
6916 +
6917 +void quote_fmterror(char *str)
6918 +{
6919 + g_warning(_("Error: %s\n"), str);
6920 + error = 1;
6921 +}
6922 +
6923 +int quote_fmtwrap(void)
6924 +{
6925 + return 1;
6926 +}
6927 +
6928 +static int isseparator(char ch)
6929 +{
6930 + return isspace(ch) || ch == '.' || ch == '-';
6931 +}
6932 +
6933 +#line 128 "quote_fmt_parse.y"
6934 +#ifndef YYSTYPE
6935 +typedef union {
6936 + char chr;
6937 + char str[256];
6938 +} yystype;
6939 +# define YYSTYPE yystype
6940 +#endif
6941 +#ifndef YYDEBUG
6942 +# define YYDEBUG 0
6943 +#endif
6944 +
6945 +
6946 +
6947 +#define YYFINAL 94
6948 +#define YYFLAG -32768
6949 +#define YYNTBASE 42
6950 +
6951 +/* YYTRANSLATE(YYLEX) -- Bison token number corresponding to YYLEX. */
6952 +#define YYTRANSLATE(x) ((unsigned)(x) <= 295 ? yytranslate[x] : 59)
6953 +
6954 +/* YYTRANSLATE[YYLEX] -- Bison token number corresponding to YYLEX. */
6955 +static const char yytranslate[] =
6956 +{
6957 + 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
6958 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
6959 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
6960 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
6961 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
6962 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
6963 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
6964 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
6965 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
6966 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
6967 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
6968 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
6969 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
6970 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
6971 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
6972 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
6973 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
6974 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
6975 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
6976 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
6977 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
6978 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
6979 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
6980 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
6981 + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
6982 + 2, 2, 2, 2, 2, 2, 1, 3, 4, 5,
6983 + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
6984 + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
6985 + 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
6986 + 36, 37, 38, 39, 40, 41
6987 +};
6988 +
6989 +#if YYDEBUG
6990 +static const short yyprhs[] =
6991 +{
6992 + 0, 0, 2, 5, 7, 9, 11, 13, 15, 17,
6993 + 19, 22, 24, 29, 31, 33, 35, 37, 39, 41,
6994 + 43, 45, 47, 49, 51, 53, 55, 57, 59, 61,
6995 + 63, 65, 67, 69, 71, 73, 75, 76, 82, 83,
6996 + 89, 90, 96, 97, 103, 104, 110, 111, 117, 118,
6997 + 124, 125, 131, 132, 138, 143
6998 +};
6999 +static const short yyrhs[] =
7000 +{
7001 + 43, 0, 44, 43, 0, 44, 0, 47, 0, 45,
7002 + 0, 48, 0, 58, 0, 40, 0, 40, 0, 46,
7003 + 40, 0, 3, 0, 41, 38, 46, 39, 0, 4,
7004 + 0, 5, 0, 6, 0, 7, 0, 8, 0, 9,
7005 + 0, 10, 0, 11, 0, 12, 0, 13, 0, 14,
7006 + 0, 15, 0, 16, 0, 17, 0, 21, 0, 20,
7007 + 0, 18, 0, 19, 0, 22, 0, 23, 0, 24,
7008 + 0, 25, 0, 26, 0, 0, 27, 49, 38, 42,
7009 + 39, 0, 0, 28, 50, 38, 42, 39, 0, 0,
7010 + 29, 51, 38, 42, 39, 0, 0, 30, 52, 38,
7011 + 42, 39, 0, 0, 31, 53, 38, 42, 39, 0,
7012 + 0, 32, 54, 38, 42, 39, 0, 0, 33, 55,
7013 + 38, 42, 39, 0, 0, 34, 56, 38, 42, 39,
7014 + 0, 0, 35, 57, 38, 42, 39, 0, 36, 38,
7015 + 46, 39, 0, 37, 38, 46, 39, 0
7016 +};
7017 +
7018 +#endif
7019 +
7020 +#if YYDEBUG
7021 +/* YYRLINE[YYN] -- source line where rule number YYN was defined. */
7022 +static const short yyrline[] =
7023 +{
7024 + 0, 156, 159, 161, 163, 165, 169, 170, 172, 176,
7025 + 182, 189, 195, 207, 212, 217, 222, 238, 269, 296,
7026 + 301, 306, 311, 315, 320, 325, 347, 371, 395, 421,
7027 + 425, 429, 433, 437, 441, 445, 450, 450, 459, 459,
7028 + 467, 467, 475, 475, 483, 483, 491, 491, 499, 499,
7029 + 507, 507, 515, 515, 524, 539
7030 +};
7031 +#endif
7032 +
7033 +
7034 +#if (YYDEBUG) || defined YYERROR_VERBOSE
7035 +
7036 +/* YYTNAME[TOKEN_NUM] -- String name of the token TOKEN_NUM. */
7037 +static const char *const yytname[] =
7038 +{
7039 + "$", "error", "$undefined.", "SHOW_NEWSGROUPS", "SHOW_DATE", "SHOW_FROM",
7040 + "SHOW_FULLNAME", "SHOW_FIRST_NAME", "SHOW_LAST_NAME",
7041 + "SHOW_SENDER_INITIAL", "SHOW_SUBJECT", "SHOW_TO", "SHOW_MESSAGEID",
7042 + "SHOW_PERCENT", "SHOW_CC", "SHOW_REFERENCES", "SHOW_MESSAGE",
7043 + "SHOW_QUOTED_MESSAGE", "SHOW_BACKSLASH", "SHOW_TAB",
7044 + "SHOW_QUOTED_MESSAGE_NO_SIGNATURE", "SHOW_MESSAGE_NO_SIGNATURE",
7045 + "SHOW_EOL", "SHOW_QUESTION_MARK", "SHOW_PIPE", "SHOW_OPARENT",
7046 + "SHOW_CPARENT", "QUERY_DATE", "QUERY_FROM", "QUERY_FULLNAME",
7047 + "QUERY_SUBJECT", "QUERY_TO", "QUERY_NEWSGROUPS", "QUERY_MESSAGEID",
7048 + "QUERY_CC", "QUERY_REFERENCES", "INSERT_FILE", "INSERT_PROGRAMOUTPUT",
7049 + "OPARENT", "CPARENT", "CHARACTER", "SHOW_DATE_EXPR", "quote_fmt",
7050 + "character_or_special_or_insert_or_query_list",
7051 + "character_or_special_or_insert_or_query", "character", "string",
7052 + "special", "query", "@1", "@2", "@3", "@4", "@5", "@6", "@7", "@8",
7053 + "@9", "insert", NULL
7054 +};
7055 +#endif
7056 +
7057 +/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
7058 +static const short yyr1[] =
7059 +{
7060 + 0, 42, 43, 43, 44, 44, 44, 44, 45, 46,
7061 + 46, 47, 47, 47, 47, 47, 47, 47, 47, 47,
7062 + 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
7063 + 47, 47, 47, 47, 47, 47, 49, 48, 50, 48,
7064 + 51, 48, 52, 48, 53, 48, 54, 48, 55, 48,
7065 + 56, 48, 57, 48, 58, 58
7066 +};
7067 +
7068 +/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
7069 +static const short yyr2[] =
7070 +{
7071 + 0, 1, 2, 1, 1, 1, 1, 1, 1, 1,
7072 + 2, 1, 4, 1, 1, 1, 1, 1, 1, 1,
7073 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
7074 + 1, 1, 1, 1, 1, 1, 0, 5, 0, 5,
7075 + 0, 5, 0, 5, 0, 5, 0, 5, 0, 5,
7076 + 0, 5, 0, 5, 4, 4
7077 +};
7078 +
7079 +/* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE
7080 + doesn't specify something else to do. Zero means the default is an
7081 + error. */
7082 +static const short yydefact[] =
7083 +{
7084 + 0, 11, 13, 14, 15, 16, 17, 18, 19, 20,
7085 + 21, 22, 23, 24, 25, 26, 29, 30, 28, 27,
7086 + 31, 32, 33, 34, 35, 36, 38, 40, 42, 44,
7087 + 46, 48, 50, 52, 0, 0, 8, 0, 1, 3,
7088 + 5, 4, 6, 7, 0, 0, 0, 0, 0, 0,
7089 + 0, 0, 0, 0, 0, 0, 2, 0, 0, 0,
7090 + 0, 0, 0, 0, 0, 0, 9, 0, 0, 0,
7091 + 0, 0, 0, 0, 0, 0, 0, 0, 0, 54,
7092 + 10, 55, 12, 37, 39, 41, 43, 45, 47, 49,
7093 + 51, 53, 0, 0, 0
7094 +};
7095 +
7096 +static const short yydefgoto[] =
7097 +{
7098 + 70, 38, 39, 40, 67, 41, 42, 44, 45, 46,
7099 + 47, 48, 49, 50, 51, 52, 43
7100 +};
7101 +
7102 +static const short yypact[] =
7103 +{
7104 + -2,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
7105 + -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
7106 + -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
7107 + -32768,-32768,-32768,-32768, 8, 9,-32768, 10,-32768, -2,
7108 + -32768,-32768,-32768,-32768, 11, 12, 13, 14, 15, 16,
7109 + 17, 18, 19, 26, 26, 26,-32768, -2, -2, -2,
7110 + -2, -2, -2, -2, -2, -2,-32768, -3, 1, 3,
7111 + 28, 29, 30, 31, 32, 33, 34, 35, 36,-32768,
7112 + -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
7113 + -32768,-32768, 76, 77,-32768
7114 +};
7115 +
7116 +static const short yypgoto[] =
7117 +{
7118 + 0, 39,-32768,-32768, -10,-32768,-32768,-32768,-32768,-32768,
7119 + -32768,-32768,-32768,-32768,-32768,-32768,-32768
7120 +};
7121 +
7122 +
7123 +#define YYLAST 78
7124 +
7125 +
7126 +static const short yytable[] =
7127 +{
7128 + 92, 1, 2, 3, 4, 5, 6, 7, 8, 9,
7129 + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
7130 + 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
7131 + 30, 31, 32, 33, 34, 35, 79, 80, 36, 37,
7132 + 81, 80, 82, 80, 68, 69, 53, 54, 55, 57,
7133 + 58, 59, 60, 61, 62, 63, 64, 65, 71, 72,
7134 + 73, 74, 75, 76, 77, 78, 66, 83, 84, 85,
7135 + 86, 87, 88, 89, 90, 91, 93, 94, 56
7136 +};
7137 +
7138 +static const short yycheck[] =
7139 +{
7140 + 0, 3, 4, 5, 6, 7, 8, 9, 10, 11,
7141 + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
7142 + 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
7143 + 32, 33, 34, 35, 36, 37, 39, 40, 40, 41,
7144 + 39, 40, 39, 40, 54, 55, 38, 38, 38, 38,
7145 + 38, 38, 38, 38, 38, 38, 38, 38, 58, 59,
7146 + 60, 61, 62, 63, 64, 65, 40, 39, 39, 39,
7147 + 39, 39, 39, 39, 39, 39, 0, 0, 39
7148 +};
7149 +/* -*-C-*- Note some compilers choke on comments on `#line' lines. */
7150 +#line 3 "/usr/share/bison/bison.simple"
7151 +
7152 +/* Skeleton output parser for bison,
7153 + Copyright (C) 1984, 1989, 1990, 2000, 2001 Free Software Foundation, Inc.
7154 +
7155 + This program is free software; you can redistribute it and/or modify
7156 + it under the terms of the GNU General Public License as published by
7157 + the Free Software Foundation; either version 2, or (at your option)
7158 + any later version.
7159 +
7160 + This program is distributed in the hope that it will be useful,
7161 + but WITHOUT ANY WARRANTY; without even the implied warranty of
7162 + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
7163 + GNU General Public License for more details.
7164 +
7165 + You should have received a copy of the GNU General Public License
7166 + along with this program; if not, write to the Free Software
7167 + Foundation, Inc., 59 Temple Place - Suite 330,
7168 + Boston, MA 02111-1307, USA. */
7169 +
7170 +/* As a special exception, when this file is copied by Bison into a
7171 + Bison output file, you may use that output file without restriction.
7172 + This special exception was added by the Free Software Foundation
7173 + in version 1.24 of Bison. */
7174 +
7175 +/* This is the parser code that is written into each bison parser when
7176 + the %semantic_parser declaration is not specified in the grammar.
7177 + It was written by Richard Stallman by simplifying the hairy parser
7178 + used when %semantic_parser is specified. */
7179 +
7180 +/* All symbols defined below should begin with yy or YY, to avoid
7181 + infringing on user name space. This should be done even for local
7182 + variables, as they might otherwise be expanded by user macros.
7183 + There are some unavoidable exceptions within include files to
7184 + define necessary library symbols; they are noted "INFRINGES ON
7185 + USER NAME SPACE" below. */
7186 +
7187 +#ifdef __cplusplus
7188 +# define YYSTD(x) std::x
7189 +#else
7190 +# define YYSTD(x) x
7191 +#endif
7192 +
7193 +#if ! defined (yyoverflow) || defined (YYERROR_VERBOSE)
7194 +
7195 +/* The parser invokes alloca or malloc; define the necessary symbols. */
7196 +
7197 +# if YYSTACK_USE_ALLOCA
7198 +# define YYSTACK_ALLOC alloca
7199 +# define YYSIZE_T YYSTD (size_t)
7200 +# else
7201 +# ifndef YYSTACK_USE_ALLOCA
7202 +# if defined (alloca) || defined (_ALLOCA_H)
7203 +# define YYSTACK_ALLOC alloca
7204 +# define YYSIZE_T YYSTD (size_t)
7205 +# else
7206 +# ifdef __GNUC__
7207 +# define YYSTACK_ALLOC __builtin_alloca
7208 +# endif
7209 +# endif
7210 +# endif
7211 +# endif
7212 +
7213 +# ifdef YYSTACK_ALLOC
7214 + /* Pacify GCC's `empty if-body' warning. */
7215 +# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
7216 +# else
7217 +# ifdef __cplusplus
7218 +# include <cstdlib> /* INFRINGES ON USER NAME SPACE */
7219 +# define YYSIZE_T std::size_t
7220 +# else
7221 +# ifdef __STDC__
7222 +# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
7223 +# define YYSIZE_T size_t
7224 +# endif
7225 +# endif
7226 +# define YYSTACK_ALLOC YYSTD (malloc)
7227 +# define YYSTACK_FREE YYSTD (free)
7228 +# endif
7229 +
7230 +/* A type that is properly aligned for any stack member. */
7231 +union yyalloc
7232 +{
7233 + short yyss;
7234 + YYSTYPE yyvs;
7235 +# if YYLSP_NEEDED
7236 + YYLTYPE yyls;
7237 +# endif
7238 +};
7239 +
7240 +/* The size of the maximum gap between one aligned stack and the next. */
7241 +# define YYSTACK_GAP_MAX (sizeof (union yyalloc) - 1)
7242 +
7243 +/* The size of an array large to enough to hold all stacks, each with
7244 + N elements. */
7245 +# if YYLSP_NEEDED
7246 +# define YYSTACK_BYTES(N) \
7247 + ((N) * (sizeof (short) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \
7248 + + 2 * YYSTACK_GAP_MAX)
7249 +# else
7250 +# define YYSTACK_BYTES(N) \
7251 + ((N) * (sizeof (short) + sizeof (YYSTYPE)) \
7252 + + YYSTACK_GAP_MAX)
7253 +# endif
7254 +
7255 +/* Relocate the TYPE STACK from its old location to the new one. The
7256 + local variables YYSIZE and YYSTACKSIZE give the old and new number of
7257 + elements in the stack, and YYPTR gives the new location of the
7258 + stack. Advance YYPTR to a properly aligned location for the next
7259 + stack. */
7260 +# define YYSTACK_RELOCATE(Type, Stack) \
7261 + do \
7262 + { \
7263 + YYSIZE_T yynewbytes; \
7264 + yymemcpy ((char *) yyptr, (char *) (Stack), \
7265 + yysize * (YYSIZE_T) sizeof (Type)); \
7266 + Stack = &yyptr->Stack; \
7267 + yynewbytes = yystacksize * sizeof (Type) + YYSTACK_GAP_MAX; \
7268 + yyptr += yynewbytes / sizeof (*yyptr); \
7269 + } \
7270 + while (0)
7271 +
7272 +#endif /* ! defined (yyoverflow) || defined (YYERROR_VERBOSE) */
7273 +
7274 +
7275 +#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
7276 +# define YYSIZE_T __SIZE_TYPE__
7277 +#endif
7278 +#if ! defined (YYSIZE_T) && defined (size_t)
7279 +# define YYSIZE_T size_t
7280 +#endif
7281 +#if ! defined (YYSIZE_T)
7282 +# ifdef __cplusplus
7283 +# include <cstddef> /* INFRINGES ON USER NAME SPACE */
7284 +# define YYSIZE_T std::size_t
7285 +# else
7286 +# ifdef __STDC__
7287 +# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
7288 +# define YYSIZE_T size_t
7289 +# endif
7290 +# endif
7291 +#endif
7292 +#if ! defined (YYSIZE_T)
7293 +# define YYSIZE_T unsigned int
7294 +#endif
7295 +
7296 +#define yyerrok (yyerrstatus = 0)
7297 +#define yyclearin (yychar = YYEMPTY)
7298 +#define YYEMPTY -2
7299 +#define YYEOF 0
7300 +#define YYACCEPT goto yyacceptlab
7301 +#define YYABORT goto yyabortlab
7302 +#define YYERROR goto yyerrlab1
7303 +/* Like YYERROR except do call yyerror. This remains here temporarily
7304 + to ease the transition to the new meaning of YYERROR, for GCC.
7305 + Once GCC version 2 has supplanted version 1, this can go. */
7306 +#define YYFAIL goto yyerrlab
7307 +#define YYRECOVERING() (!!yyerrstatus)
7308 +#define YYBACKUP(Token, Value) \
7309 +do \
7310 + if (yychar == YYEMPTY && yylen == 1) \
7311 + { \
7312 + yychar = (Token); \
7313 + yylval = (Value); \
7314 + yychar1 = YYTRANSLATE (yychar); \
7315 + YYPOPSTACK; \
7316 + goto yybackup; \
7317 + } \
7318 + else \
7319 + { \
7320 + yyerror ("syntax error: cannot back up"); \
7321 + YYERROR; \
7322 + } \
7323 +while (0)
7324 +
7325 +#define YYTERROR 1
7326 +#define YYERRCODE 256
7327 +
7328 +
7329 +/* YYLLOC_DEFAULT -- Compute the default location (before the actions
7330 + are run).
7331 +
7332 + When YYLLOC_DEFAULT is run, CURRENT is set the location of the
7333 + first token. By default, to implement support for ranges, extend
7334 + its range to the last symbol. */
7335 +
7336 +#ifndef YYLLOC_DEFAULT
7337 +# define YYLLOC_DEFAULT(Current, Rhs, N) \
7338 + Current.last_line = Rhs[N].last_line; \
7339 + Current.last_column = Rhs[N].last_column;
7340 +#endif
7341 +
7342 +
7343 +/* YYLEX -- calling `yylex' with the right arguments. */
7344 +
7345 +#if YYPURE
7346 +# if YYLSP_NEEDED
7347 +# ifdef YYLEX_PARAM
7348 +# define YYLEX yylex (&yylval, &yylloc, YYLEX_PARAM)
7349 +# else
7350 +# define YYLEX yylex (&yylval, &yylloc)
7351 +# endif
7352 +# else /* !YYLSP_NEEDED */
7353 +# ifdef YYLEX_PARAM
7354 +# define YYLEX yylex (&yylval, YYLEX_PARAM)
7355 +# else
7356 +# define YYLEX yylex (&yylval)
7357 +# endif
7358 +# endif /* !YYLSP_NEEDED */
7359 +#else /* !YYPURE */
7360 +# define YYLEX yylex ()
7361 +#endif /* !YYPURE */
7362 +
7363 +
7364 +/* Enable debugging if requested. */
7365 +#if YYDEBUG
7366 +
7367 +# ifndef YYFPRINTF
7368 +# ifdef __cplusplus
7369 +# include <cstdio> /* INFRINGES ON USER NAME SPACE */
7370 +# else
7371 +# include <stdio.h> /* INFRINGES ON USER NAME SPACE */
7372 +# endif
7373 +# define YYFPRINTF YYSTD (fprintf)
7374 +# endif
7375 +
7376 +# define YYDPRINTF(Args) \
7377 +do { \
7378 + if (yydebug) \
7379 + YYFPRINTF Args; \
7380 +} while (0)
7381 +/* Nonzero means print parse trace. [The following comment makes no
7382 + sense to me. Could someone clarify it? --akim] Since this is
7383 + uninitialized, it does not stop multiple parsers from coexisting.
7384 + */
7385 +int yydebug;
7386 +#else /* !YYDEBUG */
7387 +# define YYDPRINTF(Args)
7388 +#endif /* !YYDEBUG */
7389 +
7390 +/* YYINITDEPTH -- initial size of the parser's stacks. */
7391 +#ifndef YYINITDEPTH
7392 +# define YYINITDEPTH 200
7393 +#endif
7394 +
7395 +/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
7396 + if the built-in stack extension method is used).
7397 +
7398 + Do not make this value too large; the results are undefined if
7399 + SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
7400 + evaluated with infinite-precision integer arithmetic. */
7401 +
7402 +#if YYMAXDEPTH == 0
7403 +# undef YYMAXDEPTH
7404 +#endif
7405 +
7406 +#ifndef YYMAXDEPTH
7407 +# define YYMAXDEPTH 10000
7408 +#endif
7409 +\f
7410 +#if ! defined (yyoverflow) && ! defined (yymemcpy)
7411 +# if __GNUC__ > 1 /* GNU C and GNU C++ define this. */
7412 +# define yymemcpy __builtin_memcpy
7413 +# else /* not GNU C or C++ */
7414 +
7415 +/* This is the most reliable way to avoid incompatibilities
7416 + in available built-in functions on various systems. */
7417 +static void
7418 +# if defined (__STDC__) || defined (__cplusplus)
7419 +yymemcpy (char *yyto, const char *yyfrom, YYSIZE_T yycount)
7420 +# else
7421 +yymemcpy (yyto, yyfrom, yycount)
7422 + char *yyto;
7423 + const char *yyfrom;
7424 + YYSIZE_T yycount;
7425 +# endif
7426 +{
7427 + register const char *yyf = yyfrom;
7428 + register char *yyt = yyto;
7429 + register YYSIZE_T yyi = yycount;
7430 +
7431 + while (yyi-- != 0)
7432 + *yyt++ = *yyf++;
7433 +}
7434 +# endif
7435 +#endif
7436 +
7437 +#ifdef YYERROR_VERBOSE
7438 +
7439 +# ifndef yystrlen
7440 +# if defined (__GLIBC__) && defined (_STRING_H)
7441 +# define yystrlen strlen
7442 +# else
7443 +/* Return the length of YYSTR. */
7444 +static YYSIZE_T
7445 +# if defined (__STDC__) || defined (__cplusplus)
7446 +yystrlen (const char *yystr)
7447 +# else
7448 +yystrlen (yystr)
7449 + const char *yystr;
7450 +# endif
7451 +{
7452 + register const char *yys = yystr;
7453 +
7454 + while (*yys++ != '\0')
7455 + continue;
7456 +
7457 + return yys - yystr - 1;
7458 +}
7459 +# endif
7460 +# endif
7461 +
7462 +# ifndef yystpcpy
7463 +# if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
7464 +# define yystpcpy stpcpy
7465 +# else
7466 +/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
7467 + YYDEST. */
7468 +static char *
7469 +# if defined (__STDC__) || defined (__cplusplus)
7470 +yystpcpy (char *yydest, const char *yysrc)
7471 +# else
7472 +yystpcpy (yydest, yysrc)
7473 + char *yydest;
7474 + const char *yysrc;
7475 +# endif
7476 +{
7477 + register char *yyd = yydest;
7478 + register const char *yys = yysrc;
7479 +
7480 + while ((*yyd++ = *yys++) != '\0')
7481 + continue;
7482 +
7483 + return yyd - 1;
7484 +}
7485 +# endif
7486 +# endif
7487 +#endif
7488 +\f
7489 +#line 341 "/usr/share/bison/bison.simple"
7490 +
7491 +
7492 +/* The user can define YYPARSE_PARAM as the name of an argument to be passed
7493 + into yyparse. The argument should have type void *.
7494 + It should actually point to an object.
7495 + Grammar actions can access the variable by casting it
7496 + to the proper pointer type. */
7497 +
7498 +#ifdef YYPARSE_PARAM
7499 +# ifdef __cplusplus
7500 +# define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
7501 +# define YYPARSE_PARAM_DECL
7502 +# else /* !__cplusplus */
7503 +# define YYPARSE_PARAM_ARG YYPARSE_PARAM
7504 +# define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
7505 +# endif /* !__cplusplus */
7506 +#else /* !YYPARSE_PARAM */
7507 +# define YYPARSE_PARAM_ARG
7508 +# define YYPARSE_PARAM_DECL
7509 +#endif /* !YYPARSE_PARAM */
7510 +
7511 +/* Prevent warning if -Wstrict-prototypes. */
7512 +#ifdef __GNUC__
7513 +# ifdef YYPARSE_PARAM
7514 +int yyparse (void *);
7515 +# else
7516 +int yyparse (void);
7517 +# endif
7518 +#endif
7519 +
7520 +/* YY_DECL_VARIABLES -- depending whether we use a pure parser,
7521 + variables are global, or local to YYPARSE. */
7522 +
7523 +#define YY_DECL_NON_LSP_VARIABLES \
7524 +/* The lookahead symbol. */ \
7525 +int yychar; \
7526 + \
7527 +/* The semantic value of the lookahead symbol. */ \
7528 +YYSTYPE yylval; \
7529 + \
7530 +/* Number of parse errors so far. */ \
7531 +int yynerrs;
7532 +
7533 +#if YYLSP_NEEDED
7534 +# define YY_DECL_VARIABLES \
7535 +YY_DECL_NON_LSP_VARIABLES \
7536 + \
7537 +/* Location data for the lookahead symbol. */ \
7538 +YYLTYPE yylloc;
7539 +#else
7540 +# define YY_DECL_VARIABLES \
7541 +YY_DECL_NON_LSP_VARIABLES
7542 +#endif
7543 +
7544 +
7545 +/* If nonreentrant, generate the variables here. */
7546 +
7547 +#if !YYPURE
7548 +YY_DECL_VARIABLES
7549 +#endif /* !YYPURE */
7550 +
7551 +int
7552 +yyparse (YYPARSE_PARAM_ARG)
7553 + YYPARSE_PARAM_DECL
7554 +{
7555 + /* If reentrant, generate the variables here. */
7556 +#if YYPURE
7557 + YY_DECL_VARIABLES
7558 +#endif /* !YYPURE */
7559 +
7560 + register int yystate;
7561 + register int yyn;
7562 + int yyresult;
7563 + /* Number of tokens to shift before error messages enabled. */
7564 + int yyerrstatus;
7565 + /* Lookahead token as an internal (translated) token number. */
7566 + int yychar1 = 0;
7567 +
7568 + /* Three stacks and their tools:
7569 + `yyss': related to states,
7570 + `yyvs': related to semantic values,
7571 + `yyls': related to locations.
7572 +
7573 + Refer to the stacks thru separate pointers, to allow yyoverflow
7574 + to reallocate them elsewhere. */
7575 +
7576 + /* The state stack. */
7577 + short yyssa[YYINITDEPTH];
7578 + short *yyss = yyssa;
7579 + register short *yyssp;
7580 +
7581 + /* The semantic value stack. */
7582 + YYSTYPE yyvsa[YYINITDEPTH];
7583 + YYSTYPE *yyvs = yyvsa;
7584 + register YYSTYPE *yyvsp;
7585 +
7586 +#if YYLSP_NEEDED
7587 + /* The location stack. */
7588 + YYLTYPE yylsa[YYINITDEPTH];
7589 + YYLTYPE *yyls = yylsa;
7590 + YYLTYPE *yylsp;
7591 +#endif
7592 +
7593 +#if YYLSP_NEEDED
7594 +# define YYPOPSTACK (yyvsp--, yyssp--, yylsp--)
7595 +#else
7596 +# define YYPOPSTACK (yyvsp--, yyssp--)
7597 +#endif
7598 +
7599 + YYSIZE_T yystacksize = YYINITDEPTH;
7600 +
7601 +
7602 + /* The variables used to return semantic value and location from the
7603 + action routines. */
7604 + YYSTYPE yyval;
7605 +#if YYLSP_NEEDED
7606 + YYLTYPE yyloc;
7607 +#endif
7608 +
7609 + /* When reducing, the number of symbols on the RHS of the reduced
7610 + rule. */
7611 + int yylen;
7612 +
7613 + YYDPRINTF ((stderr, "Starting parse\n"));
7614 +
7615 + yystate = 0;
7616 + yyerrstatus = 0;
7617 + yynerrs = 0;
7618 + yychar = YYEMPTY; /* Cause a token to be read. */
7619 +
7620 + /* Initialize stack pointers.
7621 + Waste one element of value and location stack
7622 + so that they stay on the same level as the state stack.
7623 + The wasted elements are never initialized. */
7624 +
7625 + yyssp = yyss;
7626 + yyvsp = yyvs;
7627 +#if YYLSP_NEEDED
7628 + yylsp = yyls;
7629 +#endif
7630 + goto yysetstate;
7631 +
7632 +/*------------------------------------------------------------.
7633 +| yynewstate -- Push a new state, which is found in yystate. |
7634 +`------------------------------------------------------------*/
7635 + yynewstate:
7636 + /* In all cases, when you get here, the value and location stacks
7637 + have just been pushed. so pushing a state here evens the stacks.
7638 + */
7639 + yyssp++;
7640 +
7641 + yysetstate:
7642 + *yyssp = yystate;
7643 +
7644 + if (yyssp >= yyss + yystacksize - 1)
7645 + {
7646 + /* Get the current used size of the three stacks, in elements. */
7647 + YYSIZE_T yysize = yyssp - yyss + 1;
7648 +
7649 +#ifdef yyoverflow
7650 + {
7651 + /* Give user a chance to reallocate the stack. Use copies of
7652 + these so that the &'s don't force the real ones into
7653 + memory. */
7654 + YYSTYPE *yyvs1 = yyvs;
7655 + short *yyss1 = yyss;
7656 +
7657 + /* Each stack pointer address is followed by the size of the
7658 + data in use in that stack, in bytes. */
7659 +# if YYLSP_NEEDED
7660 + YYLTYPE *yyls1 = yyls;
7661 + /* This used to be a conditional around just the two extra args,
7662 + but that might be undefined if yyoverflow is a macro. */
7663 + yyoverflow ("parser stack overflow",
7664 + &yyss1, yysize * sizeof (*yyssp),
7665 + &yyvs1, yysize * sizeof (*yyvsp),
7666 + &yyls1, yysize * sizeof (*yylsp),
7667 + &yystacksize);
7668 + yyls = yyls1;
7669 +# else
7670 + yyoverflow ("parser stack overflow",
7671 + &yyss1, yysize * sizeof (*yyssp),
7672 + &yyvs1, yysize * sizeof (*yyvsp),
7673 + &yystacksize);
7674 +# endif
7675 + yyss = yyss1;
7676 + yyvs = yyvs1;
7677 + }
7678 +#else /* no yyoverflow */
7679 + /* Extend the stack our own way. */
7680 + if (yystacksize >= YYMAXDEPTH)
7681 + goto yyoverflowlab;
7682 + yystacksize *= 2;
7683 + if (yystacksize > YYMAXDEPTH)
7684 + yystacksize = YYMAXDEPTH;
7685 +
7686 + {
7687 + short *yyss1 = yyss;
7688 + union yyalloc *yyptr =
7689 + (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
7690 + if (! yyptr)
7691 + goto yyoverflowlab;
7692 + YYSTACK_RELOCATE (short, yyss);
7693 + YYSTACK_RELOCATE (YYSTYPE, yyvs);
7694 +# if YYLSP_NEEDED
7695 + YYSTACK_RELOCATE (YYLTYPE, yyls);
7696 +# endif
7697 +# undef YYSTACK_RELOCATE
7698 + if (yyss1 != yyssa)
7699 + YYSTACK_FREE (yyss1);
7700 + }
7701 +#endif /* no yyoverflow */
7702 +
7703 + yyssp = yyss + yysize - 1;
7704 + yyvsp = yyvs + yysize - 1;
7705 +#if YYLSP_NEEDED
7706 + yylsp = yyls + yysize - 1;
7707 +#endif
7708 +
7709 + YYDPRINTF ((stderr, "Stack size increased to %lu\n",
7710 + (unsigned long int) yystacksize));
7711 +
7712 + if (yyssp >= yyss + yystacksize - 1)
7713 + YYABORT;
7714 + }
7715 +
7716 + YYDPRINTF ((stderr, "Entering state %d\n", yystate));
7717 +
7718 + goto yybackup;
7719 +
7720 +
7721 +/*-----------.
7722 +| yybackup. |
7723 +`-----------*/
7724 +yybackup:
7725 +
7726 +/* Do appropriate processing given the current state. */
7727 +/* Read a lookahead token if we need one and don't already have one. */
7728 +/* yyresume: */
7729 +
7730 + /* First try to decide what to do without reference to lookahead token. */
7731 +
7732 + yyn = yypact[yystate];
7733 + if (yyn == YYFLAG)
7734 + goto yydefault;
7735 +
7736 + /* Not known => get a lookahead token if don't already have one. */
7737 +
7738 + /* yychar is either YYEMPTY or YYEOF
7739 + or a valid token in external form. */
7740 +
7741 + if (yychar == YYEMPTY)
7742 + {
7743 + YYDPRINTF ((stderr, "Reading a token: "));
7744 + yychar = YYLEX;
7745 + }
7746 +
7747 + /* Convert token to internal form (in yychar1) for indexing tables with */
7748 +
7749 + if (yychar <= 0) /* This means end of input. */
7750 + {
7751 + yychar1 = 0;
7752 + yychar = YYEOF; /* Don't call YYLEX any more */
7753 +
7754 + YYDPRINTF ((stderr, "Now at end of input.\n"));
7755 + }
7756 + else
7757 + {
7758 + yychar1 = YYTRANSLATE (yychar);
7759 +
7760 +#if YYDEBUG
7761 + /* We have to keep this `#if YYDEBUG', since we use variables
7762 + which are defined only if `YYDEBUG' is set. */
7763 + if (yydebug)
7764 + {
7765 + YYFPRINTF (stderr, "Next token is %d (%s",
7766 + yychar, yytname[yychar1]);
7767 + /* Give the individual parser a way to print the precise
7768 + meaning of a token, for further debugging info. */
7769 +# ifdef YYPRINT
7770 + YYPRINT (stderr, yychar, yylval);
7771 +# endif
7772 + YYFPRINTF (stderr, ")\n");
7773 + }
7774 +#endif
7775 + }
7776 +
7777 + yyn += yychar1;
7778 + if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
7779 + goto yydefault;
7780 +
7781 + yyn = yytable[yyn];
7782 +
7783 + /* yyn is what to do for this token type in this state.
7784 + Negative => reduce, -yyn is rule number.
7785 + Positive => shift, yyn is new state.
7786 + New state is final state => don't bother to shift,
7787 + just return success.
7788 + 0, or most negative number => error. */
7789 +
7790 + if (yyn < 0)
7791 + {
7792 + if (yyn == YYFLAG)
7793 + goto yyerrlab;
7794 + yyn = -yyn;
7795 + goto yyreduce;
7796 + }
7797 + else if (yyn == 0)
7798 + goto yyerrlab;
7799 +
7800 + if (yyn == YYFINAL)
7801 + YYACCEPT;
7802 +
7803 + /* Shift the lookahead token. */
7804 + YYDPRINTF ((stderr, "Shifting token %d (%s), ",
7805 + yychar, yytname[yychar1]));
7806 +
7807 + /* Discard the token being shifted unless it is eof. */
7808 + if (yychar != YYEOF)
7809 + yychar = YYEMPTY;
7810 +
7811 + *++yyvsp = yylval;
7812 +#if YYLSP_NEEDED
7813 + *++yylsp = yylloc;
7814 +#endif
7815 +
7816 + /* Count tokens shifted since error; after three, turn off error
7817 + status. */
7818 + if (yyerrstatus)
7819 + yyerrstatus--;
7820 +
7821 + yystate = yyn;
7822 + goto yynewstate;
7823 +
7824 +
7825 +/*-----------------------------------------------------------.
7826 +| yydefault -- do the default action for the current state. |
7827 +`-----------------------------------------------------------*/
7828 +yydefault:
7829 + yyn = yydefact[yystate];
7830 + if (yyn == 0)
7831 + goto yyerrlab;
7832 + goto yyreduce;
7833 +
7834 +
7835 +/*-----------------------------.
7836 +| yyreduce -- Do a reduction. |
7837 +`-----------------------------*/
7838 +yyreduce:
7839 + /* yyn is the number of a rule to reduce with. */
7840 + yylen = yyr2[yyn];
7841 +
7842 + /* If YYLEN is nonzero, implement the default value of the action:
7843 + `$$ = $1'.
7844 +
7845 + Otherwise, the following line sets YYVAL to the semantic value of
7846 + the lookahead token. This behavior is undocumented and Bison
7847 + users should not rely upon it. Assigning to YYVAL
7848 + unconditionally makes the parser a bit smaller, and it avoids a
7849 + GCC warning that YYVAL may be used uninitialized. */
7850 + yyval = yyvsp[1-yylen];
7851 +
7852 +#if YYLSP_NEEDED
7853 + /* Similarly for the default location. Let the user run additional
7854 + commands if for instance locations are ranges. */
7855 + yyloc = yylsp[1-yylen];
7856 + YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
7857 +#endif
7858 +
7859 +#if YYDEBUG
7860 + /* We have to keep this `#if YYDEBUG', since we use variables which
7861 + are defined only if `YYDEBUG' is set. */
7862 + if (yydebug)
7863 + {
7864 + int yyi;
7865 +
7866 + YYFPRINTF (stderr, "Reducing via rule %d (line %d), ",
7867 + yyn, yyrline[yyn]);
7868 +
7869 + /* Print the symbols being reduced, and their result. */
7870 + for (yyi = yyprhs[yyn]; yyrhs[yyi] > 0; yyi++)
7871 + YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
7872 + YYFPRINTF (stderr, " -> %s\n", yytname[yyr1[yyn]]);
7873 + }
7874 +#endif
7875 +
7876 + switch (yyn) {
7877 +
7878 +case 5:
7879 +#line 166 "quote_fmt_parse.y"
7880 +{
7881 + INSERT_CHARACTER(yyvsp[0].chr);
7882 + }
7883 + break;
7884 +case 9:
7885 +#line 178 "quote_fmt_parse.y"
7886 +{
7887 + yyval.str[0] = yyvsp[0].chr;
7888 + yyval.str[1] = '\0';
7889 + }
7890 + break;
7891 +case 10:
7892 +#line 183 "quote_fmt_parse.y"
7893 +{
7894 + strcpy(yyval.str, yyvsp[-1].str);
7895 + yyval.str[strlen(yyval.str) + 1] = '\0';
7896 + yyval.str[strlen(yyval.str)] = yyvsp[0].chr;
7897 + }
7898 + break;
7899 +case 11:
7900 +#line 191 "quote_fmt_parse.y"
7901 +{
7902 + if (msginfo->newsgroups)
7903 + INSERT(msginfo->newsgroups);
7904 + }
7905 + break;
7906 +case 12:
7907 +#line 196 "quote_fmt_parse.y"
7908 +{
7909 + if (msginfo->date_t) {
7910 + char timef[128];
7911 + struct tm *lt;
7912 +
7913 + if (NULL != (lt = localtime(&msginfo->date_t))) {
7914 + strftime(timef, sizeof timef, yyvsp[-1].str, lt);
7915 + INSERT(timef);
7916 + }
7917 + }
7918 + }
7919 + break;
7920 +case 13:
7921 +#line 208 "quote_fmt_parse.y"
7922 +{
7923 + if (msginfo->date)
7924 + INSERT(msginfo->date);
7925 + }
7926 + break;
7927 +case 14:
7928 +#line 213 "quote_fmt_parse.y"
7929 +{
7930 + if (msginfo->from)
7931 + INSERT(msginfo->from);
7932 + }
7933 + break;
7934 +case 15:
7935 +#line 218 "quote_fmt_parse.y"
7936 +{
7937 + if (msginfo->fromname)
7938 + INSERT(msginfo->fromname);
7939 + }
7940 + break;
7941 +case 16:
7942 +#line 223 "quote_fmt_parse.y"
7943 +{
7944 + if (msginfo->fromname) {
7945 + gchar *p;
7946 + gchar *str;
7947 +
7948 + str = alloca(strlen(msginfo->fromname) + 1);
7949 + if (str != NULL) {
7950 + strcpy(str, msginfo->fromname);
7951 + p = str;
7952 + while (*p && !isspace(*p)) p++;
7953 + *p = '\0';
7954 + INSERT(str);
7955 + }
7956 + }
7957 + }
7958 + break;
7959 +case 17:
7960 +#line 239 "quote_fmt_parse.y"
7961 +{
7962 + /* This probably won't work together very well with Middle
7963 + names and the like - thth */
7964 + if (msginfo->fromname) {
7965 + gchar *p;
7966 + gchar *str;
7967 +
7968 + str = alloca(strlen(msginfo->fromname) + 1);
7969 + if (str != NULL) {
7970 + strcpy(str, msginfo->fromname);
7971 + p = str;
7972 + while (*p && !isspace(*p)) p++;
7973 + if (*p) {
7974 + /* We found a space. Get first none-space char and
7975 + insert rest of string from there. */
7976 + while (*p && isspace(*p)) p++;
7977 + if (*p) {
7978 + INSERT(p);
7979 + } else {
7980 + /* If there is no none-space char, just insert
7981 + whole fromname. */
7982 + INSERT(str);
7983 + }
7984 + } else {
7985 + /* If there is no space, just insert whole fromname. */
7986 + INSERT(str);
7987 + }
7988 + }
7989 + }
7990 + }
7991 + break;
7992 +case 18:
7993 +#line 270 "quote_fmt_parse.y"
7994 +{
7995 +#define MAX_SENDER_INITIAL 20
7996 + if (msginfo->fromname) {
7997 + gchar tmp[MAX_SENDER_INITIAL];
7998 + gchar *p;
7999 + gchar *cur;
8000 + gint len = 0;
8001 +
8002 + p = msginfo->fromname;
8003 + cur = tmp;
8004 + while (*p) {
8005 + if (*p && isalnum(*p)) {
8006 + *cur = toupper(*p);
8007 + cur++;
8008 + len++;
8009 + if (len >= MAX_SENDER_INITIAL - 1)
8010 + break;
8011 + } else
8012 + break;
8013 + while (*p && !isseparator(*p)) p++;
8014 + while (*p && isseparator(*p)) p++;
8015 + }
8016 + *cur = '\0';
8017 + INSERT(tmp);
8018 + }
8019 + }
8020 + break;
8021 +case 19:
8022 +#line 297 "quote_fmt_parse.y"
8023 +{
8024 + if (msginfo->subject)
8025 + INSERT(msginfo->subject);
8026 + }
8027 + break;
8028 +case 20:
8029 +#line 302 "quote_fmt_parse.y"
8030 +{
8031 + if (msginfo->to)
8032 + INSERT(msginfo->to);
8033 + }
8034 + break;
8035 +case 21:
8036 +#line 307 "quote_fmt_parse.y"
8037 +{
8038 + if (msginfo->msgid)
8039 + INSERT(msginfo->msgid);
8040 + }
8041 + break;
8042 +case 22:
8043 +#line 312 "quote_fmt_parse.y"
8044 +{
8045 + INSERT("%");
8046 + }
8047 + break;
8048 +case 23:
8049 +#line 316 "quote_fmt_parse.y"
8050 +{
8051 + if (msginfo->cc)
8052 + INSERT(msginfo->cc);
8053 + }
8054 + break;
8055 +case 24:
8056 +#line 321 "quote_fmt_parse.y"
8057 +{
8058 + /* if (msginfo->references)
8059 + INSERT(msginfo->references); */
8060 + }
8061 + break;
8062 +case 25:
8063 +#line 326 "quote_fmt_parse.y"
8064 +{
8065 + if (msginfo->folder) {
8066 + gchar buf[BUFFSIZE];
8067 + FILE *fp;
8068 +
8069 + if (body)
8070 + fp = str_open_as_stream(body);
8071 + else
8072 + fp = procmime_get_first_text_content(msginfo);
8073 +
8074 + if (fp == NULL)
8075 + g_warning(_("Can't get text part\n"));
8076 + else {
8077 + while (fgets(buf, sizeof(buf), fp) != NULL) {
8078 + strcrchomp(buf);
8079 + INSERT(buf);
8080 + }
8081 + fclose(fp);
8082 + }
8083 + }
8084 + }
8085 + break;
8086 +case 26:
8087 +#line 348 "quote_fmt_parse.y"
8088 +{
8089 + if (msginfo->folder) {
8090 + gchar buf[BUFFSIZE];
8091 + FILE *fp;
8092 +
8093 + if (body)
8094 + fp = str_open_as_stream(body);
8095 + else
8096 + fp = procmime_get_first_text_content(msginfo);
8097 +
8098 + if (fp == NULL)
8099 + g_warning(_("Can't get text part\n"));
8100 + else {
8101 + while (fgets(buf, sizeof(buf), fp) != NULL) {
8102 + strcrchomp(buf);
8103 + if (quote_str)
8104 + INSERT(quote_str);
8105 + INSERT(buf);
8106 + }
8107 + fclose(fp);
8108 + }
8109 + }
8110 + }
8111 + break;
8112 +case 27:
8113 +#line 372 "quote_fmt_parse.y"
8114 +{
8115 + if (msginfo->folder) {
8116 + gchar buf[BUFFSIZE];
8117 + FILE *fp;
8118 +
8119 + if (body)
8120 + fp = str_open_as_stream(body);
8121 + else
8122 + fp = procmime_get_first_text_content(msginfo);
8123 +
8124 + if (fp == NULL)
8125 + g_warning(_("Can't get text part\n"));
8126 + else {
8127 + while (fgets(buf, sizeof(buf), fp) != NULL) {
8128 + strcrchomp(buf);
8129 + if (strncmp(buf, "-- ", 3) == 0)
8130 + break;
8131 + INSERT(buf);
8132 + }
8133 + fclose(fp);
8134 + }
8135 + }
8136 + }
8137 + break;
8138 +case 28:
8139 +#line 396 "quote_fmt_parse.y"
8140 +{
8141 + if (msginfo->folder) {
8142 + gchar buf[BUFFSIZE];
8143 + FILE *fp;
8144 +
8145 + if (body)
8146 + fp = str_open_as_stream(body);
8147 + else
8148 + fp = procmime_get_first_text_content(msginfo);
8149 +
8150 + if (fp == NULL)
8151 + g_warning(_("Can't get text part\n"));
8152 + else {
8153 + while (fgets(buf, sizeof(buf), fp) != NULL) {
8154 + strcrchomp(buf);
8155 + if (strncmp(buf, "-- ", 3) == 0)
8156 + break;
8157 + if (quote_str)
8158 + INSERT(quote_str);
8159 + INSERT(buf);
8160 + }
8161 + fclose(fp);
8162 + }
8163 + }
8164 + }
8165 + break;
8166 +case 29:
8167 +#line 422 "quote_fmt_parse.y"
8168 +{
8169 + INSERT("\\");
8170 + }
8171 + break;
8172 +case 30:
8173 +#line 426 "quote_fmt_parse.y"
8174 +{
8175 + INSERT("\t");
8176 + }
8177 + break;
8178 +case 31:
8179 +#line 430 "quote_fmt_parse.y"
8180 +{
8181 + INSERT("\n");
8182 + }
8183 + break;
8184 +case 32:
8185 +#line 434 "quote_fmt_parse.y"
8186 +{
8187 + INSERT("?");
8188 + }
8189 + break;
8190 +case 33:
8191 +#line 438 "quote_fmt_parse.y"
8192 +{
8193 + INSERT("|");
8194 + }
8195 + break;
8196 +case 34:
8197 +#line 442 "quote_fmt_parse.y"
8198 +{
8199 + INSERT("{");
8200 + }
8201 + break;
8202 +case 35:
8203 +#line 446 "quote_fmt_parse.y"
8204 +{
8205 + INSERT("}");
8206 + }
8207 + break;
8208 +case 36:
8209 +#line 452 "quote_fmt_parse.y"
8210 +{
8211 + add_visibility(msginfo->date != NULL);
8212 + }
8213 + break;
8214 +case 37:
8215 +#line 456 "quote_fmt_parse.y"
8216 +{
8217 + remove_visibility();
8218 + }
8219 + break;
8220 +case 38:
8221 +#line 460 "quote_fmt_parse.y"
8222 +{
8223 + add_visibility(msginfo->from != NULL);
8224 + }
8225 + break;
8226 +case 39:
8227 +#line 464 "quote_fmt_parse.y"
8228 +{
8229 + remove_visibility();
8230 + }
8231 + break;
8232 +case 40:
8233 +#line 468 "quote_fmt_parse.y"
8234 +{
8235 + add_visibility(msginfo->fromname != NULL);
8236 + }
8237 + break;
8238 +case 41:
8239 +#line 472 "quote_fmt_parse.y"
8240 +{
8241 + remove_visibility();
8242 + }
8243 + break;
8244 +case 42:
8245 +#line 476 "quote_fmt_parse.y"
8246 +{
8247 + add_visibility(msginfo->subject != NULL);
8248 + }
8249 + break;
8250 +case 43:
8251 +#line 480 "quote_fmt_parse.y"
8252 +{
8253 + remove_visibility();
8254 + }
8255 + break;
8256 +case 44:
8257 +#line 484 "quote_fmt_parse.y"
8258 +{
8259 + add_visibility(msginfo->to != NULL);
8260 + }
8261 + break;
8262 +case 45:
8263 +#line 488 "quote_fmt_parse.y"
8264 +{
8265 + remove_visibility();
8266 + }
8267 + break;
8268 +case 46:
8269 +#line 492 "quote_fmt_parse.y"
8270 +{
8271 + add_visibility(msginfo->newsgroups != NULL);
8272 + }
8273 + break;
8274 +case 47:
8275 +#line 496 "quote_fmt_parse.y"
8276 +{
8277 + remove_visibility();
8278 + }
8279 + break;
8280 +case 48:
8281 +#line 500 "quote_fmt_parse.y"
8282 +{
8283 + add_visibility(msginfo->msgid != NULL);
8284 + }
8285 + break;
8286 +case 49:
8287 +#line 504 "quote_fmt_parse.y"
8288 +{
8289 + remove_visibility();
8290 + }
8291 + break;
8292 +case 50:
8293 +#line 508 "quote_fmt_parse.y"
8294 +{
8295 + add_visibility(msginfo->cc != NULL);
8296 + }
8297 + break;
8298 +case 51:
8299 +#line 512 "quote_fmt_parse.y"
8300 +{
8301 + remove_visibility();
8302 + }
8303 + break;
8304 +case 52:
8305 +#line 516 "quote_fmt_parse.y"
8306 +{
8307 + /* add_visibility(msginfo->references != NULL); */
8308 + }
8309 + break;
8310 +case 53:
8311 +#line 520 "quote_fmt_parse.y"
8312 +{
8313 + remove_visibility();
8314 + }
8315 + break;
8316 +case 54:
8317 +#line 526 "quote_fmt_parse.y"
8318 +{
8319 + {
8320 + FILE *file;
8321 + char buffer[256];
8322 +
8323 + if(file = fopen(yyvsp[-1].str, "rb")) {
8324 + while(fgets(buffer, sizeof(buffer), file)) {
8325 + INSERT(buffer);
8326 + }
8327 + fclose(file);
8328 + }
8329 + }
8330 + }
8331 + break;
8332 +case 55:
8333 +#line 540 "quote_fmt_parse.y"
8334 +{
8335 + {
8336 + FILE *file;
8337 + char buffer[256];
8338 +
8339 + if(file = popen(yyvsp[-1].str, "r")) {
8340 + while(fgets(buffer, sizeof(buffer), file)) {
8341 + INSERT(buffer);
8342 + }
8343 + fclose(file);
8344 + }
8345 + }
8346 + }
8347 + break;
8348 +}
8349 +
8350 +#line 727 "/usr/share/bison/bison.simple"
8351 +
8352 +\f
8353 + yyvsp -= yylen;
8354 + yyssp -= yylen;
8355 +#if YYLSP_NEEDED
8356 + yylsp -= yylen;
8357 +#endif
8358 +
8359 +#if YYDEBUG
8360 + if (yydebug)
8361 + {
8362 + short *yyssp1 = yyss - 1;
8363 + YYFPRINTF (stderr, "state stack now");
8364 + while (yyssp1 != yyssp)
8365 + YYFPRINTF (stderr, " %d", *++yyssp1);
8366 + YYFPRINTF (stderr, "\n");
8367 + }
8368 +#endif
8369 +
8370 + *++yyvsp = yyval;
8371 +#if YYLSP_NEEDED
8372 + *++yylsp = yyloc;
8373 +#endif
8374 +
8375 + /* Now `shift' the result of the reduction. Determine what state
8376 + that goes to, based on the state we popped back to and the rule
8377 + number reduced by. */
8378 +
8379 + yyn = yyr1[yyn];
8380 +
8381 + yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
8382 + if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
8383 + yystate = yytable[yystate];
8384 + else
8385 + yystate = yydefgoto[yyn - YYNTBASE];
8386 +
8387 + goto yynewstate;
8388 +
8389 +
8390 +/*------------------------------------.
8391 +| yyerrlab -- here on detecting error |
8392 +`------------------------------------*/
8393 +yyerrlab:
8394 + /* If not already recovering from an error, report this error. */
8395 + if (!yyerrstatus)
8396 + {
8397 + ++yynerrs;
8398 +
8399 +#ifdef YYERROR_VERBOSE
8400 + yyn = yypact[yystate];
8401 +
8402 + if (yyn > YYFLAG && yyn < YYLAST)
8403 + {
8404 + YYSIZE_T yysize = 0;
8405 + char *yymsg;
8406 + int yyx, yycount;
8407 +
8408 + yycount = 0;
8409 + /* Start YYX at -YYN if negative to avoid negative indexes in
8410 + YYCHECK. */
8411 + for (yyx = yyn < 0 ? -yyn : 0;
8412 + yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)
8413 + if (yycheck[yyx + yyn] == yyx)
8414 + yysize += yystrlen (yytname[yyx]) + 15, yycount++;
8415 + yysize += yystrlen ("parse error, unexpected ") + 1;
8416 + yysize += yystrlen (yytname[YYTRANSLATE (yychar)]);
8417 + yymsg = (char *) YYSTACK_ALLOC (yysize);
8418 + if (yymsg != 0)
8419 + {
8420 + char *yyp = yystpcpy (yymsg, "parse error, unexpected ");
8421 + yyp = yystpcpy (yyp, yytname[YYTRANSLATE (yychar)]);
8422 +
8423 + if (yycount < 5)
8424 + {
8425 + yycount = 0;
8426 + for (yyx = yyn < 0 ? -yyn : 0;
8427 + yyx < (int) (sizeof (yytname) / sizeof (char *));
8428 + yyx++)
8429 + if (yycheck[yyx + yyn] == yyx)
8430 + {
8431 + const char *yyq = ! yycount ? ", expecting " : " or ";
8432 + yyp = yystpcpy (yyp, yyq);
8433 + yyp = yystpcpy (yyp, yytname[yyx]);
8434 + yycount++;
8435 + }
8436 + }
8437 + yyerror (yymsg);
8438 + YYSTACK_FREE (yymsg);
8439 + }
8440 + else
8441 + yyerror ("parse error; also virtual memory exhausted");
8442 + }
8443 + else
8444 +#endif /* defined (YYERROR_VERBOSE) */
8445 + yyerror ("parse error");
8446 + }
8447 + goto yyerrlab1;
8448 +
8449 +
8450 +/*--------------------------------------------------.
8451 +| yyerrlab1 -- error raised explicitly by an action |
8452 +`--------------------------------------------------*/
8453 +yyerrlab1:
8454 + if (yyerrstatus == 3)
8455 + {
8456 + /* If just tried and failed to reuse lookahead token after an
8457 + error, discard it. */
8458 +
8459 + /* return failure if at end of input */
8460 + if (yychar == YYEOF)
8461 + YYABORT;
8462 + YYDPRINTF ((stderr, "Discarding token %d (%s).\n",
8463 + yychar, yytname[yychar1]));
8464 + yychar = YYEMPTY;
8465 + }
8466 +
8467 + /* Else will try to reuse lookahead token after shifting the error
8468 + token. */
8469 +
8470 + yyerrstatus = 3; /* Each real token shifted decrements this */
8471 +
8472 + goto yyerrhandle;
8473 +
8474 +
8475 +/*-------------------------------------------------------------------.
8476 +| yyerrdefault -- current state does not do anything special for the |
8477 +| error token. |
8478 +`-------------------------------------------------------------------*/
8479 +yyerrdefault:
8480 +#if 0
8481 + /* This is wrong; only states that explicitly want error tokens
8482 + should shift them. */
8483 +
8484 + /* If its default is to accept any token, ok. Otherwise pop it. */
8485 + yyn = yydefact[yystate];
8486 + if (yyn)
8487 + goto yydefault;
8488 +#endif
8489 +
8490 +
8491 +/*---------------------------------------------------------------.
8492 +| yyerrpop -- pop the current state because it cannot handle the |
8493 +| error token |
8494 +`---------------------------------------------------------------*/
8495 +yyerrpop:
8496 + if (yyssp == yyss)
8497 + YYABORT;
8498 + yyvsp--;
8499 + yystate = *--yyssp;
8500 +#if YYLSP_NEEDED
8501 + yylsp--;
8502 +#endif
8503 +
8504 +#if YYDEBUG
8505 + if (yydebug)
8506 + {
8507 + short *yyssp1 = yyss - 1;
8508 + YYFPRINTF (stderr, "Error: state stack now");
8509 + while (yyssp1 != yyssp)
8510 + YYFPRINTF (stderr, " %d", *++yyssp1);
8511 + YYFPRINTF (stderr, "\n");
8512 + }
8513 +#endif
8514 +
8515 +/*--------------.
8516 +| yyerrhandle. |
8517 +`--------------*/
8518 +yyerrhandle:
8519 + yyn = yypact[yystate];
8520 + if (yyn == YYFLAG)
8521 + goto yyerrdefault;
8522 +
8523 + yyn += YYTERROR;
8524 + if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
8525 + goto yyerrdefault;
8526 +
8527 + yyn = yytable[yyn];
8528 + if (yyn < 0)
8529 + {
8530 + if (yyn == YYFLAG)
8531 + goto yyerrpop;
8532 + yyn = -yyn;
8533 + goto yyreduce;
8534 + }
8535 + else if (yyn == 0)
8536 + goto yyerrpop;
8537 +
8538 + if (yyn == YYFINAL)
8539 + YYACCEPT;
8540 +
8541 + YYDPRINTF ((stderr, "Shifting error token, "));
8542 +
8543 + *++yyvsp = yylval;
8544 +#if YYLSP_NEEDED
8545 + *++yylsp = yylloc;
8546 +#endif
8547 +
8548 + yystate = yyn;
8549 + goto yynewstate;
8550 +
8551 +
8552 +/*-------------------------------------.
8553 +| yyacceptlab -- YYACCEPT comes here. |
8554 +`-------------------------------------*/
8555 +yyacceptlab:
8556 + yyresult = 0;
8557 + goto yyreturn;
8558 +
8559 +/*-----------------------------------.
8560 +| yyabortlab -- YYABORT comes here. |
8561 +`-----------------------------------*/
8562 +yyabortlab:
8563 + yyresult = 1;
8564 + goto yyreturn;
8565 +
8566 +/*---------------------------------------------.
8567 +| yyoverflowab -- parser overflow comes here. |
8568 +`---------------------------------------------*/
8569 +yyoverflowlab:
8570 + yyerror ("parser stack overflow");
8571 + yyresult = 2;
8572 + /* Fall through. */
8573 +
8574 +yyreturn:
8575 +#ifndef yyoverflow
8576 + if (yyss != yyssa)
8577 + YYSTACK_FREE (yyss);
8578 +#endif
8579 + return yyresult;
8580 +}
8581 +#line 553 "quote_fmt_parse.y"
8582 diff -urN empty/quote_fmt_parse.h src/quote_fmt_parse.h
8583 --- empty/quote_fmt_parse.h Thu Jan 1 00:00:00 1970
8584 +++ src/quote_fmt_parse.h Sun May 12 00:04:36 2002
8585 @@ -0,0 +1,54 @@
8586 +#ifndef BISON_Y_TAB_H
8587 +# define BISON_Y_TAB_H
8588 +
8589 +#ifndef YYSTYPE
8590 +typedef union {
8591 + char chr;
8592 + char str[256];
8593 +} yystype;
8594 +# define YYSTYPE yystype
8595 +#endif
8596 +# define SHOW_NEWSGROUPS 257
8597 +# define SHOW_DATE 258
8598 +# define SHOW_FROM 259
8599 +# define SHOW_FULLNAME 260
8600 +# define SHOW_FIRST_NAME 261
8601 +# define SHOW_LAST_NAME 262
8602 +# define SHOW_SENDER_INITIAL 263
8603 +# define SHOW_SUBJECT 264
8604 +# define SHOW_TO 265
8605 +# define SHOW_MESSAGEID 266
8606 +# define SHOW_PERCENT 267
8607 +# define SHOW_CC 268
8608 +# define SHOW_REFERENCES 269
8609 +# define SHOW_MESSAGE 270
8610 +# define SHOW_QUOTED_MESSAGE 271
8611 +# define SHOW_BACKSLASH 272
8612 +# define SHOW_TAB 273
8613 +# define SHOW_QUOTED_MESSAGE_NO_SIGNATURE 274
8614 +# define SHOW_MESSAGE_NO_SIGNATURE 275
8615 +# define SHOW_EOL 276
8616 +# define SHOW_QUESTION_MARK 277
8617 +# define SHOW_PIPE 278
8618 +# define SHOW_OPARENT 279
8619 +# define SHOW_CPARENT 280
8620 +# define QUERY_DATE 281
8621 +# define QUERY_FROM 282
8622 +# define QUERY_FULLNAME 283
8623 +# define QUERY_SUBJECT 284
8624 +# define QUERY_TO 285
8625 +# define QUERY_NEWSGROUPS 286
8626 +# define QUERY_MESSAGEID 287
8627 +# define QUERY_CC 288
8628 +# define QUERY_REFERENCES 289
8629 +# define INSERT_FILE 290
8630 +# define INSERT_PROGRAMOUTPUT 291
8631 +# define OPARENT 292
8632 +# define CPARENT 293
8633 +# define CHARACTER 294
8634 +# define SHOW_DATE_EXPR 295
8635 +
8636 +
8637 +extern YYSTYPE yylval;
8638 +
8639 +#endif /* not BISON_Y_TAB_H */
8640 diff -urN empty/version.h src/version.h
8641 --- empty/version.h Thu Jan 1 00:00:00 1970
8642 +++ src/version.h Sat May 11 23:53:02 2002
8643 @@ -0,0 +1,27 @@
8644 +/*
8645 + * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
8646 + * Copyright (C) 1999-2001 Hiroyuki Yamamoto
8647 + *
8648 + * This program is free software; you can redistribute it and/or modify
8649 + * it under the terms of the GNU General Public License as published by
8650 + * the Free Software Foundation; either version 2 of the License, or
8651 + * (at your option) any later version.
8652 + *
8653 + * This program is distributed in the hope that it will be useful,
8654 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
8655 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
8656 + * GNU General Public License for more details.
8657 + *
8658 + * You should have received a copy of the GNU General Public License
8659 + * along with this program; if not, write to the Free Software
8660 + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
8661 + */
8662 +
8663 +#ifndef __VERSION_H__
8664 +#define __VERSION_H__
8665 +
8666 +#define PACKAGE "sylpheed"
8667 +#define VERSION "0.7.5claws19 WIN32"
8668 +#define PROG_VERSION "Sylpheed version "VERSION
8669 +
8670 +#endif /* __VERSION_H__ */