Return to xdisp.c CVS log

Up to [CSRG BSD Unix] / 43BSD / contrib / emacs / src

Annotation of 43BSD/contrib/emacs/src/xdisp.c, revision 1.1

1.1     ! root        1: /* Display generation from window structure and buffer text.
        !             2:    Copyright (C) 1985 Richard M. Stallman.
        !             3: 
        !             4: This file is part of GNU Emacs.
        !             5: 
        !             6: GNU Emacs is distributed in the hope that it will be useful,
        !             7: but WITHOUT ANY WARRANTY.  No author or distributor
        !             8: accepts responsibility to anyone for the consequences of using it
        !             9: or for whether it serves any particular purpose or works at all,
        !            10: unless he says so in writing.  Refer to the GNU Emacs General Public
        !            11: License for full details.
        !            12: 
        !            13: Everyone is granted permission to copy, modify and redistribute
        !            14: GNU Emacs, but only under the conditions described in the
        !            15: GNU Emacs General Public License.   A copy of this license is
        !            16: supposed to have been given to you along with GNU Emacs so you
        !            17: can know your rights and responsibilities.  It should be in a
        !            18: file named COPYING.  Among other things, the copyright notice
        !            19: and this notice must be preserved on all copies.  */
        !            20: 
        !            21: 
        !            22: #include "config.h"
        !            23: #include <stdio.h>
        !            24: #include <ctype.h>
        !            25: #undef NULL
        !            26: #include "lisp.h"
        !            27: #include "window.h"
        !            28: #include "termchar.h"
        !            29: #include "dispextern.h"
        !            30: #include "buffer.h"
        !            31: #include "indent.h"
        !            32: #include "commands.h"
        !            33: #include "macros.h"
        !            34: 
        !            35: extern int interrupt_input;
        !            36: 
        !            37: /* Nonzero means print newline before next minibuffer message.  */
        !            38: 
        !            39: int noninteractive_need_newline;
        !            40: 
        !            41: #define min(a, b) ((a) < (b) ? (a) : (b))
        !            42: #define max(a, b) ((a) > (b) ? (a) : (b))
        !            43: 
        !            44: #define CURRENT_END_POS(w) \
        !            45:   (XFASTINT (w->window_end_pos) < 0 \
        !            46:    ? -1 - XFASTINT(w->window_end_pos) \
        !            47:    : XFASTINT(w->window_end_pos))
        !            48: 
        !            49: /* The buffer position of the first character appearing
        !            50:  entirely or partially on the current screen line.
        !            51:  Or zero, which disables the optimization for the current screen line. */
        !            52: int this_line_bufpos;
        !            53: 
        !            54: /* Number of characters past the end of this line,
        !            55:    including the terminating newline */
        !            56: int this_line_endpos;
        !            57: 
        !            58: /* The vertical position of this screen line. */
        !            59: int this_line_vpos;
        !            60: 
        !            61: /* Hpos value for start of display on this screen line.
        !            62:  Usually zero, but negative if first character really began on previous line */
        !            63: int this_line_hpos;
        !            64: 
        !            65: /* Buffer that this_line variables are describing. */
        !            66: struct buffer *this_line_buffer;
        !            67: 
        !            68: /* Value of minibuf_message when it was last acted on.
        !            69:   If this is nonzero, there is a message on the screen
        !            70:   in the minibuffer and it should be erased as soon
        !            71:   as it is no longer requested to appear. */
        !            72: char *prev_minibuf_message;
        !            73: 
        !            74: /* Nonzero means truncate lines in all windows less wide than the screen */
        !            75: 
        !            76: int truncate_partial_width_windows;
        !            77: 
        !            78: Lisp_Object Vglobal_mode_string;
        !            79: 
        !            80: Lisp_Object Vglobal_minor_modes;
        !            81: 
        !            82: /* The number of lines to try scrolling a
        !            83:   window by when point leaves the window; if
        !            84:   it is <=0 then point is centered in the window */
        !            85: int scroll_step;
        !            86: 
        !            87: /* Nonzero if try_window_id has made blank lines at window bottom
        !            88:  since the last redisplay that paused */
        !            89: int blank_end_of_window;
        !            90: 
        !            91: /* Number of windows showing the buffer of the selected window.  */
        !            92: static int buffer_shared;
        !            93: 
        !            94: /* display_text_line sets these to the screen position (origin 0) of point,
        !            95:   whether the window is selected or not.
        !            96:  Set one to -1 first to determine whether point was found afterwards.  */
        !            97: 
        !            98: int point_vpos;
        !            99: int point_hpos;
        !           100: 
        !           101: int debug_end_pos;
        !           102: 
        !           103: extern int default_ctl_arrow;  /* Nonzero means display ctl chars */
        !           104:                                /* with uparrow in mode lines, etc */
        !           105: 
        !           106: int mode_line_inverse_video;   /* Nonzero means display mode line highlighted */
        !           107: 
        !           108: struct position *display_text_line ();
        !           109: 
        !           110: char *minibuf_prompt;  /* Prompt to display in front of the minibuffer contents */
        !           111: 
        !           112: /* Width in columns of current minibuffer prompt.  */
        !           113: 
        !           114: int minibuf_prompt_width;
        !           115: 
        !           116: char *minibuf_message; /* Message to display instead of minibuffer contents
        !           117:                           This is what the functions error and message make,
        !           118:                           and command echoing uses it as well.
        !           119:                           It overrides the minibuf_prompt as well as the buffer.  */
        !           120: 
        !           121: int RecurseDepth;      /* Depth in recursive edits */
        !           122: 
        !           123: int MinibufDepth;      /* Depth in minibuffer invocations */
        !           124: 
        !           125: int RedoModes;         /* true iff we should redraw the mode lines
        !           126:                           on the next redisplay */
        !           127: 
        !           128: /* Minimum value of bf_s1 since last redisplay that finished.
        !           129:  Valid for current buffer unless Cant1WinOpt is nonzero. */
        !           130: 
        !           131: int beg_unchanged;
        !           132: 
        !           133: /* Minimum value of bf_s2 since last redisplay that finished.
        !           134:  Valid for current buffer unless Cant1WinOpt is nonzero. */
        !           135: 
        !           136: int end_unchanged;
        !           137: 
        !           138: /* bf_modified as of last redisplay that finished;
        !           139:  if it matches bf_modified, beg_unchanged and end_unchanged
        !           140:  contain no useful information */
        !           141: int unchanged_modified;
        !           142: 
        !           143: /* Nonzero if head_clip or tail_clip of current buffer has changed
        !           144:  since last redisplay that finished */
        !           145: int clip_changed;
        !           146: 
        !           147: /* Nonzero if window sizes or contents have changed
        !           148:  since last redisplay that finished */
        !           149: int windows_or_buffers_changed;
        !           150: 
        !           151: DEFUN ("redraw-display", Fredraw_display, Sredraw_display, 0, 0, "",
        !           152:   "Clear the screen and output again what is supposed to appear on it.")
        !           153:   ()
        !           154: {
        !           155:   if (screen_height == 0) abort (); /* Some bug zeros some core */
        !           156:   set_terminal_modes ();
        !           157:   clear_screen ();
        !           158:   fflush (stdout);
        !           159:   clear_screen_records ();
        !           160:   if (screen_height == 0) abort (); /* Some bug zeros some core */
        !           161:   windows_or_buffers_changed++;
        !           162:   /* Mark all windows as INaccurate,
        !           163:      so that every window will have its redisplay done.  */
        !           164:   mark_window_display_accurate (XWINDOW (minibuf_window)->prev, 0);
        !           165:   if (screen_height == 0) abort (); /* Some bug zeros some core */
        !           166:   return Qnil;
        !           167: }
        !           168: 
        !           169: static char message_buf[MScreenWidth + 1];
        !           170: 
        !           171: /* dump an informative message to the minibuf */
        !           172: /* VARARGS 1 */
        !           173: message (m, a1, a2, a3)
        !           174:      char *m;
        !           175: {
        !           176:   if (noninteractive)
        !           177:     {
        !           178:       if (noninteractive_need_newline)
        !           179:        putchar ('\n');
        !           180:       printf (m, a1, a2, a3);
        !           181:       printf ("\n");
        !           182:       fflush (stdout);
        !           183:     }
        !           184:   else if (INTERACTIVE)
        !           185:     {
        !           186:       doprnt (message_buf, sizeof message_buf - 1, m, &a1);
        !           187:       minibuf_message = message_buf;
        !           188:       display_minibuf_message ();
        !           189:       update_screen (1, 1);
        !           190:     }
        !           191: }
        !           192: 
        !           193: /* Specify m, a string, as a message in the minibuf.  */
        !           194: message1 (m)
        !           195:      char *m;
        !           196: {
        !           197:   if (noninteractive)
        !           198:     {
        !           199:       if (noninteractive_need_newline)
        !           200:        putchar ('\n');
        !           201:       printf ("%s\n", m);
        !           202:       fflush (stdout);
        !           203:     }
        !           204:   else if (INTERACTIVE)
        !           205:     {
        !           206:       minibuf_message = m;
        !           207:       display_minibuf_message ();
        !           208:       update_screen (1, 1);
        !           209:     }
        !           210: }
        !           211: 
        !           212: display_minibuf_message ()
        !           213: {
        !           214:   register int vpos;
        !           215:   register struct display_line *line;
        !           216: 
        !           217:   if (screen_garbaged)
        !           218:     {
        !           219:       Fredraw_display ();
        !           220:       screen_garbaged = 0;
        !           221:     }
        !           222: 
        !           223:   if (minibuf_message || !MinibufDepth)
        !           224:     {
        !           225:       vpos = XFASTINT (XWINDOW (minibuf_window)->top);
        !           226:       line = get_display_line (vpos, 0);
        !           227:       display_string (XWINDOW (minibuf_window), line,
        !           228:                      minibuf_message ? minibuf_message : "",
        !           229:                      0, 0, 0);
        !           230: 
        !           231:       /* If desired cursor location is on this line, put it at end of text */
        !           232:       if (cursY == vpos)
        !           233:        cursX = line->length;
        !           234:     }
        !           235:   else if (!EQ (minibuf_window, selected_window))
        !           236:     windows_or_buffers_changed++;
        !           237: 
        !           238:   if (EQ (minibuf_window, selected_window))
        !           239:     this_line_bufpos = 0;
        !           240: 
        !           241:   prev_minibuf_message = minibuf_message;
        !           242: }
        !           243: 
        !           244: /* Do a screen update, taking possible shortcuts into account.
        !           245:  This is the main external entry point for redisplay */
        !           246: 
        !           247: DoDsp (SaveMiniBuf)
        !           248: {
        !           249:   register struct window *w = XWINDOW (selected_window);
        !           250:   register int pause;
        !           251:   int inhibit_hairy_id = 0;
        !           252:   int must_finish = 0;
        !           253:   int all_windows = 0;
        !           254:   register int tlbufpos, tlendpos;
        !           255:   struct position pos;
        !           256:   extern int input_pending;
        !           257: 
        !           258:   if (noninteractive)
        !           259:     return;
        !           260: 
        !           261:   if (screen_garbaged)
        !           262:     {
        !           263:       Fredraw_display ();
        !           264:       screen_garbaged = 0;
        !           265:     }
        !           266: 
        !           267:   if (minibuf_message ||
        !           268:       (prev_minibuf_message && !SaveMiniBuf))
        !           269:     {
        !           270:       display_minibuf_message ();
        !           271:       must_finish = 1;
        !           272:     }
        !           273: 
        !           274:   if (clip_changed || windows_or_buffers_changed)
        !           275:     RedoModes++;
        !           276: 
        !           277:   /* Detect case that we need to write a star in the mode line.  */
        !           278:   if (XFASTINT (w->last_modified) < bf_modified
        !           279:       && XFASTINT (w->last_modified) <= bf_cur->save_modified)
        !           280:     {
        !           281:       w->redo_mode_line = Qt;
        !           282:       if (buffer_shared > 1)
        !           283:        RedoModes++;
        !           284:     }
        !           285: 
        !           286:   all_windows = RedoModes || buffer_shared > 1;
        !           287: 
        !           288:   tlbufpos = this_line_bufpos;
        !           289:   tlendpos = this_line_endpos;
        !           290:   if (!all_windows && tlbufpos > 0 && NULL (w->redo_mode_line)
        !           291:       /* Point must be on the line that we have info recorded about */
        !           292:       && point >= tlbufpos
        !           293:       && point <= bf_s1 + bf_s2 + 1 - tlendpos
        !           294:       /* All text outside that line, including its final newline,
        !           295:         must be unchanged */
        !           296:       && (XFASTINT (w->last_modified) >= bf_modified
        !           297:          || (beg_unchanged >= tlbufpos - 1
        !           298:              && bf_s1 >= tlbufpos - 1
        !           299:              && end_unchanged >= tlendpos
        !           300:              && bf_s2 >= tlendpos))
        !           301:       /* Make sure recorded data applies to current buffer, etc */
        !           302:       && NULL (w->force_start)
        !           303:       && bf_cur == XBUFFER (w->buffer)
        !           304:       && this_line_buffer == bf_cur)
        !           305:     {
        !           306:       if (tlbufpos > FirstCharacter && CharAt (tlbufpos - 1) != '\n'
        !           307:          && (tlbufpos == NumCharacters + 1
        !           308:              || CharAt (tlbufpos) == '\n'))
        !           309:        /* Former continuation line has disappeared by becoming empty */
        !           310:        ;
        !           311:       else if (XFASTINT (w->last_modified) < bf_modified
        !           312:               || EQ (selected_window, minibuf_window))
        !           313:        {
        !           314:          point_vpos = -1;
        !           315:          display_text_line (w, tlbufpos, this_line_vpos, this_line_hpos,
        !           316:                             pos_tab_offset (w, tlbufpos));
        !           317:          /* If line contains point, is not continued,
        !           318:                 and ends at same distance from eob as before, we win */
        !           319:          if (point_vpos >= 0 && this_line_bufpos
        !           320:              && this_line_endpos == tlendpos)
        !           321:            {
        !           322:              cursX = point_hpos;
        !           323:              if (XFASTINT (w->width) != screen_width)
        !           324:                preserve_other_columns (w);
        !           325:              if (interrupt_input)
        !           326:                unrequest_sigio ();
        !           327:              goto update;
        !           328:            }
        !           329:        }
        !           330:       else if (point == XFASTINT (w->last_point))
        !           331:        {
        !           332:          if (!must_finish)
        !           333:            return;
        !           334:          goto update;
        !           335:        }
        !           336:       else
        !           337:        {
        !           338:          pos = *compute_motion (tlbufpos, 0,
        !           339:                                XINT (w->hscroll) ? 1 - XINT (w->hscroll) : 0,
        !           340:                                point, 2, - (1 << (SHORTBITS - 1)),
        !           341:                                XFASTINT (w->width) - 1
        !           342:                                - (XFASTINT (w->width) + XFASTINT (w->left) != screen_width),
        !           343:                                XINT (w->hscroll), 0);
        !           344:          if (pos.vpos < 1)
        !           345:            {
        !           346:              cursX = max (XFASTINT (w->left), pos.hpos);
        !           347:              if (interrupt_input)
        !           348:                unrequest_sigio ();
        !           349:              goto update;
        !           350:            }
        !           351:        }
        !           352:       /* Text changed drastically or point moved off of line */
        !           353:       cancel_line (this_line_vpos);
        !           354:     }
        !           355: 
        !           356:   this_line_bufpos = 0;
        !           357: 
        !           358:   if (interrupt_input)
        !           359:     unrequest_sigio ();
        !           360: 
        !           361:   if (all_windows)
        !           362:     redisplay_all_windows ();
        !           363:   else
        !           364:     {
        !           365:       inhibit_hairy_id = redisplay_window (selected_window, 1);
        !           366:       if (XFASTINT (w->width) != screen_width)
        !           367:        preserve_other_columns (w);
        !           368:     }
        !           369: 
        !           370: update: 
        !           371:   pause = update_screen (0, inhibit_hairy_id);
        !           372: 
        !           373:   /* If screen does not match, prevent doing single-line-update next time */
        !           374:   if (pause)
        !           375:     this_line_bufpos = 0;
        !           376: 
        !           377:   /* Now text on screen agrees with windows, so
        !           378:      put info into the windows for partial redisplay to follow */
        !           379: 
        !           380:   if (!pause)
        !           381:     {
        !           382:       register struct buffer_text *t
        !           383:        = XBUFFER (w->buffer) == bf_cur
        !           384:          ? &bf_text : &XBUFFER (w->buffer)->text;
        !           385: 
        !           386:       blank_end_of_window = 0;
        !           387:       clip_changed = 0;
        !           388:       unchanged_modified = t->modified;
        !           389:       beg_unchanged = t->size1, end_unchanged = t->size2;
        !           390: 
        !           391:       XFASTINT (w->last_point) = t->pointloc;
        !           392:       XFASTINT (w->last_point_x) = cursX;
        !           393:       XFASTINT (w->last_point_y) = cursY;
        !           394: 
        !           395:       if (all_windows)
        !           396:        mark_window_display_accurate (XWINDOW (minibuf_window)->prev, 1);
        !           397:       else
        !           398:        {
        !           399:          w->redo_mode_line = Qnil;
        !           400:          XFASTINT (w->last_modified) = t->modified;
        !           401:          if (XFASTINT (w->window_end_pos) < 0)
        !           402:            XFASTINT (w->window_end_pos) = -1 - XFASTINT (w->window_end_pos);
        !           403:        }
        !           404:       RedoModes = 0;
        !           405:       windows_or_buffers_changed = 0;
        !           406:     }
        !           407: 
        !           408:   /* Start SIGIO interrupts coming again.
        !           409:      Having them off during the code above
        !           410:      makes it less likely one will discard output,
        !           411:      but not impossible, since there might be stuff
        !           412:      in the system buffer here.
        !           413:      But it is much hairier to try to do anything about that.  */
        !           414: 
        !           415:   if (interrupt_input)
        !           416:     request_sigio ();
        !           417: }
        !           418: 
        !           419: mark_window_display_accurate (window, flag)
        !           420:      Lisp_Object window;
        !           421:      int flag;
        !           422: {
        !           423:   register struct window *w;
        !           424: 
        !           425:   for (;!NULL (window); window = w->next)
        !           426:     {
        !           427:       w = XWINDOW (window);
        !           428: 
        !           429:       XFASTINT (w->last_modified)
        !           430:        = !flag ? 0
        !           431:          : XBUFFER (w->buffer) == bf_cur
        !           432:            ? bf_modified : XBUFFER (w->buffer)->text.modified;
        !           433:       if (XFASTINT (w->window_end_pos) < 0)
        !           434:        XFASTINT (w->window_end_pos) = -1 - XFASTINT (w->window_end_pos);
        !           435:       w->redo_mode_line = Qnil;
        !           436: 
        !           437:       if (!NULL (w->vchild))
        !           438:        mark_window_display_accurate (w->vchild, flag);
        !           439:       if (!NULL (w->hchild))
        !           440:        mark_window_display_accurate (w->hchild, flag);
        !           441:     }
        !           442: }
        !           443: 
        !           444: int do_id = 1;
        !           445: 
        !           446: /* Do full redisplay of one or all windows.
        !           447:   This does not include updating the screen;
        !           448:   just generating lines to pass to update_screen.  */
        !           449: 
        !           450: /* Entry point to redisplay all windows */
        !           451: 
        !           452: redisplay_all_windows ()
        !           453: {
        !           454:   buffer_shared = 0;
        !           455: 
        !           456:   redisplay_windows (XWINDOW (minibuf_window)->prev);
        !           457: }
        !           458: 
        !           459: redisplay_windows (window)
        !           460:      Lisp_Object window;
        !           461: {
        !           462:   for (; !NULL (window); window = XWINDOW (window)->next)
        !           463:     redisplay_window (window, 0);
        !           464: }
        !           465: 
        !           466: redisplay_window (window, just_this_one)
        !           467:      Lisp_Object window;
        !           468:      int just_this_one;
        !           469: {
        !           470:   register struct window *w = XWINDOW (window);
        !           471:   int height;
        !           472:   register int lpoint = point;
        !           473:   struct buffer *old = bf_cur;
        !           474:   register int width = XFASTINT (w->width) - 1
        !           475:     - (XFASTINT (w->width) + XFASTINT (w->left) != screen_width);
        !           476:   register int startp = marker_position (w->start);
        !           477:   register int hscroll = XINT (w->hscroll);
        !           478:   struct position pos;
        !           479:   int inhibit_hairy_id = 0;
        !           480:   int opoint;
        !           481:   int tem;
        !           482: 
        !           483:   if (screen_height == 0) abort (); /* Some bug zeros some core */
        !           484: 
        !           485:   /* If this is a combination window, do its children; that's all.  */
        !           486: 
        !           487:   if (!NULL (w->vchild))
        !           488:     {
        !           489:       redisplay_windows (w->vchild);
        !           490:       return 0;
        !           491:     }
        !           492:   if (!NULL (w->hchild))
        !           493:     {
        !           494:       redisplay_windows (w->hchild);
        !           495:       return 0;
        !           496:     }
        !           497:   if (NULL (w->buffer))
        !           498:     abort ();
        !           499: 
        !           500:   if (RedoModes)
        !           501:     w->redo_mode_line = Qt;
        !           502: 
        !           503:   /* Otherwise set up data on this window; select its buffer and point value */
        !           504: 
        !           505:   height = XFASTINT (w->height);
        !           506:   if (w != XWINDOW (minibuf_window))
        !           507:     height--;
        !           508:   else if (minibuf_message)
        !           509:     return 0;
        !           510: 
        !           511:   SetBfx (XBUFFER (w->buffer));
        !           512:   opoint = point;
        !           513: 
        !           514:   if (!just_this_one
        !           515:       && bf_cur == XBUFFER (XWINDOW (selected_window)->buffer))
        !           516:     buffer_shared++;
        !           517: 
        !           518:   if (!EQ (window, selected_window))
        !           519:     {
        !           520:       SetPoint (marker_position (w->pointm));
        !           521:       if (point < FirstCharacter)
        !           522:        point = FirstCharacter;
        !           523:       else if (point > NumCharacters)
        !           524:        point = NumCharacters + 1;
        !           525:     }
        !           526: 
        !           527:   /* Handle case where place to start displaying has been specified */
        !           528: 
        !           529:   if (!NULL (w->force_start))
        !           530:     {
        !           531:       w->redo_mode_line = Qt;
        !           532:       w->force_start = Qnil;
        !           533:       XFASTINT (w->last_modified) = 0;
        !           534:       if (!try_window (window, startp))
        !           535:        {
        !           536:          /* If point does not appear, move point so it does appear */
        !           537:          pos = *compute_motion (startp, 0,
        !           538:                                ((EQ (window, minibuf_window) && startp == 1)
        !           539:                                 ? minibuf_prompt_width : 0)
        !           540:                                +
        !           541:                                (hscroll ? 1 - hscroll : 0),
        !           542:                                NumCharacters + 1, height / 2,
        !           543:                                - (1 << (SHORTBITS - 1)),
        !           544:                                width, hscroll, pos_tab_offset (w, startp));
        !           545:          SetPoint (pos.bufpos);
        !           546:          if (w != XWINDOW (selected_window))
        !           547:            Fset_marker (w->pointm, make_number (point), Qnil);
        !           548:          else
        !           549:            lpoint = point;
        !           550: 
        !           551:          if (EQ (window, selected_window))
        !           552:            {
        !           553:              cursX = max (0, pos.hpos) + XFASTINT (w->left);
        !           554:              cursY = pos.vpos + XFASTINT (w->top);
        !           555:            }
        !           556:        }
        !           557:       goto done;
        !           558:     }
        !           559: 
        !           560:   /* Handle case where text has not changed, only point,
        !           561:      and it has not moved off the screen */
        !           562: 
        !           563:   /* This code is not used for minibuffer for the sake of
        !           564:      the case of redisplaying to replace an echo area message;
        !           565:      since in that case the minibuffer contents per se are usually unchanged.
        !           566:      This code is of no real use in the minibuffer since
        !           567:      the handling of tlbufpos, etc., in DoDsp handles the same cases.  */
        !           568: 
        !           569:   if (XFASTINT (w->last_modified) >= bf_modified
        !           570:       && point >= startp && !clip_changed
        !           571:       && (just_this_one || XFASTINT (w->width) == screen_width)
        !           572:       && !EQ (window, minibuf_window))
        !           573:     {
        !           574:       pos = *compute_motion (startp, 0, (hscroll ? 1 - hscroll : 0),
        !           575:                            point, height + 1, 10000, width, hscroll,
        !           576:                            pos_tab_offset (w, startp));
        !           577: 
        !           578:       if (pos.vpos < height)
        !           579:        {
        !           580:          /* Ok, point is still on screen */
        !           581:          if (w == XWINDOW (selected_window))
        !           582:            {
        !           583:              /* These variables are supposed to be origin 1 */
        !           584:              cursX = max (0, pos.hpos) + XFASTINT (w->left);
        !           585:              cursY = pos.vpos + XFASTINT (w->top);
        !           586:            }
        !           587: /* This doesn't do the trick, because if a window to the right of
        !           588:  this one must be redisplayed, this does nothing because there
        !           589:  is nothing in DesiredScreen yet, and then the other window is
        !           590:  redisplayed, making likes that are empty in this window's columns.
        !           591:          if (XFASTINT (w->width) != screen_width)
        !           592:            preserve_my_columns (w);
        !           593: */
        !           594:          goto done;
        !           595:        }
        !           596:       /* Don't bother trying redisplay with same start;
        !           597:        we already know it will lose */
        !           598:     }
        !           599:   else if (just_this_one && !EQ (window, minibuf_window)
        !           600:           && point >= startp
        !           601:           && XFASTINT (w->last_modified)
        !           602:           && XFASTINT (w->window_end_pos) >= 0
        !           603:           && do_id && !clip_changed
        !           604:           && !blank_end_of_window
        !           605:           && XFASTINT (w->width) == screen_width
        !           606:           && (tem = try_window_id (selected_window))
        !           607:           && tem != -2)
        !           608:     {
        !           609:       /* tem > 0 means success.  tem == -1 means choose new start.
        !           610:         tem == -2 means try again with same start,
        !           611:          and nothing but whitespace follows the changed stuff.
        !           612:         tem == 0 means try again with same start.  */
        !           613:       if (tem > 0)
        !           614:        {
        !           615: /*       inhibit_hairy_id = 1;   */
        !           616:          goto done;
        !           617:        }
        !           618:     }
        !           619:   else if (startp >= FirstCharacter && startp <= NumCharacters + 1
        !           620:           /* Avoid starting display at end of buffer! */
        !           621:           && (startp <= NumCharacters || startp == FirstCharacter
        !           622:               || (XFASTINT (w->last_modified) >= bf_modified)))
        !           623:     {
        !           624:       /* Try to redisplay starting at same place as before */
        !           625:       /* If point has not moved off screen, accept the results */
        !           626:       if (try_window (window, startp))
        !           627:        goto done;
        !           628:       else
        !           629:        cancel_my_columns (w);
        !           630:     }
        !           631: 
        !           632:   XFASTINT (w->last_modified) = 0;
        !           633:   w->redo_mode_line = Qt;
        !           634: 
        !           635:   /* Try to scroll by specified few lines */
        !           636: 
        !           637:   if (scroll_step && !clip_changed)
        !           638:     {
        !           639:       if (point > startp)
        !           640:        {
        !           641:          pos = *vmotion (bf_s1 + bf_s2 + 1 - CURRENT_END_POS (w),
        !           642:                          scroll_step, width, hscroll, window);
        !           643:          if (pos.vpos >= height)
        !           644:            goto scroll_fail;
        !           645:        }
        !           646: 
        !           647:       pos = *vmotion (startp, point < startp ? - scroll_step : scroll_step,
        !           648:                      width, hscroll, window);
        !           649: 
        !           650:       if (point >= pos.bufpos)
        !           651:        {
        !           652:          if (try_window (window, pos.bufpos))
        !           653:            goto done;
        !           654:          else
        !           655:            cancel_my_columns (w);
        !           656:        }
        !           657:     scroll_fail: ;
        !           658:     }
        !           659: 
        !           660:   /* Finally, just choose place to start which centers point */
        !           661: 
        !           662:   pos = *vmotion (point, - height / 2, width, hscroll, window);
        !           663:   try_window (window, pos.bufpos);
        !           664: 
        !           665: done:
        !           666:   /* If window not full width, must redo its mode line
        !           667:      if the window to its side is being redone */
        !           668:   if ((!NULL (w->redo_mode_line)
        !           669:        || (!just_this_one && width < screen_width - 1))
        !           670:       && !EQ (window, minibuf_window))
        !           671:     display_mode_line (w);
        !           672: 
        !           673:   SetPoint (opoint);
        !           674:   SetBfx (old);
        !           675:   SetPoint (lpoint);
        !           676: 
        !           677:   return inhibit_hairy_id;
        !           678: }
        !           679: 
        !           680: /* Do full redisplay on one window,
        !           681:   starting at position `pos',
        !           682:   and return nonzero if point appears in the displayed text */
        !           683: 
        !           684: try_window (window, pos)
        !           685:      Lisp_Object window;
        !           686:      register int pos;
        !           687: {
        !           688:   register struct window *w = XWINDOW (window);
        !           689:   register int height = XFASTINT (w->height) - !EQ (window, minibuf_window);
        !           690:   register int vpos = XFASTINT (w->top);
        !           691:   register int last_text_vpos = vpos;
        !           692:   int tab_offset = pos_tab_offset (w, pos);
        !           693: 
        !           694:   struct position val;
        !           695: 
        !           696:   Fset_marker (w->start, make_number (pos), Qnil);
        !           697: 
        !           698:   point_vpos = -1;
        !           699:   val.hpos = XINT (w->hscroll) ? 1 - XINT (w->hscroll) : 0;
        !           700: 
        !           701:   while (--height >= 0)
        !           702:     {
        !           703:       val = *display_text_line (w, pos, vpos, val.hpos, tab_offset);
        !           704:       tab_offset += XFASTINT (w->width) - 1;
        !           705:       if (val.vpos) tab_offset = 0;
        !           706:       vpos++;
        !           707:       if (pos != val.bufpos)
        !           708:        last_text_vpos
        !           709:          /* Next line, unless prev line ended in end of buffer with no cr */
        !           710:          = vpos - (val.vpos && CharAt (val.bufpos - 1) != '\n');
        !           711:       pos = val.bufpos;
        !           712:     }
        !           713: 
        !           714:   /* If last line is continued in middle of character,
        !           715:      include the split character in the text considered on the screen */
        !           716:   if (val.hpos < XINT (w->hscroll) ? 1 - XINT (w->hscroll) : 0)
        !           717:     pos++;
        !           718: 
        !           719:   /* Make this -1 minus what it really should be, so that it is negative.
        !           720:      That serves as a signal that it is not really valid.
        !           721:      When screen updating is through,
        !           722:      change this to its correct positive value */
        !           723:   XFASTINT (w->window_end_pos) = -1 - (bf_s1 + bf_s2 + 1 - pos);
        !           724:   XFASTINT (w->window_end_vpos) = last_text_vpos - XFASTINT (w->top);
        !           725:   return point_vpos >= 0;
        !           726: }
        !           727: 
        !           728: /* Try to redisplay when buffer is modified locally,
        !           729:  computing insert/delete line to preserve text outside
        !           730:  the bounds of the changes.
        !           731:  Return 1 if successful, 0 if if cannot tell what to do,
        !           732:  or -1 to tell caller to find a new window start,
        !           733:  or -2 to tell caller that we did nothing because only whitespace
        !           734:  appears below the changed part of the screen.  */
        !           735: 
        !           736: try_window_id (window)
        !           737:      Lisp_Object window;
        !           738: {
        !           739:   int pos;
        !           740:   register struct window *w = XWINDOW (window);
        !           741:   register int height = XFASTINT (w->height) - !EQ (window, minibuf_window);
        !           742:   int top = XFASTINT (w->top);
        !           743:   int start = marker_position (w->start);
        !           744:   int width = XFASTINT (w->width) - 1
        !           745:     - (XFASTINT (w->width) + XFASTINT (w->left) != screen_width);
        !           746:   int hscroll = XINT (w->hscroll);
        !           747:   int lmargin = hscroll > 0 ? 1 - hscroll : 0;
        !           748:   register int vpos;
        !           749:   register int i, tem;
        !           750:   int last_text_vpos = 0;
        !           751:   int stop_vpos;
        !           752: 
        !           753:   struct position val, bp, ep, xp, pp;
        !           754:   int scroll_amount = 0;
        !           755:   int delta;
        !           756:   int tab_offset, epto;
        !           757: 
        !           758:   if (bf_s1 < beg_unchanged)
        !           759:     beg_unchanged = bf_s1;
        !           760:   if (bf_s2 < end_unchanged)
        !           761:     end_unchanged = bf_s2;
        !           762: 
        !           763:   if (beg_unchanged + 1 < start)
        !           764:     return 0;                  /* Give up if changes go above top of window */
        !           765: 
        !           766:   /* Find position before which nothing is changed.  */
        !           767:   bp = *compute_motion (start, 0, lmargin,
        !           768:                       beg_unchanged + 1, 10000, 10000, width, hscroll,
        !           769:                       pos_tab_offset (w, start));
        !           770:   if (bp.vpos >= height)
        !           771:     return point < bp.bufpos && !bp.contin;
        !           772: 
        !           773:   vpos = bp.vpos;
        !           774: 
        !           775:   /* Find beginning of that screen line.  Must display from there.  */
        !           776:   bp = *vmotion (bp.bufpos, 0, width, hscroll, window);
        !           777: 
        !           778:   pos = bp.bufpos;
        !           779:   val.hpos = lmargin;
        !           780:   if (pos < start)
        !           781:     return -1;
        !           782: 
        !           783:   /* If about to start displaying at the beginning of a continuation line,
        !           784:      really start with previous screen line, in case it was not
        !           785:      continued when last redisplayed */
        !           786:   if (bp.contin && bp.bufpos - 1 == beg_unchanged && vpos > 0)
        !           787:     {
        !           788:       bp = *vmotion (bp.bufpos, -1, width, hscroll, window);
        !           789:       --vpos;
        !           790:       pos = bp.bufpos;
        !           791:     }
        !           792: 
        !           793:   if (bp.contin && bp.hpos != lmargin)
        !           794:     {
        !           795:       val.hpos = bp.prevhpos - width + lmargin;
        !           796:       pos--;
        !           797:     }
        !           798: 
        !           799:   bp.vpos = vpos;
        !           800: 
        !           801:   /* Find first newline after which no more is changed */
        !           802:   ep = *compute_motion (pos, vpos, val.hpos,
        !           803:                       ScanBf ('\n',
        !           804:                               bf_s1 + bf_s2 + 1 - max (end_unchanged, bf_tail_clip),
        !           805:                               1),
        !           806:                       height, - (1 << (SHORTBITS - 1)),
        !           807:                       width, hscroll, pos_tab_offset (w, bp.bufpos));
        !           808: 
        !           809:   /* If changes reach past the text available on the screen,
        !           810:      just display rest of screen.  */
        !           811:   if (ep.bufpos > bf_s1 + bf_s2 + 1 - XFASTINT (w->window_end_pos))
        !           812:     stop_vpos = height;
        !           813:   else
        !           814:     stop_vpos = ep.vpos;
        !           815: 
        !           816:   /* If no newline before ep, the line ep is on includes some changes
        !           817:      that must be displayed.  Make sure we don't stop before it.  */
        !           818:   /* Also, if changes reach all the way until ep.bufpos,
        !           819:      it is possible that something was deleted after the
        !           820:      newline before it, so the following line must be redrawn. */
        !           821:   if (stop_vpos == ep.vpos
        !           822:       && (ep.bufpos == FirstCharacter
        !           823:          || CharAt (ep.bufpos - 1) != '\n'
        !           824:          || ep.bufpos == bf_s1 + bf_s2 + 1 - end_unchanged))
        !           825:     stop_vpos = ep.vpos + 1;
        !           826: 
        !           827:   point_vpos = -1;
        !           828: 
        !           829:   /* If changes do not reach to bottom of window,
        !           830:      figure out how much to scroll the rest of the window */
        !           831:   if (stop_vpos < height)
        !           832:     {
        !           833:       /* Now determine how far up or down the rest of the window has moved */
        !           834:       epto = pos_tab_offset (w, ep.bufpos);
        !           835:       xp = *compute_motion (ep.bufpos, ep.vpos, ep.hpos,
        !           836:                           bf_s1 + bf_s2 + 1 - XFASTINT (w->window_end_pos),
        !           837:                           10000, 0, width, hscroll, epto);
        !           838:       scroll_amount = xp.vpos - XFASTINT (w->window_end_vpos);
        !           839: 
        !           840:       /* Is everything on screen below the changes whitespace?
        !           841:         If so, no scrolling is really necessary.  */
        !           842:       for (i = ep.bufpos; i < xp.bufpos; i++)
        !           843:        {
        !           844:          tem = CharAt (i);
        !           845:          if (tem != ' ' && tem != '\n' && tem != '\t')
        !           846:            break;
        !           847:        }
        !           848:       if (i == xp.bufpos)
        !           849:        return -2;
        !           850: 
        !           851:       XFASTINT (w->window_end_vpos) += scroll_amount;
        !           852: 
        !           853:       /* Before doing any scrolling, verify that point will be on screen. */
        !           854:       if (point > ep.bufpos && !(point <= xp.bufpos && xp.bufpos < height))
        !           855:        {
        !           856:          if (point <= xp.bufpos)
        !           857:            {
        !           858:              pp = *compute_motion (ep.bufpos, ep.vpos, ep.hpos,
        !           859:                                   point, height, - (1 << (SHORTBITS - 1)),
        !           860:                                   width, hscroll, epto);
        !           861:            }
        !           862:          else
        !           863:            {
        !           864:              pp = *compute_motion (xp.bufpos, xp.vpos, xp.hpos,
        !           865:                                   point, height, - (1 << (SHORTBITS - 1)),
        !           866:                                   width, hscroll, pos_tab_offset (w, xp.bufpos));
        !           867:            }
        !           868:          if (pp.bufpos < point || pp.vpos == height)
        !           869:            return 0;
        !           870:          point_vpos = pp.vpos + top;
        !           871:          point_hpos = pp.hpos + XFASTINT (w->left);
        !           872:        }
        !           873: 
        !           874:       if (stop_vpos - scroll_amount >= height
        !           875:          || ep.bufpos == xp.bufpos)
        !           876:        {
        !           877:          if (scroll_amount < 0)
        !           878:            stop_vpos -= scroll_amount;
        !           879:          scroll_amount = 0;
        !           880:          /* In this path, we have altered window_end_vpos
        !           881:             and not left it negative.
        !           882:             We must make sure that, in case display is preempted
        !           883:             before the screen changes to reflect what we do here,
        !           884:             further updates will not come to try_window_id
        !           885:             and assume the screen and window_end_vpos match.  */
        !           886:          blank_end_of_window = 1;
        !           887:        }
        !           888:       else if (!scroll_amount)
        !           889:        {}
        !           890:       else if (bp.bufpos == bf_s1 + bf_s2 + 1 - end_unchanged)
        !           891:        {
        !           892:          /* If pure deletion, scroll up as many lines as possible.
        !           893:             In common case of killing a line, this can save the
        !           894:             following line from being overwritten by scrolling
        !           895:             and therefore having to be redrawn.  */
        !           896:          tem = scroll_screen_lines (bp.vpos + top - scroll_amount,
        !           897:                                     top + height - max (0, scroll_amount),
        !           898:                                     scroll_amount);
        !           899:          if (!tem) stop_vpos = height;
        !           900:        }
        !           901:       else if (scroll_amount)
        !           902:        {
        !           903:          tem = scroll_screen_lines (ep.vpos + top - scroll_amount,
        !           904:                                     top + height - max (0, scroll_amount),
        !           905:                                     scroll_amount);
        !           906:          if (!tem) stop_vpos = height;
        !           907:        }
        !           908:     }
        !           909: 
        !           910:   /* In any case, do not display past bottom of window */
        !           911:   if (stop_vpos >= height)
        !           912:     {
        !           913:       stop_vpos = height;
        !           914:       scroll_amount = 0;
        !           915:     }
        !           916: 
        !           917:   /* Handle case where pos is before w->start --
        !           918:      can happen if part of line had been clipped and is not clipped now */
        !           919:   if (vpos == 0 && pos < marker_position (w->start))
        !           920:     Fset_marker (w->start, make_number (pos), Qnil);
        !           921: 
        !           922:   /* Redisplay the lines where the text was changed */
        !           923:   last_text_vpos = vpos;
        !           924:   tab_offset = pos_tab_offset (w, pos);
        !           925:   if (val.hpos < 0)
        !           926:     tab_offset += XFASTINT (w->width) - 1;
        !           927:   while (vpos < stop_vpos)
        !           928:     {
        !           929:       val = *display_text_line (w, pos, top + vpos++, val.hpos, tab_offset);
        !           930:       tab_offset += XFASTINT (w->width) - 1;
        !           931:       if (val.vpos) tab_offset = 0;
        !           932:       if (pos != val.bufpos)
        !           933:        last_text_vpos
        !           934:          /* Next line, unless prev line ended in end of buffer with no cr */
        !           935:            = vpos - (val.vpos && CharAt (val.bufpos - 1) != '\n');
        !           936:       pos = val.bufpos;
        !           937:     }
        !           938: 
        !           939:   /* There are two cases:
        !           940:      1) we have displayed down to the bottom of the window
        !           941:      2) we have scrolled lines below stop_vpos by scroll_amount  */
        !           942: 
        !           943:   if (vpos == height)
        !           944:     {
        !           945:       /* If last line is continued in middle of character,
        !           946:         include the split character in the text considered on the screen */
        !           947:       if (val.hpos < lmargin)
        !           948:        val.bufpos++;
        !           949:       XFASTINT (w->window_end_vpos) = last_text_vpos;
        !           950:       XFASTINT (w->window_end_pos) = -1 - (bf_s1 + bf_s2 + 1 - val.bufpos);
        !           951:     }
        !           952: 
        !           953:   /* If scrolling made blank lines at window bottom,
        !           954:      redisplay to fill those lines */
        !           955:   if (scroll_amount < 0)
        !           956:     {
        !           957:       vpos = xp.vpos;
        !           958:       pos = xp.bufpos;
        !           959:       val.hpos = lmargin;
        !           960:       if (pos == NumCharacters + 1)
        !           961:        vpos = height + scroll_amount;
        !           962:       else if (xp.contin && xp.hpos != lmargin)
        !           963:        {
        !           964:          val.hpos = xp.prevhpos - width + lmargin;
        !           965:          pos--;
        !           966:        }
        !           967: 
        !           968:       blank_end_of_window = 1;
        !           969:       tab_offset = pos_tab_offset (w, pos);
        !           970:       if (val.hpos < 0)
        !           971:        tab_offset += XFASTINT (w->width) - 1;
        !           972: 
        !           973:       while (vpos < height)
        !           974:        {
        !           975:          val = *display_text_line (w, pos, top + vpos++, val.hpos, tab_offset);
        !           976:          tab_offset += XFASTINT (w->width) - 1;
        !           977:          if (val.vpos) tab_offset = 0;
        !           978:          pos = val.bufpos;
        !           979:        }
        !           980: 
        !           981:       /* Here is a case where display_line_text sets point_vpos wrong.
        !           982:         Make it be fixed up, below.  */
        !           983:       if (xp.bufpos == NumCharacters + 1
        !           984:          && xp.bufpos == point)
        !           985:        point_vpos = -1;
        !           986:     }
        !           987: 
        !           988:   /* Attempt to adjust end-of-text positions to new bottom line */
        !           989:   if (scroll_amount)
        !           990:     {
        !           991:       delta = height - xp.vpos;
        !           992:       if (delta < 0
        !           993:          || (delta > 0 && xp.bufpos <= NumCharacters)
        !           994:          || (delta == 0 && xp.hpos))
        !           995:        {
        !           996:          val = *vmotion (bf_s1 + bf_s2 + 1 - XFASTINT (w->window_end_pos),
        !           997:                          delta, width, hscroll, window);
        !           998:          XFASTINT (w->window_end_pos) = bf_s1 + bf_s2 + 1 - val.bufpos;
        !           999:          XFASTINT (w->window_end_vpos) += val.vpos;
        !          1000:        }
        !          1001:     }
        !          1002: 
        !          1003:   /* If point was not in a line that was displayed, find it */
        !          1004:   if (point_vpos < 0)
        !          1005:     {
        !          1006:       val = *compute_motion (start, 0, lmargin, point, 10000, 10000,
        !          1007:                            width, hscroll, pos_tab_offset (w, start));
        !          1008:       /* Admit failure if point is off screen now */
        !          1009:       if (val.vpos >= height)
        !          1010:        {
        !          1011:          for (vpos = 0; vpos < height; vpos++)
        !          1012:            cancel_line (vpos + top);
        !          1013:          return 0;
        !          1014:        }
        !          1015:       point_vpos = val.vpos + top;
        !          1016:       point_hpos = val.hpos + XFASTINT (w->left);
        !          1017:     }
        !          1018: 
        !          1019:   cursX = max (0, point_hpos);
        !          1020:   cursY = point_vpos;
        !          1021: 
        !          1022:   if (debug_end_pos)
        !          1023:     {
        !          1024:       val = *compute_motion (start, 0, lmargin, NumCharacters + 1,
        !          1025:                            height, - (1 << (SHORTBITS - 1)),
        !          1026:                            width, hscroll, pos_tab_offset (w, start));
        !          1027:       if (val.vpos != XFASTINT (w->window_end_vpos))
        !          1028:        abort ();
        !          1029:       if ((XFASTINT (w->window_end_pos) < 0
        !          1030:           ? -1 - XFASTINT (w->window_end_pos)
        !          1031:           : XFASTINT (w->window_end_pos))
        !          1032:          != bf_s1 + bf_s2 + 1 - val.bufpos)
        !          1033:        abort ();
        !          1034:     }
        !          1035: 
        !          1036:   return 1;
        !          1037: }
        !          1038: 
        !          1039: /* Display one line of window w, starting at position `start' in w's buffer.
        !          1040:  Display starting at horizontal position `hpos',
        !          1041:   which is normally zero or negative.
        !          1042:   A negative value causes output up to hpos = 0 to be discarded.
        !          1043:   This is done for negative hscroll, or when this is a continuation line
        !          1044:   and the continuation occurred in the middle of a multi-column character.
        !          1045: 
        !          1046:  `taboffset' is an offset for ostensible hpos, used in tab stop calculations.
        !          1047: 
        !          1048:  Display on position `vpos' on the screen.  (origin 0).
        !          1049: 
        !          1050:  Returns a `struct position' giving character to start next line with
        !          1051:  and where to display it, including a zero or negative hpos.
        !          1052:  The vpos field is not really a vpos; it is 1 unless the line is continued */
        !          1053: 
        !          1054: struct position val_display_text_line;
        !          1055: 
        !          1056: struct position *
        !          1057: display_text_line (w, start, vpos, hpos, taboffset)
        !          1058:      struct window *w;
        !          1059:      int start;
        !          1060:      int vpos;
        !          1061:      int hpos;
        !          1062:      int taboffset;
        !          1063: {
        !          1064:   register int pos = start;
        !          1065:   register int c;
        !          1066:   register char *p1;
        !          1067:   int end;
        !          1068:   register int pause;
        !          1069:   register unsigned char *p;
        !          1070:   char *endp;
        !          1071:   register char *startp;
        !          1072:   register char *p1prev;
        !          1073:   register struct display_line *line;
        !          1074:   int tab_width = XFASTINT (XBUFFER (w->buffer)->tab_width);
        !          1075:   int ctl_arrow = !NULL (XBUFFER (w->buffer)->ctl_arrow);
        !          1076:   int width = XFASTINT (w->width) - 1
        !          1077:     - (XFASTINT (w->width) + XFASTINT (w->left) != screen_width);
        !          1078:   struct position val;
        !          1079:   int lastpos;
        !          1080:   int invis;
        !          1081:   int hscroll = XINT (w->hscroll);
        !          1082:   int truncate = hscroll
        !          1083:     || (truncate_partial_width_windows
        !          1084:        && XFASTINT (w->width) < screen_width)
        !          1085:     || !NULL (XBUFFER (w->buffer)->truncate_lines);
        !          1086:   int selective
        !          1087:     = XTYPE (bf_cur->selective_display) == Lisp_Int
        !          1088:       ? XINT (bf_cur->selective_display)
        !          1089:        : !NULL (bf_cur->selective_display) ? -1 : 0;
        !          1090: 
        !          1091:   hpos += XFASTINT (w->left);
        !          1092:   line = get_display_line (vpos, XFASTINT (w->left));
        !          1093:   if (tab_width <= 0) tab_width = 1;
        !          1094: 
        !          1095:   if (w == XWINDOW (minibuf_window) && start == 1)
        !          1096:     {
        !          1097:       if (minibuf_prompt)
        !          1098:        hpos = display_string (w, line, minibuf_prompt, hpos,
        !          1099:                               !truncate ? '\\' : '$',
        !          1100:                               0);
        !          1101:       minibuf_prompt_width = hpos;
        !          1102:     }
        !          1103: 
        !          1104:   p1 = line->body + hpos;
        !          1105: 
        !          1106:   end = NumCharacters + 1;
        !          1107: 
        !          1108:   startp = line->body + XFASTINT (w->left);
        !          1109:   endp = startp + width;
        !          1110: 
        !          1111:   /* Loop generating characters.
        !          1112:    Stop at end of buffer, before newline,
        !          1113:    or if reach or pass continuation column.  */
        !          1114: 
        !          1115:   pause = pos;
        !          1116:   while (p1 < endp)
        !          1117:     {
        !          1118:       p1prev = p1;
        !          1119:       if (pos == pause)
        !          1120:        {
        !          1121:          if (pos == end)
        !          1122:            break;
        !          1123:          if (pos == point && point_vpos < 0)
        !          1124:            {
        !          1125:              point_vpos = vpos;
        !          1126:              point_hpos = p1 - startp;
        !          1127:            }
        !          1128: 
        !          1129:          pause = end;
        !          1130:          if (pos < point && point < pause)
        !          1131:            pause = point;
        !          1132:          if (pos <= bf_s1 && bf_s1 + 1 < pause)
        !          1133:            pause = bf_s1 + 1;
        !          1134: 
        !          1135:          p = &CharAt (pos);
        !          1136:        }
        !          1137:       c = *p++;
        !          1138:       if (c >= 040 && c < 0177)
        !          1139:        {
        !          1140:          if (p1 >= startp)
        !          1141:            *p1 = c;
        !          1142:          p1++;
        !          1143:        }
        !          1144:       else if (c == '\n')
        !          1145:        {
        !          1146:          invis = 0;
        !          1147:          while (pos < end
        !          1148:                 && selective > 0
        !          1149:                 && position_indentation (pos + 1) >= selective)
        !          1150:            {
        !          1151:              invis = 1;
        !          1152:              pos = ScanBf ('\n', pos + 1, 1);
        !          1153:              if (CharAt (pos - 1) == '\n')
        !          1154:                pos--;
        !          1155:            }
        !          1156:          if (invis)
        !          1157:            {
        !          1158:              p1 += 4;
        !          1159:              if (p1 - startp > width)
        !          1160:                p1 = endp;
        !          1161:              strncpy (p1prev, " ...", p1 - p1prev);
        !          1162:            }
        !          1163:          break;
        !          1164:        }
        !          1165:       else if (c == '\t')
        !          1166:        {
        !          1167:          do
        !          1168:            {
        !          1169:              if (p1 >= startp)
        !          1170:                *p1 = ' ';
        !          1171:              p1++;
        !          1172:            }
        !          1173:          while ((p1 - startp + taboffset + hscroll - (hscroll > 0))
        !          1174:                 % tab_width);
        !          1175:        }
        !          1176:       else if (c == Ctl('M') && !NULL (bf_cur->selective_display))
        !          1177:        {
        !          1178:          pos = ScanBf ('\n', pos, 1);
        !          1179:          if (CharAt (pos - 1) == '\n')
        !          1180:            pos--;
        !          1181:          break;
        !          1182:        }
        !          1183:       else if (c < 0200 && ctl_arrow)
        !          1184:        {
        !          1185:          if (p1 >= startp)
        !          1186:            *p1 = '^';
        !          1187:          p1++;
        !          1188:          if (p1 >= startp)
        !          1189:            *p1 = c ^ 0100;
        !          1190:          p1++;
        !          1191:        }
        !          1192:       else
        !          1193:        {
        !          1194:          if (p1 >= startp)
        !          1195:            *p1 = '\\';
        !          1196:          p1++;
        !          1197:          if (p1 >= startp)
        !          1198:            *p1 = (c >> 6) + '0';
        !          1199:          p1++;
        !          1200:          if (p1 >= startp)
        !          1201:            *p1 = (7 & (c >> 3)) + '0';
        !          1202:          p1++;
        !          1203:          if (p1 >= startp)
        !          1204:            *p1 = (7 & c) + '0';
        !          1205:          p1++;
        !          1206:        }
        !          1207:       pos++;
        !          1208:     }
        !          1209: 
        !          1210:   val.hpos = - XINT (w->hscroll);
        !          1211:   if (val.hpos)
        !          1212:     {
        !          1213:       val.hpos++;
        !          1214:       /* If line not empty, insert truncation-at-left marker */
        !          1215:       if (pos != start)
        !          1216:        {
        !          1217:          *startp = '$';
        !          1218:          if (p1 <= startp)
        !          1219:            p1 = startp + 1;
        !          1220:          if (line->length <= XFASTINT (w->left))
        !          1221:            line->length = XFASTINT (w->left) + 1;
        !          1222:        }
        !          1223:     }
        !          1224:   val.vpos = 1;
        !          1225: 
        !          1226:   /* Handle continuation in middle of a character */
        !          1227:   /* by backing up over it */
        !          1228:   if (p1 > endp)
        !          1229:     {
        !          1230:       /* Start the next line with that same character */
        !          1231:       pos--;
        !          1232:       /* but at a negative hpos, to skip the columns output on this line.  */
        !          1233:       val.hpos += p1prev - endp;
        !          1234:       /* Keep in this line everything up to the continuation column.  */
        !          1235:       p1 = endp;
        !          1236:     }
        !          1237: 
        !          1238:   /* Finish deciding which character to start the next line on,
        !          1239:      and what hpos to start it at.
        !          1240:      Also set `lastpos' to the last position which counts as "on this line"
        !          1241:      for cursor-positioning.  */
        !          1242: 
        !          1243:   lastpos = pos;
        !          1244: 
        !          1245:   if (pos < NumCharacters + 1)
        !          1246:     {
        !          1247:       if (CharAt (pos) == '\n')
        !          1248:        /* If stopped due to a newline, start next line after it */
        !          1249:        pos++;
        !          1250:       else
        !          1251:        /* Stopped due to right margin of window */
        !          1252:        {
        !          1253:          if (truncate)
        !          1254:            {
        !          1255:              *p1++ = '$';
        !          1256:              /* Truncating => start next line after next newline,
        !          1257:                 and point is on this line if it is before the newline,
        !          1258:                 and skip none of first char of next line */
        !          1259:              pos = ScanBf ('\n', pos, 1);
        !          1260:              val.hpos = XINT (w->hscroll) ? 1 - XINT (w->hscroll) : 0;
        !          1261: 
        !          1262:              lastpos = pos - (CharAt (pos - 1) == '\n');
        !          1263:            }
        !          1264:          else
        !          1265:            {
        !          1266:              *p1++ = '\\';
        !          1267:              val.vpos = 0;
        !          1268:              lastpos = 0;
        !          1269:            }
        !          1270:        }
        !          1271:     }
        !          1272: 
        !          1273:   if (start <= point && point <= lastpos && point_vpos < 0)
        !          1274:     {
        !          1275:       point_vpos = vpos;
        !          1276:       point_hpos = p1 - startp;
        !          1277:     }
        !          1278: 
        !          1279:   if (point_vpos == vpos)
        !          1280:     {
        !          1281:       if (point_hpos < 0) point_hpos = 0;
        !          1282:       if (point_hpos > width) point_hpos = width;
        !          1283:       point_hpos += XFASTINT (w->left);
        !          1284:       if (w == XWINDOW (selected_window))
        !          1285:        {
        !          1286:          cursY = point_vpos;
        !          1287:          cursX = point_hpos;
        !          1288: 
        !          1289:          /* Line is not continued and did not start in middle of character */
        !          1290:          if (hpos == (XINT (w->hscroll) ? 1 - XINT (w->hscroll) : 0)
        !          1291:              && val.vpos)
        !          1292:            {
        !          1293:              this_line_bufpos = start;
        !          1294:              this_line_buffer = bf_cur;
        !          1295:              this_line_vpos = vpos;
        !          1296:              this_line_hpos = hpos;
        !          1297:              this_line_endpos = bf_s1 + bf_s2 + 1 - lastpos;
        !          1298:            }
        !          1299:          else
        !          1300:            this_line_bufpos = 0;
        !          1301:        }
        !          1302:     }
        !          1303: 
        !          1304:   if (XFASTINT (w->width) + XFASTINT (w->left) != screen_width)
        !          1305:     {
        !          1306:       endp++;
        !          1307:       if (p1 < startp) p1 = startp;
        !          1308:       while (p1 < endp) *p1++ = ' ';
        !          1309:       *p1++ = '|';
        !          1310:     }
        !          1311:   line->length = max (line->length, p1 - line->body);
        !          1312:   line->body[line->length] = 0;
        !          1313: 
        !          1314:   val.bufpos = pos;
        !          1315:   val_display_text_line = val;
        !          1316:   return &val_display_text_line;
        !          1317: }
        !          1318: 
        !          1319: /* Display the mode line for window w */
        !          1320: 
        !          1321: display_mode_line (w)
        !          1322:      struct window *w;
        !          1323: {
        !          1324:   int vpos = XFASTINT (w->height) + XFASTINT (w->top) - 1;
        !          1325:   struct display_line *line = get_display_line (vpos, XFASTINT (w->left));
        !          1326: 
        !          1327:   register unsigned char *s = XSTRING (bf_cur->mode_line_format)->data;
        !          1328: 
        !          1329:   display_string (w, line, s, XFASTINT (w->left), 0, 1);
        !          1330:   /* Make the mode line inverse video if the entire line
        !          1331:      is made of mode lines.
        !          1332:      I.e. if this window is full width,
        !          1333:      or if it is the child of a full width window
        !          1334:      (which implies that that window is split side-by-side
        !          1335:      and the rest of this line is mode lines of the sibling windows).  */
        !          1336:   if (XFASTINT (w->width) == screen_width
        !          1337:       || XFASTINT (XWINDOW (w->parent)->width) == screen_width)
        !          1338:     line->highlighted = mode_line_inverse_video;
        !          1339: }
        !          1340: 
        !          1341: char fmodetrunc_buf[100];
        !          1342: 
        !          1343: char *
        !          1344: fmodetrunc (str, width)
        !          1345:      char *str;
        !          1346:      long width;
        !          1347: {
        !          1348:   register char *buf = fmodetrunc_buf;
        !          1349:   register char *bp = buf;
        !          1350:   register long len;
        !          1351:     
        !          1352:   len = strlen(str);
        !          1353:   if (width && width < len)
        !          1354:     {
        !          1355:       strcpy(buf,str+len-width);
        !          1356:       if (buf[0] != '/')
        !          1357:        while (*bp)
        !          1358:          if (*bp++ == '/')
        !          1359:            {
        !          1360:              bp--;
        !          1361:              *--bp = '$';
        !          1362:              return bp;
        !          1363:            }
        !          1364:       buf[0] = '$';
        !          1365:       return buf;
        !          1366:     }
        !          1367:   return str;
        !          1368: }
        !          1369: 
        !          1370: char decode_mode_spec_buf[MScreenWidth + 1];
        !          1371: 
        !          1372: char *
        !          1373: decode_mode_spec (w, string, data_ptr, len_ptr, max_ptr)
        !          1374:      struct window *w;
        !          1375:      register char *string;
        !          1376:      char **data_ptr;
        !          1377:      int *len_ptr;
        !          1378:      int *max_ptr;
        !          1379: {
        !          1380:   register int width = 0;
        !          1381:   register char c;
        !          1382:   Lisp_Object lstr, proc, list;
        !          1383:   register char *str;
        !          1384:   int len;
        !          1385:   int pos, total;
        !          1386:   char *tbuf = decode_mode_spec_buf;
        !          1387: #define tbufsize (sizeof decode_mode_spec_buf)
        !          1388: 
        !          1389:   lstr = Qnil, str = 0;
        !          1390: 
        !          1391:   while (isdigit (c = *string++))
        !          1392:     width = width * 10 + (c - '0');
        !          1393: 
        !          1394:   switch (c)
        !          1395:     {
        !          1396:     case 'b': 
        !          1397:       lstr = bf_cur->name;
        !          1398:       if (width && XSTRING (lstr)->size > width)
        !          1399:        width = min (2 * width, XSTRING (lstr)->size);
        !          1400:       if (width && XSTRING (lstr)->size > width)
        !          1401:        {
        !          1402:          str = (char *) alloca (width + 1);
        !          1403:          bcopy (XSTRING (lstr)->data, str, width - 3);
        !          1404:          bcopy ("...", str + width - 3, 4);
        !          1405:          lstr = Qnil;
        !          1406:        }
        !          1407:       break;
        !          1408: 
        !          1409:     case 'f': 
        !          1410:       if (NULL (bf_cur->filename))
        !          1411:        str = "[none]";
        !          1412:       else if (XTYPE (bf_cur->filename) == Lisp_String)
        !          1413:        str = fmodetrunc (XSTRING (bf_cur -> filename)->data, width);
        !          1414:       break;
        !          1415: 
        !          1416:     case 'm': 
        !          1417:       lstr = bf_cur->mode_name;
        !          1418:       total = min (XSTRING (lstr)->size, tbufsize - 30);
        !          1419:       if (total < 0) total = 0;
        !          1420:       bcopy (XSTRING (lstr)->data, tbuf, total);
        !          1421:       len = 0;
        !          1422:       list = bf_cur->minor_modes;
        !          1423:       while (1)
        !          1424:        {
        !          1425:          if (!LISTP (list) && !len)
        !          1426:            {
        !          1427:              list = Vglobal_minor_modes;
        !          1428:              len = 1;
        !          1429:            }
        !          1430: 
        !          1431:          if (!(total < tbufsize - 30 && LISTP (list)))
        !          1432:            break;
        !          1433: 
        !          1434:          lstr = XCONS (list)->car;
        !          1435:          if (!LISTP (lstr))
        !          1436:            goto foo;
        !          1437:          lstr = XCONS (lstr)->cdr;
        !          1438:          if (XTYPE (lstr) != Lisp_String)
        !          1439:            goto foo;
        !          1440:          tbuf[total++] = ' ';
        !          1441:          pos = min (XSTRING (lstr)->size, tbufsize - 30 - total);
        !          1442:          if (pos < 0)
        !          1443:            pos = 0;
        !          1444:          bcopy (XSTRING (lstr)->data, tbuf + total, pos);
        !          1445:          total += pos;
        !          1446:        foo:
        !          1447:          list = Fcdr (list);
        !          1448:        }
        !          1449:       str = tbuf;
        !          1450:       tbuf[total] = 0;
        !          1451: /*    if (bf_cur->abbrev_mode)
        !          1452:        strcat (tbuf, " Abbrev"); */
        !          1453:       if (bf_head_clip > 1 || bf_tail_clip > 0)
        !          1454:        strcat (tbuf, " Narrow");
        !          1455:       if (defining_kbd_macro)
        !          1456:        strcat (tbuf, " Def");
        !          1457:       lstr = Qnil;
        !          1458:       break;
        !          1459: 
        !          1460:     case 'M': 
        !          1461:       lstr = Vglobal_mode_string;
        !          1462:       break;
        !          1463: 
        !          1464:     case '*': 
        !          1465:       str = !NULL (bf_cur->read_only) ? "%"
        !          1466:            : bf_modified > bf_cur->save_modified ? "*" :"-";
        !          1467:       break;
        !          1468: 
        !          1469:     case 's':
        !          1470:       /* status of process */
        !          1471: #ifdef subprocesses
        !          1472:       proc = Fget_buffer_process (Fcurrent_buffer ());
        !          1473:       if (NULL (proc))
        !          1474:        str = "no process";
        !          1475:       else
        !          1476:        lstr = Fsymbol_name (Fprocess_status (proc));
        !          1477: #else
        !          1478:       str = "no process";
        !          1479: #endif /* subprocesses */
        !          1480:       break;
        !          1481: 
        !          1482:     case 'p':
        !          1483:       pos = marker_position (w->start);
        !          1484:       total = NumCharacters + 1 - FirstCharacter;
        !          1485: 
        !          1486:       if ((XFASTINT (w->window_end_pos) < 0
        !          1487:           ? -1 - XFASTINT (w->window_end_pos)
        !          1488:           : XFASTINT (w->window_end_pos))
        !          1489:          <= bf_tail_clip)
        !          1490:        {
        !          1491:          if (pos <= FirstCharacter)
        !          1492:            str = "All";
        !          1493:          else
        !          1494:            str = "Bottom";
        !          1495:        }
        !          1496:       else if (pos <= FirstCharacter)
        !          1497:        str = "Top";
        !          1498:       else
        !          1499:        {
        !          1500:          total = ((pos - FirstCharacter) * 100 + total - 1) / total;
        !          1501:          /* We can't normally display a 3-digit number,
        !          1502:             so get us a 2-digit number that is close.  */
        !          1503:          if (total == 100)
        !          1504:            total = 99;
        !          1505:          sprintf (tbuf, "%2d%%", total);
        !          1506:          str = tbuf;
        !          1507:        }
        !          1508:       break;
        !          1509: 
        !          1510:     case '[': 
        !          1511:       str = "[[[[[[[[[[" + 10 - (RecurseDepth - MinibufDepth);
        !          1512:       if (RecurseDepth - MinibufDepth > 10)
        !          1513:        str = "[[[... ";
        !          1514:       break;
        !          1515: 
        !          1516:     case ']': 
        !          1517:       str = "]]]]]]]]]]" + 10 - (RecurseDepth - MinibufDepth);
        !          1518:       if (RecurseDepth - MinibufDepth > 10)
        !          1519:        str = " ...]]]";
        !          1520:       break;
        !          1521: 
        !          1522:     case '-':
        !          1523:       str = "--------------------------------------------------------------------------------------------------------------------------------------------";
        !          1524:     }
        !          1525: 
        !          1526:   /* Report the chosen mode item to the caller */
        !          1527: 
        !          1528:   if (str)
        !          1529:     *data_ptr = str, *len_ptr = strlen (str);
        !          1530:   else if (XTYPE (lstr) == Lisp_String)
        !          1531:     *data_ptr = (char *) XSTRING (lstr)->data,
        !          1532:     *len_ptr = XSTRING (lstr)->size;
        !          1533:   else
        !          1534:     *data_ptr = 0, *len_ptr = 0;
        !          1535: 
        !          1536:   /* Report specified truncation or padding */
        !          1537: 
        !          1538:   *max_ptr = width;
        !          1539: 
        !          1540:   /* Tell caller how much of mode line format was used up */
        !          1541: 
        !          1542:   return string;
        !          1543: }
        !          1544: 
        !          1545: /* Display `string' on one line of window `w', starting at `hpos'.
        !          1546:  Display on the display_line `line', which should have
        !          1547:   been obtained by get_display_line (vpos, hpos)
        !          1548:   or in some suitable manner.
        !          1549: 
        !          1550:  `truncate' is character to display at end if truncated.
        !          1551:  `modeline' nonzero means substitute for % constructs.
        !          1552: 
        !          1553:  Returns ending hpos */
        !          1554: 
        !          1555: 
        !          1556: display_string (w, line, string, hpos, truncate, modeline)
        !          1557:      struct window *w;
        !          1558:      register struct display_line *line;
        !          1559:      unsigned char *string;
        !          1560:      int hpos;
        !          1561:      int truncate;
        !          1562:      int modeline;
        !          1563: {
        !          1564:   register int c;
        !          1565:   register unsigned char *p1;
        !          1566:   int width = XFASTINT (w->width) - 1
        !          1567:     - (XFASTINT (w->width) + XFASTINT (w->left) != screen_width);
        !          1568:   int hscroll = XINT (w->hscroll);
        !          1569:   int tab_width = 8;
        !          1570:   register unsigned char *start;
        !          1571:   register unsigned char *end;
        !          1572:   char *modeeltstring;
        !          1573:   int modeeltleft = 0;
        !          1574:   int modeeltmax = 0;
        !          1575: 
        !          1576:   p1 = (unsigned char *) line->body + hpos;
        !          1577:   start = (unsigned char *) line->body + XFASTINT (w->left);
        !          1578:   end = start + width;
        !          1579: 
        !          1580:   while (p1 < end)
        !          1581:     {
        !          1582:       if (modeeltmax)
        !          1583:        {
        !          1584:          modeeltmax--;
        !          1585:          if (modeeltleft-- > 0)
        !          1586:            c = *modeeltstring++;
        !          1587:          else
        !          1588:            c = ' ';
        !          1589:        }
        !          1590:       else
        !          1591:        {
        !          1592:          c = *string++;
        !          1593:          if (!c) break;
        !          1594:          if (c == '%' && modeline)
        !          1595:            {
        !          1596:              string = (unsigned char *)
        !          1597:                decode_mode_spec (w, string, &modeeltstring,
        !          1598:                                  &modeeltleft, &modeeltmax);
        !          1599: 
        !          1600:              if (!modeeltmax)
        !          1601:                modeeltmax = modeeltleft;
        !          1602:              else if (modeeltleft > modeeltmax)
        !          1603:                modeeltleft = modeeltmax;
        !          1604: 
        !          1605:              continue;
        !          1606:            }
        !          1607:        }
        !          1608: 
        !          1609:       if (c >= 040 && c < 0177)
        !          1610:        {
        !          1611:          if (p1 >= start)
        !          1612:            *p1 = c;
        !          1613:          p1++;
        !          1614:        }
        !          1615:       else if (c == '\t')
        !          1616:        {
        !          1617:          do
        !          1618:            {
        !          1619:              if (p1 >= start)
        !          1620:                *p1 = ' ';
        !          1621:              p1++;
        !          1622:            }
        !          1623:          while ((p1 - start + hscroll - (hscroll > 0)) % tab_width);
        !          1624:        }
        !          1625:       else if (c < 0200 && default_ctl_arrow)
        !          1626:        {
        !          1627:          if (p1 >= start)
        !          1628:            *p1 = '^';
        !          1629:          p1++;
        !          1630:          if (p1 >= start)
        !          1631:            *p1 = c ^ 0100;
        !          1632:          p1++;
        !          1633:        }
        !          1634:       else
        !          1635:        {
        !          1636:          if (p1 >= start)
        !          1637:            *p1 = '\\';
        !          1638:          p1++;
        !          1639:          if (p1 >= start)
        !          1640:            *p1 = (c >> 6) + '0';
        !          1641:          p1++;
        !          1642:          if (p1 >= start)
        !          1643:            *p1 = (7 & (c >> 3)) + '0';
        !          1644:          p1++;
        !          1645:          if (p1 >= start)
        !          1646:            *p1 = (7 & c) + '0';
        !          1647:          p1++;
        !          1648:        }
        !          1649:     }
        !          1650: 
        !          1651:   if (c)
        !          1652:     {
        !          1653:       p1 = end;
        !          1654:       if (truncate) *p1++ = truncate;
        !          1655:     }
        !          1656: 
        !          1657:   line->length = max (line->length, p1 - (unsigned char *) line->body);
        !          1658:   line->body[line->length] = 0;
        !          1659:   return p1 - (unsigned char *) line->body;
        !          1660: }
        !          1661: 
        !          1662: syms_of_xdisp ()
        !          1663: {
        !          1664:   DefLispVar ("global-mode-string", &Vglobal_mode_string,
        !          1665:     "String which mode line can display (if its format requests to).");
        !          1666:   Vglobal_mode_string = Qnil;
        !          1667: 
        !          1668:   DefLispVar ("global-minor-modes", &Vglobal_minor_modes,
        !          1669:     "Alist of minor modes that are not per buffer.\n\
        !          1670: Cdr of each element is a string to display in mode line.");
        !          1671: 
        !          1672:   DefIntVar ("scroll-step", &scroll_step,
        !          1673:     "*The number of lines to try scrolling a window by when point moves out.\n\
        !          1674: If that fails to bring point back on screen, point is centered instead.\n\
        !          1675: If this is zero, point is always centered after it moves off screen.");
        !          1676: 
        !          1677:   DefIntVar ("debug-end-pos", &debug_end_pos, "Don't ask");
        !          1678: 
        !          1679:   DefBoolVar ("truncate-partial-width-windows",
        !          1680:             &truncate_partial_width_windows,
        !          1681:     "*Non-nil means truncate lines in all windows less than full screen wide.");
        !          1682:   truncate_partial_width_windows = 1;
        !          1683: 
        !          1684:   DefBoolVar ("mode-line-inverse-video", &mode_line_inverse_video,
        !          1685:     "*Non-nil means use inverse video, or other suitable display mode, for the mode line.");
        !          1686:   mode_line_inverse_video = 1;
        !          1687: 
        !          1688:   defsubr (&Sredraw_display);
        !          1689: }
        !          1690: 
        !          1691: /* initialize the window system */
        !          1692: init_xdisp ()
        !          1693: {
        !          1694:   Lisp_Object root_window;
        !          1695: #ifndef COMPILER_REGISTER_BUG
        !          1696:   register
        !          1697: #endif COMPILER_REGISTER_BUG
        !          1698:     struct window *mini_w;
        !          1699: 
        !          1700:   this_line_bufpos = 0;
        !          1701: 
        !          1702:   mini_w = XWINDOW (minibuf_window);
        !          1703:   root_window = mini_w->prev;
        !          1704: 
        !          1705:   minibuf_message = 0;
        !          1706:   prev_minibuf_message = 0;
        !          1707: 
        !          1708:   if (!noninteractive)
        !          1709:     {
        !          1710:       XFASTINT (XWINDOW (root_window)->top) = 0;
        !          1711:       set_window_height (root_window, screen_height - 1, 0);
        !          1712:       XFASTINT (mini_w->top) = screen_height - 1;
        !          1713:       set_window_height (minibuf_window, 1, 0);
        !          1714: 
        !          1715:       XFASTINT (XWINDOW (root_window)->width) = screen_width;
        !          1716:       XFASTINT (mini_w->width) = screen_width;
        !          1717:     }
        !          1718: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.