]> git.llucax.com Git - software/mutt-debian.git/blob - pager.c
Switch to tokyocabinet (Closes: #530670)
[software/mutt-debian.git] / pager.c
1 /*
2  * Copyright (C) 1996-2002,2007 Michael R. Elkins <me@mutt.org>
3  * 
4  *     This program is free software; you can redistribute it and/or modify
5  *     it under the terms of the GNU General Public License as published by
6  *     the Free Software Foundation; either version 2 of the License, or
7  *     (at your option) any later version.
8  * 
9  *     This program is distributed in the hope that it will be useful,
10  *     but WITHOUT ANY WARRANTY; without even the implied warranty of
11  *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  *     GNU General Public License for more details.
13  * 
14  *     You should have received a copy of the GNU General Public License
15  *     along with this program; if not, write to the Free Software
16  *     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
17  */ 
18
19 #if HAVE_CONFIG_H
20 # include "config.h"
21 #endif
22
23 #include "mutt.h"
24 #include "mutt_curses.h"
25 #include "mutt_regex.h"
26 #include "keymap.h"
27 #include "mutt_menu.h"
28 #include "mapping.h"
29 #include "pager.h"
30 #include "attach.h"
31 #include "mbyte.h"
32
33 #include "mutt_crypt.h"
34
35 #include <sys/stat.h>
36 #include <ctype.h>
37 #include <unistd.h>
38 #include <stdlib.h>
39 #include <string.h>
40 #include <errno.h>
41
42 #define ISHEADER(x) ((x) == MT_COLOR_HEADER || (x) == MT_COLOR_HDEFAULT)
43
44 #define IsAttach(x) (x && (x)->bdy)
45 #define IsRecvAttach(x) (x && (x)->bdy && (x)->fp)
46 #define IsSendAttach(x) (x && (x)->bdy && !(x)->fp)
47 #define IsMsgAttach(x) (x && (x)->fp && (x)->bdy && (x)->bdy->hdr)
48 #define IsHeader(x) (x && (x)->hdr && !(x)->bdy)
49
50 static const char *Not_available_in_this_menu = N_("Not available in this menu.");
51 static const char *Mailbox_is_read_only = N_("Mailbox is read-only.");
52 static const char *Function_not_permitted_in_attach_message_mode = N_("Function not permitted in attach-message mode.");
53
54 /* hack to return to position when returning from index to same message */
55 static int TopLine = 0;
56 static HEADER *OldHdr = NULL;
57
58 #define CHECK_MODE(x)   if (!(x)) \
59                         { \
60                                 mutt_flushinp (); \
61                                 mutt_error _(Not_available_in_this_menu); \
62                                 break; \
63                         }
64
65 #define CHECK_READONLY  if (Context->readonly) \
66                         { \
67                                 mutt_flushinp (); \
68                                 mutt_error _(Mailbox_is_read_only);     \
69                                 break; \
70                         }
71
72 #define CHECK_ATTACH if(option(OPTATTACHMSG)) \
73                      {\
74                         mutt_flushinp (); \
75                         mutt_error _(Function_not_permitted_in_attach_message_mode); \
76                         break; \
77                      }
78
79 #define CHECK_ACL(aclbit,action) \
80                 if (!mutt_bit_isset(Context->rights,aclbit)) { \
81                         mutt_flushinp(); \
82                         mutt_error (_("Cannot %s: Operation not permitted by ACL"), action); \
83                         break; \
84                 }
85
86 struct q_class_t
87 {
88   int length;
89   int index;
90   int color;
91   char *prefix;
92   struct q_class_t *next, *prev;
93   struct q_class_t *down, *up;
94 };
95
96 struct syntax_t
97 {
98   int color;
99   int first;
100   int last;
101 };
102
103 struct line_t
104 {
105   LOFF_T offset;
106   short type;
107   short continuation;
108   short chunks;
109   short search_cnt;
110   struct syntax_t *syntax;
111   struct syntax_t *search;
112   struct q_class_t *quote;
113 };
114
115 #define ANSI_OFF       (1<<0)
116 #define ANSI_BLINK     (1<<1)
117 #define ANSI_BOLD      (1<<2)
118 #define ANSI_UNDERLINE (1<<3)
119 #define ANSI_REVERSE   (1<<4)
120 #define ANSI_COLOR     (1<<5)
121
122 typedef struct _ansi_attr {
123   int attr;
124   int fg;
125   int bg;
126   int pair;
127 } ansi_attr;
128
129 static short InHelp = 0;
130
131 #if defined (USE_SLANG_CURSES) || defined (HAVE_RESIZETERM)
132 static struct resize {
133   int line;
134   int SearchCompiled;
135   int SearchBack;
136 } *Resize = NULL;
137 #endif
138
139 #define NumSigLines 4
140
141 static int check_sig (const char *s, struct line_t *info, int n)
142 {
143   int count = 0;
144
145   while (n > 0 && count <= NumSigLines)
146   {
147     if (info[n].type != MT_COLOR_SIGNATURE)
148       break;
149     count++;
150     n--;
151   }
152
153   if (count == 0)
154     return (-1);
155
156   if (count > NumSigLines)
157   {
158     /* check for a blank line */
159     while (*s)
160     {
161       if (!ISSPACE (*s))
162         return 0;
163       s++;
164     }
165
166     return (-1);
167   }
168
169   return (0);
170 }
171
172 static void
173 resolve_color (struct line_t *lineInfo, int n, int cnt, int flags, int special,
174     ansi_attr *a)
175 {
176   int def_color;                /* color without syntax hilight */
177   int color;                    /* final color */
178   static int last_color;        /* last color set */
179   int search = 0, i, m;
180
181   if (!cnt)
182     last_color = -1;            /* force attrset() */
183
184   if (lineInfo[n].continuation)
185   {
186     if (!cnt && option (OPTMARKERS))
187     {
188       SETCOLOR (MT_COLOR_MARKERS);
189       addch ('+');
190       last_color = ColorDefs[MT_COLOR_MARKERS];
191     }
192     m = (lineInfo[n].syntax)[0].first;
193     cnt += (lineInfo[n].syntax)[0].last;
194   }
195   else
196     m = n;
197   if (!(flags & M_SHOWCOLOR))
198     def_color = ColorDefs[MT_COLOR_NORMAL];
199   else if (lineInfo[m].type == MT_COLOR_HEADER)
200     def_color = (lineInfo[m].syntax)[0].color;
201   else
202     def_color = ColorDefs[lineInfo[m].type];
203
204   if ((flags & M_SHOWCOLOR) && lineInfo[m].type == MT_COLOR_QUOTED)
205   {
206     struct q_class_t *class = lineInfo[m].quote;
207
208     if (class)
209     {
210       def_color = class->color;
211
212       while (class && class->length > cnt)
213       {
214         def_color = class->color;
215         class = class->up;
216       }
217     }
218   }
219
220   color = def_color;
221   if (flags & M_SHOWCOLOR)
222   {
223     for (i = 0; i < lineInfo[m].chunks; i++)
224     {
225       /* we assume the chunks are sorted */
226       if (cnt > (lineInfo[m].syntax)[i].last)
227         continue;
228       if (cnt < (lineInfo[m].syntax)[i].first)
229         break;
230       if (cnt != (lineInfo[m].syntax)[i].last)
231       {
232         color = (lineInfo[m].syntax)[i].color;
233         break;
234       }
235       /* don't break here, as cnt might be 
236        * in the next chunk as well */
237     }
238   }
239
240   if (flags & M_SEARCH)
241   {
242     for (i = 0; i < lineInfo[m].search_cnt; i++)
243     {
244       if (cnt > (lineInfo[m].search)[i].last)
245         continue;
246       if (cnt < (lineInfo[m].search)[i].first)
247         break;
248       if (cnt != (lineInfo[m].search)[i].last)
249       {
250         color = ColorDefs[MT_COLOR_SEARCH];
251         search = 1;
252         break;
253       }
254     }
255   }
256
257   /* handle "special" bold & underlined characters */
258   if (special || a->attr)
259   {
260 #ifdef HAVE_COLOR
261     if ((a->attr & ANSI_COLOR))
262     {
263       if (a->pair == -1)
264         a->pair = mutt_alloc_color (a->fg, a->bg);
265       color = a->pair;
266       if (a->attr & ANSI_BOLD)
267           color |= A_BOLD;
268     }
269     else
270 #endif
271       if ((special & A_BOLD) || (a->attr & ANSI_BOLD))
272     {
273       if (ColorDefs[MT_COLOR_BOLD] && !search)
274         color = ColorDefs[MT_COLOR_BOLD];
275       else
276         color ^= A_BOLD;
277     }
278     if ((special & A_UNDERLINE) || (a->attr & ANSI_UNDERLINE))
279     {
280       if (ColorDefs[MT_COLOR_UNDERLINE] && !search)
281         color = ColorDefs[MT_COLOR_UNDERLINE];
282       else
283         color ^= A_UNDERLINE;
284     }
285     else if (a->attr & ANSI_REVERSE) 
286     {
287       color ^= A_REVERSE;
288     }
289     else if (a->attr & ANSI_BLINK) 
290     {
291       color ^= A_BLINK;
292     }
293     else if (a->attr & ANSI_OFF)
294     {
295       a->attr = 0;
296     }
297   }
298
299   if (color != last_color)
300   {
301     attrset (color);
302     last_color = color;
303   }
304 }
305
306 static void
307 append_line (struct line_t *lineInfo, int n, int cnt)
308 {
309   int m;
310
311   lineInfo[n+1].type = lineInfo[n].type;
312   (lineInfo[n+1].syntax)[0].color = (lineInfo[n].syntax)[0].color;
313   lineInfo[n+1].continuation = 1;
314
315   /* find the real start of the line */
316   for (m = n; m >= 0; m--)
317     if (lineInfo[m].continuation == 0) break;
318
319   (lineInfo[n+1].syntax)[0].first = m;
320   (lineInfo[n+1].syntax)[0].last = (lineInfo[n].continuation) ? 
321     cnt + (lineInfo[n].syntax)[0].last : cnt;
322 }
323
324 static void
325 new_class_color (struct q_class_t *class, int *q_level)
326 {
327   class->index = (*q_level)++;
328   class->color = ColorQuote[class->index % ColorQuoteUsed];
329 }
330
331 static void
332 shift_class_colors (struct q_class_t *QuoteList, struct q_class_t *new_class,
333                       int index, int *q_level)
334 {
335   struct q_class_t * q_list;
336
337   q_list = QuoteList;
338   new_class->index = -1;
339
340   while (q_list)
341   {
342     if (q_list->index >= index)
343     {
344       q_list->index++;
345       q_list->color = ColorQuote[q_list->index % ColorQuoteUsed];
346     }
347     if (q_list->down)
348       q_list = q_list->down;
349     else if (q_list->next)
350       q_list = q_list->next;
351     else
352     {
353       while (!q_list->next)
354       {
355         q_list = q_list->up;
356         if (q_list == NULL)
357           break;
358       }
359       if (q_list)
360         q_list = q_list->next;
361     }
362   }
363
364   new_class->index = index;
365   new_class->color = ColorQuote[index % ColorQuoteUsed];
366   (*q_level)++;
367 }
368
369 static void
370 cleanup_quote (struct q_class_t **QuoteList)
371 {
372   struct q_class_t *ptr;
373
374   while (*QuoteList)
375   {
376     if ((*QuoteList)->down)
377       cleanup_quote (&((*QuoteList)->down));
378     ptr = (*QuoteList)->next;
379     if ((*QuoteList)->prefix)
380       FREE (&(*QuoteList)->prefix);
381     FREE (QuoteList);           /* __FREE_CHECKED__ */
382     *QuoteList = ptr;
383   }
384
385   return;
386 }
387
388 static struct q_class_t *
389 classify_quote (struct q_class_t **QuoteList, const char *qptr,
390                 int length, int *force_redraw, int *q_level)
391 {
392   struct q_class_t *q_list = *QuoteList;
393   struct q_class_t *class = NULL, *tmp = NULL, *ptr, *save;
394   char *tail_qptr;
395   int offset, tail_lng;
396   int index = -1;
397
398   if (ColorQuoteUsed <= 1)
399   {
400     /* not much point in classifying quotes... */
401
402     if (*QuoteList == NULL)
403     {
404       class = (struct q_class_t *) safe_calloc (1, sizeof (struct q_class_t));
405       class->color = ColorQuote[0];
406       *QuoteList = class;
407     }
408     return (*QuoteList);
409   }
410
411   /* Did I mention how much I like emulating Lisp in C? */
412
413   /* classify quoting prefix */
414   while (q_list)
415   {
416     if (length <= q_list->length)
417     {
418       /* case 1: check the top level nodes */
419
420       if (mutt_strncmp (qptr, q_list->prefix, length) == 0)
421       {
422         if (length == q_list->length)
423           return q_list;        /* same prefix: return the current class */
424
425         /* found shorter prefix */
426         if (tmp == NULL)
427         {
428           /* add a node above q_list */
429           tmp = (struct q_class_t *) safe_calloc (1, sizeof (struct q_class_t));
430           tmp->prefix = (char *) safe_calloc (1, length + 1);
431           strncpy (tmp->prefix, qptr, length);
432           tmp->length = length;
433
434           /* replace q_list by tmp in the top level list */
435           if (q_list->next)
436           {
437             tmp->next = q_list->next;
438             q_list->next->prev = tmp;
439           }
440           if (q_list->prev)
441           {
442             tmp->prev = q_list->prev;
443             q_list->prev->next = tmp;
444           }
445
446           /* make q_list a child of tmp */
447           tmp->down = q_list;
448           q_list->up = tmp;
449
450           /* q_list has no siblings for now */
451           q_list->next = NULL;
452           q_list->prev = NULL;
453
454           /* update the root if necessary */
455           if (q_list == *QuoteList)
456             *QuoteList = tmp;
457
458           index = q_list->index;
459
460           /* tmp should be the return class too */
461           class = tmp;
462
463           /* next class to test; if tmp is a shorter prefix for another
464            * node, that node can only be in the top level list, so don't
465            * go down after this point
466            */
467           q_list = tmp->next;
468         }
469         else
470         {
471           /* found another branch for which tmp is a shorter prefix */
472
473           /* save the next sibling for later */
474           save = q_list->next;
475
476           /* unlink q_list from the top level list */
477           if (q_list->next)
478             q_list->next->prev = q_list->prev;
479           if (q_list->prev)
480             q_list->prev->next = q_list->next;
481
482           /* at this point, we have a tmp->down; link q_list to it */
483           ptr = tmp->down;
484           /* sibling order is important here, q_list should be linked last */
485           while (ptr->next)
486             ptr = ptr->next;
487           ptr->next = q_list;
488           q_list->next = NULL;
489           q_list->prev = ptr;
490           q_list->up = tmp;
491
492           index = q_list->index;
493
494           /* next class to test; as above, we shouldn't go down */
495           q_list = save;
496         }
497
498         /* we found a shorter prefix, so certain quotes have changed classes */
499         *force_redraw = 1;
500         continue;
501       }
502       else
503       {
504         /* shorter, but not a substring of the current class: try next */
505         q_list = q_list->next;
506         continue;
507       }
508     }
509     else
510     {
511       /* case 2: try subclassing the current top level node */
512       
513       /* tmp != NULL means we already found a shorter prefix at case 1 */
514       if (tmp == NULL && mutt_strncmp (qptr, q_list->prefix, q_list->length) == 0)
515       {
516         /* ok, it's a subclass somewhere on this branch */
517
518         ptr = q_list;
519         offset = q_list->length;
520
521         q_list = q_list->down;
522         tail_lng = length - offset;
523         tail_qptr = (char *) qptr + offset;
524
525         while (q_list)
526         {
527           if (length <= q_list->length)
528           {
529             if (mutt_strncmp (tail_qptr, (q_list->prefix) + offset, tail_lng) == 0)
530             {
531               /* same prefix: return the current class */
532               if (length == q_list->length)
533                 return q_list;
534
535               /* found shorter common prefix */
536               if (tmp == NULL)
537               {
538                 /* add a node above q_list */
539                 tmp = (struct q_class_t *) safe_calloc (1, 
540                                             sizeof (struct q_class_t));
541                 tmp->prefix = (char *) safe_calloc (1, length + 1);
542                 strncpy (tmp->prefix, qptr, length);
543                 tmp->length = length;
544                         
545                 /* replace q_list by tmp */
546                 if (q_list->next)
547                 {
548                   tmp->next = q_list->next;
549                   q_list->next->prev = tmp;
550                 }
551                 if (q_list->prev)
552                 {
553                   tmp->prev = q_list->prev;
554                   q_list->prev->next = tmp;
555                 }
556
557                 /* make q_list a child of tmp */
558                 tmp->down = q_list;
559                 tmp->up = q_list->up;
560                 q_list->up = tmp;
561                 if (tmp->up->down == q_list)
562                   tmp->up->down = tmp;
563
564                 /* q_list has no siblings */
565                 q_list->next = NULL;
566                 q_list->prev = NULL;
567                               
568                 index = q_list->index;
569
570                 /* tmp should be the return class too */
571                 class = tmp;
572
573                 /* next class to test */
574                 q_list = tmp->next;
575               }
576               else
577               {
578                 /* found another branch for which tmp is a shorter prefix */
579
580                 /* save the next sibling for later */
581                 save = q_list->next;
582
583                 /* unlink q_list from the top level list */
584                 if (q_list->next)
585                   q_list->next->prev = q_list->prev;
586                 if (q_list->prev)
587                   q_list->prev->next = q_list->next;
588
589                 /* at this point, we have a tmp->down; link q_list to it */
590                 ptr = tmp->down;
591                 while (ptr->next)
592                   ptr = ptr->next;
593                 ptr->next = q_list;
594                 q_list->next = NULL;
595                 q_list->prev = ptr;
596                 q_list->up = tmp;
597
598                 index = q_list->index;
599
600                 /* next class to test */
601                 q_list = save;
602               }
603
604               /* we found a shorter prefix, so we need a redraw */
605               *force_redraw = 1;
606               continue;
607             }
608             else
609             {
610               q_list = q_list->next;
611               continue;
612             }
613           }
614           else
615           {
616             /* longer than the current prefix: try subclassing it */
617             if (tmp == NULL && mutt_strncmp (tail_qptr, (q_list->prefix) + offset,
618                           q_list->length - offset) == 0)
619             {
620               /* still a subclass: go down one level */
621               ptr = q_list;
622               offset = q_list->length;
623
624               q_list = q_list->down;
625               tail_lng = length - offset;
626               tail_qptr = (char *) qptr + offset;
627
628               continue;
629             }
630             else
631             {
632               /* nope, try the next prefix */
633               q_list = q_list->next;
634               continue;
635             }
636           }
637         }
638
639         /* still not found so far: add it as a sibling to the current node */
640         if (class == NULL)
641         {
642           tmp = (struct q_class_t *) safe_calloc (1, sizeof (struct q_class_t));
643           tmp->prefix = (char *) safe_calloc (1, length + 1);
644           strncpy (tmp->prefix, qptr, length);
645           tmp->length = length;
646
647           if (ptr->down)
648           {
649             tmp->next = ptr->down;
650             ptr->down->prev = tmp;
651           }
652           ptr->down = tmp;
653           tmp->up = ptr;
654
655           new_class_color (tmp, q_level);
656
657           return tmp;
658         }
659         else
660         {
661           if (index != -1)
662             shift_class_colors (*QuoteList, tmp, index, q_level);
663
664           return class;
665         }
666       }
667       else
668       {
669         /* nope, try the next prefix */
670         q_list = q_list->next;
671         continue;
672       }
673     }
674   }
675
676   if (class == NULL)
677   {
678     /* not found so far: add it as a top level class */
679     class = (struct q_class_t *) safe_calloc (1, sizeof (struct q_class_t));
680     class->prefix = (char *) safe_calloc (1, length + 1);
681     strncpy (class->prefix, qptr, length);
682     class->length = length;
683     new_class_color (class, q_level);
684
685     if (*QuoteList)
686     {
687       class->next = *QuoteList;
688       (*QuoteList)->prev = class;
689     }
690     *QuoteList = class;
691   }
692
693   if (index != -1)
694     shift_class_colors (*QuoteList, tmp, index, q_level);
695
696   return class;
697 }
698
699 static int brailleLine = -1;
700 static int brailleCol = -1;
701
702 static int check_attachment_marker (char *);
703
704 static void
705 resolve_types (char *buf, char *raw, struct line_t *lineInfo, int n, int last,
706                 struct q_class_t **QuoteList, int *q_level, int *force_redraw,
707                 int q_classify)
708 {
709   COLOR_LINE *color_line;
710   regmatch_t pmatch[1], smatch[1];
711   int found, offset, null_rx, i;
712
713   if (n == 0 || ISHEADER (lineInfo[n-1].type))
714   {
715     if (buf[0] == '\n') {
716       lineInfo[n].type = MT_COLOR_NORMAL;
717       getyx(stdscr, brailleLine, brailleCol);
718     } else if (n > 0 && (buf[0] == ' ' || buf[0] == '\t'))
719     {
720       lineInfo[n].type = lineInfo[n-1].type; /* wrapped line */
721       (lineInfo[n].syntax)[0].color = (lineInfo[n-1].syntax)[0].color;
722     }
723     else
724     {
725       lineInfo[n].type = MT_COLOR_HDEFAULT;
726       color_line = ColorHdrList;
727       while (color_line)
728       {
729         if (REGEXEC (color_line->rx, buf) == 0)
730         {
731           lineInfo[n].type = MT_COLOR_HEADER;
732           lineInfo[n].syntax[0].color = color_line->pair;
733           break;
734         }
735         color_line = color_line->next;
736       }
737     }
738   }
739   else if (mutt_strncmp ("\033[0m", raw, 4) == 0)       /* a little hack... */
740     lineInfo[n].type = MT_COLOR_NORMAL;
741 #if 0
742   else if (mutt_strncmp ("[-- ", buf, 4) == 0)
743     lineInfo[n].type = MT_COLOR_ATTACHMENT;
744 #else
745   else if (check_attachment_marker ((char *) raw) == 0)
746     lineInfo[n].type = MT_COLOR_ATTACHMENT;
747 #endif
748   else if (mutt_strcmp ("-- \n", buf) == 0 || mutt_strcmp ("-- \r\n", buf) == 0)
749   {
750     i = n + 1;
751
752     lineInfo[n].type = MT_COLOR_SIGNATURE;
753     while (i < last && check_sig (buf, lineInfo, i - 1) == 0 &&
754            (lineInfo[i].type == MT_COLOR_NORMAL ||
755             lineInfo[i].type == MT_COLOR_QUOTED ||
756             lineInfo[i].type == MT_COLOR_HEADER))
757       {
758         /* oops... */
759         if (lineInfo[i].chunks)
760         {
761           lineInfo[i].chunks = 0;
762           safe_realloc (&(lineInfo[n].syntax), 
763                         sizeof (struct syntax_t));
764         }
765         lineInfo[i++].type = MT_COLOR_SIGNATURE;
766       }
767   }
768   else if (check_sig (buf, lineInfo, n - 1) == 0)
769     lineInfo[n].type = MT_COLOR_SIGNATURE;
770   else if (regexec ((regex_t *) QuoteRegexp.rx, buf, 1, pmatch, 0) == 0)
771   {
772     if (regexec ((regex_t *) Smileys.rx, buf, 1, smatch, 0) == 0)
773     {
774       if (smatch[0].rm_so > 0)
775       {
776         char c;
777
778         /* hack to avoid making an extra copy of buf */
779         c = buf[smatch[0].rm_so];
780         buf[smatch[0].rm_so] = 0;
781
782         if (regexec ((regex_t *) QuoteRegexp.rx, buf, 1, pmatch, 0) == 0)
783         {
784           if (q_classify && lineInfo[n].quote == NULL)
785             lineInfo[n].quote = classify_quote (QuoteList,
786                                   buf + pmatch[0].rm_so,
787                                   pmatch[0].rm_eo - pmatch[0].rm_so,
788                                   force_redraw, q_level);
789           lineInfo[n].type = MT_COLOR_QUOTED;
790         }
791         else
792           lineInfo[n].type = MT_COLOR_NORMAL;
793
794         buf[smatch[0].rm_so] = c;
795       }
796       else
797         lineInfo[n].type = MT_COLOR_NORMAL;
798     }
799     else
800     {
801       if (q_classify && lineInfo[n].quote == NULL)
802         lineInfo[n].quote = classify_quote (QuoteList, buf + pmatch[0].rm_so,
803                               pmatch[0].rm_eo - pmatch[0].rm_so,
804                               force_redraw, q_level);
805       lineInfo[n].type = MT_COLOR_QUOTED;
806     }
807   }
808   else
809     lineInfo[n].type = MT_COLOR_NORMAL;
810
811   /* body patterns */
812   if (lineInfo[n].type == MT_COLOR_NORMAL || 
813       lineInfo[n].type == MT_COLOR_QUOTED)
814   {
815     size_t nl;
816
817     /* don't consider line endings part of the buffer
818      * for regex matching */
819     if ((nl = mutt_strlen (buf)) > 0 && buf[nl-1] == '\n')
820       buf[nl-1] = 0;
821
822     i = 0;
823     offset = 0;
824     lineInfo[n].chunks = 0;
825     do
826     {
827       if (!buf[offset])
828         break;
829
830       found = 0;
831       null_rx = 0;
832       color_line = ColorBodyList;
833       while (color_line)
834       {
835         if (regexec (&color_line->rx, buf + offset, 1, pmatch,
836                      (offset ? REG_NOTBOL : 0)) == 0)
837         {
838           if (pmatch[0].rm_eo != pmatch[0].rm_so)
839           {
840             if (!found)
841             {
842               if (++(lineInfo[n].chunks) > 1)
843                 safe_realloc (&(lineInfo[n].syntax), 
844                               (lineInfo[n].chunks) * sizeof (struct syntax_t));
845             }
846             i = lineInfo[n].chunks - 1;
847             pmatch[0].rm_so += offset;
848             pmatch[0].rm_eo += offset;
849             if (!found ||
850                 pmatch[0].rm_so < (lineInfo[n].syntax)[i].first ||
851                 (pmatch[0].rm_so == (lineInfo[n].syntax)[i].first &&
852                  pmatch[0].rm_eo > (lineInfo[n].syntax)[i].last))
853             {
854               (lineInfo[n].syntax)[i].color = color_line->pair;
855               (lineInfo[n].syntax)[i].first = pmatch[0].rm_so;
856               (lineInfo[n].syntax)[i].last = pmatch[0].rm_eo;
857             }
858             found = 1;
859             null_rx = 0;
860           }
861           else
862             null_rx = 1; /* empty regexp; don't add it, but keep looking */
863         }
864         color_line = color_line->next;
865       }
866
867       if (null_rx)
868         offset++; /* avoid degenerate cases */
869       else
870         offset = (lineInfo[n].syntax)[i].last;
871     } while (found || null_rx);
872     if (nl > 0)
873       buf[nl] = '\n';
874   }
875 }
876
877 static int is_ansi (unsigned char *buf)
878 {
879   while (*buf && (isdigit(*buf) || *buf == ';'))
880     buf++;
881   return (*buf == 'm');
882 }
883
884 static int check_attachment_marker (char *p)
885 {
886   char *q = AttachmentMarker;
887   
888   for (;*p == *q && *q && *p && *q != '\a' && *p != '\a'; p++, q++)
889     ;
890   return (int) (*p - *q);
891 }
892
893 static int grok_ansi(unsigned char *buf, int pos, ansi_attr *a)
894 {
895   int x = pos;
896
897   while (isdigit(buf[x]) || buf[x] == ';')
898     x++;
899
900   /* Character Attributes */
901   if (option (OPTALLOWANSI) && a != NULL && buf[x] == 'm')
902   {
903     if (pos == x)
904     {
905 #ifdef HAVE_COLOR
906       if (a->pair != -1)
907         mutt_free_color (a->fg, a->bg);
908 #endif
909       a->attr = ANSI_OFF;
910       a->pair = -1;
911     }
912     while (pos < x)
913     {
914       if (buf[pos] == '1' && (pos+1 == x || buf[pos+1] == ';'))
915       {
916         a->attr |= ANSI_BOLD;
917         pos += 2;
918       } 
919       else if (buf[pos] == '4' && (pos+1 == x || buf[pos+1] == ';'))
920       {
921         a->attr |= ANSI_UNDERLINE;
922         pos += 2;
923       }
924       else if (buf[pos] == '5' && (pos+1 == x || buf[pos+1] == ';'))
925       {
926         a->attr |= ANSI_BLINK;
927         pos += 2;
928       }
929       else if (buf[pos] == '7' && (pos+1 == x || buf[pos+1] == ';'))
930       {
931         a->attr |= ANSI_REVERSE;
932         pos += 2;
933       }
934       else if (buf[pos] == '0' && (pos+1 == x || buf[pos+1] == ';'))
935       {
936 #ifdef HAVE_COLOR
937         if (a->pair != -1)
938           mutt_free_color(a->fg,a->bg);
939 #endif
940         a->attr = ANSI_OFF;
941         a->pair = -1;
942         pos += 2;
943       }
944       else if (buf[pos] == '3' && isdigit(buf[pos+1]))
945       {
946 #ifdef HAVE_COLOR
947         if (a->pair != -1)
948           mutt_free_color(a->fg,a->bg);
949 #endif
950         a->pair = -1;
951         a->attr |= ANSI_COLOR;
952         a->fg = buf[pos+1] - '0';
953         pos += 3;
954       }
955       else if (buf[pos] == '4' && isdigit(buf[pos+1]))
956       {
957 #ifdef HAVE_COLOR
958         if (a->pair != -1)
959           mutt_free_color(a->fg,a->bg);
960 #endif
961         a->pair = -1;
962         a->attr |= ANSI_COLOR;
963         a->bg = buf[pos+1] - '0';
964         pos += 3;
965       }
966       else 
967       {
968         while (pos < x && buf[pos] != ';') pos++;
969         pos++;
970       }
971     }
972   }
973   pos = x;
974   return pos;
975 }
976
977 /* trim tail of buf so that it contains complete multibyte characters */
978 static int
979 trim_incomplete_mbyte(unsigned char *buf, size_t len)
980 {
981   mbstate_t mbstate;
982   size_t k;
983
984   memset (&mbstate, 0, sizeof (mbstate));
985   for (; len > 0; buf += k, len -= k)
986   {
987     k = mbrtowc (NULL, (char *) buf, len, &mbstate);
988     if (k == -2) 
989       break; 
990     else if (k == -1 || k == 0) 
991       k = 1;
992   }
993   *buf = '\0';
994
995   return len;
996 }
997
998 static int
999 fill_buffer (FILE *f, LOFF_T *last_pos, LOFF_T offset, unsigned char **buf,
1000              unsigned char **fmt, size_t *blen, int *buf_ready)
1001 {
1002   unsigned char *p, *q;
1003   static int b_read;
1004   int l;
1005
1006   if (*buf_ready == 0)
1007   {
1008     if (offset != *last_pos)
1009       fseeko (f, offset, 0);
1010     if ((*buf = (unsigned char *) mutt_read_line ((char *) *buf, blen, f, &l, M_EOL)) == NULL)
1011     {
1012       fmt[0] = 0;
1013       return (-1);
1014     }
1015     *last_pos = ftello (f);
1016     b_read = (int) (*last_pos - offset);
1017     *buf_ready = 1;
1018
1019     safe_realloc (fmt, *blen);
1020
1021     /* incomplete mbyte characters trigger a segfault in regex processing for
1022      * certain versions of glibc. Trim them if necessary. */
1023     if (b_read == *blen - 2)
1024       b_read -= trim_incomplete_mbyte(*buf, b_read);
1025     
1026     /* copy "buf" to "fmt", but without bold and underline controls */
1027     p = *buf;
1028     q = *fmt;
1029     while (*p)
1030     {
1031       if (*p == '\010' && (p > *buf))
1032       {
1033         if (*(p+1) == '_')      /* underline */
1034           p += 2;
1035         else if (*(p+1))        /* bold or overstrike */
1036         {
1037           *(q-1) = *(p+1);
1038           p += 2;
1039         }
1040         else                    /* ^H */
1041           *q++ = *p++;
1042       }
1043       else if (*p == '\033' && *(p+1) == '[' && is_ansi (p + 2))
1044       {
1045         while (*p++ != 'm')     /* skip ANSI sequence */
1046           ;
1047       }
1048       else if (*p == '\033' && *(p+1) == ']' && check_attachment_marker ((char *) p) == 0)
1049       {
1050         dprint (2, (debugfile, "fill_buffer: Seen attachment marker.\n"));
1051         while (*p++ != '\a')    /* skip pseudo-ANSI sequence */
1052           ;
1053       }
1054       else
1055         *q++ = *p++;
1056     }
1057     *q = 0;
1058   }
1059   return b_read;
1060 }
1061
1062
1063 static int format_line (struct line_t **lineInfo, int n, unsigned char *buf,
1064                         int flags, ansi_attr *pa, int cnt,
1065                         int *pspace, int *pvch, int *pcol, int *pspecial)
1066 {
1067   int space = -1; /* index of the last space or TAB */
1068   int col = option (OPTMARKERS) ? (*lineInfo)[n].continuation : 0;
1069   int ch, vch, k, last_special = -1, special = 0, t;
1070   wchar_t wc;
1071   mbstate_t mbstate;
1072
1073   int wrap_cols = mutt_term_width ((flags & M_PAGER_NOWRAP) ? 0 : Wrap);
1074   
1075   /* FIXME: this should come from lineInfo */
1076   memset(&mbstate, 0, sizeof(mbstate));
1077
1078   for (ch = 0, vch = 0; ch < cnt; ch += k, vch += k)
1079   {
1080     /* Handle ANSI sequences */
1081     while (cnt-ch >= 2 && buf[ch] == '\033' && buf[ch+1] == '[' &&
1082            is_ansi (buf+ch+2))
1083       ch = grok_ansi (buf, ch+2, pa) + 1;
1084
1085     while (cnt-ch >= 2 && buf[ch] == '\033' && buf[ch+1] == ']' &&
1086            check_attachment_marker ((char *) buf+ch) == 0)
1087     {
1088       while (buf[ch++] != '\a')
1089         if (ch >= cnt)
1090           break;
1091     }
1092
1093     /* is anything left to do? */
1094     if (ch >= cnt)
1095       break;
1096     
1097     k = mbrtowc (&wc, (char *)buf+ch, cnt-ch, &mbstate);
1098     if (k == -2 || k == -1)
1099     {
1100       dprint (1, (debugfile, "%s:%d: mbrtowc returned %d; errno = %d.\n",
1101                   __FILE__, __LINE__, k, errno));
1102       if (col + 4 > wrap_cols)
1103         break;
1104       col += 4;
1105       if (pa)
1106         printw ("\\%03o", buf[ch]);
1107       k = 1;
1108       continue;
1109     }
1110     if (k == 0)
1111       k = 1;
1112
1113     if (Charset_is_utf8 && (wc == 0x200B || wc == 0xFEFF))
1114     {
1115         dprint (3, (debugfile, "skip zero-width character U+%04X\n", (unsigned short)wc));
1116         continue;
1117     }
1118
1119     /* Handle backspace */
1120     special = 0;
1121     if (IsWPrint (wc))
1122     {
1123       wchar_t wc1;
1124       mbstate_t mbstate1;
1125       int k1, k2;
1126
1127       while ((wc1 = 0, mbstate1 = mbstate,
1128               k1 = k + mbrtowc (&wc1, (char *)buf+ch+k, cnt-ch-k, &mbstate1),
1129               k1 - k > 0 && wc1 == '\b') &&
1130              (wc1 = 0,
1131               k2 = mbrtowc (&wc1, (char *)buf+ch+k1, cnt-ch-k1, &mbstate1),
1132               k2 > 0 && IsWPrint (wc1)))
1133       {
1134         if (wc == wc1)
1135         {
1136           special |= (wc == '_' && special & A_UNDERLINE)
1137             ? A_UNDERLINE : A_BOLD;
1138         }
1139         else if (wc == '_' || wc1 == '_')
1140         {
1141           special |= A_UNDERLINE;
1142           wc = (wc1 == '_') ? wc : wc1;
1143         }
1144         else
1145         {
1146           /* special = 0; / * overstrike: nothing to do! */
1147           wc = wc1;
1148         }
1149         ch += k1;
1150         k = k2;
1151         mbstate = mbstate1;
1152       }
1153     }
1154
1155     if (pa &&
1156         ((flags & (M_SHOWCOLOR | M_SEARCH | M_PAGER_MARKER)) ||
1157          special || last_special || pa->attr))
1158     {
1159       resolve_color (*lineInfo, n, vch, flags, special, pa);
1160       last_special = special;
1161     }
1162
1163     if (IsWPrint (wc))
1164     {
1165       if (wc == ' ')
1166         space = ch;
1167       t = wcwidth (wc);
1168       if (col + t > wrap_cols)
1169         break;
1170       col += t;
1171       if (pa)
1172         mutt_addwch (wc);
1173     }
1174     else if (wc == '\n')
1175       break;
1176     else if (wc == '\t')
1177     {
1178       space = ch;
1179       t = (col & ~7) + 8;
1180       if (t > wrap_cols)
1181         break;
1182       if (pa)
1183         for (; col < t; col++)
1184           addch (' ');
1185       else
1186         col = t;
1187     }
1188     else if (wc < 0x20 || wc == 0x7f)
1189     {
1190       if (col + 2 > wrap_cols)
1191         break;
1192       col += 2;
1193       if (pa)
1194         printw ("^%c", ('@' + wc) & 0x7f);
1195     }
1196     else if (wc < 0x100)
1197     {
1198       if (col + 4 > wrap_cols)
1199         break;
1200       col += 4;
1201       if (pa)
1202         printw ("\\%03o", wc);
1203     }
1204     else
1205     {
1206       if (col + 1 > wrap_cols)
1207         break;
1208       ++col;
1209       if (pa)
1210         addch (replacement_char ());
1211     }
1212   }
1213   *pspace = space;
1214   *pcol = col;
1215   *pvch = vch;
1216   *pspecial = special;
1217   return ch;
1218 }
1219
1220 /*
1221  * Args:
1222  *      flags   M_SHOWFLAT, show characters (used for displaying help)
1223  *              M_SHOWCOLOR, show characters in color
1224  *                      otherwise don't show characters
1225  *              M_HIDE, don't show quoted text
1226  *              M_SEARCH, resolve search patterns
1227  *              M_TYPES, compute line's type
1228  *              M_PAGER_NSKIP, keeps leading whitespace
1229  *              M_PAGER_MARKER, eventually show markers
1230  *
1231  * Return values:
1232  *      -1      EOF was reached
1233  *      0       normal exit, line was not displayed
1234  *      >0      normal exit, line was displayed
1235  */
1236
1237 static int
1238 display_line (FILE *f, LOFF_T *last_pos, struct line_t **lineInfo, int n, 
1239               int *last, int *max, int flags, struct q_class_t **QuoteList,
1240               int *q_level, int *force_redraw, regex_t *SearchRE)
1241 {
1242   unsigned char *buf = NULL, *fmt = NULL;
1243   size_t buflen = 0;
1244   unsigned char *buf_ptr = buf;
1245   int ch, vch, col, cnt, b_read;
1246   int buf_ready = 0, change_last = 0;
1247   int special;
1248   int offset;
1249   int def_color;
1250   int m;
1251   int rc = -1;
1252   ansi_attr a = {0,0,0,-1};
1253   regmatch_t pmatch[1];
1254
1255   if (n == *last)
1256   {
1257     (*last)++;
1258     change_last = 1;
1259   }
1260
1261   if (*last == *max)
1262   {
1263     safe_realloc (lineInfo, sizeof (struct line_t) * (*max += LINES));
1264     for (ch = *last; ch < *max ; ch++)
1265     {
1266       memset (&((*lineInfo)[ch]), 0, sizeof (struct line_t));
1267       (*lineInfo)[ch].type = -1;
1268       (*lineInfo)[ch].search_cnt = -1;
1269       (*lineInfo)[ch].syntax = safe_malloc (sizeof (struct syntax_t));
1270       ((*lineInfo)[ch].syntax)[0].first = ((*lineInfo)[ch].syntax)[0].last = -1;
1271     }
1272   }
1273
1274   /* only do color hiliting if we are viewing a message */
1275   if (flags & (M_SHOWCOLOR | M_TYPES))
1276   {
1277     if ((*lineInfo)[n].type == -1)
1278     {
1279       /* determine the line class */
1280       if (fill_buffer (f, last_pos, (*lineInfo)[n].offset, &buf, &fmt, &buflen, &buf_ready) < 0)
1281       {
1282         if (change_last)
1283           (*last)--;
1284         goto out;
1285       }
1286
1287       resolve_types ((char *) fmt, (char *) buf, *lineInfo, n, *last,
1288                       QuoteList, q_level, force_redraw, flags & M_SHOWCOLOR);
1289
1290       /* avoid race condition for continuation lines when scrolling up */
1291       for (m = n + 1; m < *last && (*lineInfo)[m].offset && (*lineInfo)[m].continuation; m++)
1292         (*lineInfo)[m].type = (*lineInfo)[n].type;
1293     }
1294
1295     /* this also prevents searching through the hidden lines */
1296     if ((flags & M_HIDE) && (*lineInfo)[n].type == MT_COLOR_QUOTED)
1297       flags = 0; /* M_NOSHOW */
1298   }
1299
1300   /* At this point, (*lineInfo[n]).quote may still be undefined. We 
1301    * don't want to compute it every time M_TYPES is set, since this
1302    * would slow down the "bottom" function unacceptably. A compromise
1303    * solution is hence to call regexec() again, just to find out the
1304    * length of the quote prefix.
1305    */
1306   if ((flags & M_SHOWCOLOR) && !(*lineInfo)[n].continuation &&
1307       (*lineInfo)[n].type == MT_COLOR_QUOTED && (*lineInfo)[n].quote == NULL)
1308   {
1309     if (fill_buffer (f, last_pos, (*lineInfo)[n].offset, &buf, &fmt, &buflen, &buf_ready) < 0)
1310     {
1311       if (change_last)
1312         (*last)--;
1313       goto out;
1314     }
1315     regexec ((regex_t *) QuoteRegexp.rx, (char *) fmt, 1, pmatch, 0);
1316     (*lineInfo)[n].quote = classify_quote (QuoteList,
1317                             (char *) fmt + pmatch[0].rm_so,
1318                             pmatch[0].rm_eo - pmatch[0].rm_so,
1319                             force_redraw, q_level);
1320   }
1321
1322   if ((flags & M_SEARCH) && !(*lineInfo)[n].continuation && (*lineInfo)[n].search_cnt == -1) 
1323   {
1324     if (fill_buffer (f, last_pos, (*lineInfo)[n].offset, &buf, &fmt, &buflen, &buf_ready) < 0)
1325     {
1326       if (change_last)
1327         (*last)--;
1328       goto out;
1329     }
1330
1331     offset = 0;
1332     (*lineInfo)[n].search_cnt = 0;
1333     while (regexec (SearchRE, (char *) fmt + offset, 1, pmatch, (offset ? REG_NOTBOL : 0)) == 0)
1334     {
1335       if (++((*lineInfo)[n].search_cnt) > 1)
1336         safe_realloc (&((*lineInfo)[n].search),
1337                       ((*lineInfo)[n].search_cnt) * sizeof (struct syntax_t));
1338       else
1339         (*lineInfo)[n].search = safe_malloc (sizeof (struct syntax_t));
1340       pmatch[0].rm_so += offset;
1341       pmatch[0].rm_eo += offset;
1342       ((*lineInfo)[n].search)[(*lineInfo)[n].search_cnt - 1].first = pmatch[0].rm_so;
1343       ((*lineInfo)[n].search)[(*lineInfo)[n].search_cnt - 1].last = pmatch[0].rm_eo;
1344
1345       if (pmatch[0].rm_eo == pmatch[0].rm_so)
1346         offset++; /* avoid degenerate cases */
1347       else
1348         offset = pmatch[0].rm_eo;
1349       if (!fmt[offset])
1350         break;
1351     }
1352   }
1353
1354   if (!(flags & M_SHOW) && (*lineInfo)[n+1].offset > 0)
1355   {
1356     /* we've already scanned this line, so just exit */
1357     rc = 0;
1358     goto out;
1359   }
1360   if ((flags & M_SHOWCOLOR) && *force_redraw && (*lineInfo)[n+1].offset > 0)
1361   {
1362     /* no need to try to display this line... */
1363     rc = 1;
1364     goto out; /* fake display */
1365   }
1366
1367   if ((b_read = fill_buffer (f, last_pos, (*lineInfo)[n].offset, &buf, &fmt, 
1368                              &buflen, &buf_ready)) < 0)
1369   {
1370     if (change_last)
1371       (*last)--;
1372     goto out;
1373   }
1374
1375   /* now chose a good place to break the line */
1376   cnt = format_line (lineInfo, n, buf, flags, 0, b_read, &ch, &vch, &col, &special);
1377   buf_ptr = buf + cnt;
1378
1379   /* move the break point only if smart_wrap is set */
1380   if (option (OPTWRAP))
1381   {
1382     if (cnt < b_read)
1383     {
1384       if (ch != -1 && buf[cnt] != ' ' && buf[cnt] != '\t' && buf[cnt] != '\n' && buf[cnt] != '\r')
1385       {
1386         buf_ptr = buf + ch;
1387         /* skip trailing blanks */
1388         while (ch && (buf[ch] == ' ' || buf[ch] == '\t' || buf[ch] == '\r'))
1389           ch--;
1390         /* a very long word with leading spaces causes infinite wrapping */
1391         if ((!ch) && (flags & M_PAGER_NSKIP))
1392           buf_ptr = buf + cnt;
1393         else
1394           cnt = ch + 1;
1395       }
1396       else
1397         buf_ptr = buf + cnt; /* a very long word... */
1398     }
1399     if (!(flags & M_PAGER_NSKIP))
1400       /* skip leading blanks on the next line too */
1401       while (*buf_ptr == ' ' || *buf_ptr == '\t') 
1402         buf_ptr++;
1403   }
1404
1405   if (*buf_ptr == '\r')
1406     buf_ptr++;
1407   if (*buf_ptr == '\n')
1408     buf_ptr++;
1409
1410   if ((int) (buf_ptr - buf) < b_read && !(*lineInfo)[n+1].continuation)
1411     append_line (*lineInfo, n, (int) (buf_ptr - buf));
1412   (*lineInfo)[n+1].offset = (*lineInfo)[n].offset + (long) (buf_ptr - buf);
1413
1414   /* if we don't need to display the line we are done */
1415   if (!(flags & M_SHOW))
1416   {
1417     rc = 0;
1418     goto out;
1419   }
1420
1421   /* display the line */
1422   format_line (lineInfo, n, buf, flags, &a, cnt, &ch, &vch, &col, &special);
1423
1424   /* avoid a bug in ncurses... */
1425 #ifndef USE_SLANG_CURSES
1426   if (col == 0)
1427   {
1428     SETCOLOR (MT_COLOR_NORMAL);
1429     addch (' ');
1430   }
1431 #endif
1432
1433   /* end the last color pattern (needed by S-Lang) */
1434   if (special || (col != COLS && (flags & (M_SHOWCOLOR | M_SEARCH))))
1435     resolve_color (*lineInfo, n, vch, flags, 0, &a);
1436           
1437   /*
1438    * Fill the blank space at the end of the line with the prevailing color.
1439    * ncurses does an implicit clrtoeol() when you do addch('\n') so we have
1440    * to make sure to reset the color *after* that
1441    */
1442   if (flags & M_SHOWCOLOR)
1443   {
1444     m = ((*lineInfo)[n].continuation) ? ((*lineInfo)[n].syntax)[0].first : n;
1445     if ((*lineInfo)[m].type == MT_COLOR_HEADER)
1446       def_color = ((*lineInfo)[m].syntax)[0].color;
1447     else
1448       def_color = ColorDefs[ (*lineInfo)[m].type ];
1449
1450     attrset (def_color);
1451 #ifdef HAVE_BKGDSET
1452     bkgdset (def_color | ' ');
1453 #endif
1454   }
1455
1456   /* ncurses always wraps lines when you get to the right side of the
1457    * screen, but S-Lang seems to only wrap if the next character is *not*
1458    * a newline (grr!).
1459    */
1460 #ifndef USE_SLANG_CURSES
1461     if (col < COLS)
1462 #endif
1463       addch ('\n');
1464
1465   /*
1466    * reset the color back to normal.  This *must* come after the
1467    * addch('\n'), otherwise the color for this line will not be
1468    * filled to the right margin.
1469    */
1470   if (flags & M_SHOWCOLOR)
1471   {
1472     SETCOLOR(MT_COLOR_NORMAL);
1473     BKGDSET(MT_COLOR_NORMAL);
1474   }
1475
1476   /* build a return code */
1477   if (!(flags & M_SHOW))
1478     flags = 0;
1479
1480   rc = flags;
1481
1482 out:
1483   FREE(&buf);
1484   FREE(&fmt);
1485   return rc;
1486 }
1487
1488 static int
1489 upNLines (int nlines, struct line_t *info, int cur, int hiding)
1490 {
1491   while (cur > 0 && nlines > 0)
1492   {
1493     cur--;
1494     if (!hiding || info[cur].type != MT_COLOR_QUOTED)
1495       nlines--;
1496   }
1497
1498   return cur;
1499 }
1500
1501 static struct mapping_t PagerHelp[] = {
1502   { N_("Exit"), OP_EXIT },
1503   { N_("PrevPg"), OP_PREV_PAGE },
1504   { N_("NextPg"), OP_NEXT_PAGE },
1505   { NULL,       0 }
1506 };
1507 static struct mapping_t PagerHelpExtra[] = {
1508   { N_("View Attachm."), OP_VIEW_ATTACHMENTS },
1509   { N_("Del"), OP_DELETE },
1510   { N_("Reply"), OP_REPLY },
1511   { N_("Next"), OP_MAIN_NEXT_UNDELETED },
1512   { NULL,       0 }
1513 };
1514
1515
1516
1517 /* This pager is actually not so simple as it once was.  It now operates in
1518    two modes: one for viewing messages and the other for viewing help.  These
1519    can be distinguished by whether or not ``hdr'' is NULL.  The ``hdr'' arg
1520    is there so that we can do operations on the current message without the
1521    need to pop back out to the main-menu.  */
1522 int 
1523 mutt_pager (const char *banner, const char *fname, int flags, pager_t *extra)
1524 {
1525   static char searchbuf[STRING] = "";
1526   char buffer[LONG_STRING];
1527   char helpstr[SHORT_STRING*2];
1528   char tmphelp[SHORT_STRING*2];
1529   int maxLine, lastLine = 0;
1530   struct line_t *lineInfo;
1531   struct q_class_t *QuoteList = NULL;
1532   int i, j, ch = 0, rc = -1, hideQuoted = 0, q_level = 0, force_redraw = 0;
1533   int lines = 0, curline = 0, topline = 0, oldtopline = 0, err, first = 1;
1534   int r = -1, wrapped = 0, searchctx = 0;
1535   int redraw = REDRAW_FULL;
1536   FILE *fp = NULL;
1537   LOFF_T last_pos = 0, last_offset = 0;
1538   int old_smart_wrap, old_markers;
1539   struct stat sb;
1540   regex_t SearchRE;
1541   int SearchCompiled = 0, SearchFlag = 0, SearchBack = 0;
1542   int has_types = (IsHeader(extra) || (flags & M_SHOWCOLOR)) ? M_TYPES : 0; /* main message or rfc822 attachment */
1543
1544   int bodyoffset = 1;                   /* offset of first line of real text */
1545   int statusoffset = 0;                 /* offset for the status bar */
1546   int helpoffset = LINES - 2;           /* offset for the help bar. */
1547   int bodylen = LINES - 2 - bodyoffset; /* length of displayable area */
1548
1549   MUTTMENU *index = NULL;               /* the Pager Index (PI) */
1550   int indexoffset = 0;                  /* offset for the PI */
1551   int indexlen = PagerIndexLines;       /* indexlen not always == PIL */
1552   int indicator = indexlen / 3;         /* the indicator line of the PI */
1553   int old_PagerIndexLines;              /* some people want to resize it
1554                                          * while inside the pager... */
1555
1556   if (!(flags & M_SHOWCOLOR))
1557     flags |= M_SHOWFLAT;
1558
1559   if ((fp = fopen (fname, "r")) == NULL)
1560   {
1561     mutt_perror (fname);
1562     return (-1);
1563   }
1564
1565   if (stat (fname, &sb) != 0)
1566   {
1567     mutt_perror (fname);
1568     safe_fclose (&fp);
1569     return (-1);
1570   }
1571   unlink (fname);
1572
1573   /* Initialize variables */
1574
1575   if (IsHeader (extra) && !extra->hdr->read)
1576   {
1577     Context->msgnotreadyet = extra->hdr->msgno;
1578     mutt_set_flag (Context, extra->hdr, M_READ, 1);
1579   }
1580
1581   lineInfo = safe_malloc (sizeof (struct line_t) * (maxLine = LINES));
1582   for (i = 0 ; i < maxLine ; i++)
1583   {
1584     memset (&lineInfo[i], 0, sizeof (struct line_t));
1585     lineInfo[i].type = -1;
1586     lineInfo[i].search_cnt = -1;
1587     lineInfo[i].syntax = safe_malloc (sizeof (struct syntax_t));
1588     (lineInfo[i].syntax)[0].first = (lineInfo[i].syntax)[0].last = -1;
1589   }
1590
1591   mutt_compile_help (helpstr, sizeof (helpstr), MENU_PAGER, PagerHelp);
1592   if (IsHeader (extra))
1593   {
1594     strfcpy (tmphelp, helpstr, sizeof (tmphelp));
1595     mutt_compile_help (buffer, sizeof (buffer), MENU_PAGER, PagerHelpExtra);
1596     snprintf (helpstr, sizeof (helpstr), "%s %s", tmphelp, buffer);
1597   }
1598   if (!InHelp)
1599   {
1600     strfcpy (tmphelp, helpstr, sizeof (tmphelp));
1601     mutt_make_help (buffer, sizeof (buffer), _("Help"), MENU_PAGER, OP_HELP);
1602     snprintf (helpstr, sizeof (helpstr), "%s %s", tmphelp, buffer);
1603   }
1604
1605   while (ch != -1)
1606   {
1607     mutt_curs_set (0);
1608
1609     if (redraw & REDRAW_FULL)
1610     {
1611       SETCOLOR (MT_COLOR_NORMAL);
1612       /* clear() doesn't optimize screen redraws */
1613       move (0, 0);
1614       clrtobot ();
1615
1616       if (IsHeader (extra) && Context->vcount + 1 < PagerIndexLines)
1617         indexlen = Context->vcount + 1;
1618       else
1619         indexlen = PagerIndexLines;
1620
1621       indicator = indexlen / 3;
1622
1623       if (option (OPTSTATUSONTOP))
1624       {
1625         indexoffset = 0;
1626         statusoffset = IsHeader (extra) ? indexlen : 0;
1627         bodyoffset = statusoffset + 1;
1628         helpoffset = LINES - 2;
1629         bodylen = helpoffset - bodyoffset;
1630         if (!option (OPTHELP))
1631           bodylen++;
1632       }
1633       else
1634       {
1635         helpoffset = 0;
1636         indexoffset = 1;
1637         statusoffset = LINES - 2;
1638         if (!option (OPTHELP))
1639           indexoffset = 0;
1640         bodyoffset = indexoffset + (IsHeader (extra) ? indexlen : 0);
1641         bodylen = statusoffset - bodyoffset;
1642       }
1643
1644       if (option (OPTHELP))
1645       {
1646         SETCOLOR (MT_COLOR_STATUS);
1647         move (helpoffset, 0);
1648         mutt_paddstr (COLS, helpstr);
1649         SETCOLOR (MT_COLOR_NORMAL);
1650       }
1651
1652 #if defined (USE_SLANG_CURSES) || defined (HAVE_RESIZETERM)
1653       if (Resize != NULL)
1654       {
1655         if ((SearchCompiled = Resize->SearchCompiled))
1656         {
1657           REGCOMP
1658             (&SearchRE, searchbuf, REG_NEWLINE | mutt_which_case (searchbuf));
1659           SearchFlag = M_SEARCH;
1660           SearchBack = Resize->SearchBack;
1661         }
1662         lines = Resize->line;
1663         redraw |= REDRAW_SIGWINCH;
1664
1665         FREE (&Resize);
1666       }
1667 #endif
1668
1669       if (IsHeader (extra) && PagerIndexLines)
1670       {
1671         if (index == NULL)
1672         {
1673           /* only allocate the space if/when we need the index.
1674              Initialise the menu as per the main index */
1675           index = mutt_new_menu(MENU_MAIN);
1676           index->make_entry = index_make_entry;
1677           index->color = index_color;
1678           index->max = Context->vcount;
1679           index->current = extra->hdr->virtual;
1680         }
1681
1682         SETCOLOR (MT_COLOR_NORMAL);
1683         index->offset  = indexoffset + (option (OPTSTATUSONTOP) ? 1 : 0);
1684
1685         index->pagelen = indexlen - 1;
1686
1687         /* some fudge to work out where abouts the indicator should go */
1688         if (index->current - indicator < 0)
1689           index->top = 0;
1690         else if (index->max - index->current < index->pagelen - indicator)
1691           index->top = index->max - index->pagelen;
1692         else
1693           index->top = index->current - indicator;
1694
1695         menu_redraw_index(index);
1696       }
1697
1698       redraw |= REDRAW_BODY | REDRAW_INDEX | REDRAW_STATUS;
1699       mutt_show_error ();
1700     }
1701
1702     if (redraw & REDRAW_SIGWINCH)
1703     {
1704       i = -1;
1705       j = -1;
1706       while (display_line (fp, &last_pos, &lineInfo, ++i, &lastLine, &maxLine,
1707              has_types | SearchFlag | (flags & M_PAGER_NOWRAP), &QuoteList, &q_level, &force_redraw,
1708              &SearchRE) == 0)
1709         if (!lineInfo[i].continuation && ++j == lines)
1710         {
1711           topline = i;
1712           if (!SearchFlag)
1713             break;
1714         }
1715     }
1716
1717     if ((redraw & REDRAW_BODY) || topline != oldtopline)
1718     {
1719       do {
1720         move (bodyoffset, 0);
1721         curline = oldtopline = topline;
1722         lines = 0;
1723         force_redraw = 0;
1724
1725         while (lines < bodylen && lineInfo[curline].offset <= sb.st_size - 1)
1726         {
1727           if (display_line (fp, &last_pos, &lineInfo, curline, &lastLine, 
1728                             &maxLine,
1729                             (flags & M_DISPLAYFLAGS) | hideQuoted | SearchFlag | (flags & M_PAGER_NOWRAP),
1730                             &QuoteList, &q_level, &force_redraw, &SearchRE) > 0)
1731             lines++;
1732           curline++;
1733         }
1734         last_offset = lineInfo[curline].offset;
1735       } while (force_redraw);
1736
1737       SETCOLOR (MT_COLOR_TILDE);
1738       BKGDSET (MT_COLOR_TILDE);
1739       while (lines < bodylen)
1740       {
1741         clrtoeol ();
1742         if (option (OPTTILDE))
1743           addch ('~');
1744         addch ('\n');
1745         lines++;
1746       }
1747       /* We are going to update the pager status bar, so it isn't
1748        * necessary to reset to normal color now. */
1749
1750       redraw |= REDRAW_STATUS; /* need to update the % seen */
1751     }
1752
1753     if (redraw & REDRAW_STATUS)
1754     {
1755       struct hdr_format_info hfi;
1756       char pager_progress_str[4];
1757
1758       hfi.ctx = Context;
1759       hfi.pager_progress = pager_progress_str;
1760
1761       if (last_pos < sb.st_size - 1)
1762         snprintf(pager_progress_str, sizeof(pager_progress_str), OFF_T_FMT "%%", (100 * last_offset / sb.st_size));
1763       else
1764         strfcpy(pager_progress_str, (topline == 0) ? "all" : "end", sizeof(pager_progress_str));
1765
1766       /* print out the pager status bar */
1767       SETCOLOR (MT_COLOR_STATUS);
1768       BKGDSET (MT_COLOR_STATUS);
1769       CLEARLINE (statusoffset);
1770
1771       if (IsHeader (extra) || IsMsgAttach (extra))
1772       {
1773         size_t l1 = COLS * MB_LEN_MAX;
1774         size_t l2 = sizeof (buffer);
1775         hfi.hdr = (IsHeader (extra)) ? extra->hdr : extra->bdy->hdr;
1776         mutt_make_string_info (buffer, l1 < l2 ? l1 : l2, NONULL (PagerFmt), &hfi, M_FORMAT_MAKEPRINT);
1777         mutt_paddstr (COLS, buffer);
1778       }
1779       else
1780       {
1781         char bn[STRING];
1782         snprintf (bn, sizeof (bn), "%s (%s)", banner, pager_progress_str);
1783         mutt_paddstr (COLS, bn);
1784       }
1785       BKGDSET (MT_COLOR_NORMAL);
1786       SETCOLOR (MT_COLOR_NORMAL);
1787     }
1788
1789     if ((redraw & REDRAW_INDEX) && index)
1790     {
1791       /* redraw the pager_index indicator, because the
1792        * flags for this message might have changed. */
1793       menu_redraw_current (index);
1794
1795       /* print out the index status bar */
1796       menu_status_line (buffer, sizeof (buffer), index, NONULL(Status));
1797  
1798       move (indexoffset + (option (OPTSTATUSONTOP) ? 0 : (indexlen - 1)), 0);
1799       SETCOLOR (MT_COLOR_STATUS);
1800       BKGDSET (MT_COLOR_STATUS);
1801       mutt_paddstr (COLS, buffer);
1802       SETCOLOR (MT_COLOR_NORMAL);
1803       BKGDSET (MT_COLOR_NORMAL);
1804     }
1805
1806     redraw = 0;
1807
1808     if (option(OPTBRAILLEFRIENDLY)) {
1809       if (brailleLine!=-1) {
1810         move(brailleLine+1, 0);
1811         brailleLine = -1;
1812       }
1813     } else move (statusoffset, COLS-1);
1814     mutt_refresh ();
1815
1816     if (IsHeader (extra) && OldHdr == extra->hdr && TopLine != topline
1817         && lineInfo[curline].offset < sb.st_size-1)
1818     {
1819       if (TopLine - topline > lines)
1820         topline += lines;
1821       else
1822         topline = TopLine;
1823       continue;
1824     }
1825     else
1826       OldHdr = NULL;
1827       
1828     ch = km_dokey (MENU_PAGER);
1829     if (ch != -1)
1830       mutt_clear_error ();
1831     mutt_curs_set (1);
1832
1833     if (SigInt)
1834     {
1835       mutt_query_exit ();
1836       continue;
1837     }
1838 #if defined (USE_SLANG_CURSES) || defined (HAVE_RESIZETERM)
1839     else if (SigWinch)
1840     {
1841       mutt_resize_screen ();
1842
1843       /* Store current position. */
1844       lines = -1;
1845       for (i = 0; i <= topline; i++)
1846         if (!lineInfo[i].continuation)
1847           lines++;
1848
1849       if (flags & M_PAGER_RETWINCH)
1850       {
1851         Resize = safe_malloc (sizeof (struct resize));
1852
1853         Resize->line = lines;
1854         Resize->SearchCompiled = SearchCompiled;
1855         Resize->SearchBack = SearchBack;
1856
1857         ch = -1;
1858         rc = OP_REFORMAT_WINCH;
1859       }
1860       else
1861       {
1862         for (i = 0; i < maxLine; i++)
1863         {
1864           lineInfo[i].offset = 0;
1865           lineInfo[i].type = -1;
1866           lineInfo[i].continuation = 0;
1867           lineInfo[i].chunks = 0;
1868           lineInfo[i].search_cnt = -1;
1869           lineInfo[i].quote = NULL;
1870
1871           safe_realloc (&(lineInfo[i].syntax),
1872                         sizeof (struct syntax_t));
1873           if (SearchCompiled && lineInfo[i].search)
1874               FREE (&(lineInfo[i].search));
1875         }
1876
1877         lastLine = 0;
1878         topline = 0;
1879
1880         redraw = REDRAW_FULL | REDRAW_SIGWINCH;
1881         ch = 0;
1882       }
1883
1884       SigWinch = 0;
1885       clearok(stdscr,TRUE);/*force complete redraw*/
1886       continue;
1887     }
1888 #endif
1889     else if (ch == -1)
1890     {
1891       ch = 0;
1892       continue;
1893     }
1894
1895     rc = ch;
1896
1897     switch (ch)
1898     {
1899       case OP_EXIT:
1900         rc = -1;
1901         ch = -1;
1902         break;
1903
1904       case OP_NEXT_PAGE:
1905         if (lineInfo[curline].offset < sb.st_size-1)
1906         {
1907           topline = upNLines (PagerContext, lineInfo, curline, hideQuoted);
1908         }
1909         else if (option (OPTPAGERSTOP))
1910         {
1911           /* emulate "less -q" and don't go on to the next message. */
1912           mutt_error _("Bottom of message is shown.");
1913         }
1914         else
1915         {
1916           /* end of the current message, so display the next message. */
1917           rc = OP_MAIN_NEXT_UNDELETED;
1918           ch = -1;
1919         }
1920         break;
1921
1922       case OP_PREV_PAGE:
1923         if (topline != 0)
1924         {
1925           topline = upNLines (bodylen-PagerContext, lineInfo, topline, hideQuoted);
1926         }
1927         else
1928           mutt_error _("Top of message is shown.");
1929         break;
1930
1931       case OP_NEXT_LINE:
1932         if (lineInfo[curline].offset < sb.st_size-1)
1933         {
1934           topline++;
1935           if (hideQuoted)
1936           {
1937             while (lineInfo[topline].type == MT_COLOR_QUOTED &&
1938                    topline < lastLine)
1939               topline++;
1940           }
1941         }
1942         else
1943           mutt_error _("Bottom of message is shown.");
1944         break;
1945
1946       case OP_PREV_LINE:
1947         if (topline)
1948           topline = upNLines (1, lineInfo, topline, hideQuoted);
1949         else
1950           mutt_error _("Top of message is shown.");
1951         break;
1952
1953       case OP_PAGER_TOP:
1954         if (topline)
1955           topline = 0;
1956         else
1957           mutt_error _("Top of message is shown.");
1958         break;
1959
1960       case OP_HALF_UP:
1961         if (topline)
1962           topline = upNLines (bodylen/2, lineInfo, topline, hideQuoted);
1963         else
1964           mutt_error _("Top of message is shown.");
1965         break;
1966
1967       case OP_HALF_DOWN:
1968         if (lineInfo[curline].offset < sb.st_size-1)
1969         {
1970           topline = upNLines (bodylen/2, lineInfo, curline, hideQuoted);
1971         }
1972         else if (option (OPTPAGERSTOP))
1973         {
1974           /* emulate "less -q" and don't go on to the next message. */
1975           mutt_error _("Bottom of message is shown.");
1976         }
1977         else
1978         {
1979           /* end of the current message, so display the next message. */
1980           rc = OP_MAIN_NEXT_UNDELETED;
1981           ch = -1;
1982         }
1983         break;
1984
1985       case OP_SEARCH_NEXT:
1986       case OP_SEARCH_OPPOSITE:
1987         if (SearchCompiled)
1988         {
1989           wrapped = 0;
1990
1991           if (SearchContext > 0 && SearchContext < LINES - 2 - option (OPTHELP) ? 1 : 0)
1992             searchctx = SearchContext;
1993           else
1994             searchctx = 0;
1995
1996 search_next:
1997           if ((!SearchBack && ch==OP_SEARCH_NEXT) ||
1998               (SearchBack &&ch==OP_SEARCH_OPPOSITE))
1999           {
2000             /* searching forward */
2001             for (i = wrapped ? 0 : topline + searchctx + 1; i < lastLine; i++)
2002             {
2003               if ((!hideQuoted || lineInfo[i].type != MT_COLOR_QUOTED) && 
2004                     !lineInfo[i].continuation && lineInfo[i].search_cnt > 0)
2005                 break;
2006             }
2007
2008             if (i < lastLine)
2009               topline = i;
2010             else if (wrapped || !option (OPTWRAPSEARCH))
2011               mutt_error _("Not found.");
2012             else
2013             {
2014               mutt_message _("Search wrapped to top.");
2015               wrapped = 1;
2016               goto search_next;
2017             }
2018           }
2019           else
2020           {
2021             /* searching backward */
2022             for (i = wrapped ? lastLine : topline + searchctx - 1; i >= 0; i--)
2023             {
2024               if ((!hideQuoted || (has_types && 
2025                     lineInfo[i].type != MT_COLOR_QUOTED)) && 
2026                     !lineInfo[i].continuation && lineInfo[i].search_cnt > 0)
2027                 break;
2028             }
2029
2030             if (i >= 0)
2031               topline = i;
2032             else if (wrapped || !option (OPTWRAPSEARCH))
2033               mutt_error _("Not found.");
2034             else
2035             {
2036               mutt_message _("Search wrapped to bottom.");
2037               wrapped = 1;
2038               goto search_next;
2039             }
2040           }
2041
2042           if (lineInfo[topline].search_cnt > 0)
2043           {
2044             SearchFlag = M_SEARCH;
2045             /* give some context for search results */
2046             if (topline - searchctx > 0)
2047               topline -= searchctx;
2048           }
2049
2050           break;
2051         }
2052         /* no previous search pattern, so fall through to search */
2053
2054       case OP_SEARCH:
2055       case OP_SEARCH_REVERSE:
2056         strfcpy (buffer, searchbuf, sizeof (buffer));
2057         if (mutt_get_field ((ch == OP_SEARCH || ch == OP_SEARCH_NEXT) ?
2058                             _("Search for: ") : _("Reverse search for: "),
2059                             buffer, sizeof (buffer),
2060                             M_CLEAR) != 0)
2061           break;
2062
2063         if (!strcmp (buffer, searchbuf))
2064         {
2065           if (SearchCompiled)
2066           {
2067             /* do an implicit search-next */
2068             if (ch == OP_SEARCH)
2069               ch = OP_SEARCH_NEXT;
2070             else
2071               ch = OP_SEARCH_OPPOSITE;
2072
2073             wrapped = 0;
2074             goto search_next;
2075           }
2076         }
2077       
2078         if (!buffer[0])
2079           break;
2080       
2081         strfcpy (searchbuf, buffer, sizeof (searchbuf));
2082
2083         /* leave SearchBack alone if ch == OP_SEARCH_NEXT */
2084         if (ch == OP_SEARCH)
2085           SearchBack = 0;
2086         else if (ch == OP_SEARCH_REVERSE)
2087           SearchBack = 1;
2088
2089         if (SearchCompiled)
2090         {
2091           regfree (&SearchRE);
2092           for (i = 0; i < lastLine; i++)
2093           {
2094             if (lineInfo[i].search)
2095               FREE (&(lineInfo[i].search));
2096             lineInfo[i].search_cnt = -1;
2097           }
2098         }
2099
2100         if ((err = REGCOMP (&SearchRE, searchbuf, REG_NEWLINE | mutt_which_case (searchbuf))) != 0)
2101         {
2102           regerror (err, &SearchRE, buffer, sizeof (buffer));
2103           mutt_error ("%s", buffer);
2104           regfree (&SearchRE);
2105           for (i = 0; i < maxLine ; i++)
2106           {
2107             /* cleanup */
2108             if (lineInfo[i].search)
2109               FREE (&(lineInfo[i].search));
2110             lineInfo[i].search_cnt = -1;
2111           }
2112           SearchFlag = 0;
2113           SearchCompiled = 0;
2114         }
2115         else
2116         {
2117           SearchCompiled = 1;
2118           /* update the search pointers */
2119           i = 0;
2120           while (display_line (fp, &last_pos, &lineInfo, i, &lastLine, 
2121                                 &maxLine, M_SEARCH | (flags & M_PAGER_NSKIP) | (flags & M_PAGER_NOWRAP),
2122                                 &QuoteList, &q_level,
2123                                 &force_redraw, &SearchRE) == 0)
2124             i++;
2125
2126           if (!SearchBack)
2127           {
2128             /* searching forward */
2129             for (i = topline; i < lastLine; i++)
2130             {
2131               if ((!hideQuoted || lineInfo[i].type != MT_COLOR_QUOTED) && 
2132                     !lineInfo[i].continuation && lineInfo[i].search_cnt > 0)
2133                 break;
2134             }
2135
2136             if (i < lastLine) topline = i;
2137           }
2138           else
2139           {
2140             /* searching backward */
2141             for (i = topline; i >= 0; i--)
2142             {
2143               if ((!hideQuoted || lineInfo[i].type != MT_COLOR_QUOTED) && 
2144                     !lineInfo[i].continuation && lineInfo[i].search_cnt > 0)
2145                 break;
2146             }
2147
2148             if (i >= 0) topline = i;
2149           }
2150
2151           if (lineInfo[topline].search_cnt == 0)
2152           {
2153             SearchFlag = 0;
2154             mutt_error _("Not found.");
2155           }
2156           else
2157           {
2158             SearchFlag = M_SEARCH;
2159             /* give some context for search results */
2160             if (SearchContext > 0 && SearchContext < LINES - 2 - option (OPTHELP) ? 1 : 0)
2161               searchctx = SearchContext;
2162             else
2163               searchctx = 0;
2164             if (topline - searchctx > 0)
2165               topline -= searchctx;
2166           }
2167
2168         }
2169         redraw = REDRAW_BODY;
2170         break;
2171
2172       case OP_SEARCH_TOGGLE:
2173         if (SearchCompiled)
2174         {
2175           SearchFlag ^= M_SEARCH;
2176           redraw = REDRAW_BODY;
2177         }
2178         break;
2179
2180       case OP_HELP:
2181         /* don't let the user enter the help-menu from the help screen! */
2182         if (! InHelp)
2183         {
2184           InHelp = 1;
2185           mutt_help (MENU_PAGER);
2186           redraw = REDRAW_FULL;
2187           InHelp = 0;
2188         }
2189         else
2190           mutt_error _("Help is currently being shown.");
2191         break;
2192
2193       case OP_PAGER_HIDE_QUOTED:
2194         if (has_types)
2195         {
2196           hideQuoted ^= M_HIDE;
2197           if (hideQuoted && lineInfo[topline].type == MT_COLOR_QUOTED)
2198             topline = upNLines (1, lineInfo, topline, hideQuoted);
2199           else
2200             redraw = REDRAW_BODY;
2201         }
2202         break;
2203
2204       case OP_PAGER_SKIP_QUOTED:
2205         if (has_types)
2206         {
2207           int dretval = 0;
2208           int new_topline = topline;
2209
2210           while ((new_topline < lastLine ||
2211                   (0 == (dretval = display_line (fp, &last_pos, &lineInfo,
2212                          new_topline, &lastLine, &maxLine, M_TYPES | (flags & M_PAGER_NOWRAP),
2213                          &QuoteList, &q_level, &force_redraw, &SearchRE))))
2214                  && lineInfo[new_topline].type != MT_COLOR_QUOTED)
2215             new_topline++;
2216
2217           if (dretval < 0)
2218           {
2219             mutt_error _("No more quoted text.");
2220             break;
2221           }
2222
2223           while ((new_topline < lastLine ||
2224                   (0 == (dretval = display_line (fp, &last_pos, &lineInfo,
2225                          new_topline, &lastLine, &maxLine, M_TYPES | (flags & M_PAGER_NOWRAP),
2226                          &QuoteList, &q_level, &force_redraw, &SearchRE))))
2227                  && lineInfo[new_topline].type == MT_COLOR_QUOTED)
2228             new_topline++;
2229
2230           if (dretval < 0)
2231           {
2232             mutt_error _("No more unquoted text after quoted text.");
2233             break;        
2234           }
2235           topline = new_topline;
2236         }
2237         break;
2238
2239       case OP_PAGER_BOTTOM: /* move to the end of the file */
2240         if (lineInfo[curline].offset < sb.st_size - 1)
2241         {
2242           i = curline;
2243           /* make sure the types are defined to the end of file */
2244           while (display_line (fp, &last_pos, &lineInfo, i, &lastLine, 
2245                                 &maxLine, has_types | (flags & M_PAGER_NOWRAP),
2246                                 &QuoteList, &q_level, &force_redraw,
2247                                 &SearchRE) == 0)
2248             i++;
2249           topline = upNLines (bodylen, lineInfo, lastLine, hideQuoted);
2250         }
2251         else
2252           mutt_error _("Bottom of message is shown.");
2253         break;
2254
2255       case OP_REDRAW:
2256         clearok (stdscr, TRUE);
2257         redraw = REDRAW_FULL;
2258         break;
2259
2260       case OP_NULL:
2261         km_error_key (MENU_PAGER);
2262         break;
2263
2264         /* --------------------------------------------------------------------
2265          * The following are operations on the current message rather than
2266          * adjusting the view of the message.
2267          */
2268
2269       case OP_BOUNCE_MESSAGE:
2270         CHECK_MODE(IsHeader (extra) || IsMsgAttach (extra))
2271         CHECK_ATTACH;
2272         if (IsMsgAttach (extra))
2273           mutt_attach_bounce (extra->fp, extra->hdr,
2274                               extra->idx, extra->idxlen,
2275                               extra->bdy);
2276         else
2277           ci_bounce_message (extra->hdr, &redraw);
2278         break;
2279
2280       case OP_RESEND:
2281         CHECK_MODE(IsHeader (extra) || IsMsgAttach (extra))
2282         CHECK_ATTACH;
2283         if (IsMsgAttach (extra))
2284           mutt_attach_resend (extra->fp, extra->hdr,
2285                               extra->idx, extra->idxlen,
2286                               extra->bdy);
2287         else
2288           mutt_resend_message (NULL, extra->ctx, extra->hdr);
2289         redraw = REDRAW_FULL;
2290         break;
2291
2292       case OP_CHECK_TRADITIONAL:
2293         CHECK_MODE (IsHeader (extra));
2294         if (!(WithCrypto & APPLICATION_PGP))
2295           break;
2296         if (!(extra->hdr->security & PGP_TRADITIONAL_CHECKED)) 
2297         {
2298           ch = -1;
2299           rc = OP_CHECK_TRADITIONAL;
2300         }
2301         break;
2302       
2303       case OP_CREATE_ALIAS:
2304         CHECK_MODE(IsHeader (extra) || IsMsgAttach (extra));
2305         if (IsMsgAttach (extra))
2306           mutt_create_alias (extra->bdy->hdr->env, NULL);
2307         else
2308           mutt_create_alias (extra->hdr->env, NULL);
2309         MAYBE_REDRAW (redraw);
2310         break;
2311
2312       case OP_DELETE:
2313         CHECK_MODE(IsHeader (extra));
2314         CHECK_READONLY;
2315         CHECK_ACL(M_ACL_DELETE, _("delete message"));
2316
2317         mutt_set_flag (Context, extra->hdr, M_DELETE, 1);
2318         if (option (OPTDELETEUNTAG))
2319           mutt_set_flag (Context, extra->hdr, M_TAG, 0);
2320         redraw = REDRAW_STATUS | REDRAW_INDEX;
2321         if (option (OPTRESOLVE))
2322         {
2323           ch = -1;
2324           rc = OP_MAIN_NEXT_UNDELETED;
2325         }
2326         break;
2327
2328       case OP_MAIN_SET_FLAG:
2329       case OP_MAIN_CLEAR_FLAG:
2330         CHECK_MODE(IsHeader (extra));
2331         CHECK_READONLY;
2332
2333         if (mutt_change_flag (extra->hdr, (ch == OP_MAIN_SET_FLAG)) == 0)
2334           redraw |= REDRAW_STATUS | REDRAW_INDEX;
2335         if (extra->hdr->deleted && option (OPTRESOLVE))
2336         {
2337           ch = -1;
2338           rc = OP_MAIN_NEXT_UNDELETED;
2339         }
2340         break;
2341
2342       case OP_DELETE_THREAD:
2343       case OP_DELETE_SUBTHREAD:
2344         CHECK_MODE(IsHeader (extra));
2345         CHECK_READONLY;
2346         CHECK_ACL(M_ACL_DELETE, _("delete message(s)"));
2347
2348         r = mutt_thread_set_flag (extra->hdr, M_DELETE, 1,
2349                                   ch == OP_DELETE_THREAD ? 0 : 1);
2350
2351         if (r != -1)
2352         {
2353           if (option (OPTDELETEUNTAG))
2354             mutt_thread_set_flag (extra->hdr, M_TAG, 0,
2355                                   ch == OP_DELETE_THREAD ? 0 : 1);
2356           if (option (OPTRESOLVE))
2357           {
2358             rc = OP_MAIN_NEXT_UNDELETED;
2359             ch = -1;
2360           }
2361
2362           if (!option (OPTRESOLVE) && PagerIndexLines)
2363             redraw = REDRAW_FULL;
2364           else
2365             redraw = REDRAW_STATUS | REDRAW_INDEX;
2366         }
2367         break;
2368
2369       case OP_DISPLAY_ADDRESS:
2370         CHECK_MODE(IsHeader (extra) || IsMsgAttach (extra));
2371         if (IsMsgAttach (extra))
2372           mutt_display_address (extra->bdy->hdr->env);
2373         else
2374           mutt_display_address (extra->hdr->env);
2375         break;
2376
2377       case OP_ENTER_COMMAND:
2378         old_smart_wrap = option (OPTWRAP);
2379         old_markers = option (OPTMARKERS);
2380         old_PagerIndexLines = PagerIndexLines;
2381
2382         CurrentMenu = MENU_PAGER;
2383         mutt_enter_command ();
2384
2385         if (option (OPTNEEDRESORT))
2386         {
2387           unset_option (OPTNEEDRESORT);
2388           CHECK_MODE(IsHeader (extra));
2389           set_option (OPTNEEDRESORT);
2390         }
2391
2392         if (old_PagerIndexLines != PagerIndexLines)
2393         {
2394           if (index)
2395             mutt_menuDestroy (&index);
2396           index = NULL;
2397         }
2398         
2399         if (option (OPTWRAP) != old_smart_wrap || 
2400             option (OPTMARKERS) != old_markers)
2401         {
2402           if (flags & M_PAGER_RETWINCH)
2403           {
2404             ch = -1;
2405             rc = OP_REFORMAT_WINCH;
2406             continue;
2407           }
2408
2409           /* count the real lines above */
2410           j = 0;
2411           for (i = 0; i <= topline; i++)
2412           {
2413             if (!lineInfo[i].continuation)
2414               j++;
2415           }
2416
2417           /* we need to restart the whole thing */
2418           for (i = 0; i < maxLine; i++)
2419           {
2420             lineInfo[i].offset = 0;
2421             lineInfo[i].type = -1;
2422             lineInfo[i].continuation = 0;
2423             lineInfo[i].chunks = 0;
2424             lineInfo[i].search_cnt = -1;
2425             lineInfo[i].quote = NULL;
2426
2427             safe_realloc (&(lineInfo[i].syntax), sizeof (struct syntax_t));
2428             if (SearchCompiled && lineInfo[i].search)
2429                 FREE (&(lineInfo[i].search));
2430           }
2431
2432           if (SearchCompiled)
2433           {
2434             regfree (&SearchRE);
2435             SearchCompiled = 0;
2436           }
2437           SearchFlag = 0;
2438
2439           /* try to keep the old position */
2440           topline = 0;
2441           lastLine = 0;
2442           while (j > 0 && display_line (fp, &last_pos, &lineInfo, topline, 
2443                                         &lastLine, &maxLine,
2444                                         (has_types ? M_TYPES : 0) | (flags & M_PAGER_NOWRAP),
2445                                         &QuoteList, &q_level, &force_redraw,
2446                                         &SearchRE) == 0)
2447           {
2448             if (! lineInfo[topline].continuation)
2449               j--;
2450             if (j > 0)
2451               topline++;
2452           }
2453
2454           ch = 0;
2455         }
2456
2457         if (option (OPTFORCEREDRAWPAGER))
2458           redraw = REDRAW_FULL;
2459         unset_option (OPTFORCEREDRAWINDEX);
2460         unset_option (OPTFORCEREDRAWPAGER);
2461         break;
2462
2463       case OP_FLAG_MESSAGE:
2464         CHECK_MODE(IsHeader (extra));
2465         CHECK_READONLY;
2466         CHECK_ACL(M_ACL_WRITE, "flag message");
2467
2468         mutt_set_flag (Context, extra->hdr, M_FLAG, !extra->hdr->flagged);
2469         redraw = REDRAW_STATUS | REDRAW_INDEX;
2470         if (option (OPTRESOLVE))
2471         {
2472           ch = -1;
2473           rc = OP_MAIN_NEXT_UNDELETED;
2474         }
2475         break;
2476
2477       case OP_PIPE:
2478         CHECK_MODE(IsHeader (extra) || IsAttach (extra));
2479         if (IsAttach (extra))
2480           mutt_pipe_attachment_list (extra->fp, 0, extra->bdy, 0);
2481         else
2482           mutt_pipe_message (extra->hdr);
2483         MAYBE_REDRAW (redraw);
2484         break;
2485
2486       case OP_PRINT:
2487         CHECK_MODE(IsHeader (extra) || IsAttach (extra));
2488         if (IsAttach (extra))
2489           mutt_print_attachment_list (extra->fp, 0, extra->bdy);
2490         else
2491           mutt_print_message (extra->hdr);
2492         break;
2493
2494       case OP_MAIL:
2495         CHECK_MODE(IsHeader (extra) && !IsAttach (extra));
2496         CHECK_ATTACH;      
2497         ci_send_message (0, NULL, NULL, extra->ctx, NULL);
2498         redraw = REDRAW_FULL;
2499         break;
2500
2501       case OP_REPLY:
2502         CHECK_MODE(IsHeader (extra) || IsMsgAttach (extra));
2503         CHECK_ATTACH;      
2504         if (IsMsgAttach (extra)) 
2505           mutt_attach_reply (extra->fp, extra->hdr, extra->idx,
2506                              extra->idxlen, extra->bdy,
2507                              SENDREPLY);
2508         else
2509           ci_send_message (SENDREPLY, NULL, NULL, extra->ctx, extra->hdr);
2510         redraw = REDRAW_FULL;
2511         break;
2512
2513       case OP_RECALL_MESSAGE:
2514         CHECK_MODE(IsHeader (extra) && !IsAttach(extra));
2515         CHECK_ATTACH;
2516         ci_send_message (SENDPOSTPONED, NULL, NULL, extra->ctx, extra->hdr);
2517         redraw = REDRAW_FULL;
2518         break;
2519
2520       case OP_GROUP_REPLY:
2521         CHECK_MODE(IsHeader (extra) || IsMsgAttach (extra));
2522         CHECK_ATTACH;
2523         if (IsMsgAttach (extra))
2524           mutt_attach_reply (extra->fp, extra->hdr, extra->idx,
2525                              extra->idxlen, extra->bdy, SENDREPLY|SENDGROUPREPLY);
2526         else
2527           ci_send_message (SENDREPLY | SENDGROUPREPLY, NULL, NULL, extra->ctx, extra->hdr);
2528         redraw = REDRAW_FULL;
2529         break;
2530
2531       case OP_LIST_REPLY:
2532         CHECK_MODE(IsHeader (extra) || IsMsgAttach (extra));
2533         CHECK_ATTACH;        
2534         if (IsMsgAttach (extra))
2535           mutt_attach_reply (extra->fp, extra->hdr, extra->idx,
2536                              extra->idxlen, extra->bdy, SENDREPLY|SENDLISTREPLY);
2537         else
2538           ci_send_message (SENDREPLY | SENDLISTREPLY, NULL, NULL, extra->ctx, extra->hdr);
2539         redraw = REDRAW_FULL;
2540         break;
2541
2542       case OP_FORWARD_MESSAGE:
2543         CHECK_MODE(IsHeader (extra) || IsMsgAttach (extra));
2544         CHECK_ATTACH;
2545         if (IsMsgAttach (extra))
2546           mutt_attach_forward (extra->fp, extra->hdr, extra->idx,
2547                                extra->idxlen, extra->bdy);
2548         else
2549           ci_send_message (SENDFORWARD, NULL, NULL, extra->ctx, extra->hdr);
2550         redraw = REDRAW_FULL;
2551         break;
2552
2553       case OP_DECRYPT_SAVE:
2554         if (!WithCrypto)
2555         {
2556           ch = -1;
2557           break;
2558         }
2559         /* fall through */
2560       case OP_SAVE:
2561         if (IsAttach (extra))
2562         {
2563           mutt_save_attachment_list (extra->fp, 0, extra->bdy, extra->hdr, NULL);
2564           break;
2565         }
2566         /* fall through */
2567       case OP_COPY_MESSAGE:
2568       case OP_DECODE_SAVE:
2569       case OP_DECODE_COPY:
2570       case OP_DECRYPT_COPY:
2571         if (!WithCrypto && ch == OP_DECRYPT_COPY)
2572         {
2573           ch = -1;
2574           break;
2575         }
2576         CHECK_MODE(IsHeader (extra));
2577         if (mutt_save_message (extra->hdr,
2578                                (ch == OP_DECRYPT_SAVE) ||
2579                                (ch == OP_SAVE) || (ch == OP_DECODE_SAVE),
2580                                (ch == OP_DECODE_SAVE) || (ch == OP_DECODE_COPY),
2581                                (ch == OP_DECRYPT_SAVE) || (ch == OP_DECRYPT_COPY) ||
2582                                0,
2583                                &redraw) == 0 && (ch == OP_SAVE || ch == OP_DECODE_SAVE
2584                                                  || ch == OP_DECRYPT_SAVE
2585                                                  ))
2586         {
2587           if (option (OPTRESOLVE))
2588           {
2589             ch = -1;
2590             rc = OP_MAIN_NEXT_UNDELETED;
2591           }
2592           else
2593             redraw |= REDRAW_STATUS | REDRAW_INDEX;
2594         }
2595         MAYBE_REDRAW (redraw);
2596         break;
2597
2598       case OP_SHELL_ESCAPE:
2599         mutt_shell_escape ();
2600         MAYBE_REDRAW (redraw);
2601         break;
2602
2603       case OP_TAG:
2604         CHECK_MODE(IsHeader (extra));
2605         mutt_set_flag (Context, extra->hdr, M_TAG, !extra->hdr->tagged);
2606
2607         Context->last_tag = extra->hdr->tagged ? extra->hdr :
2608           ((Context->last_tag == extra->hdr && !extra->hdr->tagged)
2609            ? NULL : Context->last_tag);
2610
2611         redraw = REDRAW_STATUS | REDRAW_INDEX;
2612         if (option (OPTRESOLVE))
2613         {
2614           ch = -1;
2615           rc = OP_NEXT_ENTRY;
2616         }
2617         break;
2618
2619       case OP_TOGGLE_NEW:
2620         CHECK_MODE(IsHeader (extra));
2621         CHECK_READONLY;
2622         CHECK_ACL(M_ACL_SEEN, _("toggle new"));
2623
2624         if (extra->hdr->read || extra->hdr->old)
2625           mutt_set_flag (Context, extra->hdr, M_NEW, 1);
2626         else if (!first)
2627           mutt_set_flag (Context, extra->hdr, M_READ, 1);
2628         first = 0;
2629         Context->msgnotreadyet = -1;
2630         redraw = REDRAW_STATUS | REDRAW_INDEX;
2631         if (option (OPTRESOLVE))
2632         {
2633           ch = -1;
2634           rc = OP_MAIN_NEXT_UNDELETED;
2635         }
2636         break;
2637
2638       case OP_UNDELETE:
2639         CHECK_MODE(IsHeader (extra));
2640         CHECK_READONLY;
2641         CHECK_ACL(M_ACL_DELETE, _("undelete message"));
2642
2643         mutt_set_flag (Context, extra->hdr, M_DELETE, 0);
2644         redraw = REDRAW_STATUS | REDRAW_INDEX;
2645         if (option (OPTRESOLVE))
2646         {
2647           ch = -1;
2648           rc = OP_NEXT_ENTRY;
2649         }
2650         break;
2651
2652       case OP_UNDELETE_THREAD:
2653       case OP_UNDELETE_SUBTHREAD:
2654         CHECK_MODE(IsHeader (extra));
2655         CHECK_READONLY;
2656         CHECK_ACL(M_ACL_DELETE, _("undelete message(s)"));
2657
2658         r = mutt_thread_set_flag (extra->hdr, M_DELETE, 0,
2659                                   ch == OP_UNDELETE_THREAD ? 0 : 1);
2660
2661         if (r != -1)
2662         {
2663           if (option (OPTRESOLVE))
2664           {
2665             rc = (ch == OP_DELETE_THREAD) ?
2666                                   OP_MAIN_NEXT_THREAD : OP_MAIN_NEXT_SUBTHREAD;
2667             ch = -1;
2668           }
2669
2670           if (!option (OPTRESOLVE) && PagerIndexLines)
2671             redraw = REDRAW_FULL;
2672           else
2673             redraw = REDRAW_STATUS | REDRAW_INDEX;
2674         }
2675         break;
2676
2677       case OP_VERSION:
2678         mutt_version ();
2679         break;
2680
2681       case OP_BUFFY_LIST:
2682         mutt_buffy_list ();
2683         break;
2684
2685       case OP_VIEW_ATTACHMENTS:
2686         if (flags & M_PAGER_ATTACHMENT)
2687         {
2688           ch = -1;
2689           rc = OP_ATTACH_COLLAPSE;
2690           break;
2691         }
2692         CHECK_MODE(IsHeader (extra));
2693         mutt_view_attachments (extra->hdr);
2694         if (extra->hdr->attach_del)
2695           Context->changed = 1;
2696         redraw = REDRAW_FULL;
2697         break;
2698
2699
2700       case OP_MAIL_KEY:
2701         if (!(WithCrypto & APPLICATION_PGP))
2702         {
2703           ch = -1;
2704           break;
2705         }
2706         CHECK_MODE(IsHeader(extra));
2707         CHECK_ATTACH;
2708         ci_send_message (SENDKEY, NULL, NULL, extra->ctx, extra->hdr);
2709         redraw = REDRAW_FULL;
2710         break;
2711
2712
2713       case OP_FORGET_PASSPHRASE:
2714         crypt_forget_passphrase ();
2715         break;
2716
2717       case OP_EXTRACT_KEYS:
2718         if (!WithCrypto)
2719         {
2720           ch = -1;
2721           break;
2722         }
2723         CHECK_MODE(IsHeader(extra));
2724         crypt_extract_keys_from_messages(extra->hdr);
2725         redraw = REDRAW_FULL;
2726         break;
2727
2728       case OP_WHAT_KEY:
2729         mutt_what_key ();
2730         break;
2731
2732       default:
2733         ch = -1;
2734         break;
2735     }
2736   }
2737
2738   safe_fclose (&fp);
2739   if (IsHeader (extra))
2740   {
2741     Context->msgnotreadyet = -1;
2742     if (rc == -1)
2743       OldHdr = NULL;
2744     else
2745     {
2746       TopLine = topline;
2747       OldHdr = extra->hdr;
2748     }
2749   }
2750     
2751   cleanup_quote (&QuoteList);
2752   
2753   for (i = 0; i < maxLine ; i++)
2754   {
2755     FREE (&(lineInfo[i].syntax));
2756     if (SearchCompiled && lineInfo[i].search)
2757       FREE (&(lineInfo[i].search));
2758   }
2759   if (SearchCompiled)
2760   {
2761     regfree (&SearchRE);
2762     SearchCompiled = 0;
2763   }
2764   FREE (&lineInfo);
2765   if (index)
2766     mutt_menuDestroy(&index);
2767   return (rc != -1 ? rc : 0);
2768 }