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 }