sync with 0.8.10cvs11
[claws.git] / src / quote_fmt_parse.y
1 /*
2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
3  * Copyright (C) 1999-2002 Hiroyuki Yamamoto and the Sylpheed-Claws 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 2 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, write to the Free Software
17  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
18  */
19
20 %{
21
22 #include "defs.h"
23
24 #include <glib.h>
25 #include <ctype.h>
26
27 #include "procmsg.h"
28 #include "procmime.h"
29 #include "utils.h"
30 #include "procheader.h"
31
32 #include "quote_fmt.h"
33 #include "quote_fmt_lex.h"
34
35 /* decl */
36 /*
37 flex quote_fmt.l
38 bison -p quote_fmt quote_fmt.y
39 */
40
41 int yylex(void);
42
43 static MsgInfo *msginfo = NULL;
44 static gboolean *visible = NULL;
45 static gint maxsize = 0;
46 static gint stacksize = 0;
47
48 static gchar *buffer = NULL;
49 static gint bufmax = 0;
50 static gint bufsize = 0;
51 static const gchar *quote_str = NULL;
52 static const gchar *body = NULL;
53 static gint error = 0;
54
55 static void add_visibility(gboolean val)
56 {
57         stacksize++;
58         if (maxsize < stacksize) {
59                 maxsize += 128;
60                 visible = g_realloc(visible, maxsize * sizeof(gboolean));
61                 if (visible == NULL)
62                         maxsize = 0;
63         }
64
65         visible[stacksize - 1] = val;
66 }
67
68 static void remove_visibility(void)
69 {
70         stacksize--;
71 }
72
73 static void add_buffer(const gchar *s)
74 {
75         gint len;
76
77         len = strlen(s);
78         if (bufsize + len + 1 > bufmax) {
79                 if (bufmax == 0)
80                         bufmax = 128;
81                 while (bufsize + len + 1 > bufmax)
82                         bufmax *= 2;
83                 buffer = g_realloc(buffer, bufmax);
84         }
85         strcpy(buffer + bufsize, s);
86         bufsize += len;
87 }
88
89 gchar *quote_fmt_get_buffer(void)
90 {
91         if (error != 0)
92                 return NULL;
93         else
94                 return buffer;
95 }
96
97 #define INSERT(buf) \
98         if (stacksize != 0 && visible[stacksize - 1]) \
99                 add_buffer(buf)
100
101 #define INSERT_CHARACTER(chr) \
102         if (stacksize != 0 && visible[stacksize - 1]) { \
103                 gchar tmp[2]; \
104                 tmp[0] = (chr); \
105                 tmp[1] = '\0'; \
106                 add_buffer(tmp); \
107         }
108
109 void quote_fmt_init(MsgInfo *info, const gchar *my_quote_str,
110                     const gchar *my_body)
111 {
112         quote_str = my_quote_str;
113         body = my_body;
114         msginfo = info;
115         stacksize = 0;
116         add_visibility(TRUE);
117         if (buffer != NULL)
118                 *buffer = 0;
119         bufsize = 0;
120         error = 0;
121 }
122
123 void quote_fmterror(char *str)
124 {
125         g_warning("Error: %s\n", str);
126         error = 1;
127 }
128
129 int quote_fmtwrap(void)
130 {
131         return 1;
132 }
133
134 static int isseparator(char ch)
135 {
136         return isspace(ch) || ch == '.' || ch == '-';
137 }
138 %}
139
140 %union {
141         char chr;
142         char str[256];
143 }
144
145 %token SHOW_NEWSGROUPS
146 %token SHOW_DATE SHOW_FROM SHOW_FULLNAME SHOW_FIRST_NAME SHOW_LAST_NAME
147 %token SHOW_SENDER_INITIAL SHOW_SUBJECT SHOW_TO SHOW_MESSAGEID
148 %token SHOW_PERCENT SHOW_CC SHOW_REFERENCES SHOW_MESSAGE
149 %token SHOW_QUOTED_MESSAGE SHOW_BACKSLASH SHOW_TAB
150 %token SHOW_QUOTED_MESSAGE_NO_SIGNATURE SHOW_MESSAGE_NO_SIGNATURE
151 %token SHOW_EOL SHOW_QUESTION_MARK SHOW_PIPE SHOW_OPARENT SHOW_CPARENT
152 %token QUERY_DATE QUERY_FROM
153 %token QUERY_FULLNAME QUERY_SUBJECT QUERY_TO QUERY_NEWSGROUPS
154 %token QUERY_MESSAGEID QUERY_CC QUERY_REFERENCES
155 %token INSERT_FILE INSERT_PROGRAMOUTPUT
156 %token OPARENT CPARENT
157 %token CHARACTER
158 %token SHOW_DATE_EXPR
159
160 %start quote_fmt
161
162 %token <chr> CHARACTER
163 %type <chr> character
164 %type <str> string
165
166 %%
167
168 quote_fmt:
169         character_or_special_or_insert_or_query_list;
170
171 character_or_special_or_insert_or_query_list:
172         character_or_special_or_insert_or_query character_or_special_or_insert_or_query_list
173         | character_or_special_or_insert_or_query ;
174
175 character_or_special_or_insert_or_query:
176         special
177         | character
178         {
179                 INSERT_CHARACTER($1);
180         }
181         | query
182         | insert ;
183
184 character:
185         CHARACTER
186         ;
187
188 string:
189         CHARACTER
190         {
191                 $$[0] = $1;
192                 $$[1] = '\0';
193         }
194         | string CHARACTER
195         {
196                 strcpy($$, $1);
197                 $$[strlen($$) + 1] = '\0';
198                 $$[strlen($$)] = $2;
199         };
200
201 special:
202         SHOW_NEWSGROUPS
203         {
204                 if (msginfo->newsgroups)
205                         INSERT(msginfo->newsgroups);
206         }
207         | SHOW_DATE_EXPR OPARENT string CPARENT
208         {
209                 /* 
210                  * ALF - GNU C's strftime() has a nice format specifier 
211                  * for time zone offset (%z). Non-standard however, so 
212                  * emulate it.
213                  */
214                 if (msginfo->date) {
215                         char  result[100];
216                         char *rptr;
217                         char  zone[6];
218                         struct tm lt;
219                         const char *fptr;
220                         const char *zptr;
221
222 #define RLEFT (sizeof result) - (rptr - result) 
223 #define STR_SIZE(x) (sizeof (x) - 1)
224
225                         zone[0] = 0;
226
227                         if (procheader_date_parse_to_tm(msginfo->date, &lt, zone)) {
228                                 /*
229                                  * break up format string in tiny bits delimited by valid %z's and 
230                                  * feed it to strftime(). don't forget that '%%z' mean literal '%z'.
231                                  */
232                                 for (rptr = result, fptr = $3; fptr && *fptr && rptr < &result[sizeof result - 1];) {
233                                         int         perc;
234                                         const char *p;
235                                         char       *tmp;
236                                         
237                                         if (NULL != (zptr = strstr(fptr, "%z"))) {
238                                                 /*
239                                                  * count nr. of prepended percent chars
240                                                  */
241                                                 for (perc = 0, p = zptr; p && p >= $3 && *p == '%'; p--, perc++)
242                                                         ;
243                                                 /*
244                                                  * feed to strftime()
245                                                  */
246                                                 tmp = g_strndup(fptr, zptr - fptr + (perc % 2 ? 0 : STR_SIZE("%z")));
247                                                 if (tmp) {
248                                                         rptr += strftime(rptr, RLEFT, tmp, &lt);
249                                                         g_free(tmp);
250                                                 }
251                                                 /*
252                                                  * append time zone offset
253                                                  */
254                                                 if (zone[0] && perc % 2) 
255                                                         rptr += g_snprintf(rptr, RLEFT, "%s", zone);
256                                                 fptr = zptr + STR_SIZE("%z");
257                                         } else {
258                                                 rptr += strftime(rptr, RLEFT, fptr, &lt);
259                                                 fptr  = NULL;
260                                         }
261                                 }
262                                 
263                                 INSERT(result);
264                         }
265 #undef STR_SIZE                 
266 #undef RLEFT                    
267                 }
268         }
269         | SHOW_DATE
270         {
271                 if (msginfo->date)
272                         INSERT(msginfo->date);
273         }
274         | SHOW_FROM
275         {
276                 if (msginfo->from)
277                         INSERT(msginfo->from);
278         }
279         | SHOW_FULLNAME
280         {
281                 if (msginfo->fromname)
282                         INSERT(msginfo->fromname);
283         }
284         | SHOW_FIRST_NAME
285         {
286                 if (msginfo->fromname) {
287                         gchar *p;
288                         gchar *str;
289
290                         str = alloca(strlen(msginfo->fromname) + 1);
291                         if (str != NULL) {
292                                 strcpy(str, msginfo->fromname);
293                                 p = str;
294                                 while (*p && !isspace(*p)) p++;
295                                 *p = '\0';
296                                 INSERT(str);
297                         }
298                 }
299         }
300         | SHOW_LAST_NAME
301         {
302                 /* This probably won't work together very well with Middle
303                  names and the like - thth */
304                 if (msginfo->fromname) {
305                         gchar *p;
306                         gchar *str;
307
308                         str = alloca(strlen(msginfo->fromname) + 1);
309                         if (str != NULL) {
310                                 strcpy(str, msginfo->fromname);
311                                 p = str;
312                                 while (*p && !isspace(*p)) p++;
313                                 if (*p) {
314                                     /* We found a space. Get first none-space char and
315                                      insert rest of string from there. */
316                                     while (*p && isspace(*p)) p++;
317                                     if (*p) {
318                                         INSERT(p);
319                                     } else {
320                                         /* If there is no none-space char, just insert
321                                          whole fromname. */
322                                         INSERT(str);
323                                     }
324                                 } else {
325                                     /* If there is no space, just insert whole fromname. */
326                                     INSERT(str);
327                                 }
328                         }
329                 }
330         }
331         | SHOW_SENDER_INITIAL
332         {
333 #define MAX_SENDER_INITIAL 20
334                 if (msginfo->fromname) {
335                         gchar tmp[MAX_SENDER_INITIAL];
336                         gchar *p;
337                         gchar *cur;
338                         gint len = 0;
339
340                         p = msginfo->fromname;
341                         cur = tmp;
342                         while (*p) {
343                                 if (*p && isalnum(*p)) {
344                                         *cur = toupper(*p);
345                                                 cur++;
346                                         len++;
347                                         if (len >= MAX_SENDER_INITIAL - 1)
348                                                 break;
349                                 } else
350                                         break;
351                                 while (*p && !isseparator(*p)) p++;
352                                 while (*p && isseparator(*p)) p++;
353                         }
354                         *cur = '\0';
355                         INSERT(tmp);
356                 }
357         }
358         | SHOW_SUBJECT
359         {
360                 if (msginfo->subject)
361                         INSERT(msginfo->subject);
362         }
363         | SHOW_TO
364         {
365                 if (msginfo->to)
366                         INSERT(msginfo->to);
367         }
368         | SHOW_MESSAGEID
369         {
370                 if (msginfo->msgid)
371                         INSERT(msginfo->msgid);
372         }
373         | SHOW_PERCENT
374         {
375                 INSERT("%");
376         }
377         | SHOW_CC
378         {
379                 if (msginfo->cc)
380                         INSERT(msginfo->cc);
381         }
382         | SHOW_REFERENCES
383         {
384                 /* if (msginfo->references)
385                         INSERT(msginfo->references); */
386         }
387         | SHOW_MESSAGE
388         {
389                 if (msginfo->folder || body) {
390                         gchar buf[BUFFSIZE];
391                         FILE *fp;
392
393                         if (body)
394                                 fp = str_open_as_stream(body);
395                         else
396                                 fp = procmime_get_first_text_content(msginfo);
397
398                         if (fp == NULL)
399                                 g_warning("Can't get text part\n");
400                         else {
401                                 while (fgets(buf, sizeof(buf), fp) != NULL) {
402                                         strcrchomp(buf);
403                                         INSERT(buf);
404                                 }
405                                 fclose(fp);
406                         }
407                 }
408         }
409         | SHOW_QUOTED_MESSAGE
410         {
411                 if (msginfo->folder || body) {
412                         gchar buf[BUFFSIZE];
413                         FILE *fp;
414
415                         if (body)
416                                 fp = str_open_as_stream(body);
417                         else
418                                 fp = procmime_get_first_text_content(msginfo);
419
420                         if (fp == NULL)
421                                 g_warning("Can't get text part\n");
422                         else {
423                                 while (fgets(buf, sizeof(buf), fp) != NULL) {
424                                         strcrchomp(buf);
425                                         if (quote_str)
426                                                 INSERT(quote_str);
427                                         INSERT(buf);
428                                 }
429                                 fclose(fp);
430                         }
431                 }
432         }
433         | SHOW_MESSAGE_NO_SIGNATURE
434         {
435                 if (msginfo->folder || body) {
436                         gchar buf[BUFFSIZE];
437                         FILE *fp;
438
439                         if (body)
440                                 fp = str_open_as_stream(body);
441                         else
442                                 fp = procmime_get_first_text_content(msginfo);
443
444                         if (fp == NULL)
445                                 g_warning("Can't get text part\n");
446                         else {
447                                 while (fgets(buf, sizeof(buf), fp) != NULL) {
448                                         strcrchomp(buf);
449                                         if (strncmp(buf, "-- \n", 4) == 0)
450                                                 break;
451                                         INSERT(buf);
452                                 }
453                                 fclose(fp);
454                         }
455                 }
456         }
457         | SHOW_QUOTED_MESSAGE_NO_SIGNATURE
458         {
459                 if (msginfo->folder || body) {
460                         gchar buf[BUFFSIZE];
461                         FILE *fp;
462
463                         if (body)
464                                 fp = str_open_as_stream(body);
465                         else
466                                 fp = procmime_get_first_text_content(msginfo);
467
468                         if (fp == NULL)
469                                 g_warning("Can't get text part\n");
470                         else {
471                                 while (fgets(buf, sizeof(buf), fp) != NULL) {
472                                         strcrchomp(buf);
473                                         if (strncmp(buf, "-- \n", 4) == 0)
474                                                 break;
475                                         if (quote_str)
476                                                 INSERT(quote_str);
477                                         INSERT(buf);
478                                 }
479                                 fclose(fp);
480                         }
481                 }
482         }
483         | SHOW_BACKSLASH
484         {
485                 INSERT("\\");
486         }
487         | SHOW_TAB
488         {
489                 INSERT("\t");
490         }
491         | SHOW_EOL
492         {
493                 INSERT("\n");
494         }
495         | SHOW_QUESTION_MARK
496         {
497                 INSERT("?");
498         }
499         | SHOW_PIPE
500         {
501                 INSERT("|");
502         }
503         | SHOW_OPARENT
504         {
505                 INSERT("{");
506         }
507         | SHOW_CPARENT
508         {
509                 INSERT("}");
510         };
511
512 query:
513         QUERY_DATE
514         {
515                 add_visibility(msginfo->date != NULL);
516         }
517         OPARENT quote_fmt CPARENT
518         {
519                 remove_visibility();
520         }
521         | QUERY_FROM
522         {
523                 add_visibility(msginfo->from != NULL);
524         }
525         OPARENT quote_fmt CPARENT
526         {
527                 remove_visibility();
528         }
529         | QUERY_FULLNAME
530         {
531                 add_visibility(msginfo->fromname != NULL);
532         }
533         OPARENT quote_fmt CPARENT
534         {
535                 remove_visibility();
536         }
537         | QUERY_SUBJECT
538         {
539                 add_visibility(msginfo->subject != NULL);
540         }
541         OPARENT quote_fmt CPARENT
542         {
543                 remove_visibility();
544         }
545         | QUERY_TO
546         {
547                 add_visibility(msginfo->to != NULL);
548         }
549         OPARENT quote_fmt CPARENT
550         {
551                 remove_visibility();
552         }
553         | QUERY_NEWSGROUPS
554         {
555                 add_visibility(msginfo->newsgroups != NULL);
556         }
557         OPARENT quote_fmt CPARENT
558         {
559                 remove_visibility();
560         }
561         | QUERY_MESSAGEID
562         {
563                 add_visibility(msginfo->msgid != NULL);
564         }
565         OPARENT quote_fmt CPARENT
566         {
567                 remove_visibility();
568         }
569         | QUERY_CC
570         {
571                 add_visibility(msginfo->cc != NULL);
572         }
573         OPARENT quote_fmt CPARENT
574         {
575                 remove_visibility();
576         }
577         | QUERY_REFERENCES
578         {
579                 /* add_visibility(msginfo->references != NULL); */
580         }
581         OPARENT quote_fmt CPARENT
582         {
583                 remove_visibility();
584         };
585
586 insert:
587         INSERT_FILE OPARENT string CPARENT
588         {
589                 {
590                         FILE *file;
591                         char buffer[256];
592                         
593                         if((file = fopen($3, "rb")) != NULL) {
594                                 while(fgets(buffer, sizeof(buffer), file)) {
595                                         INSERT(buffer);
596                                 }
597                                 fclose(file);
598                         }
599                 }
600         }
601         | INSERT_PROGRAMOUTPUT OPARENT string CPARENT
602         {
603                 {
604                         FILE *file;
605                         char buffer[256];
606
607                         if((file = popen($3, "r")) != NULL) {
608                                 while(fgets(buffer, sizeof(buffer), file)) {
609                                         INSERT(buffer);
610                                 }
611                                 fclose(file);
612                         }
613                 }
614         };