Fix bug #3263 ‘Wrong timezone while using date_fmt function’
[claws.git] / src / quote_fmt_parse.y
1 /*
2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
3  * Copyright (C) 1999-2007 Hiroyuki Yamamoto and the Claws Mail Team
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; either version 3 of the License, or
8  * (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program. If not, see <http://www.gnu.org/licenses/>.
17  * 
18  */
19
20 %{
21
22 #include "defs.h"
23
24 #include <glib.h>
25 #include <glib/gi18n.h>
26
27 #include <ctype.h>
28
29 #include "procmsg.h"
30 #include "procmime.h"
31 #include "utils.h"
32 #include "codeconv.h"
33 #include "procheader.h"
34 #include "addr_compl.h"
35 #include "gtk/inputdialog.h"
36
37 #include "quote_fmt.h"
38 #include "quote_fmt_lex.h"
39 #include "account.h"
40
41 /* decl */
42 /*
43 flex quote_fmt.l
44 bison -p quote_fmt quote_fmt.y
45 */
46
47 int yylex(void);
48
49 static MsgInfo *msginfo = NULL;
50 static PrefsAccount *account = NULL;
51 #ifdef USE_ENCHANT
52 static gchar default_dictionary[BUFFSIZE];
53 #endif
54 static gboolean *visible = NULL;
55 static gboolean dry_run = FALSE;
56 static gint maxsize = 0;
57 static gint stacksize = 0;
58 static GHashTable *var_table = NULL;
59 static GList *attachments = NULL;
60
61 typedef struct st_buffer
62 {
63         gchar *buffer;
64         gint bufsize;
65         gint bufmax;
66 } st_buffer;
67
68 static struct st_buffer main_expr = { NULL, 0, 0 };
69 static struct st_buffer sub_expr = { NULL, 0, 0 };
70 static struct st_buffer* current = NULL;
71
72 static const gchar *quote_str = NULL;
73 static const gchar *body = NULL;
74 static gint error = 0;
75
76 static gint cursor_pos = -1;
77
78 extern int quote_fmt_firsttime;
79 extern int line;
80 extern int escaped_string;
81
82 static void add_visibility(gboolean val)
83 {
84         stacksize++;
85         if (maxsize < stacksize) {
86                 maxsize += 128;
87                 visible = g_realloc(visible, maxsize * sizeof(gboolean));
88                 if (visible == NULL)
89                         maxsize = 0;
90         }
91         if (visible != NULL)
92                 visible[stacksize - 1] = val;
93 }
94
95 static void remove_visibility(void)
96 {
97         stacksize--;
98         if (stacksize < 0) {
99                 g_warning("Error: visibility stack underflow");
100                 stacksize = 0;
101         }
102 }
103
104 static void add_buffer(const gchar *s)
105 {
106         gint len;
107
108         if (s == NULL)
109                 return;
110
111         len = strlen(s);
112         if (current->bufsize + len + 1 > current->bufmax) {
113                 if (current->bufmax == 0)
114                         current->bufmax = 128;
115                 while (current->bufsize + len + 1 > current->bufmax)
116                         current->bufmax *= 2;
117                 current->buffer = g_realloc(current->buffer, current->bufmax);
118         }
119         strcpy(current->buffer + current->bufsize, s);
120         current->bufsize += len;
121 }
122
123 static void clear_buffer(void)
124 {
125         if (current->buffer)
126                 *current->buffer = '\0';
127         else
128                 /* force to an empty string, as buffer should not be left unallocated */
129                 add_buffer("");
130         current->bufsize = 0;
131 }
132
133 gchar *quote_fmt_get_buffer(void)
134 {
135         if (current != &main_expr)
136                 g_warning("Error: parser still in sub-expr mode");
137
138         if (error != 0)
139                 return NULL;
140         else
141                 return current->buffer;
142 }
143
144 GList *quote_fmt_get_attachments_list(void)
145 {
146         return attachments;
147 }
148
149 gint quote_fmt_get_line(void)
150 {
151         return line;
152 }
153
154 gint quote_fmt_get_cursor_pos(void)
155 {
156         return cursor_pos;      
157 }
158
159 #define INSERT(buf) \
160         if (stacksize != 0 && visible[stacksize - 1])\
161                 add_buffer(buf); \
162
163 #define INSERT_CHARACTER(chr) \
164         if (stacksize != 0 && visible[stacksize - 1]) { \
165                 gchar tmp[2]; \
166                 tmp[0] = (chr); \
167                 tmp[1] = '\0'; \
168                 add_buffer(tmp); \
169         }
170
171 void quote_fmt_reset_vartable(void)
172 {
173         if (var_table) {
174                 g_hash_table_destroy(var_table);
175                 var_table = NULL;
176         }
177         if (attachments) {
178                 GList *cur = attachments;
179                 while (cur) {
180                         g_free(cur->data);
181                         cur = g_list_next(cur);
182                 }
183                 g_list_free(attachments);
184                 attachments = NULL;
185         }
186 }
187
188 #ifdef USE_ENCHANT
189 void quote_fmt_init(MsgInfo *info, const gchar *my_quote_str,
190                     const gchar *my_body, gboolean my_dry_run,
191                         PrefsAccount *compose_account,
192                         gboolean string_is_escaped,
193                         GtkAspell *compose_gtkaspell)
194 #else
195 void quote_fmt_init(MsgInfo *info, const gchar *my_quote_str,
196                     const gchar *my_body, gboolean my_dry_run,
197                         PrefsAccount *compose_account,
198                         gboolean string_is_escaped)
199 #endif
200 {
201         quote_str = my_quote_str;
202         body = my_body;
203         msginfo = info;
204         account = compose_account;
205 #ifdef USE_ENCHANT
206         gchar *dict = gtkaspell_get_default_dictionary(compose_gtkaspell);
207         if (dict)
208                 strncpy2(default_dictionary, dict, sizeof(default_dictionary));
209         else
210                 *default_dictionary = '\0';
211 #endif
212         dry_run = my_dry_run;
213         stacksize = 0;
214         add_visibility(TRUE);
215         main_expr.bufmax = 0;
216         sub_expr.bufmax = 0;
217         current = &main_expr;
218         clear_buffer();
219         error = 0;
220         line = 1;
221         escaped_string = string_is_escaped;
222
223         if (!var_table)
224                 var_table = g_hash_table_new_full(g_str_hash, g_str_equal, 
225                                 g_free, g_free);
226
227         /*
228          * force LEX initialization
229          */
230         quote_fmt_firsttime = 1;
231         cursor_pos = -1;
232 }
233
234 void quote_fmterror(char *str)
235 {
236         g_warning("Error: %s at line %d", str, line);
237         error = 1;
238 }
239
240 int quote_fmtwrap(void)
241 {
242         return 1;
243 }
244
245 static int isseparator(int ch)
246 {
247         return g_ascii_isspace(ch) || ch == '.' || ch == '-';
248 }
249
250 /*
251  * Search for glibc extended strftime timezone specs within haystack.
252  * If not found NULL is returned and the integer pointed by tzspeclen is
253  * not changed.
254  * If found a pointer to the start of the specification within haystack
255  * is returned and the integer pointed by tzspeclen is set to the lenght
256  * of specification.
257  */
258 static const char* strtzspec(const char *haystack, int *tzspeclen)
259 {
260         const char *p = NULL;
261         const char *q = NULL;
262         const char *r = NULL;
263
264         p = strstr(haystack, "%");
265         while (p != NULL) {
266                 q = p + 1;
267                 if (!*q) return NULL;
268                 r = strchr("_-0^#", *q); /* skip flags */
269                 if (r != NULL) {
270                         ++q;
271                         if (!*q) return NULL;
272                 }
273                 while (*q >= '0' && *q <= '9') ++q; /* skip width */
274                 if (!*q) return NULL;
275                 if (*q == 'z' || *q == 'Z') { /* numeric or name */
276                         *tzspeclen = 1 + (q - p);
277                         return p;
278                 }
279                 p = strstr(q, "%");
280         }
281         return NULL;
282 }
283
284 static void quote_fmt_show_date(const MsgInfo *msginfo, const gchar *format)
285 {
286         char  result[100];
287         char *rptr;
288         char  zone[6];
289         struct tm lt;
290         const char *fptr;
291         const char *zptr;
292
293         if (!msginfo->date)
294                 return;
295         
296         /* 
297          * ALF - GNU C's strftime() has a nice format specifier 
298          * for time zone offset (%z). Non-standard however, so 
299          * emulate it.
300          */
301
302 #define RLEFT (sizeof result) - (rptr - result) 
303
304         zone[0] = 0;
305
306         if (procheader_date_parse_to_tm(msginfo->date, &lt, zone)) {
307                 /*
308                  * break up format string in tiny bits delimited by valid %z's and 
309                  * feed it to strftime(). don't forget that '%%z' mean literal '%z'.
310                  */
311                 for (rptr = result, fptr = format; fptr && *fptr && rptr < &result[sizeof result - 1];) {
312                         int         perc, zlen;
313                         const char *p;
314                         char       *tmp;
315                         
316                         if (NULL != (zptr = strtzspec(fptr, &zlen))) {
317                                 /*
318                                  * count nr. of prepended percent chars
319                                  */
320                                 for (perc = 0, p = zptr; p && p >= format && *p == '%'; p--, perc++)
321                                         ;
322                                 /*
323                                  * feed to strftime()
324                                  */
325                                 tmp = g_strndup(fptr, zptr - fptr + (perc % 2 ? 0 : zlen));
326                                 if (tmp) {
327                                         rptr += strftime(rptr, RLEFT, tmp, &lt);
328                                         g_free(tmp);
329                                 }
330                                 /*
331                                  * append time zone offset
332                                  */
333                                 if (zone[0] && perc % 2) 
334                                         rptr += g_snprintf(rptr, RLEFT, "%s", zone);
335                                 fptr = zptr + zlen;
336                         } else {
337                                 rptr += strftime(rptr, RLEFT, fptr, &lt);
338                                 fptr  = NULL;
339                         }
340                 }
341                 
342                 if (g_utf8_validate(result, -1, NULL)) {
343                         INSERT(result);
344                 } else {
345                         gchar *utf = conv_codeset_strdup(result, 
346                                 conv_get_locale_charset_str_no_utf8(),
347                                 CS_INTERNAL);
348                         if (utf == NULL || 
349                             !g_utf8_validate(utf, -1, NULL)) {
350                                 g_free(utf);
351                                 utf = g_malloc(strlen(result)*2+1);
352                                 conv_localetodisp(utf, 
353                                         strlen(result)*2+1, result);
354                         }
355                         if (g_utf8_validate(utf, -1, NULL)) {
356                                 INSERT(utf);
357                         }
358                         g_free(utf);
359                 }
360         }
361 #undef RLEFT                    
362 }               
363
364 static void quote_fmt_show_first_name(const MsgInfo *msginfo)
365 {
366         guchar *p;
367         gchar *str;
368
369         if (!msginfo->fromname)
370                 return; 
371         
372         p = (guchar*)strchr(msginfo->fromname, ',');
373         if (p != NULL) {
374                 /* fromname is like "Duck, Donald" */
375                 p++;
376                 while (*p && isspace(*p)) p++;
377                 str = alloca(strlen((char *)p) + 1);
378                 if (str != NULL) {
379                         strcpy(str, (char *)p);
380                         INSERT(str);
381                 }
382         } else {
383                 /* fromname is like "Donald Duck" */
384                 str = alloca(strlen(msginfo->fromname) + 1);
385                 if (str != NULL) {
386                         strcpy(str, msginfo->fromname);
387                         p = (guchar *)str;
388                         while (*p && !isspace(*p)) p++;
389                         *p = '\0';
390                         INSERT(str);
391                 }
392         }
393 }
394
395 static void quote_fmt_show_last_name(const MsgInfo *msginfo)
396 {
397         gchar *p;
398         gchar *str;
399
400         /* This probably won't work together very well with Middle
401            names and the like - thth */
402         if (!msginfo->fromname) 
403                 return;
404
405         str = alloca(strlen(msginfo->fromname) + 1);
406         if (str != NULL) {
407                 strcpy(str, msginfo->fromname);
408                 p = strchr(str, ',');
409                 if (p != NULL) {
410                         /* fromname is like "Duck, Donald" */
411                         *p = '\0';
412                         INSERT(str);
413                 } else {
414                         /* fromname is like "Donald Duck" */
415                         p = str;
416                         while (*p && !isspace(*p)) p++;
417                         if (*p) {
418                             /* We found a space. Get first 
419                              none-space char and insert
420                              rest of string from there. */
421                             while (*p && isspace(*p)) p++;
422                             if (*p) {
423                                 INSERT(p);
424                             } else {
425                                 /* If there is no none-space 
426                                  char, just insert whole 
427                                  fromname. */
428                                 INSERT(str);
429                             }
430                         } else {
431                             /* If there is no space, just 
432                              insert whole fromname. */
433                             INSERT(str);
434                         }
435                 }
436         }
437 }
438
439 static void quote_fmt_show_sender_initial(const MsgInfo *msginfo)
440 {
441 #define MAX_SENDER_INITIAL 20
442         gchar tmp[MAX_SENDER_INITIAL];
443         guchar *p;
444         gchar *cur;
445         gint len = 0;
446
447         if (!msginfo->fromname) 
448                 return;
449
450         p = (guchar *)msginfo->fromname;
451         cur = tmp;
452         while (*p) {
453                 if (*p && g_utf8_validate((gchar *)p, 1, NULL)) {
454                         *cur = toupper(*p);
455                                 cur++;
456                         len++;
457                         if (len >= MAX_SENDER_INITIAL - 1)
458                                 break;
459                 } else
460                         break;
461                 while (*p && !isseparator(*p)) p++;
462                 while (*p && isseparator(*p)) p++;
463         }
464         *cur = '\0';
465         INSERT(tmp);
466 }
467
468 static void quote_fmt_show_msg(MsgInfo *msginfo, const gchar *body,
469                                gboolean quoted, gboolean signature,
470                                const gchar *quote_str)
471 {
472         gchar buf[BUFFSIZE];
473         FILE *fp;
474
475         if (!(msginfo->folder || body))
476                 return;
477
478         if (body)
479                 fp = str_open_as_stream(body);
480         else {
481                 if (MSG_IS_ENCRYPTED(msginfo->flags))
482                         fp = procmime_get_first_encrypted_text_content(msginfo);
483                 else
484                         fp = procmime_get_first_text_content(msginfo);
485         }
486
487         if (fp == NULL)
488                 g_warning("Can't get text part");
489         else {
490                 while (fgets(buf, sizeof(buf), fp) != NULL) {
491                         strcrchomp(buf);
492                         
493                         if (!signature && strncmp(buf, "-- \n", 4) == 0)
494                                 break;
495                 
496                         if (quoted && quote_str)
497                                 INSERT(quote_str);
498                         
499                         INSERT(buf);
500                 }
501                 fclose(fp);
502         }
503 }
504
505 static void quote_fmt_insert_file(const gchar *filename)
506 {
507         FILE *file;
508         char buffer[256];
509         
510         if ((file = g_fopen(filename, "rb")) != NULL) {
511                 while (fgets(buffer, sizeof(buffer), file)) {
512                         INSERT(buffer);
513                 }
514                 fclose(file);
515         }
516
517 }
518
519 static void quote_fmt_insert_program_output(const gchar *progname)
520 {
521         FILE *file;
522         char buffer[256];
523
524         if ((file = popen(progname, "r")) != NULL) {
525                 while (fgets(buffer, sizeof(buffer), file)) {
526                         INSERT(buffer);
527                 }
528                 pclose(file);
529         }
530 }
531
532 static void quote_fmt_insert_user_input(const gchar *varname)
533 {
534         gchar *buf = NULL;
535         gchar *text = NULL;
536         
537         if (dry_run) 
538                 return;
539
540         if ((text = g_hash_table_lookup(var_table, varname)) == NULL) {
541                 buf = g_strdup_printf(_("Enter text to replace '%s'"), varname);
542                 text = input_dialog(_("Enter variable"), buf, "");
543                 g_free(buf);
544                 if (!text)
545                         return;
546                 g_hash_table_insert(var_table, g_strdup(varname), g_strdup(text));
547         } else {
548                 /* don't free the one in hashtable at the end */
549                 text = g_strdup(text);
550         }
551
552         if (!text)
553                 return;
554         INSERT(text);
555         g_free(text);
556 }
557
558 static void quote_fmt_attach_file(const gchar *filename)
559 {
560         attachments = g_list_append(attachments, g_strdup(filename));
561 }
562
563 static gchar *quote_fmt_complete_address(const gchar *addr)
564 {
565         gint count;
566         gchar *res, *tmp, *email_addr;
567         gchar **split;
568
569         debug_print("quote_fmt_complete_address: %s\n", addr);
570         if (addr == NULL)
571                 return NULL;
572
573         /* if addr is a list of message, try the 1st element only */
574         split = g_strsplit(addr, ",", -1);
575         if (!split || !split[0] || *split[0] == '\0') {
576                 g_strfreev(split);
577                 return NULL;
578         }
579
580         Xstrdup_a(email_addr, split[0], return NULL);
581         extract_address(email_addr);
582         if (!*email_addr) {
583                 g_strfreev(split);
584                 return NULL;
585         }
586
587         res = NULL;
588         start_address_completion(NULL);
589         if (1 < (count = complete_address(email_addr))) {
590                 tmp = get_complete_address(1);
591                 res = procheader_get_fromname(tmp);
592                 g_free(tmp);
593         }
594         end_address_completion();
595         g_strfreev(split);
596
597         debug_print("quote_fmt_complete_address: matched %s\n", res);
598         return res;
599 }
600
601 %}
602
603 %union {
604         char chr;
605         char str[256];
606 }
607
608 /* tokens SHOW */
609 %token SHOW_NEWSGROUPS
610 %token SHOW_DATE SHOW_FROM SHOW_FULLNAME SHOW_FIRST_NAME SHOW_LAST_NAME
611 %token SHOW_SENDER_INITIAL SHOW_SUBJECT SHOW_TO SHOW_MESSAGEID
612 %token SHOW_PERCENT SHOW_CC SHOW_REFERENCES SHOW_MESSAGE
613 %token SHOW_QUOTED_MESSAGE SHOW_BACKSLASH SHOW_TAB SHOW_MAIL_ADDRESS
614 %token SHOW_QUOTED_MESSAGE_NO_SIGNATURE SHOW_MESSAGE_NO_SIGNATURE
615 %token SHOW_EOL SHOW_QUESTION_MARK SHOW_EXCLAMATION_MARK SHOW_PIPE SHOW_OPARENT SHOW_CPARENT
616 %token SHOW_ACCOUNT_FULL_NAME SHOW_ACCOUNT_MAIL_ADDRESS SHOW_ACCOUNT_NAME SHOW_ACCOUNT_ORGANIZATION
617 %token SHOW_ACCOUNT_DICT SHOW_ACCOUNT_SIG SHOW_ACCOUNT_SIGPATH
618 %token SHOW_DICT SHOW_TAGS
619 %token SHOW_ADDRESSBOOK_COMPLETION_FOR_CC
620 %token SHOW_ADDRESSBOOK_COMPLETION_FOR_FROM
621 %token SHOW_ADDRESSBOOK_COMPLETION_FOR_TO
622 /* tokens QUERY */
623 %token QUERY_DATE QUERY_FROM
624 %token QUERY_FULLNAME QUERY_SUBJECT QUERY_TO QUERY_NEWSGROUPS
625 %token QUERY_MESSAGEID QUERY_CC QUERY_REFERENCES
626 %token QUERY_ACCOUNT_FULL_NAME QUERY_ACCOUNT_ORGANIZATION QUERY_ACCOUNT_DICT
627 %token QUERY_ACCOUNT_SIG QUERY_ACCOUNT_SIGPATH
628 %token QUERY_DICT
629 %token QUERY_CC_FOUND_IN_ADDRESSBOOK
630 %token QUERY_FROM_FOUND_IN_ADDRESSBOOK
631 %token QUERY_TO_FOUND_IN_ADDRESSBOOK
632 /* tokens QUERY_NOT */
633 %token QUERY_NOT_DATE QUERY_NOT_FROM
634 %token QUERY_NOT_FULLNAME QUERY_NOT_SUBJECT QUERY_NOT_TO QUERY_NOT_NEWSGROUPS
635 %token QUERY_NOT_MESSAGEID QUERY_NOT_CC QUERY_NOT_REFERENCES
636 %token QUERY_NOT_ACCOUNT_FULL_NAME QUERY_NOT_ACCOUNT_ORGANIZATION QUERY_NOT_ACCOUNT_DICT
637 %token QUERY_NOT_ACCOUNT_SIG QUERY_NOT_ACCOUNT_SIGPATH
638 %token QUERY_NOT_DICT
639 %token QUERY_NOT_CC_FOUND_IN_ADDRESSBOOK
640 %token QUERY_NOT_FROM_FOUND_IN_ADDRESSBOOK
641 %token QUERY_NOT_TO_FOUND_IN_ADDRESSBOOK
642 /* other tokens */
643 %token INSERT_FILE INSERT_PROGRAMOUTPUT INSERT_USERINPUT
644 %token ATTACH_FILE
645 %token OPARENT CPARENT
646 %token CHARACTER
647 %token SHOW_DATE_EXPR
648 %token SET_CURSOR_POS
649
650 %start quote_fmt
651
652 %type <chr> CHARACTER
653 %type <chr> character
654 %type <str> string
655
656 %%
657
658 quote_fmt:
659         character_or_special_or_insert_or_query_list ;
660
661 sub_expr:
662         character_or_special_list ;
663
664 character_or_special_or_insert_or_query_list:
665         character_or_special_or_insert_or_query character_or_special_or_insert_or_query_list
666         | character_or_special_or_insert_or_query ;
667
668 character_or_special_list:
669         character_or_special character_or_special_list
670         | character_or_special ;
671
672 character_or_special_or_insert_or_query:
673         character_or_special
674         | query
675         | query_not
676         | insert
677         | attach ;
678
679 character_or_special:
680         special
681         | character
682         {
683                 INSERT_CHARACTER($1);
684         };
685
686 character:
687         CHARACTER
688         ;
689
690 string:
691         CHARACTER
692         {
693                 $$[0] = $1;
694                 $$[1] = '\0';
695         }
696         | string CHARACTER
697         {
698                 size_t len;
699                 
700                 strncpy($$, $1, sizeof($$));
701                 $$[sizeof($$) - 1] = '\0';
702                 len = strlen($$);
703                 if (len + 1 < sizeof($$)) {
704                         $$[len + 1] = '\0';
705                         $$[len] = $2;
706                 }
707         };
708
709 special:
710         SHOW_NEWSGROUPS
711         {
712                 if (msginfo->newsgroups)
713                         INSERT(msginfo->newsgroups);
714         }
715         | SHOW_DATE_EXPR OPARENT string CPARENT
716         {
717                 quote_fmt_show_date(msginfo, $3);
718         }
719         | SHOW_DATE
720         {
721                 if (msginfo->date)
722                         INSERT(msginfo->date);
723         }
724         | SHOW_FROM
725         {
726                 if (msginfo->from)
727                         INSERT(msginfo->from);
728         }
729         | SHOW_MAIL_ADDRESS
730         {
731                 if (msginfo->from) {
732                         gchar *stripped_address = g_strdup(msginfo->from);
733                         extract_address(stripped_address);
734                         INSERT(stripped_address);
735                         g_free(stripped_address);
736                 }
737         }
738         | SHOW_FULLNAME
739         {
740                 if (msginfo->fromname)
741                         INSERT(msginfo->fromname);
742         }
743         | SHOW_FIRST_NAME
744         {
745                 quote_fmt_show_first_name(msginfo);
746         }
747         | SHOW_LAST_NAME
748     {
749                 quote_fmt_show_last_name(msginfo);
750         }
751         | SHOW_SENDER_INITIAL
752         {
753                 quote_fmt_show_sender_initial(msginfo);
754         }
755         | SHOW_SUBJECT
756         {
757                 if (msginfo->subject)
758                         INSERT(msginfo->subject);
759         }
760         | SHOW_TO
761         {
762                 if (msginfo->to)
763                         INSERT(msginfo->to);
764         }
765         | SHOW_MESSAGEID
766         {
767                 if (msginfo->msgid)
768                         INSERT(msginfo->msgid);
769         }
770         | SHOW_PERCENT
771         {
772                 INSERT("%");
773         }
774         | SHOW_CC
775         {
776                 if (msginfo->cc)
777                         INSERT(msginfo->cc);
778         }
779         | SHOW_REFERENCES
780         {
781                 GSList *item;
782
783                 INSERT(msginfo->inreplyto);
784                 for (item = msginfo->references; item != NULL; item = g_slist_next(item))
785                         if (item->data)
786                                 INSERT(item->data);
787         }
788         | SHOW_MESSAGE
789         {
790                 quote_fmt_show_msg(msginfo, body, FALSE, TRUE, quote_str);
791         }
792         | SHOW_QUOTED_MESSAGE
793         {
794                 quote_fmt_show_msg(msginfo, body, TRUE, TRUE, quote_str);
795         }
796         | SHOW_MESSAGE_NO_SIGNATURE
797         {
798                 quote_fmt_show_msg(msginfo, body, FALSE, FALSE, quote_str);
799         }
800         | SHOW_QUOTED_MESSAGE_NO_SIGNATURE
801         {
802                 quote_fmt_show_msg(msginfo, body, TRUE, FALSE, quote_str);
803         }
804         | SHOW_ACCOUNT_FULL_NAME
805         {
806                 if (account && account->name)
807                         INSERT(account->name);
808         }
809         | SHOW_ACCOUNT_MAIL_ADDRESS
810         {
811                 if (account && account->address)
812                         INSERT(account->address);
813         }
814         | SHOW_ACCOUNT_NAME
815         {
816                 if (account && account->account_name)
817                         INSERT(account->account_name);
818         }
819         | SHOW_ACCOUNT_ORGANIZATION
820         {
821                 if (account && account->organization)
822                         INSERT(account->organization);
823         }
824         | SHOW_ACCOUNT_SIG
825         {
826                 gchar *str = account_get_signature_str(account);
827                 INSERT(str);
828                 g_free(str);
829         }
830         | SHOW_ACCOUNT_SIGPATH
831         {
832                 if (account && account->sig_path)
833                         INSERT(account->sig_path);
834         }
835         | SHOW_ACCOUNT_DICT
836         {
837 #ifdef USE_ENCHANT
838                 if (account && account->enable_default_dictionary) {
839                         gchar *dictname = g_path_get_basename(account->default_dictionary);
840                         INSERT(dictname);
841                         g_free(dictname);
842                 }
843 #endif
844         }
845         | SHOW_DICT
846         {
847 #ifdef USE_ENCHANT
848                 INSERT(default_dictionary);
849 #endif
850         }
851         | SHOW_TAGS
852         {
853                 gchar *tags = procmsg_msginfo_get_tags_str(msginfo);
854                 if (tags) {
855                         INSERT(tags);
856                 }
857                 g_free(tags);
858         }
859         | SHOW_BACKSLASH
860         {
861                 INSERT("\\");
862         }
863         | SHOW_TAB
864         {
865                 INSERT("\t");
866         }
867         | SHOW_EOL
868         {
869                 INSERT("\n");
870         }
871         | SHOW_QUESTION_MARK
872         {
873                 INSERT("?");
874         }
875         | SHOW_EXCLAMATION_MARK
876         {
877                 INSERT("!");
878         }
879         | SHOW_PIPE
880         {
881                 INSERT("|");
882         }
883         | SHOW_OPARENT
884         {
885                 INSERT("{");
886         }
887         | SHOW_CPARENT
888         {
889                 INSERT("}");
890         }
891         | SET_CURSOR_POS
892         {
893                 if (current->buffer)
894                         cursor_pos = g_utf8_strlen(current->buffer, -1);
895                 else
896                         cursor_pos = 0;
897         }
898         | SHOW_ADDRESSBOOK_COMPLETION_FOR_CC
899         {
900                 gchar *tmp = quote_fmt_complete_address(msginfo->cc);
901                 if (tmp) {
902                         INSERT(tmp);
903                         g_free(tmp);
904                 }
905         }
906         | SHOW_ADDRESSBOOK_COMPLETION_FOR_FROM
907         {
908                 gchar *tmp = quote_fmt_complete_address(msginfo->from);
909                 if (tmp) {
910                         INSERT(tmp);
911                         g_free(tmp);
912                 }
913         }
914         | SHOW_ADDRESSBOOK_COMPLETION_FOR_TO
915         {
916                 gchar *tmp = quote_fmt_complete_address(msginfo->to);
917                 if (tmp) {
918                         INSERT(tmp);
919                         g_free(tmp);
920                 }
921         };
922
923 query:
924         QUERY_DATE
925         {
926                 add_visibility(msginfo->date != NULL);
927         }
928         OPARENT quote_fmt CPARENT
929         {
930                 remove_visibility();
931         }
932         | QUERY_FROM
933         {
934                 add_visibility(msginfo->from != NULL);
935         }
936         OPARENT quote_fmt CPARENT
937         {
938                 remove_visibility();
939         }
940         | QUERY_FULLNAME
941         {
942                 add_visibility(msginfo->fromname != NULL);
943         }
944         OPARENT quote_fmt CPARENT
945         {
946                 remove_visibility();
947         }
948         | QUERY_SUBJECT
949         {
950                 add_visibility(msginfo->subject != NULL);
951         }
952         OPARENT quote_fmt CPARENT
953         {
954                 remove_visibility();
955         }
956         | QUERY_TO
957         {
958                 add_visibility(msginfo->to != NULL);
959         }
960         OPARENT quote_fmt CPARENT
961         {
962                 remove_visibility();
963         }
964         | QUERY_NEWSGROUPS
965         {
966                 add_visibility(msginfo->newsgroups != NULL);
967         }
968         OPARENT quote_fmt CPARENT
969         {
970                 remove_visibility();
971         }
972         | QUERY_MESSAGEID
973         {
974                 add_visibility(msginfo->msgid != NULL);
975         }
976         OPARENT quote_fmt CPARENT
977         {
978                 remove_visibility();
979         }
980         | QUERY_CC
981         {
982                 add_visibility(msginfo->cc != NULL);
983         }
984         OPARENT quote_fmt CPARENT
985         {
986                 remove_visibility();
987         }
988         | QUERY_REFERENCES
989         {
990                 gboolean found;
991                 GSList *item;
992
993                 found = (msginfo->inreplyto != NULL);
994                 for (item = msginfo->references; found == FALSE && item != NULL; item = g_slist_next(item))
995                         if (item->data)
996                                 found = TRUE;
997                 add_visibility(found == TRUE);
998         }
999         OPARENT quote_fmt CPARENT
1000         {
1001                 remove_visibility();
1002         }
1003         | QUERY_ACCOUNT_FULL_NAME
1004         {
1005                 add_visibility(account != NULL && account->name != NULL);
1006         }
1007         OPARENT quote_fmt CPARENT
1008         {
1009                 remove_visibility();
1010         }
1011         | QUERY_ACCOUNT_ORGANIZATION
1012         {
1013                 add_visibility(account != NULL && account->organization != NULL);
1014         }
1015         OPARENT quote_fmt CPARENT
1016         {
1017                 remove_visibility();
1018         }
1019         | QUERY_ACCOUNT_SIG
1020         {
1021                 gchar *str = account_get_signature_str(account);
1022                 add_visibility(str != NULL && * str != '\0');
1023                 g_free(str);
1024         }
1025         OPARENT quote_fmt CPARENT
1026         {
1027                 remove_visibility();
1028         }
1029         | QUERY_ACCOUNT_SIGPATH
1030         {
1031                 add_visibility(account != NULL && account->sig_path != NULL
1032                                 && *account->sig_path != '\0');
1033         }
1034         OPARENT quote_fmt CPARENT
1035         {
1036                 remove_visibility();
1037         }
1038         | QUERY_ACCOUNT_DICT
1039         {
1040 #ifdef USE_ENCHANT
1041                 add_visibility(account != NULL && account->enable_default_dictionary == TRUE &&
1042                                 account->default_dictionary != NULL && *account->default_dictionary != '\0');
1043 #else
1044                 add_visibility(FALSE);
1045 #endif
1046         }
1047         OPARENT quote_fmt CPARENT
1048         {
1049                 remove_visibility();
1050         }
1051         | QUERY_DICT
1052         {
1053 #ifdef USE_ENCHANT
1054                 add_visibility(*default_dictionary != '\0');
1055 #else
1056                 add_visibility(FALSE);
1057 #endif
1058         }
1059         OPARENT quote_fmt CPARENT
1060         {
1061                 remove_visibility();
1062         }
1063         | QUERY_CC_FOUND_IN_ADDRESSBOOK
1064         {
1065                 gchar *tmp = quote_fmt_complete_address(msginfo->cc);
1066                 add_visibility(tmp != NULL && *tmp != '\0');
1067                 g_free(tmp);
1068         }
1069         OPARENT quote_fmt CPARENT
1070         {
1071                 remove_visibility();
1072         }
1073         | QUERY_FROM_FOUND_IN_ADDRESSBOOK
1074         {
1075                 gchar *tmp = quote_fmt_complete_address(msginfo->from);
1076                 add_visibility(tmp != NULL && *tmp != '\0');
1077                 g_free(tmp);
1078         }
1079         OPARENT quote_fmt CPARENT
1080         {
1081                 remove_visibility();
1082         }
1083         | QUERY_TO_FOUND_IN_ADDRESSBOOK
1084         {
1085                 gchar *tmp = quote_fmt_complete_address(msginfo->to);
1086                 add_visibility(tmp != NULL && *tmp != '\0');
1087                 g_free(tmp);
1088         }
1089         OPARENT quote_fmt CPARENT
1090         {
1091                 remove_visibility();
1092         };
1093
1094 query_not:
1095         QUERY_NOT_DATE
1096         {
1097                 add_visibility(msginfo->date == NULL);
1098         }
1099         OPARENT quote_fmt CPARENT
1100         {
1101                 remove_visibility();
1102         }
1103         | QUERY_NOT_FROM
1104         {
1105                 add_visibility(msginfo->from == NULL);
1106         }
1107         OPARENT quote_fmt CPARENT
1108         {
1109                 remove_visibility();
1110         }
1111         | QUERY_NOT_FULLNAME
1112         {
1113                 add_visibility(msginfo->fromname == NULL);
1114         }
1115         OPARENT quote_fmt CPARENT
1116         {
1117                 remove_visibility();
1118         }
1119         | QUERY_NOT_SUBJECT
1120         {
1121                 add_visibility(msginfo->subject == NULL);
1122         }
1123         OPARENT quote_fmt CPARENT
1124         {
1125                 remove_visibility();
1126         }
1127         | QUERY_NOT_TO
1128         {
1129                 add_visibility(msginfo->to == NULL);
1130         }
1131         OPARENT quote_fmt CPARENT
1132         {
1133                 remove_visibility();
1134         }
1135         | QUERY_NOT_NEWSGROUPS
1136         {
1137                 add_visibility(msginfo->newsgroups == NULL);
1138         }
1139         OPARENT quote_fmt CPARENT
1140         {
1141                 remove_visibility();
1142         }
1143         | QUERY_NOT_MESSAGEID
1144         {
1145                 add_visibility(msginfo->msgid == NULL);
1146         }
1147         OPARENT quote_fmt CPARENT
1148         {
1149                 remove_visibility();
1150         }
1151         | QUERY_NOT_CC
1152         {
1153                 add_visibility(msginfo->cc == NULL);
1154         }
1155         OPARENT quote_fmt CPARENT
1156         {
1157                 remove_visibility();
1158         }
1159         | QUERY_NOT_REFERENCES
1160         {
1161                 gboolean found;
1162                 GSList *item;
1163
1164                 found = (msginfo->inreplyto != NULL);
1165                 for (item = msginfo->references; found == FALSE && item != NULL; item = g_slist_next(item))
1166                         if (item->data)
1167                                 found = TRUE;
1168                 add_visibility(found == FALSE);
1169         }
1170         OPARENT quote_fmt CPARENT
1171         {
1172                 remove_visibility();
1173         }
1174         | QUERY_NOT_ACCOUNT_FULL_NAME
1175         {
1176                 add_visibility(account == NULL || account->name == NULL);
1177         }
1178         OPARENT quote_fmt CPARENT
1179         {
1180                 remove_visibility();
1181         }
1182         | QUERY_NOT_ACCOUNT_ORGANIZATION
1183         {
1184                 add_visibility(account == NULL || account->organization == NULL);
1185         }
1186         OPARENT quote_fmt CPARENT
1187         {
1188                 remove_visibility();
1189         }
1190         | QUERY_NOT_ACCOUNT_SIG
1191         {
1192                 gchar *str = account_get_signature_str(account);
1193                 add_visibility(str == NULL || *str == '\0');
1194                 g_free(str);
1195         }
1196         OPARENT quote_fmt CPARENT
1197         {
1198                 remove_visibility();
1199         }
1200         | QUERY_NOT_ACCOUNT_SIGPATH
1201         {
1202                 add_visibility(account == NULL || account->sig_path == NULL
1203                                 || *account->sig_path == '\0');
1204         }
1205         OPARENT quote_fmt CPARENT
1206         {
1207                 remove_visibility();
1208         }
1209         | QUERY_NOT_ACCOUNT_DICT
1210         {
1211 #ifdef USE_ENCHANT
1212                 add_visibility(account == NULL || account->enable_default_dictionary == FALSE
1213                                 || *account->default_dictionary == '\0');
1214 #else
1215                 add_visibility(FALSE);
1216 #endif
1217         }
1218         OPARENT quote_fmt CPARENT
1219         {
1220                 remove_visibility();
1221         }
1222         | QUERY_NOT_DICT
1223         {
1224 #ifdef USE_ENCHANT
1225                 add_visibility(*default_dictionary == '\0');
1226 #else
1227                 add_visibility(FALSE);
1228 #endif
1229         }
1230         OPARENT quote_fmt CPARENT
1231         {
1232                 remove_visibility();
1233         }
1234         | QUERY_NOT_CC_FOUND_IN_ADDRESSBOOK
1235         {
1236                 gchar *tmp = quote_fmt_complete_address(msginfo->cc);
1237                 add_visibility(tmp == NULL || *tmp == '\0');
1238                 g_free(tmp);
1239         }
1240         OPARENT quote_fmt CPARENT
1241         {
1242                 remove_visibility();
1243         }
1244         | QUERY_NOT_FROM_FOUND_IN_ADDRESSBOOK
1245         {
1246                 gchar *tmp = quote_fmt_complete_address(msginfo->from);
1247                 add_visibility(tmp == NULL || *tmp == '\0');
1248                 g_free(tmp);
1249         }
1250         OPARENT quote_fmt CPARENT
1251         {
1252                 remove_visibility();
1253         }
1254         | QUERY_NOT_TO_FOUND_IN_ADDRESSBOOK
1255         {
1256                 gchar *tmp = quote_fmt_complete_address(msginfo->to);
1257                 add_visibility(tmp == NULL || *tmp == '\0');
1258                 g_free(tmp);
1259         }
1260         OPARENT quote_fmt CPARENT
1261         {
1262                 remove_visibility();
1263         };
1264
1265 insert:
1266         INSERT_FILE
1267         {
1268                 current = &sub_expr;
1269                 clear_buffer();
1270         }
1271         OPARENT sub_expr CPARENT
1272         {
1273                 current = &main_expr;
1274                 if (!dry_run) {
1275                         quote_fmt_insert_file(sub_expr.buffer);
1276                 }
1277         }
1278         | INSERT_PROGRAMOUTPUT
1279         {
1280                 current = &sub_expr;
1281                 clear_buffer();
1282         }
1283         OPARENT sub_expr CPARENT
1284         {
1285                 current = &main_expr;
1286                 if (!dry_run) {
1287                         quote_fmt_insert_program_output(sub_expr.buffer);
1288                 }
1289         }
1290         | INSERT_USERINPUT
1291         {
1292                 current = &sub_expr;
1293                 clear_buffer();
1294         }
1295         OPARENT sub_expr CPARENT
1296         {
1297                 current = &main_expr;
1298                 if (!dry_run) {
1299                         quote_fmt_insert_user_input(sub_expr.buffer);
1300                 }
1301         };
1302
1303 attach:
1304         ATTACH_FILE
1305         {
1306                 current = &sub_expr;
1307                 clear_buffer();
1308         }
1309         OPARENT sub_expr CPARENT
1310         {
1311                 current = &main_expr;
1312                 if (!dry_run) {
1313                         quote_fmt_attach_file(sub_expr.buffer);
1314                 }
1315         };